sqlite: add per-entity public modules (BioProject, Study, BioSample, Experiment, Run)

Each module exposes insert / tryGet / delete / listAccessions and
deconstructs the full F# record into its row family in one transaction.

- BioProject: Collaborators + RelatedProjects (PARENT/CHILD/PEER DU) +
  FirstPublic date.
- Study: takes the parent bioProjectAccession explicitly (the F# type
  doesn't carry it); rebuilds StudyDescriptor with its existing-type
  enum, nullable ProjectId, and RelatedStudies XRef + IsPrimary.
- BioSample: handles the biosample_name child table.
- Experiment: serializes StudyRef + Library.SampleDescriptor via the
  shared References helper; library strategy/source/selection enums,
  paired-end nominal length/sdev, targeted loci, spot descriptor.
- Run: ExperimentRef, RunDate (ISO-8601), RunCenter, DataBlock.MemberName,
  spot descriptor (Files deferred per plan section D4).

Extracts the Platform DU dispatch into a new Internal/Platforms.fs so
Experiment and Run share one ~170-line helper instead of duplicating it.

Expands the schema's experiment_platform / run_platform CHECK constraint
from 11 to all 18 Platform DU cases — the generated F# Platform type has
18, the original constraint would have rejected 7 (ION_TORRENT, ELEMENT,
ULTIMA, VELA_DIAGNOSTICS, GENAPSYS, GENEMIND, TAPESTRI).

Verified via fsi: every entity round-trips with all populated collections,
FK enforcement raises on a bogus parent, cascade delete honors the
schema's ON DELETE SET NULL on study.bioproject_accession.

Author: kMutagene

plans/sqlite-store.md

@@ -343,14 +343,20 @@ O(entity_count) queries per reconstruction; with FK indexes this stays cheap.
 
 **Result:** Clean build, zero warnings. Smoke test through `dotnet fsi`: schema loads (42 tables), all 5 identifier kinds round-trip (PRIMARY/SECONDARY/EXTERNAL/SUBMITTER/UUID) with label/namespace preserved, attributes round-trip with NULL value/units preserved, all 3 Link DU cases (URL/XREF/ENTREZ with nullable int64 Id) round-trip cleanly.
 
-### Chunk 4 — Per-entity public modules
-
-- [ ] `Schema.fs` — public `Schema.init : SqliteConnection -> unit`
-- [ ] `BioProject.fs` — `insert`, `tryGet`, `delete`, `listAccessions`
-- [ ] `Study.fs` — same surface; handles `study_descriptor` denormalization
-- [ ] `BioSample.fs` — same surface; handles `biosample_name`
-- [ ] `Experiment.fs` — same surface; uses `References` for `StudyRef` and `Library.SampleDescriptor`; serializes `Platform` DU into `experiment_platform` + `_params`
-- [ ] `Run.fs` — same surface; uses `References` for `ExperimentRef`; serializes optional `Platform` DU
+### Chunk 4 — Per-entity public modules ✅
+
+- [x] `Schema.fs` — public `Schema.init : SqliteConnection -> unit`
+- [x] `BioProject.fs` — `insert`, `tryGet`, `delete`, `listAccessions`; covers `Collaborators` and `RelatedProjects` (PARENT/CHILD/PEER DU)
+- [x] `Study.fs` — same surface; reconstructs the full `StudyDescriptor` (existing-type enum, NullableProjectId, RelatedStudies with XRef). Takes parent `bioProjectAccession` (NULL ok) since the F# type doesn't model the parent FK.
+- [x] `BioSample.fs` — same surface; handles `biosample_name`
+- [x] `Experiment.fs` — same surface; uses `References` for `StudyRef` and `Library.SampleDescriptor`; serializes `Platform` DU via the new shared `Internal/Platforms.fs` helper; round-trips library strategy/source/selection enums, paired-end nominal length/sdev, targeted loci, spot descriptor read specs
+- [x] `Run.fs` — same surface; uses `References` for `ExperimentRef`; reuses `Platforms` helper; persists `RunDate` (ISO-8601), `RunCenter`, `DataBlock.MemberName`, spot descriptor
+
+**Extras landed:**
+- Schema's platform `CHECK (kind IN (...))` constraint expanded from 11 to all 18 DU cases (the F# `Platform` type has 18, the original constraint would have rejected 7).
+- `Internal/Platforms.fs` extracted as a sibling to `Identifiers/Attributes/Links/References` — both Experiment and Run share it.
+
+**Result:** fsi round-trip test exercises every entity (and through them every helper). Outputs match inputs for: identifiers (all 5 kinds), attributes, URL/XREF/ENTREZ links, collaborators, related-projects (PARENT case), `FirstPublic` date, `StudyDescriptor` with enum + nullable long + RelatedStudies, library strategy/source/selection enums, paired layout, Platform `ILLUMINA → IlluminaNovaSeq6000`, `RunDate` timestamp, ExperimentRef. FK enforcement verified (bogus parent rejected). `listAccessions` works for all five entities. Cascade delete behaves correctly with `bioproject → study` being `ON DELETE SET NULL` (so dropping a BioProject leaves orphan studies, by design).
 
 ### Chunk 5 — Tests
 

src/BioFSharp.INSDC.SQLite/BioFSharp.INSDC.SQLite.fsproj

@@ -14,6 +14,13 @@
     <Compile Include="Internal\Attributes.fs" />
     <Compile Include="Internal\Links.fs" />
     <Compile Include="Internal\References.fs" />
+    <Compile Include="Internal\Platforms.fs" />
+    <Compile Include="Schema.fs" />
+    <Compile Include="BioProject.fs" />
+    <Compile Include="Study.fs" />
+    <Compile Include="BioSample.fs" />
+    <Compile Include="Experiment.fs" />
+    <Compile Include="Run.fs" />
     <EmbeddedResource Include="schema\insdc_schema.sql" />
     <None Include="..\..\docs\img\icon.png" Pack="true" PackagePath="" />
     <None Include="..\..\README.md" Pack="true" PackagePath="" />

src/BioFSharp.INSDC.SQLite/BioProject.fs

@@ -0,0 +1,178 @@
+namespace BioFSharp.INSDC.SQLite
+
+open System
+open Microsoft.Data.Sqlite
+open BioFSharp.FileFormats.INSDC
+open BioFSharp.INSDC.SQLite.Internal
+
+/// SQLite persistence for `BioProject`. Each public function maps a single
+/// in-memory record to the full set of rows it spans (core row + identifiers
+/// + attributes + links + collaborators + related-projects).
+module BioProject =
+
+    [<Literal>]
+    let private accessionColumn = "bioproject_accession"
+
+    let private identifierOwner accession : IdentifierOwner =
+        { Table = "bioproject_identifiers"; AccessionColumn = accessionColumn; Accession = accession }
+
+    let private attributeOwner accession : AttributeOwner =
+        { Table = "bioproject_attributes"; AccessionColumn = accessionColumn; Accession = accession }
+
+    let private linkOwner accession : LinkOwner =
+        { Table = "bioproject_links"; AccessionColumn = accessionColumn; Accession = accession }
+
+    let private formatDate (date: Nullable<DateTime>) : obj =
+        if date.HasValue then box (date.Value.ToString("yyyy-MM-dd")) else null
+
+    let private parseDate (text: string) : Nullable<DateTime> =
+        if isNull text then Nullable() else Nullable(DateTime.Parse(text))
+
+    let private insertCore (connection: SqliteConnection) (project: BioProject) : unit =
+        Sql.execNonQuery
+            connection
+            "INSERT INTO bioproject (accession, alias, center_name, broker_name, name, title, description, first_public) \
+             VALUES (@acc, @alias, @cn, @bn, @name, @title, @desc, @fp);"
+            [
+                "@acc", box project.Accession
+                "@alias", box project.Alias
+                "@cn", box project.CenterName
+                "@bn", box project.BrokerName
+                "@name", box project.Name
+                "@title", box project.Title
+                "@desc", box project.Description
+                "@fp", formatDate project.FirstPublic
+            ]
+        |> ignore
+
+    let private insertCollaborators (connection: SqliteConnection) (project: BioProject) : unit =
+        if isNull project.Collaborators then () else
+        project.Collaborators
+        |> Seq.iteri (fun i name ->
+            Sql.execNonQuery
+                connection
+                "INSERT INTO bioproject_collaborators (bioproject_accession, ordinal, name) VALUES (@acc, @ordinal, @name);"
+                [
+                    "@acc", box project.Accession
+                    "@ordinal", box i
+                    "@name", box name
+                ]
+            |> ignore)
+
+    let private insertRelatedProjects (connection: SqliteConnection) (project: BioProject) : unit =
+        if isNull project.RelatedProjects then () else
+        project.RelatedProjects
+        |> Seq.iteri (fun i related ->
+            let kind, target =
+                if not (isNull related.ParentProject) then "PARENT", related.ParentProject.Accession
+                elif not (isNull related.ChildProject) then "CHILD", related.ChildProject.Accession
+                elif not (isNull related.PeerProject) then "PEER", related.PeerProject.Accession
+                else
+                    failwithf
+                        "BioProject %s related-project at ordinal %d has none of PARENT/CHILD/PEER set"
+                        project.Accession i
+            Sql.execNonQuery
+                connection
+                "INSERT INTO bioproject_related_projects (bioproject_accession, ordinal, kind, related_accession) \
+                 VALUES (@acc, @ordinal, @kind, @target);"
+                [
+                    "@acc", box project.Accession
+                    "@ordinal", box i
+                    "@kind", box kind
+                    "@target", box target
+                ]
+            |> ignore)
+
+    /// Persists `project` and every row it deconstructs into. Wraps all
+    /// inserts in a single transaction so FK or constraint violations leave
+    /// the database untouched.
+    let insert (connection: SqliteConnection) (project: BioProject) : unit =
+        Sql.withTransaction connection (fun _tx ->
+            insertCore connection project
+            Identifiers.write connection (identifierOwner project.Accession) project.Identifiers
+            Attributes.write connection (attributeOwner project.Accession) project.ProjectAttributes
+            Links.write connection (linkOwner project.Accession) project.ProjectLinks
+            insertCollaborators connection project
+            insertRelatedProjects connection project)
+
+    /// Reconstructs a `BioProject` from its accession by joining all owner
+    /// tables. Returns `None` when no core row exists.
+    let tryGet (connection: SqliteConnection) (accession: string) : BioProject option =
+        let core =
+            Sql.tryQueryOne
+                connection
+                "SELECT alias, center_name, broker_name, name, title, description, first_public \
+                 FROM bioproject WHERE accession = @acc;"
+                [ "@acc", box accession ]
+                (fun reader ->
+                    let alias = Sql.readStringOrNull reader 0
+                    let centerName = Sql.readStringOrNull reader 1
+                    let brokerName = Sql.readStringOrNull reader 2
+                    let name = Sql.readStringOrNull reader 3
+                    let title = Sql.readStringOrNull reader 4
+                    let description = Sql.readStringOrNull reader 5
+                    let firstPublic = Sql.readStringOrNull reader 6
+                    alias, centerName, brokerName, name, title, description, firstPublic)
+        match core with
+        | None -> None
+        | Some (alias, centerName, brokerName, name, title, description, firstPublic) ->
+            let project = BioProject()
+            project.Accession <- accession
+            project.Alias <- alias
+            project.CenterName <- centerName
+            project.BrokerName <- brokerName
+            project.Name <- name
+            project.Title <- title
+            project.Description <- description
+            project.FirstPublic <- parseDate firstPublic
+            project.Identifiers <- Identifiers.read connection (identifierOwner accession)
+            for attr in Attributes.read connection (attributeOwner accession) do
+                project.ProjectAttributes.Add(attr)
+            for link in Links.read connection (linkOwner accession) do
+                project.ProjectLinks.Add(link)
+            Sql.queryAll
+                connection
+                "SELECT name FROM bioproject_collaborators WHERE bioproject_accession = @acc ORDER BY ordinal;"
+                [ "@acc", box accession ]
+                (fun reader -> reader.GetString(0))
+            |> List.iter project.Collaborators.Add
+            Sql.queryAll
+                connection
+                "SELECT kind, related_accession FROM bioproject_related_projects \
+                 WHERE bioproject_accession = @acc ORDER BY ordinal;"
+                [ "@acc", box accession ]
+                (fun reader ->
+                    let kind = reader.GetString(0)
+                    let target = reader.GetString(1)
+                    let related = BioProjectRelatedProjectsRelatedProject()
+                    match kind with
+                    | "PARENT" ->
+                        related.ParentProject <- BioProjectRelatedProjectsRelatedProjectParentProject(Accession = target)
+                    | "CHILD" ->
+                        related.ChildProject <- BioProjectRelatedProjectsRelatedProjectChildProject(Accession = target)
+                    | "PEER" ->
+                        related.PeerProject <- BioProjectRelatedProjectsRelatedProjectPeerProject(Accession = target)
+                    | other ->
+                        failwithf "Unexpected related-project kind '%s' for bioproject '%s'" other accession
+                    related)
+            |> List.iter project.RelatedProjects.Add
+            Some project
+
+    /// Removes the row from `bioproject`; every owned table's rows are deleted
+    /// via the schema's ON DELETE CASCADE.
+    let delete (connection: SqliteConnection) (accession: string) : unit =
+        Sql.execNonQuery
+            connection
+            "DELETE FROM bioproject WHERE accession = @acc;"
+            [ "@acc", box accession ]
+        |> ignore
+
+    /// Lists every BioProject accession currently stored, in lexicographic
+    /// order. Suitable for crawler resume / dedup bookkeeping.
+    let listAccessions (connection: SqliteConnection) : string seq =
+        Sql.queryAll
+            connection
+            "SELECT accession FROM bioproject ORDER BY accession;"
+            []
+            (fun reader -> reader.GetString(0))
+        :> string seq

src/BioFSharp.INSDC.SQLite/BioSample.fs

@@ -0,0 +1,127 @@
+namespace BioFSharp.INSDC.SQLite
+
+open Microsoft.Data.Sqlite
+open BioFSharp.FileFormats.INSDC
+open BioFSharp.INSDC.SQLite.Internal
+
+/// SQLite persistence for `BioSample`. The taxonomic identity sits in its own
+/// child table (`biosample_name`); everything else follows the standard
+/// identifiers/attributes/links pattern.
+module BioSample =
+
+    [<Literal>]
+    let private accessionColumn = "biosample_accession"
+
+    let private identifierOwner accession : IdentifierOwner =
+        { Table = "biosample_identifiers"; AccessionColumn = accessionColumn; Accession = accession }
+
+    let private attributeOwner accession : AttributeOwner =
+        { Table = "biosample_attributes"; AccessionColumn = accessionColumn; Accession = accession }
+
+    let private linkOwner accession : LinkOwner =
+        { Table = "biosample_links"; AccessionColumn = accessionColumn; Accession = accession }
+
+    let private insertCore (connection: SqliteConnection) (sample: BioSample) : unit =
+        Sql.execNonQuery
+            connection
+            "INSERT INTO biosample (accession, alias, center_name, broker_name, title, description) \
+             VALUES (@acc, @alias, @cn, @bn, @title, @desc);"
+            [
+                "@acc", box sample.Accession
+                "@alias", box sample.Alias
+                "@cn", box sample.CenterName
+                "@bn", box sample.BrokerName
+                "@title", box sample.Title
+                "@desc", box sample.Description
+            ]
+        |> ignore
+
+    let private insertSampleName (connection: SqliteConnection) (sample: BioSample) : unit =
+        match sample.SampleName with
+        | null -> ()
+        | name ->
+            Sql.execNonQuery
+                connection
+                "INSERT INTO biosample_name (biosample_accession, taxon_id, scientific_name, common_name, display_name) \
+                 VALUES (@acc, @tid, @sci, @common, @display);"
+                [
+                    "@acc", box sample.Accession
+                    "@tid", box name.TaxonId
+                    "@sci", box name.ScientificName
+                    "@common", box name.CommonName
+                    "@display", box name.DisplayName
+                ]
+            |> ignore
+
+    /// Persists `sample` and every row it deconstructs into.
+    let insert (connection: SqliteConnection) (sample: BioSample) : unit =
+        Sql.withTransaction connection (fun _tx ->
+            insertCore connection sample
+            insertSampleName connection sample
+            Identifiers.write connection (identifierOwner sample.Accession) sample.Identifiers
+            Attributes.write connection (attributeOwner sample.Accession) sample.SampleAttributes
+            Links.write connection (linkOwner sample.Accession) sample.SampleLinks)
+
+    let private readSampleName (connection: SqliteConnection) (accession: string) : BioSampleName =
+        Sql.tryQueryOne
+            connection
+            "SELECT taxon_id, scientific_name, common_name, display_name \
+             FROM biosample_name WHERE biosample_accession = @acc;"
+            [ "@acc", box accession ]
+            (fun reader ->
+                BioSampleName(
+                    TaxonId = reader.GetInt32(0),
+                    ScientificName = Sql.readStringOrNull reader 1,
+                    CommonName = Sql.readStringOrNull reader 2,
+                    DisplayName = Sql.readStringOrNull reader 3))
+        |> Option.defaultValue null
+
+    /// Reconstructs a `BioSample` from its accession by joining every owner
+    /// table. Returns `None` when no core row exists.
+    let tryGet (connection: SqliteConnection) (accession: string) : BioSample option =
+        let core =
+            Sql.tryQueryOne
+                connection
+                "SELECT alias, center_name, broker_name, title, description \
+                 FROM biosample WHERE accession = @acc;"
+                [ "@acc", box accession ]
+                (fun reader ->
+                    Sql.readStringOrNull reader 0,
+                    Sql.readStringOrNull reader 1,
+                    Sql.readStringOrNull reader 2,
+                    Sql.readStringOrNull reader 3,
+                    Sql.readStringOrNull reader 4)
+        match core with
+        | None -> None
+        | Some (alias, centerName, brokerName, title, description) ->
+            let sample = BioSample()
+            sample.Accession <- accession
+            sample.Alias <- alias
+            sample.CenterName <- centerName
+            sample.BrokerName <- brokerName
+            sample.Title <- title
+            sample.Description <- description
+            sample.SampleName <- readSampleName connection accession
+            sample.Identifiers <- Identifiers.read connection (identifierOwner accession)
+            for attr in Attributes.read connection (attributeOwner accession) do
+                sample.SampleAttributes.Add(attr)
+            for link in Links.read connection (linkOwner accession) do
+                sample.SampleLinks.Add(link)
+            Some sample
+
+    /// Removes the row from `biosample`; cascades through every owned table.
+    let delete (connection: SqliteConnection) (accession: string) : unit =
+        Sql.execNonQuery
+            connection
+            "DELETE FROM biosample WHERE accession = @acc;"
+            [ "@acc", box accession ]
+        |> ignore
+
+    /// Lists every BioSample accession in the database, lexicographically.
+    let listAccessions (connection: SqliteConnection) : string seq =
+        Sql.queryAll
+            connection
+            "SELECT accession FROM biosample ORDER BY accession;"
+            []
+            (fun reader -> reader.GetString(0))
+        :> string seq