@reventlessdev/reventless-aws 3.0.0-alpha.345 → 3.0.0-alpha.347

package/tests/BakeManifestTest.res.mjs

@@ -0,0 +1,259 @@
+// 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 Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
+import * as BakeManifest$ReventlessAws from "../scripts/BakeManifest.res.mjs";
+import * as DeployManifest$ReventlessAws from "../scripts/DeployManifest.res.mjs";
+
+function json(text) {
+  return JSON.parse(text);
+}
+
+globalThis.describe("DeployManifest", () => {
+  globalThis.test("resolves every folder against the manifest's own folder", () => {
+    let resolved = Stdlib_Result.map(DeployManifest$ReventlessAws.parseString(`
+region: eu-west-1
+platform:
+  path: platform-aws
+  name: shop-platform
+  stack-defaults:
+    platform:messagingEmailProvider: log
+plugins:
+  - name: catalog
+    path: catalog-aws
+    depends-on: []
+  - name: ordering
+    path: ordering-aws
+`), m => DeployManifest$ReventlessAws.resolve(m, "/repo/shop/deploy-manifest.yaml"));
+    globalThis.expect(resolved).toEqual({
+      TAG: "Ok",
+      _0: {
+        file: "/repo/shop/deploy-manifest.yaml",
+        region: "eu-west-1",
+        platform: {
+          name: "shop-platform",
+          dir: "/repo/shop/platform-aws",
+          stackDefaults: Object.fromEntries([[
+              "platform:messagingEmailProvider",
+              "log"
+            ]])
+        },
+        plugins: [
+          {
+            name: "catalog",
+            dir: "/repo/shop/catalog-aws",
+            stackDefaults: {}
+          },
+          {
+            name: "ordering",
+            dir: "/repo/shop/ordering-aws",
+            stackDefaults: {}
+          }
+        ]
+      }
+    });
+  });
+  globalThis.test("refuses a manifest without a platform", () => {
+    globalThis.expect(Stdlib_Result.isError(DeployManifest$ReventlessAws.parseString("plugins: []"))).toBe(true);
+  });
+});
+
+globalThis.describe("BakeManifest.parseArgs", () => {
+  globalThis.test("reads the stack, the manifest and the deploy's start", () => {
+    globalThis.expect(BakeManifest$ReventlessAws.parseArgs([
+      "--stack",
+      "alpha",
+      "--manifest",
+      "m.yaml",
+      "--since",
+      "2026-09-16T10:00:00Z"
+    ])).toEqual({
+      TAG: "Ok",
+      _0: {
+        manifest: "m.yaml",
+        stack: "alpha",
+        since: "2026-09-16T10:00:00Z",
+        help: false
+      }
+    });
+  });
+  globalThis.test("an empty --since is no instant", () => {
+    globalThis.expect(Stdlib_Result.map(BakeManifest$ReventlessAws.parseArgs([
+      "--since",
+      ""
+    ]), a => a.since)).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+  });
+  globalThis.test("an unknown flag refuses", () => {
+    globalThis.expect(BakeManifest$ReventlessAws.parseArgs([
+      "--stak",
+      "alpha"
+    ])).toEqual({
+      TAG: "Error",
+      _0: `unknown argument "--stak"`
+    });
+  });
+});
+
+globalThis.describe("BakeManifest reads the stacks", () => {
+  globalThis.test("a platform without a bake function declares no bake", () => {
+    globalThis.expect(BakeManifest$ReventlessAws.targetOf(Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(`{"bakedManifestBucket": "b", "bakedManifestFunction": ""}`)), {}))).toEqual(undefined);
+  });
+  globalThis.test("a platform with one names the function, bucket and key", () => {
+    globalThis.expect(BakeManifest$ReventlessAws.targetOf(Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(`{"bakedManifestFunction": "fn", "bakedManifestBucket": "b", "bakedManifestKey": "manifest.json"}`)), {}))).toEqual({
+      functionName: "fn",
+      bucket: "b",
+      key: "manifest.json"
+    });
+  });
+  globalThis.test("a plugin stack's structure key is read from pluginStructureRef", () => {
+    globalThis.expect(BakeManifest$ReventlessAws.structureRefOf(Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(`{"pluginStructureRef": {"plugin": "Catalog", "key": "sha256/abc"}}`)), {}))).toEqual([
+      "Catalog",
+      "sha256/abc"
+    ]);
+  });
+  globalThis.test("the payload carries the deploy's start only when there is one", () => {
+    let target = {
+      functionName: "fn",
+      bucket: "b",
+      key: "k"
+    };
+    let expect_ = Object.fromEntries([[
+        "Catalog",
+        "sha256/abc"
+      ]]);
+    globalThis.expect(JSON.stringify(BakeManifest$ReventlessAws.payload(target, expect_, undefined))).toBe(`{"bake":true,"bucket":"b","key":"k","expect":{"Catalog":"sha256/abc"}}`);
+    globalThis.expect(JSON.stringify(BakeManifest$ReventlessAws.payload(target, expect_, "2026-09-16T10:00:00Z"))).toBe(`{"bake":true,"bucket":"b","key":"k","expect":{"Catalog":"sha256/abc"},"since":"2026-09-16T10:00:00Z"}`);
+  });
+});
+
+function pending(state) {
+  return JSON.parse(`[{"baked": false, "pending": ["Catalog"], "registrations": [
+    {"plugin": "Catalog", "state": "` + state + `", "expected": "sha256/new", "found": "sha256/old", "writtenAt": null}
+  ]}]`);
+}
+
+let baked = JSON.parse(`[
+  {"baked": true, "bucket": "b", "key": "manifest.json", "plugins": 2, "bytes": 512},
+  {"summary": true, "plugins": 1, "registered": 1, "unchanged": 0, "matched": 0, "registrations": [
+    {"plugin": "Catalog", "state": "registered", "expected": "sha256/new", "found": "sha256/new", "writtenAt": "2026-09-16T10:01:00Z"}
+  ]}
+]`);
+
+globalThis.describe("BakeManifest.readAnswer", () => {
+  globalThis.test("a written manifest reports its files and what convergence proved", () => {
+    let match = BakeManifest$ReventlessAws.readAnswer(baked);
+    if (match.TAG === "Ok") {
+      let match$1 = match._0;
+      if (match$1.TAG === "Baked") {
+        globalThis.expect([
+          match$1.written.map(w => [
+            w.key,
+            w.bytes
+          ]),
+          Stdlib_Option.map(match$1.summary, s => s.registered)
+        ]).toEqual([
+          [[
+              "manifest.json",
+              512
+            ]],
+          1
+        ]);
+        return;
+      }
+      globalThis.expect("not baked").toBe("baked");
+      return;
+    }
+    globalThis.expect("not baked").toBe("baked");
+  });
+  globalThis.test("a pending answer names the plugins not yet arrived", () => {
+    let match = BakeManifest$ReventlessAws.readAnswer(pending("behind"));
+    if (match.TAG === "Ok") {
+      let match$1 = match._0;
+      if (match$1.TAG === "Baked") {
+        globalThis.expect("not pending").toBe("pending");
+        return;
+      }
+      globalThis.expect(match$1.pending).toEqual(["Catalog"]);
+      return;
+    }
+    globalThis.expect("not pending").toBe("pending");
+  });
+  globalThis.test("the report line carries both keys and the row's date", () => {
+    globalThis.expect(BakeManifest$ReventlessAws.registrationLine({
+      plugin: "Catalog",
+      state: "missing",
+      expected: "sha256/new",
+      found: undefined,
+      writtenAt: undefined
+    })).toBe("  Catalog: missing — expected sha256/new, row holds no row (written never)");
+  });
+});
+
+globalThis.describe("BakeManifest.converge", () => {
+  let run = async (answers, attempts) => {
+    let asked = {
+      contents: 0
+    };
+    let invoke = async () => {
+      let answer = answers[Math.min(asked.contents, answers.length - 1 | 0)];
+      asked.contents = asked.contents + 1 | 0;
+      return {
+        TAG: "Ok",
+        _0: answer
+      };
+    };
+    let outcome = await BakeManifest$ReventlessAws.converge(invoke, async () => {}, param => {}, attempts);
+    return [
+      Stdlib_Result.isOk(outcome),
+      asked.contents
+    ];
+  };
+  globalThis.test("asks again while a plugin is behind, then succeeds", async () => {
+    globalThis.expect(await run([
+      pending("behind"),
+      pending("behind"),
+      baked
+    ], 5)).toEqual([
+      true,
+      3
+    ]);
+  });
+  globalThis.test("waits for a missing registration", async () => {
+    globalThis.expect(await run([
+      pending("missing"),
+      baked
+    ], 5)).toEqual([
+      true,
+      2
+    ]);
+  });
+  globalThis.test("stops at once on a registration that diverged", async () => {
+    globalThis.expect(await run([
+      pending("diverged"),
+      baked
+    ], 5)).toEqual([
+      false,
+      1
+    ]);
+  });
+  globalThis.test("gives up when the attempts run out", async () => {
+    globalThis.expect(await run([pending("behind")], 3)).toEqual([
+      false,
+      3
+    ]);
+  });
+});
+
+let Bake;
+
+export {
+  Bake,
+  json,
+  pending,
+  baked,
+}
+/*  Not a pure module */

package/tests/DcbColdStartPartitionTest.res

@@ -0,0 +1,32 @@
+// The DCB command Lambda refuses to start when its partition keys cannot be
+// derived, and says why on every invocation.
+//
+// Deploy derives the same keys from the same slices, so this only fails when the
+// framework in the Lambda layer differs from the one deploy used. Carrying on
+// would file events under the wrong keys; refusing sends messages to the DLQ.
+
+open JestGlobals
+
+type afterFailedStartup = {messages: array<string>, unhandled: array<string>}
+
+@module("./dcbColdStartPartition.mjs")
+external invokeAfterFailedStartup: unit => promise<afterFailedStartup> = "invokeAfterFailedStartup"
+
+@module("./dcbColdStartPartition.mjs")
+external startWithUnresolvedSlice: unit => promise<string> = "startWithUnresolvedSlice"
+
+describe("DcbCommandTopicEntryPoint cold start", () => {
+  test("a slice whose partition cannot be inferred stops startup, naming it", async () => {
+    let message = await startWithUnresolvedSlice()
+    expect(message->String.includes("LinkGadget"))->toBe(true)
+    expect(message->String.includes("@partitionTag"))->toBe(true)
+  })
+
+  test("after a failed startup every invocation rethrows the same error", async () => {
+    let {messages, unhandled} = await invokeAfterFailedStartup()
+    expect(messages->Array.length)->toBe(2)
+    expect(messages->Array.includes("resolved"))->toBe(false)
+    expect(messages->Array.getUnsafe(0))->toBe(messages->Array.getUnsafe(1))
+    expect(unhandled)->toEqual([])
+  })
+})

package/tests/DcbColdStartPartitionTest.res.mjs

@@ -0,0 +1,33 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as DcbColdStartPartitionMjs from "./dcbColdStartPartition.mjs";
+
+function invokeAfterFailedStartup(prim) {
+  return DcbColdStartPartitionMjs.invokeAfterFailedStartup();
+}
+
+function startWithUnresolvedSlice(prim) {
+  return DcbColdStartPartitionMjs.startWithUnresolvedSlice();
+}
+
+globalThis.describe("DcbCommandTopicEntryPoint cold start", () => {
+  globalThis.test("a slice whose partition cannot be inferred stops startup, naming it", async () => {
+    let message = await DcbColdStartPartitionMjs.startWithUnresolvedSlice();
+    globalThis.expect(message.includes("LinkGadget")).toBe(true);
+    globalThis.expect(message.includes("@partitionTag")).toBe(true);
+  });
+  globalThis.test("after a failed startup every invocation rethrows the same error", async () => {
+    let match = await DcbColdStartPartitionMjs.invokeAfterFailedStartup();
+    let messages = match.messages;
+    globalThis.expect(messages.length).toBe(2);
+    globalThis.expect(messages.includes("resolved")).toBe(false);
+    globalThis.expect(messages[0]).toBe(messages[1]);
+    globalThis.expect(match.unhandled).toEqual([]);
+  });
+});
+
+export {
+  invokeAfterFailedStartup,
+  startWithUnresolvedSlice,
+}
+/*  Not a pure module */

package/tests/DcbEventLogStorage_DynamoDb_RuntimeTest.res

@@ -259,6 +259,94 @@ describe("Runtime.buildScanFilter — excludes fence sentinels (Issue 12)", () =
   })
 })
 
+describe("Runtime.derivePartitionKey — each event type under its slice's key", () => {
+  // Two entities in one log. AddressLinked declares addressId first, so a
+  // positional default would file it under the reference.
+  let partitionTag = Reventless.DcbTag.ByEventType(
+    Dict.fromArray([("OrderPlaced", "orderId"), ("AddressLinked", "customerId")]),
+  )
+  let thrownMessage = f =>
+    try {
+      let _ = f()
+      ""
+    } catch {
+    | JsExn(err) => JsExn.message(err)->Option.getOr("")
+    }
+
+  testSync("files an event under its own type's key, not its first tag", () =>
+    expect(
+      Runtime.derivePartitionKey(
+        ~partitionTag,
+        ~eventType="AddressLinked",
+        [tag("addressId", "a1"), tag("customerId", "c1")],
+      ),
+    )->toBe("customerId:c1")
+  )
+
+  testSync("another type in the same log keeps its own key", () =>
+    expect(
+      Runtime.derivePartitionKey(
+        ~partitionTag,
+        ~eventType="OrderPlaced",
+        [tag("customerId", "c1"), tag("orderId", "o1")],
+      ),
+    )->toBe("orderId:o1")
+  )
+
+  testSync("an event type no slice writes throws instead of guessing", () =>
+    expect(
+      thrownMessage(
+        () =>
+          Runtime.derivePartitionKey(
+            ~partitionTag,
+            ~eventType="Unknown",
+            [tag("customerId", "c1")],
+          ),
+      )->String.includes("Unknown has no partition key"),
+    )->toBe(true)
+  )
+
+  testSync("an event missing its partition tag throws instead of guessing", () =>
+    expect(
+      thrownMessage(
+        () =>
+          Runtime.derivePartitionKey(
+            ~partitionTag,
+            ~eventType="AddressLinked",
+            [tag("addressId", "a1")],
+          ),
+      )->String.includes("carries no customerId tag"),
+    )->toBe(true)
+  )
+
+  testSync("a conditional append puts and fences the event under that key", () => {
+    let linked: ReventlessCore.DcbEventLog_Adapter.rawStoredEvent = {
+      eventType: "AddressLinked",
+      data: JSON.Object(Dict.make()),
+      tags: [tag("addressId", "a1"), tag("customerId", "c1")],
+      meta: testMeta(),
+    }
+    let cond: Reventless.DcbTag.appendCondition = {
+      query: [{tags: [tag("customerId", "c1")], eventTypes: ["AddressLinked"]}],
+      after: "50",
+    }
+    let ids =
+      Runtime.buildConditionalTransactItems(table, [linked], cond, "100", ~partitionTag)
+      ->Array.filterMap(
+        it =>
+          switch (it.put, it.update) {
+          | (Some(p), _) => p.item->JSON.Decode.object->Option.flatMap(i => i->Dict.get("id"))
+          | (_, Some(u)) => u.key->Dict.get("id")
+          | _ => None
+          },
+      )
+      ->Array.filterMap(JSON.Decode.string)
+    expect(ids->Array.includes("customerId:c1"))->toBe(true)
+    expect(ids->Array.includes("fence#customerId:c1"))->toBe(true)
+    expect(ids->Array.some(id => id->String.includes("addressId")))->toBe(false)
+  })
+})
+
 describe("Runtime.buildEventPuts", () => {
   let event = (eventType, tags): ReventlessCore.DcbEventLog_Adapter.rawStoredEvent => {
     eventType,

package/tests/DcbEventLogStorage_DynamoDb_RuntimeTest.res.mjs

@@ -2,8 +2,10 @@
 
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.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 Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
 import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
 
@@ -314,6 +316,116 @@ globalThis.describe("Runtime.buildScanFilter — excludes fence sentinels (Issue
   });
 });
 
+globalThis.describe("Runtime.derivePartitionKey — each event type under its slice's key", () => {
+  let partitionTag = {
+    TAG: "ByEventType",
+    _0: Object.fromEntries([
+      [
+        "OrderPlaced",
+        "orderId"
+      ],
+      [
+        "AddressLinked",
+        "customerId"
+      ]
+    ])
+  };
+  let thrownMessage = f => {
+    try {
+      f();
+      return "";
+    } catch (raw_err) {
+      let err = Primitive_exceptions.internalToException(raw_err);
+      if (err.RE_EXN_ID === "JsExn") {
+        return Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "");
+      }
+      throw err;
+    }
+  };
+  globalThis.test("files an event under its own type's key, not its first tag", () => {
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.derivePartitionKey(partitionTag, "AddressLinked", [
+      {
+        key: "addressId",
+        value: "a1"
+      },
+      {
+        key: "customerId",
+        value: "c1"
+      }
+    ])).toBe("customerId:c1");
+  });
+  globalThis.test("another type in the same log keeps its own key", () => {
+    globalThis.expect(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.derivePartitionKey(partitionTag, "OrderPlaced", [
+      {
+        key: "customerId",
+        value: "c1"
+      },
+      {
+        key: "orderId",
+        value: "o1"
+      }
+    ])).toBe("orderId:o1");
+  });
+  globalThis.test("an event type no slice writes throws instead of guessing", () => {
+    globalThis.expect(thrownMessage(() => DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.derivePartitionKey(partitionTag, "Unknown", [{
+        key: "customerId",
+        value: "c1"
+      }])).includes("Unknown has no partition key")).toBe(true);
+  });
+  globalThis.test("an event missing its partition tag throws instead of guessing", () => {
+    globalThis.expect(thrownMessage(() => DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.derivePartitionKey(partitionTag, "AddressLinked", [{
+        key: "addressId",
+        value: "a1"
+      }])).includes("carries no customerId tag")).toBe(true);
+  });
+  globalThis.test("a conditional append puts and fences the event under that key", () => {
+    let linked_data = {};
+    let linked_tags = [
+      {
+        key: "addressId",
+        value: "a1"
+      },
+      {
+        key: "customerId",
+        value: "c1"
+      }
+    ];
+    let linked_meta = testMeta();
+    let linked = {
+      eventType: "AddressLinked",
+      data: linked_data,
+      tags: linked_tags,
+      meta: linked_meta
+    };
+    let cond_query = [{
+        eventTypes: ["AddressLinked"],
+        tags: [{
+            key: "customerId",
+            value: "c1"
+          }]
+      }];
+    let cond_after = "50";
+    let cond = {
+      query: cond_query,
+      after: cond_after
+    };
+    let ids = Stdlib_Array.filterMap(Stdlib_Array.filterMap(DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.buildConditionalTransactItems(table, [linked], cond, "100", partitionTag, undefined), it => {
+      let match = it.Put;
+      let match$1 = it.Update;
+      if (match !== undefined) {
+        return Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(match.Item), i => i["id"]);
+      } else if (match$1 !== undefined) {
+        return match$1.Key["id"];
+      } else {
+        return;
+      }
+    }), Stdlib_JSON.Decode.string);
+    globalThis.expect(ids.includes("customerId:c1")).toBe(true);
+    globalThis.expect(ids.includes("fence#customerId:c1")).toBe(true);
+    globalThis.expect(ids.some(id => id.includes("addressId"))).toBe(false);
+  });
+});
+
 globalThis.describe("Runtime.buildEventPuts", () => {
   let event = (eventType, tags) => ({
     eventType: eventType,

package/tests/DcbUnresolvedPartitionSlice.res

@@ -0,0 +1,28 @@
+// A slice whose partition cannot be inferred, for `DcbColdStartPartitionTest`.
+// It writes two ids and reads both off an event nothing in its boundary writes,
+// so neither can be told apart from a reference.
+//
+// Explicit `@s.matches(...)` form: reventless-ppx is not wired into this package.
+
+@schema
+type consumedEvent = GadgetImported({gadgetId: string, supplierId: string})
+
+@schema
+type command =
+  | LinkGadget({
+      gadgetId: @s.matches(Reventless.DcbTag.string) string,
+      supplierId: @s.matches(Reventless.DcbTag.string) string,
+    })
+
+@schema
+type error = AlreadyLinked
+
+@schema
+type event =
+  | GadgetLinked({
+      gadgetId: @s.matches(Reventless.DcbTag.string) string,
+      supplierId: @s.matches(Reventless.DcbTag.string) string,
+    })
+
+let name = "LinkGadget"
+let moduleUrl = "cold-start-test://LinkGadget"

package/tests/DcbUnresolvedPartitionSlice.res.mjs

@@ -0,0 +1,38 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+
+let consumedEventSchema = Sury.$schema(s => ({
+  TAG: "GadgetImported",
+  gadgetId: s.m(Sury.string),
+  supplierId: s.m(Sury.string)
+}));
+
+let commandSchema = Sury.$schema(s => ({
+  TAG: "LinkGadget",
+  gadgetId: s.m(DcbTag$Reventless.string),
+  supplierId: s.m(DcbTag$Reventless.string)
+}));
+
+let errorSchema = Sury.literal("AlreadyLinked");
+
+let eventSchema = Sury.$schema(s => ({
+  TAG: "GadgetLinked",
+  gadgetId: s.m(DcbTag$Reventless.string),
+  supplierId: s.m(DcbTag$Reventless.string)
+}));
+
+let name = "LinkGadget";
+
+let moduleUrl = "cold-start-test://LinkGadget";
+
+export {
+  consumedEventSchema,
+  commandSchema,
+  errorSchema,
+  eventSchema,
+  name,
+  moduleUrl,
+}
+/* consumedEventSchema Not a pure module */