@reventlessdev/reventless-aws 3.0.0-alpha.343 → 3.0.0-alpha.345

package/tests/EventCollectorConnectLambdaPreviewTest.res

@@ -69,12 +69,12 @@ beforeAll(() =>
 )
 
 // Pulumi registers resources asynchronously; give the runtime a few ticks.
-let settle = async () => await Promise.make((resolve, _) => {
-  let _ = setTimeout(() => resolve(), 300)
-})
+let settle = async () =>
+  await Promise.make((resolve, _) => {
+    let _ = setTimeout(() => resolve(), 300)
+  })
 
-let wasRegistered = (type_, name) =>
-  registered->Array.some(((t, n)) => t == type_ && n == name)
+let wasRegistered = (type_, name) => registered->Array.some(((t, n)) => t == type_ && n == name)
 
 // ── Fixtures ─────────────────────────────────────────────────────────────────
 
@@ -124,7 +124,9 @@ describe("EventCollectorChannel_Helpers.connectLambda under an unknown view tabl
       name,
       lambdaRole,
       [],
-      Dict.fromArray([("DcbEventLog", {ReventlessInfra.EventTopic.resources: [knownEventLogStream]})]),
+      Dict.fromArray([
+        ("DcbEventLog", {ReventlessInfra.EventTopic.resources: [knownEventLogStream]}),
+      ]),
       [unknownViewTable],
       {},
     )
@@ -139,6 +141,11 @@ describe("EventCollectorChannel_Helpers.connectLambda under an unknown view tabl
   })
 
   test("still registers the event-log mapping, which never reads a view table", async () => {
-    expect(wasRegistered("aws:lambda/eventSourceMapping:EventSourceMapping", "CatalogDcbEventLog2" ++ name))->toBe(true)
+    expect(
+      wasRegistered(
+        "aws:lambda/eventSourceMapping:EventSourceMapping",
+        "CatalogDcbEventLog2" ++ name,
+      ),
+    )->toBe(true)
   })
 })

package/tests/EventCollectorEntryPoint_OpsTest.res

@@ -16,7 +16,7 @@ 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)
+    expect(project(JSON.Encode.string("nope"))->Option.isNone)->toBe(true)
   })
 
   testSync("rejects a row missing id or status", () => {
@@ -25,7 +25,8 @@ describe("EventCollectorEntryPoint_Ops.projectPluginRow", () => {
   })
 
   testSync("projects the id/status/eventCollector subset with defaults", () => {
-    let p = project(obj([("id", str("Catalog@1")), ("status", str("Connected"))]))->Option.getOrThrow
+    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
@@ -42,7 +43,11 @@ describe("EventCollectorEntryPoint_Ops.projectPluginRow", () => {
       (
         "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("OrdersExt")),
+            ("extensionPointName", str("Catalog.Products")),
+            ("dcbSources", JSON.Encode.array([str("prod"), JSON.Encode.int(7)])),
+          ]),
           obj([("name", str("Malformed"))]), // no extensionPointName -> dropped
         ]),
       ),
@@ -127,7 +132,10 @@ describe("EventCollectorEntryPoint_Ops.parseHandlerConfig", () => {
     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:")),
+      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"),

package/tests/EventCollectorPluginDefinitionAssetTest.res

@@ -80,16 +80,22 @@ describe("pluginDefinition.json write/read symmetry", () => {
     }
   })
 
-  testSync("a definition read back from the asset can be published to the Connect handshake", () => {
-    // The encode the old cast broke. Both arms, because only Offloaded diverges
-    // between wire and runtime shape and an Inline-only test would stay green.
-    [offloadedFragment, inlineFragment]->Array.forEach(def => {
-      let published =
-        ReventlessInfra.PluginExtensionPointSpec.ConnectPlugin(def->writeAsset->readAsset)
-        ->Reventless.Util_Sury.toJson(ReventlessInfra.PluginExtensionPointSpec.commandSchema)
-      expect(published->JSON.Decode.object->Option.isSome)->toBe(true)
-    })
-  })
+  testSync(
+    "a definition read back from the asset can be published to the Connect handshake",
+    () => {
+      // The encode the old cast broke. Both arms, because only Offloaded diverges
+      // between wire and runtime shape and an Inline-only test would stay green.
+      [offloadedFragment, inlineFragment]->Array.forEach(
+        def => {
+          let published =
+            ReventlessInfra.PluginExtensionPointSpec.ConnectPlugin(
+              def->writeAsset->readAsset,
+            )->Reventless.Util_Sury.toJson(ReventlessInfra.PluginExtensionPointSpec.commandSchema)
+          expect(published->JSON.Decode.object->Option.isSome)->toBe(true)
+        },
+      )
+    },
+  )
 
   testSync("the asset round-trips byte-identically, so no stored message shifts", () => {
     let once = offloadedFragment->writeAsset
@@ -108,7 +114,8 @@ describe("pluginDefinition.json write/read symmetry", () => {
   // hand-written JSON literal in PluginRuntime_Builder and fell two fields behind
   // (dcbEventLog, kind) with nothing to notice.
   testSync("the platform's own placeholder asset survives the same round trip", () => {
-    let def = ReventlessCore.Platform_Admin_Structure.internalPluginDefinition->writeAsset->readAsset
+    let def =
+      ReventlessCore.Platform_Admin_Structure.internalPluginDefinition->writeAsset->readAsset
     expect(def.id)->toBe(ReventlessCore.Platform_Admin_Structure.pluginId ++ "@INTERNAL")
     expect(def.kind)->toBe(Reventless.Plugin.Domain)
   })

package/tests/EventCollectorReadyGateTest.res

@@ -32,7 +32,7 @@ external makeOutput: (
 
 let pending = (value: 'a): (Pulumi.Output.t<'a>, unit => unit) => {
   let settle = ref(() => ())
-  let p = Promise.make((resolve, _) => settle := () => resolve(value))
+  let p = Promise.make((resolve, _) => settle := (() => resolve(value)))
   (
     makeOutput(
       Set.make(),
@@ -45,9 +45,10 @@ let pending = (value: 'a): (Pulumi.Output.t<'a>, unit => unit) => {
   )
 }
 
-let ticks = async () => await Promise.make((resolve, _) => {
-  let _ = setTimeout(() => resolve(), 50)
-})
+let ticks = async () =>
+  await Promise.make((resolve, _) => {
+    let _ = setTimeout(() => resolve(), 50)
+  })
 
 /** A collector mid-update, the way the engine presents one: the identifiers are
     already known — they do not change across a code update — and only

package/tests/EventLogStorage_DynamoDb_RuntimeTest.res

@@ -117,8 +117,7 @@ describe("Runtime snapshot item codec", () => {
     // The DynamoDB stream decoder drops rows without an `event` column (same
     // mechanism that filters DCB FENCE rows), so snapshot writes are invisible
     // to event collectors.
-    let asDict =
-      Runtime.snapshotItem("agg-1", snap)->JSON.Decode.object->Option.getOr(Dict.make())
+    let asDict = Runtime.snapshotItem("agg-1", snap)->JSON.Decode.object->Option.getOr(Dict.make())
     expect(Util_DynamoDbStream_Runtime.buildJsonEvent'(asDict))->toEqual(None)
   })
 })

package/tests/EventMapperEntryPoint_OpsTest.res

@@ -37,9 +37,7 @@ let context: PulumiAws.Lambda.context = {
 
 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"}`,
-    )
+    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"))

package/tests/ExtensionPointEntryPoint_OpsTest.res

@@ -9,12 +9,9 @@
 
 open JestGlobals
 
-
 describe("ExtensionPointEntryPoint_Ops.parseHandlerConfig", () => {
   testSync("reads the builder's field names", () => {
-    let config = ExtensionPointEntryPoint_Ops.parseHandlerConfig(
-      `{"specModule":"@x/spec/src/Products_ExtensionPoint.res.mjs","mappingsModule":"@x/p/src/ExtensionPoint/Products_ExtensionPointMapping.res.mjs","queueUrl":"https://sqs/ep","publishToAggregates":{"Product":"EP_TEST_PRODUCT_QUEUE"}}`,
-    )
+    let config = ExtensionPointEntryPoint_Ops.parseHandlerConfig(`{"specModule":"@x/spec/src/Products_ExtensionPoint.res.mjs","mappingsModule":"@x/p/src/ExtensionPoint/Products_ExtensionPointMapping.res.mjs","queueUrl":"https://sqs/ep","publishToAggregates":{"Product":"EP_TEST_PRODUCT_QUEUE"}}`)
     expect(config.specModule)->toEqual(Some("@x/spec/src/Products_ExtensionPoint.res.mjs"))
     expect(config.queueUrl)->toEqual(Some("https://sqs/ep"))
     expect(config.publishToAggregates->Option.flatMap(d => d->Dict.get("Product")))->toEqual(

package/tests/HandlerFactoryDispatchTest.res

@@ -85,106 +85,133 @@ let capture = (): Effect.t<ReventlessCore.RequestContext.t, string, _> =>
 
 describe("entry-point dispatch boundary", () => {
   describe("SQS records", () => {
-    testSync("reads the envelope out of the body", () => {
-      expect(extractMetaField(sqsRecords, "correlationId"))->Expect.toEqual(Some("corr-1"))
-      expect(extractMetaField(sqsRecords, "causationId"))->Expect.toEqual(Some("cause-1"))
-    })
+    testSync(
+      "reads the envelope out of the body",
+      () => {
+        expect(extractMetaField(sqsRecords, "correlationId"))->Expect.toEqual(Some("corr-1"))
+        expect(extractMetaField(sqsRecords, "causationId"))->Expect.toEqual(Some("cause-1"))
+      },
+    )
 
-    testSync("reads SentTimestamp as ms since epoch", () =>
-      expect(extractSentTimestamp(sqsRecords))->Expect.toEqual(Some(1750000000000.0))
+    testSync(
+      "reads SentTimestamp as ms since epoch",
+      () => expect(extractSentTimestamp(sqsRecords))->Expect.toEqual(Some(1750000000000.0)),
     )
 
-    testSync("reads ApproximateReceiveCount as the delivery attempt", () =>
-      expect(extractRetryCount(sqsRecords))->Expect.toBe(3)
+    testSync(
+      "reads ApproximateReceiveCount as the delivery attempt",
+      () => expect(extractRetryCount(sqsRecords))->Expect.toBe(3),
     )
   })
 
   describe("DynamoDB stream records", () => {
     // EventLog rows store meta keys flat as top-level attributes
     // (Message.composeMeta rebuilds `meta` from them) — not as a nested map.
-    testSync("reads the envelope off the flat NewImage attributes", () => {
-      expect(extractMetaField(streamRecords, "correlationId"))->Expect.toEqual(Some("corr-2"))
-      expect(extractMetaField(streamRecords, "causationId"))->Expect.toEqual(Some("cause-2"))
-    })
+    testSync(
+      "reads the envelope off the flat NewImage attributes",
+      () => {
+        expect(extractMetaField(streamRecords, "correlationId"))->Expect.toEqual(Some("corr-2"))
+        expect(extractMetaField(streamRecords, "causationId"))->Expect.toEqual(Some("cause-2"))
+      },
+    )
 
-    testSync("converts ApproximateCreationDateTime from seconds to ms", () =>
-      expect(extractSentTimestamp(streamRecords))->Expect.toEqual(Some(1750000001000.0))
+    testSync(
+      "converts ApproximateCreationDateTime from seconds to ms",
+      () => expect(extractSentTimestamp(streamRecords))->Expect.toEqual(Some(1750000001000.0)),
     )
 
-    testSync("reports a first delivery — streams have no receive count", () =>
-      expect(extractRetryCount(streamRecords))->Expect.toBe(1)
+    testSync(
+      "reports a first delivery — streams have no receive count",
+      () => expect(extractRetryCount(streamRecords))->Expect.toBe(1),
     )
   })
 
   describe("absent or malformed input", () => {
-    testSync("an empty batch has no send time", () =>
-      expect(extractSentTimestamp([]))->Expect.toEqual(None)
+    testSync(
+      "an empty batch has no send time",
+      () => expect(extractSentTimestamp([]))->Expect.toEqual(None),
     )
 
-    testSync("an unparseable body yields no envelope field", () =>
-      expect(extractMetaField([{body: "not json"}], "correlationId"))->Expect.toEqual(None)
+    testSync(
+      "an unparseable body yields no envelope field",
+      () => expect(extractMetaField([{body: "not json"}], "correlationId"))->Expect.toEqual(None),
     )
   })
 
   describe("RequestContext provided at dispatch", () => {
-    test("carries the full record, not a bare correlationId literal", async () => {
-      let ctx = await runEffect(
-        capture(),
-        {
-          correlationId: "corr-1",
-          causationId: "cause-1",
-          comp: "AggregateRuntime(Customer)",
-          plugin: "Catalog",
-          timestamp: 1750000000000.0,
-          retryCount: 3,
-        },
-      )
-      expect(ctx.correlationId)->Expect.toBe("corr-1")
-      expect(ctx.causationId)->Expect.toEqual(Some("cause-1"))
-      expect(ctx.component)->Expect.toEqual(Some("AggregateRuntime(Customer)"))
-      expect(ctx.pluginName)->Expect.toEqual(Some("Catalog"))
-      expect(ctx.timestamp)->Expect.toEqual(Some(1750000000000.0))
-      expect(ctx.retryCount)->Expect.toEqual(Some(3))
-    })
-
-    test("fills identity and claims, which the record declares non-optional", async () => {
-      let ctx = await runEffect(capture(), {correlationId: "corr-1"})
-      expect(ctx.identity.userId)->Expect.toBe(Reventless.Identity.anonymous.userId)
-      expect(ctx.claims->Dict.keysToArray)->Expect.toEqual([])
-    })
-
-    test("falls back to a placeholder when no correlationId is on the message", async () => {
-      let ctx = await runEffect(capture(), {comp: "X(Y)"})
-      expect(ctx.correlationId)->Expect.toBe("unknown")
-    })
+    test(
+      "carries the full record, not a bare correlationId literal",
+      async () => {
+        let ctx = await runEffect(
+          capture(),
+          {
+            correlationId: "corr-1",
+            causationId: "cause-1",
+            comp: "AggregateRuntime(Customer)",
+            plugin: "Catalog",
+            timestamp: 1750000000000.0,
+            retryCount: 3,
+          },
+        )
+        expect(ctx.correlationId)->Expect.toBe("corr-1")
+        expect(ctx.causationId)->Expect.toEqual(Some("cause-1"))
+        expect(ctx.component)->Expect.toEqual(Some("AggregateRuntime(Customer)"))
+        expect(ctx.pluginName)->Expect.toEqual(Some("Catalog"))
+        expect(ctx.timestamp)->Expect.toEqual(Some(1750000000000.0))
+        expect(ctx.retryCount)->Expect.toEqual(Some(3))
+      },
+    )
+
+    test(
+      "fills identity and claims, which the record declares non-optional",
+      async () => {
+        let ctx = await runEffect(capture(), {correlationId: "corr-1"})
+        expect(ctx.identity.userId)->Expect.toBe(Reventless.Identity.anonymous.userId)
+        expect(ctx.claims->Dict.keysToArray)->Expect.toEqual([])
+      },
+    )
+
+    test(
+      "falls back to a placeholder when no correlationId is on the message",
+      async () => {
+        let ctx = await runEffect(capture(), {comp: "X(Y)"})
+        expect(ctx.correlationId)->Expect.toBe("unknown")
+      },
+    )
   })
 
   describe("log annotations", () => {
     // Effect keeps annotations in a HashMap; read it as a dict.
     let annotations = (): Effect.t<Effect.logAnnotationMap, string, _> => Effect.logAnnotations
 
-    test("promotes comp, causationId and the request id onto every line", async () => {
-      setRequestId("req-abc")
-      let annotated = await runEffect(
-        annotations(),
-        {correlationId: "corr-1", causationId: "cause-1", comp: "EventCollector(Customers)"},
-      )
-      let annotated = annotated->Effect.annotationsToDict
-      expect(annotated->Dict.get("comp"))->Expect.toEqual(Some("EventCollector(Customers)"))
-      expect(annotated->Dict.get("causationId"))->Expect.toEqual(Some("cause-1"))
-      expect(annotated->Dict.get("correlationId"))->Expect.toEqual(Some("corr-1"))
-      expect(annotated->Dict.get("requestId"))->Expect.toEqual(Some("req-abc"))
-    })
+    test(
+      "promotes comp, causationId and the request id onto every line",
+      async () => {
+        setRequestId("req-abc")
+        let annotated = await runEffect(
+          annotations(),
+          {correlationId: "corr-1", causationId: "cause-1", comp: "EventCollector(Customers)"},
+        )
+        let annotated = annotated->Effect.annotationsToDict
+        expect(annotated->Dict.get("comp"))->Expect.toEqual(Some("EventCollector(Customers)"))
+        expect(annotated->Dict.get("causationId"))->Expect.toEqual(Some("cause-1"))
+        expect(annotated->Dict.get("correlationId"))->Expect.toEqual(Some("corr-1"))
+        expect(annotated->Dict.get("requestId"))->Expect.toEqual(Some("req-abc"))
+      },
+    )
 
     // A constant "1" on every line is noise; its absence is what makes
     // `filter retryCount > 1` a usable CloudWatch query.
-    test("annotates retryCount only on a redelivery", async () => {
-      let first = await runEffect(annotations(), {correlationId: "c", retryCount: 1})
-      expect(first->Effect.annotationsToDict->Dict.get("retryCount"))->Expect.toEqual(None)
-      let redelivered = await runEffect(annotations(), {correlationId: "c", retryCount: 2})
-      expect(redelivered->Effect.annotationsToDict->Dict.get("retryCount"))->Expect.toEqual(
-        Some("2"),
-      )
-    })
+    test(
+      "annotates retryCount only on a redelivery",
+      async () => {
+        let first = await runEffect(annotations(), {correlationId: "c", retryCount: 1})
+        expect(first->Effect.annotationsToDict->Dict.get("retryCount"))->Expect.toEqual(None)
+        let redelivered = await runEffect(annotations(), {correlationId: "c", retryCount: 2})
+        expect(redelivered->Effect.annotationsToDict->Dict.get("retryCount"))->Expect.toEqual(
+          Some("2"),
+        )
+      },
+    )
   })
 })

package/tests/MCP_LambdaTest.res

@@ -22,27 +22,18 @@ describe("MCP_Lambda.generateAdminConfig", () => {
   })
 
   testSync("produces resources from admin query entries", () => {
-    let config = MCP_Lambda.generateAdminConfig(
-      ~serverName="test",
-      ~serverVersion="1.0.0",
-    )
+    let config = MCP_Lambda.generateAdminConfig(~serverName="test", ~serverVersion="1.0.0")
     // PluginBaseFragment has one query entry → generates resources for single + list
     expect(config.resources->Array.length)->toBeGreaterThan(0)
   })
 
   testSync("server name has -admin suffix", () => {
-    let config = MCP_Lambda.generateAdminConfig(
-      ~serverName="my-platform",
-      ~serverVersion="2.0.0",
-    )
+    let config = MCP_Lambda.generateAdminConfig(~serverName="my-platform", ~serverVersion="2.0.0")
     expect(config.serverName)->toBe("my-platform-admin")
   })
 
   testSync("server version is passed through", () => {
-    let config = MCP_Lambda.generateAdminConfig(
-      ~serverName="test",
-      ~serverVersion="3.1.4",
-    )
+    let config = MCP_Lambda.generateAdminConfig(~serverName="test", ~serverVersion="3.1.4")
     expect(config.serverVersion)->toBe("3.1.4")
   })
 
@@ -52,21 +43,22 @@ describe("MCP_Lambda.generateAdminConfig", () => {
       ~serverVersion="1.0.0",
       ~cloner=true,
     )
-    config.tools->Array.forEach(tool => {
-      expect(tool.name->String.length)->toBeGreaterThan(0)
-      expect(tool.description->String.length)->toBeGreaterThan(0)
-    })
+    config.tools->Array.forEach(
+      tool => {
+        expect(tool.name->String.length)->toBeGreaterThan(0)
+        expect(tool.description->String.length)->toBeGreaterThan(0)
+      },
+    )
   })
 
   testSync("resources have non-empty names and URI templates", () => {
-    let config = MCP_Lambda.generateAdminConfig(
-      ~serverName="test",
-      ~serverVersion="1.0.0",
+    let config = MCP_Lambda.generateAdminConfig(~serverName="test", ~serverVersion="1.0.0")
+    config.resources->Array.forEach(
+      resource => {
+        expect(resource.name->String.length)->toBeGreaterThan(0)
+        expect(resource.uriTemplate->String.length)->toBeGreaterThan(0)
+      },
     )
-    config.resources->Array.forEach(resource => {
-      expect(resource.name->String.length)->toBeGreaterThan(0)
-      expect(resource.uriTemplate->String.length)->toBeGreaterThan(0)
-    })
   })
 
   testSync("commandTopicArns are mapped to tools", () => {
@@ -92,10 +84,7 @@ describe("MCP_Lambda.generateAdminConfig", () => {
   })
 
   testSync("event history resources default to empty", () => {
-    let config = MCP_Lambda.generateAdminConfig(
-      ~serverName="test",
-      ~serverVersion="1.0.0",
-    )
+    let config = MCP_Lambda.generateAdminConfig(~serverName="test", ~serverVersion="1.0.0")
     expect(config.eventHistoryResources)->toHaveLength(0)
   })
 })