v2.2

Reviewed-on: #51

.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 = [ "net6.0"; "net8.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,144 +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 //$"src/{name}-theme"
-    |> Seq.filter (fun (_, name) -> not (name.EndsWith ".zip"))
-    |> Zip.zipSpec $"{releasePath}/{name}.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"
-    [ !! $"{path}/**/*"
-        |> Zip.filesAsSpecs path
-        |> Zip.moveToFolder "app"
-      Seq.singleton ($"{releasePath}/admin.zip", "admin.zip")
-      Seq.singleton ($"{releasePath}/default.zip", "default.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"; "app/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.zip"
-    Shell.rm $"{releasePath}/default.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

@@ -0,0 +1,9 @@
+<Project>
+  <PropertyGroup>
+    <TargetFrameworks>net6.0;net8.0</TargetFrameworks>
+    <DebugType>embedded</DebugType>
+    <AssemblyVersion>2.2.0.0</AssemblyVersion>
+    <FileVersion>2.2.0.0</FileVersion>
+    <Version>2.2.0</Version>
+  </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

@@ -9,148 +9,179 @@ 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) =
+    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) =
+    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) =
+    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
+
+    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 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
             
-    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 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
         
-    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 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
             
-    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) =
+    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) =
+    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
+    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) =
+    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) =
+    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
+    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) =
+    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 UploadDestinationConverter () =
-        inherit JsonConverter<UploadDestination> ()
-        override _.WriteJson (writer : JsonWriter, value : UploadDestination, _ : JsonSerializer) =
-            writer.WriteValue (UploadDestination.toString value)
-        override _.ReadJson (reader : JsonReader, _ : Type, _ : UploadDestination, _ : bool, _ : JsonSerializer) =
-            (string >> UploadDestination.parse) 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) =
+    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) =
+    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 () =
+    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
-
-    /// All converters to use for data conversion
-    let all () : JsonConverter seq =
-        seq {
-            // Our converters
-            CategoryIdConverter        ()
-            CommentIdConverter         ()
-            CustomFeedIdConverter      ()
-            CustomFeedSourceConverter  ()
-            ExplicitRatingConverter    ()
-            MarkupTextConverter        ()
-            PermalinkConverter         ()
-            PageIdConverter            ()
-            PodcastMediumConverter     ()
-            PostIdConverter            ()
-            TagMapIdConverter          ()
-            ThemeAssetIdConverter      ()
-            ThemeIdConverter           ()
-            UploadDestinationConverter ()
-            UploadIdConverter          ()
-            WebLogIdConverter          ()
-            WebLogUserIdConverter      ()
-            // Handles DUs with no associated data, as well as option fields
-            CompactUnionJsonConverter  ()
-        }
+    open NodaTime
+    open NodaTime.Serialization.JsonNet
+    
+    /// Configure a serializer to use these converters
+    let configure (ser : JsonSerializer) =
+        // Our converters
+        [ CategoryIdConverter() :> JsonConverter
+          CommentIdConverter()
+          CommentStatusConverter()
+          CustomFeedIdConverter()
+          CustomFeedSourceConverter()
+          ExplicitRatingConverter()
+          MarkupTextConverter()
+          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.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) =
+        if Option.isNone serializerSettings then
+            serializerSettings <- JsonSerializerSettings (
+                ConstructorHandling            = ser.ConstructorHandling,
+                ContractResolver               = ser.ContractResolver,
+                Converters                     = ser.Converters,
+                DefaultValueHandling           = ser.DefaultValueHandling,
+                DateFormatHandling             = ser.DateFormatHandling,
+                DateParseHandling              = ser.DateParseHandling,
+                MetadataPropertyHandling       = ser.MetadataPropertyHandling,
+                MissingMemberHandling          = ser.MissingMemberHandling,
+                NullValueHandling              = ser.NullValueHandling,
+                ObjectCreationHandling         = ser.ObjectCreationHandling,
+                ReferenceLoopHandling          = ser.ReferenceLoopHandling,
+                SerializationBinder            = ser.SerializationBinder,
+                TraceWriter                    = ser.TraceWriter,
+                TypeNameAssemblyFormatHandling = ser.TypeNameAssemblyFormatHandling,
+                TypeNameHandling               = ser.TypeNameHandling)
+                |> Some
+        serializerSettings.Value

src/MyWebLog.Data/Interfaces.fs

@@ -1,274 +1,304 @@
 namespace MyWebLog.Data
 
-open System
 open System.Threading.Tasks
 open MyWebLog
 open MyWebLog.ViewModels
+open Newtonsoft.Json
+open NodaTime
+
+/// The result of a category deletion attempt
+[<Struct>]
+type CategoryDeleteResult =
+    /// The category was deleted successfully
+    | CategoryDeleted
+    /// The category was deleted successfully, and its children were reassigned to its parent
+    | ReassignedChildCategories
+    /// The category was not found, so no effort was made to delete it
+    | CategoryNotFound
+
 
 /// Data functions to support manipulating categories
 type ICategoryData =
     
     /// Add a category
-    abstract member add : Category -> Task<unit>
+    abstract member Add : Category -> Task<unit>
     
     /// Count all categories for the given web log
-    abstract member countAll : WebLogId -> Task<int>
+    abstract member CountAll : WebLogId -> Task<int>
     
     /// Count all top-level categories for the given web log
-    abstract member countTopLevel : WebLogId -> Task<int>
+    abstract member CountTopLevel : WebLogId -> Task<int>
     
     /// Delete a category (also removes it from posts)
-    abstract member delete : CategoryId -> WebLogId -> Task<bool>
+    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>
+    abstract member FindById : CategoryId -> WebLogId -> Task<Category option>
     
     /// Find all categories for the given web log
-    abstract member findByWebLog : WebLogId -> Task<Category list>
+    abstract member FindByWebLog : WebLogId -> Task<Category list>
     
     /// Restore categories from a backup
-    abstract member restore : Category list -> Task<unit>
+    abstract member Restore : Category list -> Task<unit>
     
     /// Update a category (slug, name, description, and parent ID)
-    abstract member update : Category -> Task<unit>
+    abstract member Update : Category -> Task<unit>
 
 
 /// Data functions to support manipulating pages
 type IPageData =
     
     /// Add a page
-    abstract member add : Page -> Task<unit>
+    abstract member Add : Page -> Task<unit>
     
-    /// Get all pages for the web log (excluding meta items, text, revisions, and prior permalinks)
-    abstract member all : WebLogId -> Task<Page list>
+    /// 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
-    abstract member countAll : WebLogId -> Task<int>
+    abstract member CountAll : WebLogId -> Task<int>
     
     /// Count pages marked as "show in page list" for the given web log
-    abstract member countListed : WebLogId -> Task<int>
+    abstract member CountListed : WebLogId -> Task<int>
     
     /// Delete a page
-    abstract member delete : PageId -> WebLogId -> Task<bool>
+    abstract member Delete : PageId -> WebLogId -> Task<bool>
     
     /// Find a page by its ID (excluding revisions and prior permalinks)
-    abstract member findById : PageId -> WebLogId -> Task<Page option>
+    abstract member FindById : PageId -> WebLogId -> Task<Page option>
     
     /// Find a page by its permalink (excluding revisions and prior permalinks)
-    abstract member findByPermalink : Permalink -> WebLogId -> Task<Page option>
+    abstract member FindByPermalink : Permalink -> WebLogId -> Task<Page option>
     
     /// Find the current permalink for a page from a list of prior permalinks
-    abstract member findCurrentPermalink : Permalink list -> WebLogId -> Task<Permalink option>
+    abstract member FindCurrentPermalink : Permalink list -> WebLogId -> Task<Permalink option>
     
     /// Find a page by its ID (including revisions and prior permalinks)
-    abstract member findFullById : PageId -> WebLogId -> Task<Page option>
+    abstract member FindFullById : PageId -> WebLogId -> Task<Page option>
     
     /// Find all pages for the given web log (including revisions and prior permalinks)
-    abstract member findFullByWebLog : WebLogId -> Task<Page list>
+    abstract member FindFullByWebLog : WebLogId -> Task<Page list>
     
     /// Find pages marked as "show in page list" for the given web log (excluding text, revisions, and prior permalinks)
-    abstract member findListed : WebLogId -> Task<Page list>
+    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>
+    abstract member Restore : Page list -> Task<unit>
     
     /// Update a page
-    abstract member update : Page -> Task<unit>
+    abstract member Update : Page -> Task<unit>
     
     /// Update the prior permalinks for the given page
-    abstract member updatePriorPermalinks : PageId -> WebLogId -> Permalink list -> Task<bool>
+    abstract member UpdatePriorPermalinks : PageId -> WebLogId -> Permalink list -> Task<bool>
 
 
 /// Data functions to support manipulating posts
 type IPostData =
     
     /// Add a post
-    abstract member add : Post -> Task<unit>
+    abstract member Add : Post -> Task<unit>
     
     /// Count posts by their status
-    abstract member countByStatus : PostStatus -> WebLogId -> Task<int>
+    abstract member CountByStatus : PostStatus -> WebLogId -> Task<int>
     
     /// Delete a post
-    abstract member delete : PostId -> WebLogId -> Task<bool>
+    abstract member Delete : PostId -> WebLogId -> Task<bool>
+    
+    /// Find a post by its ID (excluding revisions and prior permalinks)
+    abstract member FindById : PostId -> WebLogId -> Task<Post option>
     
     /// Find a post by its permalink (excluding revisions and prior permalinks)
-    abstract member findByPermalink : Permalink -> WebLogId -> Task<Post option>
+    abstract member FindByPermalink : Permalink -> WebLogId -> Task<Post option>
     
     /// Find the current permalink for a post from a list of prior permalinks
-    abstract member findCurrentPermalink : Permalink list -> WebLogId -> Task<Permalink option>
+    abstract member FindCurrentPermalink : Permalink list -> WebLogId -> Task<Permalink option>
     
     /// Find a post by its ID (including revisions and prior permalinks)
-    abstract member findFullById : PostId -> WebLogId -> Task<Post option>
+    abstract member FindFullById : PostId -> WebLogId -> Task<Post option>
     
     /// Find all posts for the given web log (including revisions and prior permalinks)
-    abstract member findFullByWebLog : WebLogId -> Task<Post list>
+    abstract member FindFullByWebLog : WebLogId -> Task<Post list>
     
     /// 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>
+    abstract member FindPageOfCategorizedPosts :
+        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>
+    abstract member FindPageOfTaggedPosts :
+        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 : DateTime -> 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>
+    abstract member Restore : Post list -> Task<unit>
     
     /// Update a post
-    abstract member update : Post -> Task<unit>
+    abstract member Update : Post -> Task<unit>
     
     /// Update the prior permalinks for a post
-    abstract member updatePriorPermalinks : PostId -> WebLogId -> Permalink list -> Task<bool>
+    abstract member UpdatePriorPermalinks : PostId -> WebLogId -> Permalink list -> Task<bool>
 
 
 /// Functions to manipulate tag mappings
 type ITagMapData =
     
     /// Delete a tag mapping
-    abstract member delete : TagMapId -> WebLogId -> Task<bool>
+    abstract member Delete : TagMapId -> WebLogId -> Task<bool>
     
     /// Find a tag mapping by its ID
-    abstract member findById : TagMapId -> WebLogId -> Task<TagMap option>
+    abstract member FindById : TagMapId -> WebLogId -> Task<TagMap option>
     
     /// Find a tag mapping by its URL value
-    abstract member findByUrlValue : string -> WebLogId -> Task<TagMap option>
+    abstract member FindByUrlValue : string -> WebLogId -> Task<TagMap option>
     
     /// Retrieve all tag mappings for the given web log
-    abstract member findByWebLog : WebLogId -> Task<TagMap list>
+    abstract member FindByWebLog : WebLogId -> Task<TagMap list>
     
     /// Find tag mappings for the given tags
-    abstract member findMappingForTags : tags : string list -> WebLogId -> Task<TagMap list>
+    abstract member FindMappingForTags : tags : string list -> WebLogId -> Task<TagMap list>
     
     /// Restore tag mappings from a backup
-    abstract member restore : TagMap list -> Task<unit>
+    abstract member Restore : TagMap list -> Task<unit>
     
     /// Save a tag mapping (insert or update)
-    abstract member save : TagMap -> Task<unit>
+    abstract member Save : TagMap -> Task<unit>
 
 
 /// Functions to manipulate themes
 type IThemeData =
     
-    /// Retrieve all themes (except "admin")
-    abstract member all : unit -> Task<Theme list>
+    /// Retrieve all themes (except "admin") (excluding the text of templates)
+    abstract member All : unit -> Task<Theme list>
+    
+    /// Delete a theme
+    abstract member Delete : ThemeId -> Task<bool>
+    
+    /// Determine if a theme exists
+    abstract member Exists : ThemeId -> Task<bool>
     
     /// Find a theme by its ID
-    abstract member findById : ThemeId -> Task<Theme option>
+    abstract member FindById : ThemeId -> Task<Theme option>
     
     /// Find a theme by its ID (excluding the text of its templates)
-    abstract member findByIdWithoutText : ThemeId -> Task<Theme option>
+    abstract member FindByIdWithoutText : ThemeId -> Task<Theme option>
     
     /// Save a theme (insert or update)
-    abstract member save : Theme -> Task<unit>
+    abstract member Save : Theme -> Task<unit>
 
 
 /// Functions to manipulate theme assets
 type IThemeAssetData =
     
     /// Retrieve all theme assets (excluding data)
-    abstract member all : unit -> Task<ThemeAsset list>
+    abstract member All : unit -> Task<ThemeAsset list>
     
     /// Delete all theme assets for the given theme
-    abstract member deleteByTheme : ThemeId -> Task<unit>
+    abstract member DeleteByTheme : ThemeId -> Task<unit>
     
     /// Find a theme asset by its ID
-    abstract member findById : ThemeAssetId -> Task<ThemeAsset option>
+    abstract member FindById : ThemeAssetId -> Task<ThemeAsset option>
     
     /// Find all assets for the given theme (excludes data)
-    abstract member findByTheme : ThemeId -> Task<ThemeAsset list>
+    abstract member FindByTheme : ThemeId -> Task<ThemeAsset list>
     
     /// Find all assets for the given theme (includes data)
-    abstract member findByThemeWithData : ThemeId -> Task<ThemeAsset list>
+    abstract member FindByThemeWithData : ThemeId -> Task<ThemeAsset list>
     
     /// Save a theme asset (insert or update)
-    abstract member save : ThemeAsset -> Task<unit>
+    abstract member Save : ThemeAsset -> Task<unit>
 
 
 /// Functions to manipulate uploaded files
 type IUploadData =
     
     /// Add an uploaded file
-    abstract member add : Upload -> Task<unit>
+    abstract member Add : Upload -> Task<unit>
     
     /// Delete an uploaded file
-    abstract member delete : UploadId -> WebLogId -> Task<Result<string, string>>
+    abstract member Delete : UploadId -> WebLogId -> Task<Result<string, string>>
     
     /// Find an uploaded file by its path for the given web log
-    abstract member findByPath : string -> WebLogId -> Task<Upload option>
+    abstract member FindByPath : string -> WebLogId -> Task<Upload option>
     
     /// Find all uploaded files for a web log (excludes data)
-    abstract member findByWebLog : WebLogId -> Task<Upload list>
+    abstract member FindByWebLog : WebLogId -> Task<Upload list>
     
     /// Find all uploaded files for a web log
-    abstract member findByWebLogWithData : WebLogId -> Task<Upload list>
+    abstract member FindByWebLogWithData : WebLogId -> Task<Upload list>
     
     /// Restore uploaded files from a backup
-    abstract member restore : Upload list -> Task<unit>
+    abstract member Restore : Upload list -> Task<unit>
 
 
 /// Functions to manipulate web logs
 type IWebLogData =
     
     /// Add a web log
-    abstract member add : WebLog -> Task<unit>
+    abstract member Add : WebLog -> Task<unit>
     
     /// Retrieve all web logs
-    abstract member all : unit -> Task<WebLog list>
+    abstract member All : unit -> Task<WebLog list>
     
     /// Delete a web log, including categories, tag mappings, posts/comments, and pages
-    abstract member delete : WebLogId -> Task<unit>
+    abstract member Delete : WebLogId -> Task<unit>
     
     /// Find a web log by its host (URL base)
-    abstract member findByHost : string -> Task<WebLog option>
+    abstract member FindByHost : string -> Task<WebLog option>
     
     /// Find a web log by its ID
-    abstract member findById : WebLogId -> Task<WebLog option>
+    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>
+    abstract member UpdateRssOptions : WebLog -> Task<unit>
     
     /// Update web log settings (from the settings page)
-    abstract member updateSettings : WebLog -> Task<unit>
+    abstract member UpdateSettings : WebLog -> Task<unit>
 
 
 /// Functions to manipulate web log users
 type IWebLogUserData =
     
     /// Add a web log user
-    abstract member add : WebLogUser -> Task<unit>
+    abstract member Add : WebLogUser -> Task<unit>
+    
+    /// Delete a web log user
+    abstract member Delete : WebLogUserId -> WebLogId -> Task<Result<bool, string>>
     
     /// Find a web log user by their e-mail address
-    abstract member findByEmail : email : string -> WebLogId -> Task<WebLogUser option>
+    abstract member FindByEmail : email : string -> WebLogId -> Task<WebLogUser option>
     
     /// Find a web log user by their ID
-    abstract member findById : WebLogUserId -> WebLogId -> Task<WebLogUser option>
+    abstract member FindById : WebLogUserId -> WebLogId -> Task<WebLogUser option>
     
     /// Find all web log users for the given web log
-    abstract member findByWebLog : WebLogId -> Task<WebLogUser list>
+    abstract member FindByWebLog : WebLogId -> Task<WebLogUser list>
     
     /// Get a user ID -> name dictionary for the given user IDs
-    abstract member findNames : WebLogId -> WebLogUserId list -> Task<MetaItem list>
+    abstract member FindNames : WebLogId -> WebLogUserId list -> Task<MetaItem list>
     
     /// Restore users from a backup
-    abstract member restore : WebLogUser list -> Task<unit>
+    abstract member Restore : WebLogUser list -> Task<unit>
+    
+    /// Set a user's last seen date/time to now
+    abstract member SetLastSeen : WebLogUserId -> WebLogId -> Task<unit>
     
     /// Update a web log user
-    abstract member update : WebLogUser -> Task<unit>
+    abstract member Update : WebLogUser -> Task<unit>
 
 
 /// Data interface required for a myWebLog data implementation
@@ -301,6 +331,9 @@ type IData =
     /// Web log user data functions
     abstract member WebLogUser : IWebLogUserData
     
+    /// A JSON serializer for use in persistence
+    abstract member Serializer : JsonSerializer
+    
     /// Do any required start up data checks
-    abstract member startUp : unit -> Task<unit>
+    abstract member StartUp : unit -> Task<unit>
     

src/MyWebLog.Data/MyWebLog.Data.fsproj

@@ -1,31 +1,29 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<PropertyGroup>
-		<TargetFramework>net6.0</TargetFramework>
-		<GenerateDocumentationFile>true</GenerateDocumentationFile>
-		<DebugType>embedded</DebugType>
-	</PropertyGroup>
-
 	<ItemGroup>
 		<ProjectReference Include="..\MyWebLog.Domain\MyWebLog.Domain.fsproj" />
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.Data.Sqlite" Version="6.0.6" />
-		<PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="6.0.0" />
+		<PackageReference Include="BitBadger.Documents.Postgres" Version="3.1.0" />
+		<PackageReference Include="BitBadger.Documents.Sqlite" Version="3.1.0" />
+		<PackageReference Include="Microsoft.Data.Sqlite" Version="8.0.6" />
+		<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
+		<PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
 		<PackageReference Include="Microsoft.FSharpLu.Json" Version="0.11.7" />
-		<PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
+		<PackageReference Include="NodaTime.Serialization.JsonNet" Version="3.1.0" />
+		<PackageReference Include="Npgsql.NodaTime" Version="8.0.3" />
 		<PackageReference Include="RethinkDb.Driver" Version="2.3.150" />
-		<PackageReference Include="RethinkDb.Driver.FSharp" Version="0.9.0-beta-05" />
-		<PackageReference Update="FSharp.Core" Version="6.0.5" />
+		<PackageReference Include="RethinkDb.Driver.FSharp" Version="0.9.0-beta-07" />
+		<PackageReference Update="FSharp.Core" Version="8.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" />
@@ -35,6 +33,23 @@
 		<Compile Include="SQLite\SQLiteWebLogData.fs" />
 		<Compile Include="SQLite\SQLiteWebLogUserData.fs" />
 		<Compile Include="SQLiteData.fs" />
+		<Compile Include="Postgres\PostgresHelpers.fs" />
+		<Compile Include="Postgres\PostgresCache.fs" />
+		<Compile Include="Postgres\PostgresCategoryData.fs" />
+		<Compile Include="Postgres\PostgresPageData.fs" />
+		<Compile Include="Postgres\PostgresPostData.fs" />
+		<Compile Include="Postgres\PostgresTagMapData.fs" />
+		<Compile Include="Postgres\PostgresThemeData.fs" />
+		<Compile Include="Postgres\PostgresUploadData.fs" />
+		<Compile Include="Postgres\PostgresWebLogData.fs" />
+		<Compile Include="Postgres\PostgresWebLogUserData.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

@@ -0,0 +1,187 @@
+namespace MyWebLog.Data.Postgres
+
+open System.Threading
+open System.Threading.Tasks
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Caching.Distributed
+open NodaTime
+
+/// 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 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)
+    
+    /// Get the current instant
+    let getNow () = SystemClock.Instance.GetCurrentInstant()
+    
+    /// Create a parameter for the expire-at time
+    let expireParam =
+        typedParam "expireAt"
+
+
+/// A distributed cache implementation in PostgreSQL used to handle sessions for myWebLog
+type DistributedCache () =
+    
+    // ~~~ INITIALIZATION ~~~
+    
+    do
+        task {
+            let! exists =
+                Custom.scalar
+                    "SELECT EXISTS
+                       (SELECT 1 FROM pg_tables WHERE schemaname = 'public' AND tablename = 'session')
+                     AS it"
+                    []
+                    toExists
+            if not exists then
+                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)" []
+        } |> sync
+    
+    // ~~~ SUPPORT FUNCTIONS ~~~
+    
+    /// Get an entry, updating it for sliding expiration
+    let getEntry key = backgroundTask {
+        let idParam = "@id", Sql.string key
+        let! tryEntry =
+            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 ()
+            let slideExp = defaultArg entry.SlidingExpiration  Duration.MinValue
+            let absExp   = defaultArg entry.AbsoluteExpiration Instant.MinValue
+            let needsRefresh, item =
+                if entry.ExpireAt = absExp then false, entry
+                elif slideExp = Duration.MinValue && absExp = Instant.MinValue then false, entry
+                elif absExp > Instant.MinValue && entry.ExpireAt.Plus slideExp > absExp then
+                    true, { entry with ExpireAt = absExp }
+                else true, { entry with ExpireAt = now.Plus slideExp }
+            if needsRefresh then
+                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
+    }
+    
+    /// The last time expired entries were purged (runs every 30 minutes)
+    let mutable lastPurge = Instant.MinValue
+    
+    /// Purge expired entries every 30 minutes
+    let purge () = backgroundTask {
+        let now = getNow ()
+        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 =
+        Custom.nonQuery "DELETE FROM session WHERE id = @id" [ "@id", Sql.string key ]
+    
+    /// Save an entry
+    let saveEntry (opts: DistributedCacheEntryOptions) key payload =
+        let now = getNow ()
+        let expireAt, slideExp, absExp =
+            if opts.SlidingExpiration.HasValue then
+                let slide = Duration.FromTimeSpan opts.SlidingExpiration.Value
+                now.Plus slide, Some slide, None
+            elif opts.AbsoluteExpiration.HasValue then
+                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)
+                exp, None, Some exp
+            else
+                // Default to 1 hour sliding expiration
+                let slide = Duration.FromHours 1
+                now.Plus slide, Some slide, None
+        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 {
+        match! getEntry key with
+        | Some entry ->
+            do! purge ()
+            return entry.Payload
+        | None -> return null
+    }
+    
+    /// Refresh an entry
+    let refresh key (cancelToken: CancellationToken) = backgroundTask {
+        let! _ = get key cancelToken
+        ()
+    }
+    
+    /// Remove an entry
+    let remove key (_: CancellationToken) = backgroundTask {
+        do! removeEntry key
+        do! purge ()
+    }
+    
+    /// Set an entry
+    let set key value options (_: CancellationToken) = backgroundTask {
+        do! saveEntry options key value
+        do! purge ()
+    }
+    
+    interface IDistributedCache with
+        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

@@ -0,0 +1,155 @@
+namespace MyWebLog.Data.Postgres
+
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
+open MyWebLog
+open MyWebLog.Data
+open Npgsql.FSharp
+
+/// PostgreSQL myWebLog category data implementation
+type PostgresCategoryData(log: ILogger) =
+    
+    /// Count all categories for the given web log
+    let countAll webLogId =
+        log.LogTrace "Category.countAll"
+        Count.byContains Table.Category (webLogDoc webLogId)
+    
+    /// Count all top-level categories for the given web log
+    let countTopLevel webLogId =
+        log.LogTrace "Category.countTopLevel"
+        Custom.scalar
+            $"""{Query.Count.byContains Table.Category}
+                  AND {Query.whereByField (Field.NEX (nameof Category.Empty.ParentId)) ""}"""
+            [ webLogContains webLogId ]
+            toCount
+    
+    /// Retrieve all categories for the given web log in a DotLiquid-friendly format
+    let findAllForView webLogId = backgroundTask {
+        log.LogTrace "Category.findAllForView"
+        let! cats =
+            Custom.list
+                $"{selectWithCriteria Table.Category} ORDER BY LOWER(data ->> '{nameof Category.Empty.Name}')"
+                [ webLogContains webLogId ]
+                fromData<Category>
+        let ordered = Utils.orderByHierarchy cats None None []
+        let counts  =
+            ordered
+            |> Seq.map (fun it ->
+                // Parent category post counts include posts in subcategories
+                let catIdSql, catIdParams =
+                    ordered
+                    |> Seq.filter (fun cat -> cat.ParentNames |> Array.contains it.Name)
+                    |> Seq.map _.Id
+                    |> Seq.append (Seq.singleton it.Id)
+                    |> List.ofSeq
+                    |> arrayContains (nameof Post.Empty.CategoryIds) id
+                let postCount =
+                    Custom.scalar
+                        $"""SELECT COUNT(DISTINCT data ->> '{nameof Post.Empty.Id}') AS it
+                              FROM {Table.Post}
+                             WHERE {Query.whereDataContains "@criteria"}
+                               AND {catIdSql}"""
+                        [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |}; catIdParams ]
+                        toCount
+                    |> Async.AwaitTask
+                    |> Async.RunSynchronously
+                it.Id, postCount)
+            |> List.ofSeq
+        return
+            ordered
+            |> Seq.map (fun cat ->
+                { cat with
+                    PostCount = counts
+                                |> List.tryFind (fun c -> fst c = cat.Id)
+                                |> Option.map snd
+                                |> Option.defaultValue 0 })
+            |> Array.ofSeq
+    }
+    /// Find a category by its ID for the given web log
+    let findById catId webLogId =
+        log.LogTrace "Category.findById"
+        Document.findByIdAndWebLog<CategoryId, Category> Table.Category catId webLogId
+    
+    /// Find all categories for the given web log
+    let findByWebLog webLogId =
+        log.LogTrace "Category.findByWebLog"
+        Document.findByWebLog<Category> Table.Category 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! 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.Patch.byId Table.Category,
+                        children
+                        |> List.map (fun child -> [ idParam child.Id; jsonParam "@data" {| ParentId = cat.ParentId |} ])
+                    else
+                        Query.RemoveFields.byId Table.Category,
+                        children
+                        |> List.map (fun child ->
+                            [ idParam child.Id; fieldNameParam [ nameof Category.Empty.ParentId ] ])
+                let! _ =
+                    Configuration.dataSource ()
+                    |> Sql.fromDataSource
+                    |> Sql.executeTransactionAsync [ childQuery, childParams ]
+                ()
+            // 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.Patch.byId 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
+    }
+    
+    /// Save a category
+    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! _ =
+            Configuration.dataSource ()
+            |> Sql.fromDataSource
+            |> Sql.executeTransactionAsync [
+                Query.insert Table.Category, cats |> List.map (fun c -> [ jsonParam "@data" c ])
+            ]
+        ()
+    }
+    
+    interface ICategoryData with
+        member _.Add cat = save cat
+        member _.CountAll webLogId = countAll webLogId
+        member _.CountTopLevel webLogId = countTopLevel webLogId
+        member _.FindAllForView webLogId = findAllForView webLogId
+        member _.FindById catId webLogId = findById catId webLogId
+        member _.FindByWebLog webLogId = findByWebLog webLogId
+        member _.Delete catId webLogId = delete catId webLogId
+        member _.Restore cats = restore cats
+        member _.Update cat = save cat

src/MyWebLog.Data/Postgres/PostgresHelpers.fs

@@ -0,0 +1,223 @@
+/// Helper functions for the PostgreSQL data implementation
+[<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 NodaTime
+open Npgsql
+open Npgsql.FSharp
+
+/// Create a SQL parameter for the web log ID
+let webLogIdParam (webLogId: WebLogId) =
+    "@webLogId", Sql.string (string webLogId)
+
+/// Create an anonymous record with the given web log ID
+let webLogDoc (webLogId: WebLogId) =
+    {| WebLogId = webLogId |}
+
+/// Create a parameter for a web log document-contains query
+let webLogContains webLogId =
+    jsonParam "@criteria" (webLogDoc webLogId)
+
+/// A SQL string to select data from a table with the given JSON document contains criteria
+let selectWithCriteria tableName =
+    $"""{Query.selectFromTable tableName} WHERE {Query.whereDataContains "@criteria"}"""
+
+/// Create the SQL and parameters for an IN clause
+let inClause<'T> colNameAndPrefix paramName (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 (string it)) :: itemP)
+            (Seq.ofList items
+             |> Seq.map (fun it ->
+                 $"%s{colNameAndPrefix} IN (@%s{paramName}0", [ $"@%s{paramName}0", Sql.string (string it) ])
+             |> Seq.head)
+        |> function sql, ps -> $"{sql})", ps
+
+/// Create the SQL and parameters for match-any array query
+let arrayContains<'T> name (valueFunc: 'T -> string) (items: 'T list) =
+    $"data['{name}'] ?| @{name}Values",
+    ($"@{name}Values", Sql.stringArray (items |> List.map valueFunc |> Array.ofList))
+
+/// Get the first result of the given query
+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))
+
+/// 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)
+    p.ParameterName, Sql.parameter p
+
+/// Mapping functions for SQL queries
+module Map =
+    
+    /// Create a permalink from the current row
+    let toPermalink (row: RowReader) =
+        Permalink (row.string "permalink")
+    
+    /// 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 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 [||] }
+    
+    /// 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 [||] }
+
+/// Document manipulation functions
+module Document =
+    
+    /// 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
+    
+    /// Find a document by its ID for the given web log
+    let findByIdAndWebLog<'TKey, 'TDoc> table (key: 'TKey) webLogId =
+        Custom.single
+            $"""{Query.selectFromTable table} WHERE {Query.whereById "@id"} AND {Query.whereDataContains "@criteria"}"""
+            [ "@id", Sql.string (string key); webLogContains webLogId ]
+            fromData<'TDoc>
+    
+    /// Find documents for the given web log
+    let findByWebLog<'TDoc> table webLogId : Task<'TDoc list> =
+        Find.byContains table (webLogDoc webLogId)
+
+
+/// 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

@@ -0,0 +1,201 @@
+namespace MyWebLog.Data.Postgres
+
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
+open MyWebLog
+open MyWebLog.Data
+open Npgsql.FSharp
+
+/// PostgreSQL myWebLog page data implementation
+type PostgresPageData(log: ILogger) =
+    
+    // SUPPORT FUNCTIONS
+    
+    /// 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 }
+    }
+    
+    /// Return a page with no text or revisions
+    let pageWithoutText (row: RowReader) =
+        { fromData<Page> row with Text = "" }
+    
+    /// Update a page's revisions
+    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: PageId) webLogId =
+        log.LogTrace "Page.pageExists"
+        Document.existsByWebLog Table.Page pageId webLogId
+    
+    // IMPLEMENTATION FUNCTIONS
+    
+    /// 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 =
+        log.LogTrace "Page.all"
+        Custom.list
+            $"{selectWithCriteria Table.Page} ORDER BY LOWER(data ->> '{nameof Page.Empty.Title}')"
+            [ webLogContains webLogId ]
+            (fun row -> { fromData<Page> row with Text = ""; Metadata = []; PriorPermalinks = [] }) 
+    
+    /// Count all pages for the given web log
+    let countAll webLogId =
+        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 =
+        log.LogTrace "Page.countListed"
+        Count.byContains Table.Page {| webLogDoc webLogId with IsInPageList = true |}
+    
+    /// 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 {
+        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 ->
+            do! Custom.nonQuery
+                    $"""DELETE FROM {Table.PageRevision} WHERE page_id = @id;
+                        DELETE FROM {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: 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: Permalink list) webLogId = backgroundTask {
+        log.LogTrace "Page.findCurrentPermalink"
+        if List.isEmpty permalinks then return None
+        else
+            let linkSql, linkParam = arrayContains (nameof Page.Empty.PriorPermalinks) string permalinks
+            return!
+                Custom.single
+                    $"""SELECT data ->> '{nameof Page.Empty.Permalink}' AS permalink
+                          FROM page
+                         WHERE {Query.whereDataContains "@criteria"}
+                           AND {linkSql}"""
+                    [ webLogContains webLogId; linkParam ]
+                    Map.toPermalink
+    }
+    
+    /// Get all complete pages for the given web log
+    let findFullByWebLog webLogId = backgroundTask {
+        log.LogTrace "Page.findFullByWebLog"
+        let! pages     = Document.findByWebLog<Page> Table.Page webLogId
+        let! revisions = Revisions.findByWebLog Table.PageRevision Table.Page PageId webLogId 
+        return
+            pages
+            |> List.map (fun it ->
+                { it with Revisions = revisions |> List.filter (fun r -> fst r = it.Id) |> List.map snd })
+    }
+    
+    /// Get all listed pages for the given web log (without revisions or text)
+    let findListed webLogId =
+        log.LogTrace "Page.findListed"
+        Custom.list
+            $"{selectWithCriteria Table.Page} ORDER BY LOWER(data ->> '{nameof Page.Empty.Title}')"
+            [ jsonParam "@criteria" {| webLogDoc webLogId with IsInPageList = true |} ]
+            pageWithoutText
+    
+    /// Get a page of pages for the given web log (without revisions)
+    let findPageOfPages webLogId pageNbr =
+        log.LogTrace "Page.findPageOfPages"
+        Custom.list
+            $"{selectWithCriteria Table.Page}
+               ORDER BY LOWER(data->>'{nameof Page.Empty.Title}')
+               LIMIT @pageSize OFFSET @toSkip"
+            [ webLogContains webLogId; "@pageSize", Sql.int 26; "@toSkip", Sql.int ((pageNbr - 1) * 25) ]
+            (fun row -> { fromData<Page> row with Metadata = []; PriorPermalinks = [] })
+    
+    /// Restore pages from a backup
+    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! _ =
+            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) ]
+        ()
+    }
+    
+    /// 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: Permalink list) = backgroundTask {
+        log.LogTrace "Page.updatePriorPermalinks"
+        match! pageExists pageId webLogId with
+        | true ->
+            do! Patch.byId Table.Page pageId {| PriorPermalinks = permalinks |}
+            return true
+        | false -> return false
+    }
+    
+    interface IPageData with
+        member _.Add page = add page
+        member _.All webLogId = all webLogId
+        member _.CountAll webLogId = countAll webLogId
+        member _.CountListed webLogId = countListed webLogId
+        member _.Delete pageId webLogId = delete pageId webLogId
+        member _.FindById pageId webLogId = findById pageId webLogId
+        member _.FindByPermalink permalink webLogId = findByPermalink permalink webLogId
+        member _.FindCurrentPermalink permalinks webLogId = findCurrentPermalink permalinks webLogId
+        member _.FindFullById pageId webLogId = findFullById pageId webLogId
+        member _.FindFullByWebLog webLogId = findFullByWebLog webLogId
+        member _.FindListed webLogId = findListed webLogId
+        member _.FindPageOfPages webLogId pageNbr = findPageOfPages webLogId pageNbr
+        member _.Restore pages = restore pages
+        member _.Update page = update page
+        member _.UpdatePriorPermalinks pageId webLogId permalinks = updatePriorPermalinks pageId webLogId permalinks

src/MyWebLog.Data/Postgres/PostgresPostData.fs

@@ -0,0 +1,236 @@
+namespace MyWebLog.Data.Postgres
+
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
+open MyWebLog
+open MyWebLog.Data
+open NodaTime
+open Npgsql.FSharp
+
+/// PostgreSQL myWebLog post data implementation
+type PostgresPostData(log: ILogger) =
+
+    // SUPPORT FUNCTIONS
+    
+    /// Append revisions to a post
+    let appendPostRevisions (post: Post) = backgroundTask {
+        log.LogTrace "Post.appendPostRevisions"
+        let! revisions = Revisions.findByEntityId Table.PostRevision Table.Post post.Id
+        return { post with Revisions = revisions }
+    }
+    
+    /// 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 =
+        { postWithoutLinks row with Text = "" }
+    
+    /// Update a post's revisions
+    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: 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: 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 = 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)
+    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 {
+        log.LogTrace "Post.findFullById"
+        match! Document.findByIdAndWebLog<PostId, Post> Table.Post postId webLogId with
+        | Some post ->
+            let! withRevisions = appendPostRevisions post
+            return Some withRevisions
+        | None -> return None
+    }
+    
+    /// 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 ->
+            do! Custom.nonQuery
+                    $"""DELETE FROM {Table.PostComment}  WHERE {Query.whereDataContains "@criteria"};
+                        DELETE FROM {Table.PostRevision} WHERE post_id = @id;
+                        DELETE FROM {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: Permalink list) webLogId = backgroundTask {
+        log.LogTrace "Post.findCurrentPermalink"
+        if List.isEmpty permalinks then return None
+        else
+            let linkSql, linkParam = arrayContains (nameof Post.Empty.PriorPermalinks) string permalinks
+            return!
+                Custom.single
+                    $"""SELECT data ->> '{nameof Post.Empty.Permalink}' AS permalink
+                          FROM {Table.Post}
+                         WHERE {Query.whereDataContains "@criteria"}
+                           AND {linkSql}"""
+                    [ webLogContains webLogId; linkParam ]
+                    Map.toPermalink
+    }
+    
+    /// Get all complete posts for the given web log
+    let findFullByWebLog webLogId = backgroundTask {
+        log.LogTrace "Post.findFullByWebLog"
+        let! posts     = Document.findByWebLog<Post> Table.Post webLogId
+        let! revisions = Revisions.findByWebLog Table.PostRevision Table.Post PostId webLogId
+        return
+            posts
+            |> List.map (fun it ->
+                { it with Revisions = revisions |> List.filter (fun r -> fst r = it.Id) |> List.map snd })
+    }
+    
+    /// 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 catSql, catParam = arrayContains (nameof Post.Empty.CategoryIds) string categoryIds
+        Custom.list
+            $"{selectWithCriteria Table.Post}
+                 AND {catSql}
+               ORDER BY data ->> '{nameof Post.Empty.PublishedOn}' DESC
+               LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
+            [ jsonParam "@criteria" {| webLogDoc webLogId with Status = Published |}; catParam ]
+            postWithoutLinks
+    
+    /// Get a page of posts for the given web log (excludes text and revisions)
+    let findPageOfPosts webLogId pageNbr postsPerPage =
+        log.LogTrace "Post.findPageOfPosts"
+        Custom.list
+            $"{selectWithCriteria Table.Post}
+               ORDER BY data ->> '{nameof Post.Empty.PublishedOn}' DESC NULLS FIRST,
+                        data ->> '{nameof Post.Empty.UpdatedOn}'
+               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 =
+        log.LogTrace "Post.findPageOfPublishedPosts"
+        Custom.list
+            $"{selectWithCriteria Table.Post}
+               ORDER BY data ->> '{nameof Post.Empty.PublishedOn}' DESC
+               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 =
+        log.LogTrace "Post.findPageOfTaggedPosts"
+        Custom.list
+            $"{selectWithCriteria Table.Post}
+                 AND data['{nameof Post.Empty.Tags}'] @> @tag
+               ORDER BY data ->> '{nameof Post.Empty.PublishedOn}' DESC
+               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 {
+        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
+               ORDER BY data ->> '{nameof Post.Empty.PublishedOn}' %s{direction}
+               LIMIT 1"
+        let! older = Custom.list (query "<" "DESC") (queryParams ()) postWithoutLinks
+        let! newer = Custom.list (query ">" "")     (queryParams ()) postWithoutLinks
+        return List.tryHead older, List.tryHead newer
+    }
+    
+    /// 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 {
+        log.LogTrace "Post.restore"
+        let revisions = posts |> List.collect (fun p -> p.Revisions |> List.map (fun r -> p.Id, r))
+        let! _ =
+            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: Permalink list) = backgroundTask {
+        log.LogTrace "Post.updatePriorPermalinks"
+        match! postExists postId webLogId with
+        | true ->
+            do! Patch.byId Table.Post postId {| PriorPermalinks = permalinks |}
+            return true
+        | false -> return false
+    }
+    
+    interface IPostData with
+        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
+        member _.FindByPermalink permalink webLogId = findByPermalink permalink webLogId
+        member _.FindCurrentPermalink permalinks webLogId = findCurrentPermalink permalinks webLogId
+        member _.FindFullById postId webLogId = findFullById postId webLogId
+        member _.FindFullByWebLog webLogId = findFullByWebLog webLogId
+        member _.FindPageOfCategorizedPosts webLogId categoryIds pageNbr postsPerPage =
+            findPageOfCategorizedPosts webLogId categoryIds pageNbr postsPerPage
+        member _.FindPageOfPosts webLogId pageNbr postsPerPage = findPageOfPosts webLogId pageNbr postsPerPage
+        member _.FindPageOfPublishedPosts webLogId pageNbr postsPerPage =
+            findPageOfPublishedPosts webLogId pageNbr postsPerPage
+        member _.FindPageOfTaggedPosts webLogId tag pageNbr postsPerPage =
+            findPageOfTaggedPosts webLogId tag pageNbr postsPerPage
+        member _.FindSurroundingPosts webLogId publishedOn = findSurroundingPosts webLogId publishedOn
+        member _.Restore posts = restore posts
+        member _.Update post = update post
+        member _.UpdatePriorPermalinks postId webLogId permalinks = updatePriorPermalinks postId webLogId permalinks

src/MyWebLog.Data/Postgres/PostgresTagMapData.fs

@@ -0,0 +1,73 @@
+namespace MyWebLog.Data.Postgres
+
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
+open MyWebLog
+open MyWebLog.Data
+open Npgsql.FSharp
+
+/// 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 =
+        log.LogTrace "TagMap.findById"
+        Document.findByIdAndWebLog<TagMapId, TagMap> Table.TagMap tagMapId webLogId
+    
+    /// Delete a tag mapping for the given web log
+    let delete (tagMapId: TagMapId) webLogId = backgroundTask {
+        log.LogTrace "TagMap.delete"
+        let! exists = Document.existsByWebLog Table.TagMap tagMapId webLogId
+        if exists then
+            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: 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 =
+        log.LogTrace "TagMap.findByWebLog"
+        Custom.list
+            $"{selectWithCriteria Table.TagMap} ORDER BY data ->> 'tag'"
+            [ webLogContains webLogId ]
+            fromData<TagMap>
+    
+    /// Find any tag mappings in a list of tags for the given web log
+    let findMappingForTags tags webLogId =
+        log.LogTrace "TagMap.findMappingForTags"
+        let tagSql, tagParam = arrayContains (nameof TagMap.Empty.Tag) id tags
+        Custom.list
+            $"{selectWithCriteria Table.TagMap} AND {tagSql}"
+            [ webLogContains webLogId; tagParam ]
+            fromData<TagMap>
+    
+    /// Save a tag mapping
+    let save (tagMap: TagMap) =
+        log.LogTrace "TagMap.save"
+        save Table.TagMap tagMap
+    
+    /// Restore tag mappings from a backup
+    let restore (tagMaps: TagMap list) = backgroundTask {
+        let! _ =
+            Configuration.dataSource ()
+            |> Sql.fromDataSource
+            |> Sql.executeTransactionAsync
+                [ Query.insert Table.TagMap,
+                    tagMaps |> List.map (fun tagMap -> [ jsonParam "@data" tagMap ]) ]
+        ()
+    }
+    
+    interface ITagMapData with
+        member _.Delete tagMapId webLogId = delete tagMapId webLogId
+        member _.FindById tagMapId webLogId = findById tagMapId webLogId
+        member _.FindByUrlValue urlValue webLogId = findByUrlValue urlValue webLogId
+        member _.FindByWebLog webLogId = findByWebLog webLogId
+        member _.FindMappingForTags tags webLogId = findMappingForTags tags webLogId
+        member _.Save tagMap = save tagMap
+        member _.Restore tagMaps = restore tagMaps

src/MyWebLog.Data/Postgres/PostgresThemeData.fs

@@ -0,0 +1,127 @@
+namespace MyWebLog.Data.Postgres
+
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
+open MyWebLog
+open MyWebLog.Data
+
+/// 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 () =
+        log.LogTrace "Theme.all"
+        Custom.list
+            $"{Query.selectFromTable Table.Theme}
+               WHERE data ->> '{nameof Theme.Empty.Id}' <> 'admin'
+               ORDER BY data ->> '{nameof Theme.Empty.Id}'"
+            []
+            withoutTemplateText
+    
+    /// Does a given theme exist?
+    let exists (themeId: ThemeId) =
+        log.LogTrace "Theme.exists"
+        Exists.byId Table.Theme themeId
+    
+    /// Find a theme by its ID
+    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: ThemeId) =
+        log.LogTrace "Theme.findByIdWithoutText"
+        Custom.single (Query.Find.byId Table.Theme) [ idParam themeId ] withoutTemplateText
+    
+    /// Delete a theme by its ID
+    let delete themeId = backgroundTask {
+        log.LogTrace "Theme.delete"
+        match! exists themeId with
+        | true ->
+            do! Custom.nonQuery
+                    $"""DELETE FROM {Table.ThemeAsset} WHERE theme_id = @id;
+                        DELETE FROM {Table.Theme}      WHERE {Query.whereById "@id"}"""
+                    [ idParam themeId ]
+            return true
+        | false -> return false
+    }
+    
+    /// Save a theme
+    let save (theme: Theme) =
+        log.LogTrace "Theme.save"
+        save Table.Theme theme
+    
+    interface IThemeData with
+        member _.All() = all ()
+        member _.Delete themeId = delete themeId
+        member _.Exists themeId = exists themeId
+        member _.FindById themeId = findById themeId
+        member _.FindByIdWithoutText themeId = findByIdWithoutText themeId
+        member _.Save theme = save theme
+
+
+/// PostreSQL myWebLog theme data implementation
+type PostgresThemeAssetData(log: ILogger) =
+    
+    /// Get all theme assets (excludes data)
+    let all () =
+        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: ThemeId) =
+        log.LogTrace "ThemeAsset.deleteByTheme"
+        Custom.nonQuery $"DELETE FROM {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
+        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: 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: 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) =
+        log.LogTrace "ThemeAsset.save"
+        let (ThemeAssetId (ThemeId themeId, path)) = asset.Id
+        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 _.DeleteByTheme themeId = deleteByTheme themeId
+        member _.FindById assetId = findById assetId
+        member _.FindByTheme themeId = findByTheme themeId
+        member _.FindByThemeWithData themeId = findByThemeWithData themeId
+        member _.Save asset = save asset

src/MyWebLog.Data/Postgres/PostgresUploadData.fs

@@ -0,0 +1,90 @@
+namespace MyWebLog.Data.Postgres
+
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
+open MyWebLog
+open MyWebLog.Data
+open Npgsql.FSharp
+
+/// PostgreSQL myWebLog uploaded file data implementation
+type PostgresUploadData(log: ILogger) =
+
+    /// The INSERT statement for an uploaded file
+    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
+          idParam upload.Id
+          "@path", Sql.string (string upload.Path)
+          "@data", Sql.bytea  upload.Data ]
+    
+    /// Save an uploaded file
+    let add upload =
+        log.LogTrace "Upload.add"
+        Custom.nonQuery upInsert (upParams upload)
+    
+    /// Delete an uploaded file by its ID
+    let delete uploadId webLogId = backgroundTask {
+        log.LogTrace "Upload.delete"
+        let idParam = [ idParam uploadId ]
+        let! path =
+            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
+            do! Custom.nonQuery $"DELETE FROM {Table.Upload} WHERE id = @id" idParam
+            return Ok path.Value
+        else return Error $"Upload ID {uploadId} not found"
+    }
+    
+    /// Find an uploaded file by its path for the given web log
+    let findByPath path webLogId =
+        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 =
+        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 =
+        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! _ =
+                Configuration.dataSource ()
+                |> Sql.fromDataSource
+                |> Sql.executeTransactionAsync [ upInsert, batch |> List.map upParams ]
+            ()
+    }
+    
+    interface IUploadData with
+        member _.Add upload = add upload
+        member _.Delete uploadId webLogId = delete uploadId webLogId
+        member _.FindByPath path webLogId = findByPath path webLogId
+        member _.FindByWebLog webLogId = findByWebLog webLogId
+        member _.FindByWebLogWithData webLogId = findByWebLogWithData webLogId
+        member _.Restore uploads = restore uploads
+        

src/MyWebLog.Data/Postgres/PostgresWebLogData.fs

@@ -0,0 +1,83 @@
+namespace MyWebLog.Data.Postgres
+
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
+open MyWebLog
+open MyWebLog.Data
+
+/// PostgreSQL myWebLog web log data implementation
+type PostgresWebLogData(log: ILogger) =
+    
+    /// Add a web log
+    let add (webLog: WebLog) =
+        log.LogTrace "WebLog.add"
+        insert Table.WebLog webLog
+    
+    /// Retrieve all web logs
+    let all () =
+        log.LogTrace "WebLog.all"
+        Find.all<WebLog> Table.WebLog
+    
+    /// Delete a web log by its ID
+    let delete webLogId =
+        log.LogTrace "WebLog.delete"
+        Custom.nonQuery
+            $"""DELETE FROM {Table.PostComment}
+                 WHERE data ->> '{nameof Comment.Empty.PostId}'
+                         IN (SELECT data ->> '{nameof Post.Empty.Id}'
+                               FROM {Table.Post}
+                              WHERE {Query.whereDataContains "@criteria"});
+                DELETE FROM {Table.PostRevision}
+                 WHERE post_id IN (SELECT data ->> 'Id' FROM {Table.Post} WHERE {Query.whereDataContains "@criteria"});
+                DELETE FROM {Table.PageRevision}
+                 WHERE page_id IN (SELECT data ->> 'Id' FROM {Table.Page} WHERE {Query.whereDataContains "@criteria"});
+                {Query.Delete.byContains Table.Post};
+                {Query.Delete.byContains Table.Page};
+                {Query.Delete.byContains Table.Category};
+                {Query.Delete.byContains Table.TagMap};
+                {Query.Delete.byContains Table.WebLogUser};
+                DELETE FROM {Table.Upload} WHERE web_log_id = @webLogId;
+                DELETE FROM {Table.WebLog} WHERE {Query.whereById "@webLogId"}"""
+            [ webLogIdParam webLogId; webLogContains webLogId ]
+    
+    /// Find a web log by its host (URL base)
+    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: WebLogId) = 
+        log.LogTrace "WebLog.findById"
+        Find.byId<WebLogId, WebLog> Table.WebLog webLogId
+    
+    /// 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 {
+        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 _.Delete webLogId = delete webLogId
+        member _.FindByHost url = findByHost url
+        member _.FindById webLogId = findById webLogId
+        member _.UpdateRedirectRules webLog = updateRedirectRules webLog
+        member _.UpdateRssOptions webLog = updateRssOptions webLog
+        member _.UpdateSettings webLog = updateSettings webLog

src/MyWebLog.Data/Postgres/PostgresWebLogUserData.fs

@@ -0,0 +1,102 @@
+namespace MyWebLog.Data.Postgres
+
+open BitBadger.Documents
+open BitBadger.Documents.Postgres
+open Microsoft.Extensions.Logging
+open MyWebLog
+open MyWebLog.Data
+open Npgsql.FSharp
+
+/// PostgreSQL myWebLog user data implementation
+type PostgresWebLogUserData(log: ILogger) =
+    
+    /// Add a user
+    let add (user: WebLogUser) =
+        log.LogTrace "WebLogUser.add"
+        insert Table.WebLogUser user
+    
+    /// Find a user by their ID for the given web log
+    let findById userId webLogId =
+        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  criteria = Query.whereDataContains "@criteria"
+            let! isAuthor =
+                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
+                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: 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 =
+        log.LogTrace "WebLogUser.findByWebLog"
+        Custom.list
+            $"{selectWithCriteria Table.WebLogUser} ORDER BY LOWER(data ->> '{nameof WebLogUser.Empty.PreferredName}')"
+            [ webLogContains webLogId ]
+            fromData<WebLogUser>
+    
+    /// Find the names of users by their IDs for the given web log
+    let findNames webLogId (userIds: WebLogUserId list) = backgroundTask {
+        log.LogTrace "WebLogUser.findNames"
+        let idSql, idParams = inClause $"AND data ->> '{nameof WebLogUser.Empty.Id}'" "id" userIds
+        let! users =
+            Custom.list
+                $"{selectWithCriteria Table.WebLogUser} {idSql}"
+                (webLogContains webLogId :: idParams)
+                fromData<WebLogUser>
+        return users |> List.map (fun u -> { Name = string u.Id; Value = u.DisplayName })
+    }
+    
+    /// Restore users from a backup
+    let restore (users: WebLogUser list) = backgroundTask {
+        log.LogTrace "WebLogUser.restore"
+        let! _ =
+            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: 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 -> ()
+    }
+    
+    /// Update a user
+    let update (user: WebLogUser) =
+        log.LogTrace "WebLogUser.update"
+        Update.byId Table.WebLogUser user.Id user
+    
+    interface IWebLogUserData with
+        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
+        member _.FindByWebLog webLogId = findByWebLog webLogId
+        member _.FindNames webLogId userIds = findNames webLogId userIds
+        member _.Restore users = restore users
+        member _.SetLastSeen userId webLogId = setLastSeen userId webLogId
+        member _.Update user = update user

src/MyWebLog.Data/PostgresData.fs

@@ -0,0 +1,269 @@
+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.FSharp
+
+/// Data implementation for PostgreSQL
+type PostgresData(log: ILogger<PostgresData>, ser: JsonSerializer) =
+    
+    /// Create any needed tables
+    let ensureTables () = backgroundTask {
+        // Set up the PostgreSQL document store
+        Configuration.useSerializer (Utils.createDocumentSerializer ser)
+        
+        let! tables =
+            Custom.list
+                "SELECT tablename FROM pg_tables WHERE schemaname = 'public'" [] (fun row -> row.string "tablename")
+        let needsTable table = not (List.contains table tables)
+        
+        let sql = seq {
+            // Theme tables
+            if needsTable Table.Theme then
+                Query.Definition.ensureTable Table.Theme
+                Query.Definition.ensureKey   Table.Theme
+            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 table
+            if needsTable Table.WebLog then
+                Query.Definition.ensureTable         Table.WebLog
+                Query.Definition.ensureKey           Table.WebLog
+                Query.Definition.ensureDocumentIndex Table.WebLog Optimized
+            
+            // Category table
+            if needsTable Table.Category then
+                Query.Definition.ensureTable         Table.Category
+                Query.Definition.ensureKey           Table.Category
+                Query.Definition.ensureDocumentIndex Table.Category Optimized
+            
+            // Web log user table
+            if needsTable Table.WebLogUser then
+                Query.Definition.ensureTable         Table.WebLogUser
+                Query.Definition.ensureKey           Table.WebLogUser
+                Query.Definition.ensureDocumentIndex Table.WebLogUser Optimized
+            
+            // Page tables
+            if needsTable Table.Page then
+                Query.Definition.ensureTable   Table.Page
+                Query.Definition.ensureKey     Table.Page
+                Query.Definition.ensureIndexOn Table.Page "author" [ nameof Page.Empty.AuthorId ]
+                Query.Definition.ensureIndexOn
+                    Table.Page "permalink" [ nameof Page.Empty.WebLogId; nameof Page.Empty.Permalink ]
+            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 Table.Post then
+                Query.Definition.ensureTable   Table.Post
+                Query.Definition.ensureKey     Table.Post
+                Query.Definition.ensureIndexOn Table.Post "author" [ nameof Post.Empty.AuthorId ]
+                Query.Definition.ensureIndexOn
+                    Table.Post "permalink" [ nameof Post.Empty.WebLogId; nameof Post.Empty.Permalink ]
+                Query.Definition.ensureIndexOn
+                    Table.Post
+                    "status"
+                    [ nameof Post.Empty.WebLogId; nameof Post.Empty.Status; nameof Post.Empty.UpdatedOn ]
+                $"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 Table.PostComment then
+                Query.Definition.ensureTable   Table.PostComment
+                Query.Definition.ensureKey     Table.PostComment
+                Query.Definition.ensureIndexOn Table.PostComment "post" [ nameof Comment.Empty.PostId ]
+            
+            // Tag map table
+            if needsTable Table.TagMap then
+                Query.Definition.ensureTable         Table.TagMap
+                Query.Definition.ensureKey           Table.TagMap
+                Query.Definition.ensureDocumentIndex Table.TagMap Optimized
+            
+            // Uploaded file table
+            if needsTable Table.Upload then
+                $"CREATE TABLE {Table.Upload} (
+                    id          TEXT        NOT NULL PRIMARY KEY,
+                    web_log_id  TEXT        NOT NULL,
+                    path        TEXT        NOT NULL,
+                    updated_on  TIMESTAMPTZ NOT NULL,
+                    data        BYTEA       NOT NULL)"
+                $"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 Table.DbVersion then
+                $"CREATE TABLE {Table.DbVersion} (id TEXT NOT NULL PRIMARY KEY)"
+                $"INSERT INTO {Table.DbVersion} VALUES ('{Utils.Migration.currentDbVersion}')"
+        }
+        
+        Configuration.dataSource ()
+        |> Sql.fromDataSource
+        |> Sql.executeTransactionAsync
+            (sql
+             |> Seq.map (fun s ->
+                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)
+        |> Async.AwaitTask
+        |> Async.RunSynchronously
+        |> ignore
+    }
+    
+    /// Set a specific database version
+    let setDbVersion version = backgroundTask {
+        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 Query.Definition.ensureKey |> 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 Query.Definition.ensureKey
+              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 ]
+              Query.Definition.ensureIndexOn
+                  Table.Page "permalink" [ nameof Page.Empty.WebLogId; nameof Page.Empty.Permalink ]
+              Query.Definition.ensureIndexOn Table.Post "author" [ nameof Post.Empty.AuthorId ]
+              Query.Definition.ensureIndexOn
+                  Table.Post "permalink" [ nameof Post.Empty.WebLogId; nameof Post.Empty.Permalink ]
+              Query.Definition.ensureIndexOn
+                  Table.Post
+                  "status"
+                  [ nameof Post.Empty.WebLogId; nameof Post.Empty.Status; nameof Post.Empty.UpdatedOn ]
+              $"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 ] ]
+        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"
+    }
+
+    /// Do required data migration between versions
+    let migrate version = backgroundTask {
+        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 <> Utils.Migration.currentDbVersion then
+            log.LogWarning $"Unknown database version; assuming {Utils.Migration.currentDbVersion}"
+            let! _ = setDbVersion Utils.Migration.currentDbVersion
+            ()
+    }
+        
+    interface IData with
+        
+        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 = Custom.single "SELECT id FROM db_version" [] (fun row -> row.string "id")
+            do! migrate version
+        }

src/MyWebLog.Data/SQLite/Helpers.fs

@@ -1,311 +0,0 @@
-/// Helper functions for the SQLite data implementation
-[<AutoOpen>]
-module MyWebLog.Data.SQLite.Helpers
-
-open System
-open Microsoft.Data.Sqlite
-open MyWebLog
-
-/// Run a command that returns a count
-let count (cmd : SqliteCommand) = backgroundTask {
-    let! it = cmd.ExecuteScalarAsync ()
-    return int (it :?> int64)
-}
-
-/// Get lists of items removed from and added to the given lists
-let diffLists<'T, 'U when 'U : equality> oldItems newItems (f : 'T -> 'U) =
-    let diff compList = fun item -> not (compList |> List.exists (fun other -> f item = f other))
-    List.filter (diff newItems) oldItems, List.filter (diff oldItems) newItems
-
-/// Find meta items added and removed
-let diffMetaItems (oldItems : MetaItem list) newItems =
-    diffLists oldItems newItems (fun item -> $"{item.name}|{item.value}")
-
-/// Find the permalinks added and removed
-let diffPermalinks oldLinks newLinks =
-    diffLists oldLinks newLinks Permalink.toString
-
-/// Find the revisions added and removed
-let diffRevisions oldRevs newRevs =
-    diffLists oldRevs newRevs (fun (rev : Revision) -> $"{rev.asOf.Ticks}|{MarkupText.toString rev.text}")
-
-/// 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 ()
-    ()
-}
-
-/// 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)
-    
-    /// 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 category ID from the current row in the given data reader
-    let toCategoryId = getString "id" >> CategoryId
-    
-    /// Create a category from the current row in the given data reader
-    let toCategory (rdr : SqliteDataReader) : Category =
-        { id          = toCategoryId rdr
-          webLogId    = WebLogId (getString "web_log_id" rdr)
-          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 (rdr : SqliteDataReader) : CustomFeed =
-        { id      = CustomFeedId (getString "id" rdr)
-          source  = CustomFeedSource.parse (getString "source" rdr)
-          path    = Permalink (getString "path" rdr)
-          podcast =
-              if rdr.IsDBNull (rdr.GetOrdinal "title") then
-                  None
-              else
-                  Some {
-                      title             = getString "title" rdr
-                      subtitle          = tryString "subtitle" rdr
-                      itemsInFeed       = getInt "items_in_feed" rdr
-                      summary           = getString "summary" rdr
-                      displayedAuthor   = getString "displayed_author" rdr
-                      email             = getString "email" rdr
-                      imageUrl          = Permalink (getString "image_url" rdr)
-                      iTunesCategory    = getString "itunes_category" rdr
-                      iTunesSubcategory = tryString "itunes_subcategory" rdr
-                      explicit          = ExplicitRating.parse (getString "explicit" rdr)
-                      defaultMediaType  = tryString "default_media_type" rdr
-                      mediaBaseUrl      = tryString "media_base_url" rdr
-                      guid              = tryGuid "guid" rdr
-                      fundingUrl        = tryString "funding_url" rdr
-                      fundingText       = tryString "funding_text" rdr
-                      medium            = tryString "medium" rdr |> Option.map PodcastMedium.parse
-                  }
-        }
-    
-    /// Create a meta item from the current row in the given data reader
-    let toMetaItem (rdr : SqliteDataReader) : MetaItem =
-        { name  = getString "name" rdr
-          value = getString "value" rdr
-        }
-    
-    /// Create a permalink from the current row in the given data reader
-    let toPermalink = getString "permalink" >> Permalink
-    
-    /// Create a page from the current row in the given data reader
-    let toPage (rdr : SqliteDataReader) : Page =
-        { Page.empty with
-            id             = PageId (getString "id" rdr)
-            webLogId       = WebLogId (getString "web_log_id" rdr)
-            authorId       = WebLogUserId (getString "author_id" rdr)
-            title          = getString "title" rdr
-            permalink      = toPermalink rdr
-            publishedOn    = getDateTime "published_on" rdr
-            updatedOn      = getDateTime "updated_on" rdr
-            showInPageList = getBoolean "show_in_page_list" rdr
-            template       = tryString "template" rdr
-            text           = getString "page_text" rdr
-        }
-    
-    /// Create a post from the current row in the given data reader
-    let toPost (rdr : SqliteDataReader) : Post =
-        { Post.empty with
-            id             = PostId (getString "id" rdr)
-            webLogId       = WebLogId (getString "web_log_id" rdr)
-            authorId       = WebLogUserId (getString "author_id" rdr)
-            status         = PostStatus.parse (getString "status" rdr)
-            title          = getString "title" rdr
-            permalink      = toPermalink rdr
-            publishedOn    = tryDateTime "published_on" rdr
-            updatedOn      = getDateTime "updated_on" rdr
-            template       = tryString "template" rdr
-            text           = getString "post_text" rdr
-            episode        =
-                match tryString "media" rdr with
-                | Some media ->
-                    Some {
-                        media              = media
-                        length             = getLong "length" rdr
-                        duration           = tryTimeSpan "duration" rdr
-                        mediaType          = tryString "media_type" rdr
-                        imageUrl           = tryString "image_url" rdr
-                        subtitle           = tryString "subtitle" rdr
-                        explicit           = tryString "explicit" rdr |> Option.map ExplicitRating.parse
-                        chapterFile        = tryString "chapter_file" rdr
-                        chapterType        = tryString "chapter_type" rdr
-                        transcriptUrl      = tryString "transcript_url" rdr
-                        transcriptType     = tryString "transcript_type" rdr
-                        transcriptLang     = tryString "transcript_lang" rdr
-                        transcriptCaptions = tryBoolean "transcript_captions" rdr
-                        seasonNumber       = tryInt "season_number" rdr
-                        seasonDescription  = tryString "season_description" rdr
-                        episodeNumber      = tryString "episode_number" rdr |> Option.map Double.Parse
-                        episodeDescription = tryString "episode_description" rdr
-                    }
-                | None -> None
-        }
-    
-    /// Create a revision from the current row in the given data reader
-    let toRevision (rdr : SqliteDataReader) : Revision =
-        { asOf = getDateTime "as_of" rdr
-          text = MarkupText.parse (getString "revision_text" rdr)
-        }
-    
-    /// Create a tag mapping from the current row in the given data reader
-    let toTagMap (rdr : SqliteDataReader) : TagMap =
-        { id       = TagMapId (getString "id" rdr)
-          webLogId = WebLogId (getString "web_log_id" rdr)
-          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 : SqliteDataReader) : Theme =
-        { Theme.empty with
-            id      = ThemeId (getString "id" rdr)
-            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 : SqliteDataReader) : 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 = getDateTime "updated_on" rdr
-          data      = assetData
-        }
-    
-    /// Create a theme template from the current row in the given data reader
-    let toThemeTemplate (rdr : SqliteDataReader) : ThemeTemplate =
-        { name = getString "name" rdr
-          text = getString "template" rdr
-        }
-    
-    /// Create an uploaded file from the current row in the given data reader
-    let toUpload includeData (rdr : SqliteDataReader) : Upload =
-        let data =
-            if includeData then
-                use dataStream = new MemoryStream ()
-                use blobStream = getStream "data" rdr
-                blobStream.CopyTo dataStream
-                dataStream.ToArray ()
-            else
-                [||]
-        { id        = UploadId (getString "id" rdr)
-          webLogId  = WebLogId (getString "web_log_id" rdr)
-          path      = Permalink (getString "path" rdr)
-          updatedOn = getDateTime "updated_on" rdr
-          data      = data
-        }
-    
-    /// Create a web log from the current row in the given data reader
-    let toWebLog (rdr : SqliteDataReader) : WebLog =
-        { id           = WebLogId (getString "id" rdr)
-          name         = getString "name" rdr
-          slug         = getString "slug" rdr
-          subtitle     = tryString "subtitle" rdr
-          defaultPage  = getString "default_page" rdr
-          postsPerPage = getInt "posts_per_page" rdr
-          themePath    = getString "theme_id" rdr
-          urlBase      = getString "url_base" rdr
-          timeZone     = getString "time_zone" rdr
-          autoHtmx     = getBoolean "auto_htmx" rdr
-          uploads      = UploadDestination.parse (getString "uploads" rdr)
-          rss          = {
-              feedEnabled     = getBoolean "feed_enabled" rdr
-              feedName        = getString "feed_name" rdr
-              itemsInFeed     = tryInt "items_in_feed" rdr
-              categoryEnabled = getBoolean "category_enabled" rdr
-              tagEnabled      = getBoolean "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 : SqliteDataReader) : WebLogUser =
-        { id                 = WebLogUserId (getString "id" rdr)
-          webLogId           = WebLogId (getString "web_log_id" rdr)
-          userName           = getString "user_name" rdr
-          firstName          = getString "first_name" rdr
-          lastName           = getString "last_name" rdr
-          preferredName      = getString "preferred_name" rdr
-          passwordHash       = getString "password_hash" rdr
-          salt               = getGuid "salt" rdr
-          url                = tryString "url" rdr
-          authorizationLevel = AuthorizationLevel.parse (getString "authorization_level" rdr)
-        }
-
-/// 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
-
-/// 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,129 @@
 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
-    }
+    let countAll webLogId =
+        log.LogTrace "Category.countAll"
+        Document.countByWebLog Table.Category webLogId conn
     
     /// 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
-    }
+    let countTopLevel webLogId =
+        log.LogTrace "Category.countTopLevel"
+        conn.customScalar
+            $"{Document.Query.countByWebLog Table.Category} AND data ->> '{parentIdField}' IS NULL"
+            [ webLogParam webLogId ]
+            (toCount >> int)
+    
+    /// Find all categories for the given web log
+    let findByWebLog webLogId =
+        log.LogTrace "Category.findByWebLog"
+        Document.findByWebLog<Category> Table.Category webLogId conn
     
     /// 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
-                cmd.Parameters.Clear ()
-                addWebLogId cmd webLogId
-                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'
-                       AND pc.category_id IN ("""
-                ordered
-                |> Seq.filter (fun cat -> cat.parentNames |> Array.contains it.name)
-                |> Seq.map (fun cat -> cat.id)
-                |> Seq.append (Seq.singleton it.id)
-                |> Seq.iteri (fun idx item ->
-                    if idx > 0 then cmd.CommandText <- $"{cmd.CommandText}, "
-                    cmd.CommandText <- $"{cmd.CommandText}@catId{idx}"
-                    cmd.Parameters.AddWithValue ($"@catId{idx}", item) |> ignore)
-                cmd.CommandText <- $"{cmd.CommandText})"
-                let! postCount = count cmd
-                return it.id, postCount
-                })
+                let catSql, catParams =
+                    ordered
+                    |> Seq.filter (fun cat -> cat.ParentNames |> Array.contains it.Name)
+                    |> Seq.map _.Id
+                    |> Seq.append (Seq.singleton it.Id)
+                    |> List.ofSeq
+                    |> inJsonArray Table.Post (nameof Post.Empty.CategoryIds) "catId"
+                let query = $"""
+                    SELECT COUNT(DISTINCT data ->> '{nameof Post.Empty.Id}')
+                      FROM {Table.Post}
+                     WHERE {Document.Query.whereByWebLog}
+                       AND {Query.whereByField (Field.EQ (nameof Post.Empty.Status) "") $"'{string Published}'"}
+                       AND {catSql}"""
+                let! postCount = conn.customScalar query (webLogParam webLogId :: catParams) 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 webLogId =
+        log.LogTrace "Category.findById"
+        Document.findByIdAndWebLog<CategoryId, Category> Table.Category catId webLogId conn
     
     /// Delete a category
     let delete catId webLogId = backgroundTask {
+        log.LogTrace "Category.delete"
         match! findById catId webLogId with
-        | Some _ ->
-            use cmd = conn.CreateCommand ()
-            // Delete the category off all posts where it is assigned
-            cmd.CommandText <- """
-                DELETE FROM post_category
-                 WHERE category_id = @id
-                   AND post_id IN (SELECT id FROM post WHERE web_log_id = @webLogId)"""
-            let catIdParameter = cmd.Parameters.AddWithValue ("@id", CategoryId.toString catId)
-            cmd.Parameters.AddWithValue ("@webLogId", WebLogId.toString webLogId) |> ignore
-            do! write cmd
-            // Delete the category itself
-            cmd.CommandText <- "DELETE FROM category WHERE id = @id"
-            cmd.Parameters.Clear ()
-            cmd.Parameters.Add catIdParameter |> ignore
-            do! write cmd
-            return true
-        | None -> return false
+        | Some cat ->
+            // Reassign any children to the category's parent category
+            let! children = conn.countByField Table.Category (Field.EQ parentIdField (string catId))
+            if children > 0L then
+                let parent = Field.EQ parentIdField (string catId)
+                match cat.ParentId with
+                | Some _ -> do! conn.patchByField Table.Category parent {| ParentId = cat.ParentId |}
+                | None -> do! conn.removeFieldsByField Table.Category parent [ parentIdField ]
+            // Delete the category off all posts where it is assigned, and the category itself
+            let catIdField = nameof Post.Empty.CategoryIds
+            let! posts =
+                conn.customList
+                    $"SELECT data ->> '{nameof Post.Empty.Id}', data -> '{catIdField}'
+                        FROM {Table.Post}
+                       WHERE {Document.Query.whereByWebLog}
+                         AND EXISTS
+                               (SELECT 1
+                                  FROM json_each({Table.Post}.data -> '{catIdField}')
+                                 WHERE json_each.value = @id)"
+                    [ idParam catId; webLogParam webLogId ]
+                    (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 _.countAll webLogId = countAll webLogId
-        member _.countTopLevel webLogId = countTopLevel webLogId
-        member _.findAllForView webLogId = findAllForView webLogId
-        member _.findById catId webLogId = findById catId webLogId
-        member _.findByWebLog webLogId = findByWebLog webLogId
-        member _.delete catId webLogId = delete catId webLogId
-        member _.restore cats = restore cats
-        member _.update cat = update cat
+        member _.Add cat = save cat
+        member _.CountAll webLogId = countAll webLogId
+        member _.CountTopLevel webLogId = countTopLevel webLogId
+        member _.FindAllForView webLogId = findAllForView webLogId
+        member _.FindById catId webLogId = findById catId webLogId
+        member _.FindByWebLog webLogId = findByWebLog webLogId
+        member _.Delete catId webLogId = delete catId webLogId
+        member _.Restore cats = restore cats
+        member _.Update cat = save cat

src/MyWebLog.Data/SQLite/SQLiteHelpers.fs

@@ -0,0 +1,307 @@
+/// 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
+
+/// Create the SQL and parameters for an EXISTS applied to a JSON array
+let inJsonArray<'T> table jsonField paramName (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}", string it) :: itemP))
+            (Seq.ofList items
+             |> Seq.map (fun it -> $"(@%s{paramName}0", [ SqliteParameter($"@%s{paramName}0", string it) ])
+             |> Seq.head)
+        |> function
+            sql, ps ->
+                $"EXISTS (SELECT 1 FROM json_each(%s{table}.data, '$.%s{jsonField}') WHERE value IN {sql}))", ps
+
+/// 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 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 }
+
+
+/// 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)
+
+
+open BitBadger.Documents
+open BitBadger.Documents.Sqlite
+open BitBadger.Documents.Sqlite.WithConn
+
+/// Functions for manipulating documents
+module Document =
+    
+    /// Queries to assist with document manipulation
+    module Query =
+        
+        /// Fragment to add a web log ID condition to a WHERE clause (parameter @webLogId)
+        let whereByWebLog =
+            Query.whereByField (Field.EQ "WebLogId" "") "@webLogId"
+        
+        /// A SELECT query to count documents for a given web log ID
+        let countByWebLog table =
+            $"{Query.Count.all table} WHERE {whereByWebLog}"
+        
+        /// A query to select from a table by the document's ID and its web log ID
+        let selectByIdAndWebLog table =
+            $"{Query.Find.byId table} AND {whereByWebLog}"
+        
+        /// A query to select from a table by its web log ID
+        let selectByWebLog table =
+            $"{Query.selectFromTable table} WHERE {whereByWebLog}"
+    
+    /// Count documents for the given web log ID
+    let countByWebLog table (webLogId: WebLogId) conn = backgroundTask {
+        let! count = Count.byField table (Field.EQ "WebLogId" (string webLogId)) conn
+        return int count
+    }
+    
+    /// Find a document by its ID and web log ID
+    let findByIdAndWebLog<'TKey, 'TDoc> table (key: 'TKey) webLogId conn =
+        Custom.single (Query.selectByIdAndWebLog table) [ idParam key; webLogParam webLogId ] fromData<'TDoc> conn
+    
+    /// Find documents for the given web log
+    let findByWebLog<'TDoc> table (webLogId: WebLogId) conn =
+        Find.byField<'TDoc> table (Field.EQ "WebLogId" (string webLogId)) conn
+
+
+/// Functions to support revisions
+module Revisions =
+    
+    /// Find all revisions for the given entity
+    let findByEntityId<'TKey> revTable entityTable (key: 'TKey) conn =
+        Custom.list
+            $"SELECT as_of, revision_text FROM %s{revTable} WHERE %s{entityTable}_id = @id ORDER BY as_of DESC"
+            [ idParam key ]
+            Map.toRevision
+            conn
+    
+    /// Find all revisions for all posts for the given web log
+    let findByWebLog<'TKey> revTable entityTable (keyFunc: string -> 'TKey) webLogId conn =
+        Custom.list
+            $"SELECT pr.*
+                FROM %s{revTable} pr
+                     INNER JOIN %s{entityTable} p ON p.data ->> 'Id' = pr.{entityTable}_id
+               WHERE p.{Document.Query.whereByWebLog}
+               ORDER BY as_of DESC"
+            [ webLogParam webLogId ]
+            (fun rdr -> keyFunc (Map.getString $"{entityTable}_id" rdr), Map.toRevision rdr)
+            conn
+
+    /// Update a page or post's revisions
+    let update<'TKey> revTable entityTable (key: 'TKey) oldRevs newRevs conn = backgroundTask {
+        let toDelete, toAdd = Utils.diffRevisions oldRevs newRevs
+        for delRev in toDelete do
+            do! Custom.nonQuery
+                    $"DELETE FROM %s{revTable} WHERE %s{entityTable}_id = @id AND as_of = @asOf"
+                    [ idParam key; sqlParam "@asOf" (instantParam delRev.AsOf) ]
+                    conn
+        for addRev in toAdd do
+            do! Custom.nonQuery
+                    $"INSERT INTO {revTable} VALUES (@id, @asOf, @text)"
+                    [ idParam key; sqlParam "asOf" (instantParam addRev.AsOf); sqlParam "@text" (string addRev.Text) ]
+                    conn
+    }

src/MyWebLog.Data/SQLite/SQLitePageData.fs

@@ -1,366 +1,188 @@
 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 page data implementation        
-type SQLitePageData (conn : SqliteConnection) =
+/// 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
+    
+    /// The JSON field for the title of the page
+    let titleField = $"data ->> '{nameof Page.Empty.Title}'"
     
     // 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", page.publishedOn)
-          cmd.Parameters.AddWithValue ("@updatedOn", page.updatedOn)
-          cmd.Parameters.AddWithValue ("@showInPageList", page.showInPageList)
-          cmd.Parameters.AddWithValue ("@template", maybe page.template)
-          cmd.Parameters.AddWithValue ("@text", page.text)
-        ] |> ignore
-    
-    /// Append meta items to a page
-    let appendPageMeta (page : Page) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT name, value FROM page_meta WHERE page_id = @id"
-        cmd.Parameters.AddWithValue ("@id", PageId.toString page.id) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return { page with metadata = toList Map.toMetaItem 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 }
     }
     
-    /// 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 }
-    }
-    
-    /// Return a page with no text (or meta items, prior permalinks, or revisions)
-    let pageWithoutTextOrMeta rdr =
-        { Map.toPage rdr with text = "" }
-    
-    /// Update a page's metadata items
-    let updatePageMeta pageId oldItems newItems = backgroundTask {
-        let toDelete, toAdd = diffMetaItems oldItems newItems
-        if List.isEmpty toDelete && List.isEmpty toAdd then
-            return ()
-        else
-            use cmd = conn.CreateCommand ()
-            [ cmd.Parameters.AddWithValue ("@pageId", PageId.toString pageId)
-              cmd.Parameters.Add ("@name", SqliteType.Text)
-              cmd.Parameters.Add ("@value", SqliteType.Text)
-            ] |> ignore
-            let runCmd (item : MetaItem) = backgroundTask {
-                cmd.Parameters["@name" ].Value <- item.name
-                cmd.Parameters["@value"].Value <- item.value
-                do! write cmd
-            }
-            cmd.CommandText <- "DELETE FROM page_meta WHERE page_id = @pageId AND name = @name AND value = @value" 
-            toDelete
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-            cmd.CommandText <- "INSERT INTO page_meta VALUES (@pageId, @name, @value)"
-            toAdd
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-    }
-    
-    /// Update a page's prior permalinks
-    let updatePagePermalinks pageId oldLinks newLinks = backgroundTask {
-        let toDelete, toAdd = 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 = 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", 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, show_in_page_list, template,
-                page_text
-            ) VALUES (
-                @id, @webLogId, @authorId, @title, @permalink, @publishedOn, @updatedOn, @showInPageList, @template,
-                @text
-            )"""
-        addPageParameters cmd page
-        do! write cmd
-        do! updatePageMeta       page.id [] page.metadata
-        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 pageWithoutTextOrMeta rdr
-    }
+    /// Get all pages for a web log (without text, metadata, revisions, or prior permalinks)
+    let all webLogId =
+        log.LogTrace "Page.all"
+        conn.customList
+            $"{Query.selectFromTable Table.Page} WHERE {Document.Query.whereByWebLog} ORDER BY LOWER({titleField})"
+            [ webLogParam webLogId ]
+            (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
-    }
+    let countAll webLogId =
+        log.LogTrace "Page.countAll"
+        Document.countByWebLog Table.Page webLogId conn
     
     /// 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 show_in_page_list = @showInPageList"""
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@showInPageList", true) |> ignore
-        return! count cmd
-    }
+    let countListed webLogId =
+        log.LogTrace "Page.countListed"
+        conn.customScalar
+            $"""{Document.Query.countByWebLog Table.Page} AND {Query.whereByField (Field.EQ pgListName "") "true"}"""
+            [ webLogParam webLogId ]
+            (toCount >> int)
     
     /// 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 ()
-        match Helpers.verifyWebLog<Page> webLogId (fun it -> it.webLogId) Map.toPage rdr with
-        | Some page ->
-            let! page = appendPageMeta page
-            return Some page
+        log.LogTrace "Page.findById"
+        match! Document.findByIdAndWebLog<PageId, Page> Table.Page pageId webLogId conn 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 conn 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_meta      WHERE page_id = @id;
-                DELETE FROM page           WHERE id      = @id"""
-            do! write cmd
+            do! conn.customNonQuery
+                    $"DELETE FROM {Table.PageRevision} WHERE page_id = @id; {Query.Delete.byId Table.Page}"
+                    [ 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 ()
-        if rdr.Read () then
-            let! page = appendPageMeta (Map.toPage rdr)
-            return Some page
-        else
-            return None
-    }
+    let findByPermalink (permalink: Permalink) webLogId =
+        log.LogTrace "Page.findByPermalink"
+        let linkParam = Field.EQ linkName (string permalink)
+        conn.customSingle
+            $"""{Document.Query.selectByWebLog Table.Page} AND {Query.whereByField linkParam "@link"}"""
+            (addFieldParam "@link" linkParam [ webLogParam webLogId ])
+            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 ()
-        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
-               AND pp.permalink IN ("""
-        permalinks
-        |> List.iteri (fun idx link ->
-            if idx > 0 then cmd.CommandText <- $"{cmd.CommandText}, "
-            cmd.CommandText <- $"{cmd.CommandText}@link{idx}"
-            cmd.Parameters.AddWithValue ($"@link{idx}", Permalink.toString link) |> ignore)
-        cmd.CommandText <- $"{cmd.CommandText})"
-        addWebLogId cmd webLogId
-        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 linkSql, linkParams = inJsonArray Table.Page (nameof Page.Empty.PriorPermalinks) "link" permalinks
+        conn.customSingle
+            $"SELECT data ->> '{linkName}' AS permalink
+                FROM {Table.Page}
+               WHERE {Document.Query.whereByWebLog} AND {linkSql}"
+            (webLogParam webLogId :: linkParams)
+            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 Map.toPage rdr
-            |> List.map (fun page -> backgroundTask {
-                let! page = appendPageMeta page
-                return! appendPageRevisionsAndPermalinks page
-            })
-            |> Task.WhenAll
-        return List.ofArray pages
+        log.LogTrace "Page.findFullByWebLog"
+        let! pages    = Document.findByWebLog<Page> Table.Page webLogId conn
+        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 show_in_page_list = @showInPageList
-             ORDER BY LOWER(title)"""
-        addWebLogId cmd webLogId
-        cmd.Parameters.AddWithValue ("@showInPageList", true) |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! pages =
-            toList pageWithoutTextOrMeta rdr
-            |> List.map (fun page -> backgroundTask { return! appendPageMeta page })
-            |> Task.WhenAll
-        return List.ofArray pages
-    }
+    /// Get all listed pages for the given web log (without revisions or text)
+    let findListed webLogId =
+        log.LogTrace "Page.findListed"
+        conn.customList
+            $"""{Document.Query.selectByWebLog Table.Page} AND {Query.whereByField (Field.EQ pgListName "") "true"}
+                ORDER BY LOWER({titleField})"""
+            [ webLogParam webLogId ]
+            (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 Map.toPage rdr
+    /// Get a page of pages for the given web log (without revisions)
+    let findPageOfPages webLogId pageNbr =
+        log.LogTrace "Page.findPageOfPages"
+        conn.customList
+            $"{Document.Query.selectByWebLog Table.Page} ORDER BY LOWER({titleField}) LIMIT @pageSize OFFSET @toSkip"
+            [ webLogParam webLogId; SqliteParameter("@pageSize", 26); SqliteParameter("@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,
-                       show_in_page_list = @showInPageList,
-                       template          = @template,
-                       page_text         = @text
-                 WHERE id         = @pageId
-                   AND web_log_id = @webLogId"""
-            addPageParameters cmd page
-            do! write cmd
-            do! updatePageMeta       page.id oldPage.metadata        page.metadata
-            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
-        member _.add page = add page
-        member _.all webLogId = all webLogId
-        member _.countAll webLogId = countAll webLogId
-        member _.countListed webLogId = countListed webLogId
-        member _.delete pageId webLogId = delete pageId webLogId
-        member _.findById pageId webLogId = findById pageId webLogId
-        member _.findByPermalink permalink webLogId = findByPermalink permalink webLogId
-        member _.findCurrentPermalink permalinks webLogId = findCurrentPermalink permalinks webLogId
-        member _.findFullById pageId webLogId = findFullById pageId webLogId
-        member _.findFullByWebLog webLogId = findFullByWebLog webLogId
-        member _.findListed webLogId = findListed webLogId
-        member _.findPageOfPages webLogId pageNbr = findPageOfPages webLogId pageNbr
-        member _.restore pages = restore pages
-        member _.update page = update page
-        member _.updatePriorPermalinks pageId webLogId permalinks = updatePriorPermalinks pageId webLogId permalinks
+        member _.Add page = add page
+        member _.All webLogId = all webLogId
+        member _.CountAll webLogId = countAll webLogId
+        member _.CountListed webLogId = countListed webLogId
+        member _.Delete pageId webLogId = delete pageId webLogId
+        member _.FindById pageId webLogId = findById pageId webLogId
+        member _.FindByPermalink permalink webLogId = findByPermalink permalink webLogId
+        member _.FindCurrentPermalink permalinks webLogId = findCurrentPermalink permalinks webLogId
+        member _.FindFullById pageId webLogId = findFullById pageId webLogId
+        member _.FindFullByWebLog webLogId = findFullByWebLog webLogId
+        member _.FindListed webLogId = findListed webLogId
+        member _.FindPageOfPages webLogId pageNbr = findPageOfPages webLogId pageNbr
+        member _.Restore pages = restore pages
+        member _.Update page = update page
+        member _.UpdatePriorPermalinks pageId webLogId permalinks = updatePriorPermalinks pageId webLogId permalinks

src/MyWebLog.Data/SQLite/SQLitePostData.fs

@@ -1,579 +1,234 @@
 namespace MyWebLog.Data.SQLite
 
-open System
 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 NodaTime
 
-/// SQLite myWebLog post data implementation        
-type SQLitePostData (conn : SqliteConnection) =
-
+/// 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 publishField = $"data ->> '{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", maybe post.publishedOn)
-          cmd.Parameters.AddWithValue ("@updatedOn", post.updatedOn)
-          cmd.Parameters.AddWithValue ("@template", maybe post.template)
-          cmd.Parameters.AddWithValue ("@text", post.text)
-        ] |> ignore
-    
-    /// Add parameters for episode INSERT or UPDATE statements
-    let addEpisodeParameters (cmd : SqliteCommand) (ep : Episode) =
-        [ cmd.Parameters.AddWithValue ("@media", ep.media)
-          cmd.Parameters.AddWithValue ("@length", ep.length)
-          cmd.Parameters.AddWithValue ("@duration", maybe ep.duration)
-          cmd.Parameters.AddWithValue ("@mediaType", maybe ep.mediaType)
-          cmd.Parameters.AddWithValue ("@imageUrl", maybe ep.imageUrl)
-          cmd.Parameters.AddWithValue ("@subtitle", maybe ep.subtitle)
-          cmd.Parameters.AddWithValue ("@explicit", maybe (ep.explicit |> Option.map ExplicitRating.toString))
-          cmd.Parameters.AddWithValue ("@chapterFile", maybe ep.chapterFile)
-          cmd.Parameters.AddWithValue ("@chapterType", maybe ep.chapterType)
-          cmd.Parameters.AddWithValue ("@transcriptUrl", maybe ep.transcriptUrl)
-          cmd.Parameters.AddWithValue ("@transcriptType", maybe ep.transcriptType)
-          cmd.Parameters.AddWithValue ("@transcriptLang", maybe ep.transcriptLang)
-          cmd.Parameters.AddWithValue ("@transcriptCaptions", maybe ep.transcriptCaptions)
-          cmd.Parameters.AddWithValue ("@seasonNumber", maybe ep.seasonNumber)
-          cmd.Parameters.AddWithValue ("@seasonDescription", maybe ep.seasonDescription)
-          cmd.Parameters.AddWithValue ("@episodeNumber", maybe (ep.episodeNumber |> Option.map string))
-          cmd.Parameters.AddWithValue ("@episodeDescription", maybe ep.episodeDescription)
-        ] |> ignore
-        
-    /// Append category IDs, tags, and meta items to a post
-    let appendPostCategoryTagAndMeta (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 ()
-        let post = { post with tags = toList (Map.getString "tag") rdr }
-        do! rdr.CloseAsync ()
-        
-        cmd.CommandText <- "SELECT name, value FROM post_meta WHERE post_id = @id"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return { post with metadata = toList Map.toMetaItem 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 = Document.Query.selectByWebLog Table.Post
+    
+    /// 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 =
-        { Map.toPost rdr with text = "" }
+        { postWithoutLinks rdr with Text = "" }
     
-    /// Update a post's assigned categories
-    let updatePostCategories postId oldCats newCats = backgroundTask {
-        let toDelete, toAdd = 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 = 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 an episode
-    let updatePostEpisode (post : Post) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT COUNT(post_id) FROM post_episode WHERE post_id = @postId"
-        cmd.Parameters.AddWithValue ("@postId", PostId.toString post.id) |> ignore
-        let! count = count cmd
-        if count = 1 then
-            match post.episode with
-            | Some ep ->
-                cmd.CommandText <- """
-                    UPDATE post_episode
-                       SET media               = @media,
-                           length              = @length,
-                           duration            = @duration,
-                           media_type          = @mediaType,
-                           image_url           = @imageUrl,
-                           subtitle            = @subtitle,
-                           explicit            = @explicit,
-                           chapter_file        = @chapterFile,
-                           chapter_type        = @chapterType,
-                           transcript_url      = @transcriptUrl,
-                           transcript_type     = @transcriptType,
-                           transcript_lang     = @transcriptLang,
-                           transcript_captions = @transcriptCaptions,
-                           season_number       = @seasonNumber,
-                           season_description  = @seasonDescription,
-                           episode_number      = @episodeNumber,
-                           episode_description = @episodeDescription
-                     WHERE post_id = @postId"""
-                addEpisodeParameters cmd ep
-                do! write cmd
-            | None ->
-                cmd.CommandText <- "DELETE FROM post_episode WHERE post_id = @postId"
-                do! write cmd
-        else
-            match post.episode with
-            | Some ep ->
-                cmd.CommandText <- """
-                    INSERT INTO post_episode (
-                        post_id, media, length, duration, media_type, image_url, subtitle, explicit, chapter_file,
-                        chapter_type, transcript_url, transcript_type, transcript_lang, transcript_captions,
-                        season_number, season_description, episode_number, episode_description
-                    ) VALUES (
-                        @postId, @media, @length, @duration, @mediaType, @imageUrl, @subtitle, @explicit, @chapterFile,
-                        @chapterType, @transcriptUrl, @transcriptType, @transcriptLang, @transcriptCaptions,
-                        @seasonNumber, @seasonDescription, @episodeNumber, @episodeDescription
-                    )"""
-                addEpisodeParameters cmd ep
-                do! write cmd
-            | None -> ()
-    }
-    
-    /// Update a post's metadata items
-    let updatePostMeta postId oldItems newItems = backgroundTask {
-        let toDelete, toAdd = diffMetaItems oldItems newItems
-        if List.isEmpty toDelete && List.isEmpty toAdd then
-            return ()
-        else
-            use cmd = conn.CreateCommand ()
-            [ cmd.Parameters.AddWithValue ("@postId", PostId.toString postId)
-              cmd.Parameters.Add ("@name", SqliteType.Text)
-              cmd.Parameters.Add ("@value", SqliteType.Text)
-            ] |> ignore
-            let runCmd (item : MetaItem) = backgroundTask {
-                cmd.Parameters["@name" ].Value <- item.name
-                cmd.Parameters["@value"].Value <- item.value
-                do! write cmd
-            }
-            cmd.CommandText <- "DELETE FROM post_meta WHERE post_id = @postId AND name = @name AND value = @value" 
-            toDelete
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-            cmd.CommandText <- "INSERT INTO post_meta VALUES (@postId, @name, @value)"
-            toAdd
-            |> List.map runCmd
-            |> Task.WhenAll
-            |> ignore
-    }
-    
-    /// Update a post's prior permalinks
-    let updatePostPermalinks postId oldLinks newLinks = backgroundTask {
-        let toDelete, toAdd = 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 {Query.whereByField (Field.EQ statName "") $"'{string Published}'"}"""
     
     /// Update a post's revisions
-    let updatePostRevisions postId oldRevs newRevs = backgroundTask {
-        let toDelete, toAdd = 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", 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
-    }
-    
-    /// The SELECT statement for a post that will include episode data, if it exists
-    let selectPost = "SELECT p.*, e.* FROM post p LEFT JOIN post_episode e ON e.post_id = p.id"
+    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
-            ) VALUES (
-                @id, @webLogId, @authorId, @status, @title, @permalink, @publishedOn, @updatedOn, @template, @text
-            )"""
-        addPostParameters cmd post
-        do! write cmd
-        do! updatePostCategories post.id [] post.categoryIds
-        do! updatePostTags       post.id [] post.tags
-        do! updatePostEpisode    post
-        do! updatePostMeta       post.id [] post.metadata
-        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 =
+        log.LogTrace "Post.countByStatus"
+        let statParam = Field.EQ statName (string status)
+        conn.customScalar
+            $"""{Document.Query.countByWebLog Table.Post} AND {Query.whereByField statParam "@status"}"""
+            (addFieldParam "@status" statParam [ webLogParam webLogId ])
+            (toCount >> int)
+    
+    /// Find a post by its ID for the given web log (excluding revisions)
+    let findById postId webLogId = backgroundTask {
+        log.LogTrace "Post.findById"
+        match! Document.findByIdAndWebLog<PostId, Post> Table.Post postId webLogId conn 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 = appendPostCategoryTagAndMeta (Map.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 linkParam = Field.EQ linkName (string permalink)
+        conn.customSingle
+            $"""{Document.Query.selectByWebLog Table.Post} AND {Query.whereByField linkParam "@link"}"""
+            (addFieldParam "@link" linkParam [ webLogParam webLogId ])
+            postWithoutLinks
     
     /// Find a complete post by its ID for the given web log
     let findFullById 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 ()
-        match Helpers.verifyWebLog<Post> webLogId (fun p -> p.webLogId) Map.toPost rdr with
+        log.LogTrace "Post.findFullById"
+        match! Document.findByIdAndWebLog<PostId, Post> Table.Post postId webLogId conn with
         | Some post ->
-            let! post = appendPostCategoryTagAndMeta     post
-            let! post = appendPostRevisionsAndPermalinks post
+            let! post = appendPostRevisions post
             return Some post
-        | None ->
-            return None
+        | 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_meta      WHERE post_id = @id;
-                DELETE FROM post_episode   WHERE post_id = @id;
-                DELETE FROM post_tag       WHERE post_id = @id;
-                DELETE FROM post_category  WHERE post_id = @id;
-                DELETE FROM post           WHERE id      = @id"""
-            do! write cmd
+            do! conn.customNonQuery
+                    $"""DELETE FROM {Table.PostRevision} WHERE post_id = @id;
+                        DELETE FROM {Table.PostComment}
+                         WHERE {Query.whereByField (Field.EQ (nameof Comment.Empty.PostId) "") "@id"};
+                        {Query.Delete.byId Table.Post}"""
+                    [ 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 ()
-        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
-               AND pp.permalink IN ("""
-        permalinks
-        |> List.iteri (fun idx link ->
-            if idx > 0 then cmd.CommandText <- $"{cmd.CommandText}, "
-            cmd.CommandText <- $"{cmd.CommandText}@link{idx}"
-            cmd.Parameters.AddWithValue ($"@link{idx}", Permalink.toString link) |> ignore)
-        cmd.CommandText <- $"{cmd.CommandText})"
-        addWebLogId cmd webLogId
-        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 linkSql, linkParams = inJsonArray Table.Post (nameof Post.Empty.PriorPermalinks) "link" permalinks
+        conn.customSingle
+            $"SELECT data ->> '{linkName}' AS permalink
+                FROM {Table.Post}
+               WHERE {Document.Query.whereByWebLog} AND {linkSql}"
+            (webLogParam webLogId :: linkParams)
+            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 Map.toPost rdr
-            |> List.map (fun post -> backgroundTask {
-                let! post = appendPostCategoryTagAndMeta post
-                return! appendPostRevisionsAndPermalinks post
-            })
-            |> Task.WhenAll
-        return List.ofArray posts
+        log.LogTrace "Post.findFullByWebLog"
+        let! posts    = Document.findByWebLog<Post> Table.Post webLogId conn
+        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 ()
-        cmd.CommandText <- $"""
-            {selectPost}
-                   INNER JOIN post_category pc ON pc.post_id = p.id
-             WHERE p.web_log_id = @webLogId
-               AND p.status     = @status
-               AND pc.category_id IN ("""
-        categoryIds
-        |> List.iteri (fun idx catId ->
-            if idx > 0 then cmd.CommandText <- $"{cmd.CommandText}, "
-            cmd.CommandText <- $"{cmd.CommandText}@catId{idx}"
-            cmd.Parameters.AddWithValue ($"@catId{idx}", CategoryId.toString catId) |> ignore)
-        cmd.CommandText <-
-            $"""{cmd.CommandText})
-                ORDER BY 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 Map.toPost rdr
-            |> List.map (fun post -> backgroundTask { return! appendPostCategoryTagAndMeta 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 catSql, catParams = inJsonArray Table.Post (nameof Post.Empty.CategoryIds) "catId" categoryIds
+        conn.customList
+            $"{publishedPostByWebLog} AND {catSql}
+               ORDER BY {publishField} DESC
+               LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
+            (webLogParam webLogId :: catParams)
+            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! appendPostCategoryTagAndMeta 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"
+        conn.customList
+            $"{postByWebLog}
+               ORDER BY {publishField} DESC NULLS FIRST, data ->> '{nameof Post.Empty.UpdatedOn}'
+               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 Map.toPost rdr
-            |> List.map (fun post -> backgroundTask { return! appendPostCategoryTagAndMeta 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}
+               ORDER BY {publishField} DESC
+               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 Map.toPost rdr
-            |> List.map (fun post -> backgroundTask { return! appendPostCategoryTagAndMeta 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 tagSql, tagParams = inJsonArray Table.Post (nameof Post.Empty.Tags) "tag" [ tag ]
+        conn.customList
+            $"{publishedPostByWebLog} AND {tagSql}
+               ORDER BY {publishField} DESC
+               LIMIT {postsPerPage + 1} OFFSET {(pageNbr - 1) * postsPerPage}"
+            (webLogParam webLogId :: tagParams)
+            postWithoutLinks
     
     /// Find the next newest and oldest post from a publish date for the given web log
-    let findSurroundingPosts webLogId (publishedOn : DateTime) = 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", publishedOn)
-        ] |> ignore
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! older = backgroundTask {
-            if rdr.Read () then
-                let! post = appendPostCategoryTagAndMeta (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 = appendPostCategoryTagAndMeta (postWithoutText rdr)
-                return Some post
-            else
-                return None
-        }
+    let findSurroundingPosts webLogId (publishedOn : Instant) = backgroundTask {
+        log.LogTrace "Post.findSurroundingPosts"
+        let! older =
+            conn.customSingle
+                $"{publishedPostByWebLog} AND {publishField} < @publishedOn ORDER BY {publishField} DESC LIMIT 1"
+                [ webLogParam webLogId; SqliteParameter("@publishedOn", instantParam publishedOn) ]
+                postWithoutLinks
+        let! newer =
+            conn.customSingle
+                $"{publishedPostByWebLog} AND {publishField} > @publishedOn ORDER BY {publishField} LIMIT 1"
+                [ webLogParam webLogId; SqliteParameter("@publishedOn", instantParam publishedOn) ]
+                postWithoutLinks
         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
-                 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! updatePostEpisode    post
-            do! updatePostMeta       post.id oldPost.metadata        post.metadata
-            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
-        member _.add post = add post
-        member _.countByStatus status webLogId = countByStatus status webLogId
-        member _.delete postId webLogId = delete postId webLogId
-        member _.findByPermalink permalink webLogId = findByPermalink permalink webLogId
-        member _.findCurrentPermalink permalinks webLogId = findCurrentPermalink permalinks webLogId
-        member _.findFullById postId webLogId = findFullById postId webLogId
-        member _.findFullByWebLog webLogId = findFullByWebLog webLogId
-        member _.findPageOfCategorizedPosts webLogId categoryIds pageNbr postsPerPage =
+        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
+        member _.FindByPermalink permalink webLogId = findByPermalink permalink webLogId
+        member _.FindCurrentPermalink permalinks webLogId = findCurrentPermalink permalinks webLogId
+        member _.FindFullById postId webLogId = findFullById postId webLogId
+        member _.FindFullByWebLog webLogId = findFullByWebLog webLogId
+        member _.FindPageOfCategorizedPosts webLogId categoryIds pageNbr postsPerPage =
             findPageOfCategorizedPosts webLogId categoryIds pageNbr postsPerPage
-        member _.findPageOfPosts webLogId pageNbr postsPerPage = findPageOfPosts webLogId pageNbr postsPerPage
-        member _.findPageOfPublishedPosts webLogId pageNbr postsPerPage =
+        member _.FindPageOfPosts webLogId pageNbr postsPerPage = findPageOfPosts webLogId pageNbr postsPerPage
+        member _.FindPageOfPublishedPosts webLogId pageNbr postsPerPage =
             findPageOfPublishedPosts webLogId pageNbr postsPerPage
-        member _.findPageOfTaggedPosts webLogId tag pageNbr postsPerPage =
+        member _.FindPageOfTaggedPosts webLogId tag pageNbr postsPerPage =
             findPageOfTaggedPosts webLogId tag pageNbr postsPerPage
-        member _.findSurroundingPosts webLogId publishedOn = findSurroundingPosts webLogId publishedOn
-        member _.restore posts = restore posts
-        member _.update post = update post
-        member _.updatePriorPermalinks postId webLogId permalinks = updatePriorPermalinks postId webLogId permalinks
+        member _.FindSurroundingPosts webLogId publishedOn = findSurroundingPosts webLogId publishedOn
+        member _.Restore posts = restore posts
+        member _.Update post = update post
+        member _.UpdatePriorPermalinks postId webLogId permalinks = updatePriorPermalinks postId webLogId permalinks

src/MyWebLog.Data/SQLite/SQLiteTagMapData.fs

@@ -1,108 +1,69 @@
 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 webLogId =
+        log.LogTrace "TagMap.findById"
+        Document.findByIdAndWebLog<TagMapId, TagMap> Table.TagMap tagMapId webLogId conn
     
     /// 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"
+        let urlParam = Field.EQ (nameof TagMap.Empty.UrlValue) urlValue
+        conn.customSingle
+            $"""{Document.Query.selectByWebLog Table.TagMap} AND {Query.whereByField urlParam "@urlValue"}"""
+            (addFieldParam "@urlValue" urlParam [ webLogParam webLogId ])
+            fromData<TagMap>
     
     /// 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"
+        Document.findByWebLog<TagMap> Table.TagMap webLogId conn
     
     /// 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 ()
-        cmd.CommandText <- """
-            SELECT *
-              FROM tag_map
-             WHERE web_log_id = @webLogId
-               AND tag IN ("""
-        tags
-        |> List.iteri (fun idx tag ->
-            if idx > 0 then cmd.CommandText <- $"{cmd.CommandText}, "
-            cmd.CommandText <- $"{cmd.CommandText}@tag{idx}"
-            cmd.Parameters.AddWithValue ($"@tag{idx}", tag) |> ignore)
-        cmd.CommandText <- $"{cmd.CommandText})"
-        addWebLogId cmd webLogId
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList Map.toTagMap rdr
-    }
+    let findMappingForTags (tags: string list) webLogId =
+        log.LogTrace "TagMap.findMappingForTags"
+        let mapSql, mapParams = inClause $"AND data ->> '{nameof TagMap.Empty.Tag}'" "tag" id tags
+        conn.customList
+            $"{Document.Query.selectByWebLog Table.TagMap} {mapSql}"
+            (webLogParam webLogId :: mapParams)
+            fromData<TagMap>
     
     /// 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
-        member _.delete tagMapId webLogId = delete tagMapId webLogId
-        member _.findById tagMapId webLogId = findById tagMapId webLogId
-        member _.findByUrlValue urlValue webLogId = findByUrlValue urlValue webLogId
-        member _.findByWebLog webLogId = findByWebLog webLogId
-        member _.findMappingForTags tags webLogId = findMappingForTags tags webLogId
-        member _.save tagMap = save tagMap
-        member this.restore tagMaps = restore tagMaps
+        member _.Delete tagMapId webLogId = delete tagMapId webLogId
+        member _.FindById tagMapId webLogId = findById tagMapId webLogId
+        member _.FindByUrlValue urlValue webLogId = findByUrlValue urlValue webLogId
+        member _.FindByWebLog webLogId = findByWebLog webLogId
+        member _.FindMappingForTags tags webLogId = findMappingForTags tags webLogId
+        member _.Save tagMap = save tagMap
+        member _.Restore tagMaps = restore tagMaps

src/MyWebLog.Data/SQLite/SQLiteThemeData.fs

@@ -1,207 +1,149 @@
 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) =
     
-    /// Retrieve all themes (except 'admin'; excludes templates)
-    let all () = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM theme WHERE id <> 'admin' ORDER BY id"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList Map.toTheme rdr
-    }
+    /// The JSON field for the theme ID
+    let idField = $"data ->> '{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 () =
+        log.LogTrace "Theme.all"
+        conn.customList
+            $"{Query.selectFromTable Table.Theme} WHERE {idField} <> 'admin' ORDER BY {idField}"
+            []
+            withoutTemplateText
+    
+    /// Does a given theme exist?
+    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 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.Find.byId Table.Theme) [ idParam themeId ] withoutTemplateText
+    
+    /// Delete a theme by its ID
+    let delete themeId = backgroundTask {
+        log.LogTrace "Theme.delete"
+        match! findByIdWithoutText themeId with
+        | Some _ ->
+            do! conn.customNonQuery
+                    $"DELETE FROM {Table.ThemeAsset} WHERE theme_id = @id; {Query.Delete.byId Table.Theme}"
+                    [ 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 =
-            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 _.findById themeId = findById themeId
-        member _.findByIdWithoutText themeId = findByIdWithoutText themeId
-        member _.save theme = save theme
+        member _.All() = all ()
+        member _.Delete themeId = delete themeId
+        member _.Exists themeId = exists themeId
+        member _.FindById themeId = findById themeId
+        member _.FindByIdWithoutText themeId = findByIdWithoutText themeId
+        member _.Save theme = save theme
 
 
 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 $"DELETE FROM {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
+    let save (asset: ThemeAsset) = backgroundTask {
+        log.LogTrace "ThemeAsset.save"
+        do! conn.customNonQuery
+                $"INSERT INTO {Table.ThemeAsset} (
+                    theme_id, path, updated_on, data
+                  ) 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) ]
         
-        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 (
-                       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", asset.updatedOn)
-          cmd.Parameters.AddWithValue ("@dataLength", asset.data.Length)
-        ] |> ignore
-        do! write cmd
-        
-        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 _.deleteByTheme themeId = deleteByTheme themeId
-        member _.findById assetId = findById assetId
-        member _.findByTheme themeId = findByTheme themeId
-        member _.findByThemeWithData themeId = findByThemeWithData themeId
-        member _.save asset = save asset
+        member _.All() = all ()
+        member _.DeleteByTheme themeId = deleteByTheme themeId
+        member _.FindById assetId = findById assetId
+        member _.FindByTheme themeId = findByTheme themeId
+        member _.FindByThemeWithData themeId = findByThemeWithData themeId
+        member _.Save asset = save asset

src/MyWebLog.Data/SQLite/SQLiteUploadData.fs

@@ -1,101 +1,86 @@
 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", 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
     }
     
     interface IUploadData with
-        member _.add upload = add upload
-        member _.delete uploadId webLogId = delete uploadId webLogId
-        member _.findByPath path webLogId = findByPath path webLogId
-        member _.findByWebLog webLogId = findByWebLog webLogId
-        member _.findByWebLogWithData webLogId = findByWebLogWithData webLogId
-        member _.restore uploads = restore uploads
+        member _.Add upload = add upload
+        member _.Delete uploadId webLogId = delete uploadId webLogId
+        member _.FindByPath path webLogId = findByPath path webLogId
+        member _.FindByWebLog webLogId = findByWebLog webLogId
+        member _.FindByWebLogWithData webLogId = findByWebLogWithData webLogId
+        member _.Restore uploads = restore uploads
         

src/MyWebLog.Data/SQLite/SQLiteWebLogData.fs

@@ -1,334 +1,74 @@
 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
 
-// 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) =
-    
-    // SUPPORT FUNCTIONS
-    
-    /// Add parameters for web log INSERT or web log/RSS options UPDATE statements
-    let addWebLogRssParameters (cmd : SqliteCommand) (webLog : WebLog) =
-        [ cmd.Parameters.AddWithValue ("@feedEnabled", webLog.rss.feedEnabled)
-          cmd.Parameters.AddWithValue ("@feedName", webLog.rss.feedName)
-          cmd.Parameters.AddWithValue ("@itemsInFeed", maybe webLog.rss.itemsInFeed)
-          cmd.Parameters.AddWithValue ("@categoryEnabled", webLog.rss.categoryEnabled)
-          cmd.Parameters.AddWithValue ("@tagEnabled", webLog.rss.tagEnabled)
-          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", webLog.themePath)
-          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)
-        ] |> ignore
-    
-    /// Add parameters for podcast INSERT or UPDATE statements
-    let addPodcastParameters (cmd : SqliteCommand) feedId (podcast : PodcastOptions) =
-        [ cmd.Parameters.AddWithValue ("@feedId", CustomFeedId.toString feedId)
-          cmd.Parameters.AddWithValue ("@title", podcast.title)
-          cmd.Parameters.AddWithValue ("@subtitle", maybe podcast.subtitle)
-          cmd.Parameters.AddWithValue ("@itemsInFeed", podcast.itemsInFeed)
-          cmd.Parameters.AddWithValue ("@summary", podcast.summary)
-          cmd.Parameters.AddWithValue ("@displayedAuthor", podcast.displayedAuthor)
-          cmd.Parameters.AddWithValue ("@email", podcast.email)
-          cmd.Parameters.AddWithValue ("@imageUrl", Permalink.toString podcast.imageUrl)
-          cmd.Parameters.AddWithValue ("@iTunesCategory", podcast.iTunesCategory)
-          cmd.Parameters.AddWithValue ("@iTunesSubcategory", maybe podcast.iTunesSubcategory)
-          cmd.Parameters.AddWithValue ("@explicit", ExplicitRating.toString podcast.explicit)
-          cmd.Parameters.AddWithValue ("@defaultMediaType", maybe podcast.defaultMediaType)
-          cmd.Parameters.AddWithValue ("@mediaBaseUrl", maybe podcast.mediaBaseUrl)
-          cmd.Parameters.AddWithValue ("@guid", maybe podcast.guid)
-          cmd.Parameters.AddWithValue ("@fundingUrl", maybe podcast.fundingUrl)
-          cmd.Parameters.AddWithValue ("@fundingText", maybe podcast.fundingText)
-          cmd.Parameters.AddWithValue ("@medium", maybe (podcast.medium |> Option.map PodcastMedium.toString))
-        ] |> ignore
-
-    /// Get the current custom feeds for a web log
-    let getCustomFeeds (webLog : WebLog) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- """
-            SELECT f.*, p.*
-              FROM web_log_feed f
-                   LEFT JOIN web_log_feed_podcast p ON p.feed_id = f.id
-             WHERE f.web_log_id = @webLogId"""
-        addWebLogId cmd webLog.id
-        use! rdr = cmd.ExecuteReaderAsync ()
-        return toList Map.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 } }
-    }
-    
-    /// Add a podcast to a custom feed
-    let addPodcast feedId (podcast : PodcastOptions) = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- """
-            INSERT INTO web_log_feed_podcast (
-                feed_id, title, subtitle, items_in_feed, summary, displayed_author, email, image_url,
-                itunes_category, itunes_subcategory, explicit, default_media_type, media_base_url, guid, funding_url,
-                funding_text, medium
-            ) VALUES (
-                @feedId, @title, @subtitle, @itemsInFeed, @summary, @displayedAuthor, @email, @imageUrl,
-                @iTunesCategory, @iTunesSubcategory, @explicit, @defaultMediaType, @mediaBaseUrl, @guid, @fundingUrl,
-                @fundingText, @medium
-            )"""
-        addPodcastParameters cmd feedId podcast
-        do! write cmd
-    }
-    
-    /// Update the custom feeds for a web log
-    let updateCustomFeeds (webLog : WebLog) = backgroundTask {
-        let! feeds = getCustomFeeds webLog
-        let toDelete, toAdd = 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 ->
-                not (toDelete |> List.map toId |> List.append (toAdd |> List.map toId) |> List.contains f.id))
-        use cmd = conn.CreateCommand ()
-        cmd.Parameters.Add ("@id", SqliteType.Text) |> ignore
-        toDelete
-        |> List.map (fun it -> backgroundTask {
-            cmd.CommandText <- """
-                DELETE FROM web_log_feed_podcast WHERE feed_id = @id;
-                DELETE FROM web_log_feed         WHERE id      = @id"""
-            cmd.Parameters["@id"].Value <- CustomFeedId.toString it.id
-            do! write cmd
-        })
-        |> Task.WhenAll
-        |> ignore
-        cmd.Parameters.Clear ()
-        toAdd
-        |> List.map (fun it -> backgroundTask {
-            cmd.CommandText <- """
-                INSERT INTO web_log_feed (
-                    id, web_log_id, source, path
-                ) VALUES (
-                    @id, @webLogId, @source, @path
-                )"""
-            cmd.Parameters.Clear ()
-            addCustomFeedParameters cmd webLog.id it
-            do! write cmd
-            match it.podcast with
-            | Some podcast -> do! addPodcast it.id podcast
-            | None -> ()
-        })
-        |> Task.WhenAll
-        |> ignore
-        toUpdate
-        |> List.map (fun it -> backgroundTask {
-            cmd.CommandText <- """
-                UPDATE web_log_feed
-                   SET source = @source,
-                       path   = @path
-                 WHERE id         = @id
-                   AND web_log_id = @webLogId"""
-            cmd.Parameters.Clear ()
-            addCustomFeedParameters cmd webLog.id it
-            do! write cmd
-            let hadPodcast = Option.isSome (feeds |> List.find (fun f -> f.id = it.id)).podcast
-            match it.podcast with
-            | Some podcast ->
-                if hadPodcast then
-                    cmd.CommandText <- """
-                        UPDATE web_log_feed_podcast
-                           SET title              = @title,
-                               subtitle           = @subtitle,
-                               items_in_feed      = @itemsInFeed,
-                               summary            = @summary,
-                               displayed_author   = @displayedAuthor,
-                               email              = @email,
-                               image_url          = @imageUrl,
-                               itunes_category    = @iTunesCategory,
-                               itunes_subcategory = @iTunesSubcategory,
-                               explicit           = @explicit,
-                               default_media_type = @defaultMediaType,
-                               media_base_url     = @mediaBaseUrl,
-                               guid               = @guid,
-                               funding_url        = @fundingUrl,
-                               funding_text       = @fundingText,
-                               medium             = @medium
-                         WHERE feed_id = @feedId"""
-                    cmd.Parameters.Clear ()
-                    addPodcastParameters cmd it.id podcast
-                    do! write cmd
-                else
-                    do! addPodcast it.id podcast
-            | None ->
-                if hadPodcast then
-                    cmd.CommandText <- "DELETE FROM web_log_feed_podcast WHERE feed_id = @id"
-                    cmd.Parameters.Clear ()
-                    cmd.Parameters.AddWithValue ("@id", CustomFeedId.toString it.id) |> ignore
-                    do! write cmd
-                else
-                    ()
-        })
-        |> Task.WhenAll
-        |> ignore
-    }
-    
-    // IMPLEMENTATION FUNCTIONS
+/// SQLite myWebLog web log data implementation
+type SQLiteWebLogData(conn: SqliteConnection, log: ILogger) =
     
     /// Add a web log
-    let add webLog = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- """
-            INSERT INTO web_log (
-                id, name, slug, subtitle, default_page, posts_per_page, theme_id, url_base, time_zone, auto_htmx,
-                uploads, feed_enabled, feed_name, items_in_feed, category_enabled, tag_enabled, copyright
-            ) VALUES (
-                @id, @name, @slug, @subtitle, @defaultPage, @postsPerPage, @themeId, @urlBase, @timeZone, @autoHtmx,
-                @uploads, @feedEnabled, @feedName, @itemsInFeed, @categoryEnabled, @tagEnabled, @copyright
-            )"""
-        addWebLogParameters cmd webLog
-        do! write cmd
-        do! updateCustomFeeds webLog
-    }
+    let add webLog =
+        log.LogTrace "WebLog.add"
+        conn.insert<WebLog> Table.WebLog webLog
     
     /// Retrieve all web logs
-    let all () = backgroundTask {
-        use cmd = conn.CreateCommand ()
-        cmd.CommandText <- "SELECT * FROM web_log"
-        use! rdr = cmd.ExecuteReaderAsync ()
-        let! webLogs =
-            toList Map.toWebLog rdr
-            |> List.map (fun webLog -> backgroundTask { return! appendCustomFeeds webLog })
-            |> Task.WhenAll
-        return List.ofArray webLogs