@reventlessdev/reventless-local 3.0.0-alpha.166 → 3.0.0-alpha.168

package/src/adapter/PgProjectionCatchup.res.mjs

@@ -77,7 +77,7 @@ async function runCatchup(pool, bounds, handlers) {
       }
     }
   }
-  let dcbRows = await PgDriver$ReventlessPostgres.query(pool, "SELECT log_name, event_type, data, meta, tags FROM dcb_event WHERE position <= $1::bigint ORDER BY position ASC", [bounds.dcbBound]);
+  let dcbRows = await PgDriver$ReventlessPostgres.query(pool, "SELECT log_name, event_type, data, meta, tags, recorded_at FROM dcb_event WHERE position <= $1::bigint ORDER BY position ASC", [bounds.dcbBound]);
   for (let i$1 = 0, i_finish$1 = dcbRows.length; i$1 < i_finish$1; ++i$1) {
     let row$1 = dcbRows[i$1];
     let match = row$1["log_name"];
@@ -85,7 +85,9 @@ async function runCatchup(pool, bounds, handlers) {
     let match$2 = row$1["data"];
     let match$3 = row$1["meta"];
     if (typeof match === "string" && typeof match$1 === "string" && match$2 !== undefined && match$3 !== undefined) {
-      let envelope$1 = ProjectionCheckpoint$ReventlessLocal.dcbCatchupEnvelope(match, match$1, JSON.stringify(match$2), JSON.stringify(match$3), firstTagValue(row$1));
+      let match$4 = row$1["recorded_at"];
+      let recordedAt = typeof match$4 === "string" ? match$4 : "";
+      let envelope$1 = ProjectionCheckpoint$ReventlessLocal.dcbCatchupEnvelope(match, match$1, JSON.stringify(match$2), JSON.stringify(match$3), recordedAt, firstTagValue(row$1));
       if (envelope$1 !== undefined) {
         await deliver(handlers, envelope$1);
       }

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

@@ -84,6 +84,8 @@ let indexedStateSchemaWithAnnotations = indexedStateSchema->S.Metadata.set(
     collapsed: [],
     scan: [],
     scanSort: [],
+    semantic: [],
+    metric: [],
     status: None,
     groupBy: None,
     visibility: None,
@@ -111,6 +113,8 @@ let orderedStateSchemaWithAnnotations = orderedStateSchema->S.Metadata.set(
     collapsed: [],
     scan: [],
     scanSort: [],
+    semantic: [],
+    metric: [],
     status: None,
     groupBy: None,
     visibility: None,
@@ -139,6 +143,8 @@ let scanStateSchemaWithAnnotations = scanStateSchema->S.Metadata.set(
     collapsed: [],
     scan: ["status"],
     scanSort: ["name"],
+    semantic: [],
+    metric: [],
     status: None,
     groupBy: None,
     visibility: None,

package/tests/adapter/GraphQL_SchemaInspectorTest.res.mjs

@@ -95,6 +95,8 @@ let indexedStateSchemaWithAnnotations = S.Metadata.set(indexedStateSchema, State
   collapsed: [],
   scan: [],
   scanSort: [],
+  semantic: [],
+  metric: [],
   status: undefined,
   groupBy: undefined,
   visibility: undefined
@@ -119,6 +121,8 @@ let orderedStateSchemaWithAnnotations = S.Metadata.set(orderedStateSchema, State
   collapsed: [],
   scan: [],
   scanSort: [],
+  semantic: [],
+  metric: [],
   status: undefined,
   groupBy: undefined,
   visibility: undefined
@@ -144,6 +148,8 @@ let scanStateSchemaWithAnnotations = S.Metadata.set(scanStateSchema, StateAnnota
   collapsed: [],
   scan: ["status"],
   scanSort: ["name"],
+  semantic: [],
+  metric: [],
   status: undefined,
   groupBy: undefined,
   visibility: undefined

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

package/tests/adapter/ServedBucketHttpTest.res

@@ -0,0 +1,174 @@
+// End-to-end test for the local served-bucket HTTP routes on DomainGraphQL_Server
+// (the dev analogue of the AWS CloudFront read path). Boots a real server on a
+// private port, then exercises the full upload → store → serve loop:
+//   POST /__inmemory/upload → {uploadUrl, storageRef}
+//   PUT  /{prefix}/{key}    → 200 (store)
+//   GET  /{prefix}/{key}    → the stored bytes + content-type
+// Talks to the server over node:http (Jest 27's VM strips global fetch), same
+// as LocalAuthHttpTest.
+
+@@warning("-44")
+
+open JestGlobals
+
+let _ = TestRunner.setup()
+
+// High ephemeral port, clear of dev-server defaults and the auth HTTP test.
+let port = 49322
+
+// ── Minimal node:http helpers ───────────────────────────────────────────────
+
+type httpRequestOptions = {
+  hostname: string,
+  port: int,
+  path: string,
+  method: string,
+  headers: dict<string>,
+}
+type httpReq
+type httpRes
+@module("node:http") external _request: (httpRequestOptions, httpRes => unit) => httpReq = "request"
+@send external _reqWrite: (httpReq, string) => unit = "write"
+@send external _reqEnd: (httpReq, @as(json`null`) _) => unit = "end"
+@send external _reqOnError: (httpReq, @as("error") _, 'err => unit) => unit = "on"
+@send external _resOnData: (httpRes, @as("data") _, 'chunk => unit) => unit = "on"
+@send external _resOnEnd: (httpRes, @as("end") _, unit => unit) => unit = "on"
+@send external _resSetEncoding: (httpRes, string) => unit = "setEncoding"
+@get external _resStatusCode: httpRes => int = "statusCode"
+@get external _resHeaders: httpRes => dict<string> = "headers"
+
+let postJson = (path: string, body: dict<JSON.t>): promise<(int, JSON.t)> =>
+  Promise.make((resolve, reject) => {
+    let bodyStr = body->JSON.Encode.object->JSON.stringify
+    let req =
+      _request(
+        {
+          hostname: "localhost",
+          port,
+          path,
+          method: "POST",
+          headers: Dict.fromArray([
+            ("content-type", "application/json"),
+            ("content-length", bodyStr->String.length->Int.toString),
+          ]),
+        },
+        res => {
+          let status = _resStatusCode(res)
+          let buf = ref("")
+          res->_resSetEncoding("utf8")
+          res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
+          res->_resOnEnd(() => {
+            let parsed = try buf.contents->JSON.parseOrThrow catch {
+            | _ => JSON.Encode.null
+            }
+            resolve((status, parsed))
+          })
+        },
+      )
+    req->_reqOnError(err => reject(Obj.magic(err)))
+    req->_reqWrite(bodyStr)
+    req->_reqEnd
+  })
+
+// PUT a raw (ASCII) body to a served-object path. Content-length is byte-safe
+// only for ASCII payloads, which the SVG fixture below is.
+let putRaw = (path: string, body: string, ~contentType: string): promise<int> =>
+  Promise.make((resolve, reject) => {
+    let req =
+      _request(
+        {
+          hostname: "localhost",
+          port,
+          path,
+          method: "PUT",
+          headers: Dict.fromArray([
+            ("content-type", contentType),
+            ("content-length", body->String.length->Int.toString),
+          ]),
+        },
+        res => {
+          let status = _resStatusCode(res)
+          res->_resOnData(_ => ())
+          res->_resOnEnd(() => resolve(status))
+        },
+      )
+    req->_reqOnError(err => reject(Obj.magic(err)))
+    req->_reqWrite(body)
+    req->_reqEnd
+  })
+
+let getRaw = (path: string): promise<(int, string, string)> =>
+  Promise.make((resolve, reject) => {
+    let req =
+      _request(
+        {hostname: "localhost", port, path, method: "GET", headers: Dict.make()},
+        res => {
+          let status = _resStatusCode(res)
+          let contentType = _resHeaders(res)->Dict.get("content-type")->Option.getOr("")
+          let buf = ref("")
+          res->_resSetEncoding("utf8")
+          res->_resOnData(chunk => buf := buf.contents ++ Obj.magic(chunk))
+          res->_resOnEnd(() => resolve((status, buf.contents, contentType)))
+        },
+      )
+    req->_reqOnError(err => reject(Obj.magic(err)))
+    req->_reqEnd
+  })
+
+let getString = (j: JSON.t, k: string): string =>
+  j->JSON.Decode.object->Option.flatMap(d => d->Dict.get(k))->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+
+// ── Lifecycle ────────────────────────────────────────────────────────────────
+
+beforeAllAsync(async () => {
+  DomainGraphQL_Server.reset()
+  DomainGraphQL_Server.start(~port, ())
+  await Promise.make((resolve, _) => setTimeout(() => resolve(), 50)->ignore)
+})
+
+afterAll(() => {
+  DomainGraphQL_Server.stop()
+})
+
+// ── Tests ──────────────────────────────────────────────────────────────────
+
+testPromise("POST /__inmemory/upload returns matching uploadUrl + storageRef under the prefix", async () => {
+  let (status, body) =
+    await postJson(
+      "/__inmemory/upload",
+      Dict.fromArray([
+        ("fileName", JSON.Encode.string("logo.svg")),
+        ("contentType", JSON.Encode.string("image/svg+xml")),
+      ]),
+    )
+  expect(status)->toEqual(200)
+  let uploadUrl = getString(body, "uploadUrl")
+  let storageRef = getString(body, "storageRef")
+  // Same same-origin ref serves as both the PUT target and the stored value.
+  expect(uploadUrl)->toEqual(storageRef)
+  expect(storageRef->String.startsWith("/uploads/"))->toEqual(true)
+  expect(storageRef->String.endsWith("/logo.svg"))->toEqual(true)
+})
+
+testPromise("PUT then GET round-trips the bytes and content-type", async () => {
+  let (_, body) =
+    await postJson(
+      "/__inmemory/upload",
+      Dict.fromArray([("fileName", JSON.Encode.string("pixel.svg"))]),
+    )
+  let ref = getString(body, "storageRef")
+  let svg = "<svg xmlns='http://www.w3.org/2000/svg' width='1' height='1'></svg>"
+
+  let putStatus = await putRaw(ref, svg, ~contentType="image/svg+xml")
+  expect(putStatus)->toEqual(200)
+
+  let (getStatus, gotBody, gotContentType) = await getRaw(ref)
+  expect(getStatus)->toEqual(200)
+  expect(gotBody)->toEqual(svg)
+  expect(gotContentType)->toEqual("image/svg+xml")
+})
+
+testPromise("GET a missing served object returns 404", async () => {
+  let (status, _, _) = await getRaw("/uploads/missing/none.svg")
+  expect(status)->toEqual(404)
+})