Add schema record helper

adz · adz · commit b552f86d6a8c · 2026-03-31T18:58:51.000+10:30
diff --git a/README.md b/README.md
@@ -22,8 +22,7 @@ type Person = { Id: int; Name: string }
 let makePerson id name = { Id = id; Name = name }
 
 let personSchema =
-    Schema.define<Person>
-    |> Schema.construct makePerson
+    Schema.record makePerson
     |> Schema.field "id" _.Id
     |> Schema.field "name" _.Name
     |> Schema.build
diff --git a/docs/CONFIG_CONTRACTS.md b/docs/CONFIG_CONTRACTS.md
@@ -83,8 +83,7 @@ let makeAppConfig mode retryCount labels =
     }
 
 let appConfigSchema =
-    Schema.define<AppConfig>
-    |> Schema.construct makeAppConfig
+    Schema.record makeAppConfig
     |> Schema.fieldWith "mode" _.Mode (Schema.string |> Schema.missingAsValue "strict")
     |> Schema.fieldWith "retry_count" _.RetryCount (Schema.int |> Schema.missingAsValue 3)
     |> Schema.fieldWith "labels" _.Labels (Schema.list Schema.string |> Schema.missingAsValue [])
@@ -113,8 +112,7 @@ let makeServiceConfig region labels =
     }
 
 let serviceConfigSchema =
-    Schema.define<ServiceConfig>
-    |> Schema.construct makeServiceConfig
+    Schema.record makeServiceConfig
     |> Schema.fieldWith "region" _.Region (Schema.string |> Schema.nullAsValue "global")
     |> Schema.fieldWith "labels" _.Labels (Schema.list Schema.string |> Schema.emptyCollectionAsValue [ "general" ])
     |> Schema.build
@@ -361,8 +359,7 @@ module Schemas =
         }
 
     let appConfigV2 =
-        Schema.define<AppConfigV2>
-        |> Schema.construct makeAppConfigV2
+        Schema.record makeAppConfigV2
         |> Schema.field "service_url" _.ServiceUrl
         |> Schema.field "retry_count" _.RetryCount
         |> Schema.field "mode" _.Mode
@@ -377,8 +374,7 @@ module Schemas =
         { Version = version; Config = config }
 
     let versionEnvelope inner =
-        Schema.define<VersionEnvelope<'T>>
-        |> Schema.construct makeVersionEnvelope
+        Schema.record makeVersionEnvelope
         |> Schema.field "version" _.Version
         |> Schema.fieldWith "config" _.Config inner
         |> Schema.build
diff --git a/docs/GETTING_STARTED.md b/docs/GETTING_STARTED.md
@@ -18,8 +18,7 @@ type Person = { Id: int; Name: string }
 let makePerson id name = { Id = id; Name = name }
 
 let personSchema =
-    Schema.define<Person>
-    |> Schema.construct makePerson
+    Schema.record makePerson
     |> Schema.field "id" _.Id
     |> Schema.field "name" _.Name
     |> Schema.build
@@ -41,8 +40,7 @@ That is the normal shape of the library:
 
 Read the builder pipeline from top to bottom:
 
-- `Schema.define<Person>` says which value the schema describes
-- `Schema.construct makePerson` says how decode rebuilds the value
+- `Schema.record makePerson` says which value the schema describes and how decode rebuilds it
 - `Schema.field "id" _.Id` maps the wire field `"id"` to the record field `Id`
 - `Schema.build` finishes the schema
 
@@ -62,8 +60,7 @@ If the schema is only being authored inline at the end of a short example, `Json
 
 ```fsharp
 let codec =
-    Schema.define<Person>
-    |> Schema.construct makePerson
+    Schema.record makePerson
     |> Schema.field "id" _.Id
     |> Schema.field "name" _.Name
     |> Json.buildAndCompile
@@ -83,15 +80,13 @@ type Person = { Id: int; Name: string; Home: Address }
 let makePerson id name home = { Id = id; Name = name; Home = home }
 
 let addressSchema =
-    Schema.define<Address>
-    |> Schema.construct makeAddress
+    Schema.record makeAddress
     |> Schema.field "street" _.Street
     |> Schema.field "city" _.City
     |> Schema.build
 
 let personSchema =
-    Schema.define<Person>
-    |> Schema.construct makePerson
+    Schema.record makePerson
     |> Schema.field "id" _.Id
     |> Schema.field "name" _.Name
     |> Schema.fieldWith "home" _.Home addressSchema
diff --git a/docs/HOW_TO_EXPORT_JSON_SCHEMA.md b/docs/HOW_TO_EXPORT_JSON_SCHEMA.md
@@ -18,8 +18,7 @@ type Person = { Id: int; Name: string }
 let makePerson id name = { Id = id; Name = name }
 
 let personSchema =
-    Schema.define<Person>
-    |> Schema.construct makePerson
+    Schema.record makePerson
     |> Schema.fieldInfer "id" _.Id
     |> Schema.fieldInfer "name" _.Name
     |> Schema.build
diff --git a/docs/HOW_TO_MODEL_A_BASIC_RECORD.md b/docs/HOW_TO_MODEL_A_BASIC_RECORD.md
@@ -9,11 +9,10 @@ type Person = { Id: int; Name: string }
 let makePerson id name = { Id = id; Name = name }
 
 let codec =
-    Schema.define<Person>
-    |> Schema.construct makePerson
+    Schema.record makePerson
     |> Schema.field "id" _.Id
     |> Schema.field "name" _.Name
     |> Json.buildAndCompile
 ```
 
-This is the smallest authored schema shape: define the record target, provide the constructor, then map each field explicitly and finish with `Json.buildAndCompile`.
+This is the smallest authored schema shape: start the record with its constructor, then map each field explicitly and finish with `Json.buildAndCompile`.
diff --git a/docs/HOW_TO_MODEL_A_NESTED_RECORD.md b/docs/HOW_TO_MODEL_A_NESTED_RECORD.md
@@ -12,15 +12,13 @@ type Person = { Id: int; Name: string; Home: Address }
 let makePerson id name home = { Id = id; Name = name; Home = home }
 
 let addressSchema =
-    Schema.define<Address>
-    |> Schema.construct makeAddress
+    Schema.record makeAddress
     |> Schema.field "street" _.Street
     |> Schema.field "city" _.City
     |> Schema.build
 
 let personSchema =
-    Schema.define<Person>
-    |> Schema.construct makePerson
+    Schema.record makePerson
     |> Schema.field "id" _.Id
     |> Schema.field "name" _.Name
     |> Schema.fieldWith "home" _.Home addressSchema
diff --git a/docs/HOW_TO_MODEL_A_VALIDATED_WRAPPER.md b/docs/HOW_TO_MODEL_A_VALIDATED_WRAPPER.md
@@ -22,8 +22,7 @@ let userIdSchema =
     |> Schema.tryMap UserId.create UserId.value
 
 let accountSchema =
-    Schema.define<Account>
-    |> Schema.construct makeAccount
+    Schema.record makeAccount
     |> Schema.fieldWith "id" _.Id userIdSchema
     |> Schema.field "name" _.Name
     |> Schema.build
diff --git a/docs/HOW_TO_MODEL_A_VERSIONED_CONTRACT.md b/docs/HOW_TO_MODEL_A_VERSIONED_CONTRACT.md
@@ -15,8 +15,7 @@ let makeSettingsV2 version mode region =
     { Version = version; Mode = mode; Region = region }
 
 let settingsV2Schema =
-    Schema.define<SettingsV2>
-    |> Schema.construct makeSettingsV2
+    Schema.record makeSettingsV2
     |> Schema.fieldWith "version" _.Version (
         Schema.int
         |> Schema.tryMap
diff --git a/docs/HOW_TO_MODEL_COMMON_CONTRACT_PATTERNS.md b/docs/HOW_TO_MODEL_COMMON_CONTRACT_PATTERNS.md
@@ -5,8 +5,7 @@ Use this page as a quick jump list when you know the kind of schema you need and
 All examples stay on the stable authored DSL:
 
 ```fsharp
-Schema.define<'T>
-|> Schema.construct ctor
+Schema.record ctor
 |> Schema.field ...
 |> Schema.build
 ```
diff --git a/docs/INTRODUCTION.md b/docs/INTRODUCTION.md
@@ -16,17 +16,15 @@ That schema is the important idea in the library:
 Most authored schemas follow one stable shape:
 
 ```fsharp
-Schema.define<'T>
-|> Schema.construct ctor
+Schema.record ctor
 |> Schema.field ...
 |> Schema.build
 ```
 
 Read that pipeline from top to bottom:
 
-- `Schema.define<'T>` says which value the schema describes
-- `Schema.construct ctor` says how decode rebuilds the value
-- each `Schema.field` or `Schema.fieldWith` maps one wire field to one domain field
+- `Schema.record ctor` says which value the schema describes and how decode rebuilds it
+- each `Schema.field` maps one wire field to one domain field
 - `Schema.build` finishes the authored schema
 
 Then you compile that schema into a codec for the format boundary you need:
diff --git a/docs/TAGGED_UNION_REFERENCE.md b/docs/TAGGED_UNION_REFERENCE.md
@@ -169,8 +169,7 @@ type Event =
 let makeCreatedData id name = { Id = id; Name = name }
 
 let createdDataSchema =
-    Schema.define<CreatedData>
-    |> Schema.construct makeCreatedData
+    Schema.record makeCreatedData
     |> Schema.field "id" _.Id
     |> Schema.field "name" _.Name
     |> Schema.build
diff --git a/src/CodecMapper/ContractsCore.fs b/src/CodecMapper/ContractsCore.fs
@@ -860,6 +860,11 @@ module Schema =
         Chain = FieldsEnd<'Record, 'Ctor>()
     }
 
+    let ``record``<'Record, 'Ctor>
+        (ctor: 'Ctor)
+        : SchemaBuilder<'Record, 'Ctor, 'Ctor, FieldsEnd<'Record, 'Ctor>> =
+        construct ctor define<'Record>
+
     let fieldWith
         (name: string)
         (getter: 'Record -> 'Field)
@@ -888,7 +893,9 @@ module Schema =
         (builder: SchemaBuilder<'Record, 'Ctor, 'Field -> 'Next, 'Chain>)
         : SchemaBuilder<'Record, 'Ctor, 'Next, FieldsAppend<'Record, 'Ctor, 'Field, 'Next, 'Chain>>
         when 'Chain :> IChainNode<'Record, 'Ctor, 'Field -> 'Next> =
-        field name getter builder
+        match Inference.tryResolve typeof<'Field> with
+        | Some codecObj -> fieldWith name getter (unbox<Codec<'Field>> codecObj) builder
+        | None -> failwithf "Cannot infer codec for field '%s' of type %O" name typeof<'Field>
 
     let build
         (builder: SchemaBuilder<'Record, 'Ctor, 'Record, 'Chain>)
@@ -947,6 +954,7 @@ module Schema =
 
 module Builder =
     let define<'Record> = Schema.define<'Record>
+    let ``record`` ctor = Schema.record ctor
     let construct ctor builder = Schema.construct ctor builder
     let field name getter builder = Schema.field name getter builder
     let fieldWith name getter codec builder = Schema.fieldWith name getter codec builder
diff --git a/tests/CodecMapper.CompatibilitySentinel/Sentinel.fs b/tests/CodecMapper.CompatibilitySentinel/Sentinel.fs
@@ -93,15 +93,13 @@ module Domain =
 
 module Schemas =
     let address =
-        Schema.define<Address>
-        |> Schema.construct makeAddress
+        Schema.record makeAddress
         |> Schema.field "street" _.Street
         |> Schema.field "city" _.City
         |> Schema.build
 
     let person =
-        Schema.define<Person>
-        |> Schema.construct makePerson
+        Schema.record makePerson
         |> Schema.field "id" _.Id
         |> Schema.field "name" _.Name
         |> Schema.fieldWith "home" _.Home address
@@ -110,31 +108,27 @@ module Schemas =
     let personId = Schema.int |> Schema.map PersonId (fun (PersonId id) -> id)
 
     let wrappedPerson =
-        Schema.define<WrappedPerson>
-        |> Schema.construct makeWrappedPerson
+        Schema.record makeWrappedPerson
         |> Schema.fieldWith "id" _.Id personId
         |> Schema.fieldWith "tags" _.Tags (Schema.list Schema.string)
         |> Schema.build
 
     let userId = Schema.int |> Schema.tryMap UserId.create UserId.value
 
     let account =
-        Schema.define<Account>
-        |> Schema.construct makeAccount
+        Schema.record makeAccount
         |> Schema.fieldWith "id" _.Id userId
         |> Schema.field "name" _.Name
         |> Schema.build
 
     let optionalRecord =
-        Schema.define<OptionalRecord>
-        |> Schema.construct makeOptionalRecord
+        Schema.record makeOptionalRecord
         |> Schema.field "nickname" _.Nickname
         |> Schema.field "age" _.Age
         |> Schema.build
 
     let numericRecord =
-        Schema.define<NumericRecord>
-        |> Schema.construct makeNumericRecord
+        Schema.record makeNumericRecord
         |> Schema.field "total" _.Total
         |> Schema.field "count" _.Count
         |> Schema.field "capacity" _.Capacity
@@ -143,30 +137,26 @@ module Schemas =
         |> Schema.build
 
     let auditRecord =
-        Schema.define<AuditRecord>
-        |> Schema.construct makeAuditRecord
+        Schema.record makeAuditRecord
         |> Schema.field "userId" _.UserId
         |> Schema.field "createdAt" _.CreatedAt
         |> Schema.field "duration" _.Duration
         |> Schema.build
 
     let interopCollectionRecord =
-        Schema.define<InteropCollectionRecord>
-        |> Schema.construct makeInteropCollectionRecord
+        Schema.record makeInteropCollectionRecord
         |> Schema.fieldWith "buffer" _.Buffer (Schema.resizeArray Schema.string)
         |> Schema.field "names" _.Names
         |> Schema.field "scores" _.Scores
         |> Schema.build
 
     let enumRecord =
-        Schema.define<EnumRecord>
-        |> Schema.construct makeEnumRecord
+        Schema.record makeEnumRecord
         |> Schema.field "status" _.Status
         |> Schema.build
 
     let keyValueRecord =
-        Schema.define<Person>
-        |> Schema.construct makePerson
+        Schema.record makePerson
         |> Schema.field "id" _.Id
         |> Schema.field "name" _.Name
         |> Schema.fieldWith "home" _.Home address
diff --git a/tests/CodecMapper.FablePackageTests/Program.fs b/tests/CodecMapper.FablePackageTests/Program.fs
@@ -44,15 +44,13 @@ module Domain =
 
 module Schemas =
     let address =
-        Schema.define<Address>
-        |> Schema.construct makeAddress
+        Schema.record makeAddress
         |> Schema.field "street" _.Street
         |> Schema.field "city" _.City
         |> Schema.build
 
     let person =
-        Schema.define<Person>
-        |> Schema.construct makePerson
+        Schema.record makePerson
         |> Schema.field "id" _.Id
         |> Schema.field "name" _.Name
         |> Schema.fieldWith "home" _.Home address
@@ -61,15 +59,13 @@ module Schemas =
     let userId = Schema.int |> Schema.tryMap UserId.create UserId.value
 
     let account =
-        Schema.define<Account>
-        |> Schema.construct makeAccount
+        Schema.record makeAccount
         |> Schema.fieldWith "id" _.Id userId
         |> Schema.field "name" _.Name
         |> Schema.build
 
     let numericRecord =
-        Schema.define<NumericRecord>
-        |> Schema.construct makeNumericRecord
+        Schema.record makeNumericRecord
         |> Schema.field "total" _.Total
         |> Schema.field "count" _.Count
         |> Schema.field "capacity" _.Capacity
diff --git a/tests/CodecMapper.Tests/SchemaDslTests.fs b/tests/CodecMapper.Tests/SchemaDslTests.fs
@@ -8,6 +8,36 @@ open TestCommon
 
 [<Fact>]
 let ``Round-trip using Pipeline DSL`` () =
+    let addressSchema =
+        Schema.record makeAddress
+        |> Schema.field "street" (fun (address: Address) -> address.Street)
+        |> Schema.field "city" (fun (address: Address) -> address.City)
+        |> Schema.build
+
+    let personSchema =
+        Schema.record makePerson
+        |> Schema.field "id" (fun (person: Person) -> person.Id)
+        |> Schema.field "name" (fun (person: Person) -> person.Name)
+        |> Schema.fieldWith "home" (fun (person: Person) -> person.Home) addressSchema
+        |> Schema.build
+
+    let codec = Json.compileSchema personSchema
+
+    let person = {
+        Id = 42
+        Name = "Adam"
+        Home = {
+            Street = "123 F# Lane"
+            City = "Pipeline City"
+        }
+    }
+
+    let json = Json.serialize codec person
+    let decoded = Json.deserialize codec json
+    test <@ decoded = person @>
+
+[<Fact>]
+let ``Round-trip using define construct DSL`` () =
     let addressSchema =
         Schema.define<Address>
         |> Schema.construct makeAddress
