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

package/tests/eventlog/EventLogFixtures.res

@@ -1,4 +1,3 @@
-
 // ─────────────────────────────────────────────────────────────
 // Test event spec
 // ─────────────────────────────────────────────────────────────
@@ -8,7 +7,7 @@ module ItemEventLogSpec = {
   let name = "TestItemEventLog"
 
   @schema
-  type event = | ItemCreated({name: string}) | ItemDeleted({id: string})
+  type event = ItemCreated({name: string}) | ItemDeleted({id: string})
 }
 
 // ─────────────────────────────────────────────────────────────
@@ -83,7 +82,8 @@ module MockEventTopic: EventTopic.T
     publishJsonStream: ReventlessInfra.EventTopic.publishJsonStream,
   }
   type component = Component.t<EventTopic.t, EventTopic.outputs, operations>
-  let make = (~name as _, ~storageResources as _, ~owner as _=?, ~opts as _=?): component => Obj.magic(0)
+  let make = (~name as _, ~storageResources as _, ~owner as _=?, ~opts as _=?): component =>
+    Obj.magic(0)
 }
 
 let mockEventTopicOps: MockEventTopic.operations = {
@@ -91,7 +91,7 @@ let mockEventTopicOps: MockEventTopic.operations = {
     capturedPublishes := capturedPublishes.contents->Array.concat(events)
   },
   publishJson: async (_service, _meta, _json) => (),
-  publishJsonStream: _stream => Effect.succeed(()),
+  publishJsonStream: _stream => Effect.succeed(),
 }
 
 // ─────────────────────────────────────────────────────────────

package/tests/eventlog/EventLogOperationsTest.res

@@ -15,82 +15,117 @@ let _ = beforeEach(() => reset())
 
 describe("EventLog_Operations:", () => {
   describe("append", () => {
-    testPromise("stores encoded events in storage", async () => {
-      let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
-      let event' = makeEvent'("item-1", event)
-      let _ = await Ops.append(1, "item-1", [event'])
-      let stored = storedEvents.contents->Dict.get("item-1")->Option.getOr([])
-      expect(stored->Array.length)->toBe(1)
-    })
+    testPromise(
+      "stores encoded events in storage",
+      async () => {
+        let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
+        let event' = makeEvent'("item-1", event)
+        let _ = await Ops.append(1, "item-1", [event'])
+        let stored = storedEvents.contents->Dict.get("item-1")->Option.getOr([])
+        expect(stored->Array.length)->toBe(1)
+      },
+    )
 
-    testPromise("publishes events to event topic", async () => {
-      let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
-      let event' = makeEvent'("item-1", event)
-      let _ = await Ops.append(1, "item-1", [event'])
-      expect(capturedPublishes.contents->Array.length)->toBe(1)
-    })
+    testPromise(
+      "publishes events to event topic",
+      async () => {
+        let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
+        let event' = makeEvent'("item-1", event)
+        let _ = await Ops.append(1, "item-1", [event'])
+        expect(capturedPublishes.contents->Array.length)->toBe(1)
+      },
+    )
 
-    testPromise("storage failure returns Error result", async () => {
-      failNextAppend := true
-      let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
-      let event' = makeEvent'("item-1", event)
-      let result = await Ops.append(1, "item-1", [event'])
-      // When storage returns Error (not throws), the operation still publishes
-      // but the Error result is propagated back to the caller.
-      expect(Result.isError(result))->toBe(true)
-    })
+    testPromise(
+      "storage failure returns Error result",
+      async () => {
+        failNextAppend := true
+        let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
+        let event' = makeEvent'("item-1", event)
+        let result = await Ops.append(1, "item-1", [event'])
+        // When storage returns Error (not throws), the operation still publishes
+        // but the Error result is propagated back to the caller.
+        expect(Result.isError(result))->toBe(true)
+      },
+    )
 
-    testPromise("multiple events all stored and published", async () => {
-      let events' = [
-        makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "First"})),
-        makeEvent'("item-2", ItemEventLogSpec.ItemCreated({name: "Second"})),
-      ]
-      let _ = await Ops.append(1, "agg-1", events')
-      let stored = storedEvents.contents->Dict.get("agg-1")->Option.getOr([])
-      expect((stored->Array.length, capturedPublishes.contents->Array.length))->toEqual((2, 2))
-    })
+    testPromise(
+      "multiple events all stored and published",
+      async () => {
+        let events' = [
+          makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "First"})),
+          makeEvent'("item-2", ItemEventLogSpec.ItemCreated({name: "Second"})),
+        ]
+        let _ = await Ops.append(1, "agg-1", events')
+        let stored = storedEvents.contents->Dict.get("agg-1")->Option.getOr([])
+        expect((stored->Array.length, capturedPublishes.contents->Array.length))->toEqual((2, 2))
+      },
+    )
 
-    testPromise("returns Ok on success", async () => {
-      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
-      let result = await Ops.append(1, "item-1", [event'])
-      expect(Result.isOk(result))->toBe(true)
-    })
+    testPromise(
+      "returns Ok on success",
+      async () => {
+        let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+        let result = await Ops.append(1, "item-1", [event'])
+        expect(Result.isOk(result))->toBe(true)
+      },
+    )
   })
 
   describe("replay", () => {
-    testPromise("returns empty array for unknown id", async () => {
-      let events = await Ops.replay("unknown-id")
-      expect(events->Array.length)->toBe(0)
-    })
+    testPromise(
+      "returns empty array for unknown id",
+      async () => {
+        let events = await Ops.replay("unknown-id")
+        expect(events->Array.length)->toBe(0)
+      },
+    )
 
-    testPromise("decodes stored events back to typed events", async () => {
-      let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
-      let event' = makeEvent'("item-1", event)
-      let _ = await Ops.append(1, "item-1", [event'])
-      let replayed = await Ops.replay("item-1")
-      expect(replayed->Array.length)->toBe(1)
-      let first = replayed->Array.getUnsafe(0)
-      expect(first)->toEqual(event)
-    })
+    testPromise(
+      "decodes stored events back to typed events",
+      async () => {
+        let event = ItemEventLogSpec.ItemCreated({name: "Widget"})
+        let event' = makeEvent'("item-1", event)
+        let _ = await Ops.append(1, "item-1", [event'])
+        let replayed = await Ops.replay("item-1")
+        expect(replayed->Array.length)->toBe(1)
+        let first = replayed->Array.getUnsafe(0)
+        expect(first)->toEqual(event)
+      },
+    )
 
-    testPromise("decodes multiple events in order", async () => {
-      let events = [
-        ItemEventLogSpec.ItemCreated({name: "Widget"}),
-        ItemEventLogSpec.ItemDeleted({id: "item-1"}),
-      ]
-      let events' = events->Array.map(event => makeEvent'("item-1", event))
-      let _ = await Ops.append(1, "item-1", events')
-      let replayed = await Ops.replay("item-1")
-      expect(replayed->Array.length)->toBe(2)
-      expect(replayed)->toEqual(events)
-    })
+    testPromise(
+      "decodes multiple events in order",
+      async () => {
+        let events = [
+          ItemEventLogSpec.ItemCreated({name: "Widget"}),
+          ItemEventLogSpec.ItemDeleted({id: "item-1"}),
+        ]
+        let events' = events->Array.map(event => makeEvent'("item-1", event))
+        let _ = await Ops.append(1, "item-1", events')
+        let replayed = await Ops.replay("item-1")
+        expect(replayed->Array.length)->toBe(2)
+        expect(replayed)->toEqual(events)
+      },
+    )
 
-    testPromise("separate aggregates have independent event logs", async () => {
-      let _ = await Ops.append(1, "agg-A", [makeEvent'("agg-A", ItemEventLogSpec.ItemCreated({name: "A"}))])
-      let _ = await Ops.append(1, "agg-B", [makeEvent'("agg-B", ItemEventLogSpec.ItemDeleted({id: "B"}))])
-      let eventsA = await Ops.replay("agg-A")
-      let eventsB = await Ops.replay("agg-B")
-      expect((eventsA->Array.length, eventsB->Array.length))->toEqual((1, 1))
-    })
+    testPromise(
+      "separate aggregates have independent event logs",
+      async () => {
+        let _ = await Ops.append(
+          1,
+          "agg-A",
+          [makeEvent'("agg-A", ItemEventLogSpec.ItemCreated({name: "A"}))],
+        )
+        let _ = await Ops.append(
+          1,
+          "agg-B",
+          [makeEvent'("agg-B", ItemEventLogSpec.ItemDeleted({id: "B"}))],
+        )
+        let eventsA = await Ops.replay("agg-A")
+        let eventsB = await Ops.replay("agg-B")
+        expect((eventsA->Array.length, eventsB->Array.length))->toEqual((1, 1))
+      },
+    )
   })
 })

package/tests/eventlog/EventLogRetryTest.res

@@ -17,84 +17,123 @@ let _ = beforeEach(() => reset())
 describe("EventLog_Operations — retry:", () => {
   describe("isTransient predicate:", () => {
     let transient = msg => EventLog_Operations.isTransient(EventLog.StorageFailure(msg))
-    testPromise("ThrottlingException is transient", async () => {
-      expect(transient("ThrottlingException: Rate exceeded"))->toBe(true)
-    })
+    testPromise(
+      "ThrottlingException is transient",
+      async () => {
+        expect(transient("ThrottlingException: Rate exceeded"))->toBe(true)
+      },
+    )
 
-    testPromise("ProvisionedThroughputExceededException is transient", async () => {
-      expect(transient("ProvisionedThroughputExceededException"))->toBe(true)
-    })
+    testPromise(
+      "ProvisionedThroughputExceededException is transient",
+      async () => {
+        expect(transient("ProvisionedThroughputExceededException"))->toBe(true)
+      },
+    )
 
-    testPromise("ServiceUnavailable is transient", async () => {
-      expect(transient("ServiceUnavailable"))->toBe(true)
-    })
+    testPromise(
+      "ServiceUnavailable is transient",
+      async () => {
+        expect(transient("ServiceUnavailable"))->toBe(true)
+      },
+    )
 
-    testPromise("RequestLimitExceeded is transient", async () => {
-      expect(transient("RequestLimitExceeded"))->toBe(true)
-    })
+    testPromise(
+      "RequestLimitExceeded is transient",
+      async () => {
+        expect(transient("RequestLimitExceeded"))->toBe(true)
+      },
+    )
 
-    testPromise("InternalServerError is transient", async () => {
-      expect(transient("InternalServerError: something went wrong"))->toBe(true)
-    })
+    testPromise(
+      "InternalServerError is transient",
+      async () => {
+        expect(transient("InternalServerError: something went wrong"))->toBe(true)
+      },
+    )
 
-    testPromise("ValidationException is not transient", async () => {
-      expect(transient("ValidationException: invalid field"))->toBe(false)
-    })
+    testPromise(
+      "ValidationException is not transient",
+      async () => {
+        expect(transient("ValidationException: invalid field"))->toBe(false)
+      },
+    )
 
-    testPromise("generic mock storage failure is not transient", async () => {
-      expect(transient("mock storage failure"))->toBe(false)
-    })
+    testPromise(
+      "generic mock storage failure is not transient",
+      async () => {
+        expect(transient("mock storage failure"))->toBe(false)
+      },
+    )
 
-    testPromise("a Conflict is never transient (retried a layer up, not here)", async () => {
-      expect(EventLog_Operations.isTransient(EventLog.Conflict))->toBe(false)
-    })
+    testPromise(
+      "a Conflict is never transient (retried a layer up, not here)",
+      async () => {
+        expect(EventLog_Operations.isTransient(EventLog.Conflict))->toBe(false)
+      },
+    )
   })
 
   describe("permanent storage failure:", () => {
-    testPromise("returns Error immediately without retry", async () => {
-      failNextAppend := true // "mock storage failure" — not transient, no retry
-      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
-      let result = await Ops.append(1, "item-1", [event'])
-      expect(Result.isError(result))->toBe(true)
-      // Exactly one attempt — permanent error is not retried
-      expect(appendCallCount.contents)->toBe(1)
-    })
-
-    testPromise("does not publish events after permanent storage failure", async () => {
-      failNextAppend := true
-      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
-      let _ = await Ops.append(1, "item-1", [event'])
-      expect(capturedPublishes.contents->Array.length)->toBe(0)
-    })
+    testPromise(
+      "returns Error immediately without retry",
+      async () => {
+        failNextAppend := true // "mock storage failure" — not transient, no retry
+        let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+        let result = await Ops.append(1, "item-1", [event'])
+        expect(Result.isError(result))->toBe(true)
+        // Exactly one attempt — permanent error is not retried
+        expect(appendCallCount.contents)->toBe(1)
+      },
+    )
+
+    testPromise(
+      "does not publish events after permanent storage failure",
+      async () => {
+        failNextAppend := true
+        let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+        let _ = await Ops.append(1, "item-1", [event'])
+        expect(capturedPublishes.contents->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("transient storage failure — retry:", () => {
-    testPromise("1 transient failure retries and returns Ok", async () => {
-      failNextAppendsWithTransient := 1
-      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
-      let result = await Ops.append(1, "item-1", [event'])
-      expect(Result.isOk(result))->toBe(true)
-      // 1 initial attempt + 1 retry = 2 total calls to storage.append
-      expect(appendCallCount.contents)->toBe(2)
-    })
-
-    testPromise("events are stored and published after successful retry", async () => {
-      failNextAppendsWithTransient := 1
-      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
-      let _ = await Ops.append(1, "item-1", [event'])
-      let stored = storedEvents.contents->Dict.get("item-1")->Option.getOr([])
-      expect(stored->Array.length)->toBe(1)
-      expect(capturedPublishes.contents->Array.length)->toBe(1)
-    })
-
-    testPromise("2 transient failures retry twice and return Ok", async () => {
-      failNextAppendsWithTransient := 2
-      let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
-      let result = await Ops.append(1, "item-1", [event'])
-      expect(Result.isOk(result))->toBe(true)
-      // 1 initial + 2 retries = 3 total calls
-      expect(appendCallCount.contents)->toBe(3)
-    })
+    testPromise(
+      "1 transient failure retries and returns Ok",
+      async () => {
+        failNextAppendsWithTransient := 1
+        let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+        let result = await Ops.append(1, "item-1", [event'])
+        expect(Result.isOk(result))->toBe(true)
+        // 1 initial attempt + 1 retry = 2 total calls to storage.append
+        expect(appendCallCount.contents)->toBe(2)
+      },
+    )
+
+    testPromise(
+      "events are stored and published after successful retry",
+      async () => {
+        failNextAppendsWithTransient := 1
+        let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+        let _ = await Ops.append(1, "item-1", [event'])
+        let stored = storedEvents.contents->Dict.get("item-1")->Option.getOr([])
+        expect(stored->Array.length)->toBe(1)
+        expect(capturedPublishes.contents->Array.length)->toBe(1)
+      },
+    )
+
+    testPromise(
+      "2 transient failures retry twice and return Ok",
+      async () => {
+        failNextAppendsWithTransient := 2
+        let event' = makeEvent'("item-1", ItemEventLogSpec.ItemCreated({name: "Widget"}))
+        let result = await Ops.append(1, "item-1", [event'])
+        expect(Result.isOk(result))->toBe(true)
+        // 1 initial + 2 retries = 3 total calls
+        expect(appendCallCount.contents)->toBe(3)
+      },
+    )
   })
 
   describe("retry exhaustion:", () => {