@reventlessdev/reventless-aws 3.0.0-alpha.231 → 3.0.0-alpha.233

package/tests/StateViewSliceEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,296 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as StateViewSliceEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res.mjs";
+
+function str(prim) {
+  return prim;
+}
+
+function obj(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+globalThis.describe("StateViewSliceEntryPoint_Ops.parseHandlerConfig", () => {
+  globalThis.test("empty raw config yields no handlers", () => {
+    globalThis.expect(StateViewSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfig("").length).toBe(0);
+  });
+  globalThis.test("expands compact-v2 entries against shared base/sourceUrn/pgConnection", () => {
+    let config = JSON.stringify(Object.fromEntries([
+      [
+        "v",
+        2
+      ],
+      [
+        "base",
+        "@x/plugin/src/StateViewSlice/"
+      ],
+      [
+        "sourceUrn",
+        "arn:shared"
+      ],
+      [
+        "pgConnection",
+        Object.fromEntries([
+          [
+            "host",
+            "db.local"
+          ],
+          [
+            "port",
+            5432
+          ],
+          [
+            "database",
+            "app"
+          ],
+          [
+            "username",
+            "master"
+          ],
+          [
+            "secretArn",
+            "arn:secret"
+          ]
+        ])
+      ],
+      [
+        "handlers",
+        [
+          Object.fromEntries([
+            [
+              "s",
+              "Carts.res.mjs"
+            ],
+            [
+              "p",
+              "Carts_Projection.res.mjs"
+            ],
+            [
+              "q",
+              "qdb_Carts"
+            ]
+          ]),
+          Object.fromEntries([
+            [
+              "s",
+              "Totals.res.mjs"
+            ],
+            [
+              "p",
+              "Totals_Projection.res.mjs"
+            ],
+            [
+              "q",
+              "qdb_Totals"
+            ],
+            [
+              "u",
+              "arn:override"
+            ],
+            [
+              "t",
+              "cartTotals"
+            ]
+          ])
+        ]
+      ]
+    ]));
+    let entries = StateViewSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfig(config);
+    globalThis.expect(entries.length).toBe(2);
+    let first = entries[0];
+    globalThis.expect(first.specModule).toBe("@x/plugin/src/StateViewSlice/Carts.res.mjs");
+    globalThis.expect(first.projectionModule).toBe("@x/plugin/src/StateViewSlice/Carts_Projection.res.mjs");
+    globalThis.expect(first.queryDbTableName).toBe("qdb_Carts");
+    globalThis.expect(first.sourceUrn).toBe("arn:shared");
+    globalThis.expect(Stdlib_Option.isNone(first.stateTopicName)).toBe(true);
+    globalThis.expect(Stdlib_Option.map(first.pgConnection, cc => cc.host)).toEqual("db.local");
+    let second = entries[1];
+    globalThis.expect(second.sourceUrn).toBe("arn:override");
+    globalThis.expect(second.stateTopicName).toEqual("cartTotals");
+  });
+  globalThis.test("passes legacy full-key entries through with per-entry fields", () => {
+    let config = JSON.stringify(Object.fromEntries([
+      [
+        "base",
+        "ignored/"
+      ],
+      [
+        "sourceUrn",
+        "arn:shared"
+      ],
+      [
+        "handlers",
+        [Object.fromEntries([
+            [
+              "specModule",
+              "full/Carts.res.mjs"
+            ],
+            [
+              "projectionModule",
+              "full/Carts_Projection.res.mjs"
+            ],
+            [
+              "queryDbTableName",
+              "qdb_Carts"
+            ],
+            [
+              "sourceUrn",
+              "arn:own"
+            ]
+          ])]
+      ]
+    ]));
+    let e = StateViewSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfig(config)[0];
+    globalThis.expect(e.specModule).toBe("full/Carts.res.mjs");
+    globalThis.expect(e.projectionModule).toBe("full/Carts_Projection.res.mjs");
+    globalThis.expect(e.sourceUrn).toBe("arn:own");
+    globalThis.expect(Stdlib_Option.isNone(e.pgConnection)).toBe(true);
+  });
+});
+
+globalThis.describe("StateViewSliceEntryPoint_Ops.decodeEnvelope", () => {
+  globalThis.test("surfaces event/recordedAt from the envelope", () => {
+    let envelope = Object.fromEntries([
+      [
+        "id",
+        "evt-1"
+      ],
+      [
+        "event",
+        "payload"
+      ],
+      [
+        "meta",
+        Object.fromEntries([[
+            "service",
+            "Carts"
+          ]])
+      ],
+      [
+        "recordedAt",
+        "2026-07-27T00:00:00Z"
+      ]
+    ]);
+    let decoded = StateViewSliceEntryPoint_Ops$ReventlessAws.decodeEnvelope(envelope);
+    globalThis.expect(decoded.event).toEqual("payload");
+    globalThis.expect(decoded.recordedAt).toBe("2026-07-27T00:00:00Z");
+  });
+  globalThis.test("falls back to the whole json for bare / null-event records", () => {
+    let bare = Object.fromEntries([[
+        "kind",
+        "CartCreated"
+      ]]);
+    globalThis.expect(StateViewSliceEntryPoint_Ops$ReventlessAws.decodeEnvelope(bare).event).toEqual(bare);
+    let nullEvent = Object.fromEntries([
+      [
+        "event",
+        null
+      ],
+      [
+        "recordedAt",
+        "t"
+      ]
+    ]);
+    globalThis.expect(StateViewSliceEntryPoint_Ops$ReventlessAws.decodeEnvelope(nullEvent).event).toEqual(nullEvent);
+    globalThis.expect(StateViewSliceEntryPoint_Ops$ReventlessAws.decodeEnvelope(bare).recordedAt).toBe("");
+  });
+});
+
+globalThis.describe("StateViewSliceEntryPoint_Ops.makeJsonEventsHandler", () => {
+  let makeStub = saved => ({
+    load: async param => ({
+      TAG: "Ok",
+      _0: []
+    }),
+    loadStream: param => Stream.fromIterable([]),
+    save: async (id, state, _mode, _ttl) => {
+      saved.push([
+        id,
+        state
+      ]);
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    },
+    saveBatch: async items => {
+      items.forEach(param => {
+        saved.push([
+          param[0],
+          param[1]
+        ]);
+      });
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    },
+    count: async (param, param$1, param$2) => ({
+      TAG: "Ok",
+      _0: 0
+    }),
+    delete: async (param, param$1) => ({
+      TAG: "Ok",
+      _0: undefined
+    }),
+    deleteBatch: async param => ({
+      TAG: "Ok",
+      _0: undefined
+    })
+  });
+  let project = param => [{
+      TAG: "Set",
+      _0: param.event,
+      _1: param.recordedAt
+    }];
+  globalThis.test("decodes envelopes, projects, and runs actions against the ops", async () => {
+    let saved = [];
+    let handler = StateViewSliceEntryPoint_Ops$ReventlessAws.makeJsonEventsHandler("TestSlice", S.string, project, makeStub(saved), undefined);
+    let envelope = Object.fromEntries([
+      [
+        "event",
+        "row-1"
+      ],
+      [
+        "recordedAt",
+        "2026-07-27"
+      ]
+    ]);
+    await Effect.runPromise(handler(Stream.fromIterable([
+      envelope,
+      "row-2"
+    ])));
+    globalThis.expect(saved).toEqual([
+      [
+        "row-1",
+        "2026-07-27"
+      ],
+      [
+        "row-2",
+        ""
+      ]
+    ]);
+  });
+  globalThis.test("a decode failure yields no actions and does not wedge the batch", async () => {
+    let saved = [];
+    let handler = StateViewSliceEntryPoint_Ops$ReventlessAws.makeJsonEventsHandler("TestSlice", S.string, project, makeStub(saved), undefined);
+    await Effect.runPromise(handler(Stream.fromIterable([
+      42,
+      "row-after"
+    ])));
+    globalThis.expect(saved).toEqual([[
+        "row-after",
+        ""
+      ]]);
+  });
+});
+
+export {
+  str,
+  obj,
+}
+/*  Not a pure module */

package/tests/TaskBucketEntryPoint_OpsTest.res

@@ -0,0 +1,117 @@
+// Guards the typed cold-start core hoisted out of TaskBucketEntryPoint.mjs:
+//   - parseHandlerConfig — the callbackModule / publishToAggregates /
+//     scheduler env-indirection contract.
+//   - buildPublishCommands — env-var queue resolution incl. the skip on
+//     unset/empty URLs.
+//   - dispatchTaskActions — the exhaustive task-action dispatch (publish
+//     routing, schedule create/delete, and the no-scheduler skip paths).
+
+open JestGlobals
+
+let str = JSON.Encode.string
+let obj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+
+@val @scope("process") external processEnv: dict<string> = "env"
+
+describe("TaskBucketEntryPoint_Ops.parseHandlerConfig", () => {
+  testSync("empty raw config decodes to empty defaults", () => {
+    let c = TaskBucketEntryPoint_Ops.parseHandlerConfig("")
+    expect(c.callbackModule)->toBe("")
+    expect(c.publishToAggregates->Dict.toArray->Array.length)->toBe(0)
+    expect(c.scheduler->Option.isNone)->toBe(true)
+  })
+
+  testSync("decodes callbackModule, publishToAggregates, and scheduler env names", () => {
+    let config = obj([
+      ("callbackModule", str("@x/plugin/src/Task/ImportCatalog.res.mjs")),
+      ("publishToAggregates", obj([("Product", str("PTA_Product_QUEUE_URL"))])),
+      (
+        "scheduler",
+        obj([
+          ("roleArnEnv", str("SCHEDULER_ROLE_ARN")),
+          ("targetArnEnv", str("SCHEDULER_TARGET_ARN")),
+          ("targetNameEnv", str("SCHEDULER_TARGET_NAME")),
+        ]),
+      ),
+    ])->JSON.stringify
+    let c = TaskBucketEntryPoint_Ops.parseHandlerConfig(config)
+    expect(c.callbackModule)->toBe("@x/plugin/src/Task/ImportCatalog.res.mjs")
+    expect(c.publishToAggregates->Dict.get("Product"))->toEqual(Some("PTA_Product_QUEUE_URL"))
+    switch c.scheduler {
+    | Some(s) => expect(s.roleArnEnv)->toBe("SCHEDULER_ROLE_ARN")
+    | None => JsError.throwWithMessage("expected Some(scheduler)")
+    }
+  })
+})
+
+describe("TaskBucketEntryPoint_Ops.buildPublishCommands", () => {
+  testSync("resolves queue URLs via env vars, skipping unset or empty ones", () => {
+    processEnv->Dict.set("TB_TEST_QUEUE_A", "https://sqs/a.fifo")
+    processEnv->Dict.set("TB_TEST_QUEUE_EMPTY", "")
+    let map = Dict.fromArray([
+      ("AggA", "TB_TEST_QUEUE_A"),
+      ("AggEmpty", "TB_TEST_QUEUE_EMPTY"),
+      ("AggUnset", "TB_TEST_QUEUE_UNSET"),
+    ])
+    let publish = TaskBucketEntryPoint_Ops.buildPublishCommands(map)
+    expect(publish->Dict.get("AggA")->Option.isSome)->toBe(true)
+    expect(publish->Dict.get("AggEmpty")->Option.isNone)->toBe(true)
+    expect(publish->Dict.get("AggUnset")->Option.isNone)->toBe(true)
+  })
+})
+
+describe("TaskBucketEntryPoint_Ops.dispatchTaskActions", () => {
+  let schedule: Reventless.Schedule.schedule = {
+    name: "sweep",
+    rate: Reventless.Schedule.Minutes(5),
+    payload: "{}",
+  }
+
+  test("routes PublishCommands to the aggregate's publish fn", async () => {
+    let published = []
+    let publishCommands = Dict.fromArray([
+      (
+        "Product",
+        (
+          async cmds => {
+            published->Array.push(cmds)
+          }: ReventlessCore.CommandTopic.publishJsons
+        ),
+      ),
+    ])
+    await TaskBucketEntryPoint_Ops.dispatchTaskActions(
+      ~actions=[
+        Reventless.Task.PublishCommands("Product", []),
+        // Unknown aggregate — logged, not thrown.
+        Reventless.Task.PublishCommands("Nope", []),
+      ],
+      ~publishCommands,
+      ~schedulerOps=() => None,
+    )
+    expect(published->Array.length)->toBe(1)
+  })
+
+  test("routes schedule actions to the scheduler ops; skips when unconfigured", async () => {
+    let created = []
+    let deleted = []
+    let ops: TaskBucketEntryPoint_Ops.schedulerOps = {
+      createSchedule: async s => created->Array.push(s.name),
+      deleteSchedule: async name => deleted->Array.push(name),
+    }
+    await TaskBucketEntryPoint_Ops.dispatchTaskActions(
+      ~actions=[Reventless.Task.CreateSchedule(schedule), Reventless.Task.DeleteSchedule("sweep")],
+      ~publishCommands=Dict.make(),
+      ~schedulerOps=() => Some(ops),
+    )
+    expect(created)->toEqual(["sweep"])
+    expect(deleted)->toEqual(["sweep"])
+
+    // No scheduler configured — both actions skip without throwing.
+    await TaskBucketEntryPoint_Ops.dispatchTaskActions(
+      ~actions=[Reventless.Task.CreateSchedule(schedule), Reventless.Task.DeleteSchedule("sweep")],
+      ~publishCommands=Dict.make(),
+      ~schedulerOps=() => None,
+    )
+    expect(created->Array.length)->toBe(1)
+  })
+})

package/tests/TaskBucketEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,165 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as TaskBucketEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/TaskBucketEntryPoint_Ops.res.mjs";
+
+function str(prim) {
+  return prim;
+}
+
+function obj(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+globalThis.describe("TaskBucketEntryPoint_Ops.parseHandlerConfig", () => {
+  globalThis.test("empty raw config decodes to empty defaults", () => {
+    let c = TaskBucketEntryPoint_Ops$ReventlessAws.parseHandlerConfig("");
+    globalThis.expect(c.callbackModule).toBe("");
+    globalThis.expect(Object.entries(c.publishToAggregates).length).toBe(0);
+    globalThis.expect(Stdlib_Option.isNone(c.scheduler)).toBe(true);
+  });
+  globalThis.test("decodes callbackModule, publishToAggregates, and scheduler env names", () => {
+    let config = JSON.stringify(Object.fromEntries([
+      [
+        "callbackModule",
+        "@x/plugin/src/Task/ImportCatalog.res.mjs"
+      ],
+      [
+        "publishToAggregates",
+        Object.fromEntries([[
+            "Product",
+            "PTA_Product_QUEUE_URL"
+          ]])
+      ],
+      [
+        "scheduler",
+        Object.fromEntries([
+          [
+            "roleArnEnv",
+            "SCHEDULER_ROLE_ARN"
+          ],
+          [
+            "targetArnEnv",
+            "SCHEDULER_TARGET_ARN"
+          ],
+          [
+            "targetNameEnv",
+            "SCHEDULER_TARGET_NAME"
+          ]
+        ])
+      ]
+    ]));
+    let c = TaskBucketEntryPoint_Ops$ReventlessAws.parseHandlerConfig(config);
+    globalThis.expect(c.callbackModule).toBe("@x/plugin/src/Task/ImportCatalog.res.mjs");
+    globalThis.expect(c.publishToAggregates["Product"]).toEqual("PTA_Product_QUEUE_URL");
+    let s = c.scheduler;
+    if (s !== undefined) {
+      globalThis.expect(s.roleArnEnv).toBe("SCHEDULER_ROLE_ARN");
+      return;
+    } else {
+      return Stdlib_JsError.throwWithMessage("expected Some(scheduler)");
+    }
+  });
+});
+
+globalThis.describe("TaskBucketEntryPoint_Ops.buildPublishCommands", () => {
+  globalThis.test("resolves queue URLs via env vars, skipping unset or empty ones", () => {
+    process.env["TB_TEST_QUEUE_A"] = "https://sqs/a.fifo";
+    process.env["TB_TEST_QUEUE_EMPTY"] = "";
+    let map = Object.fromEntries([
+      [
+        "AggA",
+        "TB_TEST_QUEUE_A"
+      ],
+      [
+        "AggEmpty",
+        "TB_TEST_QUEUE_EMPTY"
+      ],
+      [
+        "AggUnset",
+        "TB_TEST_QUEUE_UNSET"
+      ]
+    ]);
+    let publish = TaskBucketEntryPoint_Ops$ReventlessAws.buildPublishCommands(map);
+    globalThis.expect(Stdlib_Option.isSome(publish["AggA"])).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(publish["AggEmpty"])).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(publish["AggUnset"])).toBe(true);
+  });
+});
+
+globalThis.describe("TaskBucketEntryPoint_Ops.dispatchTaskActions", () => {
+  let schedule = {
+    name: "sweep",
+    rate: {
+      TAG: "Minutes",
+      _0: 5
+    },
+    payload: "{}"
+  };
+  globalThis.test("routes PublishCommands to the aggregate's publish fn", async () => {
+    let published = [];
+    let publishCommands = Object.fromEntries([[
+        "Product",
+        async cmds => {
+          published.push(cmds);
+        }
+      ]]);
+    await TaskBucketEntryPoint_Ops$ReventlessAws.dispatchTaskActions([
+      {
+        TAG: "PublishCommands",
+        _0: "Product",
+        _1: []
+      },
+      {
+        TAG: "PublishCommands",
+        _0: "Nope",
+        _1: []
+      }
+    ], publishCommands, () => {});
+    globalThis.expect(published.length).toBe(1);
+  });
+  globalThis.test("routes schedule actions to the scheduler ops; skips when unconfigured", async () => {
+    let created = [];
+    let deleted = [];
+    let ops_createSchedule = async s => {
+      created.push(s.name);
+    };
+    let ops_deleteSchedule = async name => {
+      deleted.push(name);
+    };
+    let ops = {
+      createSchedule: ops_createSchedule,
+      deleteSchedule: ops_deleteSchedule
+    };
+    await TaskBucketEntryPoint_Ops$ReventlessAws.dispatchTaskActions([
+      {
+        TAG: "CreateSchedule",
+        _0: schedule
+      },
+      {
+        TAG: "DeleteSchedule",
+        _0: "sweep"
+      }
+    ], {}, () => ops);
+    globalThis.expect(created).toEqual(["sweep"]);
+    globalThis.expect(deleted).toEqual(["sweep"]);
+    await TaskBucketEntryPoint_Ops$ReventlessAws.dispatchTaskActions([
+      {
+        TAG: "CreateSchedule",
+        _0: schedule
+      },
+      {
+        TAG: "DeleteSchedule",
+        _0: "sweep"
+      }
+    ], {}, () => {});
+    globalThis.expect(created.length).toBe(1);
+  });
+});
+
+export {
+  str,
+  obj,
+}
+/*  Not a pure module */

package/tests/integration/StateViewSliceEntryPoint_IntegrationTest.res

@@ -1,5 +1,6 @@
 // Integration regression guard for the StateViewSlice projection Lambda entry
-// point (`StateViewSliceEntryPoint.mjs`), run against DynamoDB Local.
+// point (`StateViewSliceEntryPoint.mjs` + `StateViewSliceEntryPoint_Ops.res`),
+// run against DynamoDB Local.
 //
 // Covers the 2026-07-09 incident: the deployed runtime built its projection
 // loop with `handleAction(action, queryDbOps, undefined)` — hardcoding
@@ -8,8 +9,10 @@
 // then hit the `MissingSubIdConfig` guard and silently wrote nothing, while the
 // in-memory GWT/callback path (which threads `subIdConfig`) stayed green. This
 // is a deployed-runtime vs test-harness parity gap: a unit test on the callback
-// path cannot catch it, so this test drives the *real* `.mjs` entry point that
-// production uses.
+// path cannot catch it, so this test drives the real entry-point wiring the
+// production shell uses — `makeRegisteredHandler` with the modules record read
+// off the dynamically imported spec/projection modules, invoked with an
+// SQS-shaped Lambda record so the full decode path runs.
 //
 // The fixture `SvsTestSlice` is an `@subId productId` view slice whose only
 // projection path is `UpdateMultiState`. Before the fix both appends no-op and
@@ -48,26 +51,52 @@ let createViewTable = async (tableName): Util_DynamoDb_Runtime.resolvedTable =>
   }
 }
 
-// Drives the real entry point: builds the handler via its exported
-// `buildJsonEventsHandler` factory (DynamoDB path — `pgConnection`/`stateTopicName`
-// undefined), feeds one encoded event through the effect Stream, and runs the
-// resulting Effect through the request context the production handler supplies.
+// Drives the real entry-point wiring: mirrors the shell's untyped seam line for
+// line — a HANDLER_CONFIG-shaped entry (DynamoDB path — `pgConnection`/
+// `stateTopicName` undefined) plus the modules record read off the dynamically
+// imported spec/projection modules — then feeds one SQS-shaped Lambda record
+// through the registered stream handler, so the same decode path the deployed
+// Lambda runs (handleStreamEvent → envelope decode → schema parse → project →
+// handleAction) is exercised end to end.
 let runOneEvent: (string, JSON.t) => promise<unit> = %raw(`
   async (tableName, eventJson) => {
-    const { buildJsonEventsHandler } = await import(
-      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint.mjs"
+    const Ops = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res.mjs"
     );
     const specModule = await import("./SvsTestSlice.res.mjs");
     const projectionModule = await import("./SvsTestSlice_Projection.res.mjs");
     const Effect = await import("effect/Effect");
-    const Stream = await import("effect/Stream");
     const { tag: requestContextTag } = await import(
       "@reventlessdev/reventless-core/src/RequestContext.res.mjs"
     );
 
-    const handler = buildJsonEventsHandler(specModule, projectionModule, tableName, undefined, undefined);
-    const stream = Stream.fromIterable([eventJson]);
-    const effect = handler(stream)
+    const registered = Ops.makeRegisteredHandler(
+      {
+        specModule: "",
+        projectionModule: "",
+        queryDbTableName: tableName,
+        sourceUrn: "svs-test-urn",
+        stateTopicName: undefined,
+        pgConnection: undefined,
+      },
+      {
+        name: specModule.name,
+        consumedEventSchema: specModule.consumedEventSchema,
+        project: projectionModule.project,
+        config: specModule.config,
+        subIdConfig: specModule.subIdConfig,
+      },
+    );
+    const event = {
+      Records: [
+        {
+          eventSource: "aws:sqs",
+          eventSourceARN: "svs-test-urn",
+          body: JSON.stringify(eventJson),
+        },
+      ],
+    };
+    const effect = registered.handler(event, {})
       .pipe(Effect.provideService(requestContextTag, { correlationId: "svs-test" }));
     await Effect.runPromise(effect);
   }