WIP on OpenGraph form; first cut done (#52)

- Removed SecureUrl prop; will generate if URL starts with https:

.config/dotnet-tools.json

@@ -1,12 +0,0 @@
-{
-  "version": 1,
-  "isRoot": true,
-  "tools": {
-    "fake-cli": {
-      "version": "5.22.0",
-      "commands": [
-        "fake"
-      ]
-    }
-  }
-}

.github/workflows/ci.yml

@@ -0,0 +1,99 @@
+name: Continuous Integration
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+env:
+  MWL_TEST_RETHINK_URI: rethinkdb://localhost/mwl_test
+jobs:
+  build_and_test:
+    name: Build / Test
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        dotnet-version:
+          - "6.0"
+          - "7.0"
+          - "8.0"
+
+    services:
+      postgres:
+        image: postgres:latest
+        env:
+          POSTGRES_PASSWORD: postgres
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+      rethink:
+        image: rethinkdb:latest
+        ports:
+          - 28015:28015
+    
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+      - name: Setup .NET Core SDK
+        uses: actions/setup-dotnet@v4.0.0
+        with:
+          dotnet-version: 8.x
+      - name: Restore dependencies
+        run: dotnet restore src/MyWebLog.sln
+      - name: Build (${{ matrix.dotnet-version }})
+        run: dotnet build src/MyWebLog.sln -f net${{ matrix.dotnet-version }}
+      - name: Test (${{ matrix.dotnet-version }})
+        run: cd src/MyWebLog.Tests; dotnet run -f net${{ matrix.dotnet-version }}
+
+  publish:
+    name: Publish Packages
+    runs-on: ubuntu-latest
+    needs: build_and_test
+    
+    strategy:
+      matrix:
+        ver:
+          - "net6.0"
+          - "net7.0"
+          - "net8.0"
+        os:
+          - "linux-x64"
+          - "win-x64"
+        include:
+          - os: "linux-x64"
+            bz2: true
+          - os: "win-x64"
+            zip: true
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+      - name: Setup .NET Core SDK
+        uses: actions/setup-dotnet@v4.0.0
+        with:
+          dotnet-version: 8.x
+      - name: Publish (Release)
+        run: dotnet publish -c Release -f ${{ matrix.ver }} -r ${{ matrix.os }} src/MyWebLog/MyWebLog.fsproj
+      - name: Zip Admin Theme
+        run: cd src/admin-theme; zip -r ../MyWebLog/bin/Release/${{ matrix.ver }}/${{ matrix.os }}/publish/admin-theme.zip *; cd ../..
+      - name: Zip Default Theme
+        run: cd src/default-theme; zip -r ../MyWebLog/bin/Release/${{ matrix.ver }}/${{ matrix.os }}/publish/default-theme.zip *; cd ../..
+      - if: ${{ matrix.bz2 }}
+        name: Create .tar.bz2 Archive
+        run: tar cfj myWebLog-${{ matrix.ver }}-${{ matrix.os }}.tar.bz2 -C src/MyWebLog/bin/Release/${{ matrix.ver }}/${{ matrix.os }}/publish .
+      - if: ${{ matrix.zip }}
+        name: Create .zip Archive
+        run: cd src/MyWebLog/bin/Release/${{ matrix.ver }}/${{ matrix.os }}/publish; zip -r myWebLog-${{ matrix.ver }}-${{ matrix.os }}.zip *; cp myWeb*.zip ../../../../../../..; cd ../../../../../../..
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: package-${{ matrix.ver }}-${{ matrix.os }}
+          path: |
+            *x64.zip
+            *.bz2

.gitignore

@@ -261,7 +261,8 @@ src/MyWebLog/wwwroot/img/daniel-j-summers
 src/MyWebLog/wwwroot/img/bit-badger
 
 .ionide
+.vscode
 src/MyWebLog/appsettings.Production.json
 
 # SQLite database files
-src/MyWebLog/*.db*
+src/MyWebLog/data/*.db*

build.fs

@@ -0,0 +1,166 @@
+open System.IO
+open Fake.Core
+open Fake.DotNet
+open Fake.IO
+open Fake.IO.Globbing.Operators
+
+let execContext = Context.FakeExecutionContext.Create false "build.fsx" []
+Context.setExecutionContext (Context.RuntimeContext.Fake execContext)
+
+/// The output directory for release ZIPs
+let releasePath = "releases"
+
+/// The path to the main project
+let projectPath = "src/MyWebLog"
+
+/// The path and name of the main project
+let projName = $"{projectPath}/MyWebLog.fsproj"
+
+/// The version being packaged (extracted from appsettings.json)
+let version =
+    let settings   = File.ReadAllText $"{projectPath}/appsettings.json"
+    let generator  = settings.Substring (settings.IndexOf "\"Generator\":")
+    let appVersion = generator.Replace("\"Generator\": \"", "")
+    let appVersion = appVersion.Substring (0, appVersion.IndexOf "\"")
+    appVersion.Split ' ' |> Array.last
+
+/// Zip a theme distributed with myWebLog
+let zipTheme (name : string) (_ : TargetParameter) =
+    let path = $"src/{name}-theme"
+    !! $"{path}/**/*"
+    |> Zip.filesAsSpecs path
+    |> Seq.filter (fun (_, name) -> not (name.EndsWith ".zip"))
+    |> Zip.zipSpec $"{releasePath}/{name}-theme.zip"
+
+/// Frameworks supported by this build
+let frameworks = [ "net8.0"; "net9.0" ]
+
+/// Publish the project for the given runtime ID
+let publishFor rid (_ : TargetParameter) =
+    frameworks
+    |> List.iter (fun fwk ->
+        DotNet.publish
+            (fun opts ->
+                { opts with Runtime = Some rid; SelfContained = Some false; NoLogo = true; Framework = Some fwk })
+            projName)
+
+/// Package published output for the given runtime ID
+let packageFor rid (_ : TargetParameter) =
+    frameworks
+    |> List.iter (fun fwk ->
+        let path = $"{projectPath}/bin/Release/{fwk}/%s{rid}/publish"
+        let prodSettings = $"{path}/appsettings.Production.json"
+        if File.exists prodSettings then File.delete prodSettings
+        [   !! $"{path}/**/*"
+            |> Zip.filesAsSpecs path
+            |> Seq.map (fun (orig, dest) ->
+                orig, if dest.StartsWith "MyWebLog" then dest.Replace ("MyWebLog", "myWebLog") else dest)
+            Seq.singleton ($"{releasePath}/admin-theme.zip", "admin-theme.zip")
+            Seq.singleton ($"{releasePath}/default-theme.zip", "default-theme.zip")
+        ]
+        |> Seq.concat
+        |> Zip.zipSpec $"{releasePath}/myWebLog-{version}.{fwk}.{rid}.zip")
+
+
+Target.create "Clean" (fun _ ->
+    !! "src/**/bin"
+    ++ "src/**/obj"
+    |> Shell.cleanDirs
+    Shell.cleanDir releasePath
+)
+
+Target.create "Build" (fun _ ->
+    DotNet.build (fun opts -> { opts with NoLogo = true }) projName
+)
+
+Target.create "ZipAdminTheme"   (zipTheme "admin")
+Target.create "ZipDefaultTheme" (zipTheme "default")
+
+Target.create "PublishWindows" (publishFor "win-x64")
+Target.create "PackageWindows" (packageFor "win-x64")
+
+Target.create "PublishLinux" (publishFor "linux-x64")
+Target.create "PackageLinux" (packageFor "linux-x64")
+
+Target.create "RepackageLinux" (fun _ ->
+    let workDir = $"{releasePath}/linux"
+    frameworks
+    |> List.iter (fun fwk ->
+        let zipArchive = $"{releasePath}/myWebLog-{version}.{fwk}.linux-x64.zip"
+        let sh command args =
+            CreateProcess.fromRawCommand command args
+            |> CreateProcess.redirectOutput
+            |> Proc.run
+            |> ignore
+        Shell.mkdir workDir
+        Zip.unzip workDir zipArchive
+        Shell.cd workDir
+        sh "chmod" [ "+x"; "./myWebLog" ]
+        sh "tar" [ "cfj"; $"../myWebLog-{version}.{fwk}.linux-x64.tar.bz2"; "." ]
+        Shell.cd "../.."
+        Shell.rm zipArchive)
+    Shell.rm_rf workDir
+)
+
+Target.create "All" ignore
+
+Target.create "RemoveThemeArchives" (fun _ ->
+    Shell.rm $"{releasePath}/admin-theme.zip"
+    Shell.rm $"{releasePath}/default-theme.zip"
+)
+
+Target.create "CI" ignore
+
+open Fake.Core.TargetOperators
+
+let dependencies = [
+    "Clean"
+      ==> "All"
+
+    "Clean"
+      ?=> "Build"
+      ==> "All"
+
+    "Clean"
+      ?=> "ZipDefaultTheme"
+      ==> "All"
+
+    "Clean"
+      ?=> "ZipAdminTheme"
+      ==> "All"
+
+    "Build"
+      ==> "PublishWindows"
+      ==> "All"
+
+    "Build"
+      ==> "PublishLinux"
+      ==> "All"
+
+    "PublishWindows"
+      ==> "PackageWindows"
+      ==> "All"
+
+    "PublishLinux"
+      ==> "PackageLinux"
+      ==> "All"
+
+    "PackageLinux"
+      ==> "RepackageLinux"
+      ==> "All"
+
+    "All"
+      ==> "RemoveThemeArchives"
+      ==> "CI"
+]
+
+[<EntryPoint>]
+let main args =
+    try
+        match args with
+        | [| target |] -> Target.runOrDefault target
+        | _ -> Target.runOrDefault "All"
+        0
+    with e ->
+        printfn "%A" e
+        1

build.fsproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="build.fs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Fake.Core.Target" Version="6.0.0" />
+    <PackageReference Include="Fake.DotNet.Cli" Version="6.0.0" />
+    <PackageReference Include="Fake.IO.FileSystem" Version="6.0.0" />
+    <PackageReference Include="Fake.IO.Zip" Version="6.0.0" />
+    <PackageReference Include="MSBuild.StructuredLogger" Version="2.2.206" />
+  </ItemGroup>
+
+</Project>

build.fsx

@@ -1,147 +0,0 @@
-#r "paket:
-nuget Fake.DotNet.Cli
-nuget Fake.IO.FileSystem
-nuget Fake.IO.Zip
-nuget Fake.Core.Target //"
-#load ".fake/build.fsx/intellisense.fsx"
-open System.IO
-open Fake.Core
-open Fake.DotNet
-open Fake.IO
-open Fake.IO.Globbing.Operators
-open Fake.Core.TargetOperators
-
-Target.initEnvironment ()
-
-/// The output directory for release ZIPs
-let releasePath = "releases"
-
-/// The path to the main project
-let projectPath = "src/MyWebLog"
-
-/// The path and name of the main project
-let projName = $"{projectPath}/MyWebLog.fsproj"
-
-/// The version being packaged (extracted from appsettings.json)
-let version =
-    let settings   = File.ReadAllText $"{projectPath}/appsettings.json"
-    let generator  = settings.Substring (settings.IndexOf "\"Generator\":")
-    let appVersion = generator.Replace("\"Generator\": \"", "")
-    let appVersion = appVersion.Substring (0, appVersion.IndexOf "\"")
-    appVersion.Split ' ' |> Array.last
-    
-/// Zip a theme distributed with myWebLog
-let zipTheme (name : string) (_ : TargetParameter) =
-    let path = $"src/{name}-theme"
-    !! $"{path}/**/*"
-    |> Zip.filesAsSpecs path
-    |> Seq.filter (fun (_, name) -> not (name.EndsWith ".zip"))
-    |> Zip.zipSpec $"{releasePath}/{name}-theme.zip"
-
-/// Publish the project for the given runtime ID    
-let publishFor rid (_ : TargetParameter) =
-    DotNet.publish (fun opts -> { opts with Runtime = Some rid; SelfContained = Some false; NoLogo = true }) projName
-
-/// Package published output for the given runtime ID
-let packageFor (rid : string) (_ : TargetParameter) =
-    let path = $"{projectPath}/bin/Release/net6.0/{rid}/publish"
-    let prodSettings = $"{path}/appsettings.Production.json"
-    if File.exists prodSettings then File.delete prodSettings
-    [ !! $"{path}/**/*"
-        |> Zip.filesAsSpecs path
-        |> Seq.map (fun (orig, dest) ->
-            orig, if dest.StartsWith "MyWebLog" then dest.Replace ("MyWebLog", "myWebLog") else dest)
-      Seq.singleton ($"{releasePath}/admin-theme.zip", "admin-theme.zip")
-      Seq.singleton ($"{releasePath}/default-theme.zip", "default-theme.zip")
-    ]
-    |> Seq.concat
-    |> Zip.zipSpec $"{releasePath}/myWebLog-{version}.{rid}.zip"
-
-
-Target.create "Clean" (fun _ ->
-    !! "src/**/bin"
-    ++ "src/**/obj"
-    |> Shell.cleanDirs 
-    Shell.cleanDir releasePath
-)
-
-Target.create "Build" (fun _ ->
-    DotNet.build (fun opts -> { opts with NoLogo = true }) projName
-)
-
-Target.create "ZipAdminTheme"   (zipTheme "admin")
-Target.create "ZipDefaultTheme" (zipTheme "default")
-
-Target.create "PublishWindows" (publishFor "win-x64")
-Target.create "PackageWindows" (packageFor "win-x64")
-
-Target.create "PublishLinux" (publishFor "linux-x64")
-Target.create "PackageLinux" (packageFor "linux-x64")
-
-Target.create "RepackageLinux" (fun _ ->
-    let workDir = $"{releasePath}/linux"
-    let zipArchive = $"{releasePath}/myWebLog-{version}.linux-x64.zip"
-    let sh command args = 
-        CreateProcess.fromRawCommand command args
-        |> CreateProcess.redirectOutput
-        |> Proc.run
-        |> ignore
-    Shell.mkdir workDir
-    Zip.unzip workDir zipArchive
-    Shell.cd workDir
-    sh "chmod" [ "+x"; "./myWebLog" ]
-    sh "tar" [ "cfj"; $"../myWebLog-{version}.linux-x64.tar.bz2"; "." ]
-    Shell.cd "../.."
-    Shell.rm zipArchive
-    Shell.rm_rf workDir
-)
-
-Target.create "All" ignore
-
-Target.create "RemoveThemeArchives" (fun _ ->
-    Shell.rm $"{releasePath}/admin-theme.zip"
-    Shell.rm $"{releasePath}/default-theme.zip"
-)
-
-Target.create "CI" ignore
-
-"Clean"
-  ==> "All"
-
-"Clean"
-  ?=> "Build"
-  ==> "All"
-
-"Clean"
-  ?=> "ZipDefaultTheme"
-  ==> "All"
-
-"Clean"
-  ?=> "ZipAdminTheme"
-  ==> "All"
-
-"Build"
-  ==> "PublishWindows"
-  ==> "All"
-
-"Build"
-  ==> "PublishLinux"
-  ==> "All"
-
-"PublishWindows"
-  ==> "PackageWindows"
-  ==> "All"
-
-"PublishLinux"
-  ==> "PackageLinux"
-  ==> "All"
-
-"PackageLinux"
-  ==> "RepackageLinux"
-  ==> "All"
-
-"All"
-  ==> "RemoveThemeArchives"
-  ==> "CI"
-
-Target.runOrDefault "All"

build.fsx.lock

@@ -1,227 +0,0 @@
-STORAGE: NONE
-RESTRICTION: || (== net6.0) (== netstandard2.0)
-NUGET
-  remote: https://api.nuget.org/v3/index.json
-    BlackFox.VsWhere (1.1)
-      FSharp.Core (>= 4.2.3)
-      Microsoft.Win32.Registry (>= 4.7)
-    Fake.Core.CommandLineParsing (5.22)
-      FParsec (>= 1.1.1)
-      FSharp.Core (>= 6.0)
-    Fake.Core.Context (5.22)
-      FSharp.Core (>= 6.0)
-    Fake.Core.Environment (5.22)
-      FSharp.Core (>= 6.0)
-    Fake.Core.FakeVar (5.22)
-      Fake.Core.Context (>= 5.22)
-      FSharp.Core (>= 6.0)
-    Fake.Core.Process (5.22)
-      Fake.Core.Environment (>= 5.22)
-      Fake.Core.FakeVar (>= 5.22)
-      Fake.Core.String (>= 5.22)
-      Fake.Core.Trace (>= 5.22)
-      Fake.IO.FileSystem (>= 5.22)
-      FSharp.Core (>= 6.0)
-      System.Collections.Immutable (>= 5.0)
-    Fake.Core.SemVer (5.22)
-      FSharp.Core (>= 6.0)
-    Fake.Core.String (5.22)
-      FSharp.Core (>= 6.0)
-    Fake.Core.Target (5.22)
-      Fake.Core.CommandLineParsing (>= 5.22)
-      Fake.Core.Context (>= 5.22)
-      Fake.Core.Environment (>= 5.22)
-      Fake.Core.FakeVar (>= 5.22)
-      Fake.Core.Process (>= 5.22)
-      Fake.Core.String (>= 5.22)
-      Fake.Core.Trace (>= 5.22)
-      FSharp.Control.Reactive (>= 5.0.2)
-      FSharp.Core (>= 6.0)
-    Fake.Core.Tasks (5.22)
-      Fake.Core.Trace (>= 5.22)
-      FSharp.Core (>= 6.0)
-    Fake.Core.Trace (5.22)
-      Fake.Core.Environment (>= 5.22)
-      Fake.Core.FakeVar (>= 5.22)
-      FSharp.Core (>= 6.0)
-    Fake.Core.Xml (5.22)
-      Fake.Core.String (>= 5.22)
-      FSharp.Core (>= 6.0)
-    Fake.DotNet.Cli (5.22)
-      Fake.Core.Environment (>= 5.22)
-      Fake.Core.Process (>= 5.22)
-      Fake.Core.String (>= 5.22)
-      Fake.Core.Trace (>= 5.22)
-      Fake.DotNet.MSBuild (>= 5.22)
-      Fake.DotNet.NuGet (>= 5.22)
-      Fake.IO.FileSystem (>= 5.22)
-      FSharp.Core (>= 6.0)
-      Mono.Posix.NETStandard (>= 1.0)
-      Newtonsoft.Json (>= 13.0.1)
-    Fake.DotNet.MSBuild (5.22)
-      BlackFox.VsWhere (>= 1.1)
-      Fake.Core.Environment (>= 5.22)
-      Fake.Core.Process (>= 5.22)
-      Fake.Core.String (>= 5.22)
-      Fake.Core.Trace (>= 5.22)
-      Fake.IO.FileSystem (>= 5.22)
-      FSharp.Core (>= 6.0)
-      MSBuild.StructuredLogger (>= 2.1.545)
-    Fake.DotNet.NuGet (5.22)
-      Fake.Core.Environment (>= 5.22)
-      Fake.Core.Process (>= 5.22)
-      Fake.Core.SemVer (>= 5.22)
-      Fake.Core.String (>= 5.22)
-      Fake.Core.Tasks (>= 5.22)
-      Fake.Core.Trace (>= 5.22)
-      Fake.Core.Xml (>= 5.22)
-      Fake.IO.FileSystem (>= 5.22)
-      Fake.Net.Http (>= 5.22)
-      FSharp.Core (>= 6.0)
-      Newtonsoft.Json (>= 13.0.1)
-      NuGet.Protocol (>= 5.11)
-    Fake.IO.FileSystem (5.22)
-      Fake.Core.String (>= 5.22)
-      FSharp.Core (>= 6.0)
-    Fake.IO.Zip (5.22)
-      Fake.Core.String (>= 5.22)
-      Fake.IO.FileSystem (>= 5.22)
-      FSharp.Core (>= 6.0)
-    Fake.Net.Http (5.22)
-      Fake.Core.Trace (>= 5.22)
-      FSharp.Core (>= 6.0)
-    FParsec (1.1.1)
-      FSharp.Core (>= 4.3.4)
-    FSharp.Control.Reactive (5.0.5)
-      FSharp.Core (>= 4.7.2)
-      System.Reactive (>= 5.0 < 6.0)
-    FSharp.Core (6.0.5)
-    Microsoft.Build (17.2)
-      Microsoft.Build.Framework (>= 17.2) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net472)) (&& (== netstandard2.0) (>= net6.0))
-      Microsoft.NET.StringTools (>= 1.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net472)) (&& (== netstandard2.0) (>= net6.0))
-      Microsoft.Win32.Registry (>= 4.3) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net6.0))
-      System.Collections.Immutable (>= 5.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net472)) (&& (== netstandard2.0) (>= net6.0))
-      System.Configuration.ConfigurationManager (>= 4.7) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net472)) (&& (== netstandard2.0) (>= net6.0))
-      System.Reflection.Metadata (>= 1.6) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net6.0))
-      System.Security.Principal.Windows (>= 4.7) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net6.0))
-      System.Text.Encoding.CodePages (>= 4.0.1) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net6.0))
-      System.Text.Json (>= 6.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net472)) (&& (== netstandard2.0) (>= net6.0))
-      System.Threading.Tasks.Dataflow (>= 6.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net472)) (&& (== netstandard2.0) (>= net6.0))
-    Microsoft.Build.Framework (17.2)
-      Microsoft.Win32.Registry (>= 4.3)
-      System.Security.Permissions (>= 4.7)
-    Microsoft.Build.Tasks.Core (17.2)
-      Microsoft.Build.Framework (>= 17.2)
-      Microsoft.Build.Utilities.Core (>= 17.2)
-      Microsoft.NET.StringTools (>= 1.0)
-      Microsoft.Win32.Registry (>= 4.3)
-      System.CodeDom (>= 4.4)
-      System.Collections.Immutable (>= 5.0)
-      System.Reflection.Metadata (>= 1.6)
-      System.Resources.Extensions (>= 4.6)
-      System.Security.Cryptography.Pkcs (>= 4.7)
-      System.Security.Cryptography.Xml (>= 4.7)
-      System.Security.Permissions (>= 4.7)
-      System.Threading.Tasks.Dataflow (>= 6.0)
-    Microsoft.Build.Utilities.Core (17.2)
-      Microsoft.Build.Framework (>= 17.2)
-      Microsoft.NET.StringTools (>= 1.0)
-      Microsoft.Win32.Registry (>= 4.3)
-      System.Collections.Immutable (>= 5.0)
-      System.Configuration.ConfigurationManager (>= 4.7)
-      System.Security.Permissions (>= 4.7) - restriction: == netstandard2.0
-      System.Text.Encoding.CodePages (>= 4.0.1) - restriction: == netstandard2.0
-    Microsoft.NET.StringTools (1.0)
-      System.Memory (>= 4.5.4)
-      System.Runtime.CompilerServices.Unsafe (>= 5.0)
-    Microsoft.NETCore.Platforms (6.0.4) - restriction: || (&& (== net6.0) (< netcoreapp3.1)) (&& (== net6.0) (< netstandard1.2)) (&& (== net6.0) (< netstandard1.3)) (&& (== net6.0) (< netstandard1.5)) (== netstandard2.0)
-    Microsoft.NETCore.Targets (5.0) - restriction: || (&& (== net6.0) (< netcoreapp3.1)) (&& (== net6.0) (< netstandard1.2)) (&& (== net6.0) (< netstandard1.3)) (&& (== net6.0) (< netstandard1.5)) (== netstandard2.0)
-    Microsoft.Win32.Registry (5.0)
-      System.Buffers (>= 4.5.1) - restriction: || (&& (== net6.0) (>= monoandroid) (< netstandard1.3)) (&& (== net6.0) (>= monotouch)) (&& (== net6.0) (< netcoreapp2.0)) (&& (== net6.0) (>= xamarinios)) (&& (== net6.0) (>= xamarinmac)) (&& (== net6.0) (>= xamarintvos)) (&& (== net6.0) (>= xamarinwatchos)) (== netstandard2.0)
-      System.Memory (>= 4.5.4) - restriction: || (&& (== net6.0) (< netcoreapp2.0)) (&& (== net6.0) (< netcoreapp2.1)) (&& (== net6.0) (>= uap10.1)) (== netstandard2.0)
-      System.Security.AccessControl (>= 5.0)
-      System.Security.Principal.Windows (>= 5.0)
-    Microsoft.Win32.SystemEvents (6.0.1) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= netcoreapp3.1))
-    Mono.Posix.NETStandard (1.0)
-    MSBuild.StructuredLogger (2.1.669)
-      Microsoft.Build (>= 16.10)
-      Microsoft.Build.Framework (>= 16.10)
-      Microsoft.Build.Tasks.Core (>= 16.10)
-      Microsoft.Build.Utilities.Core (>= 16.10)
-    Newtonsoft.Json (13.0.1)
-    NuGet.Common (6.2.1)
-      NuGet.Frameworks (>= 6.2.1)
-    NuGet.Configuration (6.2.1)
-      NuGet.Common (>= 6.2.1)
-      System.Security.Cryptography.ProtectedData (>= 4.4)
-    NuGet.Frameworks (6.2.1)
-    NuGet.Packaging (6.2.1)
-      Newtonsoft.Json (>= 13.0.1)
-      NuGet.Configuration (>= 6.2.1)
-      NuGet.Versioning (>= 6.2.1)
-      System.Security.Cryptography.Cng (>= 5.0)
-      System.Security.Cryptography.Pkcs (>= 5.0)
-    NuGet.Protocol (6.2.1)
-      NuGet.Packaging (>= 6.2.1)
-    NuGet.Versioning (6.2.1)
-    System.Buffers (4.5.1) - restriction: || (&& (== net6.0) (>= monoandroid) (< netstandard1.3)) (&& (== net6.0) (>= monotouch)) (&& (== net6.0) (< netcoreapp2.0)) (&& (== net6.0) (>= xamarinios)) (&& (== net6.0) (>= xamarinmac)) (&& (== net6.0) (>= xamarintvos)) (&& (== net6.0) (>= xamarinwatchos)) (== netstandard2.0)
-    System.CodeDom (6.0)
-    System.Collections.Immutable (6.0)
-      System.Memory (>= 4.5.4) - restriction: || (&& (== net6.0) (>= net461)) (== netstandard2.0)
-      System.Runtime.CompilerServices.Unsafe (>= 6.0)
-    System.Configuration.ConfigurationManager (6.0)
-      System.Security.Cryptography.ProtectedData (>= 6.0)
-      System.Security.Permissions (>= 6.0)
-    System.Drawing.Common (6.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= netcoreapp3.1))
-      Microsoft.Win32.SystemEvents (>= 6.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= netcoreapp3.1))
-    System.Formats.Asn1 (6.0)
-      System.Buffers (>= 4.5.1) - restriction: || (&& (== net6.0) (>= net461)) (== netstandard2.0)
-      System.Memory (>= 4.5.4) - restriction: || (&& (== net6.0) (>= net461)) (== netstandard2.0)
-    System.Memory (4.5.5)
-      System.Buffers (>= 4.5.1) - restriction: || (&& (== net6.0) (>= monotouch)) (&& (== net6.0) (>= net461)) (&& (== net6.0) (< netcoreapp2.0)) (&& (== net6.0) (< netstandard1.1)) (&& (== net6.0) (< netstandard2.0)) (&& (== net6.0) (>= xamarinios)) (&& (== net6.0) (>= xamarinmac)) (&& (== net6.0) (>= xamarintvos)) (&& (== net6.0) (>= xamarinwatchos)) (== netstandard2.0)
-      System.Numerics.Vectors (>= 4.4) - restriction: || (&& (== net6.0) (< netcoreapp2.0)) (== netstandard2.0)
-      System.Runtime.CompilerServices.Unsafe (>= 4.5.3) - restriction: || (&& (== net6.0) (>= monotouch)) (&& (== net6.0) (>= net461)) (&& (== net6.0) (< netcoreapp2.0)) (&& (== net6.0) (< netcoreapp2.1)) (&& (== net6.0) (< netstandard1.1)) (&& (== net6.0) (< netstandard2.0)) (&& (== net6.0) (>= uap10.1)) (&& (== net6.0) (>= xamarinios)) (&& (== net6.0) (>= xamarinmac)) (&& (== net6.0) (>= xamarintvos)) (&& (== net6.0) (>= xamarinwatchos)) (== netstandard2.0)
-    System.Numerics.Vectors (4.5) - restriction: || (&& (== net6.0) (>= net461)) (== netstandard2.0)
-    System.Reactive (5.0)
-      System.Runtime.InteropServices.WindowsRuntime (>= 4.3) - restriction: || (&& (== net6.0) (< netcoreapp3.1)) (== netstandard2.0)
-      System.Threading.Tasks.Extensions (>= 4.5.4) - restriction: || (&& (== net6.0) (>= net472)) (&& (== net6.0) (< netcoreapp3.1)) (&& (== net6.0) (>= uap10.1)) (== netstandard2.0)
-    System.Reflection.Metadata (6.0.1)
-      System.Collections.Immutable (>= 6.0)
-    System.Resources.Extensions (6.0)
-      System.Memory (>= 4.5.4) - restriction: || (&& (== net6.0) (>= net461)) (== netstandard2.0)
-    System.Runtime (4.3.1) - restriction: || (&& (== net6.0) (< netcoreapp3.1)) (== netstandard2.0)
-      Microsoft.NETCore.Platforms (>= 1.1.1)
-      Microsoft.NETCore.Targets (>= 1.1.3)
-    System.Runtime.CompilerServices.Unsafe (6.0)
-    System.Runtime.InteropServices.WindowsRuntime (4.3) - restriction: || (&& (== net6.0) (< netcoreapp3.1)) (== netstandard2.0)
-      System.Runtime (>= 4.3)
-    System.Security.AccessControl (6.0)
-      System.Security.Principal.Windows (>= 5.0) - restriction: || (&& (== net6.0) (>= net461)) (== netstandard2.0)
-    System.Security.Cryptography.Cng (5.0)
-      System.Formats.Asn1 (>= 5.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= netcoreapp3.0))
-    System.Security.Cryptography.Pkcs (6.0.1)
-      System.Buffers (>= 4.5.1) - restriction: || (&& (== net6.0) (< netstandard2.1)) (== netstandard2.0)
-      System.Formats.Asn1 (>= 6.0)
-      System.Memory (>= 4.5.4) - restriction: || (&& (== net6.0) (< netstandard2.1)) (== netstandard2.0)
-      System.Security.Cryptography.Cng (>= 5.0) - restriction: || (&& (== net6.0) (< netcoreapp3.1)) (&& (== net6.0) (< netstandard2.1)) (== netstandard2.0)
-    System.Security.Cryptography.ProtectedData (6.0)
-    System.Security.Cryptography.Xml (6.0)
-      System.Memory (>= 4.5.4) - restriction: == netstandard2.0
-      System.Security.AccessControl (>= 6.0)
-      System.Security.Cryptography.Pkcs (>= 6.0)
-    System.Security.Permissions (6.0)
-      System.Security.AccessControl (>= 6.0)
-      System.Windows.Extensions (>= 6.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= netcoreapp3.1))
-    System.Security.Principal.Windows (5.0)
-    System.Text.Encoding.CodePages (6.0)
-      System.Runtime.CompilerServices.Unsafe (>= 6.0)
-    System.Text.Encodings.Web (6.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net472)) (&& (== netstandard2.0) (>= net6.0))
-      System.Runtime.CompilerServices.Unsafe (>= 6.0)
-    System.Text.Json (6.0.5) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= net472)) (&& (== netstandard2.0) (>= net6.0))
-      System.Runtime.CompilerServices.Unsafe (>= 6.0)
-      System.Text.Encodings.Web (>= 6.0)
-    System.Threading.Tasks.Dataflow (6.0)
-    System.Threading.Tasks.Extensions (4.5.4) - restriction: || (&& (== net6.0) (>= net472)) (&& (== net6.0) (< netcoreapp3.1)) (&& (== net6.0) (>= uap10.1)) (== netstandard2.0)
-      System.Runtime.CompilerServices.Unsafe (>= 4.5.3) - restriction: || (&& (== net6.0) (>= net461)) (&& (== net6.0) (< netcoreapp2.1)) (&& (== net6.0) (< netstandard1.0)) (&& (== net6.0) (< netstandard2.0)) (&& (== net6.0) (>= wp8)) (== netstandard2.0)
-    System.Windows.Extensions (6.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= netcoreapp3.1))
-      System.Drawing.Common (>= 6.0) - restriction: || (== net6.0) (&& (== netstandard2.0) (>= netcoreapp3.1))

fake.cmd

@@ -1,2 +0,0 @@
-dotnet tool restore
-dotnet fake %*

fake.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-set -o pipefail
-
-dotnet tool restore
-dotnet fake "$@"

src/.dockerignore

@@ -0,0 +1,4 @@
+**/bin
+**/obj
+**/*.db
+**/appsettings.*.json

src/Directory.Build.props

@@ -1,10 +1,11 @@
 <Project>
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
     <DebugType>embedded</DebugType>
-    <AssemblyVersion>2.0.0.0</AssemblyVersion>
-    <FileVersion>2.0.0.0</FileVersion>
-    <Version>2.0.0</Version>
-    <VersionSuffix>rc2</VersionSuffix>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <AssemblyVersion>3.0.0.0</AssemblyVersion>
+    <FileVersion>3.0.0.0</FileVersion>
+    <Version>3.0.0</Version>
+    <VersionSuffix>beta1</VersionSuffix>
   </PropertyGroup>
 </Project>

src/Dockerfile

@@ -0,0 +1,33 @@
+FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine AS build
+WORKDIR /mwl
+COPY ./MyWebLog.sln                            ./
+COPY ./Directory.Build.props                   ./
+COPY ./MyWebLog/MyWebLog.fsproj                ./MyWebLog/
+COPY ./MyWebLog.Data/MyWebLog.Data.fsproj      ./MyWebLog.Data/
+COPY ./MyWebLog.Domain/MyWebLog.Domain.fsproj  ./MyWebLog.Domain/
+COPY ./MyWebLog.Tests/MyWebLog.Tests.fsproj    ./MyWebLog.Tests/
+RUN dotnet restore
+
+COPY . ./
+WORKDIR /mwl/MyWebLog
+RUN dotnet publish -f net8.0 -c Release -r linux-x64 --no-self-contained -p:PublishSingleFile=false
+
+FROM alpine AS theme
+RUN apk add --no-cache zip
+WORKDIR /themes/default-theme
+COPY ./default-theme ./
+RUN zip -r ../default-theme.zip ./*
+WORKDIR /themes/admin-theme
+COPY ./admin-theme ./
+RUN zip -r ../admin-theme.zip ./*
+
+FROM  mcr.microsoft.com/dotnet/aspnet:8.0-alpine as final
+WORKDIR /app
+RUN apk add --no-cache icu-libs
+ENV DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=false
+COPY --from=build /mwl/MyWebLog/bin/Release/net8.0/linux-x64/publish/ ./
+COPY --from=theme /themes/*.zip /app/
+RUN mkdir themes
+
+EXPOSE 80
+CMD [ "dotnet", "/app/MyWebLog.dll" ]

src/MyWebLog.Data/Converters.fs

@@ -1,163 +1,199 @@
-/// Converters for discriminated union types
+/// <summary>Converters for discriminated union types</summary>
 module MyWebLog.Converters
 
 open MyWebLog
 open System
 
-/// JSON.NET converters for discriminated union types
+/// <summary>JSON.NET converters for discriminated union types</summary>
 module Json =
-    
+
     open Newtonsoft.Json
-    
-    type CategoryIdConverter () =
-        inherit JsonConverter<CategoryId> ()
-        override _.WriteJson (writer : JsonWriter, value : CategoryId, _ : JsonSerializer) =
-            writer.WriteValue (CategoryId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : CategoryId, _ : bool, _ : JsonSerializer) =
+
+    /// <summary>Converter for the <see cref="CategoryId" /> type</summary>
+    type CategoryIdConverter() =
+        inherit JsonConverter<CategoryId>()
+        override _.WriteJson(writer: JsonWriter, value: CategoryId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: CategoryId, _: bool, _: JsonSerializer) =
             (string >> CategoryId) reader.Value
 
-    type CommentIdConverter () =
-        inherit JsonConverter<CommentId> ()
-        override _.WriteJson (writer : JsonWriter, value : CommentId, _ : JsonSerializer) =
-            writer.WriteValue (CommentId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : CommentId, _ : bool, _ : JsonSerializer) =
+    /// <summary>Converter for the <see cref="CommentId" /> type</summary>
+    type CommentIdConverter() =
+        inherit JsonConverter<CommentId>()
+        override _.WriteJson(writer: JsonWriter, value: CommentId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: CommentId, _: bool, _: JsonSerializer) =
             (string >> CommentId) reader.Value
 
-    type CustomFeedIdConverter () =
-        inherit JsonConverter<CustomFeedId> ()
-        override _.WriteJson (writer : JsonWriter, value : CustomFeedId, _ : JsonSerializer) =
-            writer.WriteValue (CustomFeedId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : CustomFeedId, _ : bool, _ : JsonSerializer) =
+    /// <summary>Converter for the <see cref="CommentStatus" /> type</summary>
+    type CommentStatusConverter() =
+        inherit JsonConverter<CommentStatus>()
+        override _.WriteJson(writer: JsonWriter, value: CommentStatus, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: CommentStatus, _: bool, _: JsonSerializer) =
+            (string >> CommentStatus.Parse) reader.Value
+
+    /// <summary>Converter for the <see cref="CustomFeedId" /> type</summary>
+    type CustomFeedIdConverter() =
+        inherit JsonConverter<CustomFeedId>()
+        override _.WriteJson(writer: JsonWriter, value: CustomFeedId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: CustomFeedId, _: bool, _: JsonSerializer) =
             (string >> CustomFeedId) reader.Value
 
-    type CustomFeedSourceConverter () =
-        inherit JsonConverter<CustomFeedSource> ()
-        override _.WriteJson (writer : JsonWriter, value : CustomFeedSource, _ : JsonSerializer) =
-            writer.WriteValue (CustomFeedSource.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : CustomFeedSource, _ : bool, _ : JsonSerializer) =
-            (string >> CustomFeedSource.parse) reader.Value
-            
-    type ExplicitRatingConverter () =
-        inherit JsonConverter<ExplicitRating> ()
-        override _.WriteJson (writer : JsonWriter, value : ExplicitRating, _ : JsonSerializer) =
-            writer.WriteValue (ExplicitRating.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : ExplicitRating, _ : bool, _ : JsonSerializer) =
-            (string >> ExplicitRating.parse) reader.Value
-        
-    type MarkupTextConverter () =
-        inherit JsonConverter<MarkupText> ()
-        override _.WriteJson (writer : JsonWriter, value : MarkupText, _ : JsonSerializer) =
-            writer.WriteValue (MarkupText.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : MarkupText, _ : bool, _ : JsonSerializer) =
-            (string >> MarkupText.parse) reader.Value
-            
-    type PermalinkConverter () =
-        inherit JsonConverter<Permalink> ()
-        override _.WriteJson (writer : JsonWriter, value : Permalink, _ : JsonSerializer) =
-            writer.WriteValue (Permalink.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : Permalink, _ : bool, _ : JsonSerializer) =
+    /// <summary>Converter for the <see cref="CustomFeedSource" /> type</summary>
+    type CustomFeedSourceConverter() =
+        inherit JsonConverter<CustomFeedSource>()
+        override _.WriteJson(writer: JsonWriter, value: CustomFeedSource, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: CustomFeedSource, _: bool, _: JsonSerializer) =
+            (string >> CustomFeedSource.Parse) reader.Value
+
+    /// <summary>Converter for the <see cref="ExplicitRating" /> type</summary>
+    type ExplicitRatingConverter() =
+        inherit JsonConverter<ExplicitRating>()
+        override _.WriteJson(writer: JsonWriter, value: ExplicitRating, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: ExplicitRating, _: bool, _: JsonSerializer) =
+            (string >> ExplicitRating.Parse) reader.Value
+
+    /// <summary>Converter for the <see cref="MarkupText" /> type</summary>
+    type MarkupTextConverter() =
+        inherit JsonConverter<MarkupText>()
+        override _.WriteJson(writer: JsonWriter, value: MarkupText, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: MarkupText, _: bool, _: JsonSerializer) =
+            (string >> MarkupText.Parse) reader.Value
+
+    /// <summary>Converter for the <see cref="OpenGraphType" /> type</summary>
+    type OpenGraphTypeConverter() =
+        inherit JsonConverter<OpenGraphType>()
+        override _.WriteJson(writer: JsonWriter, value: OpenGraphType, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: OpenGraphType, _: bool, _: JsonSerializer) =
+            (string >> OpenGraphType.Parse) reader.Value
+
+    /// <summary>Converter for the <see cref="Permalink" /> type</summary>
+    type PermalinkConverter() =
+        inherit JsonConverter<Permalink>()
+        override _.WriteJson(writer: JsonWriter, value: Permalink, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: Permalink, _: bool, _: JsonSerializer) =
             (string >> Permalink) reader.Value
 
-    type PageIdConverter () =
-        inherit JsonConverter<PageId> ()
-        override _.WriteJson (writer : JsonWriter, value : PageId, _ : JsonSerializer) =
-            writer.WriteValue (PageId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : PageId, _ : bool, _ : JsonSerializer) =
+    /// <summary>Converter for the <see cref="PageId" /> type</summary>
+    type PageIdConverter() =
+        inherit JsonConverter<PageId>()
+        override _.WriteJson(writer: JsonWriter, value: PageId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: PageId, _: bool, _: JsonSerializer) =
             (string >> PageId) reader.Value
 
-    type PodcastMediumConverter () =
-        inherit JsonConverter<PodcastMedium> ()
-        override _.WriteJson (writer : JsonWriter, value : PodcastMedium, _ : JsonSerializer) =
-            writer.WriteValue (PodcastMedium.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : PodcastMedium, _ : bool, _ : JsonSerializer) =
-            (string >> PodcastMedium.parse) reader.Value
+    /// <summary>Converter for the <see cref="PodcastMedium" /> type</summary>
+    type PodcastMediumConverter() =
+        inherit JsonConverter<PodcastMedium>()
+        override _.WriteJson(writer: JsonWriter, value: PodcastMedium, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: PodcastMedium, _: bool, _: JsonSerializer) =
+            (string >> PodcastMedium.Parse) reader.Value
 
-    type PostIdConverter () =
-        inherit JsonConverter<PostId> ()
-        override _.WriteJson (writer : JsonWriter, value : PostId, _ : JsonSerializer) =
-            writer.WriteValue (PostId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : PostId, _ : bool, _ : JsonSerializer) =
+    /// <summary>Converter for the <see cref="PostId" /> type</summary>
+    type PostIdConverter() =
+        inherit JsonConverter<PostId>()
+        override _.WriteJson(writer: JsonWriter, value: PostId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: PostId, _: bool, _: JsonSerializer) =
             (string >> PostId) reader.Value
 
-    type TagMapIdConverter () =
-        inherit JsonConverter<TagMapId> ()
-        override _.WriteJson (writer : JsonWriter, value : TagMapId, _ : JsonSerializer) =
-            writer.WriteValue (TagMapId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : TagMapId, _ : bool, _ : JsonSerializer) =
+    /// <summary>Converter for the <see cref="TagMapId" /> type</summary>
+    type TagMapIdConverter() =
+        inherit JsonConverter<TagMapId>()
+        override _.WriteJson(writer: JsonWriter, value: TagMapId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: TagMapId, _: bool, _: JsonSerializer) =
             (string >> TagMapId) reader.Value
 
-    type ThemeAssetIdConverter () =
-        inherit JsonConverter<ThemeAssetId> ()
-        override _.WriteJson (writer : JsonWriter, value : ThemeAssetId, _ : JsonSerializer) =
-            writer.WriteValue (ThemeAssetId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : ThemeAssetId, _ : bool, _ : JsonSerializer) =
-            (string >> ThemeAssetId.ofString) reader.Value
+    /// <summary>Converter for the <see cref="ThemeAssetId" /> type</summary>
+    type ThemeAssetIdConverter() =
+        inherit JsonConverter<ThemeAssetId>()
+        override _.WriteJson(writer: JsonWriter, value: ThemeAssetId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: ThemeAssetId, _: bool, _: JsonSerializer) =
+            (string >> ThemeAssetId.Parse) reader.Value
 
-    type ThemeIdConverter () =
-        inherit JsonConverter<ThemeId> ()
-        override _.WriteJson (writer : JsonWriter, value : ThemeId, _ : JsonSerializer) =
-            writer.WriteValue (ThemeId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : ThemeId, _ : bool, _ : JsonSerializer) =
+    /// <summary>Converter for the <see cref="ThemeId" /> type</summary>
+    type ThemeIdConverter() =
+        inherit JsonConverter<ThemeId>()
+        override _.WriteJson(writer: JsonWriter, value: ThemeId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: ThemeId, _: bool, _: JsonSerializer) =
             (string >> ThemeId) reader.Value
-    
-    type UploadIdConverter () =
-        inherit JsonConverter<UploadId> ()
-        override _.WriteJson (writer : JsonWriter, value : UploadId, _ : JsonSerializer) =
-            writer.WriteValue (UploadId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : UploadId, _ : bool, _ : JsonSerializer) =
+
+    /// <summary>Converter for the <see cref="UploadId" /> type</summary>
+    type UploadIdConverter() =
+        inherit JsonConverter<UploadId>()
+        override _.WriteJson(writer: JsonWriter, value: UploadId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: UploadId, _: bool, _: JsonSerializer) =
             (string >> UploadId) reader.Value
-    
-    type WebLogIdConverter () =
-        inherit JsonConverter<WebLogId> ()
-        override _.WriteJson (writer : JsonWriter, value : WebLogId, _ : JsonSerializer) =
-            writer.WriteValue (WebLogId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : WebLogId, _ : bool, _ : JsonSerializer) =
+
+    /// <summary>Converter for the <see cref="WebLogId" /> type</summary>
+    type WebLogIdConverter() =
+        inherit JsonConverter<WebLogId>()
+        override _.WriteJson(writer: JsonWriter, value: WebLogId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: WebLogId, _: bool, _: JsonSerializer) =
             (string >> WebLogId) reader.Value
 
-    type WebLogUserIdConverter () =
+    /// <summary>Converter for the <see cref="WebLogUserId" /> type</summary>
+    type WebLogUserIdConverter() =
         inherit JsonConverter<WebLogUserId> ()
-        override _.WriteJson (writer : JsonWriter, value : WebLogUserId, _ : JsonSerializer) =
-            writer.WriteValue (WebLogUserId.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : WebLogUserId, _ : bool, _ : JsonSerializer) =
+        override _.WriteJson(writer: JsonWriter, value: WebLogUserId, _: JsonSerializer) =
+            writer.WriteValue(string value)
+        override _.ReadJson(reader: JsonReader, _: Type, _: WebLogUserId, _: bool, _: JsonSerializer) =
             (string >> WebLogUserId) reader.Value
 
     open Microsoft.FSharpLu.Json
     open NodaTime
     open NodaTime.Serialization.JsonNet
-    
-    /// Configure a serializer to use these converters
-    let configure (ser : JsonSerializer) =
+
+    /// <summary>Configure a serializer to use these converters (and other settings)</summary>
+    let configure (ser: JsonSerializer) =
         // Our converters
-        [   CategoryIdConverter       () :> JsonConverter
-            CommentIdConverter        ()
-            CustomFeedIdConverter     ()
-            CustomFeedSourceConverter ()
-            ExplicitRatingConverter   ()
-            MarkupTextConverter       ()
-            PermalinkConverter        ()
-            PageIdConverter           ()
-            PodcastMediumConverter    ()
-            PostIdConverter           ()
-            TagMapIdConverter         ()
-            ThemeAssetIdConverter     ()
-            ThemeIdConverter          ()
-            UploadIdConverter         ()
-            WebLogIdConverter         ()
-            WebLogUserIdConverter     ()
-        ] |> List.iter ser.Converters.Add
+        [ CategoryIdConverter() :> JsonConverter
+          CommentIdConverter()
+          CommentStatusConverter()
+          CustomFeedIdConverter()
+          CustomFeedSourceConverter()
+          ExplicitRatingConverter()
+          MarkupTextConverter()
+          OpenGraphTypeConverter()
+          PermalinkConverter()
+          PageIdConverter()
+          PodcastMediumConverter()
+          PostIdConverter()
+          TagMapIdConverter()
+          ThemeAssetIdConverter()
+          ThemeIdConverter()
+          UploadIdConverter()
+          WebLogIdConverter()
+          WebLogUserIdConverter() ]
+        |> List.iter ser.Converters.Add
         // NodaTime
         let _ = ser.ConfigureForNodaTime DateTimeZoneProviders.Tzdb
         // Handles DUs with no associated data, as well as option fields
-        ser.Converters.Add (CompactUnionJsonConverter ())
+        ser.Converters.Add(CompactUnionJsonConverter())
         ser.NullValueHandling     <- NullValueHandling.Ignore
         ser.MissingMemberHandling <- MissingMemberHandling.Ignore
         ser
-    
+
     /// Serializer settings extracted from a JsonSerializer (a property sure would be nice...)
     let mutable private serializerSettings : JsonSerializerSettings option = None
-    
-    /// Extract settings from the serializer to be used in JsonConvert calls
-    let settings (ser : JsonSerializer) =
+
+    /// <summary>Extract settings from the serializer to be used in <c>JsonConvert</c> calls</summary>
+    /// <param name="ser">The serializer from which settings will be extracted if required</param>
+    /// <returns>The serializer settings to use for <c>JsonConvert</c> calls</returns>
+    let settings (ser: JsonSerializer) =
         if Option.isNone serializerSettings then
             serializerSettings <- JsonSerializerSettings (
                 ConstructorHandling            = ser.ConstructorHandling,
@@ -165,6 +201,7 @@ module Json =
                 Converters                     = ser.Converters,
                 DefaultValueHandling           = ser.DefaultValueHandling,
                 DateFormatHandling             = ser.DateFormatHandling,
+                DateParseHandling              = ser.DateParseHandling,
                 MetadataPropertyHandling       = ser.MetadataPropertyHandling,
                 MissingMemberHandling          = ser.MissingMemberHandling,
                 NullValueHandling              = ser.NullValueHandling,

src/MyWebLog.Data/Interfaces.fs

@@ -7,6 +7,7 @@ open Newtonsoft.Json
 open NodaTime
 
 /// The result of a category deletion attempt
+[<Struct>]
 type CategoryDeleteResult =
     /// The category was deleted successfully
     | CategoryDeleted
@@ -32,7 +33,7 @@ type ICategoryData =
     abstract member Delete : CategoryId -> WebLogId -> Task<CategoryDeleteResult>
     
     /// Find all categories for a web log, sorted alphabetically and grouped by hierarchy
-    abstract member FindAllForView : WebLogId -> Task<DisplayCategory[]>
+    abstract member FindAllForView : WebLogId -> Task<DisplayCategory array>
     
     /// Find a category by its ID
     abstract member FindById : CategoryId -> WebLogId -> Task<Category option>
@@ -53,7 +54,7 @@ type IPageData =
     /// Add a page
     abstract member Add : Page -> Task<unit>
     
-    /// Get all pages for the web log (excluding meta items, text, revisions, and prior permalinks)
+    /// Get all pages for the web log (excluding text, metadata, revisions, and prior permalinks)
     abstract member All : WebLogId -> Task<Page list>
     
     /// Count all pages for the given web log
@@ -84,7 +85,7 @@ type IPageData =
     abstract member FindListed : WebLogId -> Task<Page list>
     
     /// Find a page of pages (displayed in admin section) (excluding meta items, revisions and prior permalinks)
-    abstract member FindPageOfPages : WebLogId -> pageNbr : int -> Task<Page list>
+    abstract member FindPageOfPages : WebLogId -> pageNbr: int -> Task<Page list>
     
     /// Restore pages from a backup
     abstract member Restore : Page list -> Task<unit>
@@ -125,20 +126,20 @@ type IPostData =
     
     /// Find posts to be displayed on a category list page (excluding revisions and prior permalinks)
     abstract member FindPageOfCategorizedPosts :
-        WebLogId -> CategoryId list -> pageNbr : int -> postsPerPage : int -> Task<Post list>
+        WebLogId -> CategoryId list -> pageNbr: int -> postsPerPage: int -> Task<Post list>
     
-    /// Find posts to be displayed on an admin page (excluding revisions and prior permalinks)
-    abstract member FindPageOfPosts : WebLogId -> pageNbr : int -> postsPerPage : int -> Task<Post list>
+    /// Find posts to be displayed on an admin page (excluding text, revisions, and prior permalinks)
+    abstract member FindPageOfPosts : WebLogId -> pageNbr: int -> postsPerPage: int -> Task<Post list>
     
     /// Find posts to be displayed on a page (excluding revisions and prior permalinks)
-    abstract member FindPageOfPublishedPosts : WebLogId -> pageNbr : int -> postsPerPage : int -> Task<Post list>
+    abstract member FindPageOfPublishedPosts : WebLogId -> pageNbr: int -> postsPerPage: int -> Task<Post list>
     
     /// Find posts to be displayed on a tag list page (excluding revisions and prior permalinks)
     abstract member FindPageOfTaggedPosts :
-        WebLogId -> tag : string -> pageNbr : int -> postsPerPage : int -> Task<Post list>
+        WebLogId -> tag : string -> pageNbr: int -> postsPerPage: int -> Task<Post list>
     
     /// Find the next older and newer post for the given published date/time (excluding revisions and prior permalinks)
-    abstract member FindSurroundingPosts : WebLogId -> publishedOn : Instant -> Task<Post option * Post option>
+    abstract member FindSurroundingPosts : WebLogId -> publishedOn: Instant -> Task<Post option * Post option>
     
     /// Restore posts from a backup
     abstract member Restore : Post list -> Task<unit>
@@ -259,6 +260,9 @@ type IWebLogData =
     /// Find a web log by its ID
     abstract member FindById : WebLogId -> Task<WebLog option>
     
+    /// Update redirect rules for a web log
+    abstract member UpdateRedirectRules : WebLog -> Task<unit>
+    
     /// Update RSS options for a web log
     abstract member UpdateRssOptions : WebLog -> Task<unit>
     

src/MyWebLog.Data/MyWebLog.Data.fsproj

@@ -5,27 +5,25 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.Data.Sqlite" Version="6.0.8" />
-		<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="6.0.0" />
-		<PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="6.0.0" />
+		<PackageReference Include="BitBadger.Documents.Postgres" Version="4.1.0" />
+		<PackageReference Include="BitBadger.Documents.Sqlite" Version="4.1.0" />
+		<PackageReference Include="Microsoft.Data.Sqlite" Version="9.0.6" />
+		<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.6" />
+		<PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="9.0.6" />
 		<PackageReference Include="Microsoft.FSharpLu.Json" Version="0.11.7" />
-		<PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-		<PackageReference Include="NodaTime" Version="3.1.2" />
-		<PackageReference Include="NodaTime.Serialization.JsonNet" Version="3.0.0" />
-		<PackageReference Include="Npgsql" Version="6.0.6" />
-		<PackageReference Include="Npgsql.FSharp" Version="5.3.0" />
-		<PackageReference Include="Npgsql.NodaTime" Version="6.0.6" />
+		<PackageReference Include="NodaTime.Serialization.JsonNet" Version="3.2.0" />
+		<PackageReference Include="Npgsql.NodaTime" Version="9.0.3" />
 		<PackageReference Include="RethinkDb.Driver" Version="2.3.150" />
 		<PackageReference Include="RethinkDb.Driver.FSharp" Version="0.9.0-beta-07" />
-		<PackageReference Update="FSharp.Core" Version="6.0.5" />
+		<PackageReference Update="FSharp.Core" Version="9.0.300" />
 	</ItemGroup>
-	
+
 	<ItemGroup>
 		<Compile Include="Converters.fs" />
 		<Compile Include="Interfaces.fs" />
 		<Compile Include="Utils.fs" />
 		<Compile Include="RethinkDbData.fs" />
-		<Compile Include="SQLite\Helpers.fs" />
+		<Compile Include="SQLite\SQLiteHelpers.fs" />
 		<Compile Include="SQLite\SQLiteCategoryData.fs" />
 		<Compile Include="SQLite\SQLitePageData.fs" />
 		<Compile Include="SQLite\SQLitePostData.fs" />
@@ -45,7 +43,13 @@
 		<Compile Include="Postgres\PostgresUploadData.fs" />
 		<Compile Include="Postgres\PostgresWebLogData.fs" />
 		<Compile Include="Postgres\PostgresWebLogUserData.fs" />
-        <Compile Include="PostgresData.fs" />
+		<Compile Include="PostgresData.fs" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
+			<_Parameter1>MyWebLog.Tests</_Parameter1>
+		</AssemblyAttribute>
 	</ItemGroup>
 
 </Project>

src/MyWebLog.Data/Postgres/PostgresCache.fs

@@ -2,37 +2,37 @@ namespace MyWebLog.Data.Postgres
 
 open System.Threading
 open System.Threading.Tasks
+open BitBadger.Documents.Postgres
 open Microsoft.Extensions.Caching.Distributed
 open NodaTime
-open Npgsql.FSharp
 
 /// Helper types and functions for the cache
 [<AutoOpen>]
 module private Helpers =
     
     /// The cache entry
-    type Entry =
-        {   /// The ID of the cache entry
-            Id : string
-            
-            /// The value to be cached
-            Payload : byte[]
-            
-            /// When this entry will expire
-            ExpireAt : Instant
-            
-            /// The duration by which the expiration should be pushed out when being refreshed
-            SlidingExpiration : Duration option
-            
-            /// The must-expire-by date/time for the cache entry
-            AbsoluteExpiration : Instant option
-        }
+    type Entry = {
+        /// The ID of the cache entry
+        Id: string
+        
+        /// The value to be cached
+        Payload: byte array
+        
+        /// When this entry will expire
+        ExpireAt: Instant
+        
+        /// The duration by which the expiration should be pushed out when being refreshed
+        SlidingExpiration: Duration option
+        
+        /// The must-expire-by date/time for the cache entry
+        AbsoluteExpiration: Instant option
+    }
     
     /// Run a task synchronously
-    let sync<'T> (it : Task<'T>) = it |> (Async.AwaitTask >> Async.RunSynchronously)
+    let sync<'T> (it: Task<'T>) = it |> (Async.AwaitTask >> Async.RunSynchronously)
     
     /// Get the current instant
-    let getNow () = SystemClock.Instance.GetCurrentInstant ()
+    let getNow () = SystemClock.Instance.GetCurrentInstant()
     
     /// Create a parameter for the expire-at time
     let expireParam =
@@ -40,32 +40,28 @@ module private Helpers =
 
 
 /// A distributed cache implementation in PostgreSQL used to handle sessions for myWebLog
-type DistributedCache (connStr : string) =
+type DistributedCache () =
     
     // ~~~ INITIALIZATION ~~~
     
     do
         task {
             let! exists =
-                Sql.connect connStr
-                |> Sql.query $"
-                    SELECT EXISTS
-                        (SELECT 1 FROM pg_tables WHERE schemaname = 'public' AND tablename = 'session')
-                      AS {existsName}"
-                |> Sql.executeRowAsync Map.toExists
+                Custom.scalar
+                    "SELECT EXISTS
+                       (SELECT 1 FROM pg_tables WHERE schemaname = 'public' AND tablename = 'session')
+                     AS it"
+                    []
+                    toExists
             if not exists then
-                let! _ =
-                    Sql.connect connStr
-                    |> Sql.query
+                do! Custom.nonQuery
                         "CREATE TABLE session (
                             id                  TEXT        NOT NULL PRIMARY KEY,
                             payload             BYTEA       NOT NULL,
                             expire_at           TIMESTAMPTZ NOT NULL,
                             sliding_expiration  INTERVAL,
                             absolute_expiration TIMESTAMPTZ);
-                        CREATE INDEX idx_session_expiration ON session (expire_at)"
-                    |> Sql.executeNonQueryAsync
-                ()
+                        CREATE INDEX idx_session_expiration ON session (expire_at)" []
         } |> sync
     
     // ~~~ SUPPORT FUNCTIONS ~~~
@@ -74,16 +70,15 @@ type DistributedCache (connStr : string) =
     let getEntry key = backgroundTask {
         let idParam = "@id", Sql.string key
         let! tryEntry =
-            Sql.connect connStr
-            |> Sql.query "SELECT * FROM session WHERE id = @id"
-            |> Sql.parameters [ idParam ]
-            |> Sql.executeAsync (fun row ->
-                {   Id                 = row.string                     "id"
-                    Payload            = row.bytea                      "payload"
-                    ExpireAt           = row.fieldValue<Instant>        "expire_at"
-                    SlidingExpiration  = row.fieldValueOrNone<Duration> "sliding_expiration"
-                    AbsoluteExpiration = row.fieldValueOrNone<Instant>  "absolute_expiration"   })
-            |> tryHead
+            Custom.single
+                "SELECT * FROM session WHERE id = @id"
+                [ idParam ]
+                (fun row ->
+                      { Id                 = row.string                     "id"
+                        Payload            = row.bytea                      "payload"
+                        ExpireAt           = row.fieldValue<Instant>        "expire_at"
+                        SlidingExpiration  = row.fieldValueOrNone<Duration> "sliding_expiration"
+                        AbsoluteExpiration = row.fieldValueOrNone<Instant>  "absolute_expiration" })
         match tryEntry with
         | Some entry ->
             let now      = getNow ()
@@ -96,11 +91,9 @@ type DistributedCache (connStr : string) =
                     true, { entry with ExpireAt = absExp }
                 else true, { entry with ExpireAt = now.Plus slideExp }
             if needsRefresh then
-                let! _ =
-                    Sql.connect connStr
-                    |> Sql.query "UPDATE session SET expire_at = @expireAt WHERE id = @id"
-                    |> Sql.parameters [ expireParam item.ExpireAt; idParam ]
-                    |> Sql.executeNonQueryAsync
+                do! Custom.nonQuery
+                        "UPDATE session SET expire_at = @expireAt WHERE id = @id"
+                        [ expireParam item.ExpireAt; idParam ]
                 ()
             return if item.ExpireAt > now then Some entry else None
         | None -> return None
@@ -112,27 +105,17 @@ type DistributedCache (connStr : string) =
     /// Purge expired entries every 30 minutes
     let purge () = backgroundTask {
         let now = getNow ()
-        if lastPurge.Plus (Duration.FromMinutes 30L) < now then
-            let! _ =
-                Sql.connect connStr
-                |> Sql.query "DELETE FROM session WHERE expire_at < @expireAt"
-                |> Sql.parameters [ expireParam now ]
-                |> Sql.executeNonQueryAsync
+        if lastPurge.Plus(Duration.FromMinutes 30L) < now then
+            do! Custom.nonQuery "DELETE FROM session WHERE expire_at < @expireAt" [ expireParam now ]
             lastPurge <- now
     }
     
     /// Remove a cache entry
-    let removeEntry key = backgroundTask {
-        let! _ =
-            Sql.connect connStr
-            |> Sql.query "DELETE FROM session WHERE id = @id"
-            |> Sql.parameters [ "@id", Sql.string key ]
-            |> Sql.executeNonQueryAsync
-        ()
-    }
+    let removeEntry key =
+        Custom.nonQuery "DELETE FROM session WHERE id = @id" [ "@id", Sql.string key ]
     
     /// Save an entry
-    let saveEntry (opts : DistributedCacheEntryOptions) key payload = backgroundTask {
+    let saveEntry (opts: DistributedCacheEntryOptions) key payload =
         let now = getNow ()
         let expireAt, slideExp, absExp =
             if opts.SlidingExpiration.HasValue then
@@ -142,38 +125,32 @@ type DistributedCache (connStr : string) =
                 let exp = Instant.FromDateTimeOffset opts.AbsoluteExpiration.Value
                 exp, None, Some exp
             elif opts.AbsoluteExpirationRelativeToNow.HasValue then
-                let exp = now.Plus (Duration.FromTimeSpan opts.AbsoluteExpirationRelativeToNow.Value)
+                let exp = now.Plus(Duration.FromTimeSpan opts.AbsoluteExpirationRelativeToNow.Value)
                 exp, None, Some exp
             else
                 // Default to 1 hour sliding expiration
                 let slide = Duration.FromHours 1
                 now.Plus slide, Some slide, None
-        let! _ =
-            Sql.connect connStr
-            |> Sql.query
-                "INSERT INTO session (
-                    id, payload, expire_at, sliding_expiration, absolute_expiration
-                ) VALUES (
-                    @id, @payload, @expireAt, @slideExp, @absExp
-                ) ON CONFLICT (id) DO UPDATE
-                SET payload             = EXCLUDED.payload,
-                    expire_at           = EXCLUDED.expire_at,
-                    sliding_expiration  = EXCLUDED.sliding_expiration,
-                    absolute_expiration = EXCLUDED.absolute_expiration"
-            |> Sql.parameters
-                [   "@id",      Sql.string key
-                    "@payload", Sql.bytea payload
-                    expireParam expireAt
-                    optParam "slideExp" slideExp
-                    optParam "absExp"   absExp ]
-            |> Sql.executeNonQueryAsync
-        ()
-    }
+        Custom.nonQuery
+            "INSERT INTO session (
+                id, payload, expire_at, sliding_expiration, absolute_expiration
+            ) VALUES (
+                @id, @payload, @expireAt, @slideExp, @absExp
+            ) ON CONFLICT (id) DO UPDATE
+            SET payload             = EXCLUDED.payload,
+                expire_at           = EXCLUDED.expire_at,
+                sliding_expiration  = EXCLUDED.sliding_expiration,
+                absolute_expiration = EXCLUDED.absolute_expiration"
+            [   "@id",      Sql.string key
+                "@payload", Sql.bytea payload
+                expireParam expireAt
+                optParam "slideExp" slideExp
+                optParam "absExp"   absExp ]
         
     // ~~~ IMPLEMENTATION FUNCTIONS ~~~
     
     /// Retrieve the data for a cache entry
-    let get key (_ : CancellationToken) = backgroundTask {
+    let get key (_: CancellationToken) = backgroundTask {
         match! getEntry key with
         | Some entry ->
             do! purge ()
@@ -182,29 +159,29 @@ type DistributedCache (connStr : string) =
     }
     
     /// Refresh an entry
-    let refresh key (cancelToken : CancellationToken) = backgroundTask {
+    let refresh key (cancelToken: CancellationToken) = backgroundTask {
         let! _ = get key cancelToken
         ()
     }
     
     /// Remove an entry
-    let remove key (_ : CancellationToken) = backgroundTask {
+    let remove key (_: CancellationToken) = backgroundTask {
         do! removeEntry key
         do! purge ()
     }
     
     /// Set an entry
-    let set key value options (_ : CancellationToken) = backgroundTask {
+    let set key value options (_: CancellationToken) = backgroundTask {
         do! saveEntry options key value
         do! purge ()
     }
     
     interface IDistributedCache with
-        member this.Get key = get key CancellationToken.None |> sync
-        member this.GetAsync (key, token) = get key token
-        member this.Refresh key = refresh key CancellationToken.None |> sync
-        member this.RefreshAsync (key, token) = refresh key token
-        member this.Remove key = remove key CancellationToken.None |> sync
-        member this.RemoveAsync (key, token) = remove key token
-        member this.Set (key, value, options) = set key value options CancellationToken.None |> sync
-        member this.SetAsync (key, value, options, token) = set key value options token
+        member _.Get key = get key CancellationToken.None |> sync
+        member _.GetAsync(key, token) = get key token
+        member _.Refresh key = refresh key CancellationToken.None |> sync
+        member _.RefreshAsync(key, token) = refresh key token
+        member _.Remove key = remove key CancellationToken.None |> sync
+        member _.RemoveAsync(key, token) = remove key token
+        member _.Set(key, value, options) = set key value options CancellationToken.None |> sync
+        member _.SetAsync(key, value, options, token) = set key value options token

src/MyWebLog.Data/Postgres/PostgresCategoryData.fs

@@ -1,57 +1,60 @@
 namespace MyWebLog.Data.Postgres
 
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Npgsql
 open Npgsql.FSharp
 
 /// PostgreSQL myWebLog category data implementation
-type PostgresCategoryData (conn : NpgsqlConnection) =
+type PostgresCategoryData(log: ILogger) =
     
     /// Count all categories for the given web log
     let countAll webLogId =
-        Sql.existingConnection conn
-        |> Sql.query $"SELECT COUNT(id) AS {countName} FROM category WHERE web_log_id = @webLogId"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeRowAsync Map.toCount
+        log.LogTrace "Category.countAll"
+        Count.byContains Table.Category (webLogDoc webLogId)
     
     /// Count all top-level categories for the given web log
     let countTopLevel webLogId =
-        Sql.existingConnection conn
-        |> Sql.query $"SELECT COUNT(id) AS {countName} FROM category WHERE web_log_id = @webLogId AND parent_id IS NULL"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeRowAsync Map.toCount
+        log.LogTrace "Category.countTopLevel"
+        Custom.scalar
+            $"""{Query.byContains (Query.count Table.Category)}
+                  AND {Query.whereByFields Any [ Field.NotExists (nameof Category.Empty.ParentId) ]}"""
+            [ webLogContains webLogId ]
+            toCount
+    
+    /// Find all categories for the given web log
+    let findByWebLog webLogId =
+        log.LogTrace "Category.findByWebLog"
+        Find.byContains<Category> Table.Category (webLogDoc webLogId)
     
     /// Retrieve all categories for the given web log in a DotLiquid-friendly format
     let findAllForView webLogId = backgroundTask {
-        let! cats =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT * FROM category WHERE web_log_id = @webLogId ORDER BY LOWER(name)"
-            |> Sql.parameters [ webLogIdParam webLogId ]
-            |> Sql.executeAsync Map.toCategory
-        let ordered = Utils.orderByHierarchy cats None None []
-        let counts  =
+        log.LogTrace "Category.findAllForView"
+        let! cats    = findByWebLog webLogId
+        let  ordered = Utils.orderByHierarchy (cats |> List.sortBy _.Name.ToLowerInvariant()) None None []
+        let  counts  =
             ordered
             |> Seq.map (fun it ->
                 // Parent category post counts include posts in subcategories
-                let catIdSql, catIdParams =
+                let catIdField =
                     ordered
                     |> Seq.filter (fun cat -> cat.ParentNames |> Array.contains it.Name)
-                    |> Seq.map (fun cat -> cat.Id)
+                    |> Seq.map _.Id
                     |> Seq.append (Seq.singleton it.Id)
-                    |> List.ofSeq
-                    |> inClause "AND pc.category_id" "id" id
+                    |> Field.InArray (nameof Post.Empty.CategoryIds) Table.Post
+                let query =
+                    (Query.statementWhere
+                         (Query.count Table.Post)
+                         $"""{Query.whereDataContains "@criteria"} AND {Query.whereByFields All [ catIdField ]}""")
+                        .Replace("(*)", $"(DISTINCT data->>'{nameof Post.Empty.Id}')")
                 let postCount =
-                    Sql.existingConnection conn
-                    |> Sql.query $"
-                        SELECT COUNT(DISTINCT p.id) AS {countName}
-                          FROM post p
-                               INNER JOIN post_category pc ON pc.post_id = p.id
-                         WHERE p.web_log_id = @webLogId
-                           AND p.status     = 'Published'
-                           {catIdSql}"
-                    |> Sql.parameters (webLogIdParam webLogId :: catIdParams)
-                    |> Sql.executeRowAsync Map.toCount
+                    Custom.scalar
+                        query
+                        (addFieldParams
+                             [ catIdField ] [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |} ])
+                        toCount
                     |> Async.AwaitTask
                     |> Async.RunSynchronously
                 it.Id, postCount)
@@ -63,99 +66,77 @@ type PostgresCategoryData (conn : NpgsqlConnection) =
                     PostCount = counts
                                 |> List.tryFind (fun c -> fst c = cat.Id)
                                 |> Option.map snd
-                                |> Option.defaultValue 0
-                })
+                                |> Option.defaultValue 0 })
             |> Array.ofSeq
     }
     /// Find a category by its ID for the given web log
     let findById catId webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM category WHERE id = @id AND web_log_id = @webLogId"
-        |> Sql.parameters [ "@id", Sql.string (CategoryId.toString catId); webLogIdParam webLogId ]
-        |> Sql.executeAsync Map.toCategory
-        |> tryHead
-    
-    /// Find all categories for the given web log
-    let findByWebLog webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM category WHERE web_log_id = @webLogId"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeAsync Map.toCategory
-    
+        log.LogTrace "Category.findById"
+        Document.findByIdAndWebLog<CategoryId, Category> Table.Category catId webLogId
     
     /// Delete a category
     let delete catId webLogId = backgroundTask {
+        log.LogTrace "Category.delete"
         match! findById catId webLogId with
         | Some cat ->
             // Reassign any children to the category's parent category
-            let  parentParam = "@parentId", Sql.string (CategoryId.toString catId)
-            let! hasChildren =
-                Sql.existingConnection conn
-                |> Sql.query $"SELECT EXISTS (SELECT 1 FROM category WHERE parent_id = @parentId) AS {existsName}"
-                |> Sql.parameters [ parentParam ]
-                |> Sql.executeRowAsync Map.toExists
+            let! children = Find.byContains<Category> Table.Category {| ParentId = catId |}
+            let hasChildren = not (List.isEmpty children)
             if hasChildren then
+                let childQuery, childParams =
+                    if cat.ParentId.IsSome then
+                        Query.byId (Query.patch Table.Category) "",
+                        children
+                        |> List.map (fun child -> [ idParam child.Id; jsonParam "@data" {| ParentId = cat.ParentId |} ])
+                    else
+                        Query.byId (Query.removeFields Table.Category) "",
+                        children
+                        |> List.map (fun child ->
+                            [ idParam child.Id; fieldNameParams [ nameof Category.Empty.ParentId ] ])
                 let! _ =
-                    Sql.existingConnection conn
-                    |> Sql.query "UPDATE category SET parent_id = @newParentId WHERE parent_id = @parentId"
-                    |> Sql.parameters
-                        [   parentParam
-                            "@newParentId", Sql.stringOrNone (cat.ParentId |> Option.map CategoryId.toString) ]
-                    |> Sql.executeNonQueryAsync
+                    Configuration.dataSource ()
+                    |> Sql.fromDataSource
+                    |> Sql.executeTransactionAsync [ childQuery, childParams ]
                 ()
-            // Delete the category off all posts where it is assigned, and the category itself
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.query
-                    "DELETE FROM post_category
-                      WHERE category_id = @id
-                        AND post_id IN (SELECT id FROM post WHERE web_log_id = @webLogId);
-                     DELETE FROM category WHERE id = @id"
-                |> Sql.parameters [ "@id", Sql.string (CategoryId.toString catId); webLogIdParam webLogId ]
-                |> Sql.executeNonQueryAsync
+            // Delete the category off all posts where it is assigned
+            let! posts =
+                Custom.list
+                    $"SELECT data FROM {Table.Post} WHERE data->'{nameof Post.Empty.CategoryIds}' @> @id"
+                    [ jsonParam "@id" [| string catId |] ]
+                    fromData<Post>
+            if not (List.isEmpty posts) then
+                let! _ =
+                    Configuration.dataSource ()
+                    |> Sql.fromDataSource
+                    |> Sql.executeTransactionAsync
+                        [ Query.byId (Query.patch Table.Post) "",
+                          posts
+                          |> List.map (fun post ->
+                              [ idParam post.Id
+                                jsonParam
+                                    "@data"
+                                    {| CategoryIds = post.CategoryIds |> List.filter (fun cat -> cat <> catId) |} ]) ]
+                ()
+            // Delete the category itself
+            do! Delete.byId Table.Category catId
             return if hasChildren then ReassignedChildCategories else CategoryDeleted
         | None -> return CategoryNotFound
     }
     
-    /// The INSERT statement for a category
-    let catInsert =
-        "INSERT INTO category (
-            id, web_log_id, name, slug, description, parent_id
-        ) VALUES (
-            @id, @webLogId, @name, @slug, @description, @parentId
-        )"
-    
-    /// Create parameters for a category insert / update
-    let catParameters (cat : Category) = [
-        webLogIdParam cat.WebLogId
-        "@id",          Sql.string       (CategoryId.toString cat.Id)
-        "@name",        Sql.string       cat.Name
-        "@slug",        Sql.string       cat.Slug
-        "@description", Sql.stringOrNone cat.Description
-        "@parentId",    Sql.stringOrNone (cat.ParentId |> Option.map CategoryId.toString)
-    ]
-
     /// Save a category
-    let save cat = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query $"
-                {catInsert} ON CONFLICT (id) DO UPDATE
-                SET name        = EXCLUDED.name,
-                    slug        = EXCLUDED.slug,
-                    description = EXCLUDED.description,
-                    parent_id   = EXCLUDED.parent_id"
-            |> Sql.parameters (catParameters cat)
-            |> Sql.executeNonQueryAsync
-        ()
+    let save (cat: Category) = backgroundTask {
+        log.LogTrace "Category.save"
+        do! save Table.Category cat
     }
     
     /// Restore categories from a backup
     let restore cats = backgroundTask {
+        log.LogTrace "Category.restore"
         let! _ =
-            Sql.existingConnection conn
+            Configuration.dataSource ()
+            |> Sql.fromDataSource
             |> Sql.executeTransactionAsync [
-                catInsert, cats |> List.map catParameters
+                Query.insert Table.Category, cats |> List.map (fun c -> [ jsonParam "@data" c ])
             ]
         ()
     }

src/MyWebLog.Data/Postgres/PostgresHelpers.fs

@@ -2,239 +2,197 @@
 [<AutoOpen>]
 module MyWebLog.Data.Postgres.PostgresHelpers
 
+/// The table names used in the PostgreSQL implementation
+[<RequireQualifiedAccess>]
+module Table =
+    
+    /// Categories
+    [<Literal>]
+    let Category = "category"
+    
+    /// Database Version
+    [<Literal>]
+    let DbVersion = "db_version"
+    
+    /// Pages
+    [<Literal>]
+    let Page = "page"
+    
+    /// Page Revisions
+    [<Literal>]
+    let PageRevision = "page_revision"
+    
+    /// Posts
+    [<Literal>]
+    let Post = "post"
+    
+    /// Post Comments
+    [<Literal>]
+    let PostComment = "post_comment"
+    
+    /// Post Revisions
+    [<Literal>]
+    let PostRevision = "post_revision"
+    
+    /// Tag/URL Mappings
+    [<Literal>]
+    let TagMap = "tag_map"
+    
+    /// Themes
+    [<Literal>]
+    let Theme = "theme"
+    
+    /// Theme Assets
+    [<Literal>]
+    let ThemeAsset = "theme_asset"
+    
+    /// Uploads
+    [<Literal>]
+    let Upload = "upload"
+    
+    /// Web Logs
+    [<Literal>]
+    let WebLog = "web_log"
+    
+    /// Users
+    [<Literal>]
+    let WebLogUser = "web_log_user"
+
+
 open System
 open System.Threading.Tasks
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
 open MyWebLog
 open MyWebLog.Data
-open Newtonsoft.Json
 open NodaTime
 open Npgsql
 open Npgsql.FSharp
 
 /// Create a SQL parameter for the web log ID
-let webLogIdParam webLogId =
-    "@webLogId", Sql.string (WebLogId.toString webLogId)
+let webLogIdParam (webLogId: WebLogId) =
+    "@webLogId", Sql.string (string webLogId)
 
-/// The name of the field to select to be able to use Map.toCount
-let countName = "the_count"
+/// Create an anonymous record with the given web log ID
+let webLogDoc (webLogId: WebLogId) =
+    {| WebLogId = webLogId |}
 
-/// The name of the field to select to be able to use Map.toExists
-let existsName = "does_exist"
+/// Create a parameter for a web log document-contains query
+let webLogContains webLogId =
+    jsonParam "@criteria" (webLogDoc webLogId)
 
-/// Create the SQL and parameters for an IN clause
-let inClause<'T> colNameAndPrefix paramName (valueFunc: 'T -> string) (items : 'T list) =
-    if List.isEmpty items then "", []
-    else
-        let mutable idx = 0
-        items
-        |> List.skip 1
-        |> List.fold (fun (itemS, itemP) it ->
-            idx <- idx + 1
-            $"{itemS}, @%s{paramName}{idx}", ($"@%s{paramName}{idx}", Sql.string (valueFunc it)) :: itemP)
-            (Seq.ofList items
-             |> Seq.map (fun it ->
-                 $"%s{colNameAndPrefix} IN (@%s{paramName}0", [ $"@%s{paramName}0", Sql.string (valueFunc it) ])
-             |> Seq.head)
-        |> function sql, ps -> $"{sql})", ps
+/// A SQL string to select data from a table with the given JSON document contains criteria
+let selectWithCriteria tableName =
+    Query.byContains (Query.find tableName)
 
-/// Create the SQL and parameters for the array equivalent of an IN clause
-let arrayInClause<'T> name (valueFunc : 'T -> string) (items : 'T list) =
-    if List.isEmpty items then "TRUE = FALSE", []
-    else
-        let mutable idx = 0
-        items
-        |> List.skip 1
-        |> List.fold (fun (itemS, itemP) it ->
-            idx <- idx + 1
-            $"{itemS} OR %s{name} && ARRAY[@{name}{idx}]",
-            ($"@{name}{idx}", Sql.string (valueFunc it)) :: itemP)
-            (Seq.ofList items
-             |> Seq.map (fun it ->
-                 $"{name} && ARRAY[@{name}0]", [ $"@{name}0", Sql.string (valueFunc it) ])
-             |> Seq.head)
-    
 /// Get the first result of the given query
-let tryHead<'T> (query : Task<'T list>) = backgroundTask {
+let tryHead<'T> (query: Task<'T list>) = backgroundTask {
     let! results = query
     return List.tryHead results
 }
 
 /// Create a parameter for a non-standard type
-let typedParam<'T> name (it : 'T) =
-    $"@%s{name}", Sql.parameter (NpgsqlParameter ($"@{name}", it))
+let typedParam<'T> name (it: 'T) =
+    $"@%s{name}", Sql.parameter (NpgsqlParameter($"@{name}", it))
 
 /// Create a parameter for a possibly-missing non-standard type
-let optParam<'T> name (it : 'T option) =
-    let p = NpgsqlParameter ($"@%s{name}", if Option.isSome it then box it.Value else DBNull.Value)
+let optParam<'T> name (it: 'T option) =
+    let p = NpgsqlParameter($"@%s{name}", if Option.isSome it then box it.Value else DBNull.Value)
     p.ParameterName, Sql.parameter p
 
 /// Mapping functions for SQL queries
 module Map =
     
-    /// Map an id field to a category ID
-    let toCategoryId (row : RowReader) =
-        CategoryId (row.string "id")
-    
-    /// Create a category from the current row
-    let toCategory (row : RowReader) : Category =
-        {   Id          = toCategoryId row
-            WebLogId    = row.string       "web_log_id" |> WebLogId
-            Name        = row.string       "name"
-            Slug        = row.string       "slug"
-            Description = row.stringOrNone "description"
-            ParentId    = row.stringOrNone "parent_id"  |> Option.map CategoryId
-        }
-
-    /// Get a count from a row
-    let toCount (row : RowReader) =
-        row.int countName
-    
-    /// Create a custom feed from the current row
-    let toCustomFeed (ser : JsonSerializer) (row : RowReader) : CustomFeed =
-        {   Id      = row.string       "id"      |> CustomFeedId
-            Source  = row.string       "source"  |> CustomFeedSource.parse
-            Path    = row.string       "path"    |> Permalink
-            Podcast = row.stringOrNone "podcast" |> Option.map (Utils.deserialize ser)
-        }
-    
-    /// Get a true/false value as to whether an item exists
-    let toExists (row : RowReader) =
-        row.bool existsName
-    
-    /// Create a meta item from the current row
-    let toMetaItem (row : RowReader) : MetaItem =
-        {   Name  = row.string "name"
-            Value = row.string "value"
-        }
-    
     /// Create a permalink from the current row
-    let toPermalink (row : RowReader) =
+    let toPermalink (row: RowReader) =
         Permalink (row.string "permalink")
     
-    /// Create a page from the current row
-    let toPage (ser : JsonSerializer) (row : RowReader) : Page =
-        { Page.empty with
-            Id              = row.string              "id"         |> PageId
-            WebLogId        = row.string              "web_log_id" |> WebLogId
-            AuthorId        = row.string              "author_id"  |> WebLogUserId
-            Title           = row.string              "title"
-            Permalink       = toPermalink row
-            PriorPermalinks = row.stringArray         "prior_permalinks" |> Array.map Permalink |> List.ofArray
-            PublishedOn     = row.fieldValue<Instant> "published_on"
-            UpdatedOn       = row.fieldValue<Instant> "updated_on"
-            IsInPageList    = row.bool                "is_in_page_list"
-            Template        = row.stringOrNone        "template"
-            Text            = row.string              "page_text"
-            Metadata        = row.stringOrNone        "meta_items"
-                              |> Option.map (Utils.deserialize ser)
-                              |> Option.defaultValue []
-        }
-    
-    /// Create a post from the current row
-    let toPost (ser : JsonSerializer) (row : RowReader) : Post =
-        { Post.empty with
-            Id              = row.string                    "id"         |> PostId
-            WebLogId        = row.string                    "web_log_id" |> WebLogId
-            AuthorId        = row.string                    "author_id"  |> WebLogUserId
-            Status          = row.string                    "status"     |> PostStatus.parse
-            Title           = row.string                    "title"
-            Permalink       = toPermalink row
-            PriorPermalinks = row.stringArray               "prior_permalinks" |> Array.map Permalink |> List.ofArray
-            PublishedOn     = row.fieldValueOrNone<Instant> "published_on"
-            UpdatedOn       = row.fieldValue<Instant>       "updated_on"
-            Template        = row.stringOrNone              "template"
-            Text            = row.string                    "post_text"
-            Episode         = row.stringOrNone              "episode"          |> Option.map (Utils.deserialize ser)
-            CategoryIds     = row.stringArrayOrNone         "category_ids"
-                              |> Option.map (Array.map CategoryId >> List.ofArray)
-                              |> Option.defaultValue []
-            Tags            = row.stringArrayOrNone         "tags"
-                              |> Option.map List.ofArray
-                              |> Option.defaultValue []
-            Metadata        = row.stringOrNone              "meta_items"
-                              |> Option.map (Utils.deserialize ser)
-                              |> Option.defaultValue []
-        }
-    
     /// Create a revision from the current row
-    let toRevision (row : RowReader) : Revision =
-        {   AsOf = row.fieldValue<Instant> "as_of"
-            Text = row.string              "revision_text" |> MarkupText.parse
-        }
-    
-    /// Create a tag mapping from the current row
-    let toTagMap (row : RowReader) : TagMap =
-        {   Id       = row.string "id"         |> TagMapId
-            WebLogId = row.string "web_log_id" |> WebLogId
-            Tag      = row.string "tag"
-            UrlValue = row.string "url_value"
-        }
-    
-    /// Create a theme from the current row (excludes templates)
-    let toTheme (row : RowReader) : Theme =
-        { Theme.empty with
-            Id      = row.string "id" |> ThemeId
-            Name    = row.string "name"
-            Version = row.string "version"
-        }
+    let toRevision (row: RowReader) : Revision =
+        { AsOf = row.fieldValue<Instant> "as_of"
+          Text = row.string              "revision_text" |> MarkupText.Parse }
     
     /// Create a theme asset from the current row
-    let toThemeAsset includeData (row : RowReader) : ThemeAsset =
-        {   Id        = ThemeAssetId (ThemeId (row.string "theme_id"), row.string "path")
-            UpdatedOn = row.fieldValue<Instant> "updated_on"
-            Data      = if includeData then row.bytea "data" else [||]
-        }
+    let toThemeAsset includeData (row: RowReader) : ThemeAsset =
+        { Id        = ThemeAssetId (ThemeId (row.string "theme_id"), row.string "path")
+          UpdatedOn = row.fieldValue<Instant> "updated_on"
+          Data      = if includeData then row.bytea "data" else [||] }
     
-    /// Create a theme template from the current row
-    let toThemeTemplate includeText (row : RowReader) : ThemeTemplate =
-        {   Name = row.string "name"
-            Text = if includeText then row.string "template" else ""
-        }
-
     /// Create an uploaded file from the current row
-    let toUpload includeData (row : RowReader) : Upload =
-        {   Id        = row.string              "id"         |> UploadId
-            WebLogId  = row.string              "web_log_id" |> WebLogId
-            Path      = row.string              "path"       |> Permalink
-            UpdatedOn = row.fieldValue<Instant> "updated_on"
-            Data      = if includeData then row.bytea "data" else [||]
-        }
+    let toUpload includeData (row: RowReader) : Upload =
+        { Id        = row.string              "id"         |> UploadId
+          WebLogId  = row.string              "web_log_id" |> WebLogId
+          Path      = row.string              "path"       |> Permalink
+          UpdatedOn = row.fieldValue<Instant> "updated_on"
+          Data      = if includeData then row.bytea "data" else [||] }
+
+/// Document manipulation functions
+module Document =
     
-    /// Create a web log from the current row
-    let toWebLog (row : RowReader) : WebLog =
-        {   Id           = row.string       "id"             |> WebLogId
-            Name         = row.string       "name"
-            Slug         = row.string       "slug"
-            Subtitle     = row.stringOrNone "subtitle"
-            DefaultPage  = row.string       "default_page"
-            PostsPerPage = row.int          "posts_per_page"
-            ThemeId      = row.string       "theme_id"       |> ThemeId
-            UrlBase      = row.string       "url_base"
-            TimeZone     = row.string       "time_zone"
-            AutoHtmx     = row.bool         "auto_htmx"
-            Uploads      = row.string       "uploads"        |> UploadDestination.parse
-            Rss          = {
-                IsFeedEnabled     = row.bool         "is_feed_enabled"
-                FeedName          = row.string       "feed_name"
-                ItemsInFeed       = row.intOrNone    "items_in_feed"
-                IsCategoryEnabled = row.bool         "is_category_enabled"
-                IsTagEnabled      = row.bool         "is_tag_enabled"
-                Copyright         = row.stringOrNone "copyright"
-                CustomFeeds       = []
-            }
-        }
+    /// Determine whether a document exists with the given key for the given web log
+    let existsByWebLog<'TKey> table (key: 'TKey) webLogId =
+        Custom.scalar
+            $"""SELECT EXISTS (
+                    SELECT 1 FROM %s{table} WHERE {Query.whereById "@id"} AND {Query.whereDataContains "@criteria"}
+                    ) AS it"""
+            [ "@id", Sql.string (string key); webLogContains webLogId ]
+            toExists
     
-    /// Create a web log user from the current row
-    let toWebLogUser (row : RowReader) : WebLogUser =
-        {   Id            = row.string                    "id"             |> WebLogUserId
-            WebLogId      = row.string                    "web_log_id"     |> WebLogId
-            Email         = row.string                    "email"
-            FirstName     = row.string                    "first_name"
-            LastName      = row.string                    "last_name"
-            PreferredName = row.string                    "preferred_name"
-            PasswordHash  = row.string                    "password_hash"
-            Url           = row.stringOrNone              "url"
-            AccessLevel   = row.string                    "access_level"   |> AccessLevel.parse
-            CreatedOn     = row.fieldValue<Instant>       "created_on"
-            LastSeenOn    = row.fieldValueOrNone<Instant> "last_seen_on"
-        }
+    /// Find a document by its ID for the given web log
+    let findByIdAndWebLog<'TKey, 'TDoc> table (key: 'TKey) webLogId =
+        Custom.single
+            $"""{Query.find table} WHERE {Query.whereById "@id"} AND {Query.whereDataContains "@criteria"}"""
+            [ "@id", Sql.string (string key); webLogContains webLogId ]
+            fromData<'TDoc>
+
+
+/// Functions to support revisions
+module Revisions =
+    
+    /// Find all revisions for the given entity
+    let findByEntityId<'TKey> revTable entityTable (key: 'TKey) =
+        Custom.list
+            $"SELECT as_of, revision_text FROM %s{revTable} WHERE %s{entityTable}_id = @id ORDER BY as_of DESC"
+            [ "@id", Sql.string (string key) ]
+            Map.toRevision
+    
+    /// Find all revisions for all posts for the given web log
+    let findByWebLog<'TKey> revTable entityTable (keyFunc: string -> 'TKey) webLogId =
+        Custom.list
+            $"""SELECT pr.*
+                  FROM %s{revTable} pr
+                       INNER JOIN %s{entityTable} p ON p.data->>'{nameof Post.Empty.Id}' = pr.{entityTable}_id
+                 WHERE p.{Query.whereDataContains "@criteria"}
+                 ORDER BY as_of DESC"""
+            [ webLogContains webLogId ]
+            (fun row -> keyFunc (row.string $"{entityTable}_id"), Map.toRevision row)
+
+    /// Parameters for a revision INSERT statement
+    let revParams<'TKey> (key: 'TKey) rev = [
+        typedParam "asOf" rev.AsOf
+        "@id",   Sql.string (string key)
+        "@text", Sql.string (string rev.Text)
+    ]
+    
+    /// The SQL statement to insert a revision
+    let insertSql table =
+        $"INSERT INTO %s{table} VALUES (@id, @asOf, @text)"
+    
+    /// Update a page's revisions
+    let update<'TKey> revTable entityTable (key: 'TKey) oldRevs newRevs = backgroundTask {
+        let toDelete, toAdd = Utils.diffRevisions oldRevs newRevs
+        if not (List.isEmpty toDelete) || not (List.isEmpty toAdd) then
+            let! _ =
+                Configuration.dataSource ()
+                |> Sql.fromDataSource
+                |> Sql.executeTransactionAsync
+                    [ if not (List.isEmpty toDelete) then
+                        $"DELETE FROM %s{revTable} WHERE %s{entityTable}_id = @id AND as_of = @asOf",
+                        toDelete
+                        |> List.map (fun it ->
+                            [ "@id", Sql.string (string key)
+                              typedParam "asOf" it.AsOf ])
+                      if not (List.isEmpty toAdd) then
+                        insertSql revTable, toAdd |> List.map (revParams key) ]
+            ()
+    }

src/MyWebLog.Data/Postgres/PostgresPageData.fs

@@ -1,167 +1,130 @@
 namespace MyWebLog.Data.Postgres
 
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Newtonsoft.Json
-open Npgsql
 open Npgsql.FSharp
 
-/// PostgreSQL myWebLog page data implementation        
-type PostgresPageData (conn : NpgsqlConnection, ser : JsonSerializer) =
+/// PostgreSQL myWebLog page data implementation
+type PostgresPageData(log: ILogger) =
     
     // SUPPORT FUNCTIONS
     
-    /// Append revisions and permalinks to a page
-    let appendPageRevisions (page : Page) = backgroundTask {
-        let! revisions =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT as_of, revision_text FROM page_revision WHERE page_id = @pageId ORDER BY as_of DESC"
-            |> Sql.parameters [ "@pageId", Sql.string (PageId.toString page.Id) ]
-            |> Sql.executeAsync Map.toRevision
+    /// Append revisions to a page
+    let appendPageRevisions (page: Page) = backgroundTask {
+        log.LogTrace "Page.appendPageRevisions"
+        let! revisions = Revisions.findByEntityId Table.PageRevision Table.Page page.Id
         return { page with Revisions = revisions }
     }
     
-    /// Shorthand to map to a page
-    let toPage = Map.toPage ser
-    
     /// Return a page with no text or revisions
-    let pageWithoutText row =
-        { toPage row with Text = "" }
-    
-    /// The INSERT statement for a page revision
-    let revInsert = "INSERT INTO page_revision VALUES (@pageId, @asOf, @text)"
-    
-    /// Parameters for a revision INSERT statement
-    let revParams pageId rev = [
-        typedParam "asOf" rev.AsOf
-        "@pageId", Sql.string (PageId.toString pageId)
-        "@text",   Sql.string (MarkupText.toString rev.Text)
-    ]
+    let pageWithoutText (row: RowReader) =
+        { fromData<Page> row with Text = "" }
     
     /// Update a page's revisions
-    let updatePageRevisions pageId oldRevs newRevs = backgroundTask {
-        let toDelete, toAdd = Utils.diffRevisions oldRevs newRevs
-        if not (List.isEmpty toDelete) || not (List.isEmpty toAdd) then
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.executeTransactionAsync [
-                    if not (List.isEmpty toDelete) then
-                        "DELETE FROM page_revision WHERE page_id = @pageId AND as_of = @asOf",
-                        toDelete
-                        |> List.map (fun it -> [
-                            "@pageId", Sql.string (PageId.toString pageId)
-                            typedParam "asOf" it.AsOf
-                        ])
-                    if not (List.isEmpty toAdd) then
-                        revInsert, toAdd |> List.map (revParams pageId)
-                ]
-            ()
-    }
+    let updatePageRevisions (pageId: PageId) oldRevs newRevs =
+        log.LogTrace "Page.updatePageRevisions"
+        Revisions.update Table.PageRevision Table.Page pageId oldRevs newRevs
     
     /// Does the given page exist?
-    let pageExists pageId webLogId =
-        Sql.existingConnection conn
-        |> Sql.query $"SELECT EXISTS (SELECT 1 FROM page WHERE id = @id AND web_log_id = @webLogId) AS {existsName}"
-        |> Sql.parameters [ "@id", Sql.string (PageId.toString pageId); webLogIdParam webLogId ]
-        |> Sql.executeRowAsync Map.toExists
+    let pageExists (pageId: PageId) webLogId =
+        log.LogTrace "Page.pageExists"
+        Document.existsByWebLog Table.Page pageId webLogId
     
+    /// The query to get all pages ordered by title
+    let sortedPages =
+        selectWithCriteria Table.Page + Query.orderBy [ Field.Named $"i:{nameof Page.Empty.Title}" ] PostgreSQL
+        
     // IMPLEMENTATION FUNCTIONS
     
-    /// Get all pages for a web log (without text, revisions, prior permalinks, or metadata)
+    /// Add a page
+    let add (page: Page) = backgroundTask {
+        log.LogTrace "Page.add"
+        do! insert Table.Page { page with Revisions = [] }
+        do! updatePageRevisions page.Id [] page.Revisions
+        ()
+    }
+    
+    /// Get all pages for a web log (without text, metadata, revisions, or prior permalinks)
     let all webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM page WHERE web_log_id = @webLogId ORDER BY LOWER(title)"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeAsync pageWithoutText
+        log.LogTrace "Page.all"
+        Custom.list
+            sortedPages
+            [ webLogContains webLogId ]
+            (fun row -> { fromData<Page> row with Text = ""; Metadata = []; PriorPermalinks = [] }) 
     
     /// Count all pages for the given web log
     let countAll webLogId =
-        Sql.existingConnection conn
-        |> Sql.query $"SELECT COUNT(id) AS {countName} FROM page WHERE web_log_id = @webLogId"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeRowAsync Map.toCount
+        log.LogTrace "Page.countAll"
+        Count.byContains Table.Page (webLogDoc webLogId)
     
     /// Count all pages shown in the page list for the given web log
     let countListed webLogId =
-        Sql.existingConnection conn
-        |> Sql.query $"
-            SELECT COUNT(id) AS {countName}
-              FROM page
-             WHERE web_log_id      = @webLogId
-               AND is_in_page_list = TRUE"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeRowAsync Map.toCount
+        log.LogTrace "Page.countListed"
+        Count.byContains Table.Page {| webLogDoc webLogId with IsInPageList = true |}
     
-    /// Find a page by its ID (without revisions)
-    let findById pageId webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM page WHERE id = @id AND web_log_id = @webLogId"
-        |> Sql.parameters [ "@id", Sql.string (PageId.toString pageId); webLogIdParam webLogId ]
-        |> Sql.executeAsync toPage
-        |> tryHead
+    /// Find a page by its ID (without revisions or prior permalinks)
+    let findById pageId webLogId = backgroundTask {
+        log.LogTrace "Page.findById"
+        match! Document.findByIdAndWebLog<PageId, Page> Table.Page pageId webLogId with
+        | Some page -> return Some { page with PriorPermalinks = [] }
+        | None -> return None
+    }
     
     /// Find a complete page by its ID
     let findFullById pageId webLogId = backgroundTask {
-        match! findById pageId webLogId with
+        log.LogTrace "Page.findFullById"
+        match! Document.findByIdAndWebLog<PageId, Page> Table.Page pageId webLogId with
         | Some page ->
             let! withMore = appendPageRevisions page
             return Some withMore
         | None -> return None
     }
     
+    // TODO: need to handle when the page being deleted is the home page
     /// Delete a page by its ID
     let delete pageId webLogId = backgroundTask {
+        log.LogTrace "Page.delete"
         match! pageExists pageId webLogId with
         | true ->
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.query
-                    "DELETE FROM page_revision WHERE page_id = @id;
-                     DELETE FROM page          WHERE id      = @id"
-                |> Sql.parameters [ "@id", Sql.string (PageId.toString pageId) ]
-                |> Sql.executeNonQueryAsync
+            do! Custom.nonQuery
+                    $"""{Query.delete Table.PageRevision} WHERE page_id = @id;
+                        {Query.delete Table.Page}         WHERE {Query.whereById "@id"}"""
+                    [ idParam pageId ]
             return true
         | false -> return false
     }
     
     /// Find a page by its permalink for the given web log
-    let findByPermalink permalink webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM page WHERE web_log_id = @webLogId AND permalink = @link"
-        |> Sql.parameters [ webLogIdParam webLogId; "@link", Sql.string (Permalink.toString permalink) ]
-        |> Sql.executeAsync toPage
-        |> tryHead
+    let findByPermalink (permalink: Permalink) webLogId = backgroundTask {
+        log.LogTrace "Page.findByPermalink"
+        let! page =
+            Find.byContains<Page> Table.Page {| webLogDoc webLogId with Permalink = permalink |}
+            |> tryHead
+        return page |> Option.map (fun pg -> { pg with PriorPermalinks = [] })
+    }
     
     /// Find the current permalink within a set of potential prior permalinks for the given web log
-    let findCurrentPermalink permalinks webLogId = backgroundTask {
+    let findCurrentPermalink (permalinks: Permalink list) webLogId = backgroundTask {
+        log.LogTrace "Page.findCurrentPermalink"
         if List.isEmpty permalinks then return None
         else
-            let linkSql, linkParams = arrayInClause "prior_permalinks" Permalink.toString permalinks
-            return!
-                Sql.existingConnection conn
-                |> Sql.query $"SELECT permalink FROM page WHERE web_log_id = @webLogId AND ({linkSql})"
-                |> Sql.parameters (webLogIdParam webLogId :: linkParams)
-                |> Sql.executeAsync Map.toPermalink
-                |> tryHead
+            let linkField = Field.InArray (nameof Page.Empty.PriorPermalinks) Table.Page (List.map string permalinks)
+            let query =
+                (Query.statementWhere
+                     (Query.find Table.Page)
+                     $"""{Query.whereDataContains "@criteria"} AND {Query.whereByFields All [ linkField ]}""")
+                    .Replace("SELECT data", $"SELECT data->>'{nameof Page.Empty.Permalink}' AS permalink")
+            return! Custom.single query (addFieldParams [ linkField ] [ webLogContains webLogId ]) Map.toPermalink
     }
     
     /// Get all complete pages for the given web log
     let findFullByWebLog webLogId = backgroundTask {
-        let! pages =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT * FROM page WHERE web_log_id = @webLogId"
-            |> Sql.parameters [ webLogIdParam webLogId ]
-            |> Sql.executeAsync toPage
-        let! revisions =
-            Sql.existingConnection conn
-            |> Sql.query
-                "SELECT *
-                   FROM page_revision pr
-                        INNER JOIN page p ON p.id = pr.page_id
-                  WHERE p.web_log_id = @webLogId
-                  ORDER BY pr.as_of DESC"
-            |> Sql.parameters [ webLogIdParam webLogId ]
-            |> Sql.executeAsync (fun row -> PageId (row.string "page_id"), Map.toRevision row)
+        log.LogTrace "Page.findFullByWebLog"
+        let! pages     = Find.byContains<Page> Table.Page (webLogDoc webLogId)
+        let! revisions = Revisions.findByWebLog Table.PageRevision Table.Page PageId webLogId 
         return
             pages
             |> List.map (fun it ->
@@ -170,101 +133,56 @@ type PostgresPageData (conn : NpgsqlConnection, ser : JsonSerializer) =
     
     /// Get all listed pages for the given web log (without revisions or text)
     let findListed webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM page WHERE web_log_id = @webLogId AND is_in_page_list = TRUE ORDER BY LOWER(title)"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeAsync pageWithoutText
+        log.LogTrace "Page.findListed"
+        Custom.list
+            sortedPages [ jsonParam "@criteria" {| webLogDoc webLogId with IsInPageList = true |} ] pageWithoutText
     
     /// Get a page of pages for the given web log (without revisions)
     let findPageOfPages webLogId pageNbr =
-        Sql.existingConnection conn
-        |> Sql.query
-            "SELECT *
-               FROM page
-              WHERE web_log_id = @webLogId
-              ORDER BY LOWER(title)
-              LIMIT @pageSize OFFSET @toSkip"
-        |> Sql.parameters [ webLogIdParam webLogId; "@pageSize", Sql.int 26; "@toSkip", Sql.int ((pageNbr - 1) * 25) ]
-        |> Sql.executeAsync toPage
+        log.LogTrace "Page.findPageOfPages"
+        Custom.list
+            $"{sortedPages} LIMIT @pageSize OFFSET @toSkip"
+            [ webLogContains webLogId; "@pageSize", Sql.int 26; "@toSkip", Sql.int ((pageNbr - 1) * 25) ]
+            (fun row -> { fromData<Page> row with Metadata = []; PriorPermalinks = [] })
     
-    /// The INSERT statement for a page
-    let pageInsert =
-        "INSERT INTO page (
-            id, web_log_id, author_id, title, permalink, prior_permalinks, published_on, updated_on, is_in_page_list,
-            template, page_text, meta_items
-        ) VALUES (
-            @id, @webLogId, @authorId, @title, @permalink, @priorPermalinks, @publishedOn, @updatedOn, @isInPageList,
-            @template, @text, @metaItems
-        )"
-    
-    /// The parameters for saving a page
-    let pageParams (page : Page) = [
-        webLogIdParam page.WebLogId
-        "@id",              Sql.string       (PageId.toString page.Id)
-        "@authorId",        Sql.string       (WebLogUserId.toString page.AuthorId)
-        "@title",           Sql.string       page.Title
-        "@permalink",       Sql.string       (Permalink.toString page.Permalink)
-        "@isInPageList",    Sql.bool         page.IsInPageList
-        "@template",        Sql.stringOrNone page.Template
-        "@text",            Sql.string       page.Text
-        "@metaItems",       Sql.jsonb        (Utils.serialize ser page.Metadata)
-        "@priorPermalinks", Sql.stringArray  (page.PriorPermalinks |> List.map Permalink.toString |> Array.ofList)
-        typedParam "publishedOn" page.PublishedOn
-        typedParam "updatedOn"   page.UpdatedOn
-    ]
-
     /// Restore pages from a backup
-    let restore (pages : Page list) = backgroundTask {
+    let restore (pages: Page list) = backgroundTask {
+        log.LogTrace "Page.restore"
         let revisions = pages |> List.collect (fun p -> p.Revisions |> List.map (fun r -> p.Id, r))
         let! _ =
-            Sql.existingConnection conn
-            |> Sql.executeTransactionAsync [
-                pageInsert, pages     |> List.map pageParams
-                revInsert,  revisions |> List.map (fun (pageId, rev) -> revParams pageId rev)
-            ]
+            Configuration.dataSource ()
+            |> Sql.fromDataSource
+            |> Sql.executeTransactionAsync
+                [ Query.insert Table.Page,
+                    pages |> List.map (fun page -> [ jsonParam "@data" { page with Revisions = [] } ])
+                  Revisions.insertSql Table.PageRevision,
+                    revisions |> List.map (fun (pageId, rev) -> Revisions.revParams pageId rev) ]
         ()
     }
     
-    /// Save a page
-    let save (page : Page) = backgroundTask {
-        let! oldPage = findFullById page.Id page.WebLogId
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query $"
-                {pageInsert} ON CONFLICT (id) DO UPDATE
-                SET author_id        = EXCLUDED.author_id,
-                    title            = EXCLUDED.title,
-                    permalink        = EXCLUDED.permalink,
-                    prior_permalinks = EXCLUDED.prior_permalinks,
-                    published_on     = EXCLUDED.published_on,
-                    updated_on       = EXCLUDED.updated_on,
-                    is_in_page_list  = EXCLUDED.is_in_page_list,
-                    template         = EXCLUDED.template,
-                    page_text        = EXCLUDED.page_text,
-                    meta_items       = EXCLUDED.meta_items"
-            |> Sql.parameters (pageParams page)
-            |> Sql.executeNonQueryAsync
-        do! updatePageRevisions page.Id (match oldPage with Some p -> p.Revisions | None -> []) page.Revisions
+    /// Update a page
+    let update (page: Page) = backgroundTask {
+        log.LogTrace "Page.update"
+        match! findFullById page.Id page.WebLogId with
+        | Some oldPage ->
+            do! Update.byId Table.Page page.Id { page with Revisions = [] }
+            do! updatePageRevisions page.Id oldPage.Revisions page.Revisions
+        | None -> ()
         ()
     }
     
     /// Update a page's prior permalinks
-    let updatePriorPermalinks pageId webLogId permalinks = backgroundTask {
+    let updatePriorPermalinks pageId webLogId (permalinks: Permalink list) = backgroundTask {
+        log.LogTrace "Page.updatePriorPermalinks"
         match! pageExists pageId webLogId with
         | true ->
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.query "UPDATE page SET prior_permalinks = @prior WHERE id = @id"
-                |> Sql.parameters
-                    [   "@id",    Sql.string      (PageId.toString pageId)
-                        "@prior", Sql.stringArray (permalinks |> List.map Permalink.toString |> Array.ofList) ]
-                |> Sql.executeNonQueryAsync
+            do! Patch.byId Table.Page pageId {| PriorPermalinks = permalinks |}
             return true
         | false -> return false
     }
     
     interface IPageData with
-        member _.Add page = save page
+        member _.Add page = add page
         member _.All webLogId = all webLogId
         member _.CountAll webLogId = countAll webLogId
         member _.CountListed webLogId = countListed webLogId
@@ -277,5 +195,5 @@ type PostgresPageData (conn : NpgsqlConnection, ser : JsonSerializer) =
         member _.FindListed webLogId = findListed webLogId
         member _.FindPageOfPages webLogId pageNbr = findPageOfPages webLogId pageNbr
         member _.Restore pages = restore pages
-        member _.Update page = save page
+        member _.Update page = update page
         member _.UpdatePriorPermalinks pageId webLogId permalinks = updatePriorPermalinks pageId webLogId permalinks

src/MyWebLog.Data/Postgres/PostgresPostData.fs

@@ -1,129 +1,77 @@
 namespace MyWebLog.Data.Postgres
 
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Newtonsoft.Json
 open NodaTime
-open Npgsql
 open Npgsql.FSharp
 
-/// PostgreSQL myWebLog post data implementation        
-type PostgresPostData (conn : NpgsqlConnection, ser : JsonSerializer) =
+/// PostgreSQL myWebLog post data implementation
+type PostgresPostData(log: ILogger) =
 
     // SUPPORT FUNCTIONS
     
     /// Append revisions to a post
-    let appendPostRevisions (post : Post) = backgroundTask {
-        let! revisions =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT as_of, revision_text FROM post_revision WHERE post_id = @id ORDER BY as_of DESC"
-            |> Sql.parameters [ "@id", Sql.string (PostId.toString post.Id) ]
-            |> Sql.executeAsync Map.toRevision
+    let appendPostRevisions (post: Post) = backgroundTask {
+        log.LogTrace "Post.appendPostRevisions"
+        let! revisions = Revisions.findByEntityId Table.PostRevision Table.Post post.Id
         return { post with Revisions = revisions }
     }
     
-    /// The SELECT statement for a post that will include category IDs
-    let selectPost =
-        "SELECT *, ARRAY(SELECT cat.category_id FROM post_category cat WHERE cat.post_id = p.id) AS category_ids
-           FROM post p"
-    
-    /// Shorthand for mapping to a post
-    let toPost = Map.toPost ser
+    /// Return a post with no revisions or prior permalinks
+    let postWithoutLinks row =
+        { fromData<Post> row with PriorPermalinks = [] }
     
     /// Return a post with no revisions, prior permalinks, or text
     let postWithoutText row =
-        { toPost row with Text = "" }
-    
-    /// The INSERT statement for a post/category cross-reference
-    let catInsert = "INSERT INTO post_category VALUES (@postId, @categoryId)"
-    
-    /// Parameters for adding or updating a post/category cross-reference
-    let catParams postId cat = [
-        "@postId",    Sql.string (PostId.toString postId)
-        "categoryId", Sql.string (CategoryId.toString cat)
-    ]
-    
-    /// Update a post's assigned categories
-    let updatePostCategories postId oldCats newCats = backgroundTask {
-        let toDelete, toAdd = Utils.diffLists oldCats newCats CategoryId.toString
-        if not (List.isEmpty toDelete) || not (List.isEmpty toAdd) then
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.executeTransactionAsync [
-                    if not (List.isEmpty toDelete) then
-                        "DELETE FROM post_category WHERE post_id = @postId AND category_id = @categoryId",
-                        toDelete |> List.map (catParams postId)
-                    if not (List.isEmpty toAdd) then
-                        catInsert, toAdd |> List.map (catParams postId)
-                ]
-            ()
-    }
-    
-    /// The INSERT statement for a post revision
-    let revInsert = "INSERT INTO post_revision VALUES (@postId, @asOf, @text)"
-    
-    /// The parameters for adding a post revision
-    let revParams postId rev = [
-        typedParam "asOf" rev.AsOf
-        "@postId", Sql.string (PostId.toString postId)
-        "@text",   Sql.string (MarkupText.toString rev.Text)
-    ]
+        { postWithoutLinks row with Text = "" }
     
     /// Update a post's revisions
-    let updatePostRevisions postId oldRevs newRevs = backgroundTask {
-        let toDelete, toAdd = Utils.diffRevisions oldRevs newRevs
-        if not (List.isEmpty toDelete) || not (List.isEmpty toAdd) then
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.executeTransactionAsync [
-                    if not (List.isEmpty toDelete) then
-                        "DELETE FROM post_revision WHERE post_id = @postId AND as_of = @asOf",
-                        toDelete
-                        |> List.map (fun it -> [
-                            "@postId", Sql.string (PostId.toString postId)
-                            typedParam "asOf" it.AsOf
-                        ])
-                    if not (List.isEmpty toAdd) then
-                        revInsert, toAdd |> List.map (revParams postId)
-                ]
-            ()
-    }
+    let updatePostRevisions (postId: PostId) oldRevs newRevs =
+        log.LogTrace "Post.updatePostRevisions"
+        Revisions.update Table.PostRevision Table.Post postId oldRevs newRevs
     
     /// Does the given post exist?
-    let postExists postId webLogId =
-        Sql.existingConnection conn
-        |> Sql.query $"SELECT EXISTS (SELECT 1 FROM post WHERE id = @id AND web_log_id = @webLogId) AS {existsName}"
-        |> Sql.parameters [ "@id", Sql.string (PostId.toString postId); webLogIdParam webLogId ]
-        |> Sql.executeRowAsync Map.toExists
+    let postExists (postId: PostId) webLogId =
+        log.LogTrace "Post.postExists"
+        Document.existsByWebLog Table.Post postId webLogId
     
     // IMPLEMENTATION FUNCTIONS
     
+    /// Add a post
+    let add (post : Post) = backgroundTask {
+        log.LogTrace "Post.add"
+        do! insert Table.Post { post with Revisions = [] }
+        do! updatePostRevisions post.Id [] post.Revisions
+    }
+    
     /// Count posts in a status for the given web log
-    let countByStatus status webLogId =
-        Sql.existingConnection conn
-        |> Sql.query $"SELECT COUNT(id) AS {countName} FROM post WHERE web_log_id = @webLogId AND status = @status"
-        |> Sql.parameters [ webLogIdParam webLogId; "@status", Sql.string (PostStatus.toString status) ]
-        |> Sql.executeRowAsync Map.toCount
+    let countByStatus (status: PostStatus) webLogId =
+        log.LogTrace "Post.countByStatus"
+        Count.byContains Table.Post {| webLogDoc webLogId with Status = status |}
     
     /// Find a post by its ID for the given web log (excluding revisions)
-    let findById postId webLogId = 
-        Sql.existingConnection conn
-        |> Sql.query $"{selectPost} WHERE id = @id AND web_log_id = @webLogId"
-        |> Sql.parameters [ "@id", Sql.string (PostId.toString postId); webLogIdParam webLogId ]
-        |> Sql.executeAsync toPost
-        |> tryHead
+    let findById postId webLogId = backgroundTask {
+        log.LogTrace "Post.findById"
+        match! Document.findByIdAndWebLog<PostId, Post> Table.Post postId webLogId with
+        | Some post -> return Some { post with PriorPermalinks = [] }
+        | None -> return None
+    }
     
-    /// Find a post by its permalink for the given web log (excluding revisions and prior permalinks)
-    let findByPermalink permalink webLogId =
-        Sql.existingConnection conn
-        |> Sql.query $"{selectPost} WHERE web_log_id = @webLogId AND permalink = @link"
-        |> Sql.parameters [ webLogIdParam webLogId; "@link", Sql.string (Permalink.toString permalink) ]
-        |> Sql.executeAsync toPost
-        |> tryHead
+    /// Find a post by its permalink for the given web log (excluding revisions)
+    let findByPermalink (permalink: Permalink) webLogId =
+        log.LogTrace "Post.findByPermalink"
+        Custom.single
+            (selectWithCriteria Table.Post)
+            [ jsonParam "@criteria" {| webLogDoc webLogId with Permalink = permalink |} ]
+            postWithoutLinks
     
     /// Find a complete post by its ID for the given web log
     let findFullById postId webLogId = backgroundTask {
-        match! findById postId webLogId with
+        log.LogTrace "Post.findFullById"
+        match! Document.findByIdAndWebLog<PostId, Post> Table.Post postId webLogId with
         | Some post ->
             let! withRevisions = appendPostRevisions post
             return Some withRevisions
@@ -132,50 +80,37 @@ type PostgresPostData (conn : NpgsqlConnection, ser : JsonSerializer) =
     
     /// Delete a post by its ID for the given web log
     let delete postId webLogId = backgroundTask {
+        log.LogTrace "Post.delete"
         match! postExists postId webLogId with
         | true ->
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.query
-                    "DELETE FROM post_revision WHERE post_id = @id;
-                     DELETE FROM post_category WHERE post_id = @id;
-                     DELETE FROM post          WHERE id      = @id"
-                |> Sql.parameters [ "@id", Sql.string (PostId.toString postId) ]
-                |> Sql.executeNonQueryAsync
+            do! Custom.nonQuery
+                    $"""{Query.delete Table.PostComment}  WHERE {Query.whereDataContains "@criteria"};
+                        {Query.delete Table.PostRevision} WHERE post_id = @id;
+                        {Query.delete Table.Post}         WHERE {Query.whereById "@id"}"""
+                    [ idParam postId; jsonParam "@criteria" {| PostId = postId |} ]
             return true
         | false -> return false
     }
     
     /// Find the current permalink from a list of potential prior permalinks for the given web log
-    let findCurrentPermalink permalinks webLogId = backgroundTask {
+    let findCurrentPermalink (permalinks: Permalink list) webLogId = backgroundTask {
+        log.LogTrace "Post.findCurrentPermalink"
         if List.isEmpty permalinks then return None
         else
-            let linkSql, linkParams = arrayInClause "prior_permalinks" Permalink.toString permalinks
-            return!
-                Sql.existingConnection conn
-                |> Sql.query $"SELECT permalink FROM post WHERE web_log_id = @webLogId AND ({linkSql})"
-                |> Sql.parameters (webLogIdParam webLogId :: linkParams)
-                |> Sql.executeAsync Map.toPermalink
-                |> tryHead
+            let linkField = Field.InArray (nameof Post.Empty.PriorPermalinks) Table.Post (List.map string permalinks)
+            let query =
+                (Query.statementWhere
+                     (Query.find Table.Post)
+                     $"""{Query.whereDataContains "@criteria"} AND {Query.whereByFields All [ linkField ]}""")
+                    .Replace("SELECT data", $"SELECT data->>'{nameof Post.Empty.Permalink}' AS permalink")
+            return! Custom.single query (addFieldParams [ linkField ] [ webLogContains webLogId ]) Map.toPermalink
     }
     
     /// Get all complete posts for the given web log
     let findFullByWebLog webLogId = backgroundTask {
-        let! posts =
-            Sql.existingConnection conn
-            |> Sql.query $"{selectPost} WHERE web_log_id = @webLogId"
-            |> Sql.parameters [ webLogIdParam webLogId ]
-            |> Sql.executeAsync toPost
-        let! revisions =
-            Sql.existingConnection conn
-            |> Sql.query
-                "SELECT *
-                   FROM post_revision pr
-                        INNER JOIN post p ON p.id = pr.post_id
-                  WHERE p.web_log_id = @webLogId
-                  ORDER BY as_of DESC"
-            |> Sql.parameters [ webLogIdParam webLogId ]
-            |> Sql.executeAsync (fun row -> PostId (row.string "post_id"), Map.toRevision row)
+        log.LogTrace "Post.findFullByWebLog"
+        let! posts     = Find.byContains<Post> Table.Post (webLogDoc webLogId)
+        let! revisions = Revisions.findByWebLog Table.PostRevision Table.Post PostId webLogId
         return
             posts
             |> List.map (fun it ->
@@ -183,181 +118,105 @@ type PostgresPostData (conn : NpgsqlConnection, ser : JsonSerializer) =
     }
     
     /// Get a page of categorized posts for the given web log (excludes revisions)
-    let findPageOfCategorizedPosts webLogId categoryIds pageNbr postsPerPage =
-        let catSql, catParams = inClause "AND pc.category_id" "catId" CategoryId.toString categoryIds
-        Sql.existingConnection conn
-        |> Sql.query $"
-            {selectPost}
-                   INNER JOIN post_category pc ON pc.post_id = p.id
-             WHERE p.web_log_id = @webLogId
-               AND p.status     = @status
-               {catSql}
-             ORDER BY published_on DESC
-             LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
-        |> Sql.parameters
-            [   webLogIdParam webLogId
-                "@status", Sql.string (PostStatus.toString Published)
-                yield! catParams   ]
-        |> Sql.executeAsync toPost
+    let findPageOfCategorizedPosts webLogId (categoryIds: CategoryId list) pageNbr postsPerPage =
+        log.LogTrace "Post.findPageOfCategorizedPosts"
+        let catIdField = Field.InArray (nameof Post.Empty.CategoryIds) Table.Post (List.map string categoryIds)
+        Custom.list
+            $"""{selectWithCriteria Table.Post}
+                  AND {Query.whereByFields All [ catIdField ]}
+                {Query.orderBy [ Field.Named $"{nameof Post.Empty.PublishedOn} DESC" ] PostgreSQL}
+                LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
+            (addFieldParams [ catIdField] [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |} ])
+            postWithoutLinks
     
     /// Get a page of posts for the given web log (excludes text and revisions)
     let findPageOfPosts webLogId pageNbr postsPerPage =
-        Sql.existingConnection conn
-        |> Sql.query $"
-            {selectPost}
-             WHERE web_log_id = @webLogId
-             ORDER BY published_on DESC NULLS FIRST, updated_on
-             LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeAsync postWithoutText
+        log.LogTrace "Post.findPageOfPosts"
+        let order =
+            Query.orderBy
+                [ Field.Named $"{nameof Post.Empty.PublishedOn} DESC NULLS FIRST"
+                  Field.Named (nameof Post.Empty.UpdatedOn) ]
+                PostgreSQL
+        Custom.list
+            $"{selectWithCriteria Table.Post}{order}
+              LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
+            [ webLogContains webLogId ]
+            postWithoutText
     
     /// Get a page of published posts for the given web log (excludes revisions)
     let findPageOfPublishedPosts webLogId pageNbr postsPerPage =
-        Sql.existingConnection conn
-        |> Sql.query $"
-            {selectPost}
-             WHERE web_log_id = @webLogId
-               AND status     = @status
-             ORDER BY published_on DESC
-             LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
-        |> Sql.parameters [ webLogIdParam webLogId; "@status", Sql.string (PostStatus.toString Published) ]
-        |> Sql.executeAsync toPost
+        log.LogTrace "Post.findPageOfPublishedPosts"
+        Custom.list
+            $"""{selectWithCriteria Table.Post}
+                {Query.orderBy [ Field.Named $"{nameof Post.Empty.PublishedOn} DESC" ] PostgreSQL}
+                LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
+            [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |} ]
+            postWithoutLinks
     
     /// Get a page of tagged posts for the given web log (excludes revisions and prior permalinks)
-    let findPageOfTaggedPosts webLogId (tag : string) pageNbr postsPerPage =
-        Sql.existingConnection conn
-        |> Sql.query $"
-            {selectPost}
-             WHERE web_log_id =  @webLogId
-               AND status     =  @status
-               AND tags       && ARRAY[@tag]
-             ORDER BY published_on DESC
-             LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
-        |> Sql.parameters
-            [   webLogIdParam webLogId
-                "@status", Sql.string (PostStatus.toString Published)
-                "@tag",    Sql.string tag
-            ]
-        |> Sql.executeAsync toPost
+    let findPageOfTaggedPosts webLogId (tag: string) pageNbr postsPerPage =
+        log.LogTrace "Post.findPageOfTaggedPosts"
+        Custom.list
+            $"""{selectWithCriteria Table.Post}
+                  AND data['{nameof Post.Empty.Tags}'] @> @tag
+                {Query.orderBy [ Field.Named $"{nameof Post.Empty.PublishedOn} DESC" ] PostgreSQL}
+                LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
+            [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |}; jsonParam "@tag" [| tag |] ]
+            postWithoutLinks
     
     /// Find the next newest and oldest post from a publish date for the given web log
-    let findSurroundingPosts webLogId (publishedOn : Instant) = backgroundTask {
-        let queryParams () = Sql.parameters [
-            webLogIdParam webLogId
-            typedParam "publishedOn" publishedOn
-            "@status", Sql.string (PostStatus.toString Published)
-        ]
-        let! older =
-            Sql.existingConnection conn
-            |> Sql.query $"
-                {selectPost}
-                 WHERE web_log_id   = @webLogId
-                   AND status       = @status
-                   AND published_on < @publishedOn
-                 ORDER BY published_on DESC
-                 LIMIT 1"
-            |> queryParams ()
-            |> Sql.executeAsync toPost
-        let! newer =
-            Sql.existingConnection conn
-            |> Sql.query $"
-                {selectPost}
-                 WHERE web_log_id   = @webLogId
-                   AND status       = @status
-                   AND published_on > @publishedOn
-                 ORDER BY published_on
-                 LIMIT 1"
-            |> queryParams ()
-            |> Sql.executeAsync toPost
+    let findSurroundingPosts webLogId (publishedOn: Instant) = backgroundTask {
+        log.LogTrace "Post.findSurroundingPosts"
+        let queryParams () =
+            [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |}
+              "@publishedOn", Sql.timestamptz (publishedOn.ToDateTimeOffset()) ]
+        let query op direction =
+            $"""{selectWithCriteria Table.Post}
+                  AND (data->>'{nameof Post.Empty.PublishedOn}')::timestamp with time zone %s{op} @publishedOn
+                {Query.orderBy [ Field.Named $"{nameof Post.Empty.PublishedOn} %s{direction}" ] PostgreSQL} 
+                LIMIT 1"""
+        let! older = Custom.list (query "<" "DESC") (queryParams ()) postWithoutLinks
+        let! newer = Custom.list (query ">" "")     (queryParams ()) postWithoutLinks
         return List.tryHead older, List.tryHead newer
     }
     
-    /// The INSERT statement for a post
-    let postInsert =
-        "INSERT INTO post (
-            id, web_log_id, author_id, status, title, permalink, prior_permalinks, published_on, updated_on,
-            template, post_text, tags, meta_items, episode
-        ) VALUES (
-            @id, @webLogId, @authorId, @status, @title, @permalink, @priorPermalinks, @publishedOn, @updatedOn,
-            @template, @text, @tags, @metaItems, @episode
-        )"
-    
-    /// The parameters for saving a post
-    let postParams (post : Post) = [
-        webLogIdParam post.WebLogId
-        "@id",              Sql.string       (PostId.toString post.Id)
-        "@authorId",        Sql.string       (WebLogUserId.toString post.AuthorId)
-        "@status",          Sql.string       (PostStatus.toString post.Status)
-        "@title",           Sql.string       post.Title
-        "@permalink",       Sql.string       (Permalink.toString post.Permalink)
-        "@template",        Sql.stringOrNone post.Template
-        "@text",            Sql.string       post.Text
-        "@priorPermalinks", Sql.stringArray  (post.PriorPermalinks |> List.map Permalink.toString |> Array.ofList)
-        "@episode",         Sql.jsonbOrNone  (post.Episode |> Option.map (Utils.serialize ser))
-        "@tags", Sql.stringArrayOrNone (if List.isEmpty post.Tags then None else Some (Array.ofList post.Tags))
-        "@metaItems",
-            if List.isEmpty post.Metadata then None else Some (Utils.serialize ser post.Metadata)
-            |> Sql.jsonbOrNone
-        optParam   "publishedOn" post.PublishedOn
-        typedParam "updatedOn"   post.UpdatedOn
-    ]
-    
-    /// Save a post
-    let save (post : Post) = backgroundTask {
-        let! oldPost = findFullById post.Id post.WebLogId
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query $"
-                {postInsert} ON CONFLICT (id) DO UPDATE
-                SET author_id        = EXCLUDED.author_id,
-                    status           = EXCLUDED.status,
-                    title            = EXCLUDED.title,
-                    permalink        = EXCLUDED.permalink,
-                    prior_permalinks = EXCLUDED.prior_permalinks,
-                    published_on     = EXCLUDED.published_on,
-                    updated_on       = EXCLUDED.updated_on,
-                    template         = EXCLUDED.template,
-                    post_text        = EXCLUDED.post_text,
-                    tags             = EXCLUDED.tags,
-                    meta_items       = EXCLUDED.meta_items,
-                    episode          = EXCLUDED.episode"
-            |> Sql.parameters (postParams post)
-            |> Sql.executeNonQueryAsync
-        do! updatePostCategories post.Id (match oldPost with Some p -> p.CategoryIds | None -> []) post.CategoryIds
-        do! updatePostRevisions  post.Id (match oldPost with Some p -> p.Revisions   | None -> []) post.Revisions
+    /// Update a post
+    let update (post : Post) = backgroundTask {
+        log.LogTrace "Post.save"
+        match! findFullById post.Id post.WebLogId with
+        | Some oldPost ->
+            do! Update.byId Table.Post post.Id { post with Revisions = [] }
+            do! updatePostRevisions post.Id oldPost.Revisions post.Revisions
+        | None -> ()
     }
     
     /// Restore posts from a backup
     let restore posts = backgroundTask {
-        let cats      = posts |> List.collect (fun p -> p.CategoryIds |> List.map (fun c -> p.Id, c))
-        let revisions = posts |> List.collect (fun p -> p.Revisions   |> List.map (fun r -> p.Id, r))
+        log.LogTrace "Post.restore"
+        let revisions = posts |> List.collect (fun p -> p.Revisions |> List.map (fun r -> p.Id, r))
         let! _ =
-            Sql.existingConnection conn
-            |> Sql.executeTransactionAsync [
-                postInsert, posts     |> List.map postParams
-                catInsert,  cats      |> List.map (fun (postId, catId) -> catParams postId catId)
-                revInsert,  revisions |> List.map (fun (postId, rev)   -> revParams postId rev)
-            ]
+            Configuration.dataSource ()
+            |> Sql.fromDataSource
+            |> Sql.executeTransactionAsync
+                [ Query.insert Table.Post,
+                    posts |> List.map (fun post -> [ jsonParam "@data" { post with Revisions = [] } ])
+                  Revisions.insertSql Table.PostRevision,
+                    revisions |> List.map (fun (postId, rev) -> Revisions.revParams postId rev) ]
         ()
     }
     
     /// Update prior permalinks for a post
-    let updatePriorPermalinks postId webLogId permalinks = backgroundTask {
+    let updatePriorPermalinks postId webLogId (permalinks: Permalink list) = backgroundTask {
+        log.LogTrace "Post.updatePriorPermalinks"
         match! postExists postId webLogId with
         | true ->
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.query "UPDATE post SET prior_permalinks = @prior WHERE id = @id"
-                |> Sql.parameters
-                    [   "@id",    Sql.string      (PostId.toString postId)
-                        "@prior", Sql.stringArray (permalinks |> List.map Permalink.toString |> Array.ofList) ]
-                |> Sql.executeNonQueryAsync
+            do! Patch.byId Table.Post postId {| PriorPermalinks = permalinks |}
             return true
         | false -> return false
     }
     
     interface IPostData with
-        member _.Add post = save post
+        member _.Add post = add post
         member _.CountByStatus status webLogId = countByStatus status webLogId
         member _.Delete postId webLogId = delete postId webLogId
         member _.FindById postId webLogId = findById postId webLogId
@@ -374,5 +233,5 @@ type PostgresPostData (conn : NpgsqlConnection, ser : JsonSerializer) =
             findPageOfTaggedPosts webLogId tag pageNbr postsPerPage
         member _.FindSurroundingPosts webLogId publishedOn = findSurroundingPosts webLogId publishedOn
         member _.Restore posts = restore posts
-        member _.Update post = save post
+        member _.Update post = update post
         member _.UpdatePriorPermalinks postId webLogId permalinks = updatePriorPermalinks postId webLogId permalinks

src/MyWebLog.Data/Postgres/PostgresTagMapData.fs

@@ -1,101 +1,62 @@
 namespace MyWebLog.Data.Postgres
 
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Npgsql
 open Npgsql.FSharp
 
-/// PostgreSQL myWebLog tag mapping data implementation        
-type PostgresTagMapData (conn : NpgsqlConnection) =
-
+/// PostgreSQL myWebLog tag mapping data implementation
+type PostgresTagMapData(log: ILogger) =
+    
     /// Find a tag mapping by its ID for the given web log
     let findById tagMapId webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM tag_map WHERE id = @id AND web_log_id = @webLogId"
-        |> Sql.parameters [ "@id", Sql.string (TagMapId.toString tagMapId); webLogIdParam webLogId ]
-        |> Sql.executeAsync Map.toTagMap
-        |> tryHead
+        log.LogTrace "TagMap.findById"
+        Document.findByIdAndWebLog<TagMapId, TagMap> Table.TagMap tagMapId webLogId
     
     /// Delete a tag mapping for the given web log
-    let delete tagMapId webLogId = backgroundTask {
-        let idParams = [ "@id", Sql.string (TagMapId.toString tagMapId) ]
-        let! exists =
-            Sql.existingConnection conn
-            |> Sql.query $"
-                SELECT EXISTS
-                    (SELECT 1 FROM tag_map WHERE id = @id AND web_log_id = @webLogId)
-                  AS {existsName}"
-            |> Sql.parameters (webLogIdParam webLogId :: idParams)
-            |> Sql.executeRowAsync Map.toExists
+    let delete (tagMapId: TagMapId) webLogId = backgroundTask {
+        log.LogTrace "TagMap.delete"
+        let! exists = Document.existsByWebLog Table.TagMap tagMapId webLogId
         if exists then
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.query "DELETE FROM tag_map WHERE id = @id"
-                |> Sql.parameters idParams
-                |> Sql.executeNonQueryAsync
+            do! Delete.byId Table.TagMap tagMapId
             return true
         else return false
     }
     
     /// Find a tag mapping by its URL value for the given web log
-    let findByUrlValue urlValue webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM tag_map WHERE web_log_id = @webLogId AND url_value = @urlValue"
-        |> Sql.parameters [ webLogIdParam webLogId; "@urlValue", Sql.string urlValue ]
-        |> Sql.executeAsync Map.toTagMap
-        |> tryHead
-    
+    let findByUrlValue (urlValue: string) webLogId =
+        log.LogTrace "TagMap.findByUrlValue"
+        Find.firstByContains<TagMap> Table.TagMap {| webLogDoc webLogId with UrlValue = urlValue |}
+
     /// Get all tag mappings for the given web log
     let findByWebLog webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM tag_map WHERE web_log_id = @webLogId ORDER BY tag"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeAsync Map.toTagMap
+        log.LogTrace "TagMap.findByWebLog"
+        Find.byContainsOrdered<TagMap> Table.TagMap (webLogDoc webLogId) [ Field.Named (nameof TagMap.Empty.Tag) ]
     
     /// Find any tag mappings in a list of tags for the given web log
-    let findMappingForTags tags webLogId =
-        let tagSql, tagParams = inClause "AND tag" "tag" id tags
-        Sql.existingConnection conn
-        |> Sql.query $"SELECT * FROM tag_map WHERE web_log_id = @webLogId {tagSql}"
-        |> Sql.parameters (webLogIdParam webLogId :: tagParams)
-        |> Sql.executeAsync Map.toTagMap
-    
-    /// The INSERT statement for a tag mapping
-    let tagMapInsert =
-        "INSERT INTO tag_map (
-            id, web_log_id, tag, url_value
-        ) VALUES (
-            @id, @webLogId, @tag, @urlValue
-        )"
-    
-    /// The parameters for saving a tag mapping
-    let tagMapParams (tagMap : TagMap) = [
-        webLogIdParam tagMap.WebLogId
-        "@id",       Sql.string (TagMapId.toString tagMap.Id)
-        "@tag",      Sql.string tagMap.Tag
-        "@urlValue", Sql.string tagMap.UrlValue
-    ]
+    let findMappingForTags (tags: string list) webLogId =
+        log.LogTrace "TagMap.findMappingForTags"
+        let tagField = Field.InArray (nameof TagMap.Empty.Tag) Table.TagMap tags
+        Custom.list
+            $"{selectWithCriteria Table.TagMap} AND {Query.whereByFields All [ tagField ]}"
+            (addFieldParams [ tagField ] [ webLogContains webLogId ])
+            fromData<TagMap>
     
     /// Save a tag mapping
-    let save tagMap = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query $"
-                {tagMapInsert} ON CONFLICT (id) DO UPDATE
-                SET tag       = EXCLUDED.tag,
-                    url_value = EXCLUDED.url_value"
-            |> Sql.parameters (tagMapParams tagMap)
-            |> Sql.executeNonQueryAsync
-        ()
-    }
+    let save (tagMap: TagMap) =
+        log.LogTrace "TagMap.save"
+        save Table.TagMap tagMap
     
     /// Restore tag mappings from a backup
-    let restore tagMaps = backgroundTask {
+    let restore (tagMaps: TagMap list) = backgroundTask {
         let! _ =
-            Sql.existingConnection conn
-            |> Sql.executeTransactionAsync [
-                tagMapInsert, tagMaps |> List.map tagMapParams
-            ]
+            Configuration.dataSource ()
+            |> Sql.fromDataSource
+            |> Sql.executeTransactionAsync
+                [ Query.insert Table.TagMap,
+                    tagMaps |> List.map (fun tagMap -> [ jsonParam "@data" tagMap ]) ]
         ()
     }
     

src/MyWebLog.Data/Postgres/PostgresThemeData.fs

@@ -1,132 +1,64 @@
 namespace MyWebLog.Data.Postgres
 
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Npgsql
-open Npgsql.FSharp
 
-/// PostreSQL myWebLog theme data implementation        
-type PostgresThemeData (conn : NpgsqlConnection) =
+/// PostreSQL myWebLog theme data implementation
+type PostgresThemeData(log: ILogger) =
+    
+    /// Clear out the template text from a theme
+    let withoutTemplateText row =
+        let theme = fromData<Theme> row
+        { theme with Templates = theme.Templates |> List.map (fun template -> { template with Text = "" }) }
     
     /// Retrieve all themes (except 'admin'; excludes template text)
-    let all () = backgroundTask {
-        let! themes =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT * FROM theme WHERE id <> 'admin' ORDER BY id"
-            |> Sql.executeAsync Map.toTheme
-        let! templates =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT name, theme_id FROM theme_template WHERE theme_id <> 'admin' ORDER BY name"
-            |> Sql.executeAsync (fun row -> ThemeId (row.string "theme_id"), Map.toThemeTemplate false row)
-        return
-            themes
-            |> List.map (fun t ->
-                { t with Templates = templates |> List.filter (fun tt -> fst tt = t.Id) |> List.map snd })
-    }
+    let all () =
+        log.LogTrace "Theme.all"
+        let fields = [ Field.NotEqual (nameof Theme.Empty.Id) "admin" ]
+        Custom.list
+            (Query.byFields (Query.find Table.Theme) Any fields
+                + Query.orderBy [ Field.Named (nameof Theme.Empty.Id) ] PostgreSQL)
+            (addFieldParams fields [])
+            withoutTemplateText
     
     /// Does a given theme exist?
-    let exists themeId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT EXISTS (SELECT 1 FROM theme WHERE id = @id) AS does_exist"
-        |> Sql.parameters [ "@id", Sql.string (ThemeId.toString themeId) ]
-        |> Sql.executeRowAsync Map.toExists
+    let exists (themeId: ThemeId) =
+        log.LogTrace "Theme.exists"
+        Exists.byId Table.Theme themeId
     
     /// Find a theme by its ID
-    let findById themeId = backgroundTask {
-        let themeIdParam = [ "@id", Sql.string (ThemeId.toString themeId) ]
-        let! theme =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT * FROM theme WHERE id = @id"
-            |> Sql.parameters themeIdParam
-            |> Sql.executeAsync Map.toTheme
-            |> tryHead
-        if Option.isSome theme then
-            let! templates =
-                Sql.existingConnection conn
-                |> Sql.query "SELECT * FROM theme_template WHERE theme_id = @id"
-                |> Sql.parameters themeIdParam
-                |> Sql.executeAsync (Map.toThemeTemplate true)
-            return Some { theme.Value with Templates = templates }
-        else return None
-    }
+    let findById (themeId: ThemeId) =
+        log.LogTrace "Theme.findById"
+        Find.byId<ThemeId, Theme> Table.Theme themeId
     
     /// Find a theme by its ID (excludes the text of templates)
-    let findByIdWithoutText themeId = backgroundTask {
-        match! findById themeId with
-        | Some theme ->
-            return Some {
-                theme with Templates = theme.Templates |> List.map (fun t -> { t with Text = "" })
-            }
-        | None -> return None
-    }
+    let findByIdWithoutText (themeId: ThemeId) =
+        log.LogTrace "Theme.findByIdWithoutText"
+        Custom.single (Query.byId (Query.find Table.Theme) (string themeId)) [ idParam themeId ] withoutTemplateText
     
     /// Delete a theme by its ID
     let delete themeId = backgroundTask {
-        let idParams = [ "@id", Sql.string (ThemeId.toString themeId) ]
-        let! exists =
-            Sql.existingConnection conn
-            |> Sql.query $"SELECT EXISTS (SELECT 1 FROM theme WHERE id = @id) AS {existsName}"
-            |> Sql.parameters idParams
-            |> Sql.executeRowAsync Map.toExists
-        if exists then
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.query
-                    "DELETE FROM theme_asset    WHERE theme_id = @id;
-                     DELETE FROM theme_template WHERE theme_id = @id;
-                     DELETE FROM theme          WHERE id       = @id"
-                |> Sql.parameters idParams
-                |> Sql.executeNonQueryAsync
+        log.LogTrace "Theme.delete"
+        match! exists themeId with
+        | true ->
+            do! Custom.nonQuery
+                    $"""{Query.delete Table.ThemeAsset} WHERE theme_id = @id;
+                        {Query.delete Table.Theme}      WHERE {Query.whereById "@id"}"""
+                    [ idParam themeId ]
             return true
-        else return false
+        | false -> return false
     }
     
     /// Save a theme
-    let save (theme : Theme) = backgroundTask {
-        let! oldTheme     = findById theme.Id
-        let  themeIdParam = Sql.string (ThemeId.toString theme.Id)
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query
-                "INSERT INTO theme VALUES (@id, @name, @version)
-                 ON CONFLICT (id) DO UPDATE
-                 SET name    = EXCLUDED.name,
-                     version = EXCLUDED.version"
-            |> Sql.parameters
-                [   "@id",      themeIdParam
-                    "@name",    Sql.string theme.Name
-                    "@version", Sql.string theme.Version ]
-            |> Sql.executeNonQueryAsync
-        
-        let toDelete, _ =
-            Utils.diffLists (oldTheme |> Option.map (fun t -> t.Templates) |> Option.defaultValue [])
-                            theme.Templates (fun t -> t.Name)
-        let toAddOrUpdate =
-            theme.Templates
-            |> List.filter (fun t -> not (toDelete |> List.exists (fun d -> d.Name = t.Name)))
-        
-        if not (List.isEmpty toDelete) || not (List.isEmpty toAddOrUpdate) then
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.executeTransactionAsync [
-                    if not (List.isEmpty toDelete) then
-                        "DELETE FROM theme_template WHERE theme_id = @themeId AND name = @name",
-                        toDelete |> List.map (fun tmpl -> [ "@themeId", themeIdParam; "@name", Sql.string tmpl.Name ])
-                    if not (List.isEmpty toAddOrUpdate) then
-                        "INSERT INTO theme_template VALUES (@themeId, @name, @template)
-                         ON CONFLICT (theme_id, name) DO UPDATE
-                         SET template = EXCLUDED.template",
-                        toAddOrUpdate |> List.map (fun tmpl -> [
-                            "@themeId",  themeIdParam
-                            "@name",     Sql.string tmpl.Name
-                            "@template", Sql.string tmpl.Text
-                        ])
-                ]
-            ()
-    }
+    let save (theme: Theme) =
+        log.LogTrace "Theme.save"
+        save Table.Theme theme
     
     interface IThemeData with
-        member _.All () = all ()
+        member _.All() = all ()
         member _.Delete themeId = delete themeId
         member _.Exists themeId = exists themeId
         member _.FindById themeId = findById themeId
@@ -134,72 +66,60 @@ type PostgresThemeData (conn : NpgsqlConnection) =
         member _.Save theme = save theme
 
 
-/// PostreSQL myWebLog theme data implementation        
-type PostgresThemeAssetData (conn : NpgsqlConnection) =
+/// PostreSQL myWebLog theme data implementation
+type PostgresThemeAssetData(log: ILogger) =
     
     /// Get all theme assets (excludes data)
     let all () =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT theme_id, path, updated_on FROM theme_asset"
-        |> Sql.executeAsync (Map.toThemeAsset false)
+        log.LogTrace "ThemeAsset.all"
+        Custom.list $"SELECT theme_id, path, updated_on FROM {Table.ThemeAsset}" [] (Map.toThemeAsset false)
     
     /// Delete all assets for the given theme
-    let deleteByTheme themeId = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query "DELETE FROM theme_asset WHERE theme_id = @themeId"
-            |> Sql.parameters [ "@themeId", Sql.string (ThemeId.toString themeId) ]
-            |> Sql.executeNonQueryAsync
-        ()
-    }
+    let deleteByTheme (themeId: ThemeId) =
+        log.LogTrace "ThemeAsset.deleteByTheme"
+        Custom.nonQuery $"{Query.delete Table.ThemeAsset} WHERE theme_id = @id" [ idParam themeId ]
     
     /// Find a theme asset by its ID
     let findById assetId =
+        log.LogTrace "ThemeAsset.findById"
         let (ThemeAssetId (ThemeId themeId, path)) = assetId
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM theme_asset WHERE theme_id = @themeId AND path = @path"
-        |> Sql.parameters [ "@themeId", Sql.string themeId; "@path", Sql.string path ]
-        |> Sql.executeAsync (Map.toThemeAsset true)
-        |> tryHead
+        Custom.single
+            $"SELECT * FROM {Table.ThemeAsset} WHERE theme_id = @id AND path = @path"
+            [ idParam themeId; "@path", Sql.string path ]
+            (Map.toThemeAsset true)
     
     /// Get theme assets for the given theme (excludes data)
-    let findByTheme themeId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT theme_id, path, updated_on FROM theme_asset WHERE theme_id = @themeId"
-        |> Sql.parameters [ "@themeId", Sql.string (ThemeId.toString themeId) ]
-        |> Sql.executeAsync (Map.toThemeAsset false)
+    let findByTheme (themeId: ThemeId) =
+        log.LogTrace "ThemeAsset.findByTheme"
+        Custom.list
+            $"SELECT theme_id, path, updated_on FROM {Table.ThemeAsset} WHERE theme_id = @id"
+            [ idParam themeId ]
+            (Map.toThemeAsset false)
     
     /// Get theme assets for the given theme
-    let findByThemeWithData themeId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM theme_asset WHERE theme_id = @themeId"
-        |> Sql.parameters [ "@themeId", Sql.string (ThemeId.toString themeId) ]
-        |> Sql.executeAsync (Map.toThemeAsset true)
+    let findByThemeWithData (themeId: ThemeId) =
+        log.LogTrace "ThemeAsset.findByThemeWithData"
+        Custom.list $"SELECT * FROM {Table.ThemeAsset} WHERE theme_id = @id" [ idParam themeId ] (Map.toThemeAsset true)
     
     /// Save a theme asset
-    let save (asset : ThemeAsset) = backgroundTask {
+    let save (asset: ThemeAsset) =
+        log.LogTrace "ThemeAsset.save"
         let (ThemeAssetId (ThemeId themeId, path)) = asset.Id
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query
-                "INSERT INTO theme_asset (
-                    theme_id, path, updated_on, data
-                ) VALUES (
-                    @themeId, @path, @updatedOn, @data
-                ) ON CONFLICT (theme_id, path) DO UPDATE
-                SET updated_on = EXCLUDED.updated_on,
-                    data       = EXCLUDED.data"
-            |> Sql.parameters
-                [   "@themeId", Sql.string themeId
-                    "@path",    Sql.string path
-                    "@data",    Sql.bytea  asset.Data
-                    typedParam "updatedOn" asset.UpdatedOn ]
-            |> Sql.executeNonQueryAsync
-        ()
-    }
+        Custom.nonQuery
+            $"INSERT INTO {Table.ThemeAsset} (
+                  theme_id, path, updated_on, data
+              ) VALUES (
+                  @themeId, @path, @updatedOn, @data
+              ) ON CONFLICT (theme_id, path) DO UPDATE
+              SET updated_on = EXCLUDED.updated_on,
+                  data       = EXCLUDED.data"
+            [ "@themeId", Sql.string themeId
+              "@path",    Sql.string path
+              "@data",    Sql.bytea  asset.Data
+              typedParam "updatedOn" asset.UpdatedOn ]
     
     interface IThemeAssetData with
-        member _.All () = all ()
+        member _.All() = all ()
         member _.DeleteByTheme themeId = deleteByTheme themeId
         member _.FindById assetId = findById assetId
         member _.FindByTheme themeId = findByTheme themeId

src/MyWebLog.Data/Postgres/PostgresUploadData.fs

@@ -1,89 +1,82 @@
 namespace MyWebLog.Data.Postgres
 
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Npgsql
 open Npgsql.FSharp
 
-/// PostgreSQL myWebLog uploaded file data implementation        
-type PostgresUploadData (conn : NpgsqlConnection) =
+/// PostgreSQL myWebLog uploaded file data implementation
+type PostgresUploadData(log: ILogger) =
 
     /// The INSERT statement for an uploaded file
-    let upInsert =
-        "INSERT INTO upload (
+    let upInsert = $"
+        INSERT INTO {Table.Upload} (
             id, web_log_id, path, updated_on, data
         ) VALUES (
             @id, @webLogId, @path, @updatedOn, @data
         )"
     
     /// Parameters for adding an uploaded file
-    let upParams (upload : Upload) = [
-        webLogIdParam upload.WebLogId
-        typedParam "updatedOn" upload.UpdatedOn
-        "@id",   Sql.string (UploadId.toString upload.Id)
-        "@path", Sql.string (Permalink.toString upload.Path)
-        "@data", Sql.bytea  upload.Data
-    ]
+    let upParams (upload: Upload) =
+        [ webLogIdParam upload.WebLogId
+          typedParam "updatedOn" upload.UpdatedOn
+          idParam upload.Id
+          "@path", Sql.string (string upload.Path)
+          "@data", Sql.bytea  upload.Data ]
     
     /// Save an uploaded file
-    let add upload = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query upInsert
-            |> Sql.parameters (upParams upload)
-            |> Sql.executeNonQueryAsync
-        ()
-    }
+    let add upload =
+        log.LogTrace "Upload.add"
+        Custom.nonQuery upInsert (upParams upload)
     
     /// Delete an uploaded file by its ID
     let delete uploadId webLogId = backgroundTask {
-        let theParams = [ "@id", Sql.string (UploadId.toString uploadId); webLogIdParam webLogId ]
+        log.LogTrace "Upload.delete"
+        let idParam = [ idParam uploadId ]
         let! path =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT path FROM upload WHERE id = @id AND web_log_id = @webLogId"
-            |> Sql.parameters theParams
-            |> Sql.executeAsync (fun row -> row.string "path")
-            |> tryHead
+            Custom.single
+                $"SELECT path FROM {Table.Upload} WHERE id = @id AND web_log_id = @webLogId"
+                (webLogIdParam webLogId :: idParam)
+                (fun row -> row.string "path")
         if Option.isSome path then
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.query "DELETE FROM upload WHERE id = @id AND web_log_id = @webLogId"
-                |> Sql.parameters theParams
-                |> Sql.executeNonQueryAsync
+            do! Custom.nonQuery $"DELETE FROM {Table.Upload} WHERE id = @id" idParam
             return Ok path.Value
-        else return Error $"""Upload ID {UploadId.toString uploadId} not found"""
+        else return Error $"Upload ID {uploadId} not found"
     }
     
     /// Find an uploaded file by its path for the given web log
     let findByPath path webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM upload WHERE web_log_id = @webLogId AND path = @path"
-        |> Sql.parameters [ webLogIdParam webLogId; "@path", Sql.string path ]
-        |> Sql.executeAsync (Map.toUpload true)
-        |> tryHead
+        log.LogTrace "Upload.findByPath"
+        Custom.single
+            $"SELECT * FROM {Table.Upload} WHERE web_log_id = @webLogId AND path = @path"
+            [ webLogIdParam webLogId; "@path", Sql.string path ]
+            (Map.toUpload true)
     
     /// Find all uploaded files for the given web log (excludes data)
     let findByWebLog webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT id, web_log_id, path, updated_on FROM upload WHERE web_log_id = @webLogId"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeAsync (Map.toUpload false)
+        log.LogTrace "Upload.findByWebLog"
+        Custom.list
+            $"SELECT id, web_log_id, path, updated_on FROM {Table.Upload} WHERE web_log_id = @webLogId"
+            [ webLogIdParam webLogId ]
+            (Map.toUpload false)
     
     /// Find all uploaded files for the given web log
     let findByWebLogWithData webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM upload WHERE web_log_id = @webLogId"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeAsync (Map.toUpload true)
+        log.LogTrace "Upload.findByWebLogWithData"
+        Custom.list
+            $"SELECT * FROM {Table.Upload} WHERE web_log_id = @webLogId"
+            [ webLogIdParam webLogId ]
+            (Map.toUpload true)
     
     /// Restore uploads from a backup
     let restore uploads = backgroundTask {
+        log.LogTrace "Upload.restore"
         for batch in uploads |> List.chunkBySize 5 do
             let! _ =
-                Sql.existingConnection conn
-                |> Sql.executeTransactionAsync [
-                    upInsert, batch |> List.map upParams
-                ]
+                Configuration.dataSource ()
+                |> Sql.fromDataSource
+                |> Sql.executeTransactionAsync [ upInsert, batch |> List.map upParams ]
             ()
     }
     

src/MyWebLog.Data/Postgres/PostgresWebLogData.fs

@@ -1,238 +1,83 @@
 namespace MyWebLog.Data.Postgres
 
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Newtonsoft.Json
-open Npgsql
-open Npgsql.FSharp
 
-/// PostgreSQL myWebLog web log data implementation        
-type PostgresWebLogData (conn : NpgsqlConnection, ser : JsonSerializer) =
-    
-    // SUPPORT FUNCTIONS
-    
-    /// The parameters for web log INSERT or web log/RSS options UPDATE statements
-    let rssParams (webLog : WebLog) = [
-        "@isFeedEnabled",     Sql.bool         webLog.Rss.IsFeedEnabled
-        "@feedName",          Sql.string       webLog.Rss.FeedName
-        "@itemsInFeed",       Sql.intOrNone    webLog.Rss.ItemsInFeed
-        "@isCategoryEnabled", Sql.bool         webLog.Rss.IsCategoryEnabled
-        "@isTagEnabled",      Sql.bool         webLog.Rss.IsTagEnabled
-        "@copyright",         Sql.stringOrNone webLog.Rss.Copyright
-    ]
-    
-    /// The parameters for web log INSERT or UPDATE statements
-    let webLogParams (webLog : WebLog) = [
-        "@id",           Sql.string       (WebLogId.toString webLog.Id)
-        "@name",         Sql.string       webLog.Name
-        "@slug",         Sql.string       webLog.Slug
-        "@subtitle",     Sql.stringOrNone webLog.Subtitle
-        "@defaultPage",  Sql.string       webLog.DefaultPage
-        "@postsPerPage", Sql.int          webLog.PostsPerPage
-        "@themeId",      Sql.string       (ThemeId.toString webLog.ThemeId)
-        "@urlBase",      Sql.string       webLog.UrlBase
-        "@timeZone",     Sql.string       webLog.TimeZone
-        "@autoHtmx",     Sql.bool         webLog.AutoHtmx
-        "@uploads",      Sql.string       (UploadDestination.toString webLog.Uploads)
-        yield! rssParams webLog
-    ]
-    
-    /// Shorthand to map a result to a custom feed
-    let toCustomFeed =
-        Map.toCustomFeed ser
-    
-    /// Get the current custom feeds for a web log
-    let getCustomFeeds (webLog : WebLog) =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM web_log_feed WHERE web_log_id = @webLogId"
-        |> Sql.parameters [ webLogIdParam webLog.Id ]
-        |> Sql.executeAsync toCustomFeed
-    
-    /// Append custom feeds to a web log
-    let appendCustomFeeds (webLog : WebLog) = backgroundTask {
-        let! feeds = getCustomFeeds webLog
-        return { webLog with Rss = { webLog.Rss with CustomFeeds = feeds } }
-    }
-    
-    /// The parameters to save a custom feed
-    let feedParams webLogId (feed : CustomFeed) = [
-        webLogIdParam webLogId
-        "@id",      Sql.string      (CustomFeedId.toString feed.Id)
-        "@source",  Sql.string      (CustomFeedSource.toString feed.Source)
-        "@path",    Sql.string      (Permalink.toString feed.Path)
-        "@podcast", Sql.jsonbOrNone (feed.Podcast |> Option.map (Utils.serialize ser))
-    ]
-
-    /// Update the custom feeds for a web log
-    let updateCustomFeeds (webLog : WebLog) = backgroundTask {
-        let! feeds = getCustomFeeds webLog
-        let toDelete, _ = Utils.diffLists feeds webLog.Rss.CustomFeeds (fun it -> $"{CustomFeedId.toString it.Id}")
-        let toId (feed : CustomFeed) = feed.Id
-        let toAddOrUpdate =
-            webLog.Rss.CustomFeeds |> List.filter (fun f -> not (toDelete |> List.map toId |> List.contains f.Id))
-        if not (List.isEmpty toDelete) || not (List.isEmpty toAddOrUpdate) then
-            let! _ =
-                Sql.existingConnection conn
-                |> Sql.executeTransactionAsync [
-                    if not (List.isEmpty toDelete) then
-                        "DELETE FROM web_log_feed WHERE id = @id",
-                        toDelete |> List.map (fun it -> [ "@id", Sql.string (CustomFeedId.toString it.Id) ])
-                    if not (List.isEmpty toAddOrUpdate) then
-                        "INSERT INTO web_log_feed (
-                            id, web_log_id, source, path, podcast
-                        ) VALUES (
-                            @id, @webLogId, @source, @path, @podcast
-                        ) ON CONFLICT (id) DO UPDATE
-                        SET source  = EXCLUDED.source,
-                            path    = EXCLUDED.path,
-                            podcast = EXCLUDED.podcast",
-                        toAddOrUpdate |> List.map (feedParams webLog.Id)
-                ]
-            ()
-    }
-    
-    // IMPLEMENTATION FUNCTIONS
+/// PostgreSQL myWebLog web log data implementation
+type PostgresWebLogData(log: ILogger) =
     
     /// Add a web log
-    let add webLog = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query
-                "INSERT INTO web_log (
-                    id, name, slug, subtitle, default_page, posts_per_page, theme_id, url_base, time_zone, auto_htmx,
-                    uploads, is_feed_enabled, feed_name, items_in_feed, is_category_enabled, is_tag_enabled, copyright
-                ) VALUES (
-                    @id, @name, @slug, @subtitle, @defaultPage, @postsPerPage, @themeId, @urlBase, @timeZone, @autoHtmx,
-                    @uploads, @isFeedEnabled, @feedName, @itemsInFeed, @isCategoryEnabled, @isTagEnabled, @copyright
-                )"
-            |> Sql.parameters (webLogParams webLog)
-            |> Sql.executeNonQueryAsync
-        do! updateCustomFeeds webLog
-    }
+    let add (webLog: WebLog) =
+        log.LogTrace "WebLog.add"
+        insert Table.WebLog webLog
     
     /// Retrieve all web logs
-    let all () = backgroundTask {
-        let! webLogs =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT * FROM web_log"
-            |> Sql.executeAsync Map.toWebLog
-        let! feeds =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT * FROM web_log_feed"
-            |> Sql.executeAsync (fun row -> WebLogId (row.string "web_log_id"), toCustomFeed row)
-        return
-            webLogs
-            |> List.map (fun it ->
-                { it with
-                    Rss =
-                        { it.Rss with
-                            CustomFeeds = feeds |> List.filter (fun (wlId, _) -> wlId = it.Id) |> List.map snd } })
-    }
+    let all () =
+        log.LogTrace "WebLog.all"
+        Find.all<WebLog> Table.WebLog
     
     /// Delete a web log by its ID
-    let delete webLogId = backgroundTask {
-        let subQuery table = $"(SELECT id FROM {table} WHERE web_log_id = @webLogId)"
-        let postSubQuery = subQuery "post"
-        let pageSubQuery = subQuery "page"
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query $"
-                DELETE FROM post_comment  WHERE post_id IN {postSubQuery};
-                DELETE FROM post_revision WHERE post_id IN {postSubQuery};
-                DELETE FROM post_category WHERE post_id IN {postSubQuery};
-                DELETE FROM post          WHERE web_log_id = @webLogId;
-                DELETE FROM page_revision WHERE page_id IN {pageSubQuery};
-                DELETE FROM page          WHERE web_log_id = @webLogId;
-                DELETE FROM category      WHERE web_log_id = @webLogId;
-                DELETE FROM tag_map       WHERE web_log_id = @webLogId;
-                DELETE FROM upload        WHERE web_log_id = @webLogId;
-                DELETE FROM web_log_user  WHERE web_log_id = @webLogId;
-                DELETE FROM web_log_feed  WHERE web_log_id = @webLogId;
-                DELETE FROM web_log       WHERE id         = @webLogId"
-            |> Sql.parameters [ webLogIdParam webLogId ]
-            |> Sql.executeNonQueryAsync
-        ()
-    }
+    let delete webLogId =
+        log.LogTrace "WebLog.delete"
+        Custom.nonQuery
+            $"""{Query.delete Table.PostComment}
+                  WHERE data->>'{nameof Comment.Empty.PostId}'
+                          IN (SELECT data->>'{nameof Post.Empty.Id}'
+                                FROM {Table.Post}
+                               WHERE {Query.whereDataContains "@criteria"});
+                {Query.delete Table.PostRevision}
+                  WHERE post_id IN (SELECT data->>'Id' FROM {Table.Post} WHERE {Query.whereDataContains "@criteria"});
+                {Query.delete Table.PageRevision}
+                  WHERE page_id IN (SELECT data->>'Id' FROM {Table.Page} WHERE {Query.whereDataContains "@criteria"});
+                {Query.byContains (Query.delete Table.Post)};
+                {Query.byContains (Query.delete Table.Page)};
+                {Query.byContains (Query.delete Table.Category)};
+                {Query.byContains (Query.delete Table.TagMap)};
+                {Query.byContains (Query.delete Table.WebLogUser)};
+                {Query.delete Table.Upload} WHERE web_log_id  = @webLogId;
+                {Query.delete Table.WebLog} WHERE data->>'Id' = @webLogId"""
+            [ webLogIdParam webLogId; webLogContains webLogId ]
     
     /// Find a web log by its host (URL base)
-    let findByHost url = backgroundTask {
-        let! webLog =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT * FROM web_log WHERE url_base = @urlBase"
-            |> Sql.parameters [ "@urlBase", Sql.string url ]
-            |> Sql.executeAsync Map.toWebLog
-            |> tryHead
-        if Option.isSome webLog then
-            let! withFeeds = appendCustomFeeds webLog.Value
-            return Some withFeeds
-        else return None
-    }
+    let findByHost (url: string) =
+        log.LogTrace "WebLog.findByHost"
+        Find.firstByContains<WebLog> Table.WebLog {| UrlBase = url |}
     
     /// Find a web log by its ID
-    let findById webLogId = backgroundTask {
-        let! webLog =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT * FROM web_log WHERE id = @webLogId"
-            |> Sql.parameters [ webLogIdParam webLogId ]
-            |> Sql.executeAsync Map.toWebLog
-            |> tryHead
-        if Option.isSome webLog then
-            let! withFeeds = appendCustomFeeds webLog.Value
-            return Some withFeeds
-        else return None
-    }
+    let findById (webLogId: WebLogId) = 
+        log.LogTrace "WebLog.findById"
+        Find.byId<WebLogId, WebLog> Table.WebLog webLogId
     
-    /// Update settings for a web log
-    let updateSettings webLog = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query
-                "UPDATE web_log
-                    SET name                = @name,
-                        slug                = @slug,
-                        subtitle            = @subtitle,
-                        default_page        = @defaultPage,
-                        posts_per_page      = @postsPerPage,
-                        theme_id            = @themeId,
-                        url_base            = @urlBase,
-                        time_zone           = @timeZone,
-                        auto_htmx           = @autoHtmx,
-                        uploads             = @uploads,
-                        is_feed_enabled     = @isFeedEnabled,
-                        feed_name           = @feedName,
-                        items_in_feed       = @itemsInFeed,
-                        is_category_enabled = @isCategoryEnabled,
-                        is_tag_enabled      = @isTagEnabled,
-                        copyright           = @copyright
-                  WHERE id = @id"
-            |> Sql.parameters (webLogParams webLog)
-            |> Sql.executeNonQueryAsync
-        ()
+    /// Update redirect rules for a web log
+    let updateRedirectRules (webLog: WebLog) = backgroundTask {
+        log.LogTrace "WebLog.updateRedirectRules"
+        match! findById webLog.Id with
+        | Some _ -> do! Patch.byId Table.WebLog webLog.Id {| RedirectRules = webLog.RedirectRules |}
+        | None -> ()
     }
     
     /// Update RSS options for a web log
-    let updateRssOptions (webLog : WebLog) = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query
-                "UPDATE web_log
-                    SET is_feed_enabled     = @isFeedEnabled,
-                        feed_name           = @feedName,
-                        items_in_feed       = @itemsInFeed,
-                        is_category_enabled = @isCategoryEnabled,
-                        is_tag_enabled      = @isTagEnabled,
-                        copyright           = @copyright
-                  WHERE id = @webLogId"
-            |> Sql.parameters (webLogIdParam webLog.Id :: rssParams webLog)
-            |> Sql.executeNonQueryAsync
-        do! updateCustomFeeds webLog
+    let updateRssOptions (webLog: WebLog) = backgroundTask {
+        log.LogTrace "WebLog.updateRssOptions"
+        match! findById webLog.Id with
+        | Some _ -> do! Patch.byId Table.WebLog webLog.Id {| Rss = webLog.Rss |}
+        | None -> ()
     }
     
+    /// Update settings for a web log
+    let updateSettings (webLog: WebLog) =
+        log.LogTrace "WebLog.updateSettings"
+        Update.byId Table.WebLog webLog.Id webLog
+    
     interface IWebLogData with
         member _.Add webLog = add webLog
-        member _.All () = all ()
+        member _.All() = all ()
         member _.Delete webLogId = delete webLogId
         member _.FindByHost url = findByHost url
         member _.FindById webLogId = findById webLogId
-        member _.UpdateSettings webLog = updateSettings webLog
+        member _.UpdateRedirectRules webLog = updateRedirectRules webLog
         member _.UpdateRssOptions webLog = updateRssOptions webLog
+        member _.UpdateSettings webLog = updateSettings webLog

src/MyWebLog.Data/Postgres/PostgresWebLogUserData.fs

@@ -1,143 +1,95 @@
 namespace MyWebLog.Data.Postgres
 
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Npgsql
 open Npgsql.FSharp
 
-/// PostgreSQL myWebLog user data implementation        
-type PostgresWebLogUserData (conn : NpgsqlConnection) =
+/// PostgreSQL myWebLog user data implementation
+type PostgresWebLogUserData(log: ILogger) =
     
-    /// The INSERT statement for a user
-    let userInsert =
-        "INSERT INTO web_log_user (
-            id, web_log_id, email, first_name, last_name, preferred_name, password_hash, url, access_level,
-            created_on, last_seen_on
-        ) VALUES (
-            @id, @webLogId, @email, @firstName, @lastName, @preferredName, @passwordHash, @url, @accessLevel,
-            @createdOn, @lastSeenOn
-        )"
+    /// Add a user
+    let add (user: WebLogUser) =
+        log.LogTrace "WebLogUser.add"
+        insert Table.WebLogUser user
     
-    /// Parameters for saving web log users
-    let userParams (user : WebLogUser) = [
-        "@id",            Sql.string       (WebLogUserId.toString user.Id)
-        "@webLogId",      Sql.string       (WebLogId.toString user.WebLogId)
-        "@email",         Sql.string       user.Email
-        "@firstName",     Sql.string       user.FirstName
-        "@lastName",      Sql.string       user.LastName
-        "@preferredName", Sql.string       user.PreferredName
-        "@passwordHash",  Sql.string       user.PasswordHash
-        "@url",           Sql.stringOrNone user.Url
-        "@accessLevel",   Sql.string       (AccessLevel.toString user.AccessLevel)
-        typedParam "createdOn"  user.CreatedOn
-        optParam   "lastSeenOn" user.LastSeenOn
-    ]
-
     /// Find a user by their ID for the given web log
     let findById userId webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM web_log_user WHERE id = @id AND web_log_id = @webLogId"
-        |> Sql.parameters [ "@id", Sql.string (WebLogUserId.toString userId); webLogIdParam webLogId ]
-        |> Sql.executeAsync Map.toWebLogUser
-        |> tryHead
+        log.LogTrace "WebLogUser.findById"
+        Document.findByIdAndWebLog<WebLogUserId, WebLogUser> Table.WebLogUser userId webLogId
     
     /// Delete a user if they have no posts or pages
     let delete userId webLogId = backgroundTask {
+        log.LogTrace "WebLogUser.delete"
         match! findById userId webLogId with
         | Some _ ->
-            let userParam = [ "@userId", Sql.string (WebLogUserId.toString userId) ]
+            let  criteria = Query.whereDataContains "@criteria"
             let! isAuthor =
-                Sql.existingConnection conn
-                |> Sql.query
-                    "SELECT (   EXISTS (SELECT 1 FROM page WHERE author_id = @userId
-                             OR EXISTS (SELECT 1 FROM post WHERE author_id = @userId)) AS does_exist"
-                |> Sql.parameters userParam
-                |> Sql.executeRowAsync Map.toExists
+                Custom.scalar
+                    $" SELECT (   EXISTS (SELECT 1 FROM {Table.Page} WHERE {criteria})
+                               OR EXISTS (SELECT 1 FROM {Table.Post} WHERE {criteria})
+                              ) AS it"
+                    [ jsonParam "@criteria" {| AuthorId = userId |} ]
+                    toExists
             if isAuthor then
                 return Error "User has pages or posts; cannot delete"
             else
-                let! _ =
-                    Sql.existingConnection conn
-                    |> Sql.query "DELETE FROM web_log_user WHERE id = @userId"
-                    |> Sql.parameters userParam
-                    |> Sql.executeNonQueryAsync
+                do! Delete.byId Table.WebLogUser userId
                 return Ok true
         | None -> return Error "User does not exist"
     }
     
     /// Find a user by their e-mail address for the given web log
-    let findByEmail email webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM web_log_user WHERE web_log_id = @webLogId AND email = @email"
-        |> Sql.parameters [ webLogIdParam webLogId; "@email", Sql.string email ]
-        |> Sql.executeAsync Map.toWebLogUser
-        |> tryHead
+    let findByEmail (email: string) webLogId =
+        log.LogTrace "WebLogUser.findByEmail"
+        Find.firstByContains<WebLogUser> Table.WebLogUser {| webLogDoc webLogId with Email = email |}
     
     /// Get all users for the given web log
     let findByWebLog webLogId =
-        Sql.existingConnection conn
-        |> Sql.query "SELECT * FROM web_log_user WHERE web_log_id = @webLogId ORDER BY LOWER(preferred_name)"
-        |> Sql.parameters [ webLogIdParam webLogId ]
-        |> Sql.executeAsync Map.toWebLogUser
+        log.LogTrace "WebLogUser.findByWebLog"
+        Find.byContainsOrdered<WebLogUser>
+            Table.WebLogUser (webLogDoc webLogId) [ Field.Named $"i:{nameof WebLogUser.Empty.PreferredName}" ]
     
     /// Find the names of users by their IDs for the given web log
-    let findNames webLogId userIds = backgroundTask {
-        let idSql, idParams = inClause "AND id" "id" WebLogUserId.toString userIds
+    let findNames webLogId (userIds: WebLogUserId list) = backgroundTask {
+        log.LogTrace "WebLogUser.findNames"
+        let idField = Field.In (nameof WebLogUser.Empty.Id) (List.map string userIds)
         let! users =
-            Sql.existingConnection conn
-            |> Sql.query $"SELECT * FROM web_log_user WHERE web_log_id = @webLogId {idSql}"
-            |> Sql.parameters (webLogIdParam webLogId :: idParams)
-            |> Sql.executeAsync Map.toWebLogUser
-        return
-            users
-            |> List.map (fun u -> { Name = WebLogUserId.toString u.Id; Value = WebLogUser.displayName u })
+            Custom.list
+                $"{selectWithCriteria Table.WebLogUser} AND {Query.whereByFields All [ idField ]}"
+                (addFieldParams [ idField ] [ webLogContains webLogId ])
+                fromData<WebLogUser>
+        return users |> List.map (fun u -> { Name = string u.Id; Value = u.DisplayName })
     }
     
     /// Restore users from a backup
-    let restore users = backgroundTask {
+    let restore (users: WebLogUser list) = backgroundTask {
+        log.LogTrace "WebLogUser.restore"
         let! _ =
-            Sql.existingConnection conn
-            |> Sql.executeTransactionAsync [
-                userInsert, users |> List.map userParams
-            ]
+            Configuration.dataSource ()
+            |> Sql.fromDataSource
+            |> Sql.executeTransactionAsync
+                [ Query.insert Table.WebLogUser, users |> List.map (fun user -> [ jsonParam "@data" user ]) ]
         ()
     }
     
     /// Set a user's last seen date/time to now
-    let setLastSeen userId webLogId = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query "UPDATE web_log_user SET last_seen_on = @lastSeenOn WHERE id = @id AND web_log_id = @webLogId"
-            |> Sql.parameters
-                [   webLogIdParam webLogId
-                    typedParam "lastSeenOn" (Noda.now ())
-                    "@id", Sql.string (WebLogUserId.toString userId) ]
-            |> Sql.executeNonQueryAsync
-        ()
+    let setLastSeen (userId: WebLogUserId) webLogId = backgroundTask {
+        log.LogTrace "WebLogUser.setLastSeen"
+        match! Document.existsByWebLog Table.WebLogUser userId webLogId with
+        | true -> do! Patch.byId Table.WebLogUser userId {| LastSeenOn = Some (Noda.now ()) |}
+        | false -> ()
     }
     
-    /// Save a user
-    let save user = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query $"
-                {userInsert} ON CONFLICT (id) DO UPDATE
-                SET email          = @email,
-                    first_name     = @firstName,
-                    last_name      = @lastName,
-                    preferred_name = @preferredName,
-                    password_hash  = @passwordHash,
-                    url            = @url,
-                    access_level   = @accessLevel,
-                    created_on     = @createdOn,
-                    last_seen_on   = @lastSeenOn"
-            |> Sql.parameters (userParams user)
-            |> Sql.executeNonQueryAsync
-        ()
-    }
+    /// Update a user
+    let update (user: WebLogUser) =
+        log.LogTrace "WebLogUser.update"
+        Update.byId Table.WebLogUser user.Id user
     
     interface IWebLogUserData with
-        member _.Add user = save user
+        member _.Add user = add user
         member _.Delete userId webLogId = delete userId webLogId
         member _.FindByEmail email webLogId = findByEmail email webLogId
         member _.FindById userId webLogId = findById userId webLogId
@@ -145,5 +97,4 @@ type PostgresWebLogUserData (conn : NpgsqlConnection) =
         member _.FindNames webLogId userIds = findNames webLogId userIds
         member _.Restore users = restore users
         member _.SetLastSeen userId webLogId = setLastSeen userId webLogId
-        member _.Update user = save user
-
+        member _.Update user = update user

src/MyWebLog.Data/PostgresData.fs

@@ -1,208 +1,126 @@
 namespace MyWebLog.Data
 
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
 open Microsoft.Extensions.Logging
+open MyWebLog
 open MyWebLog.Data.Postgres
 open Newtonsoft.Json
-open Npgsql
 open Npgsql.FSharp
 
 /// Data implementation for PostgreSQL
-type PostgresData (conn : NpgsqlConnection, log : ILogger<PostgresData>, ser : JsonSerializer) =
-    
+type PostgresData(log: ILogger<PostgresData>, ser: JsonSerializer) =
+
     /// Create any needed tables
     let ensureTables () = backgroundTask {
-        let _ = NpgsqlConnection.GlobalTypeMapper.UseNodaTime ()
-        
+        // Set up the PostgreSQL document store
+        Configuration.useSerializer (Utils.createDocumentSerializer ser)
+
         let! tables =
-            Sql.existingConnection conn
-            |> Sql.query "SELECT tablename FROM pg_tables WHERE schemaname = 'public'"
-            |> Sql.executeAsync (fun row -> row.string "tablename")
+            Custom.list
+                "SELECT tablename FROM pg_tables WHERE schemaname = 'public'" [] (fun row -> row.string "tablename")
         let needsTable table = not (List.contains table tables)
-        let mutable isNew = false
-        
+
         let sql = seq {
             // Theme tables
-            if needsTable "theme" then
-                isNew <- true
-                "CREATE TABLE theme (
-                    id       TEXT NOT NULL PRIMARY KEY,
-                    name     TEXT NOT NULL,
-                    version  TEXT NOT NULL)"
-            if needsTable "theme_template" then
-                "CREATE TABLE theme_template (
-                    theme_id  TEXT NOT NULL REFERENCES theme (id),
-                    name      TEXT NOT NULL,
-                    template  TEXT NOT NULL,
-                    PRIMARY KEY (theme_id, name))"
-            if needsTable "theme_asset" then
-                "CREATE TABLE theme_asset (
-                    theme_id    TEXT        NOT NULL REFERENCES theme (id),
+            if needsTable Table.Theme then
+                Query.Definition.ensureTable Table.Theme
+                Query.Definition.ensureKey   Table.Theme PostgreSQL
+            if needsTable Table.ThemeAsset then
+                $"CREATE TABLE {Table.ThemeAsset} (
+                    theme_id    TEXT        NOT NULL,
                     path        TEXT        NOT NULL,
                     updated_on  TIMESTAMPTZ NOT NULL,
                     data        BYTEA       NOT NULL,
                     PRIMARY KEY (theme_id, path))"
-            
-            // Web log tables
-            if needsTable "web_log" then
-                "CREATE TABLE web_log (
-                    id                   TEXT    NOT NULL PRIMARY KEY,
-                    name                 TEXT    NOT NULL,
-                    slug                 TEXT    NOT NULL,
-                    subtitle             TEXT,
-                    default_page         TEXT    NOT NULL,
-                    posts_per_page       INTEGER NOT NULL,
-                    theme_id             TEXT    NOT NULL REFERENCES theme (id),
-                    url_base             TEXT    NOT NULL,
-                    time_zone            TEXT    NOT NULL,
-                    auto_htmx            BOOLEAN NOT NULL DEFAULT FALSE,
-                    uploads              TEXT    NOT NULL,
-                    is_feed_enabled      BOOLEAN NOT NULL DEFAULT FALSE,
-                    feed_name            TEXT    NOT NULL,
-                    items_in_feed        INTEGER,
-                    is_category_enabled  BOOLEAN NOT NULL DEFAULT FALSE,
-                    is_tag_enabled       BOOLEAN NOT NULL DEFAULT FALSE,
-                    copyright            TEXT)"
-                "CREATE INDEX web_log_theme_idx ON web_log (theme_id)"
-            if needsTable "web_log_feed" then
-                "CREATE TABLE web_log_feed (
-                    id          TEXT NOT NULL PRIMARY KEY,
-                    web_log_id  TEXT NOT NULL REFERENCES web_log (id),
-                    source      TEXT NOT NULL,
-                    path        TEXT NOT NULL,
-                    podcast     JSONB)"
-                "CREATE INDEX web_log_feed_web_log_idx ON web_log_feed (web_log_id)"
-            
+
+            // Web log table
+            if needsTable Table.WebLog then
+                Query.Definition.ensureTable         Table.WebLog
+                Query.Definition.ensureKey           Table.WebLog PostgreSQL
+                Query.Definition.ensureDocumentIndex Table.WebLog Optimized
+
             // Category table
-            if needsTable "category" then
-                "CREATE TABLE category (
-                    id           TEXT NOT NULL PRIMARY KEY,
-                    web_log_id   TEXT NOT NULL REFERENCES web_log (id),
-                    name         TEXT NOT NULL,
-                    slug         TEXT NOT NULL,
-                    description  TEXT,
-                    parent_id    TEXT)"
-                "CREATE INDEX category_web_log_idx ON category (web_log_id)"
-            
+            if needsTable Table.Category then
+                Query.Definition.ensureTable         Table.Category
+                Query.Definition.ensureKey           Table.Category PostgreSQL
+                Query.Definition.ensureDocumentIndex Table.Category Optimized
+
             // Web log user table
-            if needsTable "web_log_user" then
-                "CREATE TABLE web_log_user (
-                    id              TEXT        NOT NULL PRIMARY KEY,
-                    web_log_id      TEXT        NOT NULL REFERENCES web_log (id),
-                    email           TEXT        NOT NULL,
-                    first_name      TEXT        NOT NULL,
-                    last_name       TEXT        NOT NULL,
-                    preferred_name  TEXT        NOT NULL,
-                    password_hash   TEXT        NOT NULL,
-                    url             TEXT,
-                    access_level    TEXT        NOT NULL,
-                    created_on      TIMESTAMPTZ NOT NULL,
-                    last_seen_on    TIMESTAMPTZ)"
-                "CREATE INDEX web_log_user_web_log_idx ON web_log_user (web_log_id)"
-                "CREATE INDEX web_log_user_email_idx   ON web_log_user (web_log_id, email)"
-            
+            if needsTable Table.WebLogUser then
+                Query.Definition.ensureTable         Table.WebLogUser
+                Query.Definition.ensureKey           Table.WebLogUser PostgreSQL
+                Query.Definition.ensureDocumentIndex Table.WebLogUser Optimized
+
             // Page tables
-            if needsTable "page" then
-                "CREATE TABLE page (
-                    id               TEXT        NOT NULL PRIMARY KEY,
-                    web_log_id       TEXT        NOT NULL REFERENCES web_log (id),
-                    author_id        TEXT        NOT NULL REFERENCES web_log_user (id),
-                    title            TEXT        NOT NULL,
-                    permalink        TEXT        NOT NULL,
-                    prior_permalinks TEXT[]      NOT NULL DEFAULT '{}',
-                    published_on     TIMESTAMPTZ NOT NULL,
-                    updated_on       TIMESTAMPTZ NOT NULL,
-                    is_in_page_list  BOOLEAN     NOT NULL DEFAULT FALSE,
-                    template         TEXT,
-                    page_text        TEXT        NOT NULL,
-                    meta_items       JSONB)"
-                "CREATE INDEX page_web_log_idx   ON page (web_log_id)"
-                "CREATE INDEX page_author_idx    ON page (author_id)"
-                "CREATE INDEX page_permalink_idx ON page (web_log_id, permalink)"
-            if needsTable "page_revision" then
-                "CREATE TABLE page_revision (
-                    page_id        TEXT        NOT NULL REFERENCES page (id),
+            if needsTable Table.Page then
+                Query.Definition.ensureTable   Table.Page
+                Query.Definition.ensureKey     Table.Page PostgreSQL
+                Query.Definition.ensureIndexOn Table.Page "author" [ nameof Page.Empty.AuthorId ] PostgreSQL
+                Query.Definition.ensureIndexOn
+                    Table.Page "permalink" [ nameof Page.Empty.WebLogId; nameof Page.Empty.Permalink ] PostgreSQL
+            if needsTable Table.PageRevision then
+                $"CREATE TABLE {Table.PageRevision} (
+                    page_id        TEXT        NOT NULL,
                     as_of          TIMESTAMPTZ NOT NULL,
                     revision_text  TEXT        NOT NULL,
                     PRIMARY KEY (page_id, as_of))"
-            
+
             // Post tables
-            if needsTable "post" then
-                "CREATE TABLE post (
-                    id               TEXT        NOT NULL PRIMARY KEY,
-                    web_log_id       TEXT        NOT NULL REFERENCES web_log (id),
-                    author_id        TEXT        NOT NULL REFERENCES web_log_user (id),
-                    status           TEXT        NOT NULL,
-                    title            TEXT        NOT NULL,
-                    permalink        TEXT        NOT NULL,
-                    prior_permalinks TEXT[]      NOT NULL DEFAULT '{}',
-                    published_on     TIMESTAMPTZ,
-                    updated_on       TIMESTAMPTZ NOT NULL,
-                    template         TEXT,
-                    post_text        TEXT        NOT NULL,
-                    tags             TEXT[],
-                    meta_items       JSONB,
-                    episode          JSONB)"
-                "CREATE INDEX post_web_log_idx   ON post (web_log_id)"
-                "CREATE INDEX post_author_idx    ON post (author_id)"
-                "CREATE INDEX post_status_idx    ON post (web_log_id, status, updated_on)"
-                "CREATE INDEX post_permalink_idx ON post (web_log_id, permalink)"
-            if needsTable "post_category" then
-                "CREATE TABLE post_category (
-                    post_id      TEXT NOT NULL REFERENCES post (id),
-                    category_id  TEXT NOT NULL REFERENCES category (id),
-                    PRIMARY KEY (post_id, category_id))"
-                "CREATE INDEX post_category_category_idx ON post_category (category_id)"
-            if needsTable "post_revision" then
-                "CREATE TABLE post_revision (
-                    post_id        TEXT        NOT NULL REFERENCES post (id),
+            if needsTable Table.Post then
+                Query.Definition.ensureTable   Table.Post
+                Query.Definition.ensureKey     Table.Post PostgreSQL
+                Query.Definition.ensureIndexOn Table.Post "author" [ nameof Post.Empty.AuthorId ] PostgreSQL
+                Query.Definition.ensureIndexOn
+                    Table.Post "permalink" [ nameof Post.Empty.WebLogId; nameof Post.Empty.Permalink ] PostgreSQL
+                Query.Definition.ensureIndexOn
+                    Table.Post
+                    "status"
+                    [ nameof Post.Empty.WebLogId; nameof Post.Empty.Status; nameof Post.Empty.UpdatedOn ]
+                    PostgreSQL
+                $"CREATE INDEX idx_post_category ON {Table.Post} USING GIN ((data['{nameof Post.Empty.CategoryIds}']))"
+                $"CREATE INDEX idx_post_tag      ON {Table.Post} USING GIN ((data['{nameof Post.Empty.Tags}']))"
+            if needsTable Table.PostRevision then
+                $"CREATE TABLE {Table.PostRevision} (
+                    post_id        TEXT        NOT NULL,
                     as_of          TIMESTAMPTZ NOT NULL,
                     revision_text  TEXT        NOT NULL,
                     PRIMARY KEY (post_id, as_of))"
-            if needsTable "post_comment" then
-                "CREATE TABLE post_comment (
-                    id              TEXT        NOT NULL PRIMARY KEY,
-                    post_id         TEXT        NOT NULL REFERENCES post(id),
-                    in_reply_to_id  TEXT,
-                    name            TEXT        NOT NULL,
-                    email           TEXT        NOT NULL,
-                    url             TEXT,
-                    status          TEXT        NOT NULL,
-                    posted_on       TIMESTAMPTZ NOT NULL,
-                    comment_text    TEXT        NOT NULL)"
-                "CREATE INDEX post_comment_post_idx ON post_comment (post_id)"
-            
+            if needsTable Table.PostComment then
+                Query.Definition.ensureTable   Table.PostComment
+                Query.Definition.ensureKey     Table.PostComment PostgreSQL
+                Query.Definition.ensureIndexOn Table.PostComment "post" [ nameof Comment.Empty.PostId ] PostgreSQL
+
             // Tag map table
-            if needsTable "tag_map" then
-                "CREATE TABLE tag_map (
-                    id          TEXT NOT NULL PRIMARY KEY,
-                    web_log_id  TEXT NOT NULL REFERENCES web_log (id),
-                    tag         TEXT NOT NULL,
-                    url_value   TEXT NOT NULL)"
-                "CREATE INDEX tag_map_web_log_idx ON tag_map (web_log_id)"
-            
+            if needsTable Table.TagMap then
+                Query.Definition.ensureTable         Table.TagMap
+                Query.Definition.ensureKey           Table.TagMap PostgreSQL
+                Query.Definition.ensureDocumentIndex Table.TagMap Optimized
+
             // Uploaded file table
-            if needsTable "upload" then
-                "CREATE TABLE upload (
+            if needsTable Table.Upload then
+                $"CREATE TABLE {Table.Upload} (
                     id          TEXT        NOT NULL PRIMARY KEY,
-                    web_log_id  TEXT        NOT NULL REFERENCES web_log (id),
+                    web_log_id  TEXT        NOT NULL,
                     path        TEXT        NOT NULL,
                     updated_on  TIMESTAMPTZ NOT NULL,
                     data        BYTEA       NOT NULL)"
-                "CREATE INDEX upload_web_log_idx ON upload (web_log_id)"
-                "CREATE INDEX upload_path_idx    ON upload (web_log_id, path)"
-            
+                $"CREATE INDEX idx_upload_web_log ON {Table.Upload} (web_log_id)"
+                $"CREATE INDEX idx_upload_path    ON {Table.Upload} (web_log_id, path)"
+
             // Database version table
-            if needsTable "db_version" then
-                "CREATE TABLE db_version (id TEXT NOT NULL PRIMARY KEY)"
-                $"INSERT INTO db_version VALUES ('{Utils.currentDbVersion}')"
+            if needsTable Table.DbVersion then
+                $"CREATE TABLE {Table.DbVersion} (id TEXT NOT NULL PRIMARY KEY)"
+                $"INSERT INTO {Table.DbVersion} VALUES ('{Utils.Migration.currentDbVersion}')"
         }
-        
-        Sql.existingConnection conn
+
+        Configuration.dataSource ()
+        |> Sql.fromDataSource
         |> Sql.executeTransactionAsync
             (sql
              |> Seq.map (fun s ->
-                let parts = s.Split ' '
-                if parts[1].ToLowerInvariant () = "table" then
+                let parts = s.Replace(" IF NOT EXISTS", "", System.StringComparison.OrdinalIgnoreCase).Split ' '
+                if parts[1].ToLowerInvariant() = "table" then
                     log.LogInformation $"Creating {parts[2]} table..."
                 s, [ [] ])
              |> List.ofSeq)
@@ -210,51 +128,157 @@ type PostgresData (conn : NpgsqlConnection, log : ILogger<PostgresData>, ser : J
         |> Async.RunSynchronously
         |> ignore
     }
-    
+
     /// Set a specific database version
     let setDbVersion version = backgroundTask {
-        let! _ =
-            Sql.existingConnection conn
-            |> Sql.query $"DELETE FROM db_version; INSERT INTO db_version VALUES ('%s{version}')"
-            |> Sql.executeNonQueryAsync
-        ()
+        do! Custom.nonQuery $"DELETE FROM db_version; INSERT INTO db_version VALUES ('%s{version}')" []
+        return version
     }
-    
+
+    /// Migrate from v2-rc2 to v2 (manual migration required)
+    let migrateV2Rc2ToV2 () = backgroundTask {
+        let! webLogs =
+            Custom.list
+                $"SELECT url_base, slug FROM {Table.WebLog}" [] (fun row -> row.string "url_base", row.string "slug")
+        Utils.Migration.backupAndRestoreRequired log "v2-rc2" "v2" webLogs
+    }
+
+    /// Migrate from v2 to v2.1.1
+    let migrateV2ToV2point1point1 () = backgroundTask {
+        let migration = "v2 to v2.1.1"
+        Utils.Migration.logStep log migration "Adding empty redirect rule set to all weblogs"
+        do! Custom.nonQuery $"""UPDATE {Table.WebLog} SET data = data || '{{ "RedirectRules": [] }}'::jsonb""" []
+
+        let tables =
+            [ Table.Category; Table.Page; Table.Post; Table.PostComment; Table.TagMap; Table.Theme; Table.WebLog
+              Table.WebLogUser ]
+
+        Utils.Migration.logStep log migration "Adding unique indexes on ID fields"
+        do! Custom.nonQuery
+                (tables |> List.map (fun it -> Query.Definition.ensureKey it PostgreSQL) |> String.concat "; ") []
+
+        Utils.Migration.logStep log migration "Removing constraints"
+        let fkToDrop =
+            [ "page_revision", "page_revision_page_id_fkey"
+              "post_revision", "post_revision_post_id_fkey"
+              "theme_asset",   "theme_asset_theme_id_fkey"
+              "upload",        "upload_web_log_id_fkey"
+              "category",      "category_pkey"
+              "page",          "page_pkey"
+              "post",          "post_pkey"
+              "post_comment",  "post_comment_pkey"
+              "tag_map",       "tag_map_pkey"
+              "theme",         "theme_pkey"
+              "web_log",       "web_log_pkey"
+              "web_log_user",  "web_log_user_pkey" ]
+        do! Custom.nonQuery
+                (fkToDrop
+                 |> List.map (fun (tbl, fk) -> $"ALTER TABLE {tbl} DROP CONSTRAINT {fk}")
+                 |> String.concat "; ")
+                []
+
+        Utils.Migration.logStep log migration "Dropping old indexes"
+        let toDrop =
+            [ "idx_category"; "page_author_idx"; "page_permalink_idx"; "page_web_log_idx"; "post_author_idx"
+              "post_category_idx"; "post_permalink_idx"; "post_status_idx"; "post_tag_idx"; "post_web_log_idx"
+              "post_comment_post_idx"; "idx_tag_map"; "idx_web_log"; "idx_web_log_user" ]
+        do! Custom.nonQuery (toDrop |> List.map (sprintf "DROP INDEX %s") |> String.concat "; ") []
+
+        Utils.Migration.logStep log migration "Dropping old ID columns"
+        do! Custom.nonQuery (tables |> List.map (sprintf "ALTER TABLE %s DROP COLUMN id") |> String.concat "; ") []
+
+        Utils.Migration.logStep log migration "Adding new indexes"
+        let newIdx =
+            [ yield! tables |> List.map (fun it -> Query.Definition.ensureKey it PostgreSQL)
+              Query.Definition.ensureDocumentIndex Table.Category   Optimized
+              Query.Definition.ensureDocumentIndex Table.TagMap     Optimized
+              Query.Definition.ensureDocumentIndex Table.WebLog     Optimized
+              Query.Definition.ensureDocumentIndex Table.WebLogUser Optimized
+              Query.Definition.ensureIndexOn Table.Page "author" [ nameof Page.Empty.AuthorId ] PostgreSQL
+              Query.Definition.ensureIndexOn
+                  Table.Page "permalink" [ nameof Page.Empty.WebLogId; nameof Page.Empty.Permalink ] PostgreSQL
+              Query.Definition.ensureIndexOn Table.Post "author" [ nameof Post.Empty.AuthorId ] PostgreSQL
+              Query.Definition.ensureIndexOn
+                  Table.Post "permalink" [ nameof Post.Empty.WebLogId; nameof Post.Empty.Permalink ] PostgreSQL
+              Query.Definition.ensureIndexOn
+                  Table.Post
+                  "status"
+                  [ nameof Post.Empty.WebLogId; nameof Post.Empty.Status; nameof Post.Empty.UpdatedOn ]
+                  PostgreSQL
+              $"CREATE INDEX idx_post_category ON {Table.Post} USING GIN ((data['{nameof Post.Empty.CategoryIds}']))"
+              $"CREATE INDEX idx_post_tag      ON {Table.Post} USING GIN ((data['{nameof Post.Empty.Tags}']))"
+              Query.Definition.ensureIndexOn Table.PostComment "post" [ nameof Comment.Empty.PostId ] PostgreSQL ]
+        do! Custom.nonQuery (newIdx |> String.concat "; ") []
+
+        Utils.Migration.logStep log migration "Setting database to version 2.1.1"
+        return! setDbVersion "v2.1.1"
+    }
+
+    /// Migrate from v2.1.1 to v2.2
+    let migrateV2point1point1ToV2point2 () = backgroundTask {
+        Utils.Migration.logStep log "v2.1.1 to v2.2" "Setting e-mail to lowercase"
+        do! Custom.nonQuery
+                $"""UPDATE {Table.WebLogUser} SET data = data || ('{{"Email":"' || lower(data->>'Email') || '"}}')::jsonb"""
+                []
+        Utils.Migration.logStep log "v2.1.1 to v2.2" "Setting database version to v2.2"
+        return! setDbVersion "v2.2"
+    }
+
+    /// Migrate from v2.2 to v3
+    let migrateV2point2ToV3 () = backgroundTask {
+        Utils.Migration.logStep log "v2.2 to v3" "Adding auto-OpenGraph flag to all web logs"
+        do! Patch.byFields Table.WebLog Any [ Field.Exists (nameof WebLog.Empty.Id) ] {| AutoOpenGraph = true |}
+        Utils.Migration.logStep log "v2.2 to v3" "Setting database version to v3"
+        return! setDbVersion "v3"
+    }
+
     /// Do required data migration between versions
     let migrate version = backgroundTask {
-        match version with
-        | Some "v2-rc2" -> ()
-        // Future versions will be inserted here
-        | Some _
-        | None ->
-            log.LogWarning $"Unknown database version; assuming {Utils.currentDbVersion}"
-            do! setDbVersion Utils.currentDbVersion
+        let mutable v = defaultArg version ""
+
+        if v = "v2-rc2" then
+            let! webLogs =
+                Custom.list
+                    $"SELECT url_base, slug FROM {Table.WebLog}" []
+                    (fun row -> row.string "url_base", row.string "slug")
+            Utils.Migration.backupAndRestoreRequired log "v2-rc2" "v2" webLogs
+
+        if v = "v2" then
+            let! ver = migrateV2ToV2point1point1 ()
+            v <- ver
+
+        if v = "v2.1.1" then
+            let! ver = migrateV2point1point1ToV2point2 ()
+            v <- ver
+
+        if v = "v2.2" then
+            let! ver = migrateV2point2ToV3 ()
+            v <- ver
+
+        if v <> Utils.Migration.currentDbVersion then
+            log.LogWarning $"Unknown database version; assuming {Utils.Migration.currentDbVersion}"
+            let! _ = setDbVersion Utils.Migration.currentDbVersion
+            ()
     }
-        
+
     interface IData with
-        
-        member _.Category   = PostgresCategoryData   conn
-        member _.Page       = PostgresPageData       (conn, ser)
-        member _.Post       = PostgresPostData       (conn, ser)
-        member _.TagMap     = PostgresTagMapData     conn
-        member _.Theme      = PostgresThemeData      conn
-        member _.ThemeAsset = PostgresThemeAssetData conn
-        member _.Upload     = PostgresUploadData     conn
-        member _.WebLog     = PostgresWebLogData     (conn, ser)
-        member _.WebLogUser = PostgresWebLogUserData conn
-        
+
+        member _.Category   = PostgresCategoryData   log
+        member _.Page       = PostgresPageData       log
+        member _.Post       = PostgresPostData       log
+        member _.TagMap     = PostgresTagMapData     log
+        member _.Theme      = PostgresThemeData      log
+        member _.ThemeAsset = PostgresThemeAssetData log
+        member _.Upload     = PostgresUploadData     log
+        member _.WebLog     = PostgresWebLogData     log
+        member _.WebLogUser = PostgresWebLogUserData log
+
         member _.Serializer = ser
-        
+
         member _.StartUp () = backgroundTask {
+            log.LogTrace "PostgresData.StartUp"
             do! ensureTables ()
-            
-            let! version =
-                Sql.existingConnection conn
-                |> Sql.query "SELECT id FROM db_version"
-                |> Sql.executeAsync (fun row -> row.string "id")
-                |> tryHead
-            match version with
-            | Some v when v = Utils.currentDbVersion -> ()
-            | Some _
-            | None -> do! migrate version 
+
+            let! version = Custom.single "SELECT id FROM db_version" [] (fun row -> row.string "id")
+            do! migrate version
         }

src/MyWebLog.Data/SQLite/Helpers.fs

@@ -1,314 +0,0 @@
-/// Helper functions for the SQLite data implementation
-[<AutoOpen>]
-module MyWebLog.Data.SQLite.Helpers
-
-open System
-open Microsoft.Data.Sqlite
-open MyWebLog
-open MyWebLog.Data
-open NodaTime.Text
-
-/// Run a command that returns a count
-let count (cmd : SqliteCommand) = backgroundTask {
-    let! it = cmd.ExecuteScalarAsync ()
-    return int (it :?> int64)
-}
-
-/// Create a list of items from the given data reader
-let toList<'T> (it : SqliteDataReader -> 'T) (rdr : SqliteDataReader) =
-    seq { while rdr.Read () do it rdr }
-    |> List.ofSeq
-
-/// Verify that the web log ID matches before returning an item
-let verifyWebLog<'T> webLogId (prop : 'T -> WebLogId) (it : SqliteDataReader -> 'T) (rdr : SqliteDataReader) =
-    if rdr.Read () then
-        let item = it rdr
-        if prop item = webLogId then Some item else None
-    else None
-
-/// Execute a command that returns no data
-let write (cmd : SqliteCommand) = backgroundTask {
-    let! _ = cmd.ExecuteNonQueryAsync ()
-    ()
-}
-
-/// Add a possibly-missing parameter, substituting null for None
-let maybe<'T> (it : 'T option) : obj = match it with Some x -> x :> obj | None -> DBNull.Value
-
-/// Create a value for a Duration
-let durationParam =
-    DurationPattern.Roundtrip.Format
-
-/// Create a value for an Instant
-let instantParam =
-    InstantPattern.General.Format
-
-/// Create an optional value for a Duration
-let maybeDuration =
-    Option.map durationParam >> maybe
-
-/// Create an optional value for an Instant
-let maybeInstant =
-    Option.map instantParam >> maybe
-
-/// Create the SQL and parameters for an IN clause
-let inClause<'T> colNameAndPrefix paramName (valueFunc: 'T -> string) (items : 'T list) =
-    if List.isEmpty items then "", []
-    else
-        let mutable idx = 0
-        items
-        |> List.skip 1
-        |> List.fold (fun (itemS, itemP) it ->
-            idx <- idx + 1
-            $"{itemS}, @%s{paramName}{idx}", (SqliteParameter ($"@%s{paramName}{idx}", valueFunc it) :: itemP))
-            (Seq.ofList items
-             |> Seq.map (fun it ->
-                 $"%s{colNameAndPrefix} IN (@%s{paramName}0", [ SqliteParameter ($"@%s{paramName}0", valueFunc it) ])
-             |> Seq.head)
-        |> function sql, ps -> $"{sql})", ps
-
-
-/// Functions to map domain items from a data reader
-module Map =
-    
-    open System.IO
-    
-    /// Get a boolean value from a data reader
-    let getBoolean col (rdr : SqliteDataReader) = rdr.GetBoolean (rdr.GetOrdinal col)
-    
-    /// Get a date/time value from a data reader
-    let getDateTime col (rdr : SqliteDataReader) = rdr.GetDateTime (rdr.GetOrdinal col)
-    
-    /// Get a Guid value from a data reader
-    let getGuid col (rdr : SqliteDataReader) = rdr.GetGuid (rdr.GetOrdinal col)
-    
-    /// Get an int value from a data reader
-    let getInt col (rdr : SqliteDataReader) = rdr.GetInt32 (rdr.GetOrdinal col)
-    
-    /// Get a long (64-bit int) value from a data reader
-    let getLong col (rdr : SqliteDataReader) = rdr.GetInt64 (rdr.GetOrdinal col)
-    
-    /// Get a BLOB stream value from a data reader
-    let getStream col (rdr : SqliteDataReader) = rdr.GetStream (rdr.GetOrdinal col)
-    
-    /// Get a string value from a data reader
-    let getString col (rdr : SqliteDataReader) = rdr.GetString (rdr.GetOrdinal col)
-    
-    /// Parse a Duration from the given value
-    let parseDuration value =
-        match DurationPattern.Roundtrip.Parse value with
-        | it when it.Success -> it.Value
-        | it -> raise it.Exception
-    
-    /// Get a Duration value from a data reader
-    let getDuration col rdr =
-        getString col rdr |> parseDuration
-    
-    /// Parse an Instant from the given value
-    let parseInstant value =
-        match InstantPattern.General.Parse value with
-        | it when it.Success -> it.Value
-        | it -> raise it.Exception
-    
-    /// Get an Instant value from a data reader
-    let getInstant col rdr =
-        getString col rdr |> parseInstant
-    
-    /// Get a timespan value from a data reader
-    let getTimeSpan col (rdr : SqliteDataReader) = rdr.GetTimeSpan (rdr.GetOrdinal col)
-    
-    /// Get a possibly null boolean value from a data reader
-    let tryBoolean col (rdr : SqliteDataReader) =
-        if rdr.IsDBNull (rdr.GetOrdinal col) then None else Some (getBoolean col rdr)
-    
-    /// Get a possibly null date/time value from a data reader
-    let tryDateTime col (rdr : SqliteDataReader) =
-        if rdr.IsDBNull (rdr.GetOrdinal col) then None else Some (getDateTime col rdr)
-    
-    /// Get a possibly null Guid value from a data reader
-    let tryGuid col (rdr : SqliteDataReader) =
-        if rdr.IsDBNull (rdr.GetOrdinal col) then None else Some (getGuid col rdr)
-    
-    /// Get a possibly null int value from a data reader
-    let tryInt col (rdr : SqliteDataReader) =
-        if rdr.IsDBNull (rdr.GetOrdinal col) then None else Some (getInt col rdr)
-    
-    /// Get a possibly null string value from a data reader
-    let tryString col (rdr : SqliteDataReader) =
-        if rdr.IsDBNull (rdr.GetOrdinal col) then None else Some (getString col rdr)
-    
-    /// Get a possibly null Duration value from a data reader
-    let tryDuration col rdr =
-        tryString col rdr |> Option.map parseDuration
-    
-    /// Get a possibly null Instant value from a data reader
-    let tryInstant col rdr =
-        tryString col rdr |> Option.map parseInstant
-    
-    /// Get a possibly null timespan value from a data reader
-    let tryTimeSpan col (rdr : SqliteDataReader) =
-        if rdr.IsDBNull (rdr.GetOrdinal col) then None else Some (getTimeSpan col rdr)
-    
-    /// Map an id field to a category ID
-    let toCategoryId rdr = getString "id" rdr |> CategoryId
-    
-    /// Create a category from the current row in the given data reader
-    let toCategory rdr : Category =
-        {   Id          = toCategoryId            rdr
-            WebLogId    = getString "web_log_id"  rdr |> WebLogId
-            Name        = getString "name"        rdr
-            Slug        = getString "slug"        rdr
-            Description = tryString "description" rdr
-            ParentId    = tryString "parent_id"   rdr |> Option.map CategoryId
-        }
-    
-    /// Create a custom feed from the current row in the given data reader
-    let toCustomFeed ser rdr : CustomFeed =
-        {   Id      = getString "id"      rdr |> CustomFeedId
-            Source  = getString "source"  rdr |> CustomFeedSource.parse
-            Path    = getString "path"    rdr |> Permalink
-            Podcast = tryString "podcast" rdr |> Option.map (Utils.deserialize ser)
-        }
-    
-    /// Create a permalink from the current row in the given data reader
-    let toPermalink rdr = getString "permalink" rdr |> Permalink
-    
-    /// Create a page from the current row in the given data reader
-    let toPage ser rdr : Page =
-        { Page.empty with
-            Id           = getString   "id"              rdr |> PageId
-            WebLogId     = getString   "web_log_id"      rdr |> WebLogId
-            AuthorId     = getString   "author_id"       rdr |> WebLogUserId
-            Title        = getString   "title"           rdr
-            Permalink    = toPermalink                   rdr
-            PublishedOn  = getInstant  "published_on"    rdr
-            UpdatedOn    = getInstant  "updated_on"      rdr
-            IsInPageList = getBoolean  "is_in_page_list" rdr
-            Template     = tryString   "template"        rdr
-            Text         = getString   "page_text"       rdr
-            Metadata     = tryString   "meta_items"   rdr
-                           |> Option.map (Utils.deserialize ser)
-                           |> Option.defaultValue []
-        }
-    
-    /// Create a post from the current row in the given data reader
-    let toPost ser rdr : Post =
-        { Post.empty with
-            Id          = getString   "id"           rdr |> PostId
-            WebLogId    = getString   "web_log_id"   rdr |> WebLogId
-            AuthorId    = getString   "author_id"    rdr |> WebLogUserId
-            Status      = getString   "status"       rdr |> PostStatus.parse
-            Title       = getString   "title"        rdr
-            Permalink   = toPermalink                rdr
-            PublishedOn = tryInstant  "published_on" rdr
-            UpdatedOn   = getInstant  "updated_on"   rdr
-            Template    = tryString   "template"     rdr
-            Text        = getString   "post_text"    rdr
-            Episode     = tryString   "episode"      rdr |> Option.map (Utils.deserialize ser)
-            Metadata    = tryString   "meta_items"   rdr
-                          |> Option.map (Utils.deserialize ser)
-                          |> Option.defaultValue []
-        }
-    
-    /// Create a revision from the current row in the given data reader
-    let toRevision rdr : Revision =
-        {   AsOf = getInstant "as_of"         rdr
-            Text = getString  "revision_text" rdr |> MarkupText.parse
-        }
-    
-    /// Create a tag mapping from the current row in the given data reader
-    let toTagMap rdr : TagMap =
-        {   Id       = getString "id"         rdr |> TagMapId
-            WebLogId = getString "web_log_id" rdr |> WebLogId
-            Tag      = getString "tag"        rdr
-            UrlValue = getString "url_value"  rdr
-        }
-    
-    /// Create a theme from the current row in the given data reader (excludes templates)
-    let toTheme rdr : Theme =
-        { Theme.empty with
-            Id      = getString "id"      rdr |> ThemeId
-            Name    = getString "name"    rdr
-            Version = getString "version" rdr
-        }
-    
-    /// Create a theme asset from the current row in the given data reader
-    let toThemeAsset includeData rdr : ThemeAsset =
-        let assetData =
-            if includeData then
-                use dataStream = new MemoryStream ()
-                use blobStream = getStream "data" rdr
-                blobStream.CopyTo dataStream
-                dataStream.ToArray ()
-            else
-                [||]
-        {   Id        = ThemeAssetId (ThemeId (getString "theme_id" rdr), getString "path" rdr)
-            UpdatedOn = getInstant "updated_on" rdr
-            Data      = assetData
-        }
-    
-    /// Create a theme template from the current row in the given data reader
-    let toThemeTemplate includeText rdr : ThemeTemplate =
-        {   Name = getString "name" rdr
-            Text = if includeText then getString "template" rdr else ""
-        }
-    
-    /// Create an uploaded file from the current row in the given data reader
-    let toUpload includeData rdr : Upload =
-        let data =
-            if includeData then
-                use dataStream = new MemoryStream ()
-                use blobStream = getStream "data" rdr
-                blobStream.CopyTo dataStream
-                dataStream.ToArray ()
-            else
-                [||]
-        {   Id        = getString  "id"         rdr |> UploadId
-            WebLogId  = getString  "web_log_id" rdr |> WebLogId
-            Path      = getString  "path"       rdr |> Permalink
-            UpdatedOn = getInstant "updated_on" rdr
-            Data      = data
-        }
-    
-    /// Create a web log from the current row in the given data reader
-    let toWebLog rdr : WebLog =
-        {   Id           = getString  "id"             rdr |> WebLogId
-            Name         = getString  "name"           rdr
-            Slug         = getString  "slug"           rdr
-            Subtitle     = tryString  "subtitle"       rdr
-            DefaultPage  = getString  "default_page"   rdr
-            PostsPerPage = getInt     "posts_per_page" rdr
-            ThemeId      = getString  "theme_id"       rdr |> ThemeId
-            UrlBase      = getString  "url_base"       rdr
-            TimeZone     = getString  "time_zone"      rdr
-            AutoHtmx     = getBoolean "auto_htmx"      rdr
-            Uploads      = getString  "uploads"        rdr |> UploadDestination.parse
-            Rss          = {
-                IsFeedEnabled     = getBoolean "is_feed_enabled"     rdr
-                FeedName          = getString  "feed_name"           rdr
-                ItemsInFeed       = tryInt     "items_in_feed"       rdr
-                IsCategoryEnabled = getBoolean "is_category_enabled" rdr
-                IsTagEnabled      = getBoolean "is_tag_enabled"      rdr
-                Copyright         = tryString  "copyright"           rdr
-                CustomFeeds       = []
-            }
-        }
-    
-    /// Create a web log user from the current row in the given data reader
-    let toWebLogUser rdr : WebLogUser =
-        {   Id            = getString  "id"             rdr |> WebLogUserId
-            WebLogId      = getString  "web_log_id"     rdr |> WebLogId
-            Email         = getString  "email"          rdr
-            FirstName     = getString  "first_name"     rdr
-            LastName      = getString  "last_name"      rdr
-            PreferredName = getString  "preferred_name" rdr
-            PasswordHash  = getString  "password_hash"  rdr
-            Url           = tryString  "url"            rdr
-            AccessLevel   = getString  "access_level"   rdr |> AccessLevel.parse
-            CreatedOn     = getInstant "created_on"     rdr
-            LastSeenOn    = tryInstant "last_seen_on"   rdr
-        }
-
-/// Add a web log ID parameter
-let addWebLogId (cmd : SqliteCommand) webLogId =
-    cmd.Parameters.AddWithValue ("@webLogId", WebLogId.toString webLogId) |> ignore

src/MyWebLog.Data/SQLite/SQLiteCategoryData.fs

@@ -1,174 +1,121 @@
 namespace MyWebLog.Data.SQLite
 
 open System.Threading.Tasks
+open BitBadger.Documents
+open BitBadger.Documents.Sqlite
 open Microsoft.Data.Sqlite
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
+open Newtonsoft.Json
 
-/// SQLite myWebLog category data implementation        
-type SQLiteCategoryData (conn : SqliteConnection) =
+/// SQLite myWebLog category data implementation
+type SQLiteCategoryData(conn: SqliteConnection, ser: JsonSerializer, log: ILogger) =
     
-    /// Add parameters for category INSERT or UPDATE statements
-    let addCategoryParameters (cmd : SqliteCommand) (cat : Category) =
-        [   cmd.Parameters.AddWithValue ("@id",          CategoryId.toString cat.Id)
-            cmd.Parameters.AddWithValue ("@webLogId",    WebLogId.toString cat.WebLogId)
-            cmd.Parameters.AddWithValue ("@name",        cat.Name)
-            cmd.Parameters.AddWithValue ("@slug",        cat.Slug)
-            cmd.Parameters.AddWithValue ("@description", maybe cat.Description)
-            cmd.Parameters.AddWithValue ("@parentId",    maybe (cat.ParentId |> Option.map CategoryId.toString))
-        ] |> ignore
-    
-    /// Add a category
-    let add cat = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            "INSERT INTO category (
-                id, web_log_id, name, slug, description, parent_id
-            ) VALUES (
-                @id, @webLogId, @name, @slug, @description, @parentId
-            )"
-        addCategoryParameters cmd cat
-        let! _ = cmd.ExecuteNonQueryAsync ()
-        ()
-    }
+    /// The name of the parent ID field
+    let parentIdField = nameof Category.Empty.ParentId
     
     /// Count all categories for the given web log
     let countAll webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT COUNT(id) FROM category WHERE web_log_id = @webLogId"
-        addWebLogId cmd webLogId
-        return! count cmd
+        log.LogTrace "Category.countAll"
+        let! count = conn.countByFields Table.Category Any [ webLogField webLogId ]
+        return int count
     }
     
     /// Count all top-level categories for the given web log
     let countTopLevel webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            "SELECT COUNT(id) FROM category WHERE web_log_id = @webLogId AND parent_id IS NULL"
-        addWebLogId cmd webLogId
-        return! count cmd
+        log.LogTrace "Category.countTopLevel"
+        let! count = conn.countByFields Table.Category All [ webLogField webLogId; Field.NotExists parentIdField ]
+        return int count
     }
     
+    /// Find all categories for the given web log
+    let findByWebLog webLogId =
+        log.LogTrace "Category.findByWebLog"
+        conn.findByFields<Category> Table.Category Any [ webLogField webLogId ]
+    
     /// Retrieve all categories for the given web log in a DotLiquid-friendly format
     let findAllForView webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM category WHERE web_log_id = @webLogId"
-        addWebLogId cmd webLogId
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let cats =
-            seq {
-                while rdr.Read () do
-                    Map.toCategory rdr
-            }
-            |> Seq.sortBy (fun cat -> cat.Name.ToLowerInvariant ())
-            |> List.ofSeq
-        do! rdr.CloseAsync ()
-        let  ordered = Utils.orderByHierarchy cats None None []
+        log.LogTrace "Category.findAllForView"
+        let! cats    = findByWebLog webLogId
+        let  ordered = Utils.orderByHierarchy (cats |> List.sortBy _.Name.ToLowerInvariant()) None None []
         let! counts  =
             ordered
             |> Seq.map (fun it -> backgroundTask {
                 // Parent category post counts include posts in subcategories
-                let catSql, catParams =
+                let childField =
                     ordered
                     |> Seq.filter (fun cat -> cat.ParentNames |> Array.contains it.Name)
-                    |> Seq.map (fun cat -> cat.Id)
+                    |> Seq.map _.Id
                     |> Seq.append (Seq.singleton it.Id)
-                    |> List.ofSeq
-                    |> inClause "AND pc.category_id" "catId" id
-                cmd.Parameters.Clear ()
-                addWebLogId cmd webLogId
-                cmd.Parameters.AddRange catParams
-                cmd.CommandText <- $"
-                    SELECT COUNT(DISTINCT p.id)
-                      FROM post p
-                           INNER JOIN post_category pc ON pc.post_id = p.id
-                     WHERE p.web_log_id = @webLogId
-                       AND p.status     = 'Published'
-                       {catSql}"
-                let! postCount = count cmd
-                return it.Id, postCount
-                })
+                    |> Field.InArray (nameof Post.Empty.CategoryIds) Table.Post
+                let fields =
+                    [ webLogField webLogId; Field.Equal (nameof Post.Empty.Status) (string Published); childField ]
+                let query =
+                    (Query.statementWhere (Query.count Table.Post) (Query.whereByFields All fields))
+                        .Replace("(*)", $"(DISTINCT data->>'{nameof Post.Empty.Id}')")
+                let! postCount = conn.customScalar query (addFieldParams fields []) toCount
+                return it.Id, int postCount
+            })
             |> Task.WhenAll
         return
             ordered
             |> Seq.map (fun cat ->
                 { cat with
-                    PostCount = counts
-                                |> Array.tryFind (fun c -> fst c = cat.Id)
-                                |> Option.map snd
-                                |> Option.defaultValue 0
+                    PostCount = defaultArg (counts |> Array.tryFind (fun c -> fst c = cat.Id) |> Option.map snd) 0
                 })
             |> Array.ofSeq
     }
-    /// Find a category by its ID for the given web log
-    let findById catId webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM category WHERE id = @id"
-        cmd.Parameters.AddWithValue ("@id", CategoryId.toString catId) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return Helpers.verifyWebLog<Category> webLogId (fun c -> c.WebLogId) Map.toCategory rdr
-    }
     
-    /// Find all categories for the given web log
-    let findByWebLog webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM category WHERE web_log_id = @webLogId"
-        cmd.Parameters.AddWithValue ("@webLogId", WebLogId.toString webLogId) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList Map.toCategory rdr
-    }
+    /// Find a category by its ID for the given web log
+    let findById (catId: CategoryId) webLogId =
+        log.LogTrace "Category.findById"
+        conn.findFirstByFields<Category> Table.Category All [ idField catId; webLogField webLogId ]
     
     /// Delete a category
     let delete catId webLogId = backgroundTask {
+        log.LogTrace "Category.delete"
         match! findById catId webLogId with
         | Some cat ->
-            use cmd = conn.CreateCommand ()
             // Reassign any children to the category's parent category
-            cmd.CommandText <- "SELECT COUNT(id) FROM category WHERE parent_id = @parentId"
-            cmd.Parameters.AddWithValue ("@parentId", CategoryId.toString catId) |> ignore
-            let! children = count cmd
-            if children > 0 then
-                cmd.CommandText <- "UPDATE category SET parent_id = @newParentId WHERE parent_id = @parentId"
-                cmd.Parameters.AddWithValue ("@newParentId", maybe (cat.ParentId |> Option.map CategoryId.toString))
-                |> ignore
-                do! write cmd
+            let! children = conn.countByFields Table.Category Any [ Field.Equal parentIdField (string catId) ]
+            if children > 0L then
+                let parent = [ Field.Equal parentIdField (string catId) ]
+                match cat.ParentId with
+                | Some _ -> do! conn.patchByFields Table.Category Any parent {| ParentId = cat.ParentId |}
+                | None -> do! conn.removeFieldsByFields Table.Category Any parent [ parentIdField ]
             // Delete the category off all posts where it is assigned, and the category itself
-            cmd.CommandText <-
-                "DELETE FROM post_category
-                  WHERE category_id = @id
-                    AND post_id IN (SELECT id FROM post WHERE web_log_id = @webLogId);
-                 DELETE FROM category WHERE id = @id"
-            cmd.Parameters.Clear ()
-            let _ = cmd.Parameters.AddWithValue ("@id", CategoryId.toString catId)
-            addWebLogId cmd webLogId
-            do! write cmd
-            return if children = 0 then CategoryDeleted else ReassignedChildCategories
+            let catIdField = nameof Post.Empty.CategoryIds
+            let fields     = [ webLogField webLogId; Field.InArray catIdField Table.Post [ string catId ] ]
+            let query      =
+                (Query.statementWhere (Query.find Table.Post) (Query.whereByFields All fields))
+                    .Replace("SELECT data", $"SELECT data->>'{nameof Post.Empty.Id}', data->'{catIdField}'")
+            let! posts =
+                conn.customList
+                    query
+                    (addFieldParams fields [])
+                    (fun rdr -> rdr.GetString 0, Utils.deserialize<string list> ser (rdr.GetString 1))
+            for postId, cats in posts do
+                do! conn.patchById
+                        Table.Post postId {| CategoryIds = cats |> List.filter (fun it -> it <> string catId) |}
+            do! conn.deleteById Table.Category catId
+            return if children = 0L then CategoryDeleted else ReassignedChildCategories
         | None -> return CategoryNotFound
     }
     
+    /// Save a category
+    let save cat =
+        log.LogTrace "Category.save"
+        conn.save<Category> Table.Category cat
+    
     /// Restore categories from a backup
     let restore cats = backgroundTask {
-        for cat in cats do
-            do! add cat
-    }
-    
-    /// Update a category
-    let update cat = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            "UPDATE category
-                SET name        = @name,
-                    slug        = @slug,
-                    description = @description,
-                    parent_id   = @parentId
-              WHERE id         = @id
-                AND web_log_id = @webLogId"
-        addCategoryParameters cmd cat
-        do! write cmd
+        log.LogTrace "Category.restore"
+        for cat in cats do do! save cat
     }
     
     interface ICategoryData with
-        member _.Add cat = add cat
+        member _.Add cat = save cat
         member _.CountAll webLogId = countAll webLogId
         member _.CountTopLevel webLogId = countTopLevel webLogId
         member _.FindAllForView webLogId = findAllForView webLogId
@@ -176,4 +123,4 @@ type SQLiteCategoryData (conn : SqliteConnection) =
         member _.FindByWebLog webLogId = findByWebLog webLogId
         member _.Delete catId webLogId = delete catId webLogId
         member _.Restore cats = restore cats
-        member _.Update cat = update cat
+        member _.Update cat = save cat

src/MyWebLog.Data/SQLite/SQLiteHelpers.fs

@@ -0,0 +1,241 @@
+/// Helper functions for the SQLite data implementation
+[<AutoOpen>]
+module MyWebLog.Data.SQLite.SQLiteHelpers
+
+/// The table names used in the SQLite implementation
+[<RequireQualifiedAccess>]
+module Table =
+
+    /// Categories
+    [<Literal>]
+    let Category = "category"
+
+    /// Database Version
+    [<Literal>]
+    let DbVersion = "db_version"
+
+    /// Pages
+    [<Literal>]
+    let Page = "page"
+
+    /// Page Revisions
+    [<Literal>]
+    let PageRevision = "page_revision"
+
+    /// Posts
+    [<Literal>]
+    let Post = "post"
+
+    /// Post Comments
+    [<Literal>]
+    let PostComment = "post_comment"
+
+    /// Post Revisions
+    [<Literal>]
+    let PostRevision = "post_revision"
+
+    /// Tag/URL Mappings
+    [<Literal>]
+    let TagMap = "tag_map"
+
+    /// Themes
+    [<Literal>]
+    let Theme = "theme"
+
+    /// Theme Assets
+    [<Literal>]
+    let ThemeAsset = "theme_asset"
+
+    /// Uploads
+    [<Literal>]
+    let Upload = "upload"
+
+    /// Web Logs
+    [<Literal>]
+    let WebLog = "web_log"
+
+    /// Users
+    [<Literal>]
+    let WebLogUser = "web_log_user"
+
+
+open System
+open Microsoft.Data.Sqlite
+open MyWebLog
+open MyWebLog.Data
+open NodaTime.Text
+
+/// Execute a command that returns no data
+let write (cmd: SqliteCommand) = backgroundTask {
+    let! _ = cmd.ExecuteNonQueryAsync()
+    ()
+}
+
+/// Add a possibly-missing parameter, substituting null for None
+let maybe<'T> (it: 'T option) : obj = match it with Some x -> x :> obj | None -> DBNull.Value
+
+/// Create a value for an Instant
+let instantParam =
+    InstantPattern.General.Format
+
+/// Create an optional value for an Instant
+let maybeInstant =
+    Option.map instantParam >> maybe
+
+
+/// Functions to map domain items from a data reader
+module Map =
+
+    open System.IO
+
+    /// Get a boolean value from a data reader
+    let getBoolean col (rdr: SqliteDataReader) = rdr.GetBoolean(rdr.GetOrdinal col)
+
+    /// Get a date/time value from a data reader
+    let getDateTime col (rdr: SqliteDataReader) = rdr.GetDateTime(rdr.GetOrdinal col)
+
+    /// Get a Guid value from a data reader
+    let getGuid col (rdr: SqliteDataReader) = rdr.GetGuid(rdr.GetOrdinal col)
+
+    /// Get an int value from a data reader
+    let getInt col (rdr: SqliteDataReader) = rdr.GetInt32(rdr.GetOrdinal col)
+
+    /// Get a long (64-bit int) value from a data reader
+    let getLong col (rdr: SqliteDataReader) = rdr.GetInt64(rdr.GetOrdinal col)
+
+    /// Get a BLOB stream value from a data reader
+    let getStream col (rdr: SqliteDataReader) = rdr.GetStream(rdr.GetOrdinal col)
+
+    /// Get a string value from a data reader
+    let getString col (rdr: SqliteDataReader) = rdr.GetString(rdr.GetOrdinal col)
+
+    /// Parse an Instant from the given value
+    let parseInstant value =
+        match InstantPattern.General.Parse value with
+        | it when it.Success -> it.Value
+        | it -> raise it.Exception
+
+    /// Get an Instant value from a data reader
+    let getInstant col rdr =
+        getString col rdr |> parseInstant
+
+    /// Get a timespan value from a data reader
+    let getTimeSpan col (rdr: SqliteDataReader) = rdr.GetTimeSpan(rdr.GetOrdinal col)
+
+    /// Get a possibly null boolean value from a data reader
+    let tryBoolean col (rdr: SqliteDataReader) =
+        if rdr.IsDBNull(rdr.GetOrdinal col) then None else Some (getBoolean col rdr)
+
+    /// Get a possibly null date/time value from a data reader
+    let tryDateTime col (rdr: SqliteDataReader) =
+        if rdr.IsDBNull(rdr.GetOrdinal col) then None else Some (getDateTime col rdr)
+
+    /// Get a possibly null Guid value from a data reader
+    let tryGuid col (rdr: SqliteDataReader) =
+        if rdr.IsDBNull(rdr.GetOrdinal col) then None else Some (getGuid col rdr)
+
+    /// Get a possibly null int value from a data reader
+    let tryInt col (rdr: SqliteDataReader) =
+        if rdr.IsDBNull(rdr.GetOrdinal col) then None else Some (getInt col rdr)
+
+    /// Get a possibly null string value from a data reader
+    let tryString col (rdr: SqliteDataReader) =
+        if rdr.IsDBNull(rdr.GetOrdinal col) then None else Some (getString col rdr)
+
+    /// Get a possibly null timespan value from a data reader
+    let tryTimeSpan col (rdr: SqliteDataReader) =
+        if rdr.IsDBNull(rdr.GetOrdinal col) then None else Some (getTimeSpan col rdr)
+
+    /// Create a permalink from the current row in the given data reader
+    let toPermalink rdr = getString "permalink" rdr |> Permalink
+
+    /// Create a revision from the current row in the given data reader
+    let toRevision rdr : Revision =
+        { AsOf = getInstant "as_of"         rdr
+          Text = getString  "revision_text" rdr |> MarkupText.Parse }
+
+    /// Create a theme asset from the current row in the given data reader
+    let toThemeAsset includeData rdr : ThemeAsset =
+        let assetData =
+            if includeData then
+                use dataStream = new MemoryStream()
+                use blobStream = getStream "data" rdr
+                blobStream.CopyTo dataStream
+                dataStream.ToArray()
+            else
+                [||]
+        { Id        = ThemeAssetId (ThemeId (getString "theme_id" rdr), getString "path" rdr)
+          UpdatedOn = getInstant "updated_on" rdr
+          Data      = assetData }
+
+    /// Create an uploaded file from the current row in the given data reader
+    let toUpload includeData rdr : Upload =
+        let data =
+            if includeData then
+                use dataStream = new MemoryStream()
+                use blobStream = getStream "data" rdr
+                blobStream.CopyTo dataStream
+                dataStream.ToArray ()
+            else
+                [||]
+        { Id        = getString  "id"         rdr |> UploadId
+          WebLogId  = getString  "web_log_id" rdr |> WebLogId
+          Path      = getString  "path"       rdr |> Permalink
+          UpdatedOn = getInstant "updated_on" rdr
+          Data      = data }
+
+
+open BitBadger.Documents
+
+/// Create a named parameter
+let sqlParam name (value: obj) =
+    SqliteParameter(name, value)
+
+/// Create a web log ID parameter
+let webLogParam (webLogId: WebLogId) =
+    sqlParam "@webLogId" (string webLogId)
+
+/// Create a field for an ID value
+let idField<'T> (idValue: 'T) =
+    { Field.Equal "Id" (string idValue) with ParameterName = Some "@id" }
+
+/// Create a web log field
+let webLogField (webLogId: WebLogId) =
+    { Field.Equal "WebLogId" (string webLogId) with ParameterName = Some "@webLogId" }
+
+
+open BitBadger.Documents.Sqlite
+
+/// Functions to support revisions
+module Revisions =
+
+    /// Find all revisions for the given entity
+    let findByEntityId<'TKey> revTable entityTable (key: 'TKey) (conn: SqliteConnection) =
+        conn.customList
+            $"SELECT as_of, revision_text FROM %s{revTable} WHERE %s{entityTable}_id = @id ORDER BY as_of DESC"
+            [ idParam key ]
+            Map.toRevision
+
+    /// Find all revisions for all posts for the given web log
+    let findByWebLog<'TKey> revTable entityTable (keyFunc: string -> 'TKey) webLogId (conn: SqliteConnection) =
+        conn.customList
+            $"SELECT pr.*
+                FROM %s{revTable} pr
+                     INNER JOIN %s{entityTable} p ON p.data->>'Id' = pr.{entityTable}_id
+               WHERE p.{Query.whereByFields Any [ webLogField webLogId ]}
+               ORDER BY as_of DESC"
+            [ webLogParam webLogId ]
+            (fun rdr -> keyFunc (Map.getString $"{entityTable}_id" rdr), Map.toRevision rdr)
+
+    /// Update a page or post's revisions
+    let update<'TKey> revTable entityTable (key: 'TKey) oldRevs newRevs (conn: SqliteConnection) = backgroundTask {
+        let toDelete, toAdd = Utils.diffRevisions oldRevs newRevs
+        for delRev in toDelete do
+            do! conn.customNonQuery
+                    $"DELETE FROM %s{revTable} WHERE %s{entityTable}_id = @id AND as_of = @asOf"
+                    [ idParam key; sqlParam "@asOf" (instantParam delRev.AsOf) ]
+        for addRev in toAdd do
+            do! conn.customNonQuery
+                    $"INSERT INTO {revTable} VALUES (@id, @asOf, @text)"
+                    [ idParam key; sqlParam "asOf" (instantParam addRev.AsOf); sqlParam "@text" (string addRev.Text) ]
+    }

src/MyWebLog.Data/SQLite/SQLitePageData.fs

@@ -1,300 +1,175 @@
 namespace MyWebLog.Data.SQLite
 
 open System.Threading.Tasks
+open BitBadger.Documents
+open BitBadger.Documents.Sqlite
 open Microsoft.Data.Sqlite
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Newtonsoft.Json
 
-/// SQLite myWebLog page data implementation        
-type SQLitePageData (conn : SqliteConnection, ser : JsonSerializer) =
+/// SQLite myWebLog page data implementation
+type SQLitePageData(conn: SqliteConnection, log: ILogger) =
+    
+    /// The JSON field name for the permalink
+    let linkName = nameof Page.Empty.Permalink
+    
+    /// The JSON field name for the "is in page list" flag
+    let pgListName = nameof Page.Empty.IsInPageList
+    
+    /// Query to return pages sorted by title
+    let sortedPages fields =
+        Query.byFields (Query.find Table.Page) All fields
+            + Query.orderBy [ Field.Named $"i:{nameof Page.Empty.Title}" ] SQLite
     
     // SUPPORT FUNCTIONS
     
-    /// Add parameters for page INSERT or UPDATE statements
-    let addPageParameters (cmd : SqliteCommand) (page : Page) =
-        [   cmd.Parameters.AddWithValue ("@id",           PageId.toString page.Id)
-            cmd.Parameters.AddWithValue ("@webLogId",     WebLogId.toString page.WebLogId)
-            cmd.Parameters.AddWithValue ("@authorId",     WebLogUserId.toString page.AuthorId)
-            cmd.Parameters.AddWithValue ("@title",        page.Title)
-            cmd.Parameters.AddWithValue ("@permalink",    Permalink.toString page.Permalink)
-            cmd.Parameters.AddWithValue ("@publishedOn",  instantParam page.PublishedOn)
-            cmd.Parameters.AddWithValue ("@updatedOn",    instantParam page.UpdatedOn)
-            cmd.Parameters.AddWithValue ("@isInPageList", page.IsInPageList)
-            cmd.Parameters.AddWithValue ("@template",     maybe page.Template)
-            cmd.Parameters.AddWithValue ("@text",         page.Text)
-            cmd.Parameters.AddWithValue ("@metaItems",    maybe (if List.isEmpty page.Metadata then None
-                                                                 else Some (Utils.serialize ser page.Metadata)))
-        ] |> ignore
-    
-    /// Append revisions and permalinks to a page
-    let appendPageRevisionsAndPermalinks (page : Page) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.Parameters.AddWithValue ("@pageId", PageId.toString page.Id) |> ignore
-        
-        cmd.CommandText <- "SELECT permalink FROM page_permalink WHERE page_id = @pageId"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let page = { page with PriorPermalinks = toList Map.toPermalink rdr }
-        do! rdr.CloseAsync ()
-        
-        cmd.CommandText <- "SELECT as_of, revision_text FROM page_revision WHERE page_id = @pageId ORDER BY as_of DESC"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return { page with Revisions = toList Map.toRevision rdr }
+    /// Append revisions to a page
+    let appendPageRevisions (page : Page) = backgroundTask {
+        log.LogTrace "Page.appendPageRevisions"
+        let! revisions = Revisions.findByEntityId Table.PageRevision Table.Page page.Id conn
+        return { page with Revisions = revisions }
     }
     
-    /// Shorthand for mapping a data reader to a page
-    let toPage =
-        Map.toPage ser
-    
-    /// Return a page with no text (or prior permalinks or revisions)
-    let pageWithoutText rdr =
-        { toPage rdr with Text = "" }
-    
-    /// Update a page's prior permalinks
-    let updatePagePermalinks pageId oldLinks newLinks = backgroundTask {
-        let toDelete, toAdd = Utils.diffPermalinks oldLinks newLinks
-        if List.isEmpty toDelete && List.isEmpty toAdd then
-            return ()
-        else
-            use cmd = conn.CreateCommand ()
-            [ cmd.Parameters.AddWithValue ("@pageId", PageId.toString pageId)
-              cmd.Parameters.Add          ("@link",   SqliteType.Text)
-            ] |> ignore
-            let runCmd link = backgroundTask {
-                cmd.Parameters["@link"].Value <- Permalink.toString link
-                do! write cmd
-            }
-            cmd.CommandText <- "DELETE FROM page_permalink WHERE page_id = @pageId AND permalink = @link" 
-            toDelete
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-            cmd.CommandText <- "INSERT INTO page_permalink VALUES (@pageId, @link)"
-            toAdd
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-    }
+    /// Create a page with no prior permalinks
+    let pageWithoutLinks rdr =
+        { fromData<Page> rdr with PriorPermalinks = [] }
     
     /// Update a page's revisions
-    let updatePageRevisions pageId oldRevs newRevs = backgroundTask {
-        let toDelete, toAdd = Utils.diffRevisions oldRevs newRevs
-        if List.isEmpty toDelete && List.isEmpty toAdd then
-            return ()
-        else
-            use cmd = conn.CreateCommand ()
-            let runCmd withText rev = backgroundTask {
-                cmd.Parameters.Clear ()
-                [   cmd.Parameters.AddWithValue ("@pageId", PageId.toString pageId)
-                    cmd.Parameters.AddWithValue ("@asOf",   instantParam rev.AsOf)
-                ] |> ignore
-                if withText then cmd.Parameters.AddWithValue ("@text", MarkupText.toString rev.Text) |> ignore
-                do! write cmd
-            }
-            cmd.CommandText <- "DELETE FROM page_revision WHERE page_id = @pageId AND as_of = @asOf" 
-            toDelete
-            |> List.map (runCmd false)
-            |> Task.WhenAll
-            |> ignore
-            cmd.CommandText <- "INSERT INTO page_revision VALUES (@pageId, @asOf, @text)"
-            toAdd
-            |> List.map (runCmd true)
-            |> Task.WhenAll
-            |> ignore
-    }
+    let updatePageRevisions (pageId: PageId) oldRevs newRevs =
+        log.LogTrace "Page.updatePageRevisions"
+        Revisions.update Table.PageRevision Table.Page pageId oldRevs newRevs conn
     
     // IMPLEMENTATION FUNCTIONS
     
     /// Add a page
-    let add page = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        // The page itself
-        cmd.CommandText <-
-            "INSERT INTO page (
-                id, web_log_id, author_id, title, permalink, published_on, updated_on, is_in_page_list, template,
-                page_text, meta_items
-            ) VALUES (
-                @id, @webLogId, @authorId, @title, @permalink, @publishedOn, @updatedOn, @isInPageList, @template,
-                @text, @metaItems
-            )"
-        addPageParameters cmd page
-        do! write cmd
-        do! updatePagePermalinks page.Id [] page.PriorPermalinks
-        do! updatePageRevisions  page.Id [] page.Revisions
+    let add (page: Page) = backgroundTask {
+        log.LogTrace "Page.add"
+        do! conn.insert Table.Page { page with Revisions = [] } 
+        do! updatePageRevisions page.Id [] page.Revisions
     }
     
-    /// Get all pages for a web log (without text, revisions, prior permalinks, or metadata)
-    let all webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM page WHERE web_log_id = @webLogId ORDER BY LOWER(title)"
-        addWebLogId cmd webLogId
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList pageWithoutText rdr
-    }
+    /// Get all pages for a web log (without text, metadata, revisions, or prior permalinks)
+    let all webLogId =
+        log.LogTrace "Page.all"
+        let field = [ webLogField webLogId ]
+        conn.customList
+            (sortedPages field)
+            (addFieldParams field [])
+            (fun rdr -> { fromData<Page> rdr with Text = ""; Metadata = []; PriorPermalinks = [] })
     
     /// Count all pages for the given web log
     let countAll webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT COUNT(id) FROM page WHERE web_log_id = @webLogId"
-        addWebLogId cmd webLogId
-        return! count cmd
+        log.LogTrace "Page.countAll"
+        let! count = conn.countByFields Table.Page Any [ webLogField webLogId ]
+        return int count
     }
     
     /// Count all pages shown in the page list for the given web log
     let countListed webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            "SELECT COUNT(id)
-               FROM page
-              WHERE web_log_id      = @webLogId
-                AND is_in_page_list = @isInPageList"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@isInPageList", true) |> ignore
-        return! count cmd
+        log.LogTrace "Page.countListed"
+        let! count = conn.countByFields Table.Page All [ webLogField webLogId; Field.Equal pgListName true ]
+        return int count
     }
     
     /// Find a page by its ID (without revisions and prior permalinks)
-    let findById pageId webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM page WHERE id = @id"
-        cmd.Parameters.AddWithValue ("@id", PageId.toString pageId) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return Helpers.verifyWebLog<Page> webLogId (fun it -> it.WebLogId) (Map.toPage ser) rdr
+    let findById (pageId: PageId) webLogId = backgroundTask {
+        log.LogTrace "Page.findById"
+        match! conn.findFirstByFields<Page> Table.Page All [ idField pageId; webLogField webLogId ] with
+        | Some page -> return Some { page with PriorPermalinks = [] }
+        | None -> return None
     }
     
     /// Find a complete page by its ID
-    let findFullById pageId webLogId = backgroundTask {
-        match! findById pageId webLogId with
+    let findFullById (pageId: PageId) webLogId = backgroundTask {
+        log.LogTrace "Page.findFullById"
+        match! conn.findFirstByFields<Page> Table.Page All [ idField pageId; webLogField webLogId ] with
         | Some page ->
-            let! page = appendPageRevisionsAndPermalinks page
+            let! page = appendPageRevisions page
             return Some page
         | None -> return None
     }
     
+    // TODO: need to handle when the page being deleted is the home page
+    /// Delete a page by its ID
     let delete pageId webLogId = backgroundTask {
+        log.LogTrace "Page.delete"
         match! findById pageId webLogId with
         | Some _ ->
-            use cmd = conn.CreateCommand ()
-            cmd.Parameters.AddWithValue ("@id", PageId.toString pageId) |> ignore
-            cmd.CommandText <-
-                "DELETE FROM page_revision  WHERE page_id = @id;
-                 DELETE FROM page_permalink WHERE page_id = @id;
-                 DELETE FROM page           WHERE id      = @id"
-            do! write cmd
+            do! conn.customNonQuery
+                    $"{Query.delete Table.PageRevision} WHERE page_id = @id;
+                      {Query.byId (Query.delete Table.Page) (string pageId)}"
+                    [ idParam pageId ]
             return true
         | None -> return false
     }
     
     /// Find a page by its permalink for the given web log
-    let findByPermalink permalink webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM page WHERE web_log_id = @webLogId AND permalink = @link"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@link", Permalink.toString permalink) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return if rdr.Read () then Some (toPage rdr) else None
-    }
+    let findByPermalink (permalink: Permalink) webLogId =
+        log.LogTrace "Page.findByPermalink"
+        let fields = [ webLogField webLogId; Field.Equal linkName (string permalink) ]
+        conn.customSingle
+            (Query.byFields (Query.find Table.Page) All fields) (addFieldParams fields []) pageWithoutLinks
     
     /// Find the current permalink within a set of potential prior permalinks for the given web log
-    let findCurrentPermalink permalinks webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        let linkSql, linkParams = inClause "AND pp.permalink" "link" Permalink.toString permalinks
-        cmd.CommandText <- $"
-            SELECT p.permalink
-               FROM page p
-                    INNER JOIN page_permalink pp ON pp.page_id = p.id
-              WHERE p.web_log_id = @webLogId
-                {linkSql}"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddRange linkParams
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return if rdr.Read () then Some (Map.toPermalink rdr) else None
-    }
+    let findCurrentPermalink (permalinks: Permalink list) webLogId =
+        log.LogTrace "Page.findCurrentPermalink"
+        let fields =
+            [ webLogField webLogId
+              Field.InArray (nameof Page.Empty.PriorPermalinks) Table.Page (List.map string permalinks) ]
+        let query =
+            (Query.statementWhere (Query.find Table.Page) (Query.whereByFields All fields))
+                .Replace("SELECT data", $"SELECT data->>'{linkName}' AS permalink")
+        conn.customSingle query (addFieldParams fields []) Map.toPermalink
     
     /// Get all complete pages for the given web log
     let findFullByWebLog webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM page WHERE web_log_id = @webLogId"
-        addWebLogId cmd webLogId
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! pages =
-            toList toPage rdr
-            |> List.map (fun page -> backgroundTask { return! appendPageRevisionsAndPermalinks page })
-            |> Task.WhenAll
-        return List.ofArray pages
+        log.LogTrace "Page.findFullByWebLog"
+        let! pages    = conn.findByFields<Page> Table.Page Any [ webLogField webLogId ]
+        let! withRevs = pages |> List.map appendPageRevisions |> Task.WhenAll
+        return List.ofArray withRevs
     }
     
-    /// Get all listed pages for the given web log (without revisions, prior permalinks, or text)
-    let findListed webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            "SELECT *
-               FROM page
-              WHERE web_log_id      = @webLogId
-                AND is_in_page_list = @isInPageList
-              ORDER BY LOWER(title)"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@isInPageList", true) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList pageWithoutText rdr
-    }
+    /// Get all listed pages for the given web log (without revisions or text)
+    let findListed webLogId =
+        log.LogTrace "Page.findListed"
+        let fields = [ webLogField webLogId; Field.Equal pgListName true ]
+        conn.customList
+            (sortedPages fields) (addFieldParams fields []) (fun rdr -> { fromData<Page> rdr with Text = "" })
     
-    /// Get a page of pages for the given web log (without revisions, prior permalinks, or metadata)
-    let findPageOfPages webLogId pageNbr = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            "SELECT *
-               FROM page
-              WHERE web_log_id = @webLogId
-              ORDER BY LOWER(title)
-              LIMIT @pageSize OFFSET @toSkip"
-        addWebLogId cmd webLogId
-        [   cmd.Parameters.AddWithValue ("@pageSize", 26)
-            cmd.Parameters.AddWithValue ("@toSkip",   (pageNbr - 1) * 25)
-        ] |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList toPage rdr
+    /// Get a page of pages for the given web log (without revisions)
+    let findPageOfPages webLogId pageNbr =
+        log.LogTrace "Page.findPageOfPages"
+        let field = [ webLogField webLogId ]
+        conn.customList
+            $"{sortedPages field} LIMIT @pageSize OFFSET @toSkip"
+            (addFieldParams field [ sqlParam "@pageSize" 26; sqlParam "@toSkip" ((pageNbr - 1) * 25) ])
+            (fun rdr -> { pageWithoutLinks rdr with Metadata = [] })
+    
+    /// Update a page
+    let update (page: Page) = backgroundTask {
+        log.LogTrace "Page.update"
+        match! findFullById page.Id page.WebLogId with
+        | Some oldPage ->
+            do! conn.updateById Table.Page page.Id { page with Revisions = [] } 
+            do! updatePageRevisions page.Id oldPage.Revisions page.Revisions
+        | None -> ()
     }
     
     /// Restore pages from a backup
     let restore pages = backgroundTask {
-        for page in pages do
-            do! add page
-    }
-    
-    /// Update a page
-    let update (page : Page) = backgroundTask {
-        match! findFullById page.Id page.WebLogId with
-        | Some oldPage ->
-            use cmd = conn.CreateCommand ()
-            cmd.CommandText <-
-                "UPDATE page
-                    SET author_id       = @authorId,
-                        title           = @title,
-                        permalink       = @permalink,
-                        published_on    = @publishedOn,
-                        updated_on      = @updatedOn,
-                        is_in_page_list = @isInPageList,
-                        template        = @template,
-                        page_text       = @text,
-                        meta_items      = @metaItems
-                  WHERE id         = @id
-                    AND web_log_id = @webLogId"
-            addPageParameters cmd page
-            do! write cmd
-            do! updatePagePermalinks page.Id oldPage.PriorPermalinks page.PriorPermalinks
-            do! updatePageRevisions  page.Id oldPage.Revisions       page.Revisions
-            return ()
-        | None -> return ()
+        log.LogTrace "Page.restore"
+        for page in pages do do! add page
     }
     
     /// Update a page's prior permalinks
-    let updatePriorPermalinks pageId webLogId permalinks = backgroundTask {
-        match! findFullById pageId webLogId with
-        | Some page ->
-            do! updatePagePermalinks pageId page.PriorPermalinks permalinks
+    let updatePriorPermalinks pageId webLogId (permalinks: Permalink list) = backgroundTask {
+        log.LogTrace "Page.updatePriorPermalinks"
+        match! findById pageId webLogId with
+        | Some _ ->
+            do! conn.patchById Table.Page pageId {| PriorPermalinks = permalinks |}
             return true
-        | None -> return false
+         | None -> return false
     }
     
     interface IPageData with

src/MyWebLog.Data/SQLite/SQLitePostData.fs

@@ -1,467 +1,220 @@
 namespace MyWebLog.Data.SQLite
 
 open System.Threading.Tasks
+open BitBadger.Documents
+open BitBadger.Documents.Sqlite
 open Microsoft.Data.Sqlite
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Newtonsoft.Json
 open NodaTime
 
-/// SQLite myWebLog post data implementation        
-type SQLitePostData (conn : SqliteConnection, ser : JsonSerializer) =
-
+/// SQLite myWebLog post data implementation
+type SQLitePostData(conn: SqliteConnection, log: ILogger) =
+    
+    /// The name of the JSON field for the post's permalink
+    let linkName = nameof Post.Empty.Permalink
+    
+    /// The JSON field for when the post was published
+    let publishName = nameof Post.Empty.PublishedOn
+    
+    /// The name of the JSON field for the post's status
+    let statName = nameof Post.Empty.Status
+    
     // SUPPORT FUNCTIONS
     
-    /// Add parameters for post INSERT or UPDATE statements
-    let addPostParameters (cmd : SqliteCommand) (post : Post) =
-        [   cmd.Parameters.AddWithValue ("@id",          PostId.toString post.Id)
-            cmd.Parameters.AddWithValue ("@webLogId",    WebLogId.toString post.WebLogId)
-            cmd.Parameters.AddWithValue ("@authorId",    WebLogUserId.toString post.AuthorId)
-            cmd.Parameters.AddWithValue ("@status",      PostStatus.toString post.Status)
-            cmd.Parameters.AddWithValue ("@title",       post.Title)
-            cmd.Parameters.AddWithValue ("@permalink",   Permalink.toString post.Permalink)
-            cmd.Parameters.AddWithValue ("@publishedOn", maybeInstant post.PublishedOn)
-            cmd.Parameters.AddWithValue ("@updatedOn",   instantParam post.UpdatedOn)
-            cmd.Parameters.AddWithValue ("@template",    maybe post.Template)
-            cmd.Parameters.AddWithValue ("@text",        post.Text)
-            cmd.Parameters.AddWithValue ("@episode",     maybe (if Option.isSome post.Episode then
-                                                                    Some (Utils.serialize ser post.Episode)
-                                                                else None))
-            cmd.Parameters.AddWithValue ("@metaItems",   maybe (if List.isEmpty post.Metadata then None
-                                                                else Some (Utils.serialize ser post.Metadata)))
-        ] |> ignore
-    
-    /// Append category IDs and tags to a post
-    let appendPostCategoryAndTag (post : Post) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.Parameters.AddWithValue ("@id", PostId.toString post.Id) |> ignore
-        
-        cmd.CommandText <- "SELECT category_id AS id FROM post_category WHERE post_id = @id"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let post = { post with CategoryIds = toList Map.toCategoryId rdr }
-        do! rdr.CloseAsync ()
-        
-        cmd.CommandText <- "SELECT tag FROM post_tag WHERE post_id = @id"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return { post with Tags = toList (Map.getString "tag") rdr }
+    /// Append revisions to a post
+    let appendPostRevisions (post: Post) = backgroundTask {
+        log.LogTrace "Post.appendPostRevisions"
+        let! revisions = Revisions.findByEntityId Table.PostRevision Table.Post post.Id conn
+        return { post with Revisions = revisions }
     }
     
-    /// Append revisions and permalinks to a post
-    let appendPostRevisionsAndPermalinks (post : Post) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.Parameters.AddWithValue ("@postId", PostId.toString post.Id) |> ignore
-        
-        cmd.CommandText <- "SELECT permalink FROM post_permalink WHERE post_id = @postId"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let post = { post with PriorPermalinks = toList Map.toPermalink rdr }
-        do! rdr.CloseAsync ()
-        
-        cmd.CommandText <- "SELECT as_of, revision_text FROM post_revision WHERE post_id = @postId ORDER BY as_of DESC"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return { post with Revisions = toList Map.toRevision rdr }
-    }
+    /// The SELECT statement to retrieve posts with a web log ID parameter
+    let postByWebLog =
+        Query.statementWhere
+            (Query.find Table.Post)
+            (Query.whereByFields Any [ { Field.Equal "WebLogId" "" with ParameterName = Some "@webLogId" } ])
     
-    /// The SELECT statement for a post that will include episode data, if it exists
-    let selectPost = "SELECT p.* FROM post p"
-    
-    /// Shorthand for mapping a data reader to a post
-    let toPost =
-        Map.toPost ser
-    
-    /// Find just-the-post by its ID for the given web log (excludes category, tag, meta, revisions, and permalinks)
-    let findPostById postId webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- $"{selectPost} WHERE p.id = @id"
-        cmd.Parameters.AddWithValue ("@id", PostId.toString postId) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return Helpers.verifyWebLog<Post> webLogId (fun p -> p.WebLogId) toPost rdr
-    }
+    /// Return a post with no revisions or prior permalinks
+    let postWithoutLinks rdr =
+        { fromData<Post> rdr with PriorPermalinks = [] }
     
     /// Return a post with no revisions, prior permalinks, or text
     let postWithoutText rdr =
-        { toPost rdr with Text = "" }
+        { postWithoutLinks rdr with Text = "" }
     
-    /// Update a post's assigned categories
-    let updatePostCategories postId oldCats newCats = backgroundTask {
-        let toDelete, toAdd = Utils.diffLists oldCats newCats CategoryId.toString
-        if List.isEmpty toDelete && List.isEmpty toAdd then
-            return ()
-        else
-            use cmd = conn.CreateCommand ()
-            [   cmd.Parameters.AddWithValue ("@postId",     PostId.toString postId)
-                cmd.Parameters.Add          ("@categoryId", SqliteType.Text)
-            ] |> ignore
-            let runCmd catId = backgroundTask {
-                cmd.Parameters["@categoryId"].Value <- CategoryId.toString catId
-                do! write cmd
-            }
-            cmd.CommandText <- "DELETE FROM post_category WHERE post_id = @postId AND category_id = @categoryId" 
-            toDelete
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-            cmd.CommandText <- "INSERT INTO post_category VALUES (@postId, @categoryId)"
-            toAdd
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-    }
-    
-    /// Update a post's assigned categories
-    let updatePostTags postId (oldTags : string list) newTags = backgroundTask {
-        let toDelete, toAdd = Utils.diffLists oldTags newTags id
-        if List.isEmpty toDelete && List.isEmpty toAdd then
-            return ()
-        else
-            use cmd = conn.CreateCommand ()
-            [   cmd.Parameters.AddWithValue ("@postId", PostId.toString postId)
-                cmd.Parameters.Add          ("@tag",    SqliteType.Text)
-            ] |> ignore
-            let runCmd (tag : string) = backgroundTask {
-                cmd.Parameters["@tag"].Value <- tag
-                do! write cmd
-            }
-            cmd.CommandText <- "DELETE FROM post_tag WHERE post_id = @postId AND tag = @tag" 
-            toDelete
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-            cmd.CommandText <- "INSERT INTO post_tag VALUES (@postId, @tag)"
-            toAdd
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-    }
-    
-    /// Update a post's prior permalinks
-    let updatePostPermalinks postId oldLinks newLinks = backgroundTask {
-        let toDelete, toAdd = Utils.diffPermalinks oldLinks newLinks
-        if List.isEmpty toDelete && List.isEmpty toAdd then
-            return ()
-        else
-            use cmd = conn.CreateCommand ()
-            [   cmd.Parameters.AddWithValue ("@postId", PostId.toString postId)
-                cmd.Parameters.Add          ("@link",   SqliteType.Text)
-            ] |> ignore
-            let runCmd link = backgroundTask {
-                cmd.Parameters["@link"].Value <- Permalink.toString link
-                do! write cmd
-            }
-            cmd.CommandText <- "DELETE FROM post_permalink WHERE post_id = @postId AND permalink = @link" 
-            toDelete
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-            cmd.CommandText <- "INSERT INTO post_permalink VALUES (@postId, @link)"
-            toAdd
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-    }
+    /// The SELECT statement to retrieve published posts with a web log ID parameter
+    let publishedPostByWebLog =
+        $"{postByWebLog} AND data->>'{statName}' = '{string Published}'"
     
     /// Update a post's revisions
-    let updatePostRevisions postId oldRevs newRevs = backgroundTask {
-        let toDelete, toAdd = Utils.diffRevisions oldRevs newRevs
-        if List.isEmpty toDelete && List.isEmpty toAdd then
-            return ()
-        else
-            use cmd = conn.CreateCommand ()
-            let runCmd withText rev = backgroundTask {
-                cmd.Parameters.Clear ()
-                [   cmd.Parameters.AddWithValue ("@postId", PostId.toString postId)
-                    cmd.Parameters.AddWithValue ("@asOf",   instantParam rev.AsOf)
-                ] |> ignore
-                if withText then cmd.Parameters.AddWithValue ("@text", MarkupText.toString rev.Text) |> ignore
-                do! write cmd
-            }
-            cmd.CommandText <- "DELETE FROM post_revision WHERE post_id = @postId AND as_of = @asOf" 
-            toDelete
-            |> List.map (runCmd false)
-            |> Task.WhenAll
-            |> ignore
-            cmd.CommandText <- "INSERT INTO post_revision VALUES (@postId, @asOf, @text)"
-            toAdd
-            |> List.map (runCmd true)
-            |> Task.WhenAll
-            |> ignore
-    }
+    let updatePostRevisions (postId: PostId) oldRevs newRevs =
+        log.LogTrace "Post.updatePostRevisions"
+        Revisions.update Table.PostRevision Table.Post postId oldRevs newRevs conn
     
     // IMPLEMENTATION FUNCTIONS
     
     /// Add a post
-    let add post = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            "INSERT INTO post (
-                id, web_log_id, author_id, status, title, permalink, published_on, updated_on, template, post_text,
-                episode, meta_items
-            ) VALUES (
-                @id, @webLogId, @authorId, @status, @title, @permalink, @publishedOn, @updatedOn, @template, @text,
-                @episode, @metaItems
-            )"
-        addPostParameters cmd post
-        do! write cmd
-        do! updatePostCategories post.Id [] post.CategoryIds
-        do! updatePostTags       post.Id [] post.Tags
-        do! updatePostPermalinks post.Id [] post.PriorPermalinks
-        do! updatePostRevisions  post.Id [] post.Revisions
+    let add (post: Post) = backgroundTask {
+        log.LogTrace "Post.add"
+        do! conn.insert Table.Post { post with Revisions = [] }
+        do! updatePostRevisions post.Id [] post.Revisions
     }
     
     /// Count posts in a status for the given web log
-    let countByStatus status webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT COUNT(id) FROM post WHERE web_log_id = @webLogId AND status = @status"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@status", PostStatus.toString status) |> ignore
-        return! count cmd
+    let countByStatus (status: PostStatus) webLogId = backgroundTask {
+        log.LogTrace "Post.countByStatus"
+        let! count = conn.countByFields Table.Post All [ webLogField webLogId; Field.Equal statName (string status) ]
+        return int count
     }
     
-    /// Find a post by its ID for the given web log (excluding revisions and prior permalinks
-    let findById postId webLogId = backgroundTask {
-        match! findPostById postId webLogId with
-        | Some post ->
-            let! post = appendPostCategoryAndTag post
-            return Some post
+    /// Find a post by its ID for the given web log (excluding revisions)
+    let findById (postId: PostId) webLogId = backgroundTask {
+        log.LogTrace "Post.findById"
+        match! conn.findFirstByFields<Post> Table.Post All [ idField postId; webLogField webLogId ] with
+        | Some post -> return Some { post with PriorPermalinks = [] }
         | None -> return None
     }
     
-    /// Find a post by its permalink for the given web log (excluding revisions and prior permalinks)
-    let findByPermalink permalink webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- $"{selectPost} WHERE p.web_log_id = @webLogId AND p.permalink  = @link"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@link", Permalink.toString permalink) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        if rdr.Read () then
-            let! post = appendPostCategoryAndTag (toPost rdr)
-            return Some post
-        else
-            return None
-    }
+    /// Find a post by its permalink for the given web log (excluding revisions)
+    let findByPermalink (permalink: Permalink) webLogId =
+        log.LogTrace "Post.findByPermalink"
+        let fields = [ webLogField webLogId; Field.Equal linkName (string permalink) ]
+        conn.customSingle
+            (Query.byFields (Query.find Table.Post) All fields) (addFieldParams fields []) postWithoutLinks
     
     /// Find a complete post by its ID for the given web log
     let findFullById postId webLogId = backgroundTask {
-        match! findById postId webLogId with
+        log.LogTrace "Post.findFullById"
+        match! conn.findFirstByFields<Post> Table.Post All [ idField postId; webLogField webLogId ] with
         | Some post ->
-            let! post = appendPostRevisionsAndPermalinks post
+            let! post = appendPostRevisions post
             return Some post
         | None -> return None
     }
     
     /// Delete a post by its ID for the given web log
     let delete postId webLogId = backgroundTask {
-        match! findFullById postId webLogId with
+        log.LogTrace "Post.delete"
+        match! findById postId webLogId with
         | Some _ ->
-            use cmd = conn.CreateCommand ()
-            cmd.Parameters.AddWithValue ("@id", PostId.toString postId) |> ignore
-            cmd.CommandText <-
-                "DELETE FROM post_revision  WHERE post_id = @id;
-                 DELETE FROM post_permalink WHERE post_id = @id;
-                 DELETE FROM post_tag       WHERE post_id = @id;
-                 DELETE FROM post_category  WHERE post_id = @id;
-                 DELETE FROM post_comment   WHERE post_id = @id;
-                 DELETE FROM post           WHERE id      = @id"
-            do! write cmd
+            do! conn.customNonQuery
+                    $"""{Query.delete Table.PostRevision} WHERE post_id = @id;
+                        {Query.byFields
+                             (Query.delete Table.PostComment)
+                             Any
+                             [ { Field.EQ (nameof Comment.Empty.PostId) postId with ParameterName = Some "@id" }]};
+                        {Query.byId (Query.delete Table.Post) (string postId)}"""
+                    [ idParam postId ]
             return true
         | None -> return false
     }
     
     /// Find the current permalink from a list of potential prior permalinks for the given web log
-    let findCurrentPermalink permalinks webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        let linkSql, linkParams = inClause "AND pp.permalink" "link" Permalink.toString permalinks
-        cmd.CommandText <- $"
-            SELECT p.permalink
-               FROM post p
-                    INNER JOIN post_permalink pp ON pp.post_id = p.id
-              WHERE p.web_log_id = @webLogId
-                {linkSql}"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddRange linkParams
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return if rdr.Read () then Some (Map.toPermalink rdr) else None
-    }
+    let findCurrentPermalink (permalinks: Permalink list) webLogId =
+        log.LogTrace "Post.findCurrentPermalink"
+        let fields =
+            [ webLogField webLogId
+              Field.InArray (nameof Post.Empty.PriorPermalinks) Table.Post (List.map string permalinks) ]
+        let query =
+            (Query.statementWhere (Query.find Table.Post) (Query.whereByFields All fields))
+                .Replace("SELECT data", $"SELECT data->>'{linkName}' AS permalink")
+        conn.customSingle query (addFieldParams fields []) Map.toPermalink
     
     /// Get all complete posts for the given web log
     let findFullByWebLog webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- $"{selectPost} WHERE p.web_log_id = @webLogId"
-        addWebLogId cmd webLogId
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! posts =
-            toList toPost rdr
-            |> List.map (fun post -> backgroundTask {
-                let! post = appendPostCategoryAndTag post
-                return! appendPostRevisionsAndPermalinks post
-            })
-            |> Task.WhenAll
-        return List.ofArray posts
+        log.LogTrace "Post.findFullByWebLog"
+        let! posts    = conn.findByFields<Post> Table.Post Any [ webLogField webLogId ]
+        let! withRevs = posts |> List.map appendPostRevisions |> Task.WhenAll
+        return List.ofArray withRevs
     }
     
-    /// Get a page of categorized posts for the given web log (excludes revisions and prior permalinks)
-    let findPageOfCategorizedPosts webLogId categoryIds pageNbr postsPerPage = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        let catSql, catParams = inClause "AND pc.category_id" "catId" CategoryId.toString categoryIds
-        cmd.CommandText <- $"
-            {selectPost}
-                   INNER JOIN post_category pc ON pc.post_id = p.id
-             WHERE p.web_log_id = @webLogId
-               AND p.status     = @status
-               {catSql}
-             ORDER BY published_on DESC
-             LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@status", PostStatus.toString Published) |> ignore
-        cmd.Parameters.AddRange catParams
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! posts =
-            toList toPost rdr
-            |> List.map (fun post -> backgroundTask { return! appendPostCategoryAndTag post })
-            |> Task.WhenAll
-        return List.ofArray posts
-    }
+    /// Get a page of categorized posts for the given web log (excludes revisions)
+    let findPageOfCategorizedPosts webLogId (categoryIds: CategoryId list) pageNbr postsPerPage =
+        log.LogTrace "Post.findPageOfCategorizedPosts"
+        let catIdField = Field.InArray (nameof Post.Empty.CategoryIds) Table.Post (List.map string categoryIds)
+        conn.customList
+            $"""{publishedPostByWebLog} AND {Query.whereByFields Any [ catIdField ]}
+                {Query.orderBy [ Field.Named $"{publishName} DESC" ] SQLite}
+                LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
+            (addFieldParams [ webLogField webLogId; catIdField ] [])
+            postWithoutLinks
     
-    /// Get a page of posts for the given web log (excludes text, revisions, and prior permalinks)
-    let findPageOfPosts webLogId pageNbr postsPerPage = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- $"
-            {selectPost}
-             WHERE p.web_log_id = @webLogId
-             ORDER BY p.published_on DESC NULLS FIRST, p.updated_on
-             LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
-        addWebLogId cmd webLogId
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! posts =
-            toList postWithoutText rdr
-            |> List.map (fun post -> backgroundTask { return! appendPostCategoryAndTag post })
-            |> Task.WhenAll
-        return List.ofArray posts
-    }
+    /// Get a page of posts for the given web log (excludes text and revisions)
+    let findPageOfPosts webLogId pageNbr postsPerPage =
+        log.LogTrace "Post.findPageOfPosts"
+        let order =
+            Query.orderBy
+                [ Field.Named $"{publishName} DESC NULLS FIRST"; Field.Named (nameof Post.Empty.UpdatedOn) ] SQLite
+        conn.customList
+            $"{postByWebLog}{order} LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
+            [ webLogParam webLogId ]
+            postWithoutText
     
-    /// Get a page of published posts for the given web log (excludes revisions and prior permalinks)
-    let findPageOfPublishedPosts webLogId pageNbr postsPerPage = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- $"
-            {selectPost}
-             WHERE p.web_log_id = @webLogId
-               AND p.status     = @status
-             ORDER BY p.published_on DESC
-             LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@status", PostStatus.toString Published) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! posts =
-            toList toPost rdr
-            |> List.map (fun post -> backgroundTask { return! appendPostCategoryAndTag post })
-            |> Task.WhenAll
-        return List.ofArray posts
-    }
+    /// Get a page of published posts for the given web log (excludes revisions)
+    let findPageOfPublishedPosts webLogId pageNbr postsPerPage =
+        log.LogTrace "Post.findPageOfPublishedPosts"
+        conn.customList
+            $"""{publishedPostByWebLog}
+                {Query.orderBy [ Field.Named $"{publishName} DESC" ] SQLite}
+                LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
+            [ webLogParam webLogId ]
+            postWithoutLinks
     
-    /// Get a page of tagged posts for the given web log (excludes revisions and prior permalinks)
-    let findPageOfTaggedPosts webLogId (tag : string) pageNbr postsPerPage = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- $"
-            {selectPost}
-                   INNER JOIN post_tag pt ON pt.post_id = p.id
-             WHERE p.web_log_id = @webLogId
-               AND p.status     = @status
-               AND pt.tag       = @tag
-             ORDER BY p.published_on DESC
-             LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
-        addWebLogId cmd webLogId
-        [ cmd.Parameters.AddWithValue ("@status", PostStatus.toString Published)
-          cmd.Parameters.AddWithValue ("@tag", tag)
-        ] |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! posts =
-            toList toPost rdr
-            |> List.map (fun post -> backgroundTask { return! appendPostCategoryAndTag post })
-            |> Task.WhenAll
-        return List.ofArray posts
-    }
+    /// Get a page of tagged posts for the given web log (excludes revisions)
+    let findPageOfTaggedPosts webLogId (tag : string) pageNbr postsPerPage =
+        log.LogTrace "Post.findPageOfTaggedPosts"
+        let tagField = Field.InArray (nameof Post.Empty.Tags) Table.Post [ tag ]
+        conn.customList
+            $"""{publishedPostByWebLog} AND {Query.whereByFields Any [ tagField ]}
+                {Query.orderBy [ Field.Named $"{publishName} DESC" ] SQLite}
+                LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"""
+            (addFieldParams [ webLogField webLogId; tagField ] [])
+            postWithoutLinks
     
     /// Find the next newest and oldest post from a publish date for the given web log
     let findSurroundingPosts webLogId (publishedOn : Instant) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- $"
-            {selectPost}
-             WHERE p.web_log_id   = @webLogId
-               AND p.status       = @status
-               AND p.published_on < @publishedOn
-             ORDER BY p.published_on DESC
-             LIMIT 1"
-        addWebLogId cmd webLogId
-        [   cmd.Parameters.AddWithValue ("@status",      PostStatus.toString Published)
-            cmd.Parameters.AddWithValue ("@publishedOn", instantParam publishedOn)
-        ] |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! older = backgroundTask {
-            if rdr.Read () then
-                let! post = appendPostCategoryAndTag (postWithoutText rdr)
-                return Some post
-            else
-                return None
-        }
-        do! rdr.CloseAsync ()
-        cmd.CommandText <- $"
-            {selectPost}
-             WHERE p.web_log_id   = @webLogId
-               AND p.status       = @status
-               AND p.published_on > @publishedOn
-             ORDER BY p.published_on
-             LIMIT 1"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! newer = backgroundTask {
-            if rdr.Read () then
-                let! post = appendPostCategoryAndTag (postWithoutText rdr)
-                return Some post
-            else
-                return None
-        }
+        log.LogTrace "Post.findSurroundingPosts"
+        let adjacent op order =
+            let fields = [
+                webLogField webLogId
+                Field.Equal (nameof Post.Empty.Status) (string Published)
+                (if op = "<" then Field.Less else Field.Greater) publishName (instantParam publishedOn)
+            ]
+            conn.customSingle
+                (Query.byFields (Query.find Table.Post) All fields
+                    + Query.orderBy [ Field.Named (publishName + order) ] SQLite + " LIMIT 1")
+                (addFieldParams fields [])
+                postWithoutLinks
+        let! older = adjacent "<" " DESC"
+        let! newer = adjacent ">" ""
         return older, newer
     }
     
+    /// Update a post
+    let update (post: Post) = backgroundTask {
+        log.LogTrace "Post.update"
+        match! findFullById post.Id post.WebLogId with
+        | Some oldPost ->
+            do! conn.updateById Table.Post post.Id { post with Revisions = [] }
+            do! updatePostRevisions post.Id oldPost.Revisions post.Revisions
+        | None -> ()
+    }
+    
     /// Restore posts from a backup
     let restore posts = backgroundTask {
-        for post in posts do
-            do! add post
-    }
-    
-    /// Update a post
-    let update (post : Post) = backgroundTask {
-        match! findFullById post.Id post.WebLogId with
-        | Some oldPost ->
-            use cmd = conn.CreateCommand ()
-            cmd.CommandText <-
-                "UPDATE post
-                    SET author_id    = @authorId,
-                        status       = @status,
-                        title        = @title,
-                        permalink    = @permalink,
-                        published_on = @publishedOn,
-                        updated_on   = @updatedOn,
-                        template     = @template,
-                        post_text    = @text,
-                        episode      = @episode,
-                        meta_items   = @metaItems
-                  WHERE id         = @id
-                    AND web_log_id = @webLogId"
-            addPostParameters cmd post
-            do! write cmd
-            do! updatePostCategories post.Id oldPost.CategoryIds     post.CategoryIds
-            do! updatePostTags       post.Id oldPost.Tags            post.Tags
-            do! updatePostPermalinks post.Id oldPost.PriorPermalinks post.PriorPermalinks
-            do! updatePostRevisions  post.Id oldPost.Revisions       post.Revisions
-        | None -> return ()
+        log.LogTrace "Post.restore"
+        for post in posts do do! add post
     }
     
     /// Update prior permalinks for a post
-    let updatePriorPermalinks postId webLogId permalinks = backgroundTask {
-        match! findFullById postId webLogId with
-        | Some post ->
-            do! updatePostPermalinks postId post.PriorPermalinks permalinks
+    let updatePriorPermalinks postId webLogId (permalinks: Permalink list) = backgroundTask {
+        match! findById postId webLogId with
+        | Some _ ->
+            do! conn.patchById Table.Post postId {| PriorPermalinks = permalinks |}
             return true
-        | None -> return false
+          | None -> return false
     }
     
     interface IPostData with

src/MyWebLog.Data/SQLite/SQLiteTagMapData.fs

@@ -1,97 +1,55 @@
 namespace MyWebLog.Data.SQLite
 
+open BitBadger.Documents
+open BitBadger.Documents.Sqlite
 open Microsoft.Data.Sqlite
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
 
-/// SQLite myWebLog tag mapping data implementation        
-type SQLiteTagMapData (conn : SqliteConnection) =
+/// SQLite myWebLog tag mapping data implementation
+type SQLiteTagMapData(conn: SqliteConnection, log: ILogger) =
 
     /// Find a tag mapping by its ID for the given web log
-    let findById tagMapId webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM tag_map WHERE id = @id"
-        cmd.Parameters.AddWithValue ("@id", TagMapId.toString tagMapId) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return Helpers.verifyWebLog<TagMap> webLogId (fun tm -> tm.WebLogId) Map.toTagMap rdr
-    }
+    let findById (tagMapId: TagMapId) webLogId =
+        log.LogTrace "TagMap.findById"
+        conn.findFirstByFields<TagMap> Table.TagMap All [ idField tagMapId; webLogField webLogId ]
     
     /// Delete a tag mapping for the given web log
     let delete tagMapId webLogId = backgroundTask {
+        log.LogTrace "TagMap.delete"
         match! findById tagMapId webLogId with
         | Some _ ->
-            use cmd = conn.CreateCommand ()
-            cmd.CommandText <- "DELETE FROM tag_map WHERE id = @id"
-            cmd.Parameters.AddWithValue ("@id", TagMapId.toString tagMapId) |> ignore
-            do! write cmd
+            do! conn.deleteById Table.TagMap tagMapId
             return true
         | None -> return false
     }
     
     /// Find a tag mapping by its URL value for the given web log
-    let findByUrlValue (urlValue : string) webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM tag_map WHERE web_log_id = @webLogId AND url_value = @urlValue"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@urlValue", urlValue) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return if rdr.Read () then Some (Map.toTagMap rdr) else None
-    }
+    let findByUrlValue (urlValue: string) webLogId =
+        log.LogTrace "TagMap.findByUrlValue"
+        conn.findFirstByFields<TagMap>
+            Table.TagMap All [ webLogField webLogId; Field.Equal (nameof TagMap.Empty.UrlValue) urlValue ]
     
     /// Get all tag mappings for the given web log
-    let findByWebLog webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM tag_map WHERE web_log_id = @webLogId ORDER BY tag"
-        addWebLogId cmd webLogId
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList Map.toTagMap rdr
-    }
+    let findByWebLog webLogId =
+        log.LogTrace "TagMap.findByWebLog"
+        conn.findByFields<TagMap> Table.TagMap Any [ webLogField webLogId ]
     
     /// Find any tag mappings in a list of tags for the given web log
-    let findMappingForTags (tags : string list) webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        let mapSql, mapParams = inClause "AND tag" "tag" id tags
-        cmd.CommandText <- $"
-            SELECT *
-               FROM tag_map
-              WHERE web_log_id = @webLogId
-                {mapSql}"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddRange mapParams
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList Map.toTagMap rdr
-    }
+    let findMappingForTags (tags: string list) webLogId =
+        log.LogTrace "TagMap.findMappingForTags"
+        conn.findByFields<TagMap> Table.TagMap All [ webLogField webLogId; Field.In (nameof TagMap.Empty.Tag) tags ]
     
     /// Save a tag mapping
-    let save (tagMap : TagMap) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        match! findById tagMap.Id tagMap.WebLogId with
-        | Some _ ->
-            cmd.CommandText <-
-                "UPDATE tag_map
-                    SET tag       = @tag,
-                        url_value = @urlValue
-                  WHERE id         = @id
-                    AND web_log_id = @webLogId"
-        | None ->
-            cmd.CommandText <-
-                "INSERT INTO tag_map (
-                    id, web_log_id, tag, url_value
-                ) VALUES (
-                    @id, @webLogId, @tag, @urlValue
-                )"
-        addWebLogId cmd tagMap.WebLogId
-        [   cmd.Parameters.AddWithValue ("@id",       TagMapId.toString tagMap.Id)
-            cmd.Parameters.AddWithValue ("@tag",      tagMap.Tag)
-            cmd.Parameters.AddWithValue ("@urlValue", tagMap.UrlValue)
-        ] |> ignore
-        do! write cmd
-    }
+    let save (tagMap: TagMap) =
+        log.LogTrace "TagMap.save"
+        conn.save Table.TagMap tagMap
     
     /// Restore tag mappings from a backup
     let restore tagMaps = backgroundTask {
-        for tagMap in tagMaps do
-            do! save tagMap
+        log.LogTrace "TagMap.restore"
+        for tagMap in tagMaps do do! save tagMap
     }
     
     interface ITagMapData with

src/MyWebLog.Data/SQLite/SQLiteThemeData.fs

@@ -1,141 +1,71 @@
 namespace MyWebLog.Data.SQLite
 
-open System.Threading.Tasks
+open BitBadger.Documents
+open BitBadger.Documents.Sqlite
 open Microsoft.Data.Sqlite
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
 
-/// SQLite myWebLog theme data implementation        
-type SQLiteThemeData (conn : SqliteConnection) =
+/// SQLite myWebLog theme data implementation
+type SQLiteThemeData(conn : SqliteConnection, log: ILogger) =
+    
+    /// The name of the theme ID field
+    let idName = nameof Theme.Empty.Id
+    
+    /// Convert a document to a theme with no template text
+    let withoutTemplateText (rdr: SqliteDataReader) =
+        let theme = fromData<Theme> rdr
+        { theme with Templates = theme.Templates |> List.map (fun t -> { t with Text = "" })}
+    
+    /// Remove the template text from a theme
+    let withoutTemplateText' (it: Theme) =
+        { it with Templates = it.Templates |> List.map (fun t -> { t with Text = "" }) }
     
     /// Retrieve all themes (except 'admin'; excludes template text)
-    let all () = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM theme WHERE id <> 'admin' ORDER BY id"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let themes = toList Map.toTheme rdr
-        do! rdr.CloseAsync ()
-        cmd.CommandText <- "SELECT name, theme_id FROM theme_template WHERE theme_id <> 'admin' ORDER BY name"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let templates =
-            seq { while rdr.Read () do ThemeId (Map.getString "theme_id" rdr), Map.toThemeTemplate false rdr }
-            |> List.ofSeq
-        return
-            themes
-            |> List.map (fun t ->
-                { t with Templates = templates |> List.filter (fun (themeId, _) -> themeId = t.Id) |> List.map snd })
-    }
+    let all () =
+        log.LogTrace "Theme.all"
+        let fields = [ Field.NE idName "admin" ]
+        conn.customList
+            (Query.byFields (Query.find Table.Theme) Any fields + Query.orderBy [ Field.Named idName ] SQLite)
+            (addFieldParams fields [])
+            withoutTemplateText
     
     /// Does a given theme exist?
-    let exists themeId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT COUNT(id) FROM theme WHERE id = @id"
-        cmd.Parameters.AddWithValue ("@id", ThemeId.toString themeId) |> ignore
-        let! count = count cmd
-        return count > 0
-    }
+    let exists (themeId: ThemeId) =
+        log.LogTrace "Theme.exists"
+        conn.existsById Table.Theme themeId
     
     /// Find a theme by its ID
-    let findById themeId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM theme WHERE id = @id"
-        cmd.Parameters.AddWithValue ("@id", ThemeId.toString themeId) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        if rdr.Read () then
-            let theme = Map.toTheme rdr
-            let templateCmd = conn.CreateCommand ()
-            templateCmd.CommandText <- "SELECT * FROM theme_template WHERE theme_id = @id"
-            templateCmd.Parameters.Add cmd.Parameters["@id"] |> ignore
-            use! templateRdr = templateCmd.ExecuteReaderAsync ()
-            return Some { theme with Templates = toList (Map.toThemeTemplate true) templateRdr }
-        else
-            return None
-    }
+    let findById themeId =
+        log.LogTrace "Theme.findById"
+        conn.findById<ThemeId, Theme> Table.Theme themeId
     
     /// Find a theme by its ID (excludes the text of templates)
-    let findByIdWithoutText themeId = backgroundTask {
-        match! findById themeId with
-        | Some theme ->
-            return Some {
-                theme with Templates = theme.Templates |> List.map (fun t -> { t with Text = "" })
-            }
-        | None -> return None
-    }
+    let findByIdWithoutText (themeId: ThemeId) =
+        log.LogTrace "Theme.findByIdWithoutText"
+        conn.customSingle (Query.byId (Query.find Table.Theme) (string themeId)) [ idParam themeId ] withoutTemplateText
     
     /// Delete a theme by its ID
     let delete themeId = backgroundTask {
+        log.LogTrace "Theme.delete"
         match! findByIdWithoutText themeId with
         | Some _ ->
-            use cmd = conn.CreateCommand ()
-            cmd.CommandText <-
-                "DELETE FROM theme_asset    WHERE theme_id = @id;
-                 DELETE FROM theme_template WHERE theme_id = @id;
-                 DELETE FROM theme          WHERE id       = @id"
-            cmd.Parameters.AddWithValue ("@id", ThemeId.toString themeId) |> ignore
-            do! write cmd
+            do! conn.customNonQuery
+                    $"{Query.delete Table.ThemeAsset} WHERE theme_id = @id;
+                      {Query.byId (Query.delete Table.Theme) (string themeId)}"
+                    [ idParam themeId ]
             return true
         | None -> return false
     }
     
     /// Save a theme
-    let save (theme : Theme) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        let! oldTheme = findById theme.Id
-        cmd.CommandText <-
-            match oldTheme with
-            | Some _ -> "UPDATE theme SET name = @name, version = @version WHERE id = @id"
-            | None -> "INSERT INTO theme VALUES (@id, @name, @version)"
-        [   cmd.Parameters.AddWithValue ("@id",      ThemeId.toString theme.Id)
-            cmd.Parameters.AddWithValue ("@name",    theme.Name)
-            cmd.Parameters.AddWithValue ("@version", theme.Version)
-        ] |> ignore
-        do! write cmd
-        
-        let toDelete, toAdd =
-            Utils.diffLists (oldTheme |> Option.map (fun t -> t.Templates) |> Option.defaultValue [])
-                            theme.Templates (fun t -> t.Name)
-        let toUpdate =
-            theme.Templates
-            |> List.filter (fun t ->
-                not (toDelete |> List.exists (fun d -> d.Name = t.Name))
-                && not (toAdd |> List.exists (fun a -> a.Name = t.Name)))
-        cmd.CommandText <-
-            "UPDATE theme_template SET template = @template WHERE theme_id = @themeId AND name = @name"
-        cmd.Parameters.Clear ()
-        [   cmd.Parameters.AddWithValue ("@themeId",  ThemeId.toString theme.Id)
-            cmd.Parameters.Add          ("@name",     SqliteType.Text)
-            cmd.Parameters.Add          ("@template", SqliteType.Text)
-        ] |> ignore
-        toUpdate
-        |> List.map (fun template -> backgroundTask {
-            cmd.Parameters["@name"    ].Value <- template.Name
-            cmd.Parameters["@template"].Value <- template.Text
-            do! write cmd
-        })
-        |> Task.WhenAll
-        |> ignore
-        cmd.CommandText <- "INSERT INTO theme_template VALUES (@themeId, @name, @template)"
-        toAdd
-        |> List.map (fun template -> backgroundTask {
-            cmd.Parameters["@name"    ].Value <- template.Name
-            cmd.Parameters["@template"].Value <- template.Text
-            do! write cmd
-        })
-        |> Task.WhenAll
-        |> ignore
-        cmd.CommandText <- "DELETE FROM theme_template WHERE theme_id = @themeId AND name = @name"
-        cmd.Parameters.Remove cmd.Parameters["@template"]
-        toDelete
-        |> List.map (fun template -> backgroundTask {
-            cmd.Parameters["@name"].Value <- template.Name
-            do! write cmd
-        })
-        |> Task.WhenAll
-        |> ignore
-    }
+    let save (theme: Theme) =
+        log.LogTrace "Theme.save"
+        conn.save Table.Theme theme
     
     interface IThemeData with
-        member _.All () = all ()
+        member _.All() = all ()
         member _.Delete themeId = delete themeId
         member _.Exists themeId = exists themeId
         member _.FindById themeId = findById themeId
@@ -145,97 +75,75 @@ type SQLiteThemeData (conn : SqliteConnection) =
 
 open System.IO
 
-/// SQLite myWebLog theme data implementation        
-type SQLiteThemeAssetData (conn : SqliteConnection) =
+/// SQLite myWebLog theme data implementation
+type SQLiteThemeAssetData(conn : SqliteConnection, log: ILogger) =
+    
+    /// Create parameters for a theme asset ID
+    let assetIdParams assetId =
+        let (ThemeAssetId (ThemeId themeId, path)) = assetId
+        [ idParam themeId; sqlParam "@path" path ]
     
     /// Get all theme assets (excludes data)
-    let all () = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT theme_id, path, updated_on FROM theme_asset"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList (Map.toThemeAsset false) rdr
-    }
+    let all () =
+        log.LogTrace "ThemeAsset.all"
+        conn.customList $"SELECT theme_id, path, updated_on FROM {Table.ThemeAsset}" [] (Map.toThemeAsset false)
     
     /// Delete all assets for the given theme
-    let deleteByTheme themeId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "DELETE FROM theme_asset WHERE theme_id = @themeId"
-        cmd.Parameters.AddWithValue ("@themeId", ThemeId.toString themeId) |> ignore
-        do! write cmd
-    }
+    let deleteByTheme (themeId: ThemeId) =
+        log.LogTrace "ThemeAsset.deleteByTheme"
+        conn.customNonQuery $"{Query.delete Table.ThemeAsset} WHERE theme_id = @id" [ idParam themeId ]
     
     /// Find a theme asset by its ID
-    let findById assetId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT *, ROWID FROM theme_asset WHERE theme_id = @themeId AND path = @path"
-        let (ThemeAssetId (ThemeId themeId, path)) = assetId
-        [   cmd.Parameters.AddWithValue ("@themeId", themeId)
-            cmd.Parameters.AddWithValue ("@path",    path)
-        ] |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return if rdr.Read () then Some (Map.toThemeAsset true rdr) else None
-    }
+    let findById assetId =
+        log.LogTrace "ThemeAsset.findById"
+        conn.customSingle
+            $"SELECT *, ROWID FROM {Table.ThemeAsset} WHERE theme_id = @id AND path = @path"
+            (assetIdParams assetId)
+            (Map.toThemeAsset true)
     
     /// Get theme assets for the given theme (excludes data)
-    let findByTheme themeId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT theme_id, path, updated_on FROM theme_asset WHERE theme_id = @themeId"
-        cmd.Parameters.AddWithValue ("@themeId", ThemeId.toString themeId) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList (Map.toThemeAsset false) rdr
-    }
+    let findByTheme (themeId: ThemeId) =
+        log.LogTrace "ThemeAsset.findByTheme"
+        conn.customList
+            $"SELECT theme_id, path, updated_on FROM {Table.ThemeAsset} WHERE theme_id = @id"
+            [ idParam themeId ]
+            (Map.toThemeAsset false)
     
     /// Get theme assets for the given theme
-    let findByThemeWithData themeId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT *, ROWID FROM theme_asset WHERE theme_id = @themeId"
-        cmd.Parameters.AddWithValue ("@themeId", ThemeId.toString themeId) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList (Map.toThemeAsset true) rdr
-    }
+    let findByThemeWithData (themeId: ThemeId) =
+        log.LogTrace "ThemeAsset.findByThemeWithData"
+        conn.customList
+            $"SELECT *, ROWID FROM {Table.ThemeAsset} WHERE theme_id = @id"
+            [ idParam themeId ]
+            (Map.toThemeAsset true)
     
     /// Save a theme asset
-    let save (asset : ThemeAsset) = backgroundTask {
-        use sideCmd = conn.CreateCommand ()
-        sideCmd.CommandText <-
-            "SELECT COUNT(path) FROM theme_asset WHERE theme_id = @themeId AND path = @path"
-        let (ThemeAssetId (ThemeId themeId, path)) = asset.Id
-        [   sideCmd.Parameters.AddWithValue ("@themeId", themeId)
-            sideCmd.Parameters.AddWithValue ("@path",    path)
-        ] |> ignore
-        let! exists = count sideCmd
-        
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            if exists = 1 then
-                "UPDATE theme_asset
-                    SET updated_on = @updatedOn,
-                        data       = ZEROBLOB(@dataLength)
-                  WHERE theme_id = @themeId
-                    AND path     = @path"
-            else
-                "INSERT INTO theme_asset (
+    let save (asset: ThemeAsset) = backgroundTask {
+        log.LogTrace "ThemeAsset.save"
+        do! conn.customNonQuery
+                $"INSERT INTO {Table.ThemeAsset} (
                     theme_id, path, updated_on, data
-                ) VALUES (
-                    @themeId, @path, @updatedOn, ZEROBLOB(@dataLength)
-                )"
-        [   cmd.Parameters.AddWithValue ("@themeId",    themeId)
-            cmd.Parameters.AddWithValue ("@path",       path)
-            cmd.Parameters.AddWithValue ("@updatedOn",  instantParam asset.UpdatedOn)
-            cmd.Parameters.AddWithValue ("@dataLength", asset.Data.Length)
-        ] |> ignore
-        do! write cmd
+                  ) VALUES (
+                    @id, @path, @updatedOn, ZEROBLOB(@dataLength)
+                  ) ON CONFLICT (theme_id, path) DO UPDATE
+                  SET updated_on = @updatedOn,
+                      data       = ZEROBLOB(@dataLength)"
+                [ sqlParam "@updatedOn" (instantParam asset.UpdatedOn)
+                  sqlParam "@dataLength" asset.Data.Length
+                  yield! (assetIdParams asset.Id) ]
         
-        sideCmd.CommandText <- "SELECT ROWID FROM theme_asset WHERE theme_id = @themeId AND path = @path"
-        let! rowId = sideCmd.ExecuteScalarAsync ()
-        
-        use dataStream = new MemoryStream (asset.Data)
-        use blobStream = new SqliteBlob (conn, "theme_asset", "data", rowId :?> int64)
+        let! rowId =
+            conn.customScalar
+                $"SELECT ROWID FROM {Table.ThemeAsset} WHERE theme_id = @id AND path = @path"
+                (assetIdParams asset.Id)
+                _.GetInt64(0)
+        use dataStream = new MemoryStream(asset.Data)
+        use blobStream = new SqliteBlob(conn, Table.ThemeAsset, "data", rowId)
         do! dataStream.CopyToAsync blobStream
     }
     
     interface IThemeAssetData with
-        member _.All () = all ()
+        member _.All() = all ()
         member _.DeleteByTheme themeId = deleteByTheme themeId
         member _.FindById assetId = findById assetId
         member _.FindByTheme themeId = findByTheme themeId

src/MyWebLog.Data/SQLite/SQLiteUploadData.fs

@@ -1,93 +1,78 @@
 namespace MyWebLog.Data.SQLite
 
 open System.IO
+open BitBadger.Documents.Sqlite
 open Microsoft.Data.Sqlite
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
 
-/// SQLite myWebLog web log data implementation        
-type SQLiteUploadData (conn : SqliteConnection) =
+/// SQLite myWebLog web log data implementation
+type SQLiteUploadData(conn: SqliteConnection, log: ILogger) =
 
-    /// Add parameters for uploaded file INSERT and UPDATE statements
-    let addUploadParameters (cmd : SqliteCommand) (upload : Upload) =
-        [   cmd.Parameters.AddWithValue ("@id",         UploadId.toString upload.Id)
-            cmd.Parameters.AddWithValue ("@webLogId",   WebLogId.toString upload.WebLogId)
-            cmd.Parameters.AddWithValue ("@path",       Permalink.toString upload.Path)
-            cmd.Parameters.AddWithValue ("@updatedOn",  instantParam upload.UpdatedOn)
-            cmd.Parameters.AddWithValue ("@dataLength", upload.Data.Length)
-        ] |> ignore
-    
     /// Save an uploaded file
-    let add upload = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            "INSERT INTO upload (
-                id, web_log_id, path, updated_on, data
-            ) VALUES (
-                @id, @webLogId, @path, @updatedOn, ZEROBLOB(@dataLength)
-            )"
-        addUploadParameters cmd upload
-        do! write cmd
-        
-        cmd.CommandText <- "SELECT ROWID FROM upload WHERE id = @id"
-        let! rowId = cmd.ExecuteScalarAsync ()
-        
-        use dataStream = new MemoryStream (upload.Data)
-        use blobStream = new SqliteBlob (conn, "upload", "data", rowId :?> int64)
+    let add (upload: Upload) = backgroundTask {
+        log.LogTrace "Upload.add"
+        do! conn.customNonQuery
+                $"INSERT INTO {Table.Upload} (
+                    id, web_log_id, path, updated_on, data
+                  ) VALUES (
+                    @id, @webLogId, @path, @updatedOn, ZEROBLOB(@dataLength)
+                  )"
+                [ idParam     upload.Id
+                  webLogParam upload.WebLogId
+                  sqlParam "@path"       (string upload.Path)
+                  sqlParam "@updatedOn"  (instantParam upload.UpdatedOn)
+                  sqlParam "@dataLength" upload.Data.Length ]
+        let! rowId =
+            conn.customScalar $"SELECT ROWID FROM {Table.Upload} WHERE id = @id" [ idParam upload.Id ] _.GetInt64(0)
+        use dataStream = new MemoryStream(upload.Data)
+        use blobStream = new SqliteBlob(conn, Table.Upload, "data", rowId)
         do! dataStream.CopyToAsync blobStream
     }
     
     /// Delete an uploaded file by its ID
-    let delete uploadId webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <-
-            "SELECT id, web_log_id, path, updated_on
-               FROM upload
-              WHERE id         = @id
-                AND web_log_id = @webLogId"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@id", UploadId.toString uploadId) |> ignore
-        let! rdr = cmd.ExecuteReaderAsync ()
-        if (rdr.Read ()) then
-            let upload = Map.toUpload false rdr
-            do! rdr.CloseAsync ()
-            cmd.CommandText <- "DELETE FROM upload WHERE id = @id AND web_log_id = @webLogId"
-            do! write cmd
-            return Ok (Permalink.toString upload.Path)
-        else
-            return Error $"""Upload ID {cmd.Parameters["@id"]} not found"""
+    let delete (uploadId: UploadId) webLogId = backgroundTask {
+        log.LogTrace "Upload.delete"
+        let! upload =
+            conn.customSingle
+                $"SELECT id, web_log_id, path, updated_on FROM {Table.Upload} WHERE id = @id AND web_log_id = @webLogId"
+                [ idParam uploadId; webLogParam webLogId ]
+                (Map.toUpload false)
+        match upload with
+        | Some up ->
+            do! conn.customNonQuery $"DELETE FROM {Table.Upload} WHERE id = @id" [ idParam up.Id ]
+            return Ok (string up.Path)
+        | None -> return Error $"Upload ID {string uploadId} not found"
     }
     
     /// Find an uploaded file by its path for the given web log
-    let findByPath (path : string) webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT *, ROWID FROM upload WHERE web_log_id = @webLogId AND path = @path"
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@path", path) |> ignore
-        let! rdr = cmd.ExecuteReaderAsync ()
-        return if rdr.Read () then Some (Map.toUpload true rdr) else None
-    }
+    let findByPath (path: string) webLogId =
+        log.LogTrace "Upload.findByPath"
+        conn.customSingle
+            $"SELECT *, ROWID FROM {Table.Upload} WHERE web_log_id = @webLogId AND path = @path"
+            [ webLogParam webLogId; sqlParam "@path" path ]
+            (Map.toUpload true)
     
     /// Find all uploaded files for the given web log (excludes data)
-    let findByWebLog webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT id, web_log_id, path, updated_on FROM upload WHERE web_log_id = @webLogId"
-        addWebLogId cmd webLogId
-        let! rdr = cmd.ExecuteReaderAsync ()
-        return toList (Map.toUpload false) rdr
-    }
+    let findByWebLog webLogId =
+        log.LogTrace "Upload.findByWebLog"
+        conn.customList
+            $"SELECT id, web_log_id, path, updated_on FROM {Table.Upload} WHERE web_log_id = @webLogId"
+            [ webLogParam webLogId ]
+            (Map.toUpload false)
     
     /// Find all uploaded files for the given web log
-    let findByWebLogWithData webLogId = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT *, ROWID FROM upload WHERE web_log_id = @webLogId"
-        addWebLogId cmd webLogId
-        let! rdr = cmd.ExecuteReaderAsync ()
-        return toList (Map.toUpload true) rdr
-    }
+    let findByWebLogWithData webLogId =
+        log.LogTrace "Upload.findByWebLogWithData"
+        conn.customList
+            $"SELECT *, ROWID FROM {Table.Upload} WHERE web_log_id = @webLogId"
+            [ webLogParam webLogId ]
+            (Map.toUpload true)
     
     /// Restore uploads from a backup
     let restore uploads = backgroundTask {
+        log.LogTrace "Upload.restore"
         for upload in uploads do do! add upload
     }
     

src/MyWebLog.Data/SQLite/SQLiteWebLogData.fs

@@ -1,257 +1,75 @@
 namespace MyWebLog.Data.SQLite
 
-open System.Threading.Tasks
+open BitBadger.Documents
+open BitBadger.Documents.Sqlite
 open Microsoft.Data.Sqlite
+open Microsoft.Extensions.Logging
 open MyWebLog
 open MyWebLog.Data
-open Newtonsoft.Json
 
-// The web log podcast insert loop is not statically compilable; this is OK
-#nowarn "3511"
+/// SQLite myWebLog web log data implementation
+type SQLiteWebLogData(conn: SqliteConnection, log: ILogger) =
 
-/// SQLite myWebLog web log data implementation        
-type SQLiteWebLogData (conn : SqliteConnection, ser : JsonSerializer) =
-    
-    // SUPPORT FUNCTIONS
-    
-    /// Add parameters for web log INSERT or web log/RSS options UPDATE statements
-    let addWebLogRssParameters (cmd : SqliteCommand) (webLog : WebLog) =
-        [   cmd.Parameters.AddWithValue ("@isFeedEnabled",     webLog.Rss.IsFeedEnabled)
-            cmd.Parameters.AddWithValue ("@feedName",          webLog.Rss.FeedName)
-            cmd.Parameters.AddWithValue ("@itemsInFeed",       maybe webLog.Rss.ItemsInFeed)
-            cmd.Parameters.AddWithValue ("@isCategoryEnabled", webLog.Rss.IsCategoryEnabled)
-            cmd.Parameters.AddWithValue ("@isTagEnabled",      webLog.Rss.IsTagEnabled)
-            cmd.Parameters.AddWithValue ("@copyright",         maybe webLog.Rss.Copyright)
-        ] |> ignore
-    
-    /// Add parameters for web log INSERT or UPDATE statements
-    let addWebLogParameters (cmd : SqliteCommand) (webLog : WebLog) =
-        [   cmd.Parameters.AddWithValue ("@id",           WebLogId.toString webLog.Id)
-            cmd.Parameters.AddWithValue ("@name",         webLog.Name)
-            cmd.Parameters.AddWithValue ("@slug",         webLog.Slug)
-            cmd.Parameters.AddWithValue ("@subtitle",     maybe webLog.Subtitle)
-            cmd.Parameters.AddWithValue ("@defaultPage",  webLog.DefaultPage)
-            cmd.Parameters.AddWithValue ("@postsPerPage", webLog.PostsPerPage)
-            cmd.Parameters.AddWithValue ("@themeId",      ThemeId.toString webLog.ThemeId)
-            cmd.Parameters.AddWithValue ("@urlBase",      webLog.UrlBase)
-            cmd.Parameters.AddWithValue ("@timeZone",     webLog.TimeZone)
-            cmd.Parameters.AddWithValue ("@autoHtmx",     webLog.AutoHtmx)
-            cmd.Parameters.AddWithValue ("@uploads",      UploadDestination.toString webLog.Uploads)
-        ] |> ignore
-        addWebLogRssParameters cmd webLog
-    
-    /// Add parameters for custom feed INSERT or UPDATE statements
-    let addCustomFeedParameters (cmd : SqliteCommand) webLogId (feed : CustomFeed) =
-        [   cmd.Parameters.AddWithValue ("@id",       CustomFeedId.toString feed.Id)
-            cmd.Parameters.AddWithValue ("@webLogId", WebLogId.toString webLogId)
-            cmd.Parameters.AddWithValue ("@source",   CustomFeedSource.toString feed.Source)
-            cmd.Parameters.AddWithValue ("@path",     Permalink.toString feed.Path)
-            cmd.Parameters.AddWithValue ("@podcast",  maybe (if Option.isSome feed.Podcast then
-                                                                 Some (Utils.serialize ser feed.Podcast)
-                                                             else None))
-        ] |> ignore
-    
-    /// Shorthand to map a data reader to a custom feed
-    let toCustomFeed =
-        Map.toCustomFeed ser
-    
-    /// Get the current custom feeds for a web log
-    let getCustomFeeds (webLog : WebLog) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM web_log_feed WHERE web_log_id = @webLogId"
-        addWebLogId cmd webLog.Id
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList toCustomFeed rdr
-    }
-    
-    /// Append custom feeds to a web log
-    let appendCustomFeeds (webLog : WebLog) = backgroundTask {
-        let! feeds = getCustomFeeds webLog
-        return { webLog with Rss = { webLog.Rss with CustomFeeds = feeds } }
-    }
-    
-    /// Update the custom feeds for a web log
-    let updateCustomFeeds (webLog : WebLog) = backgroundTask {
-        let! feeds = getCustomFeeds webLog
-        let toDelete, toAdd = Utils.diffLists feeds webLog.Rss.CustomFeeds (fun it -> $"{CustomFeedId.toString it.Id}")
-        let toId (feed : CustomFeed) = feed.Id
-        let toUpdate =
-            webLog.Rss.CustomFeeds
-            |> List.filter (fun f ->