@reventlessdev/reventless-aws 3.0.0-alpha.177 → 3.0.0-alpha.179

package/tests/PgQueryResolver_LambdaTest.res.mjs

@@ -157,7 +157,7 @@ function ids(arr) {
 
 globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
   globalThis.test("getById returns the item (id-carrying)", async () => {
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("getById", undefined, Object.fromEntries([[
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, mkPayload("getById", undefined, Object.fromEntries([[
         "id",
         "p-2"
       ]]), undefined));
@@ -165,14 +165,14 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
     globalThis.expect(str(r, "name")).toEqual("Bravo");
   });
   globalThis.test("getById miss → null", async () => {
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("getById", undefined, Object.fromEntries([[
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, mkPayload("getById", undefined, Object.fromEntries([[
         "id",
         "absent"
       ]]), undefined));
     globalThis.expect(r).toBe(null);
   });
   globalThis.test("byIds returns matches, drops missing", async () => {
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("byIds", undefined, Object.fromEntries([[
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, mkPayload("byIds", undefined, Object.fromEntries([[
         "ids",
         [
           "p-1",
@@ -186,7 +186,7 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
     ]);
   });
   globalThis.test("index routes to indexLookup on the idField", async () => {
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("index", "byStatus", Object.fromEntries([[
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, mkPayload("index", "byStatus", Object.fromEntries([[
         "byStatus",
         "active"
       ]]), undefined));
@@ -197,13 +197,13 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
   });
   globalThis.test("list with push-down → returns the connection listPage gives", async () => {
     listPageReturn.contents = "PUSHED";
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("list", undefined, undefined, undefined));
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, mkPayload("list", undefined, undefined, undefined));
     listPageReturn.contents = undefined;
     globalThis.expect(r).toEqual("PUSHED");
   });
   globalThis.test("list without push-down → falls back to the shared spec", async () => {
     listPageReturn.contents = undefined;
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("list", undefined, undefined, undefined));
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, mkPayload("list", undefined, undefined, undefined));
     let edgeIds = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(field(r, "edges"), Stdlib_JSON.Decode.array), []), e => Stdlib_Option.flatMap(field(e, "node"), n => str(n, "id")));
     globalThis.expect(edgeIds).toEqual([
       "p-1",
@@ -212,14 +212,14 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
     ]);
   });
   globalThis.test("items with subId routes to itemsPage (id echoed)", async () => {
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, "seq", undefined), mkPayload("items", undefined, Object.fromEntries([[
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, "seq", undefined), undefined, mkPayload("items", undefined, Object.fromEntries([[
         "id",
         "p-2"
       ]]), undefined));
     globalThis.expect(str(r, "itemsFor")).toEqual("p-2");
   });
   globalThis.test("items without subId → empty connection", async () => {
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("items", undefined, Object.fromEntries([[
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, mkPayload("items", undefined, Object.fromEntries([[
         "id",
         "p-2"
       ]]), undefined));
@@ -227,14 +227,14 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
   });
   globalThis.test("authorization DenyAll → empty shape per kind", async () => {
     let b = makeBinding("DenyAll", undefined, undefined);
-    let single = await PgQueryResolver_Lambda$ReventlessAws.dispatch(b, mkPayload("getById", undefined, Object.fromEntries([[
+    let single = await PgQueryResolver_Lambda$ReventlessAws.dispatch(b, undefined, mkPayload("getById", undefined, Object.fromEntries([[
         "id",
         "p-1"
       ]]), undefined));
     globalThis.expect(single).toBe(null);
-    let list = await PgQueryResolver_Lambda$ReventlessAws.dispatch(b, mkPayload("list", undefined, undefined, undefined));
+    let list = await PgQueryResolver_Lambda$ReventlessAws.dispatch(b, undefined, mkPayload("list", undefined, undefined, undefined));
     globalThis.expect(Stdlib_Option.getOr(Stdlib_Option.flatMap(field(list, "edges"), Stdlib_JSON.Decode.array), []).length).toBe(0);
-    let byIds = await PgQueryResolver_Lambda$ReventlessAws.dispatch(b, mkPayload("byIds", undefined, Object.fromEntries([[
+    let byIds = await PgQueryResolver_Lambda$ReventlessAws.dispatch(b, undefined, mkPayload("byIds", undefined, Object.fromEntries([[
         "ids",
         []
       ]]), undefined));
@@ -245,7 +245,7 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
       TAG: "Deny",
       _0: "nope"
     }));
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("getById", undefined, Object.fromEntries([[
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, mkPayload("getById", undefined, Object.fromEntries([[
         "id",
         "p-1"
       ]]), undefined));
@@ -271,7 +271,7 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
       arguments: payload_arguments,
       identity: Identity$Reventless.anonymous
     };
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), payload);
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, payload);
     globalThis.expect(str(r, "id")).toEqual("p-2");
   });
   globalThis.test("resolveOne multi via target index → array", async () => {
@@ -297,7 +297,7 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
       arguments: payload_arguments,
       identity: Identity$Reventless.anonymous
     };
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), payload);
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, payload);
     globalThis.expect(ids(r)).toEqual([
       "p-1",
       "p-3"
@@ -324,7 +324,7 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
       arguments: payload_arguments,
       identity: Identity$Reventless.anonymous
     };
-    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), payload);
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, payload);
     globalThis.expect(ids(r)).toEqual([
       "p-1",
       "p-3"
@@ -361,10 +361,89 @@ globalThis.describe("PgQueryResolver_Lambda.dispatch", () => {
     let r = await PgQueryResolver_Lambda$ReventlessAws.handler(payload, null);
     globalThis.expect(r).toBe(null);
   });
+  let authStore = Object.fromEntries([[
+      "active",
+      Object.fromEntries([[
+          "ownerId",
+          "alice"
+        ]])
+    ]]);
+  let authOps_load = async id => ({
+    TAG: "Ok",
+    _0: Stdlib_Option.mapOr(authStore[id], [], r => [r])
+  });
+  let authOps = {
+    load: authOps_load,
+    loadStream: 0,
+    save: 0,
+    saveBatch: 0,
+    count: 0,
+    delete: 0,
+    deleteBatch: 0
+  };
+  let init = makeBinding(undefined, undefined, undefined);
+  let authBinding_pushdowns = init.pushdowns;
+  let authBinding_indexes = init.indexes;
+  let authBinding_subIdField = init.subIdField;
+  let authBinding_capability = init.capability;
+  let authBinding_labelField = init.labelField;
+  let authBinding_includeIdParam = init.includeIdParam;
+  let authBinding_authorization = init.authorization;
+  let authBinding = {
+    ops: authOps,
+    pushdowns: authBinding_pushdowns,
+    indexes: authBinding_indexes,
+    subIdField: authBinding_subIdField,
+    capability: authBinding_capability,
+    labelField: authBinding_labelField,
+    includeIdParam: authBinding_includeIdParam,
+    authorization: authBinding_authorization
+  };
+  let lookupAuth = name => {
+    if (name === "AuthTable") {
+      return authBinding;
+    }
+  };
+  let ident = (username, groups) => ({
+    userId: username,
+    username: username,
+    groups: groups,
+    provider: "InMemory"
+  });
+  let authIndexPayload = (username, groups) => ({
+    readModelName: "Things",
+    kind: "index",
+    index: "byStatus",
+    authTable: "AuthTable",
+    authGroup: "Owner",
+    arguments: Object.fromEntries([[
+        "byStatus",
+        "active"
+      ]]),
+    identity: ident(username, groups)
+  });
+  globalThis.test("auth index: group member who owns → results", async () => {
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), lookupAuth, authIndexPayload("alice", ["Owner"]));
+    globalThis.expect(ids(r)).toEqual([
+      "p-1",
+      "p-3"
+    ]);
+  });
+  globalThis.test("auth index: group member who does NOT own → empty", async () => {
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), lookupAuth, authIndexPayload("bob", ["Owner"]));
+    globalThis.expect(Stdlib_Option.getOr(Stdlib_JSON.Decode.array(r), []).length).toBe(0);
+  });
+  globalThis.test("auth index: non-member passes through → results", async () => {
+    let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), lookupAuth, authIndexPayload("bob", []));
+    globalThis.expect(ids(r)).toEqual([
+      "p-1",
+      "p-3"
+    ]);
+  });
   globalThis.test("unmapped kind throws", async () => {
     let threw;
     try {
-      await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), mkPayload("frobnicate", undefined, undefined, undefined));
+      await PgQueryResolver_Lambda$ReventlessAws.dispatch(makeBinding(undefined, undefined, undefined), undefined, mkPayload("frobnicate", undefined, undefined, undefined));
       threw = false;
     } catch (exn) {
       threw = true;

package/tests/StateTopicPublishTest.res

@@ -0,0 +1,162 @@
+// Unit tests for the Postgres live-update publisher (B3.3a).
+//
+// `withLiveUpdates` wraps a Postgres QueryDb ops set so save/delete also publish
+// an AppSync-Events change descriptor. The publish itself (SigV4 POST) is
+// injected here as a capturing stub, so this exercises the WRAPPING logic
+// headlessly — entity-key composition, changeKind, sortKeyValue extraction, the
+// `option<(field,subValue)>` delete signature, and composite partition-wide
+// delete enumeration via ops.load. The real SigV4/channel wire format matches
+// StateTopic_AppSync (the DynamoDB path) by construction and is not re-asserted
+// here.
+
+open JestGlobals
+
+// Drive a scenario against withLiveUpdates with a mock ops + capturing publish,
+// entirely in JS (the mock ops are plain JS objects). Returns the captured
+// publish-call array as JSON for assertions.
+let run: string => promise<JSON.t> = %raw(`
+async function(scenario) {
+  const mod = await import("../src/adapter/Runtime/StateTopicPublish.mjs");
+  const { withLiveUpdates } = mod;
+  const captured = [];
+  const publish = async (call) => { captured.push(call); };
+  const ok = async () => ({ TAG: "Ok", _0: undefined });
+
+  // Mock ops. load returns the composite partition's rows for the enumerate case.
+  const partitionRows = { TAG: "Ok", _0: [
+    { id: "o1", lineId: "L1" },
+    { id: "o1", lineId: "L2" },
+  ]};
+  const ops = {
+    load: async (id) => partitionRows,
+    loadStream: () => {},
+    save: ok, saveBatch: ok, count: ok, delete: ok, deleteBatch: ok,
+  };
+
+  const cfg = (subIdField) => ({
+    endpoint: "https://x.appsync-api.eu-west-1.amazonaws.com",
+    region: "eu-west-1",
+    topicName: "Shop_Orders",
+    subIdField,
+    publish,
+  });
+
+  const w = (subIdField) => withLiveUpdates(ops, cfg(subIdField));
+
+  switch (scenario) {
+    case "save-single":
+      await w(undefined).save("p1", { id: "p1", updatedAt: "2024-01-02" }, "Insert", undefined);
+      break;
+    case "save-composite":
+      await w("lineId").save("o1", { id: "o1", lineId: "L2", createdAt: "2024-03-04" }, "Insert", undefined);
+      break;
+    case "save-no-sortkey":
+      await w(undefined).save("p1", { id: "p1" }, "Insert", undefined);
+      break;
+    case "saveBatch":
+      await w(undefined).saveBatch([
+        ["a", { id: "a", updatedAt: "t1" }, undefined],
+        ["b", { id: "b", updatedAt: "t2" }, undefined],
+      ]);
+      break;
+    case "delete-single":
+      await w(undefined).delete("p1", undefined);
+      break;
+    case "delete-composite-row":
+      await w("lineId").delete("o1", ["lineId", "L2"]);
+      break;
+    case "delete-composite-partition":
+      await w("lineId").delete("o1", undefined);
+      break;
+    case "deleteBatch":
+      await w(undefined).deleteBatch([["a", undefined], ["b", undefined]]);
+      break;
+    case "gated-no-topic": {
+      const gatedOps = withLiveUpdates(ops, { endpoint: "https://x", region: "r", topicName: undefined, publish });
+      await gatedOps.save("p1", { id: "p1" }, "Insert", undefined);
+      break;
+    }
+  }
+  return captured;
+}
+`)
+
+let getField = (call: JSON.t, key: string): option<JSON.t> =>
+  call->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))
+
+let str = (call, key) => getField(call, key)->Option.flatMap(JSON.Decode.string)
+
+let calls = (j: JSON.t): array<JSON.t> => j->JSON.Decode.array->Option.getOr([])
+
+describe("withLiveUpdates (B3.3a Postgres live updates)", () => {
+  testAsync("save on a single-key table publishes Updated with sortKeyValue", async () => {
+    let c = await run("save-single")
+    let arr = calls(c)
+    expect(arr->Array.length)->toBe(1)
+    let call = arr->Array.getUnsafe(0)
+    expect(str(call, "entityKey"))->toEqual(Some("p1"))
+    expect(str(call, "changeKind"))->toEqual(Some("Updated"))
+    expect(str(call, "sortKeyValue"))->toEqual(Some("2024-01-02"))
+    expect(str(call, "topicName"))->toEqual(Some("Shop_Orders"))
+  })
+
+  testAsync("save on a composite table uses id-subKey and createdAt fallback", async () => {
+    let c = await run("save-composite")
+    let call = calls(c)->Array.getUnsafe(0)
+    expect(str(call, "entityKey"))->toEqual(Some("o1-L2"))
+    expect(str(call, "changeKind"))->toEqual(Some("Updated"))
+    expect(str(call, "sortKeyValue"))->toEqual(Some("2024-03-04"))
+  })
+
+  testAsync("save without updatedAt/createdAt omits sortKeyValue", async () => {
+    let c = await run("save-no-sortkey")
+    let call = calls(c)->Array.getUnsafe(0)
+    expect(getField(call, "sortKeyValue"))->toEqual(None)
+  })
+
+  testAsync("saveBatch publishes one Updated per item", async () => {
+    let c = await run("saveBatch")
+    let arr = calls(c)
+    expect(arr->Array.length)->toBe(2)
+    expect(str(arr->Array.getUnsafe(0), "entityKey"))->toEqual(Some("a"))
+    expect(str(arr->Array.getUnsafe(1), "entityKey"))->toEqual(Some("b"))
+    arr->Array.forEach(call => expect(str(call, "changeKind"))->toEqual(Some("Updated")))
+  })
+
+  testAsync("delete on a single-key table publishes Removed for the id", async () => {
+    let c = await run("delete-single")
+    let call = calls(c)->Array.getUnsafe(0)
+    expect(str(call, "entityKey"))->toEqual(Some("p1"))
+    expect(str(call, "changeKind"))->toEqual(Some("Removed"))
+  })
+
+  testAsync("delete of a specific composite row uses id-subValue", async () => {
+    let c = await run("delete-composite-row")
+    let arr = calls(c)
+    expect(arr->Array.length)->toBe(1)
+    expect(str(arr->Array.getUnsafe(0), "entityKey"))->toEqual(Some("o1-L2"))
+    expect(str(arr->Array.getUnsafe(0), "changeKind"))->toEqual(Some("Removed"))
+  })
+
+  testAsync("partition-wide composite delete enumerates rows via load", async () => {
+    let c = await run("delete-composite-partition")
+    let arr = calls(c)
+    expect(arr->Array.length)->toBe(2)
+    expect(str(arr->Array.getUnsafe(0), "entityKey"))->toEqual(Some("o1-L1"))
+    expect(str(arr->Array.getUnsafe(1), "entityKey"))->toEqual(Some("o1-L2"))
+    arr->Array.forEach(call => expect(str(call, "changeKind"))->toEqual(Some("Removed")))
+  })
+
+  testAsync("deleteBatch publishes one Removed per entry", async () => {
+    let c = await run("deleteBatch")
+    let arr = calls(c)
+    expect(arr->Array.length)->toBe(2)
+    expect(str(arr->Array.getUnsafe(0), "entityKey"))->toEqual(Some("a"))
+    expect(str(arr->Array.getUnsafe(1), "entityKey"))->toEqual(Some("b"))
+  })
+
+  testAsync("no topicName → ops pass through, nothing published", async () => {
+    let c = await run("gated-no-topic")
+    expect(calls(c)->Array.length)->toBe(0)
+  })
+})

package/tests/StateTopicPublishTest.res.mjs

@@ -0,0 +1,158 @@
+// 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";
+
+let run = (async function(scenario) {
+  const mod = await import("../src/adapter/Runtime/StateTopicPublish.mjs");
+  const { withLiveUpdates } = mod;
+  const captured = [];
+  const publish = async (call) => { captured.push(call); };
+  const ok = async () => ({ TAG: "Ok", _0: undefined });
+
+  // Mock ops. load returns the composite partition's rows for the enumerate case.
+  const partitionRows = { TAG: "Ok", _0: [
+    { id: "o1", lineId: "L1" },
+    { id: "o1", lineId: "L2" },
+  ]};
+  const ops = {
+    load: async (id) => partitionRows,
+    loadStream: () => {},
+    save: ok, saveBatch: ok, count: ok, delete: ok, deleteBatch: ok,
+  };
+
+  const cfg = (subIdField) => ({
+    endpoint: "https://x.appsync-api.eu-west-1.amazonaws.com",
+    region: "eu-west-1",
+    topicName: "Shop_Orders",
+    subIdField,
+    publish,
+  });
+
+  const w = (subIdField) => withLiveUpdates(ops, cfg(subIdField));
+
+  switch (scenario) {
+    case "save-single":
+      await w(undefined).save("p1", { id: "p1", updatedAt: "2024-01-02" }, "Insert", undefined);
+      break;
+    case "save-composite":
+      await w("lineId").save("o1", { id: "o1", lineId: "L2", createdAt: "2024-03-04" }, "Insert", undefined);
+      break;
+    case "save-no-sortkey":
+      await w(undefined).save("p1", { id: "p1" }, "Insert", undefined);
+      break;
+    case "saveBatch":
+      await w(undefined).saveBatch([
+        ["a", { id: "a", updatedAt: "t1" }, undefined],
+        ["b", { id: "b", updatedAt: "t2" }, undefined],
+      ]);
+      break;
+    case "delete-single":
+      await w(undefined).delete("p1", undefined);
+      break;
+    case "delete-composite-row":
+      await w("lineId").delete("o1", ["lineId", "L2"]);
+      break;
+    case "delete-composite-partition":
+      await w("lineId").delete("o1", undefined);
+      break;
+    case "deleteBatch":
+      await w(undefined).deleteBatch([["a", undefined], ["b", undefined]]);
+      break;
+    case "gated-no-topic": {
+      const gatedOps = withLiveUpdates(ops, { endpoint: "https://x", region: "r", topicName: undefined, publish });
+      await gatedOps.save("p1", { id: "p1" }, "Insert", undefined);
+      break;
+    }
+  }
+  return captured;
+});
+
+function getField(call, key) {
+  return Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(call), d => d[key]);
+}
+
+function str(call, key) {
+  return Stdlib_Option.flatMap(getField(call, key), Stdlib_JSON.Decode.string);
+}
+
+function calls(j) {
+  return Stdlib_Option.getOr(Stdlib_JSON.Decode.array(j), []);
+}
+
+globalThis.describe("withLiveUpdates (B3.3a Postgres live updates)", () => {
+  globalThis.test("save on a single-key table publishes Updated with sortKeyValue", async () => {
+    let c = await run("save-single");
+    let arr = calls(c);
+    globalThis.expect(arr.length).toBe(1);
+    let call = arr[0];
+    globalThis.expect(str(call, "entityKey")).toEqual("p1");
+    globalThis.expect(str(call, "changeKind")).toEqual("Updated");
+    globalThis.expect(str(call, "sortKeyValue")).toEqual("2024-01-02");
+    globalThis.expect(str(call, "topicName")).toEqual("Shop_Orders");
+  });
+  globalThis.test("save on a composite table uses id-subKey and createdAt fallback", async () => {
+    let c = await run("save-composite");
+    let call = calls(c)[0];
+    globalThis.expect(str(call, "entityKey")).toEqual("o1-L2");
+    globalThis.expect(str(call, "changeKind")).toEqual("Updated");
+    globalThis.expect(str(call, "sortKeyValue")).toEqual("2024-03-04");
+  });
+  globalThis.test("save without updatedAt/createdAt omits sortKeyValue", async () => {
+    let c = await run("save-no-sortkey");
+    let call = calls(c)[0];
+    globalThis.expect(getField(call, "sortKeyValue")).toEqual(undefined);
+  });
+  globalThis.test("saveBatch publishes one Updated per item", async () => {
+    let c = await run("saveBatch");
+    let arr = calls(c);
+    globalThis.expect(arr.length).toBe(2);
+    globalThis.expect(str(arr[0], "entityKey")).toEqual("a");
+    globalThis.expect(str(arr[1], "entityKey")).toEqual("b");
+    arr.forEach(call => {
+      globalThis.expect(str(call, "changeKind")).toEqual("Updated");
+    });
+  });
+  globalThis.test("delete on a single-key table publishes Removed for the id", async () => {
+    let c = await run("delete-single");
+    let call = calls(c)[0];
+    globalThis.expect(str(call, "entityKey")).toEqual("p1");
+    globalThis.expect(str(call, "changeKind")).toEqual("Removed");
+  });
+  globalThis.test("delete of a specific composite row uses id-subValue", async () => {
+    let c = await run("delete-composite-row");
+    let arr = calls(c);
+    globalThis.expect(arr.length).toBe(1);
+    globalThis.expect(str(arr[0], "entityKey")).toEqual("o1-L2");
+    globalThis.expect(str(arr[0], "changeKind")).toEqual("Removed");
+  });
+  globalThis.test("partition-wide composite delete enumerates rows via load", async () => {
+    let c = await run("delete-composite-partition");
+    let arr = calls(c);
+    globalThis.expect(arr.length).toBe(2);
+    globalThis.expect(str(arr[0], "entityKey")).toEqual("o1-L1");
+    globalThis.expect(str(arr[1], "entityKey")).toEqual("o1-L2");
+    arr.forEach(call => {
+      globalThis.expect(str(call, "changeKind")).toEqual("Removed");
+    });
+  });
+  globalThis.test("deleteBatch publishes one Removed per entry", async () => {
+    let c = await run("deleteBatch");
+    let arr = calls(c);
+    globalThis.expect(arr.length).toBe(2);
+    globalThis.expect(str(arr[0], "entityKey")).toEqual("a");
+    globalThis.expect(str(arr[1], "entityKey")).toEqual("b");
+  });
+  globalThis.test("no topicName → ops pass through, nothing published", async () => {
+    let c = await run("gated-no-topic");
+    globalThis.expect(calls(c).length).toBe(0);
+  });
+});
+
+export {
+  run,
+  getField,
+  str,
+  calls,
+}
+/* run Not a pure module */

package/tests/Util_BundleEsmLoaderTest.res

@@ -0,0 +1,57 @@
+open JestGlobals
+
+// Guards the ESM self-containment loader (Option C) against silent drift. The
+// load-bearing contract: every code archive that ships the loader files MUST set
+// NODE_OPTIONS=--import pointing at the shipped register-hook.mjs, and the two
+// files must keep cross-referencing each other by the exact filenames used here.
+// See docs/plans/deployed-lambda-esm-self-containment.md.
+
+describe("Util_Bundle ESM loader — env-var contract", () => {
+  testSync("NODE_OPTIONS --imports the shipped register-hook file by name", () => {
+    expect(Util_Bundle.esmLoaderNodeOptions)->toBe(
+      `--import file:///var/task/${Util_Bundle.registerHookFileName}`,
+    )
+  })
+
+  testSync("fallback dirs cover both the layer and the runtime SDK dir", () => {
+    // @aws-sdk/* lives in the runtime dir; @reventlessdev/*, effect, sury in the layer.
+    expect(Util_Bundle.esmFallbackDirs->String.includes("/opt/nodejs/node_modules"))->toBe(true)
+    expect(Util_Bundle.esmFallbackDirs->String.includes("/var/runtime/node_modules"))->toBe(true)
+  })
+})
+
+describe("Util_Bundle ESM loader — file cross-references", () => {
+  testSync("register-hook registers exactly the layer-resolver filename", () => {
+    expect(Util_Bundle.registerHookSource->String.includes(Util_Bundle.layerResolverFileName))->toBe(
+      true,
+    )
+    expect(Util_Bundle.registerHookSource->String.includes("register("))->toBe(true)
+  })
+
+  testSync("layer-resolver retries only bare specifiers on ERR_MODULE_NOT_FOUND", () => {
+    expect(Util_Bundle.layerResolverSource->String.includes("ESM_FALLBACK_DIRS"))->toBe(true)
+    expect(Util_Bundle.layerResolverSource->String.includes("ERR_MODULE_NOT_FOUND"))->toBe(true)
+    // The resolve hook is the exported entry point Node's loader calls.
+    expect(Util_Bundle.layerResolverSource->String.includes("export async function resolve"))->toBe(
+      true,
+    )
+  })
+})
+
+describe("Util_Bundle.addEsmLoaderAssets", () => {
+  testSync("injects both loader files at the archive root", () => {
+    let contents: dict<Pulumi.Archive.assetOrArchive> = Dict.make()
+    let _ = Util_Bundle.addEsmLoaderAssets(contents)
+    expect(contents->Dict.has(Util_Bundle.registerHookFileName))->toBe(true)
+    expect(contents->Dict.has(Util_Bundle.layerResolverFileName))->toBe(true)
+  })
+
+  testSync("returns a stable, non-empty hash fragment", () => {
+    let a: dict<Pulumi.Archive.assetOrArchive> = Dict.make()
+    let b: dict<Pulumi.Archive.assetOrArchive> = Dict.make()
+    let hashA = Util_Bundle.addEsmLoaderAssets(a)
+    let hashB = Util_Bundle.addEsmLoaderAssets(b)
+    expect(hashA->String.length > 0)->toBe(true)
+    expect(hashA)->toBe(hashB)
+  })
+})

package/tests/Util_BundleEsmLoaderTest.res.mjs

@@ -0,0 +1,44 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Util_Bundle$ReventlessAws from "../src/util/Util_Bundle.res.mjs";
+
+globalThis.describe("Util_Bundle ESM loader — env-var contract", () => {
+  globalThis.test("NODE_OPTIONS --imports the shipped register-hook file by name", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.esmLoaderNodeOptions).toBe(`--import file:///var/task/` + Util_Bundle$ReventlessAws.registerHookFileName);
+  });
+  globalThis.test("fallback dirs cover both the layer and the runtime SDK dir", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.esmFallbackDirs.includes("/opt/nodejs/node_modules")).toBe(true);
+    globalThis.expect(Util_Bundle$ReventlessAws.esmFallbackDirs.includes("/var/runtime/node_modules")).toBe(true);
+  });
+});
+
+globalThis.describe("Util_Bundle ESM loader — file cross-references", () => {
+  globalThis.test("register-hook registers exactly the layer-resolver filename", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.registerHookSource.includes(Util_Bundle$ReventlessAws.layerResolverFileName)).toBe(true);
+    globalThis.expect(Util_Bundle$ReventlessAws.registerHookSource.includes("register(")).toBe(true);
+  });
+  globalThis.test("layer-resolver retries only bare specifiers on ERR_MODULE_NOT_FOUND", () => {
+    globalThis.expect(Util_Bundle$ReventlessAws.layerResolverSource.includes("ESM_FALLBACK_DIRS")).toBe(true);
+    globalThis.expect(Util_Bundle$ReventlessAws.layerResolverSource.includes("ERR_MODULE_NOT_FOUND")).toBe(true);
+    globalThis.expect(Util_Bundle$ReventlessAws.layerResolverSource.includes("export async function resolve")).toBe(true);
+  });
+});
+
+globalThis.describe("Util_Bundle.addEsmLoaderAssets", () => {
+  globalThis.test("injects both loader files at the archive root", () => {
+    let contents = {};
+    Util_Bundle$ReventlessAws.addEsmLoaderAssets(contents);
+    globalThis.expect(Util_Bundle$ReventlessAws.registerHookFileName in contents).toBe(true);
+    globalThis.expect(Util_Bundle$ReventlessAws.layerResolverFileName in contents).toBe(true);
+  });
+  globalThis.test("returns a stable, non-empty hash fragment", () => {
+    let a = {};
+    let b = {};
+    let hashA = Util_Bundle$ReventlessAws.addEsmLoaderAssets(a);
+    let hashB = Util_Bundle$ReventlessAws.addEsmLoaderAssets(b);
+    globalThis.expect(hashA.length > 0).toBe(true);
+    globalThis.expect(hashA).toBe(hashB);
+  });
+});
+
+/*  Not a pure module */