@reventlessdev/reventless-core 3.0.0-alpha.259 → 3.0.0-alpha.261

package/tests/api/SuryToJsonSchemaTest.res.mjs

@@ -20,6 +20,7 @@ import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/compon
 import * as Sensitive$Reventless from "@reventlessdev/reventless-spec/src/components/Sensitive.res.mjs";
 import * as StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
 import * as CalendarDate$Reventless from "@reventlessdev/reventless-spec/src/semantic/CalendarDate.res.mjs";
+import * as FieldDefault$Reventless from "@reventlessdev/reventless-spec/src/components/FieldDefault.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
 import * as SuryToJsonSchema$ReventlessCore from "../../src/components/Api/SuryToJsonSchema.res.mjs";
 
@@ -1163,6 +1164,36 @@ globalThis.describe("SuryToJsonSchema:", () => {
       globalThis.expect(nestedRequired.includes("street")).toBe(true);
     });
   });
+  globalThis.describe("a field declaring a default:", () => {
+    let defaultOf = (json, field) => Stdlib_Option.flatMap(getPropertyOf(json, field), s => getProperty(s, "default"));
+    let json = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, Sury.$schema(s => ({
+      quantity: s.m(FieldDefault$Reventless.int(Sury.int, 1)),
+      shippingMethod: s.m(FieldDefault$Reventless.string(Sury.string, "Standard")),
+      plain: s.m(Sury.int)
+    })));
+    globalThis.test("carries it as `default`", () => {
+      globalThis.expect(defaultOf(json, "quantity")).toEqual(1);
+    });
+    globalThis.test("keeps the shape the value actually has", () => {
+      globalThis.expect(Stdlib_Option.flatMap(getPropertyOf(json, "quantity"), s => getProperty(s, "type"))).toEqual("integer");
+    });
+    globalThis.test("carries a string default the same way", () => {
+      globalThis.expect(defaultOf(json, "shippingMethod")).toEqual("Standard");
+    });
+    globalThis.test("while a field declaring none says nothing", () => {
+      globalThis.expect(defaultOf(json, "plain")).toBe(undefined);
+    });
+    globalThis.test("and reaches a field of a nested record", () => {
+      let lineItem = Sury.$schema(s => ({
+        productId: s.m(Sury.string),
+        quantity: s.m(FieldDefault$Reventless.int(Sury.int, 1))
+      }));
+      let nested = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, Sury.$schema(s => ({
+        lineItems: s.m(Sury.array(lineItem))
+      })));
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(nested, "lineItems"), a => getProperty(a, "items")), i => defaultOf(i, "quantity"))).toEqual(1);
+    });
+  });
 });
 
 export {

package/tests/api/TaggedUnionSchemaTest.res

@@ -31,8 +31,7 @@ describe("SchemaType classifies a named union", () => {
         expect(fields->Dict.keysToArray)->toEqual(["point"])
       | _ => expect("Located arm")->toBe("an ObjectRef")
       }
-    | other =>
-      expect(other->Option.isSome ? "some other shape" : "nothing")->toBe("a TaggedUnion")
+    | other => expect(other->Option.isSome ? "some other shape" : "nothing")->toBe("a TaggedUnion")
     }
   })
 
@@ -58,8 +57,7 @@ describe("SchemaType classifies a named union", () => {
     | [{path, reason}] =>
       expect(path)->toBe("verdict")
       expect(reason->String.includes("no name"))->toBe(true)
-    | found =>
-      expect(found->Array.length)->toBe(1)
+    | found => expect(found->Array.length)->toBe(1)
     }
   })
 
@@ -139,17 +137,16 @@ describe("GraphQL_FragmentGenerator emits a union", () => {
       ~specName="TaggedUnionUnnamed",
       UnnamedSpec.stateSchema,
     )
-    expect(
-      typeDefFor(unnamed, "type Ordering_TuCase ")->String.includes("verdict: String!"),
-    )->toBe(true)
+    expect(typeDefFor(unnamed, "type Ordering_TuCase ")->String.includes("verdict: String!"))->toBe(
+      true,
+    )
     expect(typesOf(unnamed)->Array.some(t => t->String.startsWith("union ")))->toBe(false)
   })
 })
 
 // ── The JSON Schema ───────────────────────────────────────────────────────
 
-let objAt = (json, key) =>
-  json->JSON.Decode.object->Option.flatMap(o => o->Dict.get(key))
+let objAt = (json, key) => json->JSON.Decode.object->Option.flatMap(o => o->Dict.get(key))
 
 describe("SuryToJsonSchema emits the arms as oneOf", () => {
   let json = SuryToJsonSchema.deriveObjectSchema(CustomersSpec.stateSchema->S.castToUnknown)
@@ -166,15 +163,15 @@ describe("SuryToJsonSchema emits the arms as oneOf", () => {
   })
 
   testSync("one member per arm, each discriminated by its TAG const", () => {
-    let members =
-      objAt(field, "oneOf")->Option.flatMap(JSON.Decode.array)->Option.getOr([])
+    let members = objAt(field, "oneOf")->Option.flatMap(JSON.Decode.array)->Option.getOr([])
     expect(members->Array.length)->toBe(3)
-    let tags = members->Array.filterMap(m =>
-      objAt(m, "properties")
-      ->Option.flatMap(JSON.Decode.object)
-      ->Option.flatMap(p => p->Dict.get("TAG"))
-      ->Option.flatMap(t => objAt(t, "const"))
-      ->Option.flatMap(JSON.Decode.string)
+    let tags = members->Array.filterMap(
+      m =>
+        objAt(m, "properties")
+        ->Option.flatMap(JSON.Decode.object)
+        ->Option.flatMap(p => p->Dict.get("TAG"))
+        ->Option.flatMap(t => objAt(t, "const"))
+        ->Option.flatMap(JSON.Decode.string),
     )
     expect(tags)->toEqual(["Pending", "Located", "Unresolvable"])
   })
@@ -186,13 +183,9 @@ describe("SuryToJsonSchema emits the arms as oneOf", () => {
       objAt(field, "oneOf")
       ->Option.flatMap(JSON.Decode.array)
       ->Option.getOr([])
-      ->Array.filterMap(m =>
-        objAt(m, "x-reventless-union-member")->Option.flatMap(JSON.Decode.string)
+      ->Array.filterMap(
+        m => objAt(m, "x-reventless-union-member")->Option.flatMap(JSON.Decode.string),
       )
-    expect(names)->toEqual([
-      "GeolocationPending",
-      "GeolocationLocated",
-      "GeolocationUnresolvable",
-    ])
+    expect(names)->toEqual(["GeolocationPending", "GeolocationLocated", "GeolocationUnresolvable"])
   })
 })

package/tests/commandgenerator/CommandGeneratorCallbackTest.res

@@ -5,125 +5,159 @@ let _ = beforeEach(() => reset())
 
 describe("CommandGenerator_Callback.generateCommand:", () => {
   describe("zero-param command", () => {
-    testPromise("publishJsons called with plain string commandJson", async () => {
-      let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
-      let _msgId = await TestGenerator.generateCommand(payload)->Effect.runPromise
-      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
-      // Zero-param command serializes as a plain JSON string
-      expect(publishedCmd.commandJson)->toEqual(JSON.Encode.string("Create"))
-    })
-
-    testPromise("returns a Pending outcome with non-empty msgId", async () => {
-      let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
-      let outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
-      let msgId = switch outcome {
-      | CommandTopic.Pending({msgId}) => msgId
-      | _ => ""
-      }
-      expect(msgId->String.length > 0)->toBe(true)
-    })
-
-    testPromise("meta.service equals AggregateSpec.name", async () => {
-      let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
-      let _outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
-      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
-      expect(publishedCmd.meta.service)->toBe(CmdGenAggSpec.name)
-    })
-
-    testPromise("meta.msgId equals meta.correlationId", async () => {
-      let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
-      let outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
-      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
-      let msgId = switch outcome {
-      | CommandTopic.Pending({msgId}) => msgId
-      | _ => ""
-      }
-      expect((publishedCmd.meta.msgId, publishedCmd.meta.correlationId))->toEqual((msgId, msgId))
-    })
+    testPromise(
+      "publishJsons called with plain string commandJson",
+      async () => {
+        let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
+        let _msgId = await TestGenerator.generateCommand(payload)->Effect.runPromise
+        let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+        // Zero-param command serializes as a plain JSON string
+        expect(publishedCmd.commandJson)->toEqual(JSON.Encode.string("Create"))
+      },
+    )
+
+    testPromise(
+      "returns a Pending outcome with non-empty msgId",
+      async () => {
+        let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
+        let outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
+        let msgId = switch outcome {
+        | CommandTopic.Pending({msgId}) => msgId
+        | _ => ""
+        }
+        expect(msgId->String.length > 0)->toBe(true)
+      },
+    )
+
+    testPromise(
+      "meta.service equals AggregateSpec.name",
+      async () => {
+        let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
+        let _outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
+        let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+        expect(publishedCmd.meta.service)->toBe(CmdGenAggSpec.name)
+      },
+    )
+
+    testPromise(
+      "meta.msgId equals meta.correlationId",
+      async () => {
+        let payload = makeZeroParamPayload(~id="agg-1", ~command="Create")
+        let outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
+        let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+        let msgId = switch outcome {
+        | CommandTopic.Pending({msgId}) => msgId
+        | _ => ""
+        }
+        expect((publishedCmd.meta.msgId, publishedCmd.meta.correlationId))->toEqual((msgId, msgId))
+      },
+    )
   })
 
   describe("multi-param command", () => {
-    testPromise("publishJsons called with object commandJson {TAG, param}", async () => {
-      let payload =
-        makeOneParamPayload(~id="agg-1", ~command="CreateWithName", ~paramName="name", ~paramValue="Widget")
-      let _msgId = await TestGenerator.generateCommand(payload)->Effect.runPromise
-      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
-      // Multi-param command serializes as {TAG: "CreateWithName", name: "Widget"}
-      let cmdObj = publishedCmd.commandJson->JSON.Decode.object->Option.getOrThrow
-      expect(cmdObj->Dict.get("TAG"))->toEqual(Some(JSON.Encode.string("CreateWithName")))
-      expect(cmdObj->Dict.get("name"))->toEqual(Some(JSON.Encode.string("Widget")))
-    })
+    testPromise(
+      "publishJsons called with object commandJson {TAG, param}",
+      async () => {
+        let payload = makeOneParamPayload(
+          ~id="agg-1",
+          ~command="CreateWithName",
+          ~paramName="name",
+          ~paramValue="Widget",
+        )
+        let _msgId = await TestGenerator.generateCommand(payload)->Effect.runPromise
+        let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+        // Multi-param command serializes as {TAG: "CreateWithName", name: "Widget"}
+        let cmdObj = publishedCmd.commandJson->JSON.Decode.object->Option.getOrThrow
+        expect(cmdObj->Dict.get("TAG"))->toEqual(Some(JSON.Encode.string("CreateWithName")))
+        expect(cmdObj->Dict.get("name"))->toEqual(Some(JSON.Encode.string("Widget")))
+      },
+    )
   })
 
   describe("schema validation failure", () => {
-    testPromise("invalid command name throws an error", async () => {
-      let payload = makeZeroParamPayload(~id="agg-1", ~command="NonExistentCommand")
-      let threw = ref(false)
-      switch await TestGenerator.generateCommand(payload)->Effect.runPromise {
-      | _ => ()
-      | exception _ => threw := true
-      }
-      expect(threw.contents)->toBe(true)
-    })
+    testPromise(
+      "invalid command name throws an error",
+      async () => {
+        let payload = makeZeroParamPayload(~id="agg-1", ~command="NonExistentCommand")
+        let threw = ref(false)
+        switch await TestGenerator.generateCommand(payload)->Effect.runPromise {
+        | _ => ()
+        | exception _ => threw := true
+        }
+        expect(threw.contents)->toBe(true)
+      },
+    )
   })
 
   describe("StateChangeSlice envelope id derivation", () => {
-    testPromise("single @partitionTag: id derived from tagged field when args have no id", async () => {
-      let payload = makeSlicePayload(
-        ~command="CreateItem",
-        ~args=Dict.fromArray([
-          ("itemId", JSON.Encode.string("item-42")),
-          ("name", JSON.Encode.string("Widget")),
-        ]),
-      )
-      let outcome = await singleTagSliceGen(payload)->Effect.runPromise
-      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
-      expect(publishedCmd.id)->toBe("item-42")
-      // sanity: outcome is well-formed
-      let msgId = switch outcome {
-      | CommandTopic.Pending({msgId}) => msgId
-      | _ => ""
-      }
-      expect(msgId->String.length > 0)->toBe(true)
-    })
-
-    testPromise("composite @compositePartitionTag: id is joined partition-key value", async () => {
-      let payload = makeSlicePayload(
-        ~command="DeployVersion",
-        ~args=Dict.fromArray([
-          ("environment", JSON.Encode.string("prod")),
-          ("service", JSON.Encode.string("checkout")),
-          ("version", JSON.Encode.string("1.2.3")),
-        ]),
-      )
-      let _outcome = await compositeTagSliceGen(payload)->Effect.runPromise
-      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
-      // Composite key joins position-0 value, then sep[0] = "-", then position-1 value
-      expect(publishedCmd.id)->toBe("prod-checkout")
-    })
-
-    testPromise("explicit id in args wins over derivation (regression check)", async () => {
-      let payload = makeSlicePayload(
-        ~command="CreateItem",
-        ~args=Dict.fromArray([
-          ("id", JSON.Encode.string("explicit-id")),
-          ("itemId", JSON.Encode.string("item-99")),
-          ("name", JSON.Encode.string("Gadget")),
-        ]),
-      )
-      let _outcome = await singleTagSliceGen(payload)->Effect.runPromise
-      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
-      expect(publishedCmd.id)->toBe("explicit-id")
-    })
+    testPromise(
+      "single @partitionTag: id derived from tagged field when args have no id",
+      async () => {
+        let payload = makeSlicePayload(
+          ~command="CreateItem",
+          ~args=Dict.fromArray([
+            ("itemId", JSON.Encode.string("item-42")),
+            ("name", JSON.Encode.string("Widget")),
+          ]),
+        )
+        let outcome = await singleTagSliceGen(payload)->Effect.runPromise
+        let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+        expect(publishedCmd.id)->toBe("item-42")
+        // sanity: outcome is well-formed
+        let msgId = switch outcome {
+        | CommandTopic.Pending({msgId}) => msgId
+        | _ => ""
+        }
+        expect(msgId->String.length > 0)->toBe(true)
+      },
+    )
+
+    testPromise(
+      "composite @compositePartitionTag: id is joined partition-key value",
+      async () => {
+        let payload = makeSlicePayload(
+          ~command="DeployVersion",
+          ~args=Dict.fromArray([
+            ("environment", JSON.Encode.string("prod")),
+            ("service", JSON.Encode.string("checkout")),
+            ("version", JSON.Encode.string("1.2.3")),
+          ]),
+        )
+        let _outcome = await compositeTagSliceGen(payload)->Effect.runPromise
+        let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+        // Composite key joins position-0 value, then sep[0] = "-", then position-1 value
+        expect(publishedCmd.id)->toBe("prod-checkout")
+      },
+    )
+
+    testPromise(
+      "explicit id in args wins over derivation (regression check)",
+      async () => {
+        let payload = makeSlicePayload(
+          ~command="CreateItem",
+          ~args=Dict.fromArray([
+            ("id", JSON.Encode.string("explicit-id")),
+            ("itemId", JSON.Encode.string("item-99")),
+            ("name", JSON.Encode.string("Gadget")),
+          ]),
+        )
+        let _outcome = await singleTagSliceGen(payload)->Effect.runPromise
+        let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+        expect(publishedCmd.id)->toBe("explicit-id")
+      },
+    )
   })
 
   describe("Aggregate envelope id (regression)", () => {
-    testPromise("explicit id in args is preserved unchanged", async () => {
-      let payload = makeZeroParamPayload(~id="agg-7", ~command="Create")
-      let _outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
-      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
-      expect(publishedCmd.id)->toBe("agg-7")
-    })
+    testPromise(
+      "explicit id in args is preserved unchanged",
+      async () => {
+        let payload = makeZeroParamPayload(~id="agg-7", ~command="Create")
+        let _outcome = await TestGenerator.generateCommand(payload)->Effect.runPromise
+        let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+        expect(publishedCmd.id)->toBe("agg-7")
+      },
+    )
   })
 
   // A transport hands over exactly what the caller supplied, and GraphQL lets a
@@ -137,64 +171,80 @@ describe("CommandGenerator_Callback.generateCommand:", () => {
     let fieldOf = (cmd: Message.commandJson, name) =>
       cmd.commandJson->JSON.Decode.object->Option.flatMap(o => o->Dict.get(name))
 
-    testPromise("is dropped, and the command decodes and publishes", async () => {
-      let payload = storeItem(
-        ~args=Dict.fromArray([
-          ("itemId", JSON.Encode.string("item-1")),
-          ("data", data),
-          ("note", JSON.Null),
-        ]),
-      )
-      let _outcome = await optionalFieldSliceGen(payload)->Effect.runPromise
-      let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
-      expect((capturedCmds.contents->Array.length, publishedCmd->fieldOf("note")))
-      ->toEqual((1, None))
-    })
-
-    testPromise("carrying a value is left exactly as sent", async () => {
-      let payload = storeItem(
-        ~args=Dict.fromArray([
-          ("itemId", JSON.Encode.string("item-2")),
-          ("data", data),
-          ("note", JSON.Encode.string("gift wrap")),
-        ]),
-      )
-      let _outcome = await optionalFieldSliceGen(payload)->Effect.runPromise
-      expect(capturedCmds.contents->Array.getUnsafe(0)->fieldOf("note"))
-      ->toEqual(Some(JSON.Encode.string("gift wrap")))
-    })
+    testPromise(
+      "is dropped, and the command decodes and publishes",
+      async () => {
+        let payload = storeItem(
+          ~args=Dict.fromArray([
+            ("itemId", JSON.Encode.string("item-1")),
+            ("data", data),
+            ("note", JSON.Null),
+          ]),
+        )
+        let _outcome = await optionalFieldSliceGen(payload)->Effect.runPromise
+        let publishedCmd = capturedCmds.contents->Array.getUnsafe(0)
+        expect((capturedCmds.contents->Array.length, publishedCmd->fieldOf("note")))->toEqual((
+          1,
+          None,
+        ))
+      },
+    )
+
+    testPromise(
+      "carrying a value is left exactly as sent",
+      async () => {
+        let payload = storeItem(
+          ~args=Dict.fromArray([
+            ("itemId", JSON.Encode.string("item-2")),
+            ("data", data),
+            ("note", JSON.Encode.string("gift wrap")),
+          ]),
+        )
+        let _outcome = await optionalFieldSliceGen(payload)->Effect.runPromise
+        expect(capturedCmds.contents->Array.getUnsafe(0)->fieldOf("note"))->toEqual(
+          Some(JSON.Encode.string("gift wrap")),
+        )
+      },
+    )
 
     // The control the drop is modelled on: absent and explicitly-null must
     // reach the domain as the same command.
-    testPromise("and one simply omitted produce the same command", async () => {
-      let withNull = storeItem(
-        ~args=Dict.fromArray([
-          ("itemId", JSON.Encode.string("item-3")),
-          ("data", data),
-          ("note", JSON.Null),
-        ]),
-      )
-      let withoutKey = storeItem(
-        ~args=Dict.fromArray([("itemId", JSON.Encode.string("item-3")), ("data", data)]),
-      )
-      let _ = await optionalFieldSliceGen(withNull)->Effect.runPromise
-      let _ = await optionalFieldSliceGen(withoutKey)->Effect.runPromise
-      let published = capturedCmds.contents
-      expect((published->Array.getUnsafe(0)).commandJson)
-      ->toEqual((published->Array.getUnsafe(1)).commandJson)
-    })
+    testPromise(
+      "and one simply omitted produce the same command",
+      async () => {
+        let withNull = storeItem(
+          ~args=Dict.fromArray([
+            ("itemId", JSON.Encode.string("item-3")),
+            ("data", data),
+            ("note", JSON.Null),
+          ]),
+        )
+        let withoutKey = storeItem(
+          ~args=Dict.fromArray([("itemId", JSON.Encode.string("item-3")), ("data", data)]),
+        )
+        let _ = await optionalFieldSliceGen(withNull)->Effect.runPromise
+        let _ = await optionalFieldSliceGen(withoutKey)->Effect.runPromise
+        let published = capturedCmds.contents
+        expect((published->Array.getUnsafe(0)).commandJson)->toEqual(
+          (published->Array.getUnsafe(1)).commandJson,
+        )
+      },
+    )
 
     // Shallow on purpose. A null one level in is part of a value the caller
     // sent, not an argument they left out — `data` is opaque JSON and its own
     // nulls are data.
-    testPromise("nested inside a value is left alone", async () => {
-      let nested = JSON.Object(Dict.fromArray([("kind", JSON.Null)]))
-      let payload = storeItem(
-        ~args=Dict.fromArray([("itemId", JSON.Encode.string("item-4")), ("data", nested)]),
-      )
-      let _outcome = await optionalFieldSliceGen(payload)->Effect.runPromise
-      expect(capturedCmds.contents->Array.getUnsafe(0)->fieldOf("data"))->toEqual(Some(nested))
-    })
+    testPromise(
+      "nested inside a value is left alone",
+      async () => {
+        let nested = JSON.Object(Dict.fromArray([("kind", JSON.Null)]))
+        let payload = storeItem(
+          ~args=Dict.fromArray([("itemId", JSON.Encode.string("item-4")), ("data", nested)]),
+        )
+        let _outcome = await optionalFieldSliceGen(payload)->Effect.runPromise
+        expect(capturedCmds.contents->Array.getUnsafe(0)->fieldOf("data"))->toEqual(Some(nested))
+      },
+    )
   })
 
   // A payload that does not decode describes the caller's own request, so a
@@ -207,26 +257,32 @@ describe("CommandGenerator_Callback.generateCommand:", () => {
         ~args=Dict.fromArray([("itemId", JSON.Encode.string("item-9"))]),
       )
 
-    testPromise("is refused rather than published", async () => {
-      let refused = switch await optionalFieldSliceGen(undecodable())->Effect.runPromise {
-      | _ => false
-      | exception _ => true
-      }
-      expect((refused, capturedCmds.contents->Array.length))->toEqual((true, 0))
-    })
-
-    testPromise("is marked as the caller's fault, naming the field", async () => {
-      let failure = switch await optionalFieldSliceGen(undecodable())->Effect.runPromise {
-      | _ => None
-      | exception e => Some(e)
-      }
-      let marked = failure->Option.mapOr(false, Plugin_ResolverError.isCallerFault)
-      let saysWhy =
-        failure
-        ->Option.flatMap(JsExn.fromException)
-        ->Option.flatMap(JsExn.message)
-        ->Option.mapOr(false, m => m->String.includes("data"))
-      expect((marked, saysWhy))->toEqual((true, true))
-    })
+    testPromise(
+      "is refused rather than published",
+      async () => {
+        let refused = switch await optionalFieldSliceGen(undecodable())->Effect.runPromise {
+        | _ => false
+        | exception _ => true
+        }
+        expect((refused, capturedCmds.contents->Array.length))->toEqual((true, 0))
+      },
+    )
+
+    testPromise(
+      "is marked as the caller's fault, naming the field",
+      async () => {
+        let failure = switch await optionalFieldSliceGen(undecodable())->Effect.runPromise {
+        | _ => None
+        | exception e => Some(e)
+        }
+        let marked = failure->Option.mapOr(false, Plugin_ResolverError.isCallerFault)
+        let saysWhy =
+          failure
+          ->Option.flatMap(JsExn.fromException)
+          ->Option.flatMap(JsExn.message)
+          ->Option.mapOr(false, m => m->String.includes("data"))
+        expect((marked, saysWhy))->toEqual((true, true))
+      },
+    )
   })
 })

package/tests/commandgenerator/CommandGeneratorFixtures.res

@@ -1,4 +1,3 @@
-
 // ─────────────────────────────────────────────────────────────
 // Aggregate spec for CommandGenerator tests
 // ─────────────────────────────────────────────────────────────
@@ -13,7 +12,7 @@ module CmdGenAggSpec = {
   type command =
     | Create
     | CreateWithName({name: string})
-    | Invalid  // used for schema validation tests
+    | Invalid // used for schema validation tests
 
   @schema
   type event =
@@ -21,7 +20,7 @@ module CmdGenAggSpec = {
     | CreatedWithName({name: string})
 
   @schema
-  type error = | InvalidCommand
+  type error = InvalidCommand
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -40,7 +39,10 @@ module CmdGenBehavior = {
 
   let evolve = (_state: state, _event: CmdGenAggSpec.event): state => ()
 
-  let decide = (_state: state, command: CmdGenAggSpec.command): result<array<CmdGenAggSpec.event>, CmdGenAggSpec.error> =>
+  let decide = (_state: state, command: CmdGenAggSpec.command): result<
+    array<CmdGenAggSpec.event>,
+    CmdGenAggSpec.error,
+  > =>
     switch command {
     | Create => Ok([CmdGenAggSpec.Created])
     | CreateWithName({name}) => Ok([CmdGenAggSpec.CreatedWithName({name: name})])
@@ -89,11 +91,7 @@ type compositeTagCommand =
 // nulls are data and must survive.
 @schema
 type optionalFieldCommand =
-  StoreItem({
-    itemId: @s.matches(Reventless.DcbTag.string) string,
-    data: JSON.t,
-    note?: string,
-  })
+  StoreItem({itemId: @s.matches(Reventless.DcbTag.string) string, data: JSON.t, note?: string})
 
 let optionalFieldSliceGen = CommandGenerator_Callback.makeGenerateCommand(
   ~publishJsons=MockPublishSpec.publishJsons,
@@ -144,10 +142,7 @@ let makeOneParamPayload = (~id, ~command, ~paramName, ~paramValue): CommandGener
   Obj.magic({
     "command": command,
     "arguments": Obj.magic(
-      Dict.fromArray([
-        ("id", JSON.Encode.string(id)),
-        (paramName, JSON.Encode.string(paramValue)),
-      ]),
+      Dict.fromArray([("id", JSON.Encode.string(id)), (paramName, JSON.Encode.string(paramValue))]),
     ),
     "meta": {"ip": ["127.0.0.1"], "user": "test-user", "info": ""},
   })