@reventlessdev/reventless-aws 3.0.0-alpha.176 → 3.0.0-alpha.178

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 */