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

package/tests/ReadModelEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,267 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stream from "effect/Stream";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as ReadModelEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/ReadModelEntryPoint_Ops.res.mjs";
+
+function str(prim) {
+  return prim;
+}
+
+function obj(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+globalThis.describe("ReadModelEntryPoint_Ops.parseHandlerConfig", () => {
+  globalThis.test("empty raw config yields no handlers", () => {
+    globalThis.expect(ReadModelEntryPoint_Ops$ReventlessAws.parseHandlerConfig("").length).toBe(0);
+    globalThis.expect(ReadModelEntryPoint_Ops$ReventlessAws.parseHandlerConfig(`{"handlers":[]}`).length).toBe(0);
+  });
+  globalThis.test("decodes a full entry incl. attribution and Postgres fields", () => {
+    let config = JSON.stringify(Object.fromEntries([[
+        "handlers",
+        [Object.fromEntries([
+            [
+              "specModule",
+              "@x/spec/src/ReadModel/Products.res.mjs"
+            ],
+            [
+              "mappingsModule",
+              "@x/spec/src/ReadModel/Products_Projections.res.mjs"
+            ],
+            [
+              "queryDbTableName",
+              "Products-abc"
+            ],
+            [
+              "sourceUrn",
+              "arn:aws:sqs:eu-west-1:1:q"
+            ],
+            [
+              "comp",
+              "EventCollector(ProductsEC)"
+            ],
+            [
+              "plugin",
+              "Catalog"
+            ],
+            [
+              "stateTopicName",
+              "catalogProducts"
+            ],
+            [
+              "pgConnection",
+              Object.fromEntries([
+                [
+                  "host",
+                  "db.local"
+                ],
+                [
+                  "port",
+                  5432
+                ],
+                [
+                  "database",
+                  "app"
+                ],
+                [
+                  "username",
+                  "master"
+                ],
+                [
+                  "secretArn",
+                  "arn:secret"
+                ]
+              ])
+            ]
+          ])]
+      ]]));
+    let entries = ReadModelEntryPoint_Ops$ReventlessAws.parseHandlerConfig(config);
+    globalThis.expect(entries.length).toBe(1);
+    let e = entries[0];
+    globalThis.expect(e.specModule).toBe("@x/spec/src/ReadModel/Products.res.mjs");
+    globalThis.expect(e.mappingsModule).toBe("@x/spec/src/ReadModel/Products_Projections.res.mjs");
+    globalThis.expect(e.queryDbTableName).toBe("Products-abc");
+    globalThis.expect(e.sourceUrn).toBe("arn:aws:sqs:eu-west-1:1:q");
+    globalThis.expect(e.comp).toEqual("EventCollector(ProductsEC)");
+    globalThis.expect(e.plugin).toEqual("Catalog");
+    globalThis.expect(e.stateTopicName).toEqual("catalogProducts");
+    let cc = e.pgConnection;
+    if (cc !== undefined) {
+      globalThis.expect(cc.host).toBe("db.local");
+      globalThis.expect(cc.port).toBe(5432);
+      globalThis.expect(cc.database).toBe("app");
+      return;
+    } else {
+      return Stdlib_JsError.throwWithMessage("expected Some(pgConnection)");
+    }
+  });
+  globalThis.test("optional fields default to None; null pgConnection maps to None", () => {
+    let config = JSON.stringify(Object.fromEntries([[
+        "handlers",
+        [Object.fromEntries([
+            [
+              "specModule",
+              "a.res.mjs"
+            ],
+            [
+              "mappingsModule",
+              "b.res.mjs"
+            ],
+            [
+              "queryDbTableName",
+              "t"
+            ],
+            [
+              "sourceUrn",
+              "u"
+            ],
+            [
+              "pgConnection",
+              null
+            ]
+          ])]
+      ]]));
+    let e = ReadModelEntryPoint_Ops$ReventlessAws.parseHandlerConfig(config)[0];
+    globalThis.expect(Stdlib_Option.isNone(e.comp)).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(e.plugin)).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(e.stateTopicName)).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(e.pgConnection)).toBe(true);
+  });
+});
+
+globalThis.describe("ReadModelEntryPoint_Ops.injectId", () => {
+  globalThis.test("injects (and overwrites) id on object states", () => {
+    globalThis.expect(ReadModelEntryPoint_Ops$ReventlessAws.injectId("p-1", Object.fromEntries([[
+        "name",
+        "Widget"
+      ]]))).toEqual(Object.fromEntries([
+      [
+        "name",
+        "Widget"
+      ],
+      [
+        "id",
+        "p-1"
+      ]
+    ]));
+    globalThis.expect(ReadModelEntryPoint_Ops$ReventlessAws.injectId("p-1", Object.fromEntries([[
+        "id",
+        "stale"
+      ]]))).toEqual(Object.fromEntries([[
+        "id",
+        "p-1"
+      ]]));
+  });
+  globalThis.test("passes non-object states through unchanged", () => {
+    globalThis.expect(ReadModelEntryPoint_Ops$ReventlessAws.injectId("p-1", "scalar")).toEqual("scalar");
+    globalThis.expect(ReadModelEntryPoint_Ops$ReventlessAws.injectId("p-1", ["a"])).toEqual(["a"]);
+    globalThis.expect(ReadModelEntryPoint_Ops$ReventlessAws.injectId("p-1", null)).toEqual(null);
+  });
+});
+
+globalThis.describe("ReadModelEntryPoint_Ops.withInjectedId", () => {
+  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
+    })
+  });
+  globalThis.test("save and saveBatch write id-injected states", async () => {
+    let saved = [];
+    let ops = ReadModelEntryPoint_Ops$ReventlessAws.withInjectedId(makeStub(saved));
+    await ops.save("p-1", Object.fromEntries([[
+        "name",
+        "A"
+      ]]), "Any", undefined);
+    await ops.saveBatch([
+      [
+        "p-2",
+        Object.fromEntries([[
+            "name",
+            "B"
+          ]]),
+        undefined
+      ],
+      [
+        "p-3",
+        "scalar",
+        undefined
+      ]
+    ]);
+    globalThis.expect(saved).toEqual([
+      [
+        "p-1",
+        Object.fromEntries([
+          [
+            "name",
+            "A"
+          ],
+          [
+            "id",
+            "p-1"
+          ]
+        ])
+      ],
+      [
+        "p-2",
+        Object.fromEntries([
+          [
+            "name",
+            "B"
+          ],
+          [
+            "id",
+            "p-2"
+          ]
+        ])
+      ],
+      [
+        "p-3",
+        "scalar"
+      ]
+    ]);
+  });
+});
+
+export {
+  str,
+  obj,
+}
+/*  Not a pure module */

package/tests/SideEffectEntryPoint_OpsTest.res

@@ -0,0 +1,79 @@
+// Guards the typed cold-start core hoisted out of SideEffectEntryPoint.mjs:
+//   - parseHandlerConfig — the {handlers:[{sideEffectModules, sourceUrn,
+//     comp, plugin}]} shape written by SideEffectHandlerRuntime_Builder_Single;
+//     a drift here silently drops a side effect's stream subscription.
+//   - makeRegisteredHandler — comp/plugin attribution threading into the
+//     shared routed dispatch boundary.
+
+open JestGlobals
+
+let str = JSON.Encode.string
+let obj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+
+describe("SideEffectEntryPoint_Ops.parseHandlerConfig", () => {
+  testSync("empty raw config yields no handlers", () => {
+    expect(SideEffectEntryPoint_Ops.parseHandlerConfig("")->Array.length)->toBe(0)
+  })
+
+  testSync("decodes handlers incl. attribution fields", () => {
+    let config = obj([
+      (
+        "handlers",
+        JSON.Encode.array([
+          obj([
+            ("sideEffectModules", JSON.Encode.array([str("@x/p/src/A.res.mjs"), str("@x/p/src/B.res.mjs")])),
+            ("sourceUrn", str("arn:stream-1")),
+            ("comp", str("SideEffectHandler(Mailer)")),
+            ("plugin", str("Ordering")),
+          ]),
+          obj([
+            ("sideEffectModules", JSON.Encode.array([str("@x/p/src/C.res.mjs")])),
+            ("sourceUrn", str("arn:stream-2")),
+          ]),
+        ]),
+      ),
+    ])->JSON.stringify
+    let entries = SideEffectEntryPoint_Ops.parseHandlerConfig(config)
+    expect(entries->Array.length)->toBe(2)
+    let first = entries->Array.getUnsafe(0)
+    expect(first.sourceUrn)->toBe("arn:stream-1")
+    expect(first.sideEffectModules)->toEqual(["@x/p/src/A.res.mjs", "@x/p/src/B.res.mjs"])
+    expect(first.comp)->toEqual(Some("SideEffectHandler(Mailer)"))
+    expect(first.plugin)->toEqual(Some("Ordering"))
+    let second = entries->Array.getUnsafe(1)
+    expect(second.comp->Option.isNone)->toBe(true)
+    expect(second.plugin->Option.isNone)->toBe(true)
+  })
+})
+
+describe("SideEffectEntryPoint_Ops.noopQueryEngine", () => {
+  test("returns empty results for scan and query", async () => {
+    let scanned = await SideEffectEntryPoint_Ops.noopQueryEngine.scan(
+      ~readModelName="X",
+      ~filterConfigs=[],
+      ~limit=10,
+    )
+    expect(scanned->Array.length)->toBe(0)
+    let queried = await SideEffectEntryPoint_Ops.noopQueryEngine.query(
+      ~readModelName="X",
+      ~id=Reventless.QueryEngine.String("a"),
+    )
+    expect(queried->Array.length)->toBe(0)
+  })
+})
+
+describe("SideEffectEntryPoint_Ops.makeRegisteredHandler", () => {
+  testSync("threads comp/plugin onto the registered handler", () => {
+    let entry: SideEffectEntryPoint_Ops.handlerEntry = {
+      sourceUrn: "arn:stream-1",
+      sideEffectModules: [],
+      comp: Some("SideEffectHandler(Mailer)"),
+      plugin: Some("Ordering"),
+    }
+    let registered = SideEffectEntryPoint_Ops.makeRegisteredHandler(entry, _stream =>
+      Effect.succeed()
+    )
+    expect(registered.comp)->toEqual(Some("SideEffectHandler(Mailer)"))
+    expect(registered.plugin)->toEqual(Some("Ordering"))
+  })
+})

package/tests/SideEffectEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,105 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as SideEffectEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/SideEffectEntryPoint_Ops.res.mjs";
+
+function str(prim) {
+  return prim;
+}
+
+function obj(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+globalThis.describe("SideEffectEntryPoint_Ops.parseHandlerConfig", () => {
+  globalThis.test("empty raw config yields no handlers", () => {
+    globalThis.expect(SideEffectEntryPoint_Ops$ReventlessAws.parseHandlerConfig("").length).toBe(0);
+  });
+  globalThis.test("decodes handlers incl. attribution fields", () => {
+    let config = JSON.stringify(Object.fromEntries([[
+        "handlers",
+        [
+          Object.fromEntries([
+            [
+              "sideEffectModules",
+              [
+                "@x/p/src/A.res.mjs",
+                "@x/p/src/B.res.mjs"
+              ]
+            ],
+            [
+              "sourceUrn",
+              "arn:stream-1"
+            ],
+            [
+              "comp",
+              "SideEffectHandler(Mailer)"
+            ],
+            [
+              "plugin",
+              "Ordering"
+            ]
+          ]),
+          Object.fromEntries([
+            [
+              "sideEffectModules",
+              ["@x/p/src/C.res.mjs"]
+            ],
+            [
+              "sourceUrn",
+              "arn:stream-2"
+            ]
+          ])
+        ]
+      ]]));
+    let entries = SideEffectEntryPoint_Ops$ReventlessAws.parseHandlerConfig(config);
+    globalThis.expect(entries.length).toBe(2);
+    let first = entries[0];
+    globalThis.expect(first.sourceUrn).toBe("arn:stream-1");
+    globalThis.expect(first.sideEffectModules).toEqual([
+      "@x/p/src/A.res.mjs",
+      "@x/p/src/B.res.mjs"
+    ]);
+    globalThis.expect(first.comp).toEqual("SideEffectHandler(Mailer)");
+    globalThis.expect(first.plugin).toEqual("Ordering");
+    let second = entries[1];
+    globalThis.expect(Stdlib_Option.isNone(second.comp)).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(second.plugin)).toBe(true);
+  });
+});
+
+globalThis.describe("SideEffectEntryPoint_Ops.noopQueryEngine", () => {
+  globalThis.test("returns empty results for scan and query", async () => {
+    let scanned = await SideEffectEntryPoint_Ops$ReventlessAws.noopQueryEngine.scan("X", [], 10);
+    globalThis.expect(scanned.length).toBe(0);
+    let queried = await SideEffectEntryPoint_Ops$ReventlessAws.noopQueryEngine.query("X", undefined, {
+      TAG: "String",
+      _0: "a"
+    }, undefined, undefined, undefined, undefined);
+    globalThis.expect(queried.length).toBe(0);
+  });
+});
+
+globalThis.describe("SideEffectEntryPoint_Ops.makeRegisteredHandler", () => {
+  globalThis.test("threads comp/plugin onto the registered handler", () => {
+    let entry_sideEffectModules = [];
+    let entry_comp = "SideEffectHandler(Mailer)";
+    let entry_plugin = "Ordering";
+    let entry = {
+      sourceUrn: "arn:stream-1",
+      sideEffectModules: entry_sideEffectModules,
+      comp: entry_comp,
+      plugin: entry_plugin
+    };
+    let registered = SideEffectEntryPoint_Ops$ReventlessAws.makeRegisteredHandler(entry, _stream => Effect.succeed());
+    globalThis.expect(registered.comp).toEqual("SideEffectHandler(Mailer)");
+    globalThis.expect(registered.plugin).toEqual("Ordering");
+  });
+});
+
+export {
+  str,
+  obj,
+}
+/*  Not a pure module */

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(""))])
+  })
+})