@reventlessdev/reventless-local 3.0.0-alpha.167 → 3.0.0-alpha.169

package/src/adapter/ProjectionCheckpoint.res

@@ -180,16 +180,21 @@ let dcbCatchupEnvelope = (
   ~eventType: string,
   ~dataText: string,
   ~metaText: string,
+  ~recordedAt: string,
   ~firstTagValue: option<string>,
 ): option<JSON.t> =>
   switch (JSON.parseOrThrow(dataText), JSON.parseOrThrow(metaText)) {
   | (data, meta) =>
     let dataDict = data->JSON.Decode.object->Option.getOr(Dict.make())
     let entityId = firstTagValue->Option.getOr(logName)
+    // The stored `recorded_at` column is the authoritative storage time; unlike
+    // live publish we must NOT re-stamp here (catch-up runs at startup, long
+    // after append). StateViewSlice projections read this as `consumed.recordedAt`.
     Some(
       Dict.fromArray([
         ("id", JSON.Encode.string(entityId)),
         ("meta", meta),
+        ("recordedAt", JSON.Encode.string(recordedAt)),
         ("event", Message.combineMessage(eventType, dataDict)),
       ])->JSON.Encode.object,
     )
@@ -226,7 +231,7 @@ let missedRows = (
     // dcb_tag rows are inserted in tag order, so MIN(rowid) is the first tag.
     db
     ->SqliteDriver.prepare(
-      "SELECT rowid AS pos, log_name, event_type, data, meta, (SELECT t.tag_value FROM dcb_tag t WHERE t.log_name = dcb_event.log_name AND t.position = dcb_event.position ORDER BY t.rowid ASC LIMIT 1) AS first_tag FROM dcb_event WHERE rowid > ? AND rowid <= ? ORDER BY rowid ASC",
+      "SELECT rowid AS pos, log_name, event_type, data, meta, recorded_at, (SELECT t.tag_value FROM dcb_tag t WHERE t.log_name = dcb_event.log_name AND t.position = dcb_event.position ORDER BY t.rowid ASC LIMIT 1) AS first_tag FROM dcb_event WHERE rowid > ? AND rowid <= ? ORDER BY rowid ASC",
     )
     ->SqliteDriver.all([JSON.Encode.int(afterPos), JSON.Encode.int(upTo)])
     ->Array.filterMap(row =>
@@ -248,9 +253,13 @@ let missedRows = (
         | Some(JSON.String(v)) => Some(v)
         | _ => None
         }
+        let recordedAt = switch row->Dict.get("recorded_at") {
+        | Some(JSON.String(v)) => v
+        | _ => ""
+        }
         Some((
           Float.toInt(pos),
-          dcbCatchupEnvelope(~logName, ~eventType, ~dataText, ~metaText, ~firstTagValue),
+          dcbCatchupEnvelope(~logName, ~eventType, ~dataText, ~metaText, ~recordedAt, ~firstTagValue),
         ))
       | _ => None
       }

package/src/adapter/ProjectionCheckpoint.res.mjs

@@ -129,7 +129,7 @@ function catchupEnvelope(flat) {
   }
 }
 
-function dcbCatchupEnvelope(logName, eventType, dataText, metaText, firstTagValue) {
+function dcbCatchupEnvelope(logName, eventType, dataText, metaText, recordedAt, firstTagValue) {
   let val;
   let val$1;
   try {
@@ -149,6 +149,10 @@ function dcbCatchupEnvelope(logName, eventType, dataText, metaText, firstTagValu
       "meta",
       val$1
     ],
+    [
+      "recordedAt",
+      recordedAt
+    ],
     [
       "event",
       Message$ReventlessCore.combineMessage(eventType, dataDict)
@@ -191,7 +195,7 @@ function missedRows(db, axis, afterPos, upTo) {
       ];
     });
   } else {
-    return Stdlib_Array.filterMap(SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, "SELECT rowid AS pos, log_name, event_type, data, meta, (SELECT t.tag_value FROM dcb_tag t WHERE t.log_name = dcb_event.log_name AND t.position = dcb_event.position ORDER BY t.rowid ASC LIMIT 1) AS first_tag FROM dcb_event WHERE rowid > ? AND rowid <= ? ORDER BY rowid ASC"), [
+    return Stdlib_Array.filterMap(SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, "SELECT rowid AS pos, log_name, event_type, data, meta, recorded_at, (SELECT t.tag_value FROM dcb_tag t WHERE t.log_name = dcb_event.log_name AND t.position = dcb_event.position ORDER BY t.rowid ASC LIMIT 1) AS first_tag FROM dcb_event WHERE rowid > ? AND rowid <= ? ORDER BY rowid ASC"), [
       afterPos,
       upTo
     ]), row => {
@@ -232,9 +236,11 @@ function missedRows(db, axis, afterPos, upTo) {
       }
       let match$5 = row["first_tag"];
       let firstTagValue = typeof match$5 === "string" ? match$5 : undefined;
+      let match$6 = row["recorded_at"];
+      let recordedAt = typeof match$6 === "string" ? match$6 : "";
       return [
         match | 0,
-        dcbCatchupEnvelope(match$1, match$2, match$3, match$4, firstTagValue)
+        dcbCatchupEnvelope(match$1, match$2, match$3, match$4, recordedAt, firstTagValue)
       ];
     });
   }

package/tests/PluginEventDecodeTest.res

@@ -15,6 +15,7 @@ let envelopeOf = (event: ReventlessCore.PluginSpec.event) =>
   ReventlessCore.Message.composeEventJson'(
     "Catalog",
     meta,
+    ~recordedAt="2024-01-01T00:00:00Z",
     event->S.reverseConvertToJsonOrThrow(ReventlessCore.PluginSpec.eventSchema),
   )
 
@@ -68,6 +69,7 @@ describe("Platform.decodeUiFragmentRegistryEventEnvelope", () => {
     ReventlessCore.Message.composeEventJson'(
       "Catalog",
       dcbMeta,
+      ~recordedAt="2024-01-01T00:00:00Z",
       ReventlessCore.Message.combineMessage(eventType, data),
     )
   }

package/tests/PluginEventDecodeTest.res.mjs

@@ -15,7 +15,7 @@ TestRunner$ReventlessLocal.setup();
 let meta = Message$ReventlessCore.generateMeta(PluginSpec$ReventlessCore.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
 
 function envelopeOf(event) {
-  return Message$ReventlessCore.composeEventJson$p("Catalog", meta, S.reverseConvertToJsonOrThrow(event, PluginSpec$ReventlessCore.eventSchema));
+  return Message$ReventlessCore.composeEventJson$p("Catalog", meta, "2024-01-01T00:00:00Z", S.reverseConvertToJsonOrThrow(event, PluginSpec$ReventlessCore.eventSchema));
 }
 
 globalThis.describe("Platform.decodePluginEventEnvelope", () => {
@@ -64,7 +64,7 @@ globalThis.describe("Platform.decodeUiFragmentRegistryEventEnvelope", () => {
   let dcbEnvelopeOf = event => {
     let json = S.reverseConvertToJsonOrThrow(event, UiFragmentRegistry$ReventlessCore.eventSchema);
     let match = Message$ReventlessCore.splitMessage(json);
-    return Message$ReventlessCore.composeEventJson$p("Catalog", dcbMeta, Message$ReventlessCore.combineMessage(match[0], match[1]));
+    return Message$ReventlessCore.composeEventJson$p("Catalog", dcbMeta, "2024-01-01T00:00:00Z", Message$ReventlessCore.combineMessage(match[0], match[1]));
   };
   globalThis.test("decodes a UiFragmentRegistered event from the published envelope", () => {
     let event = {

package/tests/adapter/GraphQL_SchemaInspectorTest.res

@@ -27,6 +27,21 @@ type svState = {
   price: float,
 }
 
+// Multi-variant enum used both as a required and as an optional state field, to pin
+// the nullability the sury→GraphQL deriver must preserve for the optional case.
+@schema
+type sourceKind =
+  | @as("tagged") Tagged
+  | @as("ancestry") Ancestry
+  | @as("substrate") Substrate
+
+@schema
+type enumState = {
+  productId: @s.matches(Reventless.DcbTag.string) string,
+  requiredSource: sourceKind,
+  optionalSource?: sourceKind,
+}
+
 @schema
 type addCommand = {
   productId: @s.matches(Reventless.DcbTag.string) string,
@@ -84,6 +99,8 @@ let indexedStateSchemaWithAnnotations = indexedStateSchema->S.Metadata.set(
     collapsed: [],
     scan: [],
     scanSort: [],
+    semantic: [],
+    metric: [],
     status: None,
     groupBy: None,
     visibility: None,
@@ -111,6 +128,8 @@ let orderedStateSchemaWithAnnotations = orderedStateSchema->S.Metadata.set(
     collapsed: [],
     scan: [],
     scanSort: [],
+    semantic: [],
+    metric: [],
     status: None,
     groupBy: None,
     visibility: None,
@@ -139,6 +158,8 @@ let scanStateSchemaWithAnnotations = scanStateSchema->S.Metadata.set(
     collapsed: [],
     scan: ["status"],
     scanSort: ["name"],
+    semantic: [],
+    metric: [],
     status: None,
     groupBy: None,
     visibility: None,
@@ -901,8 +922,38 @@ describe("Plugin admin fragment — kind enum + kindEq filter", () => {
     // kind is a real enum on the Plugin type (auto-derived from the payload-less variant)
     expect(sdl->String.includes("enum Platform_PluginKind"))->toBe(true)
     expect(sdl->String.includes("PlatformInfrastructure"))->toBe(true)
-    expect(sdl->String.includes("kind: Platform_PluginKind!"))->toBe(true)
+    // `kind` is `option<pluginKind>` — nullable on purpose so a kind-less legacy row
+    // can't collapse the whole Platform_Plugins query. It must render without a `!`.
+    expect(sdl->String.includes("kind: Platform_PluginKind"))->toBe(true)
+    expect(sdl->String.includes("kind: Platform_PluginKind!"))->toBe(false)
     // @scan folds a server-side equality filter for the panel split
     expect(sdl->String.includes("kindEq: String"))->toBe(true)
   })
 })
+
+describe("optional enum fields preserve GraphQL nullability", () => {
+  testPromise(
+    "required variant field → SomeEnum!; optional variant field → nullable SomeEnum",
+    async () => {
+      let fragment = ReventlessCore.GraphQL_FragmentGenerator.generate(
+        ~mutationEntries=[],
+        ~queryEntries=[
+          {
+            singleFieldName: "SV_Sourced",
+            listFieldName: "SV_Sourceds",
+            returnTypeName: "EnumState",
+            stateSchema: enumStateSchema->S.castToUnknown,
+            authorization: None,
+            includeIdParam: false,
+          },
+        ],
+      )
+      let sdl = ReventlessCore.GraphQL_SchemaInspector.inspectFragment(fragment).sdlPreview
+      // A required variant field stays non-null.
+      expect(sdl->String.includes("requiredSource: EnumStateRequiredSource!"))->toBe(true)
+      // An optional variant field is nullable: the enum is present but never with a `!`.
+      expect(sdl->String.includes("optionalSource: EnumStateOptionalSource"))->toBe(true)
+      expect(sdl->String.includes("optionalSource: EnumStateOptionalSource!"))->toBe(false)
+    },
+  )
+})

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -29,6 +29,18 @@ let svStateSchema = S.schema(s => ({
   price: s.m(S.float)
 }));
 
+let sourceKindSchema = S.union([
+  S.literal("tagged"),
+  S.literal("ancestry"),
+  S.literal("substrate")
+]);
+
+let enumStateSchema = S.schema(s => ({
+  productId: s.m(DcbTag$Reventless.string),
+  requiredSource: s.m(sourceKindSchema),
+  optionalSource: s.m(S.option(sourceKindSchema))
+}));
+
 let addCommandSchema = S.schema(s => ({
   productId: s.m(DcbTag$Reventless.string),
   name: s.m(S.string)
@@ -95,6 +107,8 @@ let indexedStateSchemaWithAnnotations = S.Metadata.set(indexedStateSchema, State
   collapsed: [],
   scan: [],
   scanSort: [],
+  semantic: [],
+  metric: [],
   status: undefined,
   groupBy: undefined,
   visibility: undefined
@@ -119,6 +133,8 @@ let orderedStateSchemaWithAnnotations = S.Metadata.set(orderedStateSchema, State
   collapsed: [],
   scan: [],
   scanSort: [],
+  semantic: [],
+  metric: [],
   status: undefined,
   groupBy: undefined,
   visibility: undefined
@@ -144,6 +160,8 @@ let scanStateSchemaWithAnnotations = S.Metadata.set(scanStateSchema, StateAnnota
   collapsed: [],
   scan: ["status"],
   scanSort: ["name"],
+  semantic: [],
+  metric: [],
   status: undefined,
   groupBy: undefined,
   visibility: undefined
@@ -635,11 +653,29 @@ globalThis.describe("Plugin admin fragment — kind enum + kindEq filter", () =>
     let sdl = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment).sdlPreview;
     globalThis.expect(sdl.includes("enum Platform_PluginKind")).toBe(true);
     globalThis.expect(sdl.includes("PlatformInfrastructure")).toBe(true);
-    globalThis.expect(sdl.includes("kind: Platform_PluginKind!")).toBe(true);
+    globalThis.expect(sdl.includes("kind: Platform_PluginKind")).toBe(true);
+    globalThis.expect(sdl.includes("kind: Platform_PluginKind!")).toBe(false);
     globalThis.expect(sdl.includes("kindEq: String")).toBe(true);
   });
 });
 
+globalThis.describe("optional enum fields preserve GraphQL nullability", () => {
+  globalThis.test("required variant field → SomeEnum!; optional variant field → nullable SomeEnum", async () => {
+    let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+        singleFieldName: "SV_Sourced",
+        listFieldName: "SV_Sourceds",
+        returnTypeName: "EnumState",
+        stateSchema: enumStateSchema,
+        authorization: undefined,
+        includeIdParam: false
+      }]);
+    let sdl = GraphQL_SchemaInspector$ReventlessCore.inspectFragment(fragment).sdlPreview;
+    globalThis.expect(sdl.includes("requiredSource: EnumStateRequiredSource!")).toBe(true);
+    globalThis.expect(sdl.includes("optionalSource: EnumStateOptionalSource")).toBe(true);
+    globalThis.expect(sdl.includes("optionalSource: EnumStateOptionalSource!")).toBe(false);
+  });
+});
+
 let stringSchema = S.string;
 
 let taggedSchema = DcbTag$Reventless.string;
@@ -655,6 +691,8 @@ export {
   boolSchema,
   testStateSchema,
   svStateSchema,
+  sourceKindSchema,
+  enumStateSchema,
   addCommandSchema,
   unionCommandSchema,
   dcbSingleCommandSchema,

package/tests/adapter/InboundTranslationMutationTest.res

@@ -0,0 +1,139 @@
+// Response-envelope tests for InboundTranslationSlice mutations.
+//
+// The field is declared `CommandResult!`, an abstract type. A resolver invoked
+// directly cannot show whether the value it returns actually resolves to a union
+// member — only a real execution can, and until one existed every inbound
+// mutation came back as `Abstract type "CommandResult" must resolve to an Object
+// type at runtime` even though the translation had succeeded.
+//
+// So these tests compose the schema the way the running platform does
+// (DomainGraphQL_Server.composeSchema) and execute a document against it, then
+// assert on the FULL envelope — `errors` as well as `data`.
+//
+// The resolver is driven by a real InboundTranslationSlice_Callback, so the
+// mutation exercises parse -> translate -> publish -> encode end to end.
+
+@@warning("-44")
+
+open JestGlobals
+open InboundTranslationSliceFixtures
+
+module PaymentWebhookTranslation = {
+  let translate = PaymentWebhookSpec.translate
+  let moduleUrl = PaymentWebhookSpec.moduleUrl
+}
+
+module Callback = ReventlessCore.InboundTranslationSlice_Callback.Make(
+  PaymentWebhookSpec,
+  PaymentWebhookTranslation,
+)
+
+// Registered inside a plugin scope, not the platform one: a plugin bucket's
+// document is validated standalone before the cross-plugin merge, so this also
+// pins that the inbound path registers the CommandResult union itself rather
+// than borrowing a registration from a sibling command handler.
+let scope = "Payments"
+let fieldName = "Payments_PaymentWebhook"
+
+let published: ref<array<Reventless.Message.commandJson>> = ref([])
+
+let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async cmds =>
+  published.contents = published.contents->Array.concat(cmds)
+
+let selection = `__typename
+  ... on CommandAccepted { msgId entityId eventCount }
+  ... on CommandRejected { msgId errorCode errorDetail }`
+
+let runMutation = async (~status: string) => {
+  let source = `mutation {
+    r: ${fieldName}(paymentId: "pay-1", orderId: "ord-1", status: "${status}") { ${selection} }
+  }`
+  await GraphqlYoga.graphql({
+    "schema": DomainGraphQL_Server.composeSchema(),
+    "source": source,
+    "contextValue": JSON.Encode.null,
+  })
+}
+
+let errorMessages = (result: GraphqlYoga.executionResult): array<string> =>
+  result.errors
+  ->Option.getOr([])
+  ->Array.map(e => e->JsExn.message->Option.getOr("unknown error"))
+
+let payload = (result: GraphqlYoga.executionResult): JSON.t =>
+  result.data
+  ->Option.getOr(JSON.Encode.null)
+  ->JSON.Decode.object
+  ->Option.flatMap(d => d->Dict.get("r"))
+  ->Option.getOr(JSON.Encode.null)
+
+let str = (node: JSON.t, key: string): option<string> =>
+  node->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.string)
+
+let num = (node: JSON.t, key: string): option<float> =>
+  node->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.float)
+
+describe("InboundTranslationSlice mutation — response envelope", () => {
+  beforeEach(() => {
+    DomainGraphQL_Server.asInterface.reset()
+    published.contents = []
+    Callback.auditLog->Dict.keysToArray->Array.forEach(k => Callback.auditLog->Dict.delete(k))
+
+    DomainGraphQL_Server.setScope(scope)
+    InboundTranslationResolvers_GraphQL.register(
+      ~fieldName,
+      ~externalInputSchema=PaymentWebhookSpec.externalInputSchema->S.castToUnknown,
+      ~server=DomainGraphQL_Server.asInterface,
+    )
+    DomainGraphQL_Server.resetScope()
+
+    InboundTranslationResolvers_GraphQL.bindReceive(
+      ~fieldName,
+      ~receive=inputJson => Callback.receive(publishJsons, inputJson),
+    )
+  })
+
+  testPromise("a successful translation resolves as CommandAccepted, with no errors", async () => {
+    let result = await runMutation(~status="completed")
+
+    expect(errorMessages(result))->toEqual([])
+
+    let node = payload(result)
+    expect(node->str("__typename"))->toEqual(Some("CommandAccepted"))
+    expect(node->str("entityId"))->toEqual(Some("ord-1"))
+    expect(node->num("eventCount"))->toEqual(Some(1.0))
+
+    // msgId is the audit-row key, so the caller can look the request up.
+    let msgId = node->str("msgId")->Option.getOr("")
+    expect(Callback.auditLog->Dict.get(msgId)->Option.isSome)->toBe(true)
+
+    expect(published.contents->Array.length)->toBe(1)
+  })
+
+  testPromise("a rejected translation resolves as CommandRejected, with no errors", async () => {
+    let result = await runMutation(~status="pending")
+
+    expect(errorMessages(result))->toEqual([])
+
+    let node = payload(result)
+    expect(node->str("__typename"))->toEqual(Some("CommandRejected"))
+    expect(node->str("errorCode"))->toEqual(Some("TranslationFailed"))
+    expect(node->str("errorDetail"))->toEqual(Some("Unknown payment status: pending"))
+
+    let msgId = node->str("msgId")->Option.getOr("")
+    switch Callback.auditLog->Dict.get(msgId) {
+    | Some(row) => expect(row.status)->toBe(ReventlessCore.InboundTranslationSlice_Callback.Failure)
+    | None => expect(true)->toBe(false)
+    }
+
+    expect(published.contents->Array.length)->toBe(0)
+  })
+
+  testSync("the mutation field is typed CommandResult!", () => {
+    let fieldLine =
+      DomainGraphQL_Server.asInterface.buildSdl()
+      ->String.split("\n")
+      ->Array.find(line => line->String.includes(fieldName))
+    expect(fieldLine->Option.map(l => l->String.endsWith(": CommandResult!")))->toEqual(Some(true))
+  })
+})

package/tests/adapter/InboundTranslationMutationTest.res.mjs

@@ -0,0 +1,132 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Graphql from "graphql";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as DomainGraphQL_Server$ReventlessLocal from "../../src/adapter/DomainGraphQL_Server.res.mjs";
+import * as InboundTranslationSliceFixtures$ReventlessLocal from "../components/inboundtranslationslice/InboundTranslationSliceFixtures.res.mjs";
+import * as InboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
+import * as InboundTranslationResolvers_GraphQL$ReventlessLocal from "../../src/adapter/CommandGenerator/InboundTranslationResolvers_GraphQL.res.mjs";
+
+let translate = InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.translate;
+
+let moduleUrl = InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.moduleUrl;
+
+let PaymentWebhookTranslation = {
+  translate: translate,
+  moduleUrl: moduleUrl
+};
+
+let Callback = InboundTranslationSlice_Callback$ReventlessCore.Make({
+  name: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.name,
+  moduleUrl: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.moduleUrl,
+  externalInputSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalInputSchema,
+  commandSchema: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandSchema,
+  targetName: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.targetName,
+  externalSystem: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalSystem,
+  commandAuthorization: InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.commandAuthorization
+})(PaymentWebhookTranslation);
+
+let scope = "Payments";
+
+let fieldName = "Payments_PaymentWebhook";
+
+let published = {
+  contents: []
+};
+
+async function publishJsons(cmds) {
+  published.contents = published.contents.concat(cmds);
+}
+
+let selection = `__typename
+  ... on CommandAccepted { msgId entityId eventCount }
+  ... on CommandRejected { msgId errorCode errorDetail }`;
+
+async function runMutation(status) {
+  let source = `mutation {
+    r: ` + fieldName + `(paymentId: "pay-1", orderId: "ord-1", status: "` + status + `") { ` + selection + ` }
+  }`;
+  return await Graphql.graphql({
+    schema: DomainGraphQL_Server$ReventlessLocal.composeSchema(),
+    source: source,
+    contextValue: null
+  });
+}
+
+function errorMessages(result) {
+  return Stdlib_Option.getOr(result.errors, []).map(e => Stdlib_Option.getOr(Stdlib_JsExn.message(e), "unknown error"));
+}
+
+function payload(result) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(Stdlib_Option.getOr(result.data, null)), d => d["r"]), null);
+}
+
+function str(node, key) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(node), d => d[key]), Stdlib_JSON.Decode.string);
+}
+
+function num(node, key) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(node), d => d[key]), Stdlib_JSON.Decode.float);
+}
+
+globalThis.describe("InboundTranslationSlice mutation — response envelope", () => {
+  globalThis.beforeEach(() => {
+    DomainGraphQL_Server$ReventlessLocal.asInterface.reset();
+    published.contents = [];
+    Object.keys(Callback.auditLog).forEach(k => Stdlib_Dict.$$delete(Callback.auditLog, k));
+    DomainGraphQL_Server$ReventlessLocal.setScope(scope);
+    InboundTranslationResolvers_GraphQL$ReventlessLocal.register(fieldName, InboundTranslationSliceFixtures$ReventlessLocal.PaymentWebhookSpec.externalInputSchema, DomainGraphQL_Server$ReventlessLocal.asInterface);
+    DomainGraphQL_Server$ReventlessLocal.resetScope();
+    InboundTranslationResolvers_GraphQL$ReventlessLocal.bindReceive(fieldName, inputJson => Callback.receive(publishJsons, inputJson));
+  });
+  globalThis.test("a successful translation resolves as CommandAccepted, with no errors", async () => {
+    let result = await runMutation("completed");
+    globalThis.expect(errorMessages(result)).toEqual([]);
+    let node = payload(result);
+    globalThis.expect(str(node, "__typename")).toEqual("CommandAccepted");
+    globalThis.expect(str(node, "entityId")).toEqual("ord-1");
+    globalThis.expect(num(node, "eventCount")).toEqual(1.0);
+    let msgId = Stdlib_Option.getOr(str(node, "msgId"), "");
+    globalThis.expect(Stdlib_Option.isSome(Callback.auditLog[msgId])).toBe(true);
+    globalThis.expect(published.contents.length).toBe(1);
+  });
+  globalThis.test("a rejected translation resolves as CommandRejected, with no errors", async () => {
+    let result = await runMutation("pending");
+    globalThis.expect(errorMessages(result)).toEqual([]);
+    let node = payload(result);
+    globalThis.expect(str(node, "__typename")).toEqual("CommandRejected");
+    globalThis.expect(str(node, "errorCode")).toEqual("TranslationFailed");
+    globalThis.expect(str(node, "errorDetail")).toEqual("Unknown payment status: pending");
+    let msgId = Stdlib_Option.getOr(str(node, "msgId"), "");
+    let row = Callback.auditLog[msgId];
+    if (row !== undefined) {
+      globalThis.expect(row.status).toBe("Failure");
+    } else {
+      globalThis.expect(true).toBe(false);
+    }
+    globalThis.expect(published.contents.length).toBe(0);
+  });
+  globalThis.test("the mutation field is typed CommandResult!", () => {
+    let fieldLine = DomainGraphQL_Server$ReventlessLocal.asInterface.buildSdl().split("\n").find(line => line.includes(fieldName));
+    globalThis.expect(Stdlib_Option.map(fieldLine, l => l.endsWith(": CommandResult!"))).toEqual(true);
+  });
+});
+
+export {
+  PaymentWebhookTranslation,
+  Callback,
+  scope,
+  fieldName,
+  published,
+  publishJsons,
+  selection,
+  runMutation,
+  errorMessages,
+  payload,
+  str,
+  num,
+}
+/* Callback Not a pure module */

package/tests/adapter/QueryDbListResolverTest.res

@@ -35,6 +35,8 @@ let rowStateSchemaWithAnnotations =
       collapsed: [],
       scan: ["status"],
       scanSort: ["name"],
+      semantic: [],
+      metric: [],
       status: None,
       groupBy: None,
       visibility: None,

package/tests/adapter/QueryDbListResolverTest.res.mjs

@@ -43,6 +43,8 @@ let rowStateSchemaWithAnnotations = S.Metadata.set(rowStateSchema, StateAnnotati
   collapsed: [],
   scan: ["status"],
   scanSort: ["name"],
+  semantic: [],
+  metric: [],
   status: undefined,
   groupBy: undefined,
   visibility: undefined