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

package/tests/commandtopic/CommandTopicCallbackTest.res

@@ -5,62 +5,80 @@ let _ = beforeEach(() => reset())
 
 describe("CommandTopic_Callback.handleJsonCommands:", () => {
   describe("valid command JSON", () => {
-    testPromise("decoded command passed to commandsHandler", async () => {
-      let item = makeTopicItem("agg-1", TestSpec.CreateItem({itemId: "item-1"}))
-      let _ = await TestHandler.handleJsonCommands(Stream.fromIterable([item]))->Effect.runPromise
-      expect(capturedItems.contents->Array.length)->toBe(1)
-      let captured = capturedItems.contents->Array.getUnsafe(0)
-      expect(captured.reference)->toBe("agg-1")
-      expect(captured.command)->toEqual(TestSpec.CreateItem({itemId: "item-1"}))
-    })
+    testPromise(
+      "decoded command passed to commandsHandler",
+      async () => {
+        let item = makeTopicItem("agg-1", TestSpec.CreateItem({itemId: "item-1"}))
+        let _ = await TestHandler.handleJsonCommands(Stream.fromIterable([item]))->Effect.runPromise
+        expect(capturedItems.contents->Array.length)->toBe(1)
+        let captured = capturedItems.contents->Array.getUnsafe(0)
+        expect(captured.reference)->toBe("agg-1")
+        expect(captured.command)->toEqual(TestSpec.CreateItem({itemId: "item-1"}))
+      },
+    )
   })
 
   describe("results returned from commandsHandler", () => {
-    testPromise("handler results propagated as return value", async () => {
-      commandHandlerResults := [Ok("agg-1"), Error("agg-2")]
-      let item = makeTopicItem("agg-1", TestSpec.CreateItem({itemId: "item-1"}))
-      let results = await TestHandler.handleJsonCommands(Stream.fromIterable([item]))->Effect.runPromise
-      expect(results)->toEqual([Ok("agg-1"), Error("agg-2")])
-    })
+    testPromise(
+      "handler results propagated as return value",
+      async () => {
+        commandHandlerResults := [Ok("agg-1"), Error("agg-2")]
+        let item = makeTopicItem("agg-1", TestSpec.CreateItem({itemId: "item-1"}))
+        let results = await TestHandler.handleJsonCommands(
+          Stream.fromIterable([item]),
+        )->Effect.runPromise
+        expect(results)->toEqual([Ok("agg-1"), Error("agg-2")])
+      },
+    )
   })
 
   describe("malformed command JSON", () => {
-    testPromise("skipped gracefully — commandsHandler called with empty array", async () => {
-      let invalidItem: CommandTopic.topicItem<JSON.t> = {
-        reference: "ref-1",
-        command: JSON.Encode.string("not-a-command-object"),
-      }
-      let _ = await TestHandler.handleJsonCommands(Stream.fromIterable([invalidItem]))->Effect.runPromise
-      // Decode fails — commandsHandler called with empty list, returns default [Ok("ref-1")]
-      expect(capturedItems.contents->Array.length)->toBe(0)
-    })
+    testPromise(
+      "skipped gracefully — commandsHandler called with empty array",
+      async () => {
+        let invalidItem: CommandTopic.topicItem<JSON.t> = {
+          reference: "ref-1",
+          command: JSON.Encode.string("not-a-command-object"),
+        }
+        let _ = await TestHandler.handleJsonCommands(
+          Stream.fromIterable([invalidItem]),
+        )->Effect.runPromise
+        // Decode fails — commandsHandler called with empty list, returns default [Ok("ref-1")]
+        expect(capturedItems.contents->Array.length)->toBe(0)
+      },
+    )
   })
 
   describe("multiple commands in batch", () => {
-    testPromise("all decodable commands reach commandsHandler", async () => {
-      let items = [
-        makeTopicItem("agg-1", TestSpec.CreateItem({itemId: "item-1"})),
-        makeTopicItem("agg-2", TestSpec.DeleteItem({itemId: "item-2"})),
-        makeTopicItem("agg-3", TestSpec.CreateItem({itemId: "item-3"})),
-      ]
-      let _ = await TestHandler.handleJsonCommands(Stream.fromIterable(items))->Effect.runPromise
-      expect(capturedItems.contents->Array.length)->toBe(3)
-    })
+    testPromise(
+      "all decodable commands reach commandsHandler",
+      async () => {
+        let items = [
+          makeTopicItem("agg-1", TestSpec.CreateItem({itemId: "item-1"})),
+          makeTopicItem("agg-2", TestSpec.DeleteItem({itemId: "item-2"})),
+          makeTopicItem("agg-3", TestSpec.CreateItem({itemId: "item-3"})),
+        ]
+        let _ = await TestHandler.handleJsonCommands(Stream.fromIterable(items))->Effect.runPromise
+        expect(capturedItems.contents->Array.length)->toBe(3)
+      },
+    )
   })
 
   describe("mixed valid and invalid commands", () => {
-    testPromise("only valid commands reach commandsHandler", async () => {
-      let validItem = makeTopicItem("agg-1", TestSpec.CreateItem({itemId: "item-1"}))
-      let invalidItem: CommandTopic.topicItem<JSON.t> = {
-        reference: "ref-bad",
-        command: JSON.Encode.null,
-      }
-      let _ =
-        await TestHandler.handleJsonCommands(
+    testPromise(
+      "only valid commands reach commandsHandler",
+      async () => {
+        let validItem = makeTopicItem("agg-1", TestSpec.CreateItem({itemId: "item-1"}))
+        let invalidItem: CommandTopic.topicItem<JSON.t> = {
+          reference: "ref-bad",
+          command: JSON.Encode.null,
+        }
+        let _ = await TestHandler.handleJsonCommands(
           Stream.fromIterable([validItem, invalidItem]),
         )->Effect.runPromise
-      expect(capturedItems.contents->Array.length)->toBe(1)
-      expect((capturedItems.contents->Array.getUnsafe(0)).reference)->toBe("agg-1")
-    })
+        expect(capturedItems.contents->Array.length)->toBe(1)
+        expect((capturedItems.contents->Array.getUnsafe(0)).reference)->toBe("agg-1")
+      },
+    )
   })
 })

package/tests/commandtopic/CommandTopicHelpersRejectionTest.res

@@ -19,68 +19,83 @@ let cmdJson = (msgId): Reventless.Message.commandJson => {
 }
 
 describe("CommandTopic_Helpers.runInlineAndCollect:", () => {
-  testPromise("Rejected from rejectedResultChannel beats Accepted from acceptedResultChannel", async () => {
-    let handler: CommandTopic_Helpers.jsonCommandsHandler = stream =>
-      stream
-      ->Stream.runCollect
-      ->Effect.map(items => {
-        items->Array.forEach(item => {
-          // Both channels report for the same reference; rejected wins.
-          CommandTopic_Helpers.reportAccepted(
-            ~component="TestService",
-            item.reference,
-            {entityId: "agg-1", eventCount: 0},
-          )
-          CommandTopic_Helpers.reportRejected(
-            ~component="TestService",
-            ~cause=DomainRejection,
-            item.reference,
-            {errorCode: "AlreadyExists", errorDetail: ""},
-          )
-        })
-        items->Array.map(item => Ok(item.reference))
-      })
+  testPromise(
+    "Rejected from rejectedResultChannel beats Accepted from acceptedResultChannel",
+    async () => {
+      let handler: CommandTopic_Helpers.jsonCommandsHandler = stream =>
+        stream
+        ->Stream.runCollect
+        ->Effect.map(
+          items => {
+            items->Array.forEach(
+              item => {
+                // Both channels report for the same reference; rejected wins.
+                CommandTopic_Helpers.reportAccepted(
+                  ~component="TestService",
+                  item.reference,
+                  {entityId: "agg-1", eventCount: 0},
+                )
+                CommandTopic_Helpers.reportRejected(
+                  ~component="TestService",
+                  ~cause=DomainRejection,
+                  item.reference,
+                  {errorCode: "AlreadyExists", errorDetail: ""},
+                )
+              },
+            )
+            items->Array.map(item => Ok(item.reference))
+          },
+        )
 
-    let outcomes = await CommandTopic_Helpers.runInlineAndCollect([cmdJson("msg-1")], handler)
-    expect(outcomes->Array.length)->toBe(1)
-    switch outcomes->Array.getUnsafe(0) {
-    | Rejected({msgId, errorCode, errorDetail}) =>
-      expect(msgId)->toEqual("msg-1")
-      expect(errorCode)->toEqual("AlreadyExists")
-      expect(errorDetail)->toEqual(None)
-    | Accepted(_) | Pending(_) => expect("expected Rejected")->toEqual("got other")
-    }
-  })
+      let outcomes = await CommandTopic_Helpers.runInlineAndCollect([cmdJson("msg-1")], handler)
+      expect(outcomes->Array.length)->toBe(1)
+      switch outcomes->Array.getUnsafe(0) {
+      | Rejected({msgId, errorCode, errorDetail}) =>
+        expect(msgId)->toEqual("msg-1")
+        expect(errorCode)->toEqual("AlreadyExists")
+        expect(errorDetail)->toEqual(None)
+      | Accepted(_) | Pending(_) => expect("expected Rejected")->toEqual("got other")
+      }
+    },
+  )
 
-  testPromise("Rejected from rejectedResultChannel beats Error result (synthesized Conflict)", async () => {
-    let handler: CommandTopic_Helpers.jsonCommandsHandler = stream =>
-      stream
-      ->Stream.runCollect
-      ->Effect.map(items => {
-        items->Array.forEach(item =>
-          CommandTopic_Helpers.reportRejected(
-            ~component="TestService",
-            ~cause=DomainRejection,
-            item.reference,
-            {errorCode: "BusinessRuleViolated", errorDetail: "{\"reason\":\"x\"}"},
-          )
+  testPromise(
+    "Rejected from rejectedResultChannel beats Error result (synthesized Conflict)",
+    async () => {
+      let handler: CommandTopic_Helpers.jsonCommandsHandler = stream =>
+        stream
+        ->Stream.runCollect
+        ->Effect.map(
+          items => {
+            items->Array.forEach(
+              item =>
+                CommandTopic_Helpers.reportRejected(
+                  ~component="TestService",
+                  ~cause=DomainRejection,
+                  item.reference,
+                  {errorCode: "BusinessRuleViolated", errorDetail: "{\"reason\":\"x\"}"},
+                ),
+            )
+            // Handler still returns Error — rejectedChannel takes precedence.
+            items->Array.map(item => Error(item.reference))
+          },
         )
-        // Handler still returns Error — rejectedChannel takes precedence.
-        items->Array.map(item => Error(item.reference))
-      })
 
-    let outcomes = await CommandTopic_Helpers.runInlineAndCollect([cmdJson("msg-1")], handler)
-    switch outcomes->Array.getUnsafe(0) {
-    | Rejected({errorCode, errorDetail}) =>
-      expect(errorCode)->toEqual("BusinessRuleViolated")
-      expect(errorDetail)->toEqual(Some("{\"reason\":\"x\"}"))
-    | Accepted(_) | Pending(_) => expect("expected Rejected")->toEqual("got other")
-    }
-  })
+      let outcomes = await CommandTopic_Helpers.runInlineAndCollect([cmdJson("msg-1")], handler)
+      switch outcomes->Array.getUnsafe(0) {
+      | Rejected({errorCode, errorDetail}) =>
+        expect(errorCode)->toEqual("BusinessRuleViolated")
+        expect(errorDetail)->toEqual(Some("{\"reason\":\"x\"}"))
+      | Accepted(_) | Pending(_) => expect("expected Rejected")->toEqual("got other")
+      }
+    },
+  )
 
   testPromise("Error result without rejectedChannel still synthesizes Conflict", async () => {
     let handler: CommandTopic_Helpers.jsonCommandsHandler = stream =>
-      stream->Stream.runCollect->Effect.map(items => items->Array.map(item => Error(item.reference)))
+      stream
+      ->Stream.runCollect
+      ->Effect.map(items => items->Array.map(item => Error(item.reference)))
 
     let outcomes = await CommandTopic_Helpers.runInlineAndCollect([cmdJson("msg-1")], handler)
     switch outcomes->Array.getUnsafe(0) {

package/tests/counter/CounterCallbackTest.res

@@ -39,45 +39,51 @@ describe("Counter_Callback.groupByCounterId:", () => {
 
 describe("Counter_Callback.counterHandler:", () => {
   describe("count reaches zero", () => {
-    testPromise("CountFinished event dispatched via jsonEventsHandler", async () => {
-      let ref1 = Counter.makeId(("counter-1", "ref-a"))
-      let counts = [makeCountsJson(ref1, 0)]
-      await TestCounterHandler.counterHandler(~references=[(ref1, 1)], ~counts)
-      // jsonEventsHandler should have been called with 1 event batch containing 1 event
-      let batches = capturedEventBatches.contents
-      expect((batches->Array.length, batches->Array.getUnsafe(0)->Array.length))->toEqual((1, 1))
-    })
+    testPromise(
+      "CountFinished event dispatched via jsonEventsHandler",
+      async () => {
+        let ref1 = Counter.makeId(("counter-1", "ref-a"))
+        let counts = [makeCountsJson(ref1, 0)]
+        await TestCounterHandler.counterHandler(~references=[(ref1, 1)], ~counts)
+        // jsonEventsHandler should have been called with 1 event batch containing 1 event
+        let batches = capturedEventBatches.contents
+        expect((batches->Array.length, batches->Array.getUnsafe(0)->Array.length))->toEqual((1, 1))
+      },
+    )
   })
 
   describe("count above zero", () => {
-    testPromise("no CountFinished event, countsDbCount still called", async () => {
-      let ref1 = Counter.makeId(("counter-1", "ref-a"))
-      let counts = [makeCountsJson(ref1, 3)]
-      await TestCounterHandler.counterHandler(~references=[(ref1, 1)], ~counts)
-      // jsonEventsHandler called with empty array (no finished counters)
-      let batches = capturedEventBatches.contents
-      let events = batches->Array.getUnsafe(0)
-      expect(events->Array.length)->toBe(0)
-      // countsDbCount was called once
-      expect(capturedCountCalls.contents->Array.length)->toBe(1)
-    })
+    testPromise(
+      "no CountFinished event, countsDbCount still called",
+      async () => {
+        let ref1 = Counter.makeId(("counter-1", "ref-a"))
+        let counts = [makeCountsJson(ref1, 3)]
+        await TestCounterHandler.counterHandler(~references=[(ref1, 1)], ~counts)
+        // jsonEventsHandler called with empty array (no finished counters)
+        let batches = capturedEventBatches.contents
+        let events = batches->Array.getUnsafe(0)
+        expect(events->Array.length)->toBe(0)
+        // countsDbCount was called once
+        expect(capturedCountCalls.contents->Array.length)->toBe(1)
+      },
+    )
   })
 
   describe("multiple counters in batch", () => {
-    testPromise("each decremented independently", async () => {
-      let refA = Counter.makeId(("counter-a", "ref-1"))
-      let refB = Counter.makeId(("counter-b", "ref-2"))
-      let counts = [makeCountsJson(refA, 2), makeCountsJson(refB, 0)]
-      await TestCounterHandler.counterHandler(
-        ~references=[(refA, 1), (refB, 1)],
-        ~counts,
-      )
-      // countsDbCount called twice (once per counter ID)
-      expect(capturedCountCalls.contents->Array.length)->toBe(2)
-      // One CountFinished event (counter-b reached 0)
-      let batches = capturedEventBatches.contents
-      let events = batches->Array.getUnsafe(0)
-      expect(events->Array.length)->toBe(1)
-    })
+    testPromise(
+      "each decremented independently",
+      async () => {
+        let refA = Counter.makeId(("counter-a", "ref-1"))
+        let refB = Counter.makeId(("counter-b", "ref-2"))
+        let counts = [makeCountsJson(refA, 2), makeCountsJson(refB, 0)]
+        await TestCounterHandler.counterHandler(~references=[(refA, 1), (refB, 1)], ~counts)
+        // countsDbCount called twice (once per counter ID)
+        expect(capturedCountCalls.contents->Array.length)->toBe(2)
+        // One CountFinished event (counter-b reached 0)
+        let batches = capturedEventBatches.contents
+        let events = batches->Array.getUnsafe(0)
+        expect(events->Array.length)->toBe(1)
+      },
+    )
   })
 })

package/tests/counter/CounterFixtures.res

@@ -1,4 +1,3 @@
-
 // ─────────────────────────────────────────────────────────────
 // Shared captures — reset in beforeEach
 // ─────────────────────────────────────────────────────────────
@@ -14,7 +13,9 @@ let capturedEventBatches: ref<array<array<JSON.t>>> = ref([])
 
 let mockCountsDbCount: QueryDb.count<string> = async (id, field, delta) => {
   capturedCountCalls :=
-    capturedCountCalls.contents->Array.concat([(id->Reventless.Id.StringPure.toString, field, delta)])
+    capturedCountCalls.contents->Array.concat([
+      (id->Reventless.Id.StringPure.toString, field, delta),
+    ])
   Ok(0)
 }
 
@@ -26,8 +27,7 @@ let mockJsonEventsHandler: Counter.jsonEventsHandler = stream =>
   stream
   ->Stream.runCollect
   ->Effect.map(chunk => {
-    capturedEventBatches :=
-      capturedEventBatches.contents->Array.concat([chunk])
+    capturedEventBatches := capturedEventBatches.contents->Array.concat([chunk])
   })
 
 // ─────────────────────────────────────────────────────────────

package/tests/dcb/DcbDecodeTest.res

@@ -28,95 +28,126 @@ type consumedFull =
 
 describe("DcbDecode:", () => {
   describe("makeDecoder — payload-less", () => {
-    let {Reventless.DcbDecode.decode: decode, eventTypes} =
-      Reventless.DcbDecode.makeDecoder(consumedPayloadLessSchema)
-
-    testSync("returns correct eventTypes", () => {
-      let sorted = eventTypes->Array.toSorted(String.compare)
-      expect(sorted)->toEqual(["ItemArchived", "ItemCreated"])
-    })
-
-    testSync("decodes ItemCreated as payload-less variant", () => {
-      let result = decode(
-        ~eventType="ItemCreated",
-        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("name", JSON.String("Test"))]),
-      )
-      let expected: option<consumedPayloadLess> = Some(ItemCreated)
-      expect(result)->toEqual(expected)
-    })
-
-    testSync("decodes ItemArchived as payload-less variant", () => {
-      let result = decode(
-        ~eventType="ItemArchived",
-        ~data=Dict.fromArray([("itemId", JSON.String("i-1"))]),
-      )
-      let expected: option<consumedPayloadLess> = Some(ItemArchived)
-      expect(result)->toEqual(expected)
-    })
-
-    testSync("returns None for unknown event type", () => {
-      let result = decode(
-        ~eventType="ItemRenamed",
-        ~data=Dict.fromArray([("itemId", JSON.String("i-1"))]),
-      )
-      expect(result)->toEqual(None)
-    })
+    let {Reventless.DcbDecode.decode: decode, eventTypes} = Reventless.DcbDecode.makeDecoder(
+      consumedPayloadLessSchema,
+    )
+
+    testSync(
+      "returns correct eventTypes",
+      () => {
+        let sorted = eventTypes->Array.toSorted(String.compare)
+        expect(sorted)->toEqual(["ItemArchived", "ItemCreated"])
+      },
+    )
+
+    testSync(
+      "decodes ItemCreated as payload-less variant",
+      () => {
+        let result = decode(
+          ~eventType="ItemCreated",
+          ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("name", JSON.String("Test"))]),
+        )
+        let expected: option<consumedPayloadLess> = Some(ItemCreated)
+        expect(result)->toEqual(expected)
+      },
+    )
+
+    testSync(
+      "decodes ItemArchived as payload-less variant",
+      () => {
+        let result = decode(
+          ~eventType="ItemArchived",
+          ~data=Dict.fromArray([("itemId", JSON.String("i-1"))]),
+        )
+        let expected: option<consumedPayloadLess> = Some(ItemArchived)
+        expect(result)->toEqual(expected)
+      },
+    )
+
+    testSync(
+      "returns None for unknown event type",
+      () => {
+        let result = decode(
+          ~eventType="ItemRenamed",
+          ~data=Dict.fromArray([("itemId", JSON.String("i-1"))]),
+        )
+        expect(result)->toEqual(None)
+      },
+    )
   })
 
   describe("makeDecoder — partial projection", () => {
-    let {Reventless.DcbDecode.decode: decode} =
-      Reventless.DcbDecode.makeDecoder(consumedPartialSchema)
-
-    testSync("decodes ItemCreated with only itemId field", () => {
-      let result = decode(
-        ~eventType="ItemCreated",
-        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("name", JSON.String("Test"))]),
-      )
-      let expected: option<consumedPartial> = Some(ItemCreated({itemId: "i-1"}))
-      expect(result)->toEqual(expected)
-    })
-
-    testSync("decodes ItemRenamed with only itemId field", () => {
-      let result = decode(
-        ~eventType="ItemRenamed",
-        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("newName", JSON.String("New"))]),
-      )
-      let expected: option<consumedPartial> = Some(ItemRenamed({itemId: "i-1"}))
-      expect(result)->toEqual(expected)
-    })
-
-    testSync("returns None for unknown event type", () => {
-      let result = decode(~eventType="ItemArchived", ~data=Dict.fromArray([]))
-      expect(result)->toEqual(None)
-    })
+    let {Reventless.DcbDecode.decode: decode} = Reventless.DcbDecode.makeDecoder(
+      consumedPartialSchema,
+    )
+
+    testSync(
+      "decodes ItemCreated with only itemId field",
+      () => {
+        let result = decode(
+          ~eventType="ItemCreated",
+          ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("name", JSON.String("Test"))]),
+        )
+        let expected: option<consumedPartial> = Some(ItemCreated({itemId: "i-1"}))
+        expect(result)->toEqual(expected)
+      },
+    )
+
+    testSync(
+      "decodes ItemRenamed with only itemId field",
+      () => {
+        let result = decode(
+          ~eventType="ItemRenamed",
+          ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("newName", JSON.String("New"))]),
+        )
+        let expected: option<consumedPartial> = Some(ItemRenamed({itemId: "i-1"}))
+        expect(result)->toEqual(expected)
+      },
+    )
+
+    testSync(
+      "returns None for unknown event type",
+      () => {
+        let result = decode(~eventType="ItemArchived", ~data=Dict.fromArray([]))
+        expect(result)->toEqual(None)
+      },
+    )
   })
 
   describe("makeDecoder — full shape", () => {
-    let {Reventless.DcbDecode.decode: decode} =
-      Reventless.DcbDecode.makeDecoder(consumedFullSchema)
-
-    testSync("decodes ItemCreated with all fields", () => {
-      let result = decode(
-        ~eventType="ItemCreated",
-        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("name", JSON.String("Test"))]),
-      )
-      expect(result)->toEqual(Some(ItemCreated({itemId: "i-1", name: "Test"})))
-    })
-
-    testSync("decodes ItemRenamed with all fields", () => {
-      let result = decode(
-        ~eventType="ItemRenamed",
-        ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("newName", JSON.String("New"))]),
-      )
-      expect(result)->toEqual(Some(ItemRenamed({itemId: "i-1", newName: "New"})))
-    })
-
-    testSync("decodes ItemArchived with all fields", () => {
-      let result = decode(
-        ~eventType="ItemArchived",
-        ~data=Dict.fromArray([("itemId", JSON.String("i-1"))]),
-      )
-      expect(result)->toEqual(Some(ItemArchived({itemId: "i-1"})))
-    })
+    let {Reventless.DcbDecode.decode: decode} = Reventless.DcbDecode.makeDecoder(consumedFullSchema)
+
+    testSync(
+      "decodes ItemCreated with all fields",
+      () => {
+        let result = decode(
+          ~eventType="ItemCreated",
+          ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("name", JSON.String("Test"))]),
+        )
+        expect(result)->toEqual(Some(ItemCreated({itemId: "i-1", name: "Test"})))
+      },
+    )
+
+    testSync(
+      "decodes ItemRenamed with all fields",
+      () => {
+        let result = decode(
+          ~eventType="ItemRenamed",
+          ~data=Dict.fromArray([("itemId", JSON.String("i-1")), ("newName", JSON.String("New"))]),
+        )
+        expect(result)->toEqual(Some(ItemRenamed({itemId: "i-1", newName: "New"})))
+      },
+    )
+
+    testSync(
+      "decodes ItemArchived with all fields",
+      () => {
+        let result = decode(
+          ~eventType="ItemArchived",
+          ~data=Dict.fromArray([("itemId", JSON.String("i-1"))]),
+        )
+        expect(result)->toEqual(Some(ItemArchived({itemId: "i-1"})))
+      },
+    )
   })
 })