@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/tests/OutboundTranslationGwtTest.res.mjs

@@ -0,0 +1,138 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as OutboundTranslation_GWT$ReventlessGwt from "../src/OutboundTranslation_GWT.res.mjs";
+
+let consumedEventSchema = S.schema(s => ({
+  TAG: "OrderShipped",
+  orderId: s.m(S.string),
+  email: s.m(S.string)
+}));
+
+let outboundItemSchema = S.schema(s => ({
+  orderId: s.m(S.string),
+  email: s.m(S.string)
+}));
+
+let inboundCommandSchema = S.literal("NoOp");
+
+function collect(event) {
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId,
+        email: event.email
+      }
+    ]];
+}
+
+let SendTrackingEmailSlice = {
+  name: "SendTrackingEmail",
+  consumedEventSchema: consumedEventSchema,
+  outboundItemSchema: outboundItemSchema,
+  inboundCommandSchema: inboundCommandSchema,
+  collect: collect
+};
+
+let include = OutboundTranslation_GWT$ReventlessGwt.Make(SendTrackingEmailSlice);
+
+let describe = include.describe;
+
+let test = include.test;
+
+let givenEvent = include.givenEvent;
+
+let whenCollect = include.whenCollect;
+
+let thenTodos = include.thenTodos;
+
+let givenTodo = include.givenTodo;
+
+let whenTranslateMocked = include.whenTranslateMocked;
+
+let whenTranslateRetrying = include.whenTranslateRetrying;
+
+let thenRetryRecorded = include.thenRetryRecorded;
+
+let thenTodoStatus = include.thenTodoStatus;
+
+describe("SendTrackingEmail OutboundTranslationSlice", () => {
+  test("collect: OrderShipped queues an outbound TODO", undefined, async () => thenTodos(whenCollect(givenEvent({
+    TAG: "OrderShipped",
+    orderId: "o1",
+    email: "x@y"
+  })), [[
+      "o1",
+      {
+        orderId: "o1",
+        email: "x@y"
+      }
+    ]]));
+  test("translate success is fire-and-forget → #Completed", undefined, () => thenTodoStatus(whenTranslateMocked(givenTodo("o1", {
+    orderId: "o1",
+    email: "x@y"
+  }), (_id, _item) => Promise.resolve({
+    TAG: "Ok",
+    _0: undefined
+  })), "o1", "Completed"));
+  test("translate failure records a retry → #Pending", undefined, () => thenTodoStatus(whenTranslateMocked(givenTodo("o1", {
+    orderId: "o1",
+    email: "x@y"
+  }), (_id, _item) => Promise.resolve({
+    TAG: "Error",
+    _0: "smtp down"
+  })), "o1", "Pending"));
+  test("retrying translate succeeds on the third attempt → 2 retries recorded", undefined, () => {
+    let calls = {
+      contents: 0
+    };
+    return thenRetryRecorded(whenTranslateRetrying(givenTodo("o1", {
+      orderId: "o1",
+      email: "x@y"
+    }), 3, (_id, _item) => {
+      calls.contents = calls.contents + 1 | 0;
+      return Promise.resolve(calls.contents < 3 ? ({
+          TAG: "Error",
+          _0: "smtp down"
+        }) : ({
+          TAG: "Ok",
+          _0: undefined
+        }));
+    }), 2);
+  });
+  test("translate that keeps failing exhausts maxRetries", undefined, () => thenRetryRecorded(whenTranslateRetrying(givenTodo("o1", {
+    orderId: "o1",
+    email: "x@y"
+  }), 3, (_id, _item) => Promise.resolve({
+    TAG: "Error",
+    _0: "smtp down"
+  })), 3));
+});
+
+let Spec = include.Spec;
+
+let testSync = include.testSync;
+
+let thenCommand = include.thenCommand;
+
+let thenNoCommand = include.thenNoCommand;
+
+export {
+  SendTrackingEmailSlice,
+  Spec,
+  describe,
+  test,
+  testSync,
+  givenEvent,
+  whenCollect,
+  thenTodos,
+  givenTodo,
+  whenTranslateMocked,
+  whenTranslateRetrying,
+  thenCommand,
+  thenNoCommand,
+  thenRetryRecorded,
+  thenTodoStatus,
+}
+/* consumedEventSchema Not a pure module */

package/tests/PlatformRunnerTest.res

@@ -0,0 +1,66 @@
+// Unit tests for PlatformRunner.classifyLine — the pure line classifier that turns
+// the spawned reventless-local platform's stdout into structured runner events
+// (features plan Phase 9). The tap emits sentinel-prefixed JSON; the Domain
+// GraphQL "listening" line marks readiness; everything else is a passthrough log.
+
+open JestGlobals
+
+describe("PlatformRunner.classifyLine", () => {
+  testPromise("classifies a tap line as Domain with the parsed payload", async () => {
+    let line =
+      `@@RVLESS_EVT@@ {"event":"domainEvent","seq":1,"topic":"CatalogEventTopic","service":"CatalogDcbEventLog","payload":{"event":{"TAG":"ProductAdded"}},"ts":"2026-06-07T00:00:00.000Z"}`
+    switch PlatformRunner.classifyLine(line) {
+    | Domain(json) =>
+      let topic =
+        json
+        ->JSON.Decode.object
+        ->Option.flatMap(d => d->Dict.get("topic"))
+        ->Option.flatMap(JSON.Decode.string)
+      expect(topic)->toEqual(Some("CatalogEventTopic"))
+    | _ => expect("not Domain")->toEqual("Domain")
+    }
+  })
+
+  testPromise("a malformed tap line falls back to Log (never throws)", async () => {
+    switch PlatformRunner.classifyLine("@@RVLESS_EVT@@ {not json") {
+    | Log(_) => expect(true)->toBe(true)
+    | _ => expect("not Log")->toEqual("Log")
+    }
+  })
+
+  testPromise("classifies the Domain GraphQL listening line as Ready", async () => {
+    // Real platform output carries ANSI escapes around the [GraphQL:Domain] tag;
+    // the substring checks see through them.
+    let line = `12:00:00 I [GraphQL:Domain] listening on http://localhost:4100/graphql (SDL: /sdl)`
+    switch PlatformRunner.classifyLine(line) {
+    | Ready => expect(true)->toBe(true)
+    | _ => expect("not Ready")->toEqual("Ready")
+    }
+  })
+
+  testPromise("the Platform (not Domain) listening line is NOT Ready", async () => {
+    let line = `12:00:00 I [GraphQL:Platform] listening on http://localhost:4101/graphql`
+    switch PlatformRunner.classifyLine(line) {
+    | Log(_) => expect(true)->toBe(true)
+    | _ => expect("expected Log")->toEqual("Log")
+    }
+  })
+
+  testPromise("an arbitrary log line is Log", async () => {
+    switch PlatformRunner.classifyLine("12:00:00 I [Catalog][Aggregate(Product)] handling command") {
+    | Log(_) => expect(true)->toBe(true)
+    | _ => expect("expected Log")->toEqual("Log")
+    }
+  })
+
+  testPromise("a Log line preserves its ANSI colour/bold escapes (rendered in the terminal)", async () => {
+    // The child emits coloured logs; the Log payload keeps the ANSI so the
+    // extension's Pseudoterminal renders colour/bold. Build real ESC (0x1b) bytes.
+    let esc = String.fromCharCode(27)
+    let line = `12:00:00 ${esc}[36mI${esc}[0m ${esc}[1m[Catalog]${esc}[0m handling command`
+    switch PlatformRunner.classifyLine(line) {
+    | Log(raw) => expect(raw)->toEqual(line)
+    | _ => expect("expected Log")->toEqual("Log")
+    }
+  })
+})

package/tests/PlatformRunnerTest.res.mjs

@@ -0,0 +1,85 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as PlatformRunner$ReventlessGwt from "../src/PlatformRunner.res.mjs";
+
+globalThis.describe("PlatformRunner.classifyLine", () => {
+  globalThis.test("classifies a tap line as Domain with the parsed payload", async () => {
+    let json = PlatformRunner$ReventlessGwt.classifyLine(`@@RVLESS_EVT@@ {"event":"domainEvent","seq":1,"topic":"CatalogEventTopic","service":"CatalogDcbEventLog","payload":{"event":{"TAG":"ProductAdded"}},"ts":"2026-06-07T00:00:00.000Z"}`);
+    if (typeof json !== "object") {
+      globalThis.expect("not Domain").toEqual("Domain");
+      return;
+    }
+    if (json.TAG === "Domain") {
+      let topic = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json._0), d => d["topic"]), Stdlib_JSON.Decode.string);
+      globalThis.expect(topic).toEqual("CatalogEventTopic");
+      return;
+    }
+    globalThis.expect("not Domain").toEqual("Domain");
+  });
+  globalThis.test("a malformed tap line falls back to Log (never throws)", async () => {
+    let match = PlatformRunner$ReventlessGwt.classifyLine("@@RVLESS_EVT@@ {not json");
+    if (typeof match !== "object") {
+      globalThis.expect("not Log").toEqual("Log");
+      return;
+    }
+    if (match.TAG === "Domain") {
+      globalThis.expect("not Log").toEqual("Log");
+      return;
+    }
+    globalThis.expect(true).toBe(true);
+  });
+  globalThis.test("classifies the Domain GraphQL listening line as Ready", async () => {
+    let match = PlatformRunner$ReventlessGwt.classifyLine(`12:00:00 I [GraphQL:Domain] listening on http://localhost:4100/graphql (SDL: /sdl)`);
+    if (typeof match !== "object") {
+      globalThis.expect(true).toBe(true);
+      return;
+    }
+    if (match.TAG === "Domain") {
+      globalThis.expect("not Ready").toEqual("Ready");
+      return;
+    }
+    globalThis.expect("not Ready").toEqual("Ready");
+  });
+  globalThis.test("the Platform (not Domain) listening line is NOT Ready", async () => {
+    let match = PlatformRunner$ReventlessGwt.classifyLine(`12:00:00 I [GraphQL:Platform] listening on http://localhost:4101/graphql`);
+    if (typeof match !== "object") {
+      globalThis.expect("expected Log").toEqual("Log");
+      return;
+    }
+    if (match.TAG === "Domain") {
+      globalThis.expect("expected Log").toEqual("Log");
+      return;
+    }
+    globalThis.expect(true).toBe(true);
+  });
+  globalThis.test("an arbitrary log line is Log", async () => {
+    let match = PlatformRunner$ReventlessGwt.classifyLine("12:00:00 I [Catalog][Aggregate(Product)] handling command");
+    if (typeof match !== "object") {
+      globalThis.expect("expected Log").toEqual("Log");
+      return;
+    }
+    if (match.TAG === "Domain") {
+      globalThis.expect("expected Log").toEqual("Log");
+      return;
+    }
+    globalThis.expect(true).toBe(true);
+  });
+  globalThis.test("a Log line preserves its ANSI colour/bold escapes (rendered in the terminal)", async () => {
+    let esc = String.fromCharCode(27);
+    let line = `12:00:00 ` + esc + `[36mI` + esc + `[0m ` + esc + `[1m[Catalog]` + esc + `[0m handling command`;
+    let raw = PlatformRunner$ReventlessGwt.classifyLine(line);
+    if (typeof raw !== "object") {
+      globalThis.expect("expected Log").toEqual("Log");
+      return;
+    }
+    if (raw.TAG === "Domain") {
+      globalThis.expect("expected Log").toEqual("Log");
+      return;
+    }
+    globalThis.expect(raw._0).toEqual(line);
+  });
+});
+
+/*  Not a pure module */

package/tests/PlatformScanTest.res

@@ -0,0 +1,61 @@
+// Unit tests for PlatformScan.matchPlatform — the pure predicate deciding whether
+// a package.json + presence of src/Main.res.mjs make a launchable reventless-local
+// platform package, and which serve script to prefer (features plan Phase 9).
+
+open JestGlobals
+
+let pkgJson = (~deps=`{}`, ~scripts=`{}`) =>
+  `{"name":"@app/platform-local","dependencies":${deps},"scripts":${scripts}}`
+
+describe("PlatformScan.matchPlatform", () => {
+  testPromise("matches when it depends on reventless-local and Main.res.mjs exists", async () => {
+    let text = pkgJson(~deps=`{"@reventlessdev/reventless-local":"workspace:*"}`)
+    switch PlatformScan.matchPlatform(~pkgJsonText=text, ~mainExists=true) {
+    | Some((name, _)) => expect(name)->toEqual("@app/platform-local")
+    | None => expect("None")->toEqual("Some")
+    }
+  })
+
+  testPromise("no match when src/Main.res.mjs is absent", async () => {
+    let text = pkgJson(~deps=`{"@reventlessdev/reventless-local":"workspace:*"}`)
+    expect(PlatformScan.matchPlatform(~pkgJsonText=text, ~mainExists=false)->Option.isNone)->toBe(
+      true,
+    )
+  })
+
+  testPromise("no match without the reventless-local dependency", async () => {
+    let text = pkgJson(~deps=`{"sury":"^11"}`)
+    expect(PlatformScan.matchPlatform(~pkgJsonText=text, ~mainExists=true)->Option.isNone)->toBe(
+      true,
+    )
+  })
+
+  testPromise("prefers the serve:memory script over serve", async () => {
+    let text = pkgJson(
+      ~deps=`{"@reventlessdev/reventless-local":"workspace:*"}`,
+      ~scripts=`{"serve":"tsx Main","serve:memory":"REVENTLESS_LOCAL_BACKEND=memory tsx Main"}`,
+    )
+    switch PlatformScan.matchPlatform(~pkgJsonText=text, ~mainExists=true) {
+    | Some((_, serveScript)) => expect(serveScript)->toEqual(Some("serve:memory"))
+    | None => expect("None")->toEqual("Some")
+    }
+  })
+
+  testPromise("falls back to serve when serve:memory is absent", async () => {
+    let text = pkgJson(
+      ~deps=`{"@reventlessdev/reventless-local":"workspace:*"}`,
+      ~scripts=`{"serve":"tsx Main"}`,
+    )
+    switch PlatformScan.matchPlatform(~pkgJsonText=text, ~mainExists=true) {
+    | Some((_, serveScript)) => expect(serveScript)->toEqual(Some("serve"))
+    | None => expect("None")->toEqual("Some")
+    }
+  })
+
+  testPromise("matches via devDependencies too", async () => {
+    let text = `{"name":"p","devDependencies":{"@reventlessdev/reventless-local":"*"}}`
+    expect(PlatformScan.matchPlatform(~pkgJsonText=text, ~mainExists=true)->Option.isSome)->toBe(
+      true,
+    )
+  })
+})

package/tests/PlatformScanTest.res.mjs

@@ -0,0 +1,56 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as PlatformScan$ReventlessGwt from "../src/PlatformScan.res.mjs";
+
+function pkgJson(depsOpt, scriptsOpt) {
+  let deps = depsOpt !== undefined ? depsOpt : `{}`;
+  let scripts = scriptsOpt !== undefined ? scriptsOpt : `{}`;
+  return `{"name":"@app/platform-local","dependencies":` + deps + `,"scripts":` + scripts + `}`;
+}
+
+globalThis.describe("PlatformScan.matchPlatform", () => {
+  globalThis.test("matches when it depends on reventless-local and Main.res.mjs exists", async () => {
+    let text = pkgJson(`{"@reventlessdev/reventless-local":"workspace:*"}`, undefined);
+    let match = PlatformScan$ReventlessGwt.matchPlatform(text, true);
+    if (match !== undefined) {
+      globalThis.expect(match[0]).toEqual("@app/platform-local");
+    } else {
+      globalThis.expect("None").toEqual("Some");
+    }
+  });
+  globalThis.test("no match when src/Main.res.mjs is absent", async () => {
+    let text = pkgJson(`{"@reventlessdev/reventless-local":"workspace:*"}`, undefined);
+    globalThis.expect(Stdlib_Option.isNone(PlatformScan$ReventlessGwt.matchPlatform(text, false))).toBe(true);
+  });
+  globalThis.test("no match without the reventless-local dependency", async () => {
+    let text = pkgJson(`{"sury":"^11"}`, undefined);
+    globalThis.expect(Stdlib_Option.isNone(PlatformScan$ReventlessGwt.matchPlatform(text, true))).toBe(true);
+  });
+  globalThis.test("prefers the serve:memory script over serve", async () => {
+    let text = pkgJson(`{"@reventlessdev/reventless-local":"workspace:*"}`, `{"serve":"tsx Main","serve:memory":"REVENTLESS_LOCAL_BACKEND=memory tsx Main"}`);
+    let match = PlatformScan$ReventlessGwt.matchPlatform(text, true);
+    if (match !== undefined) {
+      globalThis.expect(match[1]).toEqual("serve:memory");
+    } else {
+      globalThis.expect("None").toEqual("Some");
+    }
+  });
+  globalThis.test("falls back to serve when serve:memory is absent", async () => {
+    let text = pkgJson(`{"@reventlessdev/reventless-local":"workspace:*"}`, `{"serve":"tsx Main"}`);
+    let match = PlatformScan$ReventlessGwt.matchPlatform(text, true);
+    if (match !== undefined) {
+      globalThis.expect(match[1]).toEqual("serve");
+    } else {
+      globalThis.expect("None").toEqual("Some");
+    }
+  });
+  globalThis.test("matches via devDependencies too", async () => {
+    globalThis.expect(Stdlib_Option.isSome(PlatformScan$ReventlessGwt.matchPlatform(`{"name":"p","devDependencies":{"@reventlessdev/reventless-local":"*"}}`, true))).toBe(true);
+  });
+});
+
+export {
+  pkgJson,
+}
+/*  Not a pure module */

package/tests/QueryGwtTest.res

@@ -0,0 +1,161 @@
+// Worked examples for Query_GWT — covers both a ReadModel and a StateViewSlice
+// to prove the unified DSL works for either consumer type. Stage 6 of
+// `docs/plans/reventless-gwt.md`.
+
+S.enableJson()
+
+// ---------------------------------------------------------------------------
+// Case 1 — ReadModel: Categories.
+// ---------------------------------------------------------------------------
+
+module CategoriesReadModel = {
+  module Id = Reventless.Id.StringPure
+  let name = "Categories"
+  let moduleUrl = ""
+
+  @schema
+  type state = {categoryId: string, name: string, archived: bool}
+
+  let config = Reventless.ReadModel.config(
+    ~indexes=[
+      {
+        index: "byName",
+        type_: "S",
+        idField: "name",
+        projectionType: ALL,
+      },
+    ],
+  )
+  let subIdConfig = None
+}
+
+module CategoriesQuery = Query_GWT.Make(Query_GWT.FromReadModel(CategoriesReadModel))
+
+CategoriesQuery.describe("Categories ReadModel queries", () => {
+  CategoriesQuery.test("primary-id lookup returns the row", () =>
+    CategoriesQuery.givenStore([
+      ("c1", {categoryId: "c1", name: "Electronics", archived: false}),
+      ("c2", {categoryId: "c2", name: "Books", archived: true}),
+    ])
+    ->CategoriesQuery.whenQueryById("c1")
+    ->CategoriesQuery.thenRow(Some({categoryId: "c1", name: "Electronics", archived: false}))
+  )
+
+  CategoriesQuery.test("by-name (GSI) returns matching rows", () =>
+    CategoriesQuery.givenStore([
+      ("c1", {categoryId: "c1", name: "Electronics", archived: false}),
+      ("c2", {categoryId: "c2", name: "Books", archived: true}),
+    ])
+    ->CategoriesQuery.whenQuery({by: "name", value: "Electronics", index: "byName"})
+    ->CategoriesQuery.thenRows([{categoryId: "c1", name: "Electronics", archived: false}])
+  )
+
+  CategoriesQuery.test("missing index produces QueryRowsMismatch", () => {
+    let outcome =
+      CategoriesQuery.givenStore([
+        ("c1", {categoryId: "c1", name: "Electronics", archived: false}),
+      ])
+      ->CategoriesQuery.whenQuery({by: "name", value: "Electronics", index: "byArchived"})
+      ->CategoriesQuery.thenRows([])
+    switch outcome {
+    | Error(QueryRowsMismatch(_)) => Outcome.pass
+    | Error(other) =>
+      Outcome.fail(
+        Throw({error: "expected QueryRowsMismatch, got: " ++ Outcome.kindName(other), stack: ""}),
+      )
+    | Ok() => Outcome.fail(Throw({error: "expected failure, got pass", stack: ""}))
+    }
+  })
+
+  CategoriesQuery.test("filter narrows results after the index scan", () =>
+    CategoriesQuery.givenStore([
+      ("c1", {categoryId: "c1", name: "Books", archived: false}),
+      ("c2", {categoryId: "c2", name: "Books", archived: true}),
+    ])
+    ->CategoriesQuery.whenQuery({
+      by: "name",
+      value: "Books",
+      index: "byName",
+      filter: r => !r.archived,
+    })
+    ->CategoriesQuery.thenRows([{categoryId: "c1", name: "Books", archived: false}])
+  )
+
+  CategoriesQuery.test("limit truncates results and thenRowCount verifies", () =>
+    CategoriesQuery.givenStore(
+      Array.fromInitializer(~length=10, i => {
+        let id = "c" ++ i->Int.toString
+        let state: CategoriesReadModel.state = {categoryId: id, name: "Books", archived: false}
+        (id, state)
+      }),
+    )
+    ->CategoriesQuery.whenQuery({by: "name", value: "Books", index: "byName", limit: 3})
+    ->CategoriesQuery.thenRowCount(3)
+  )
+
+  CategoriesQuery.test("composite-id lookup without subIdConfig fails", () => {
+    let outcome =
+      CategoriesQuery.givenStore([])
+      ->CategoriesQuery.whenQueryByCompositeId({id: "c1", subId: "v1"})
+      ->CategoriesQuery.thenRowFromComposite(None)
+    switch outcome {
+    | Error(QueryRowsMismatch(_)) => Outcome.pass
+    | Error(other) =>
+      Outcome.fail(
+        Throw({error: "expected QueryRowsMismatch, got: " ++ Outcome.kindName(other), stack: ""}),
+      )
+    | Ok() => Outcome.fail(Throw({error: "expected failure, got pass", stack: ""}))
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Case 2 — StateViewSlice: Orders-by-customer, composite key (id=orderId, subId=customerId).
+// ---------------------------------------------------------------------------
+
+module OrdersView = {
+  let name = "OrdersView"
+  let moduleUrl = ""
+
+  @schema
+  type state = {orderId: string, customerId: string, total: int}
+
+  @schema
+  type consumedEvent = OrderPlaced({orderId: string, customerId: string, total: int})
+
+  let project = event =>
+    switch event {
+    | OrderPlaced({orderId, customerId, total}) => [
+        Reventless.Projection.Set(orderId, {orderId, customerId, total}),
+      ]
+    }
+
+  let config = Reventless.ReadModel.config()
+  let subIdConfig = Some({
+    Reventless.ReadModel.subIdField: "customerId",
+    getSubId: (s: state) => s.customerId,
+  })
+}
+
+module OrdersQuery = Query_GWT.Make(Query_GWT.FromStateViewSlice(OrdersView))
+
+OrdersQuery.describe("OrdersView StateViewSlice queries", () => {
+  OrdersQuery.test("composite-id lookup returns the row", () =>
+    OrdersQuery.givenCompositeStore([
+      ("ord-1", "cust-a", {orderId: "ord-1", customerId: "cust-a", total: 100}),
+      ("ord-2", "cust-b", {orderId: "ord-2", customerId: "cust-b", total: 200}),
+    ])
+    ->OrdersQuery.whenQueryByCompositeId({id: "ord-1", subId: "cust-a"})
+    ->OrdersQuery.thenRowFromComposite(
+      Some({orderId: "ord-1", customerId: "cust-a", total: 100}),
+    )
+  )
+
+  OrdersQuery.test("composite-id lookup with wrong subId returns None", () =>
+    OrdersQuery.givenCompositeStore([
+      ("ord-1", "cust-a", {orderId: "ord-1", customerId: "cust-a", total: 100}),
+    ])
+    ->OrdersQuery.whenQueryByCompositeId({id: "ord-1", subId: "cust-z"})
+    ->OrdersQuery.thenRowFromComposite(None)
+  )
+})