@reventlessdev/reventless-aws 3.0.0-alpha.232 → 3.0.0-alpha.234

package/tests/StateViewSliceEntryPoint_OpsTest.res

@@ -0,0 +1,167 @@
+// Guards the typed cold-start core hoisted out of StateViewSliceEntryPoint.mjs:
+//   - parseHandlerConfig — the compact-v2 HANDLER_CONFIG expansion (shared
+//     base / sourceUrn / pgConnection, shortened s/p/q/u/t keys) and the legacy
+//     full-key pass-through; a drift here mis-routes or mis-backends every
+//     view slice of a plugin at cold start.
+//   - decodeEnvelope — the `{event, meta, recordedAt}` envelope rule incl. the
+//     bare-event fallback.
+//   - makeJsonEventsHandler — the projection stream pipeline: schema parse →
+//     project → handleAction, with decode failures logged and skipped instead
+//     of wedging the batch.
+
+open JestGlobals
+
+let str = JSON.Encode.string
+let obj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+
+describe("StateViewSliceEntryPoint_Ops.parseHandlerConfig", () => {
+  testSync("empty raw config yields no handlers", () => {
+    expect(StateViewSliceEntryPoint_Ops.parseHandlerConfig("")->Array.length)->toBe(0)
+  })
+
+  testSync("expands compact-v2 entries against shared base/sourceUrn/pgConnection", () => {
+    let config = obj([
+      ("v", JSON.Encode.int(2)),
+      ("base", str("@x/plugin/src/StateViewSlice/")),
+      ("sourceUrn", str("arn:shared")),
+      (
+        "pgConnection",
+        obj([
+          ("host", str("db.local")),
+          ("port", JSON.Encode.int(5432)),
+          ("database", str("app")),
+          ("username", str("master")),
+          ("secretArn", str("arn:secret")),
+        ]),
+      ),
+      (
+        "handlers",
+        JSON.Encode.array([
+          obj([("s", str("Carts.res.mjs")), ("p", str("Carts_Projection.res.mjs")), ("q", str("qdb_Carts"))]),
+          obj([
+            ("s", str("Totals.res.mjs")),
+            ("p", str("Totals_Projection.res.mjs")),
+            ("q", str("qdb_Totals")),
+            ("u", str("arn:override")),
+            ("t", str("cartTotals")),
+          ]),
+        ]),
+      ),
+    ])->JSON.stringify
+    let entries = StateViewSliceEntryPoint_Ops.parseHandlerConfig(config)
+    expect(entries->Array.length)->toBe(2)
+    let first = entries->Array.getUnsafe(0)
+    expect(first.specModule)->toBe("@x/plugin/src/StateViewSlice/Carts.res.mjs")
+    expect(first.projectionModule)->toBe("@x/plugin/src/StateViewSlice/Carts_Projection.res.mjs")
+    expect(first.queryDbTableName)->toBe("qdb_Carts")
+    expect(first.sourceUrn)->toBe("arn:shared")
+    expect(first.stateTopicName->Option.isNone)->toBe(true)
+    expect(first.pgConnection->Option.map(cc => cc.host))->toEqual(Some("db.local"))
+    let second = entries->Array.getUnsafe(1)
+    expect(second.sourceUrn)->toBe("arn:override")
+    expect(second.stateTopicName)->toEqual(Some("cartTotals"))
+  })
+
+  testSync("passes legacy full-key entries through with per-entry fields", () => {
+    let config = obj([
+      ("base", str("ignored/")),
+      ("sourceUrn", str("arn:shared")),
+      (
+        "handlers",
+        JSON.Encode.array([
+          obj([
+            ("specModule", str("full/Carts.res.mjs")),
+            ("projectionModule", str("full/Carts_Projection.res.mjs")),
+            ("queryDbTableName", str("qdb_Carts")),
+            ("sourceUrn", str("arn:own")),
+          ]),
+        ]),
+      ),
+    ])->JSON.stringify
+    let e = StateViewSliceEntryPoint_Ops.parseHandlerConfig(config)->Array.getUnsafe(0)
+    // Legacy entries are NOT base-prefixed and keep their own sourceUrn.
+    expect(e.specModule)->toBe("full/Carts.res.mjs")
+    expect(e.projectionModule)->toBe("full/Carts_Projection.res.mjs")
+    expect(e.sourceUrn)->toBe("arn:own")
+    expect(e.pgConnection->Option.isNone)->toBe(true)
+  })
+})
+
+describe("StateViewSliceEntryPoint_Ops.decodeEnvelope", () => {
+  testSync("surfaces event/recordedAt from the envelope", () => {
+    let envelope = obj([
+      ("id", str("evt-1")),
+      ("event", str("payload")),
+      ("meta", obj([("service", str("Carts"))])),
+      ("recordedAt", str("2026-07-27T00:00:00Z")),
+    ])
+    let decoded = StateViewSliceEntryPoint_Ops.decodeEnvelope(envelope)
+    expect(decoded.event)->toEqual(str("payload"))
+    expect(decoded.recordedAt)->toBe("2026-07-27T00:00:00Z")
+  })
+
+  testSync("falls back to the whole json for bare / null-event records", () => {
+    let bare = obj([("kind", str("CartCreated"))])
+    expect(StateViewSliceEntryPoint_Ops.decodeEnvelope(bare).event)->toEqual(bare)
+    let nullEvent = obj([("event", JSON.Null), ("recordedAt", str("t"))])
+    expect(StateViewSliceEntryPoint_Ops.decodeEnvelope(nullEvent).event)->toEqual(nullEvent)
+    expect(StateViewSliceEntryPoint_Ops.decodeEnvelope(bare).recordedAt)->toBe("")
+  })
+})
+
+describe("StateViewSliceEntryPoint_Ops.makeJsonEventsHandler", () => {
+  // Capturing stub operation set — Set actions land as saves.
+  let makeStub = (saved: array<(string, JSON.t)>): ReventlessCore.QueryDb_Adapter.operations => {
+    load: async _ => Ok([]),
+    loadStream: _ => Stream.fromIterable([]),
+    save: async (id, state, _mode, _ttl) => {
+      saved->Array.push((id, state))
+      Ok()
+    },
+    saveBatch: async items => {
+      items->Array.forEach(((id, state, _ttl)) => saved->Array.push((id, state)))
+      Ok()
+    },
+    count: async (_, _, _) => Ok(0),
+    delete: async (_, _) => Ok(),
+    deleteBatch: async _ => Ok(),
+  }
+
+  // String-typed consumed events keep the pipeline test independent of any
+  // real slice: each event value becomes the row id, `recordedAt` the state.
+  let project = (
+    {event, recordedAt, _}: Reventless.StateViewSlice.consumed<string>,
+  ): array<Reventless.Projection.action<string, JSON.t>> => [Set(event, str(recordedAt))]
+
+  test("decodes envelopes, projects, and runs actions against the ops", async () => {
+    let saved = []
+    let handler = StateViewSliceEntryPoint_Ops.makeJsonEventsHandler(
+      ~sliceName="TestSlice",
+      ~eventSchema=S.string,
+      ~project,
+      ~queryDbOps=makeStub(saved),
+      ~subIdConfig=None,
+    )
+    let envelope = obj([("event", str("row-1")), ("recordedAt", str("2026-07-27"))])
+    let bare = str("row-2")
+    await Stream.fromIterable([envelope, bare])->handler->Effect.runPromise
+    expect(saved)->toEqual([("row-1", str("2026-07-27")), ("row-2", str(""))])
+  })
+
+  test("a decode failure yields no actions and does not wedge the batch", async () => {
+    let saved = []
+    let handler = StateViewSliceEntryPoint_Ops.makeJsonEventsHandler(
+      ~sliceName="TestSlice",
+      ~eventSchema=S.string,
+      ~project,
+      ~queryDbOps=makeStub(saved),
+      ~subIdConfig=None,
+    )
+    // A number cannot parse as S.string → logged and skipped; the following
+    // record still projects.
+    await Stream.fromIterable([JSON.Encode.int(42), str("row-after")])
+    ->handler
+    ->Effect.runPromise
+    expect(saved)->toEqual([("row-after", str(""))])
+  })
+})

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)
+  })
+})