feat: add SQLite WAL auto-checkpoint configuration

* S3-compatible blob storage support

PDSharp.Core/Config.fs

···
     JwtSecret : string
     /// Connection string for SQLite
     SqliteConnectionString : string
+    /// Disable SQLite WAL auto-checkpoint (for Litestream compatibility)
+    DisableWalAutoCheckpoint : bool
     /// Blob storage configuration
     BlobStore : BlobStoreConfig
   }

PDSharp.Core/SqliteStore.fs

···
 module SqliteStore =
 
   /// Initialize the database schema
-  let initialize (connectionString : string) =
-    use conn = new SqliteConnection(connectionString)
-    conn.Open()
+  let initialize (config : AppConfig) =
+    use conn = new SqliteConnection(config.SqliteConnectionString)
 
+    conn.Open()
     conn.Execute("PRAGMA journal_mode=WAL;") |> ignore
+
+    if config.DisableWalAutoCheckpoint then
+      conn.Execute("PRAGMA wal_autocheckpoint=0;") |> ignore
+
     // TODO: fast, slightly less safe. Keep default (FULL) for now.
     // conn.Execute("PRAGMA synchronous=NORMAL;") |> ignore
 

PDSharp.Tests/Handlers.Tests.fs

···
     member _.Deserialize<'T>(json : string) = JsonSerializer.Deserialize<'T> json
 
     member _.Deserialize<'T>(bytes : byte[]) =
-      JsonSerializer.Deserialize<'T>(ReadOnlySpan(bytes))
+      JsonSerializer.Deserialize<'T>(ReadOnlySpan bytes)
 
     member _.DeserializeAsync<'T>(stream : Stream) = task { return! JsonSerializer.DeserializeAsync<'T>(stream) }
 
···
     DidHost = "did:web:pds.example.com"
     JwtSecret = "secret"
     SqliteConnectionString = ""
+    DisableWalAutoCheckpoint = false
     BlobStore = Disk "blobs"
   }
 
···
   let body = JsonSerializer.Serialize req
   let ctx = mockContext services body Map.empty
   let next : HttpFunc = fun _ -> Task.FromResult(None)
-
   let! result = PDSharp.Handlers.Auth.createAccountHandler next ctx
-
   Assert.Equal(200, ctx.Response.StatusCode)
 
   let store = accountStore :> IAccountStore
···
 let ``Server.indexHandler returns HTML`` () = task {
   let ctx = new DefaultHttpContext()
   let next : HttpFunc = fun _ -> Task.FromResult(None)
-
   let! result = PDSharp.Handlers.Server.indexHandler next ctx
-
   Assert.Equal(200, ctx.Response.StatusCode)
   Assert.Equal("text/html", ctx.Response.ContentType)
 }
···
   }
 
   let body = JsonSerializer.Serialize(req)
-
   let ctx = mockContext services body Map.empty
   let next : HttpFunc = fun _ -> Task.FromResult(None)
-
   let! result = PDSharp.Handlers.Repo.createRecordHandler next ctx
-
   Assert.Equal(400, ctx.Response.StatusCode)
 }

PDSharp.Tests/Tests.fs

···
     DidHost = "did:web:example.com"
     JwtSecret = "test-secret-key-for-testing-only"
     SqliteConnectionString = "Data Source=:memory:"
+    DisableWalAutoCheckpoint = false
     BlobStore = Disk "blobs"
   }
 
···
   let keyPair = generateKey P256
   let data = Encoding.UTF8.GetBytes("test message")
   let hash = sha256 data
-
   let signature = sign keyPair hash
   Assert.True(signature.Length = 64, "Signature should be 64 bytes (R|S)")
 
···
   let keyPair = generateKey K256
   let data = Encoding.UTF8.GetBytes("test k256")
   let hash = sha256 data
-
   let signature = sign keyPair hash
   Assert.True(signature.Length = 64, "Signature should be 64 bytes")
 
···
 [<Fact>]
 let ``CID Generation from Hash`` () =
   let hash =
-    Hex.Decode("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9")
+    Hex.Decode "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
 
   let cid = Cid.FromHash hash
   Assert.Equal<byte>(0x01uy, cid.Bytes.[0])
···
 
 [<Fact>]
 let ``DAG-CBOR Canonical Sorting`` () =
-  let m = Map.ofList [ ("b", box 1); ("a", box 2) ]
+  let m = Map.ofList [ "b", box 1; "a", box 2 ]
   let encoded = DagCbor.encode m
   let hex = Hex.ToHexString encoded
   Assert.Equal("a2616102616201", hex)
 
 [<Fact>]
 let ``DAG-CBOR Sorting Length vs Bytes`` () =
-  let m = Map.ofList [ ("aa", box 1); ("b", box 2) ]
+  let m = Map.ofList [ "aa", box 1; "b", box 2 ]
   let encoded = DagCbor.encode m
   let hex = Hex.ToHexString encoded
   Assert.Equal("a261620262616101", hex)

PDSharp/Program.fs

···
   let publicUrl = env "PDSHARP_PublicUrl" "http://localhost:5000"
   let dbPath = env "PDSHARP_DbPath" "pdsharp.db"
 
+  let disableWalAutoCheckpoint =
+    env "PDSHARP_SQLITE_DISABLE_WAL_AUTO_CHECKPOINT" "false" |> bool.Parse
+
+  let blobStoreConfig =
+    match env "PDSHARP_BLOBSTORE_TYPE" "disk" with
+    | "s3" ->
+      S3 {
+        Bucket = env "PDSHARP_S3_BUCKET" "pdsharp-blobs"
+        Region = env "PDSHARP_S3_REGION" "us-east-1"
+        AccessKey = Option.ofObj (Environment.GetEnvironmentVariable "PDSHARP_S3_ACCESS_KEY")
+        SecretKey = Option.ofObj (Environment.GetEnvironmentVariable "PDSHARP_S3_SECRET_KEY")
+        ServiceUrl = Option.ofObj (Environment.GetEnvironmentVariable "PDSHARP_S3_SERVICE_URL")
+        ForcePathStyle = env "PDSHARP_S3_FORCE_PATH_STYLE" "false" |> bool.Parse
+      }
+    | _ -> Disk "blobs"
+
   {
     PublicUrl = publicUrl
     DidHost = env "PDSHARP_DidHost" "did:web:localhost"
     JwtSecret = env "PDSHARP_JwtSecret" "development-secret-do-not-use-in-prod"
     SqliteConnectionString = $"Data Source={dbPath}"
-    BlobStore = Disk "blobs" // Default to disk for now
+    DisableWalAutoCheckpoint = disableWalAutoCheckpoint
+    BlobStore = blobStoreConfig
   }
 
 let config = getConfig ()
 
-SqliteStore.initialize config.SqliteConnectionString
+SqliteStore.initialize config
 
 module App =
-  let webApp =
+  let appRouter =
     choose [
       GET
       >=> choose [
···
       RequestErrors.NOT_FOUND "Not Found"
     ]
 
-  let configureApp (app : IApplicationBuilder) =
+  let webApp (app : IApplicationBuilder) =
     app.UseWebSockets() |> ignore
-    app.UseGiraffe webApp
+    app.UseGiraffe appRouter
 
   let configureServices (config : AppConfig) (services : IServiceCollection) =
     services.AddGiraffe() |> ignore
···
     let accountStore = new SqliteAccountStore(config.SqliteConnectionString)
     let repoStore = new SqliteRepoStore(config.SqliteConnectionString)
 
-    services.AddSingleton<IBlockStore>(blockStore) |> ignore
-    services.AddSingleton<IAccountStore>(accountStore) |> ignore
-    services.AddSingleton<IRepoStore>(repoStore) |> ignore
+    services.AddSingleton<IBlockStore> blockStore |> ignore
+    services.AddSingleton<IAccountStore> accountStore |> ignore
+    services.AddSingleton<IRepoStore> repoStore |> ignore
 
     let blobStore : IBlobStore =
       match config.BlobStore with
       | Disk path -> new DiskBlobStore(path) :> IBlobStore
       | S3 s3Config -> new S3BlobStore(s3Config) :> IBlobStore
 
-    services.AddSingleton<IBlobStore>(blobStore) |> ignore
+    services.AddSingleton<IBlobStore> blobStore |> ignore
     services.AddSingleton<FirehoseState>(new FirehoseState()) |> ignore
     services.AddSingleton<SigningKeyStore>(new SigningKeyStore()) |> ignore
 
···
     Host
       .CreateDefaultBuilder(args)
       .ConfigureWebHostDefaults(fun webHostBuilder ->
-        webHostBuilder.Configure(configureApp).ConfigureServices(configureServices config)
+        webHostBuilder.Configure(webApp).ConfigureServices(configureServices config)
         |> ignore)
       .Build()
       .Run()

roadmap.txt

···
 --------------------------------------------------------------------------------
 Milestone J: Storage Backend Configuration
 --------------------------------------------------------------------------------
-- [ ] Configure SQLite WAL mode (PDS_SQLITE_DISABLE_WAL_AUTO_CHECKPOINT=true)
-- [ ] Implement S3-compatible blobstore adapter (optional via config)
-- [ ] Configure disk-based vs S3-based blob storage selection
+- [x] Configure SQLite WAL mode (PDS_SQLITE_DISABLE_WAL_AUTO_CHECKPOINT=true)
+- [x] Implement S3-compatible blobstore adapter (optional via config)
+- [x] Configure disk-based vs S3-based blob storage selection
 DoD: PDS runs with S3 blobs (if configured) and SQLite passes Litestream checks
 --------------------------------------------------------------------------------
 Milestone K: Backup Automation + Guardrails