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

package/tests/ReadModelEntryPoint_OpsTest.res

@@ -0,0 +1,141 @@
+// Guards the typed cold-start core hoisted out of ReadModelEntryPoint.mjs:
+//   - parseHandlerConfig — the HANDLER_CONFIG contract every read-model Lambda
+//     cold-starts on, incl. the optional attribution (comp/plugin) and backend
+//     (pgConnection/stateTopicName) fields.
+//   - injectId / withInjectedId — the id-injection wrap on save/saveBatch;
+//     query resolvers and the live-update publisher read `id` off the row, so
+//     silently dropping the injection would strand every list query.
+
+open JestGlobals
+
+let str = JSON.Encode.string
+let obj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+
+describe("ReadModelEntryPoint_Ops.parseHandlerConfig", () => {
+  testSync("empty raw config yields no handlers", () => {
+    expect(ReadModelEntryPoint_Ops.parseHandlerConfig("")->Array.length)->toBe(0)
+    expect(ReadModelEntryPoint_Ops.parseHandlerConfig(`{"handlers":[]}`)->Array.length)->toBe(0)
+  })
+
+  testSync("decodes a full entry incl. attribution and Postgres fields", () => {
+    let config = obj([
+      (
+        "handlers",
+        JSON.Encode.array([
+          obj([
+            ("specModule", str("@x/spec/src/ReadModel/Products.res.mjs")),
+            ("mappingsModule", str("@x/spec/src/ReadModel/Products_Projections.res.mjs")),
+            ("queryDbTableName", str("Products-abc")),
+            ("sourceUrn", str("arn:aws:sqs:eu-west-1:1:q")),
+            ("comp", str("EventCollector(ProductsEC)")),
+            ("plugin", str("Catalog")),
+            ("stateTopicName", str("catalogProducts")),
+            (
+              "pgConnection",
+              obj([
+                ("host", str("db.local")),
+                ("port", JSON.Encode.int(5432)),
+                ("database", str("app")),
+                ("username", str("master")),
+                ("secretArn", str("arn:secret")),
+              ]),
+            ),
+          ]),
+        ]),
+      ),
+    ])->JSON.stringify
+    let entries = ReadModelEntryPoint_Ops.parseHandlerConfig(config)
+    expect(entries->Array.length)->toBe(1)
+    let e = entries->Array.getUnsafe(0)
+    expect(e.specModule)->toBe("@x/spec/src/ReadModel/Products.res.mjs")
+    expect(e.mappingsModule)->toBe("@x/spec/src/ReadModel/Products_Projections.res.mjs")
+    expect(e.queryDbTableName)->toBe("Products-abc")
+    expect(e.sourceUrn)->toBe("arn:aws:sqs:eu-west-1:1:q")
+    expect(e.comp)->toEqual(Some("EventCollector(ProductsEC)"))
+    expect(e.plugin)->toEqual(Some("Catalog"))
+    expect(e.stateTopicName)->toEqual(Some("catalogProducts"))
+    switch e.pgConnection {
+    | Some(cc) => {
+        expect(cc.host)->toBe("db.local")
+        expect(cc.port)->toBe(5432)
+        expect(cc.database)->toBe("app")
+      }
+    | None => JsError.throwWithMessage("expected Some(pgConnection)")
+    }
+  })
+
+  testSync("optional fields default to None; null pgConnection maps to None", () => {
+    let config = obj([
+      (
+        "handlers",
+        JSON.Encode.array([
+          obj([
+            ("specModule", str("a.res.mjs")),
+            ("mappingsModule", str("b.res.mjs")),
+            ("queryDbTableName", str("t")),
+            ("sourceUrn", str("u")),
+            ("pgConnection", JSON.Null),
+          ]),
+        ]),
+      ),
+    ])->JSON.stringify
+    let e = ReadModelEntryPoint_Ops.parseHandlerConfig(config)->Array.getUnsafe(0)
+    expect(e.comp->Option.isNone)->toBe(true)
+    expect(e.plugin->Option.isNone)->toBe(true)
+    expect(e.stateTopicName->Option.isNone)->toBe(true)
+    expect(e.pgConnection->Option.isNone)->toBe(true)
+  })
+})
+
+describe("ReadModelEntryPoint_Ops.injectId", () => {
+  testSync("injects (and overwrites) id on object states", () => {
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", obj([("name", str("Widget"))])))->toEqual(
+      obj([("name", str("Widget")), ("id", str("p-1"))]),
+    )
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", obj([("id", str("stale"))])))->toEqual(
+      obj([("id", str("p-1"))]),
+    )
+  })
+
+  testSync("passes non-object states through unchanged", () => {
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", str("scalar")))->toEqual(str("scalar"))
+    expect(
+      ReadModelEntryPoint_Ops.injectId("p-1", JSON.Encode.array([str("a")])),
+    )->toEqual(JSON.Encode.array([str("a")]))
+    expect(ReadModelEntryPoint_Ops.injectId("p-1", JSON.Null))->toEqual(JSON.Null)
+  })
+})
+
+describe("ReadModelEntryPoint_Ops.withInjectedId", () => {
+  // Capturing stub operation set — only save/saveBatch matter for the wrap.
+  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(),
+  }
+
+  test("save and saveBatch write id-injected states", async () => {
+    let saved = []
+    let ops = ReadModelEntryPoint_Ops.withInjectedId(makeStub(saved))
+    let _ = await ops.save("p-1", obj([("name", str("A"))]), ReventlessCore.QueryDb.Any, None)
+    let _ = await ops.saveBatch([
+      ("p-2", obj([("name", str("B"))]), None),
+      ("p-3", str("scalar"), None),
+    ])
+    expect(saved)->toEqual([
+      ("p-1", obj([("name", str("A")), ("id", str("p-1"))])),
+      ("p-2", obj([("name", str("B")), ("id", str("p-2"))])),
+      ("p-3", str("scalar")),
+    ])
+  })
+})

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