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

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

package/tests/EventCollectorEntryPoint_OpsTest.res

@@ -0,0 +1,216 @@
+// Guards the typed cold-start core hoisted out of EventCollectorEntryPoint.mjs:
+//   - projectPluginRow — the Plugin-RM row projection the admin cross-plugin
+//     subscription manager reads; a drift in the decode (a dropped nested
+//     field, a mis-defaulted optional) would silently break cross-plugin SNS
+//     wiring, invisible until a multi-plugin deploy.
+//   - parseHandlerConfig — the HANDLER_CONFIG contract every EventCollector
+//     Lambda cold-starts on: named errors for malformed deploys, the former JS
+//     normalizer's defaults, and the connectExtension null/absent → None rule.
+
+open JestGlobals
+
+let str = JSON.Encode.string
+let obj = pairs => JSON.Encode.object(Dict.fromArray(pairs))
+
+let project = EventCollectorEntryPoint_Ops.projectPluginRow
+
+describe("EventCollectorEntryPoint_Ops.projectPluginRow", () => {
+  testSync("rejects a non-object row", () => {
+    expect((project(JSON.Encode.string("nope")))->Option.isNone)->toBe(true)
+  })
+
+  testSync("rejects a row missing id or status", () => {
+    expect(project(obj([("status", str("Connected"))]))->Option.isNone)->toBe(true)
+    expect(project(obj([("id", str("Catalog@1"))]))->Option.isNone)->toBe(true)
+  })
+
+  testSync("projects the id/status/eventCollector subset with defaults", () => {
+    let p = project(obj([("id", str("Catalog@1")), ("status", str("Connected"))]))->Option.getOrThrow
+    expect(p.id)->toBe("Catalog@1")
+    expect(p.status)->toBe("Connected")
+    expect(p.eventCollector)->toBe("") // defaulted when absent
+    expect(p.extensions->Array.length)->toBe(0)
+    expect(p.extensionPoints->Array.length)->toBe(0)
+    expect(p.dcbEventLog->Option.isNone)->toBe(true)
+  })
+
+  testSync("decodes extensions, dropping entries without extensionPointName", () => {
+    let row = obj([
+      ("id", str("Ordering@2")),
+      ("status", str("Connected")),
+      ("eventCollector", str("ec-arn")),
+      (
+        "extensions",
+        JSON.Encode.array([
+          obj([("name", str("OrdersExt")), ("extensionPointName", str("Catalog.Products")), ("dcbSources", JSON.Encode.array([str("prod"), JSON.Encode.int(7)]))]),
+          obj([("name", str("Malformed"))]), // no extensionPointName -> dropped
+        ]),
+      ),
+    ])
+    let p = project(row)->Option.getOrThrow
+    expect(p.eventCollector)->toBe("ec-arn")
+    expect(p.extensions->Array.length)->toBe(1)
+    let e = p.extensions->Array.getUnsafe(0)
+    expect(e.name)->toBe("OrdersExt")
+    expect(e.extensionPointName)->toBe("Catalog.Products")
+    // Non-string dcbSources elements are filtered out.
+    expect(e.dcbSources)->toEqual(["prod"])
+  })
+
+  testSync("decodes extensionPoints and dcbEventLog; drops EPs without name/eventTopic", () => {
+    let row = obj([
+      ("id", str("Catalog@1")),
+      ("status", str("Connected")),
+      (
+        "extensionPoints",
+        JSON.Encode.array([
+          obj([("name", str("Catalog.Products")), ("eventTopic", str("t-arn"))]),
+          obj([("name", str("NoTopic"))]), // no eventTopic -> dropped
+        ]),
+      ),
+      ("dcbEventLog", obj([("name", str("catalog-dcb")), ("eventTopicArn", str("dcb-arn"))])),
+    ])
+    let p = project(row)->Option.getOrThrow
+    expect(p.extensionPoints->Array.length)->toBe(1)
+    let ep = p.extensionPoints->Array.getUnsafe(0)
+    expect(ep.name)->toBe("Catalog.Products")
+    expect(ep.commandTopic)->toBe("") // defaulted
+    expect(ep.eventTopic)->toBe("t-arn")
+    let dcb = p.dcbEventLog->Option.getOrThrow
+    expect(dcb.name)->toBe("catalog-dcb")
+    expect(dcb.eventTopicArn)->toBe("dcb-arn")
+  })
+
+  testSync("drops a dcbEventLog missing eventTopicArn", () => {
+    let row = obj([
+      ("id", str("Catalog@1")),
+      ("status", str("Connected")),
+      ("dcbEventLog", obj([("name", str("catalog-dcb"))])),
+    ])
+    expect((project(row)->Option.getOrThrow).dcbEventLog->Option.isNone)->toBe(true)
+  })
+})
+
+// ── parseHandlerConfig ────────────────────────────────────────────────────────
+
+// A minimal valid HANDLER_CONFIG (every required field present).
+let minimalConfig = (extras: array<(string, JSON.t)>): string =>
+  Array.concat(
+    [
+      ("queueUrl", str("q-url")),
+      ("pluginExtensionPointCmdTopicUrl", str("ep-url")),
+      ("eventTopicArn", str("topic-arn")),
+      ("pluginReadModelTableName", str("plugin-rm")),
+      ("appSyncApiId", str("NOT_AVAILABLE")),
+      ("schedulerRoleArn", str("role-arn")),
+      ("schedulerQueueArn", str("")),
+      ("schedulerQueueName", str("")),
+      ("extensionPoints", JSON.Encode.array([])),
+      ("extensions", JSON.Encode.array([])),
+      ("publishToAggregates", obj([])),
+    ],
+    extras,
+  )
+  ->Dict.fromArray
+  ->JSON.Encode.object
+  ->JSON.stringify
+
+let throws = (f: unit => 'a): option<string> =>
+  try {
+    let _ = f()
+    None
+  } catch {
+  | exn => exn->JsExn.fromException->Option.flatMap(JsExn.message)
+  }
+
+describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
+  testSync("throws the named errors for empty / malformed / incomplete config", () => {
+    let msgOf = raw => throws(() => EventCollectorEntryPoint_Ops.parseHandlerConfig(raw))
+    expect(msgOf(""))->toEqual(Some("HANDLER_CONFIG env var is empty"))
+    expect(
+      msgOf("{nope")->Option.mapOr(false, m => m->String.startsWith("HANDLER_CONFIG JSON parse error:")),
+    )->toBe(true)
+    expect(msgOf(`{"queueUrl":"q"}`))->toEqual(
+      Some("HANDLER_CONFIG missing required field: pluginExtensionPointCmdTopicUrl"),
+    )
+  })
+
+  testSync("decodes a minimal config with empty-collection defaults", () => {
+    let c = EventCollectorEntryPoint_Ops.parseHandlerConfig(minimalConfig([]))
+    expect(c.queueUrl)->toBe("q-url")
+    expect(c.connectExtension->Option.isNone)->toBe(true) // absent → None
+    expect(c.readModelQueueUrls->Dict.keysToArray->Array.length)->toBe(0)
+    expect(c.readModelNamesForSourceName->Dict.keysToArray->Array.length)->toBe(0)
+  })
+
+  testSync("connectExtension: JSON null (admin) maps to None; a record decodes", () => {
+    let asNull = EventCollectorEntryPoint_Ops.parseHandlerConfig(
+      minimalConfig([("connectExtension", JSON.Encode.null)]),
+    )
+    expect(asNull.connectExtension->Option.isNone)->toBe(true)
+
+    let asRecord = EventCollectorEntryPoint_Ops.parseHandlerConfig(
+      minimalConfig([
+        (
+          "connectExtension",
+          obj([
+            ("specModule", str("spec.mjs")),
+            ("mappingsModule", str("map.mjs")),
+            ("extensionPointName", str("Platform.Plugin")),
+          ]),
+        ),
+      ]),
+    )
+    let ce = asRecord.connectExtension->Option.getOrThrow
+    expect(ce.extensionPointName)->toBe("Platform.Plugin")
+  })
+
+  testSync("extension entries get the former JS normalizer's defaults", () => {
+    let c = EventCollectorEntryPoint_Ops.parseHandlerConfig(
+      minimalConfig([
+        (
+          "extensions",
+          JSON.Encode.array([
+            // no name, no module specifiers, no aggregate/readModel lists
+            obj([("extensionPointName", str("Ordering.Orders"))]),
+          ]),
+        ),
+      ]),
+    )
+    let ext = c.extensions->Array.getUnsafe(0)
+    expect(ext.name)->toBe("Ordering.Orders") // name falls back to the EP name
+    expect(ext.specModule)->toBe("")
+    expect(ext.aggregateNames)->toEqual([])
+    expect(ext.readModelNames)->toEqual([])
+  })
+
+  testSync("decodes extensionPoints entries and the env-var maps", () => {
+    let c = EventCollectorEntryPoint_Ops.parseHandlerConfig(
+      minimalConfig([
+        (
+          "extensionPoints",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("s.mjs")),
+              ("mappingsModule", str("m.mjs")),
+              ("eventTopicArn", str("arn:ep")),
+              ("aggregateNames", JSON.Encode.array([str("Plugin")])),
+            ]),
+          ]),
+        ),
+        ("publishToAggregates", obj([("Plugin", str("PTA_Plugin_QUEUE_URL"))])),
+        (
+          "readModelNamesForSourceName",
+          obj([("Ordering.Orders", JSON.Encode.array([str("ProductDemands")]))]),
+        ),
+      ]),
+    )
+    let ep = c.extensionPoints->Array.getUnsafe(0)
+    expect(ep.eventTopicArn)->toBe("arn:ep")
+    expect(ep.aggregateNames)->toEqual(["Plugin"])
+    expect(c.publishToAggregates->Dict.get("Plugin"))->toEqual(Some("PTA_Plugin_QUEUE_URL"))
+    expect(c.readModelNamesForSourceName->Dict.get("Ordering.Orders"))->toEqual(
+      Some(["ProductDemands"]),
+    )
+  })
+})