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

package/tests/dcb/DcbEventLogOperationsTest.res

@@ -25,7 +25,9 @@ module OpsAlt = DcbEventLog_Operations.Make(TestOpsAlt)
 let _ = beforeEach(() => mock.reset())
 
 // Helper to encode a TestEventLogSpec event to a rawEvent for testing
-let encodeEvent = (event: DcbFixtures.TestEventLogSpec.event): ReventlessInfra.DcbEventLog.rawEvent => {
+let encodeEvent = (
+  event: DcbFixtures.TestEventLogSpec.event,
+): ReventlessInfra.DcbEventLog.rawEvent => {
   let json = event->Reventless.Util_Sury.toJson(DcbFixtures.TestEventLogSpec.eventSchema)
   let (eventType, data) = json->Message.splitMessage
   let tags = Reventless.DcbTag.extractTags(DcbFixtures.TestEventLogSpec.eventSchema, event)
@@ -34,7 +36,9 @@ let encodeEvent = (event: DcbFixtures.TestEventLogSpec.event): ReventlessInfra.D
 }
 
 // Helper to decode a rawSequencedEvent back to a TestEventLogSpec event
-let decodeEvent = (raw: ReventlessInfra.DcbEventLog.rawSequencedEvent): DcbFixtures.TestEventLogSpec.event => {
+let decodeEvent = (
+  raw: ReventlessInfra.DcbEventLog.rawSequencedEvent,
+): DcbFixtures.TestEventLogSpec.event => {
   let json = Message.combineMessage(
     raw.eventType,
     raw.data->JSON.Decode.object->Option.getOr(Dict.make()),
@@ -44,152 +48,199 @@ let decodeEvent = (raw: ReventlessInfra.DcbEventLog.rawSequencedEvent): DcbFixtu
 
 describe("DcbEventLog_Operations:", () => {
   describe("round-trip (append then read)", () => {
-    testPromise("ItemCreated preserves through round-trip", async () => {
-      let event = DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})
-      let rawEvent = encodeEvent(event)
-      let _ = await Ops.append([rawEvent])
-      let result = await Ops.read(~query=[{}])
-
-      expect((
-        result.events->Array.length,
-        result.events->Array.get(0)->Option.map(se => decodeEvent(se)),
-      ))->toEqual((1, Some(event)))
-    })
-
-    testPromise("CountUpdated with int tag preserves through round-trip", async () => {
-      let event = DcbFixtures.TestEventLogSpec.CountUpdated({category: "electronics", amount: 42})
-      let rawEvent = encodeEvent(event)
-      let _ = await Ops.append([rawEvent])
-      let result = await Ops.read(~query=[{}])
-
-      expect(result.events->Array.get(0)->Option.map(se => decodeEvent(se)))->toEqual(Some(event))
-    })
-
-    testPromise("multiple events in single append all read back", async () => {
-      let events = [
-        DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "First"}),
-        DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Second"}),
-      ]
-      let rawEvents = events->Array.map(encodeEvent)
-      let _ = await Ops.append(rawEvents)
-      let result = await Ops.read(~query=[{}])
-
-      expect((
-        result.events->Array.length,
-        result.events->Array.map(se => decodeEvent(se)),
-      ))->toEqual((2, events))
-    })
+    testPromise(
+      "ItemCreated preserves through round-trip",
+      async () => {
+        let event = DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})
+        let rawEvent = encodeEvent(event)
+        let _ = await Ops.append([rawEvent])
+        let result = await Ops.read(~query=[{}])
+
+        expect((
+          result.events->Array.length,
+          result.events->Array.get(0)->Option.map(se => decodeEvent(se)),
+        ))->toEqual((1, Some(event)))
+      },
+    )
+
+    testPromise(
+      "CountUpdated with int tag preserves through round-trip",
+      async () => {
+        let event = DcbFixtures.TestEventLogSpec.CountUpdated({category: "electronics", amount: 42})
+        let rawEvent = encodeEvent(event)
+        let _ = await Ops.append([rawEvent])
+        let result = await Ops.read(~query=[{}])
+
+        expect(result.events->Array.get(0)->Option.map(se => decodeEvent(se)))->toEqual(Some(event))
+      },
+    )
+
+    testPromise(
+      "multiple events in single append all read back",
+      async () => {
+        let events = [
+          DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "First"}),
+          DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Second"}),
+        ]
+        let rawEvents = events->Array.map(encodeEvent)
+        let _ = await Ops.append(rawEvents)
+        let result = await Ops.read(~query=[{}])
+
+        expect((
+          result.events->Array.length,
+          result.events->Array.map(se => decodeEvent(se)),
+        ))->toEqual((2, events))
+      },
+    )
   })
 
   describe("append", () => {
-    testPromise("stores events and publishes to event topic", async () => {
-      let event = DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})
-      let result = await Ops.append([encodeEvent(event)])
-
-      expect((
-        Result.isOk(result),
-        mock.getEvents()->Array.length,
-        mock.publishedEvents.contents->Array.length,
-      ))->toEqual((true, 1, 1))
-    })
-
-    testPromise("published events have correct service name", async () => {
-      let _ = await Ops.append([
-        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
-      ])
-
-      expect(
-        mock.publishedEvents.contents->Array.get(0)->Option.map(pe => pe.service),
-      )->toEqual(Some("TestDcbEventLog"))
-    })
-
-    testPromise("service comes from Ops.serviceName, not Ops.name", async () => {
-      let _ = await OpsAlt.append([
-        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
-      ])
-
-      expect(
-        mock.publishedEvents.contents->Array.get(0)->Option.map(pe => pe.service),
-      )->toEqual(Some("CatalogDcbEventLog"))
-    })
-
-    testPromise("error from storage does not publish to event topic", async () => {
-      mock.failNextAppends := 1
-      let result = await Ops.append([
-        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
-      ])
-
-      expect((Result.isError(result), mock.publishedEvents.contents->Array.length))->toEqual((
-        true,
-        0,
-      ))
-    })
-
-    testPromise("with condition (no conflict) succeeds", async () => {
-      let _ = await Ops.append([
-        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
-      ])
-      let condition: Reventless.DcbTag.appendCondition = {
-        query: [{eventTypes: ["ItemCreated"], tags: [{Reventless.DcbTag.key: "itemId", value: "item-1"}]}],
-        after: "1",
-      }
-      let result = await Ops.append(
-        [encodeEvent(DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Updated"}))],
-        ~condition,
-      )
-
-      expect(Result.isOk(result))->toBe(true)
-    })
-
-    testPromise("multiple events all stored and published", async () => {
-      let events = [
-        DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "First"}),
-        DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-2", name: "Second"}),
-      ]
-      let _ = await Ops.append(events->Array.map(encodeEvent))
-
-      expect((
-        mock.getEvents()->Array.length,
-        mock.publishedEvents.contents->Array.length,
-      ))->toEqual((2, 2))
-    })
+    testPromise(
+      "stores events and publishes to event topic",
+      async () => {
+        let event = DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})
+        let result = await Ops.append([encodeEvent(event)])
+
+        expect((
+          Result.isOk(result),
+          mock.getEvents()->Array.length,
+          mock.publishedEvents.contents->Array.length,
+        ))->toEqual((true, 1, 1))
+      },
+    )
+
+    testPromise(
+      "published events have correct service name",
+      async () => {
+        let _ = await Ops.append([
+          encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+        ])
+
+        expect(mock.publishedEvents.contents->Array.get(0)->Option.map(pe => pe.service))->toEqual(
+          Some("TestDcbEventLog"),
+        )
+      },
+    )
+
+    testPromise(
+      "service comes from Ops.serviceName, not Ops.name",
+      async () => {
+        let _ = await OpsAlt.append([
+          encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+        ])
+
+        expect(mock.publishedEvents.contents->Array.get(0)->Option.map(pe => pe.service))->toEqual(
+          Some("CatalogDcbEventLog"),
+        )
+      },
+    )
+
+    testPromise(
+      "error from storage does not publish to event topic",
+      async () => {
+        mock.failNextAppends := 1
+        let result = await Ops.append([
+          encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+        ])
+
+        expect((Result.isError(result), mock.publishedEvents.contents->Array.length))->toEqual((
+          true,
+          0,
+        ))
+      },
+    )
+
+    testPromise(
+      "with condition (no conflict) succeeds",
+      async () => {
+        let _ = await Ops.append([
+          encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+        ])
+        let condition: Reventless.DcbTag.appendCondition = {
+          query: [
+            {
+              eventTypes: ["ItemCreated"],
+              tags: [{Reventless.DcbTag.key: "itemId", value: "item-1"}],
+            },
+          ],
+          after: "1",
+        }
+        let result = await Ops.append(
+          [
+            encodeEvent(
+              DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Updated"}),
+            ),
+          ],
+          ~condition,
+        )
+
+        expect(Result.isOk(result))->toBe(true)
+      },
+    )
+
+    testPromise(
+      "multiple events all stored and published",
+      async () => {
+        let events = [
+          DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "First"}),
+          DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-2", name: "Second"}),
+        ]
+        let _ = await Ops.append(events->Array.map(encodeEvent))
+
+        expect((
+          mock.getEvents()->Array.length,
+          mock.publishedEvents.contents->Array.length,
+        ))->toEqual((2, 2))
+      },
+    )
   })
 
   describe("read", () => {
-    testPromise("returns headPosition from storage", async () => {
-      let _ = await Ops.append([
-        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
-      ])
-      let result = await Ops.read(~query=[{}])
-
-      expect(result.headPosition)->toEqual(Some("1"))
-    })
-
-    testPromise("with ~after parameter filters out earlier events", async () => {
-      let _ = await Ops.append([
-        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "First"})),
-      ])
-      let _ = await Ops.append([
-        encodeEvent(DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Second"})),
-      ])
-      let result = await Ops.read(~query=[{}], ~after="1")
-
-      expect((
-        result.events->Array.length,
-        result.events->Array.get(0)->Option.map(se => decodeEvent(se)),
-      ))->toEqual((
-        1,
-        Some(DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Second"})),
-      ))
-    })
-
-    testPromise("no matching events returns empty array", async () => {
-      let _ = await Ops.append([
-        encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
-      ])
-      let result = await Ops.read(~query=[{eventTypes: ["NonExistent"]}])
-
-      expect(result.events->Array.length)->toEqual(0)
-    })
+    testPromise(
+      "returns headPosition from storage",
+      async () => {
+        let _ = await Ops.append([
+          encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+        ])
+        let result = await Ops.read(~query=[{}])
+
+        expect(result.headPosition)->toEqual(Some("1"))
+      },
+    )
+
+    testPromise(
+      "with ~after parameter filters out earlier events",
+      async () => {
+        let _ = await Ops.append([
+          encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "First"})),
+        ])
+        let _ = await Ops.append([
+          encodeEvent(
+            DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Second"}),
+          ),
+        ])
+        let result = await Ops.read(~query=[{}], ~after="1")
+
+        expect((
+          result.events->Array.length,
+          result.events->Array.get(0)->Option.map(se => decodeEvent(se)),
+        ))->toEqual((
+          1,
+          Some(DcbFixtures.TestEventLogSpec.ItemRenamed({itemId: "item-1", newName: "Second"})),
+        ))
+      },
+    )
+
+    testPromise(
+      "no matching events returns empty array",
+      async () => {
+        let _ = await Ops.append([
+          encodeEvent(DcbFixtures.TestEventLogSpec.ItemCreated({itemId: "item-1", name: "Test"})),
+        ])
+        let result = await Ops.read(~query=[{eventTypes: ["NonExistent"]}])
+
+        expect(result.events->Array.length)->toEqual(0)
+      },
+    )
   })
 })

package/tests/dcb/DcbEventLogSchemaTest.res

@@ -26,17 +26,18 @@ let variant = (~tag: string, fields: array<(string, S.t<unknown>)>): S.t<unknown
 
 let ref_ = (~store: string) => Reventless.StorageRef.forStore(~store)->S.castToUnknown
 
-let addCategory = S.union([
-  variant(~tag="CategoryAdded", [("imageUrl", ref_(~store="categoryImages"))]),
-])->S.castToUnknown
+let addCategory =
+  S.union([
+    variant(~tag="CategoryAdded", [("imageUrl", ref_(~store="categoryImages"))]),
+  ])->S.castToUnknown
 
-let addProduct = S.union([
-  variant(~tag="ProductAdded", [("imageUrl", ref_(~store="productImages"))]),
-])->S.castToUnknown
+let addProduct =
+  S.union([
+    variant(~tag="ProductAdded", [("imageUrl", ref_(~store="productImages"))]),
+  ])->S.castToUnknown
 
-let renameCategory = S.union([
-  variant(~tag="CategoryRenamed", [("name", S.string->S.castToUnknown)]),
-])->S.castToUnknown
+let renameCategory =
+  S.union([variant(~tag="CategoryRenamed", [("name", S.string->S.castToUnknown)])])->S.castToUnknown
 
 describe("Dcb_Builder.mergedEventSchema", () => {
   testSync("carries every slice's event types, not the first slice's", () => {
@@ -53,10 +54,9 @@ describe("Dcb_Builder.mergedEventSchema", () => {
   testSync("surfaces the ref fields of every slice that declares one", () => {
     let merged = [addCategory, addProduct, renameCategory]->Dcb_Builder.mergedEventSchema
     expect(
-      StorageRefFields.fromEventSchema(~plugin="Catalog", merged)->Array.map(e => (
-        e.eventType,
-        e.fields->Array.map(f => f.store),
-      )),
+      StorageRefFields.fromEventSchema(~plugin="Catalog", merged)->Array.map(
+        e => (e.eventType, e.fields->Array.map(f => f.store)),
+      ),
     )->toEqual([
       ("CategoryAdded", ["Catalog.categoryImages"]),
       ("ProductAdded", ["Catalog.productImages"]),

package/tests/dcb/DcbFixtures.res

@@ -1,4 +1,3 @@
-
 // --- Test Event Log Spec (events with DCB tags) ---
 
 module TestEventLogSpec = {
@@ -339,9 +338,8 @@ type multiProductCommand =
 // Scalar field override — non-Id name remapped via @dcbTag("explicitKey") at the PPX
 // level; the runtime side is exercised here directly with stringForKey.
 @schema
-type customKeyEvent = ProductLabelled({
-  sku: @s.matches(Reventless.DcbTag.stringForKey(~key="productSku")) string,
-})
+type customKeyEvent =
+  ProductLabelled({sku: @s.matches(Reventless.DcbTag.stringForKey(~key="productSku")) string})
 
 // --- Composite partition tag test schemas ---
 
@@ -357,7 +355,8 @@ type compositeEvent =
 @schema
 type compositeEventCustomSep =
   | ConfigUpdated({
-      tenantId: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=0, ~sep=":")) string,
+      tenantId: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=0, ~sep=":"))
+      string,
       region: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=1, ~sep="/")) string,
       service: @s.matches(Reventless.DcbTag.compositePartitionMember(~position=2)) string,
       value: string,