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

package/tests/AutomationSliceEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,280 @@
+// 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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as AutomationSliceEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res.mjs";
+
+function str(prim) {
+  return prim;
+}
+
+function obj(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+globalThis.describe("AutomationSliceEntryPoint_Ops.parseHandlerConfig", () => {
+  globalThis.test("empty raw config yields no handlers", () => {
+    globalThis.expect(AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfig("").length).toBe(0);
+  });
+  globalThis.test("decodes a full entry incl. bodyModule and context", () => {
+    let config = JSON.stringify(Object.fromEntries([[
+        "handlers",
+        [Object.fromEntries([
+            [
+              "specModule",
+              "@x/plugin/src/Order/AutomationSlice/Restock.res.mjs"
+            ],
+            [
+              "bodyModule",
+              "@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs"
+            ],
+            [
+              "callbackType",
+              "automation"
+            ],
+            [
+              "queryDbTableName",
+              "RestockTodo-abc"
+            ],
+            [
+              "dcbQueueUrl",
+              "https://sqs/queue.fifo"
+            ],
+            [
+              "sourceUrn",
+              "arn:aws:dynamodb:eu-west-1:1:table/log/stream/x"
+            ],
+            [
+              "context",
+              Object.fromEntries([
+                [
+                  "environment",
+                  "alpha"
+                ],
+                [
+                  "platformName",
+                  "OnlineShop"
+                ],
+                [
+                  "pluginName",
+                  "Ordering"
+                ],
+                [
+                  "sliceName",
+                  "Restock"
+                ]
+              ])
+            ]
+          ])]
+      ]]));
+    let entries = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfig(config);
+    globalThis.expect(entries.length).toBe(1);
+    let e = entries[0];
+    globalThis.expect(e.bodyModule).toBe("@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs");
+    globalThis.expect(e.callbackType).toBe("automation");
+    globalThis.expect(e.dcbQueueUrl).toBe("https://sqs/queue.fifo");
+    let ctx = e.context;
+    if (ctx !== undefined) {
+      globalThis.expect(ctx.environment).toBe("alpha");
+      globalThis.expect(ctx.platformName).toBe("OnlineShop");
+      globalThis.expect(ctx.pluginName).toBe("Ordering");
+      globalThis.expect(ctx.sliceName).toBe("Restock");
+      return;
+    } else {
+      return Stdlib_JsError.throwWithMessage("expected Some(context)");
+    }
+  });
+  globalThis.test("a stale entry without bodyModule/context decodes with defaults", () => {
+    let config = JSON.stringify(Object.fromEntries([[
+        "handlers",
+        [Object.fromEntries([
+            [
+              "specModule",
+              "a.res.mjs"
+            ],
+            [
+              "callbackType",
+              "outbound"
+            ],
+            [
+              "queryDbTableName",
+              "t"
+            ],
+            [
+              "dcbQueueUrl",
+              "u"
+            ],
+            [
+              "sourceUrn",
+              "arn"
+            ]
+          ])]
+      ]]));
+    let e = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfig(config)[0];
+    globalThis.expect(e.bodyModule).toBe("");
+    globalThis.expect(Stdlib_Option.isNone(e.context)).toBe(true);
+  });
+});
+
+async function noopPublish(param) {
+  
+}
+
+globalThis.describe("AutomationSliceEntryPoint_Ops.makeAutomationJsonEventsHandler", () => {
+  globalThis.test("passes raw envelope JSONs + context to phase 1; sync → phase 2 → sync", async () => {
+    let steps = [];
+    let receivedJsons = {
+      contents: []
+    };
+    let receivedCtx = {
+      contents: undefined
+    };
+    let callback_todoItems = {};
+    let callback_phase1 = (jsons, ctx) => {
+      receivedJsons.contents = jsons;
+      receivedCtx.contents = ctx;
+      steps.push("phase1");
+    };
+    let callback_phase2 = async _publish => {
+      steps.push("phase2");
+    };
+    let callback = {
+      todoItems: callback_todoItems,
+      phase1: callback_phase1,
+      phase2: callback_phase2
+    };
+    let handler = AutomationSliceEntryPoint_Ops$ReventlessAws.makeAutomationJsonEventsHandler({
+      environment: "test",
+      platformName: "P",
+      pluginName: "Pl",
+      sliceName: "S"
+    }, callback, noopPublish, async () => {
+      steps.push("sync");
+    });
+    let envelope = Object.fromEntries([
+      [
+        "meta",
+        Object.fromEntries([[
+            "service",
+            "Order"
+          ]])
+      ],
+      [
+        "event",
+        "Placed"
+      ]
+    ]);
+    await Effect.runPromise(handler(Stream.fromIterable([
+      envelope,
+      "bare"
+    ])));
+    globalThis.expect(receivedJsons.contents).toEqual([
+      envelope,
+      "bare"
+    ]);
+    globalThis.expect(Stdlib_Option.map(receivedCtx.contents, c => c.sliceName)).toEqual("S");
+    globalThis.expect(steps).toEqual([
+      "phase1",
+      "sync",
+      "phase2",
+      "sync"
+    ]);
+  });
+});
+
+let outboundEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(S.string)
+  })),
+  S.literal("OrderArchived")
+]);
+
+globalThis.describe("AutomationSliceEntryPoint_Ops.makeOutboundJsonEventsHandler", () => {
+  globalThis.test("decodes inner event payloads, drops non-consumed types silently", async () => {
+    let steps = [];
+    let received = {
+      contents: []
+    };
+    let callback_todoItems = {};
+    let callback_phase1 = events => {
+      received.contents = events;
+      steps.push("phase1");
+    };
+    let callback_phase2 = async _publish => {
+      steps.push("phase2");
+    };
+    let callback = {
+      todoItems: callback_todoItems,
+      phase1: callback_phase1,
+      phase2: callback_phase2
+    };
+    let handler = AutomationSliceEntryPoint_Ops$ReventlessAws.makeOutboundJsonEventsHandler(outboundEventSchema, callback, noopPublish, async () => {
+      steps.push("sync");
+    });
+    let placed = Object.fromEntries([
+      [
+        "meta",
+        Object.fromEntries([[
+            "service",
+            "Order"
+          ]])
+      ],
+      [
+        "event",
+        Object.fromEntries([
+          [
+            "TAG",
+            "OrderPlaced"
+          ],
+          [
+            "orderId",
+            "ord-1"
+          ]
+        ])
+      ]
+    ]);
+    let ignored = Object.fromEntries([[
+        "event",
+        Object.fromEntries([
+          [
+            "TAG",
+            "OrderShipped"
+          ],
+          [
+            "orderId",
+            "ord-1"
+          ]
+        ])
+      ]]);
+    await Effect.runPromise(handler(Stream.fromIterable([
+      placed,
+      ignored,
+      "OrderArchived"
+    ])));
+    globalThis.expect(received.contents).toEqual([
+      {
+        TAG: "OrderPlaced",
+        orderId: "ord-1"
+      },
+      "OrderArchived"
+    ]);
+    globalThis.expect(steps).toEqual([
+      "phase1",
+      "sync",
+      "phase2",
+      "sync"
+    ]);
+  });
+});
+
+export {
+  str,
+  obj,
+  noopPublish,
+  outboundEventSchema,
+}
+/*  Not a pure module */

package/tests/CounterEntryPoint_OpsTest.res

@@ -0,0 +1,115 @@
+// Guards the typed cold-start core hoisted out of CounterEntryPoint.mjs:
+//   - parseHandlerConfig — reads `publishChannelId`, the field the deploy side
+//     (CounterHandler_DynamoDbStream.res) actually writes; the former shell
+//     read `publishQueueUrl` and published CountFinished events to an
+//     undefined queue URL.
+//   - splitRecords — the references/counts stream routing: NewImage rows carry
+//     increments (unparsable inc falls back to 1), NewAndOldImage on the
+//     references stream is a duplicate to ignore, counts take the new image on
+//     insert AND update, and foreign records are dropped.
+
+open JestGlobals
+
+let attrS = (s: string): AwsSdk.DynamoDb.Util.attributeValue => {string: s}
+let attrN = (n: string): AwsSdk.DynamoDb.Util.attributeValue => {number: n}
+
+let refsArn = "arn:stream-references"
+let countsArn = "arn:stream-counts"
+
+let mkRecord = (
+  ~arn: string,
+  ~source="aws:dynamodb",
+  ~keysId: string,
+  ~newImage: option<dict<AwsSdk.DynamoDb.Util.attributeValue>>=?,
+  ~oldImage: option<dict<AwsSdk.DynamoDb.Util.attributeValue>>=?,
+): PulumiAws.DynamoDb.Stream.record => {
+  awsRegion: "eu-west-1",
+  dynamodb: {
+    keys: {id: attrS(keysId)},
+    newImage: ?newImage,
+    oldImage: ?oldImage,
+  },
+  eventID: "e1",
+  eventName: INSERT,
+  eventSource: source,
+  eventSourceARN: arn,
+  eventVersion: "1",
+  userIdentity: "",
+}
+
+describe("CounterEntryPoint_Ops.parseHandlerConfig", () => {
+  testSync("reads publishChannelId (the field the deploy side writes)", () => {
+    let config = CounterEntryPoint_Ops.parseHandlerConfig(
+      `{"targetSpecModule":"@x/p/src/Aggregate/Product.res.mjs","countsTableName":"counts","publishChannelId":"https://sqs/q","referencesStreamArn":"${refsArn}","countsStreamArn":"${countsArn}"}`,
+    )
+    expect(config.publishChannelId)->toEqual(Some("https://sqs/q"))
+    expect(config.countsTableName)->toEqual(Some("counts"))
+    expect(config.referencesStreamArn)->toEqual(Some(refsArn))
+  })
+})
+
+describe("CounterEntryPoint_Ops.splitRecords", () => {
+  testSync("routes references and counts records by source ARN", () => {
+    let records = [
+      // references insert: {id, inc} view row → increment 2
+      mkRecord(
+        ~arn=refsArn,
+        ~keysId="c1#ref-a",
+        ~newImage=Dict.fromArray([("id", attrS("c1#ref-a")), ("inc", attrN("2"))]),
+      ),
+      // references insert without a parsable inc → fallback 1
+      mkRecord(
+        ~arn=refsArn,
+        ~keysId="c1#ref-b",
+        ~newImage=Dict.fromArray([("id", attrS("c1#ref-b"))]),
+      ),
+      // references update (NewAndOldImage) → duplicate, ignored
+      mkRecord(
+        ~arn=refsArn,
+        ~keysId="c1#ref-a",
+        ~newImage=Dict.fromArray([("id", attrS("c1#ref-a")), ("inc", attrN("1"))]),
+        ~oldImage=Dict.fromArray([("id", attrS("c1#ref-a")), ("inc", attrN("1"))]),
+      ),
+      // counts insert AND update both take the new image
+      mkRecord(
+        ~arn=countsArn,
+        ~keysId="c1",
+        ~newImage=Dict.fromArray([("id", attrS("c1")), ("count", attrN("0"))]),
+      ),
+      mkRecord(
+        ~arn=countsArn,
+        ~keysId="c2",
+        ~newImage=Dict.fromArray([("id", attrS("c2")), ("count", attrN("3"))]),
+        ~oldImage=Dict.fromArray([("id", attrS("c2")), ("count", attrN("4"))]),
+      ),
+      // foreign stream / foreign source → dropped
+      mkRecord(
+        ~arn="arn:other",
+        ~keysId="x",
+        ~newImage=Dict.fromArray([("id", attrS("x"))]),
+      ),
+      mkRecord(
+        ~arn=refsArn,
+        ~source="aws:sqs",
+        ~keysId="y",
+        ~newImage=Dict.fromArray([("id", attrS("y"))]),
+      ),
+    ]
+
+    let (references, counts) = CounterEntryPoint_Ops.splitRecords(
+      ~referencesStreamArn=refsArn,
+      ~countsStreamArn=countsArn,
+      records,
+    )
+
+    expect(references)->toEqual([("c1#ref-a", 2), ("c1#ref-b", 1)])
+    expect(counts->Array.length)->toBe(2)
+    expect(
+      counts
+      ->Array.getUnsafe(1)
+      ->JSON.Decode.object
+      ->Option.flatMap(o => o->Dict.get("count"))
+      ->Option.flatMap(JSON.Decode.float),
+    )->toEqual(Some(3.))
+  })
+})

package/tests/CounterEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,150 @@
+// 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 CounterEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/CounterEntryPoint_Ops.res.mjs";
+
+function attrS(s) {
+  return {
+    S: s
+  };
+}
+
+function attrN(n) {
+  return {
+    N: n
+  };
+}
+
+let refsArn = "arn:stream-references";
+
+let countsArn = "arn:stream-counts";
+
+function mkRecord(arn, sourceOpt, keysId, newImage, oldImage) {
+  let source = sourceOpt !== undefined ? sourceOpt : "aws:dynamodb";
+  return {
+    awsRegion: "eu-west-1",
+    dynamodb: {
+      Keys: {
+        id: attrS(keysId)
+      },
+      NewImage: newImage,
+      OldImage: oldImage
+    },
+    eventID: "e1",
+    eventName: "INSERT",
+    eventSource: source,
+    eventSourceARN: arn,
+    eventVersion: "1",
+    userIdentity: ""
+  };
+}
+
+globalThis.describe("CounterEntryPoint_Ops.parseHandlerConfig", () => {
+  globalThis.test("reads publishChannelId (the field the deploy side writes)", () => {
+    let config = CounterEntryPoint_Ops$ReventlessAws.parseHandlerConfig(`{"targetSpecModule":"@x/p/src/Aggregate/Product.res.mjs","countsTableName":"counts","publishChannelId":"https://sqs/q","referencesStreamArn":"` + refsArn + `","countsStreamArn":"` + countsArn + `"}`);
+    globalThis.expect(config.publishChannelId).toEqual("https://sqs/q");
+    globalThis.expect(config.countsTableName).toEqual("counts");
+    globalThis.expect(config.referencesStreamArn).toEqual(refsArn);
+  });
+});
+
+globalThis.describe("CounterEntryPoint_Ops.splitRecords", () => {
+  globalThis.test("routes references and counts records by source ARN", () => {
+    let records = [
+      mkRecord(refsArn, undefined, "c1#ref-a", Object.fromEntries([
+        [
+          "id",
+          attrS("c1#ref-a")
+        ],
+        [
+          "inc",
+          attrN("2")
+        ]
+      ]), undefined),
+      mkRecord(refsArn, undefined, "c1#ref-b", Object.fromEntries([[
+          "id",
+          attrS("c1#ref-b")
+        ]]), undefined),
+      mkRecord(refsArn, undefined, "c1#ref-a", Object.fromEntries([
+        [
+          "id",
+          attrS("c1#ref-a")
+        ],
+        [
+          "inc",
+          attrN("1")
+        ]
+      ]), Object.fromEntries([
+        [
+          "id",
+          attrS("c1#ref-a")
+        ],
+        [
+          "inc",
+          attrN("1")
+        ]
+      ])),
+      mkRecord(countsArn, undefined, "c1", Object.fromEntries([
+        [
+          "id",
+          attrS("c1")
+        ],
+        [
+          "count",
+          attrN("0")
+        ]
+      ]), undefined),
+      mkRecord(countsArn, undefined, "c2", Object.fromEntries([
+        [
+          "id",
+          attrS("c2")
+        ],
+        [
+          "count",
+          attrN("3")
+        ]
+      ]), Object.fromEntries([
+        [
+          "id",
+          attrS("c2")
+        ],
+        [
+          "count",
+          attrN("4")
+        ]
+      ])),
+      mkRecord("arn:other", undefined, "x", Object.fromEntries([[
+          "id",
+          attrS("x")
+        ]]), undefined),
+      mkRecord(refsArn, "aws:sqs", "y", Object.fromEntries([[
+          "id",
+          attrS("y")
+        ]]), undefined)
+    ];
+    let match = CounterEntryPoint_Ops$ReventlessAws.splitRecords(refsArn, countsArn, records);
+    let counts = match[1];
+    globalThis.expect(match[0]).toEqual([
+      [
+        "c1#ref-a",
+        2
+      ],
+      [
+        "c1#ref-b",
+        1
+      ]
+    ]);
+    globalThis.expect(counts.length).toBe(2);
+    globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(counts[1]), o => o["count"]), Stdlib_JSON.Decode.float)).toEqual(3);
+  });
+});
+
+export {
+  attrS,
+  attrN,
+  refsArn,
+  countsArn,
+  mkRecord,
+}
+/*  Not a pure module */