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

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

package/tests/EventCollectorEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,339 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as EventCollectorEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/EventCollectorEntryPoint_Ops.res.mjs";
+
+function str(prim) {
+  return prim;
+}
+
+function obj(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+globalThis.describe("EventCollectorEntryPoint_Ops.projectPluginRow", () => {
+  globalThis.test("rejects a non-object row", () => {
+    globalThis.expect(Stdlib_Option.isNone(EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow("nope"))).toBe(true);
+  });
+  globalThis.test("rejects a row missing id or status", () => {
+    globalThis.expect(Stdlib_Option.isNone(EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow(Object.fromEntries([[
+        "status",
+        "Connected"
+      ]])))).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow(Object.fromEntries([[
+        "id",
+        "Catalog@1"
+      ]])))).toBe(true);
+  });
+  globalThis.test("projects the id/status/eventCollector subset with defaults", () => {
+    let p = Stdlib_Option.getOrThrow(EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow(Object.fromEntries([
+      [
+        "id",
+        "Catalog@1"
+      ],
+      [
+        "status",
+        "Connected"
+      ]
+    ])), undefined);
+    globalThis.expect(p.id).toBe("Catalog@1");
+    globalThis.expect(p.status).toBe("Connected");
+    globalThis.expect(p.eventCollector).toBe("");
+    globalThis.expect(p.extensions.length).toBe(0);
+    globalThis.expect(p.extensionPoints.length).toBe(0);
+    globalThis.expect(Stdlib_Option.isNone(p.dcbEventLog)).toBe(true);
+  });
+  globalThis.test("decodes extensions, dropping entries without extensionPointName", () => {
+    let row = Object.fromEntries([
+      [
+        "id",
+        "Ordering@2"
+      ],
+      [
+        "status",
+        "Connected"
+      ],
+      [
+        "eventCollector",
+        "ec-arn"
+      ],
+      [
+        "extensions",
+        [
+          Object.fromEntries([
+            [
+              "name",
+              "OrdersExt"
+            ],
+            [
+              "extensionPointName",
+              "Catalog.Products"
+            ],
+            [
+              "dcbSources",
+              [
+                "prod",
+                7
+              ]
+            ]
+          ]),
+          Object.fromEntries([[
+              "name",
+              "Malformed"
+            ]])
+        ]
+      ]
+    ]);
+    let p = Stdlib_Option.getOrThrow(EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow(row), undefined);
+    globalThis.expect(p.eventCollector).toBe("ec-arn");
+    globalThis.expect(p.extensions.length).toBe(1);
+    let e = p.extensions[0];
+    globalThis.expect(e.name).toBe("OrdersExt");
+    globalThis.expect(e.extensionPointName).toBe("Catalog.Products");
+    globalThis.expect(e.dcbSources).toEqual(["prod"]);
+  });
+  globalThis.test("decodes extensionPoints and dcbEventLog; drops EPs without name/eventTopic", () => {
+    let row = Object.fromEntries([
+      [
+        "id",
+        "Catalog@1"
+      ],
+      [
+        "status",
+        "Connected"
+      ],
+      [
+        "extensionPoints",
+        [
+          Object.fromEntries([
+            [
+              "name",
+              "Catalog.Products"
+            ],
+            [
+              "eventTopic",
+              "t-arn"
+            ]
+          ]),
+          Object.fromEntries([[
+              "name",
+              "NoTopic"
+            ]])
+        ]
+      ],
+      [
+        "dcbEventLog",
+        Object.fromEntries([
+          [
+            "name",
+            "catalog-dcb"
+          ],
+          [
+            "eventTopicArn",
+            "dcb-arn"
+          ]
+        ])
+      ]
+    ]);
+    let p = Stdlib_Option.getOrThrow(EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow(row), undefined);
+    globalThis.expect(p.extensionPoints.length).toBe(1);
+    let ep = p.extensionPoints[0];
+    globalThis.expect(ep.name).toBe("Catalog.Products");
+    globalThis.expect(ep.commandTopic).toBe("");
+    globalThis.expect(ep.eventTopic).toBe("t-arn");
+    let dcb = Stdlib_Option.getOrThrow(p.dcbEventLog, undefined);
+    globalThis.expect(dcb.name).toBe("catalog-dcb");
+    globalThis.expect(dcb.eventTopicArn).toBe("dcb-arn");
+  });
+  globalThis.test("drops a dcbEventLog missing eventTopicArn", () => {
+    let row = Object.fromEntries([
+      [
+        "id",
+        "Catalog@1"
+      ],
+      [
+        "status",
+        "Connected"
+      ],
+      [
+        "dcbEventLog",
+        Object.fromEntries([[
+            "name",
+            "catalog-dcb"
+          ]])
+      ]
+    ]);
+    globalThis.expect(Stdlib_Option.isNone(Stdlib_Option.getOrThrow(EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow(row), undefined).dcbEventLog)).toBe(true);
+  });
+});
+
+function minimalConfig(extras) {
+  return JSON.stringify(Object.fromEntries([
+    [
+      "queueUrl",
+      "q-url"
+    ],
+    [
+      "pluginExtensionPointCmdTopicUrl",
+      "ep-url"
+    ],
+    [
+      "eventTopicArn",
+      "topic-arn"
+    ],
+    [
+      "pluginReadModelTableName",
+      "plugin-rm"
+    ],
+    [
+      "appSyncApiId",
+      "NOT_AVAILABLE"
+    ],
+    [
+      "schedulerRoleArn",
+      "role-arn"
+    ],
+    [
+      "schedulerQueueArn",
+      ""
+    ],
+    [
+      "schedulerQueueName",
+      ""
+    ],
+    [
+      "extensionPoints",
+      []
+    ],
+    [
+      "extensions",
+      []
+    ],
+    [
+      "publishToAggregates",
+      Object.fromEntries([])
+    ]
+  ].concat(extras)));
+}
+
+function throws(f) {
+  try {
+    f();
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message);
+  }
+}
+
+globalThis.describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
+  globalThis.test("throws the named errors for empty / malformed / incomplete config", () => {
+    globalThis.expect(throws(() => EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig(""))).toEqual("HANDLER_CONFIG env var is empty");
+    globalThis.expect(Stdlib_Option.mapOr(throws(() => EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig("{nope")), false, m => m.startsWith("HANDLER_CONFIG JSON parse error:"))).toBe(true);
+    globalThis.expect(throws(() => EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig(`{"queueUrl":"q"}`))).toEqual("HANDLER_CONFIG missing required field: pluginExtensionPointCmdTopicUrl");
+  });
+  globalThis.test("decodes a minimal config with empty-collection defaults", () => {
+    let c = EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig(minimalConfig([]));
+    globalThis.expect(c.queueUrl).toBe("q-url");
+    globalThis.expect(Stdlib_Option.isNone(c.connectExtension)).toBe(true);
+    globalThis.expect(Object.keys(c.readModelQueueUrls).length).toBe(0);
+    globalThis.expect(Object.keys(c.readModelNamesForSourceName).length).toBe(0);
+  });
+  globalThis.test("connectExtension: JSON null (admin) maps to None; a record decodes", () => {
+    let asNull = EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig(minimalConfig([[
+        "connectExtension",
+        null
+      ]]));
+    globalThis.expect(Stdlib_Option.isNone(asNull.connectExtension)).toBe(true);
+    let asRecord = EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig(minimalConfig([[
+        "connectExtension",
+        Object.fromEntries([
+          [
+            "specModule",
+            "spec.mjs"
+          ],
+          [
+            "mappingsModule",
+            "map.mjs"
+          ],
+          [
+            "extensionPointName",
+            "Platform.Plugin"
+          ]
+        ])
+      ]]));
+    let ce = Stdlib_Option.getOrThrow(asRecord.connectExtension, undefined);
+    globalThis.expect(ce.extensionPointName).toBe("Platform.Plugin");
+  });
+  globalThis.test("extension entries get the former JS normalizer's defaults", () => {
+    let c = EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig(minimalConfig([[
+        "extensions",
+        [Object.fromEntries([[
+              "extensionPointName",
+              "Ordering.Orders"
+            ]])]
+      ]]));
+    let ext = c.extensions[0];
+    globalThis.expect(ext.name).toBe("Ordering.Orders");
+    globalThis.expect(ext.specModule).toBe("");
+    globalThis.expect(ext.aggregateNames).toEqual([]);
+    globalThis.expect(ext.readModelNames).toEqual([]);
+  });
+  globalThis.test("decodes extensionPoints entries and the env-var maps", () => {
+    let c = EventCollectorEntryPoint_Ops$ReventlessAws.parseHandlerConfig(minimalConfig([
+      [
+        "extensionPoints",
+        [Object.fromEntries([
+            [
+              "specModule",
+              "s.mjs"
+            ],
+            [
+              "mappingsModule",
+              "m.mjs"
+            ],
+            [
+              "eventTopicArn",
+              "arn:ep"
+            ],
+            [
+              "aggregateNames",
+              ["Plugin"]
+            ]
+          ])]
+      ],
+      [
+        "publishToAggregates",
+        Object.fromEntries([[
+            "Plugin",
+            "PTA_Plugin_QUEUE_URL"
+          ]])
+      ],
+      [
+        "readModelNamesForSourceName",
+        Object.fromEntries([[
+            "Ordering.Orders",
+            ["ProductDemands"]
+          ]])
+      ]
+    ]));
+    let ep = c.extensionPoints[0];
+    globalThis.expect(ep.eventTopicArn).toBe("arn:ep");
+    globalThis.expect(ep.aggregateNames).toEqual(["Plugin"]);
+    globalThis.expect(c.publishToAggregates["Plugin"]).toEqual("PTA_Plugin_QUEUE_URL");
+    globalThis.expect(c.readModelNamesForSourceName["Ordering.Orders"]).toEqual(["ProductDemands"]);
+  });
+});
+
+let project = EventCollectorEntryPoint_Ops$ReventlessAws.projectPluginRow;
+
+export {
+  str,
+  obj,
+  project,
+  minimalConfig,
+  throws,
+}
+/*  Not a pure module */

package/tests/EventMapperEntryPoint_OpsTest.res

@@ -0,0 +1,103 @@
+// Guards the typed cold-start core hoisted out of EventMapperEntryPoint.mjs:
+//   - parseHandlerConfig — the {targetSpecModule, mappingsModule, queueUrl}
+//     shape written by AggregateRuntime_Builder_Micro / _Micro_Async.
+//   - makeCounterOps — the queryEngine stub shape (the former shell's stub had
+//     `query`/`get` fields where QueryEngine.operations needs `scan`/`query`).
+//   - makeStreamHandler — the full pipeline: SQS-record body parse →
+//     commonEventsHandler → publish of the produced commands.
+
+open JestGlobals
+
+external toCbRecord: PulumiAws.SQS.Queue.record => PulumiAws.Lambda.CallbackFunction.record =
+  "%identity"
+
+let sqsRecord = (body: string): PulumiAws.Lambda.CallbackFunction.record =>
+  (
+    {
+      messageId: "m1",
+      receiptHandle: "r1",
+      body,
+      md5OfBody: "",
+      eventSource: "aws:sqs",
+      eventSourceARN: "arn:aws:sqs:eu-west-1:000000000000:q",
+      awsRegion: "eu-west-1",
+    }: PulumiAws.SQS.Queue.record
+  )->toCbRecord
+
+let context: PulumiAws.Lambda.context = {
+  callbackWaitsForEmptyEventLoop: false,
+  functionName: "test",
+  functionVersion: "1",
+  invokedFunctionArn: "arn:test",
+  memoryLimitInMB: 128,
+  awsRequestId: "req-1",
+  logGroupName: "lg",
+  logStreamName: "ls",
+}
+
+describe("EventMapperEntryPoint_Ops.parseHandlerConfig", () => {
+  testSync("reads the builder's field names", () => {
+    let config = EventMapperEntryPoint_Ops.parseHandlerConfig(
+      `{"targetSpecModule":"@x/p/src/Aggregate/Product.res.mjs","mappingsModule":"@x/p/src/Aggregate/Product_Mappings.res.mjs","queueUrl":"https://sqs/q"}`,
+    )
+    expect(config.targetSpecModule)->toEqual(Some("@x/p/src/Aggregate/Product.res.mjs"))
+    expect(config.mappingsModule)->toEqual(Some("@x/p/src/Aggregate/Product_Mappings.res.mjs"))
+    expect(config.queueUrl)->toEqual(Some("https://sqs/q"))
+  })
+})
+
+describe("EventMapperEntryPoint_Ops.makeCounterOps", () => {
+  test("queryEngine stubs return empty results instead of crashing", async () => {
+    let ops = EventMapperEntryPoint_Ops.makeCounterOps({queueUrl: "https://sqs/q"})
+    let scanned = await ops.queryEngine.scan(~readModelName="X", ~filterConfigs=[], ~limit=10)
+    expect(scanned->Array.length)->toBe(0)
+    let queried = await ops.queryEngine.query(
+      ~readModelName="X",
+      ~id=Reventless.QueryEngine.String("a"),
+    )
+    expect(queried->Array.length)->toBe(0)
+  })
+})
+
+describe("EventMapperEntryPoint_Ops.makeStreamHandler", () => {
+  test("parses SQS bodies, runs commonEventsHandler, publishes produced commands", async () => {
+    let received: ref<array<JSON.t>> = ref([])
+    let published: ref<array<ReventlessCore.Message.commandJson>> = ref([])
+    let ops: EventMapperEntryPoint_Ops.counterOps = {
+      publishJsons: async jsons => published := published.contents->Array.concat(jsons),
+      queryEngine: {
+        scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
+        query: async (
+          ~readModelName as _,
+          ~key as _=?,
+          ~id as _,
+          ~subIdConfig as _=?,
+          ~filterConfigs as _=?,
+          ~ascending as _=?,
+          ~limit as _=?,
+        ) => [],
+      },
+    }
+    let command: ReventlessCore.Message.commandJson = {
+      id: "prd-1",
+      meta: ReventlessCore.Message.generateMeta(~service="Product", ~ip="", ~user="test"),
+      commandJson: JSON.Encode.string("Add"),
+    }
+    let commonEventsHandler: EventMapperEntryPoint_Ops.commonEventsHandler = async jsons => {
+      received := received.contents->Array.concat(jsons)
+      (Promise.resolve([command]), [])
+    }
+
+    let streamHandler = EventMapperEntryPoint_Ops.makeStreamHandler(ops, commonEventsHandler)
+    let event: PulumiAws.Lambda.CallbackFunction.event = {
+      records: [sqsRecord(`{"id":"e1","event":"Added"}`), sqsRecord("not json")],
+    }
+    await streamHandler(event, context)->Effect.runPromise
+
+    // The unparsable body is dropped by the channel decode; the parsed one
+    // reaches the mapper and its produced command is published.
+    expect(received.contents->Array.length)->toBe(1)
+    expect(published.contents->Array.length)->toBe(1)
+    expect((published.contents->Array.getUnsafe(0)).id)->toBe("prd-1")
+  })
+})