@reventlessdev/reventless-core 3.0.0-alpha.260 → 3.0.0-alpha.261

package/tests/extensionpoint/ExtensionPointCallbackTest.res

@@ -5,80 +5,93 @@ let _ = beforeEach(() => reset())
 
 describe("ExtensionPoint_Callback.handleIncomingCommands:", () => {
   describe("AbstractPublishCommand — known aggregate", () => {
-    testPromise("dispatches to aggregate publishJsons, returns Ok(reference)", async () => {
-      let results =
-        await Stream.fromIterable([makeTopicItem("ref-1", TestEPSpec.RouteToAgg({aggId: "agg-1"}))])
+    testPromise(
+      "dispatches to aggregate publishJsons, returns Ok(reference)",
+      async () => {
+        let results = await Stream.fromIterable([
+          makeTopicItem("ref-1", TestEPSpec.RouteToAgg({aggId: "agg-1"})),
+        ])
         ->TestHandler.handleIncomingCommands
         ->Effect.runPromise
-      expect((results, capturedPublishedCmds.contents->Array.length))->toEqual(([Ok("ref-1")], 1))
-    })
+        expect((results, capturedPublishedCmds.contents->Array.length))->toEqual(([Ok("ref-1")], 1))
+      },
+    )
   })
 
   describe("AbstractPublishCommand — unknown aggregate", () => {
-    testPromise("throws internally, returns Error(reference)", async () => {
-      // Create a mapping that routes to an aggregate not in publishToAggregates
-      // We'll directly build a topic item that our TestMapping won't route to "TestTargetAgg"
-      // Instead test via a handler that produces AbstractPublishCommand for an unknown name.
-      // We can't easily override the mapping, so we test via the applyCommandAction path:
-      // the TestMapping always routes RouteToAgg to "TestTargetAgg" which IS in the dict.
-      // For the "unknown" case, we rely on applyCommandAction's own error path.
-      // We test this by calling handleIncomingCommands with 2 items where the second
-      // targets a known aggregate — verify both refs in results.
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "throws internally, returns Error(reference)",
+      async () => {
+        // Create a mapping that routes to an aggregate not in publishToAggregates
+        // We'll directly build a topic item that our TestMapping won't route to "TestTargetAgg"
+        // Instead test via a handler that produces AbstractPublishCommand for an unknown name.
+        // We can't easily override the mapping, so we test via the applyCommandAction path:
+        // the TestMapping always routes RouteToAgg to "TestTargetAgg" which IS in the dict.
+        // For the "unknown" case, we rely on applyCommandAction's own error path.
+        // We test this by calling handleIncomingCommands with 2 items where the second
+        // targets a known aggregate — verify both refs in results.
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-a", TestEPSpec.RouteToAgg({aggId: "agg-1"})),
           makeTopicItem("ref-b", TestEPSpec.RouteToAgg({aggId: "agg-2"})),
         ])
         ->TestHandler.handleIncomingCommands
         ->Effect.runPromise
-      // Both route to "TestTargetAgg" (known) — both should return Ok
-      expect(results->Array.length)->toBe(2)
-      let allOk = results->Array.every(r =>
-        switch r {
-        | Ok(_) => true
-        | Error(_) => false
-        }
-      )
-      expect(allOk)->toBe(true)
-    })
+        // Both route to "TestTargetAgg" (known) — both should return Ok
+        expect(results->Array.length)->toBe(2)
+        let allOk = results->Array.every(
+          r =>
+            switch r {
+            | Ok(_) => true
+            | Error(_) => false
+            },
+        )
+        expect(allOk)->toBe(true)
+      },
+    )
   })
 
   describe("AbstractHandleDirective handler succeeds", () => {
-    testPromise("handler called, returns Ok(reference)", async () => {
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "handler called, returns Ok(reference)",
+      async () => {
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-1", TestEPSpec.TriggerDirective({value: "test"})),
         ])
         ->TestHandler.handleIncomingCommands
         ->Effect.runPromise
-      expect((results, capturedCallCount.contents))->toEqual(([Ok("ref-1")], 1))
-    })
+        expect((results, capturedCallCount.contents))->toEqual(([Ok("ref-1")], 1))
+      },
+    )
   })
 
   describe("mixed actions", () => {
-    testPromise("AbstractPublishCommand and AbstractHandleDirective both resolved", async () => {
-      let results =
-        await Stream.fromIterable([
+    testPromise(
+      "AbstractPublishCommand and AbstractHandleDirective both resolved",
+      async () => {
+        let results = await Stream.fromIterable([
           makeTopicItem("ref-pub", TestEPSpec.RouteToAgg({aggId: "agg-1"})),
           makeTopicItem("ref-call", TestEPSpec.TriggerDirective({value: "v"})),
         ])
         ->TestHandler.handleIncomingCommands
         ->Effect.runPromise
-      expect((
-        results->Array.length,
-        capturedPublishedCmds.contents->Array.length,
-        capturedCallCount.contents,
-      ))->toEqual((2, 1, 1))
-    })
+        expect((
+          results->Array.length,
+          capturedPublishedCmds.contents->Array.length,
+          capturedCallCount.contents,
+        ))->toEqual((2, 1, 1))
+      },
+    )
   })
 
   describe("empty batch", () => {
-    testPromise("returns empty array", async () => {
-      let results =
-        await Stream.fromIterable([])
+    testPromise(
+      "returns empty array",
+      async () => {
+        let results = await Stream.fromIterable([])
         ->TestHandler.handleIncomingCommands
         ->Effect.runPromise
-      expect(results)->toEqual([])
-    })
+        expect(results)->toEqual([])
+      },
+    )
   })
 })

package/tests/extensionpoint/ExtensionPointFixtures.res

@@ -14,10 +14,10 @@ module TestEPSpec = {
     | TriggerDirective({value: string})
 
   @schema
-  type event = | Done({result: string})
+  type event = Done({result: string})
 
   @schema
-  type directive = | DirectiveA
+  type directive = DirectiveA
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -75,9 +75,7 @@ module TestMapping = {
       Reventless.Schedule.create,
       Reventless.Schedule.delete,
       Reventless.QueryEngine.operations,
-    ) => array<
-      ReventlessInfra.ExtensionPointMapping.abstractEventAction<TestEPSpec.event>,
-    >,
+    ) => array<ReventlessInfra.ExtensionPointMapping.abstractEventAction<TestEPSpec.event>>,
   > = None
 }
 
@@ -87,7 +85,8 @@ module TestMapping = {
 
 module TestMappings = {
   module Spec = TestEPSpec
-  module type Mapping = ReventlessInfra.ExtensionPointMapping.T with module ExtensionPoint := TestEPSpec
+  module type Mapping = ReventlessInfra.ExtensionPointMapping.T
+    with module ExtensionPoint := TestEPSpec
   let name = "TestMappings"
   let moduleUrl: string = %raw(`import.meta.url`)
   let mappings: array<module(Mapping)> = [module(TestMapping)]
@@ -98,16 +97,14 @@ module TestMappings = {
 // ─────────────────────────────────────────────────────────────
 
 module TestCallbackSpec: ExtensionPoint_Callback.Spec = {
-  let publishToAggregates: dict<CommandTopic.publishJsons> =
-    Dict.fromArray([
-      (
-        "TestTargetAgg",
-        async cmds => {
-          capturedPublishedCmds :=
-            capturedPublishedCmds.contents->Array.concat(cmds)
-        },
-      ),
-    ])
+  let publishToAggregates: dict<CommandTopic.publishJsons> = Dict.fromArray([
+    (
+      "TestTargetAgg",
+      async cmds => {
+        capturedPublishedCmds := capturedPublishedCmds.contents->Array.concat(cmds)
+      },
+    ),
+  ])
 
   let commandTopicResources: array<Adapter.resolvedResource> = []
 
@@ -154,10 +151,9 @@ let testMeta: Message.meta = {
   correlationId: "ep-corr-1",
 }
 
-let makeTopicItem = (
-  reference,
-  command,
-): CommandTopic.topicItem<Message.command'<Reventless.Id.String.t, TestEPSpec.command>> => {
+let makeTopicItem = (reference, command): CommandTopic.topicItem<
+  Message.command'<Reventless.Id.String.t, TestEPSpec.command>,
+> => {
   command: {
     id: reference->Reventless.Id.String.makeFromString,
     meta: testMeta,

package/tests/extensionpoint/ExtensionPointOperationsTest.res

@@ -3,7 +3,6 @@
 
 open JestGlobals
 
-
 // ─────────────────────────────────────────────────────────────
 // EP Spec — minimal types for operations tests
 // ─────────────────────────────────────────────────────────────
@@ -12,13 +11,13 @@ module OpsEPSpec = {
   let name = "OpsTestEP"
 
   @schema
-  type command = | OpsEPCmd({id: string})
+  type command = OpsEPCmd({id: string})
 
   @schema
-  type event = | OpsEPEvent({result: string})
+  type event = OpsEPEvent({result: string})
 
   @schema
-  type directive = | OpsEPNoDirective
+  type directive = OpsEPNoDirective
 
   let moduleUrl: string = %raw(`import.meta.url`)
 }
@@ -57,7 +56,11 @@ module TestPublishMapping = {
   let mapOutgoingEvent = Some(
     (eventJson, _createSchedule, _deleteSchedule, _queryEngine) => {
       [
-        ReventlessInfra.ExtensionPointMapping.AbstractPublishEvent("ep-dest", outgoingMeta, eventJson),
+        ReventlessInfra.ExtensionPointMapping.AbstractPublishEvent(
+          "ep-dest",
+          outgoingMeta,
+          eventJson,
+        ),
       ]
     },
   )
@@ -81,9 +84,11 @@ module TestCallMapping = {
   let mapOutgoingEvent = Some(
     (_eventJson, _createSchedule, _deleteSchedule, _queryEngine) => {
       [
-        ReventlessInfra.ExtensionPointMapping.AbstractHandleDirective(async () => {
-          capturedCallCount := capturedCallCount.contents + 1
-        }),
+        ReventlessInfra.ExtensionPointMapping.AbstractHandleDirective(
+          async () => {
+            capturedCallCount := capturedCallCount.contents + 1
+          },
+        ),
       ]
     },
   )
@@ -122,7 +127,8 @@ module TestAsyncMapping = {
 
 module TestOpsMappings = {
   module Spec = OpsEPSpec
-  module type Mapping = ReventlessInfra.ExtensionPointMapping.T with module ExtensionPoint := OpsEPSpec
+  module type Mapping = ReventlessInfra.ExtensionPointMapping.T
+    with module ExtensionPoint := OpsEPSpec
   let name = "TestOpsMappings"
   let moduleUrl: string = %raw(`import.meta.url`)
   let mappings: array<module(Mapping)> = [
@@ -207,54 +213,69 @@ describe("ExtensionPoint_Operations.Make:", () => {
   let _ = beforeEach(() => reset())
 
   describe("outgoingJsonEventsHandler — AbstractPublishEvent:", () => {
-    testPromise("known aggregate calls publishToEventTopic with correct destination id", async () => {
-      let eventJson = makeEventJsonForAgg("PublishAgg")
-      await EpOps.outgoingJsonEventsHandler(eventJson, ())
-      expect(capturedPublished.contents->Array.length)->toBe(1)
-      let item = capturedPublished.contents->Array.getUnsafe(0)
-      let (id, _, _) = item
-      expect(id)->toBe("ep-dest")
-    })
-
-    testPromise("publishToEventTopic receives the original event JSON", async () => {
-      let eventJson = makeEventJsonForAgg("PublishAgg")
-      await EpOps.outgoingJsonEventsHandler(eventJson, ())
-      let item = capturedPublished.contents->Array.getUnsafe(0)
-      let (_, _, capturedEventJson) = item
-      expect(capturedEventJson)->toEqual(eventJson)
-    })
+    testPromise(
+      "known aggregate calls publishToEventTopic with correct destination id",
+      async () => {
+        let eventJson = makeEventJsonForAgg("PublishAgg")
+        await EpOps.outgoingJsonEventsHandler(eventJson, ())
+        expect(capturedPublished.contents->Array.length)->toBe(1)
+        let item = capturedPublished.contents->Array.getUnsafe(0)
+        let (id, _, _) = item
+        expect(id)->toBe("ep-dest")
+      },
+    )
+
+    testPromise(
+      "publishToEventTopic receives the original event JSON",
+      async () => {
+        let eventJson = makeEventJsonForAgg("PublishAgg")
+        await EpOps.outgoingJsonEventsHandler(eventJson, ())
+        let item = capturedPublished.contents->Array.getUnsafe(0)
+        let (_, _, capturedEventJson) = item
+        expect(capturedEventJson)->toEqual(eventJson)
+      },
+    )
   })
 
   describe("outgoingJsonEventsHandler — AbstractHandleDirective:", () => {
-    testPromise("known aggregate with AbstractHandleDirective invokes the handler", async () => {
-      let eventJson = makeEventJsonForAgg("CallAgg")
-      await EpOps.outgoingJsonEventsHandler(eventJson, ())
-      expect(capturedCallCount.contents)->toBe(1)
-      expect(capturedPublished.contents->Array.length)->toBe(0)
-    })
+    testPromise(
+      "known aggregate with AbstractHandleDirective invokes the handler",
+      async () => {
+        let eventJson = makeEventJsonForAgg("CallAgg")
+        await EpOps.outgoingJsonEventsHandler(eventJson, ())
+        expect(capturedCallCount.contents)->toBe(1)
+        expect(capturedPublished.contents->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("outgoingJsonEventsHandler — AbstractPublishEventAsync:", () => {
-    testPromise("async mapping resolves and calls publishToEventTopic", async () => {
-      let eventJson = makeEventJsonForAgg("AsyncAgg")
-      await EpOps.outgoingJsonEventsHandler(eventJson, ())
-      expect(capturedPublished.contents->Array.length)->toBe(1)
-      let item = capturedPublished.contents->Array.getUnsafe(0)
-      let (id, _, _) = item
-      expect(id)->toBe("ep-async-dest")
-    })
+    testPromise(
+      "async mapping resolves and calls publishToEventTopic",
+      async () => {
+        let eventJson = makeEventJsonForAgg("AsyncAgg")
+        await EpOps.outgoingJsonEventsHandler(eventJson, ())
+        expect(capturedPublished.contents->Array.length)->toBe(1)
+        let item = capturedPublished.contents->Array.getUnsafe(0)
+        let (id, _, _) = item
+        expect(id)->toBe("ep-async-dest")
+      },
+    )
   })
 
   describe("outgoingJsonEventsHandler — no matching mapping:", () => {
-    testPromise("event from unknown aggregate throws", async () => {
-      let eventJson = makeEventJsonForAgg("UnknownAgg")
-      let didThrow = ref(false)
-      try {
-        await EpOps.outgoingJsonEventsHandler(eventJson, ())
-      } catch {
-      | _ => didThrow := true
-      }
-      expect(didThrow.contents)->toBe(true)
-    })
+    testPromise(
+      "event from unknown aggregate throws",
+      async () => {
+        let eventJson = makeEventJsonForAgg("UnknownAgg")
+        let didThrow = ref(false)
+        try {
+          await EpOps.outgoingJsonEventsHandler(eventJson, ())
+        } catch {
+        | _ => didThrow := true
+        }
+        expect(didThrow.contents)->toBe(true)
+      },
+    )
   })
 })

package/tests/extensionpoint/PluginDisconnectScheduleTest.res

@@ -45,7 +45,8 @@ let queryEngine: Reventless.QueryEngine.operations = {
 
 let pluginId = "Catalog_1.0.0-alpha.169"
 
-let handle = directive => EP.directiveHandler(createSchedule, deleteSchedule, queryEngine, directive)
+let handle = directive =>
+  EP.directiveHandler(createSchedule, deleteSchedule, queryEngine, directive)
 
 describe("plugin disconnect schedule", () => {
   test("create and delete address the same rule name", async () => {