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

package/tests/dcb/DcbTagTest.res

@@ -417,7 +417,11 @@ describe("DcbTag:", () => {
           DcbFixtures.compositeEventSchema,
         )
         expect(fields->Array.length)->toBe(3)->ignore
-        expect(fields->Array.map(f => f.name))->toEqual(["environment", "platformName", "pluginName"])
+        expect(fields->Array.map(f => f.name))->toEqual([
+          "environment",
+          "platformName",
+          "pluginName",
+        ])
       },
     )
 
@@ -601,10 +605,12 @@ describe("DcbTag:", () => {
         | JsExn(err) =>
           threw := true
           expect(
-            JsExn.message(err)->Option.getOr("")->String.includes(
-              "mixes @compositePartitionTag and @partitionTag",
-            ),
-          )->toBe(true)->ignore
+            JsExn.message(err)
+            ->Option.getOr("")
+            ->String.includes("mixes @compositePartitionTag and @partitionTag"),
+          )
+          ->toBe(true)
+          ->ignore
         }
         expect(threw.contents)->toBe(true)
       },
@@ -623,7 +629,9 @@ describe("DcbTag:", () => {
           threw := true
           expect(
             JsExn.message(err)->Option.getOr("")->String.includes("at least 2 annotated fields"),
-          )->toBe(true)->ignore
+          )
+          ->toBe(true)
+          ->ignore
         }
         expect(threw.contents)->toBe(true)
       },
@@ -636,7 +644,9 @@ describe("DcbTag:", () => {
       () =>
         expect(
           Reventless.DcbTag.isCompositePartitionMember(
-            Reventless.DcbTag.compositePartitionMember(~position=0)->Reventless.DcbTag.toUnknownSchema,
+            Reventless.DcbTag.compositePartitionMember(
+              ~position=0,
+            )->Reventless.DcbTag.toUnknownSchema,
           ),
         )->toBe(true),
     )
@@ -655,9 +665,7 @@ describe("DcbTag:", () => {
       "returns false for plain S.string",
       () =>
         expect(
-          Reventless.DcbTag.isCompositePartitionMember(
-            S.string->Reventless.DcbTag.toUnknownSchema,
-          ),
+          Reventless.DcbTag.isCompositePartitionMember(S.string->Reventless.DcbTag.toUnknownSchema),
         )->toBe(false),
     )
   })
@@ -844,7 +852,10 @@ describe("DcbTag:", () => {
             ~crossPartitionTagKeys=["studentId"],
           ),
         )->toEqual([
-          {Reventless.DcbTag.eventTypes: ["StudentSubscribed"], tags: [{key: "courseId", value: "C1"}]},
+          {
+            Reventless.DcbTag.eventTypes: ["StudentSubscribed"],
+            tags: [{key: "courseId", value: "C1"}],
+          },
           {eventTypes: ["StudentSubscribed"], tags: [{key: "studentId", value: "S1"}]},
         ]),
     )

package/tests/dcb/DcbValidationTest.res

@@ -7,28 +7,25 @@ type producedA =
   | ItemRenamed({itemId: @s.matches(Reventless.DcbTag.string) string, newName: string})
 
 @schema
-type producedB =
-  | ItemArchived({itemId: @s.matches(Reventless.DcbTag.string) string})
+type producedB = ItemArchived({itemId: @s.matches(Reventless.DcbTag.string) string})
 
 // A second producer for ItemCreated with matching fields/tags
 @schema
 type producedADuplicate =
-  | ItemCreated({itemId: @s.matches(Reventless.DcbTag.string) string, name: string})
+  ItemCreated({itemId: @s.matches(Reventless.DcbTag.string) string, name: string})
 
 // A second producer for ItemCreated with DIFFERENT fields (missing name)
 @schema
-type producedAMismatchFields =
-  | ItemCreated({itemId: @s.matches(Reventless.DcbTag.string) string})
+type producedAMismatchFields = ItemCreated({itemId: @s.matches(Reventless.DcbTag.string) string})
 
 // A second producer for ItemCreated with mismatched tag annotations
 @schema
-type producedAMismatchTags =
-  | ItemCreated({itemId: string, name: string})
+type producedAMismatchTags = ItemCreated({itemId: string, name: string})
 
 // A second producer for ItemCreated with mismatched field type
 @schema
 type producedAMismatchType =
-  | ItemCreated({itemId: @s.matches(Reventless.DcbTag.string) string, name: float})
+  ItemCreated({itemId: @s.matches(Reventless.DcbTag.string) string, name: float})
 
 // Consumed events — full shape
 @schema
@@ -38,8 +35,7 @@ type consumedFull =
 
 // Consumed events — partial projection (only itemId)
 @schema
-type consumedPartial =
-  | ItemCreated({itemId: string})
+type consumedPartial = ItemCreated({itemId: string})
 
 // Consumed events — payload-less
 @schema
@@ -49,18 +45,15 @@ type consumedPayloadLess =
 
 // Consumed events — references nonexistent producer
 @schema
-type consumedDangling =
-  | ItemDeleted({itemId: string})
+type consumedDangling = ItemDeleted({itemId: string})
 
 // Consumed events — field not in produced shape
 @schema
-type consumedBadField =
-  | ItemCreated({itemId: string, rating: float})
+type consumedBadField = ItemCreated({itemId: string, rating: float})
 
 // Consumed events — type mismatch
 @schema
-type consumedBadType =
-  | ItemCreated({itemId: string, name: float})
+type consumedBadType = ItemCreated({itemId: string, name: float})
 
 // --- Composite-read (Issue 5) fixtures ---
 
@@ -74,8 +67,7 @@ type recordDemandCommand =
 
 // Single-tag command → partition read, never composite.
 @schema
-type touchDemandCommand =
-  | TouchDemand({productId: @s.matches(Reventless.DcbTag.string) string})
+type touchDemandCommand = TouchDemand({productId: @s.matches(Reventless.DcbTag.string) string})
 
 // Tagged-array command → per-element OR (single-tag) clauses, never composite.
 @schema
@@ -137,213 +129,291 @@ type flaggedPartitionScoped =
 
 describe("DcbValidation:", () => {
   describe("validateProducedAndConsumed", () => {
-    testSync("passes when all consumed events match produced events", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u), ("ArchiveItem", producedBSchema->u)],
-        ~consumed=[("ItemView", consumedFullSchema->u)],
-      )
-      expect(result)->toEqual(Ok())
-    })
-
-    testSync("passes with partial field projection", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u)],
-        ~consumed=[("CheckExists", consumedPartialSchema->u)],
-      )
-      expect(result)->toEqual(Ok())
-    })
-
-    testSync("passes with payload-less consumed events", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u), ("ArchiveItem", producedBSchema->u)],
-        ~consumed=[("CheckExists", consumedPayloadLessSchema->u)],
-      )
-      expect(result)->toEqual(Ok())
-    })
-
-    testSync("passes when multiple producers have identical shapes and tags", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u), ("CloneItem", producedADuplicateSchema->u)],
-        ~consumed=[],
-      )
-      expect(result)->toEqual(Ok())
-    })
-
-    testSync("fails when consumed event has no producer", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u)],
-        ~consumed=[("DeleteHandler", consumedDanglingSchema->u)],
-      )
-      switch result {
-      | Error(errors) =>
-        expect(errors->Array.length)->toBe(1)->ignore
-        let err = errors->Array.getUnsafe(0)
-        expect(err.sliceName)->toBe("DeleteHandler")->ignore
-        expect(err.message->String.includes("ItemDeleted"))->toBe(true)->ignore
-        expect(err.message->String.includes("no slice produces it"))->toBe(true)
-      | Ok() => fail("Expected validation error")
-      }
-    })
-
-    testSync("fails when consumed event references field not in produced shape", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u)],
-        ~consumed=[("RatingView", consumedBadFieldSchema->u)],
-      )
-      switch result {
-      | Error(errors) =>
-        expect(errors->Array.length)->toBe(1)->ignore
-        let err = errors->Array.getUnsafe(0)
-        expect(err.sliceName)->toBe("RatingView")->ignore
-        expect(err.message->String.includes("rating"))->toBe(true)->ignore
-        expect(err.message->String.includes("no field"))->toBe(true)
-      | Ok() => fail("Expected validation error")
-      }
-    })
-
-    testSync("fails when consumed field type mismatches produced field type", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u)],
-        ~consumed=[("BadTypeView", consumedBadTypeSchema->u)],
-      )
-      switch result {
-      | Error(errors) =>
-        expect(errors->Array.length)->toBe(1)->ignore
-        let err = errors->Array.getUnsafe(0)
-        expect(err.sliceName)->toBe("BadTypeView")->ignore
-        expect(err.message->String.includes("name"))->toBe(true)->ignore
-        expect(err.message->String.includes("float"))->toBe(true)->ignore
-        expect(err.message->String.includes("string"))->toBe(true)
-      | Ok() => fail("Expected validation error")
-      }
-    })
-
-    testSync("fails when producers have different fields for same TAG", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u), ("ImportItem", producedAMismatchFieldsSchema->u)],
-        ~consumed=[],
-      )
-      switch result {
-      | Error(errors) =>
-        expect(errors->Array.length)->toBeGreaterThanOrEqual(1)->ignore
-        let err = errors->Array.getUnsafe(0)
-        expect(err.message->String.includes("AddItem"))->toBe(true)->ignore
-        expect(err.message->String.includes("ImportItem"))->toBe(true)->ignore
-        expect(err.message->String.includes("name"))->toBe(true)
-      | Ok() => fail("Expected validation error")
-      }
-    })
-
-    testSync("fails when producers have different tag annotations for same TAG", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u), ("UntaggerItem", producedAMismatchTagsSchema->u)],
-        ~consumed=[],
-      )
-      switch result {
-      | Error(errors) =>
-        expect(errors->Array.length)->toBeGreaterThanOrEqual(1)->ignore
-        let hasTagError = errors->Array.some(err => err.message->String.includes("tag annotations"))
-        expect(hasTagError)->toBe(true)
-      | Ok() => fail("Expected validation error")
-      }
-    })
-
-    testSync("fails when producers have different field types for same TAG", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u), ("BadTypeItem", producedAMismatchTypeSchema->u)],
-        ~consumed=[],
-      )
-      switch result {
-      | Error(errors) =>
-        expect(errors->Array.length)->toBeGreaterThanOrEqual(1)->ignore
-        let err = errors->Array.getUnsafe(0)
-        expect(err.message->String.includes("name"))->toBe(true)->ignore
-        expect(err.message->String.includes("string"))->toBe(true)->ignore
-        expect(err.message->String.includes("float"))->toBe(true)
-      | Ok() => fail("Expected validation error")
-      }
-    })
-
-    testSync("passes with empty produced and consumed", () => {
-      let result = validate(~produced=[], ~consumed=[])
-      expect(result)->toEqual(Ok())
-    })
-
-    testSync("collects multiple errors at once", () => {
-      let result = validate(
-        ~produced=[("AddItem", producedASchema->u)],
-        ~consumed=[("DeleteHandler", consumedDanglingSchema->u), ("BadTypeView", consumedBadTypeSchema->u)],
-      )
-      switch result {
-      | Error(errors) => expect(errors->Array.length)->toBeGreaterThanOrEqual(2)
-      | Ok() => fail("Expected validation errors")
-      }
-    })
+    testSync(
+      "passes when all consumed events match produced events",
+      () => {
+        let result = validate(
+          ~produced=[("AddItem", producedASchema->u), ("ArchiveItem", producedBSchema->u)],
+          ~consumed=[("ItemView", consumedFullSchema->u)],
+        )
+        expect(result)->toEqual(Ok())
+      },
+    )
+
+    testSync(
+      "passes with partial field projection",
+      () => {
+        let result = validate(
+          ~produced=[("AddItem", producedASchema->u)],
+          ~consumed=[("CheckExists", consumedPartialSchema->u)],
+        )
+        expect(result)->toEqual(Ok())
+      },
+    )
+
+    testSync(
+      "passes with payload-less consumed events",
+      () => {
+        let result = validate(
+          ~produced=[("AddItem", producedASchema->u), ("ArchiveItem", producedBSchema->u)],
+          ~consumed=[("CheckExists", consumedPayloadLessSchema->u)],
+        )
+        expect(result)->toEqual(Ok())
+      },
+    )
+
+    testSync(
+      "passes when multiple producers have identical shapes and tags",
+      () => {
+        let result = validate(
+          ~produced=[("AddItem", producedASchema->u), ("CloneItem", producedADuplicateSchema->u)],
+          ~consumed=[],
+        )
+        expect(result)->toEqual(Ok())
+      },
+    )
+
+    testSync(
+      "fails when consumed event has no producer",
+      () => {
+        let result = validate(
+          ~produced=[("AddItem", producedASchema->u)],
+          ~consumed=[("DeleteHandler", consumedDanglingSchema->u)],
+        )
+        switch result {
+        | Error(errors) =>
+          expect(errors->Array.length)->toBe(1)->ignore
+          let err = errors->Array.getUnsafe(0)
+          expect(err.sliceName)->toBe("DeleteHandler")->ignore
+          expect(err.message->String.includes("ItemDeleted"))->toBe(true)->ignore
+          expect(err.message->String.includes("no slice produces it"))->toBe(true)
+        | Ok() => fail("Expected validation error")
+        }
+      },
+    )
+
+    testSync(
+      "fails when consumed event references field not in produced shape",
+      () => {
+        let result = validate(
+          ~produced=[("AddItem", producedASchema->u)],
+          ~consumed=[("RatingView", consumedBadFieldSchema->u)],
+        )
+        switch result {
+        | Error(errors) =>
+          expect(errors->Array.length)->toBe(1)->ignore
+          let err = errors->Array.getUnsafe(0)
+          expect(err.sliceName)->toBe("RatingView")->ignore
+          expect(err.message->String.includes("rating"))->toBe(true)->ignore
+          expect(err.message->String.includes("no field"))->toBe(true)
+        | Ok() => fail("Expected validation error")
+        }
+      },
+    )
+
+    testSync(
+      "fails when consumed field type mismatches produced field type",
+      () => {
+        let result = validate(
+          ~produced=[("AddItem", producedASchema->u)],
+          ~consumed=[("BadTypeView", consumedBadTypeSchema->u)],
+        )
+        switch result {
+        | Error(errors) =>
+          expect(errors->Array.length)->toBe(1)->ignore
+          let err = errors->Array.getUnsafe(0)
+          expect(err.sliceName)->toBe("BadTypeView")->ignore
+          expect(err.message->String.includes("name"))->toBe(true)->ignore
+          expect(err.message->String.includes("float"))->toBe(true)->ignore
+          expect(err.message->String.includes("string"))->toBe(true)
+        | Ok() => fail("Expected validation error")
+        }
+      },
+    )
+
+    testSync(
+      "fails when producers have different fields for same TAG",
+      () => {
+        let result = validate(
+          ~produced=[
+            ("AddItem", producedASchema->u),
+            ("ImportItem", producedAMismatchFieldsSchema->u),
+          ],
+          ~consumed=[],
+        )
+        switch result {
+        | Error(errors) =>
+          expect(errors->Array.length)->toBeGreaterThanOrEqual(1)->ignore
+          let err = errors->Array.getUnsafe(0)
+          expect(err.message->String.includes("AddItem"))->toBe(true)->ignore
+          expect(err.message->String.includes("ImportItem"))->toBe(true)->ignore
+          expect(err.message->String.includes("name"))->toBe(true)
+        | Ok() => fail("Expected validation error")
+        }
+      },
+    )
+
+    testSync(
+      "fails when producers have different tag annotations for same TAG",
+      () => {
+        let result = validate(
+          ~produced=[
+            ("AddItem", producedASchema->u),
+            ("UntaggerItem", producedAMismatchTagsSchema->u),
+          ],
+          ~consumed=[],
+        )
+        switch result {
+        | Error(errors) =>
+          expect(errors->Array.length)->toBeGreaterThanOrEqual(1)->ignore
+          let hasTagError =
+            errors->Array.some(err => err.message->String.includes("tag annotations"))
+          expect(hasTagError)->toBe(true)
+        | Ok() => fail("Expected validation error")
+        }
+      },
+    )
+
+    testSync(
+      "fails when producers have different field types for same TAG",
+      () => {
+        let result = validate(
+          ~produced=[
+            ("AddItem", producedASchema->u),
+            ("BadTypeItem", producedAMismatchTypeSchema->u),
+          ],
+          ~consumed=[],
+        )
+        switch result {
+        | Error(errors) =>
+          expect(errors->Array.length)->toBeGreaterThanOrEqual(1)->ignore
+          let err = errors->Array.getUnsafe(0)
+          expect(err.message->String.includes("name"))->toBe(true)->ignore
+          expect(err.message->String.includes("string"))->toBe(true)->ignore
+          expect(err.message->String.includes("float"))->toBe(true)
+        | Ok() => fail("Expected validation error")
+        }
+      },
+    )
+
+    testSync(
+      "passes with empty produced and consumed",
+      () => {
+        let result = validate(~produced=[], ~consumed=[])
+        expect(result)->toEqual(Ok())
+      },
+    )
+
+    testSync(
+      "collects multiple errors at once",
+      () => {
+        let result = validate(
+          ~produced=[("AddItem", producedASchema->u)],
+          ~consumed=[
+            ("DeleteHandler", consumedDanglingSchema->u),
+            ("BadTypeView", consumedBadTypeSchema->u),
+          ],
+        )
+        switch result {
+        | Error(errors) => expect(errors->Array.length)->toBeGreaterThanOrEqual(2)
+        | Ok() => fail("Expected validation errors")
+        }
+      },
+    )
   })
 
   describe("validateCompositeReads (Issue 5)", () => {
-    let check = slices =>
-      Reventless.DcbValidation.validateCompositeReads(~slices, ~producedTagKeys)
-
-    testSync("warns when a composite read's consumed type carries an extra tag", () => {
-      let warnings = check([("RecordDemand", recordDemandCommandSchema->u, demandConsumedSchema->u)])
-      // ProductDemandRevoked carries customerId beyond [productId, orderId] → missed.
-      expect(warnings->Array.length)->toBe(1)
-      let w = warnings->Array.getUnsafe(0)
-      expect(w.sliceName)->toBe("RecordDemand")
-      expect(w.message->String.includes("ProductDemandRevoked"))->toBe(true)
-      expect(w.message->String.includes("customerId"))->toBe(true)
-    })
-
-    testSync("does not warn for an exact-match consumed type", () => {
-      // ProductDemandRecorded carries exactly [productId, orderId] — read finds it.
-      let warnings = check([("RecordDemand", recordDemandCommandSchema->u, demandConsumedSchema->u)])
-      expect(warnings->Array.some(w => w.message->String.includes("ProductDemandRecorded")))->toBe(
-        false,
-      )
-    })
-
-    testSync("ignores single-tag commands (partition read, not composite)", () => {
-      let warnings = check([("TouchDemand", touchDemandCommandSchema->u, demandConsumedSchema->u)])
-      expect(warnings)->toEqual([])
-    })
-
-    testSync("ignores tagged-array commands (per-element OR, not composite)", () => {
-      let warnings = check([("PlaceOrder", placeOrderCommandSchema->u, demandConsumedSchema->u)])
-      expect(warnings)->toEqual([])
-    })
-
-    testSync("no warnings when nothing reads compositely", () => {
-      expect(check([]))->toEqual([])
-    })
+    let check = slices => Reventless.DcbValidation.validateCompositeReads(~slices, ~producedTagKeys)
+
+    testSync(
+      "warns when a composite read's consumed type carries an extra tag",
+      () => {
+        let warnings = check([
+          ("RecordDemand", recordDemandCommandSchema->u, demandConsumedSchema->u),
+        ])
+        // ProductDemandRevoked carries customerId beyond [productId, orderId] → missed.
+        expect(warnings->Array.length)->toBe(1)
+        let w = warnings->Array.getUnsafe(0)
+        expect(w.sliceName)->toBe("RecordDemand")
+        expect(w.message->String.includes("ProductDemandRevoked"))->toBe(true)
+        expect(w.message->String.includes("customerId"))->toBe(true)
+      },
+    )
+
+    testSync(
+      "does not warn for an exact-match consumed type",
+      () => {
+        // ProductDemandRecorded carries exactly [productId, orderId] — read finds it.
+        let warnings = check([
+          ("RecordDemand", recordDemandCommandSchema->u, demandConsumedSchema->u),
+        ])
+        expect(
+          warnings->Array.some(w => w.message->String.includes("ProductDemandRecorded")),
+        )->toBe(false)
+      },
+    )
+
+    testSync(
+      "ignores single-tag commands (partition read, not composite)",
+      () => {
+        let warnings = check([
+          ("TouchDemand", touchDemandCommandSchema->u, demandConsumedSchema->u),
+        ])
+        expect(warnings)->toEqual([])
+      },
+    )
+
+    testSync(
+      "ignores tagged-array commands (per-element OR, not composite)",
+      () => {
+        let warnings = check([("PlaceOrder", placeOrderCommandSchema->u, demandConsumedSchema->u)])
+        expect(warnings)->toEqual([])
+      },
+    )
+
+    testSync(
+      "no warnings when nothing reads compositely",
+      () => {
+        expect(check([]))->toEqual([])
+      },
+    )
   })
 
   describe("validateCrossPartitionScope (Issue 13)", () => {
     let check = producers => Reventless.DcbValidation.validateCrossPartitionScope(~producers)
 
-    testSync("no warning when every carrier of a key agrees on cross-partition scope", () => {
-      let warnings = check([
-        ("Subscribe", subscribedCrossPartitionSchema->u),
-        ("Unsubscribe", unsubscribedCrossPartitionSchema->u),
-      ])
-      expect(warnings)->toEqual([])
-    })
-
-    testSync("warns when one producer leaves a cross-partition key partition-scoped", () => {
-      let warnings = check([
-        ("Subscribe", subscribedCrossPartitionSchema->u),
-        ("Flag", flaggedPartitionScopedSchema->u),
-      ])
-      // 'Flag' carries studentId but partition-scoped, while 'Subscribe' declares it
-      // @crossPartition → scope mismatch.
-      expect(warnings->Array.length)->toBe(1)
-      let w = warnings->Array.getUnsafe(0)
-      expect(w.sliceName)->toBe("Flag")
-      expect(w.message->String.includes("studentId"))->toBe(true)
-    })
-
-    testSync("no warning when no key is cross-partition anywhere", () => {
-      expect(check([("Flag", flaggedPartitionScopedSchema->u)]))->toEqual([])
-    })
+    testSync(
+      "no warning when every carrier of a key agrees on cross-partition scope",
+      () => {
+        let warnings = check([
+          ("Subscribe", subscribedCrossPartitionSchema->u),
+          ("Unsubscribe", unsubscribedCrossPartitionSchema->u),
+        ])
+        expect(warnings)->toEqual([])
+      },
+    )
+
+    testSync(
+      "warns when one producer leaves a cross-partition key partition-scoped",
+      () => {
+        let warnings = check([
+          ("Subscribe", subscribedCrossPartitionSchema->u),
+          ("Flag", flaggedPartitionScopedSchema->u),
+        ])
+        // 'Flag' carries studentId but partition-scoped, while 'Subscribe' declares it
+        // @crossPartition → scope mismatch.
+        expect(warnings->Array.length)->toBe(1)
+        let w = warnings->Array.getUnsafe(0)
+        expect(w.sliceName)->toBe("Flag")
+        expect(w.message->String.includes("studentId"))->toBe(true)
+      },
+    )
+
+    testSync(
+      "no warning when no key is cross-partition anywhere",
+      () => {
+        expect(check([("Flag", flaggedPartitionScopedSchema->u)]))->toEqual([])
+      },
+    )
   })
 })