src/MyWebLog.Data/MyWebLog.Data.fsproj

@@ -4,6 +4,10 @@
 		<ProjectReference Include="..\MyWebLog.Domain\MyWebLog.Domain.fsproj" />
 	</ItemGroup>
 
+	<ItemGroup>
+		<ProjectReference Include="..\..\..\BitBadger.Sqlite.Documents\src\BitBadger.Sqlite.FSharp.Documents\BitBadger.Sqlite.FSharp.Documents.fsproj" />
+	</ItemGroup>
+	
 	<ItemGroup>
 		<PackageReference Include="BitBadger.Npgsql.FSharp.Documents" Version="2.0.0" />
 		<PackageReference Include="Microsoft.Data.Sqlite" Version="8.0.0" />

src/MyWebLog.Data/SQLiteData.fs

@@ -1,5 +1,7 @@
 namespace MyWebLog.Data
 
+open System.Threading.Tasks
+open BitBadger.Sqlite.FSharp.Documents
 open Microsoft.Data.Sqlite
 open Microsoft.Extensions.Logging
 open MyWebLog
@@ -12,25 +14,15 @@ type SQLiteData(conn: SqliteConnection, log: ILogger<SQLiteData>, ser: JsonSeria
     
     let ensureTables () = backgroundTask {
 
-        use cmd = conn.CreateCommand()
+        let! tables = Custom.list<string> "SELECT name FROM sqlite_master WHERE type = 'table'" None _.GetString(0)
-        
-        let! tables = backgroundTask {
-            cmd.CommandText <- "SELECT name FROM sqlite_master WHERE type = 'table'"
-            let! rdr = cmd.ExecuteReaderAsync()
-            let mutable tableList = []
-            while! rdr.ReadAsync() do
-                tableList <- Map.getString "name" rdr :: tableList
-            do! rdr.CloseAsync()
-            return tableList
-        }
         
         let needsTable table =
             not (List.contains table tables)
         
         let jsonTable table =
-            $"CREATE TABLE {table} (data TEXT NOT NULL);
+            $"{Definition.createTable table}; {Definition.createKey table}"
-              CREATE UNIQUE INDEX idx_{table}_key ON {table} ((data ->> 'Id'))"
         
+        let tasks =
             seq {
                 // Theme tables
                 if needsTable Table.Theme then jsonTable Table.Theme
@@ -63,7 +55,7 @@ type SQLiteData(conn: SqliteConnection, log: ILogger<SQLiteData>, ser: JsonSeria
                       CREATE INDEX idx_{Table.Page}_permalink
                         ON {Table.Page} ((data ->> 'WebLogId'), (data ->> 'Permalink'))"
                 if needsTable Table.PageRevision then
-                "CREATE TABLE page_revision (
+                    $"CREATE TABLE {Table.PageRevision} (
                         page_id        TEXT NOT NULL,
                         as_of          TEXT NOT NULL,
                         revision_text  TEXT NOT NULL,
@@ -109,11 +101,11 @@ type SQLiteData(conn: SqliteConnection, log: ILogger<SQLiteData>, ser: JsonSeria
                       INSERT INTO {Table.DbVersion} VALUES ('v2.1')"
             }
             |> Seq.map (fun sql ->
-            log.LogInformation $"Creating {(sql.Split ' ')[2]} table..."
+                log.LogInformation $"""Creating {(sql.Replace("IF NOT EXISTS ", "").Split ' ')[2]} table..."""
-            cmd.CommandText <- sql
+                Custom.nonQuery sql None)
-            write cmd |> Async.AwaitTask |> Async.RunSynchronously)
+        
-        |> List.ofSeq
+        let! _ = Task.WhenAll tasks
-        |> ignore
+        ()
     }
     
     /// Set the database version to the specified version
@@ -459,15 +451,6 @@ type SQLiteData(conn: SqliteConnection, log: ILogger<SQLiteData>, ser: JsonSeria
     /// The connection for this instance
     member _.Conn = conn
     
-    /// Make a SQLite connection ready to execute commends
-    static member setUpConnection (conn: SqliteConnection) = backgroundTask {
-        do! conn.OpenAsync()
-        use cmd = conn.CreateCommand()
-        cmd.CommandText <- "PRAGMA foreign_keys = TRUE"
-        let! _ = cmd.ExecuteNonQueryAsync()
-        ()
-    }
-    
     interface IData with
     
         member _.Category   = SQLiteCategoryData   (conn, ser, log)
@@ -484,10 +467,6 @@ type SQLiteData(conn: SqliteConnection, log: ILogger<SQLiteData>, ser: JsonSeria
         
         member _.StartUp () = backgroundTask {
             do! ensureTables ()
-            
+            let! version = Custom.single<string> $"SELECT id FROM {Table.DbVersion}" None _.GetString(0)
-            use cmd = conn.CreateCommand()
+            do! migrate version
-            cmd.CommandText <- $"SELECT id FROM {Table.DbVersion}"
-            use! rdr = cmd.ExecuteReaderAsync()
-            let! isFound = rdr.ReadAsync()
-            do! migrate (if isFound then Some (Map.getString "id" rdr) else None)
         }

src/MyWebLog/Program.fs

@@ -50,12 +50,17 @@ type RedirectRuleMiddleware(next: RequestDelegate, log: ILogger<RedirectRuleMidd
 
 
 open System
-open BitBadger.Npgsql.FSharp.Documents
 open Microsoft.Extensions.DependencyInjection
 open MyWebLog.Data
 open Newtonsoft.Json
 open Npgsql
 
+// The PostgreSQL document library
+module Postgres = BitBadger.Npgsql.FSharp.Documents
+
+// The SQLite document library
+module Sqlite = BitBadger.Sqlite.FSharp.Documents
+
 /// Logic to obtain a data connection and implementation based on configured values
 module DataImplementation =
     
@@ -68,7 +73,7 @@ module DataImplementation =
         let builder = NpgsqlDataSourceBuilder(cfg.GetConnectionString "PostgreSQL")
         let _ = builder.UseNodaTime()
         // let _ = builder.UseLoggerFactory(LoggerFactory.Create(fun it -> it.AddConsole () |> ignore))
-        (builder.Build >> Configuration.useDataSource) ()
+        (builder.Build >> Postgres.Configuration.useDataSource) ()
 
     /// Get the configured data implementation
     let get (sp: IServiceProvider) : IData =
@@ -77,10 +82,10 @@ module DataImplementation =
         let connStr    name = config.GetConnectionString name
         let hasConnStr name = (connStr >> isNull >> not) name
         let createSQLite connStr : IData =
+            Sqlite.Configuration.useConnectionString connStr
             let log  = sp.GetRequiredService<ILogger<SQLiteData>>()
             let conn = new SqliteConnection(connStr)
             log.LogInformation $"Using SQLite database {conn.DataSource}"
-            await (SQLiteData.setUpConnection conn)
             SQLiteData(conn, log, Json.configure (JsonSerializer.CreateDefault()))
         
         if hasConnStr "SQLite" then
@@ -93,7 +98,7 @@ module DataImplementation =
             RethinkDbData(conn, rethinkCfg, log)
         elif hasConnStr "PostgreSQL" then
             createNpgsqlDataSource config
-            use conn = Configuration.dataSource().CreateConnection()
+            use conn = Postgres.Configuration.dataSource().CreateConnection()
             let log  = sp.GetRequiredService<ILogger<PostgresData>>()
             log.LogInformation $"Using PostgreSQL database {conn.Database}"
             PostgresData(log, Json.configure (JsonSerializer.CreateDefault()))
@@ -170,13 +175,13 @@ let main args =
                 opts.TableName  <- "Session"
                 opts.Connection <- rethink.Conn)
         ()
-    | :? SQLiteData as sql ->
+    | :? SQLiteData ->
         // ADO.NET connections are designed to work as per-request instantiation
         let cfg  = sp.GetRequiredService<IConfiguration>()
         let _ =
             builder.Services.AddScoped<SqliteConnection>(fun sp ->
-                let conn = new SqliteConnection(sql.Conn.ConnectionString)
+                let conn = Sqlite.Configuration.dbConn ()
-                SQLiteData.setUpConnection conn |> Async.AwaitTask |> Async.RunSynchronously
+                conn.OpenAsync() |> Async.AwaitTask |> Async.RunSynchronously
                 conn)
         let _ = builder.Services.AddScoped<IData, SQLiteData>()
         // Use SQLite for caching as well
@@ -185,7 +190,7 @@ let main args =
         ()
     | :? PostgresData as postgres ->
         // ADO.NET Data Sources are designed to work as singletons
-        let _ = builder.Services.AddSingleton<NpgsqlDataSource>(Configuration.dataSource ())
+        let _ = builder.Services.AddSingleton<NpgsqlDataSource>(Postgres.Configuration.dataSource ())
         let _ = builder.Services.AddSingleton<IData> postgres
         let _ =
             builder.Services.AddSingleton<IDistributedCache>(fun _ ->