@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/dcb/DcbFixtures.res.mjs

@@ -0,0 +1,221 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as DcbEventLog_Builder$ReventlessLocal from "../../../src/components/DcbEventLog_Builder.res.mjs";
+import * as StateChangeSlice_Builder$ReventlessLocal from "../../../src/components/StateChangeSlice_Builder.res.mjs";
+
+let eventSchema = S.schema(s => ({
+  TAG: "ItemAdded",
+  id: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let ItemEventLog = {
+  eventSchema: eventSchema
+};
+
+let name = "AddItem";
+
+let moduleUrl = import.meta.url;
+
+let eventSchema$1 = S.schema(s => ({
+  TAG: "ItemAdded",
+  id: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let consumedEventSchema = S.literal("ItemAdded");
+
+let commandSchema = S.schema(s => ({
+  TAG: "AddItem",
+  id: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let errorSchema = S.literal("ItemAlreadyExists");
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let AddItemSpec = {
+  name: name,
+  Id: undefined,
+  moduleUrl: moduleUrl,
+  eventSchema: eventSchema$1,
+  consumedEventSchema: consumedEventSchema,
+  errorSchema: errorSchema,
+  commandSchema: commandSchema,
+  commandAuthorization: commandAuthorization,
+  readConsistency: "EscalateOnRetry"
+};
+
+let moduleUrl$1 = import.meta.url;
+
+function evolve(_state, _event) {
+  return true;
+}
+
+function decide(state, command) {
+  if (state) {
+    return {
+      TAG: "Error",
+      _0: "ItemAlreadyExists"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "ItemAdded",
+          id: command.id,
+          name: command.name
+        }]
+    };
+  }
+}
+
+let AddItemBehavior = {
+  Spec: undefined,
+  moduleUrl: moduleUrl$1,
+  initialState: false,
+  evolve: evolve,
+  decide: decide
+};
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+let capturedEventCount = {
+  contents: 0
+};
+
+Bus.subscribeToEvents("ItemEventLogEventTopic", async (param, param$1, param$2) => {
+  capturedEventCount.contents = capturedEventCount.contents + 1 | 0;
+});
+
+TestRunner$ReventlessLocal.setup();
+
+let ItemEventLogMaker = DcbEventLog_Builder$ReventlessLocal.Make(Bus);
+
+let eventLog = ItemEventLogMaker.make("ItemEventLog", undefined, {
+  TAG: "Simple",
+  _0: {
+    key: "id"
+  }
+}, undefined);
+
+let AddItemMaker = StateChangeSlice_Builder$ReventlessLocal.Make({
+  name: name,
+  moduleUrl: moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: consumedEventSchema,
+  errorSchema: errorSchema,
+  eventSchema: eventSchema$1,
+  commandSchema: commandSchema,
+  commandAuthorization: commandAuthorization,
+  readConsistency: "EscalateOnRetry"
+})({
+  initialState: false,
+  evolve: evolve,
+  decide: decide,
+  moduleUrl: moduleUrl$1
+});
+
+async function publishJsons(cmdJsons) {
+  await Promise.all(cmdJsons.map(async cmdJson => {
+    let dict = cmdJson.commandJson;
+    let typeName;
+    typeName = typeof dict === "object" && dict !== null && !Array.isArray(dict) ? Stdlib_Option.getOr(Stdlib_Option.flatMap(dict["TAG"], j => {
+        if (typeof j === "string") {
+          return j;
+        }
+      }), "") : "";
+    let fullBody = Object.fromEntries([
+      [
+        "id",
+        cmdJson.id
+      ],
+      [
+        "meta",
+        S.reverseConvertToJsonOrThrow(cmdJson.meta, Message$Reventless.metaSchema)
+      ],
+      [
+        "command",
+        cmdJson.commandJson
+      ]
+    ]);
+    let handlers = CommandTopic$ReventlessCore.getHandlers(typeName);
+    await Promise.all(handlers.map(async entry => {
+      let item_reference = cmdJson.id;
+      let item = {
+        command: fullBody,
+        reference: item_reference
+      };
+      await Effect.runPromise(entry.handler(Stream.fromIterable([item])));
+    }));
+  }));
+}
+
+let publishJsonsOutput = Pulumi.output(publishJsons);
+
+let _addItemSlice = AddItemMaker.make(eventLog, publishJsonsOutput, undefined, undefined, undefined);
+
+async function dispatch(commandJson, id) {
+  return await publishJsons([{
+      id: id,
+      meta: TestFixtures$ReventlessLocal.testMeta,
+      commandJson: commandJson
+    }]);
+}
+
+function tagQuery(id) {
+  return [{
+      tags: [{
+          key: "id",
+          value: id
+        }]
+    }];
+}
+
+function typeQuery(eventType) {
+  return [{
+      eventTypes: [eventType]
+    }];
+}
+
+function addItemJson(id, name) {
+  return S.reverseConvertToJsonOrThrow({
+    TAG: "AddItem",
+    id: id,
+    name: name
+  }, commandSchema);
+}
+
+export {
+  ItemEventLog,
+  AddItemSpec,
+  AddItemBehavior,
+  Bus,
+  capturedEventCount,
+  ItemEventLogMaker,
+  eventLog,
+  AddItemMaker,
+  publishJsons,
+  publishJsonsOutput,
+  _addItemSlice,
+  dispatch,
+  tagQuery,
+  typeQuery,
+  addItemJson,
+}
+/* eventSchema Not a pure module */

package/tests/components/dcb/DcbTest.res

@@ -0,0 +1,55 @@
+// E2E tests for DcbEventLog and StateChangeSlice builders.
+// Verifies the full command → DcbEventLog → event topic pipeline.
+
+open JestGlobals
+open DcbFixtures
+
+describe("DcbEventLog E2E", () => {
+  // Force Output chain resolution so StateChangeSlice handlers are registered
+  // before the first test runs (handlers are wired inside Output.apply).
+  let _ = beforeAllAsync(async () => {
+    let _ = await eventLog->ItemEventLogMaker.operations->TestRunner.resolve
+  })
+
+  let _ = beforeEach(() => {
+    capturedEventCount := 0
+  })
+
+  testPromise("AddItem command publishes 1 event to event topic", async () => {
+    let cmd =
+      AddItemSpec.AddItem({id: "item-1", name: "Widget"})
+      ->ReventlessCore.Message.encode(AddItemSpec.commandSchema)
+    await dispatch(cmd, "item-1")
+    expect(capturedEventCount.contents)->toBe(1)
+  })
+
+  testPromise("duplicate AddItem produces 0 events (ItemAlreadyExists)", async () => {
+    // item-1 was already created in the previous test — same aggregate state persists
+    let cmd =
+      AddItemSpec.AddItem({id: "item-1", name: "Widget"})
+      ->ReventlessCore.Message.encode(AddItemSpec.commandSchema)
+    await dispatch(cmd, "item-1")
+    expect(capturedEventCount.contents)->toBe(0)
+  })
+
+  testPromise("AddItem for new id produces 1 event", async () => {
+    let cmd =
+      AddItemSpec.AddItem({id: "item-2", name: "Gadget"})
+      ->ReventlessCore.Message.encode(AddItemSpec.commandSchema)
+    await dispatch(cmd, "item-2")
+    expect(capturedEventCount.contents)->toBe(1)
+  })
+
+  testPromise("direct read of DcbEventLog returns appended events", async () => {
+    // Tests 1 and 3 appended 2 events total (item-1 and item-2)
+    let ops = await eventLog->ItemEventLogMaker.operations->TestRunner.resolve
+    let result = await ops.read(~query=[])
+    expect(result.events->Array.length > 0)->toBe(true)
+  })
+
+  testPromise("direct read with eventTypes filter returns matching events", async () => {
+    let ops = await eventLog->ItemEventLogMaker.operations->TestRunner.resolve
+    let result = await ops.read(~query=[{eventTypes: ["ItemAdded"]}])
+    expect(result.events->Array.length > 0)->toBe(true)
+  })
+})

package/tests/components/dcb/DcbTest.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as DcbFixtures$ReventlessLocal from "./DcbFixtures.res.mjs";
+
+globalThis.describe("DcbEventLog E2E", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(DcbFixtures$ReventlessLocal.ItemEventLogMaker.operations(DcbFixtures$ReventlessLocal.eventLog));
+  });
+  globalThis.beforeEach(() => {
+    DcbFixtures$ReventlessLocal.capturedEventCount.contents = 0;
+  });
+  globalThis.test("AddItem command publishes 1 event to event topic", async () => {
+    let cmd = Message$ReventlessCore.encode({
+      TAG: "AddItem",
+      id: "item-1",
+      name: "Widget"
+    }, DcbFixtures$ReventlessLocal.AddItemSpec.commandSchema);
+    await DcbFixtures$ReventlessLocal.dispatch(cmd, "item-1");
+    globalThis.expect(DcbFixtures$ReventlessLocal.capturedEventCount.contents).toBe(1);
+  });
+  globalThis.test("duplicate AddItem produces 0 events (ItemAlreadyExists)", async () => {
+    let cmd = Message$ReventlessCore.encode({
+      TAG: "AddItem",
+      id: "item-1",
+      name: "Widget"
+    }, DcbFixtures$ReventlessLocal.AddItemSpec.commandSchema);
+    await DcbFixtures$ReventlessLocal.dispatch(cmd, "item-1");
+    globalThis.expect(DcbFixtures$ReventlessLocal.capturedEventCount.contents).toBe(0);
+  });
+  globalThis.test("AddItem for new id produces 1 event", async () => {
+    let cmd = Message$ReventlessCore.encode({
+      TAG: "AddItem",
+      id: "item-2",
+      name: "Gadget"
+    }, DcbFixtures$ReventlessLocal.AddItemSpec.commandSchema);
+    await DcbFixtures$ReventlessLocal.dispatch(cmd, "item-2");
+    globalThis.expect(DcbFixtures$ReventlessLocal.capturedEventCount.contents).toBe(1);
+  });
+  globalThis.test("direct read of DcbEventLog returns appended events", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(DcbFixtures$ReventlessLocal.ItemEventLogMaker.operations(DcbFixtures$ReventlessLocal.eventLog));
+    let result = await ops.read([], undefined);
+    globalThis.expect(result.events.length !== 0).toBe(true);
+  });
+  globalThis.test("direct read with eventTypes filter returns matching events", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(DcbFixtures$ReventlessLocal.ItemEventLogMaker.operations(DcbFixtures$ReventlessLocal.eventLog));
+    let result = await ops.read([{
+        eventTypes: ["ItemAdded"]
+      }], undefined);
+    globalThis.expect(result.events.length !== 0).toBe(true);
+  });
+});
+
+/*  Not a pure module */

package/tests/components/eventcollector/EventCollectorFixtures.res

@@ -0,0 +1,42 @@
+// Integration test fixtures for EventCollector builder (in-memory).
+
+// ─────────────────────────────────────────────────────────────
+// Bus and Pulumi setup
+// ─────────────────────────────────────────────────────────────
+
+module Bus = LocalBus.Make()
+
+let _ = TestRunner.setup()
+
+// ─────────────────────────────────────────────────────────────
+// Build a minimal EventTopic resource for the EventCollector to subscribe to
+// ─────────────────────────────────────────────────────────────
+
+let topicName = "TestECEventTopic"
+let topicResource: ReventlessInfra.Adapter.resource = ReventlessInfra.Adapter.make(
+  ~name=topicName->Pulumi.Output.make,
+  ~id=topicName->Pulumi.Output.make,
+  ~urn=topicName->Pulumi.Output.make,
+  ~service="memory:InMemory"->Pulumi.Output.make,
+)
+let allEventTopics: ReventlessCore.EventTopic.allOutputs = Dict.fromArray([
+  (topicName, ({resources: [topicResource]}: ReventlessCore.EventTopic.outputs)),
+])
+
+// ─────────────────────────────────────────────────────────────
+// Captured events
+// ─────────────────────────────────────────────────────────────
+
+let capturedEvents: ref<array<JSON.t>> = ref([])
+
+// ─────────────────────────────────────────────────────────────
+// Build EventCollector
+// ─────────────────────────────────────────────────────────────
+
+module EventCollectorMaker = ReventlessCore.EventCollector_Builder.Make(
+  LocalRuntimeEnvironment,
+  LocalEventCollectorChannel.Make(Bus),
+)
+
+let eventCollector = EventCollectorMaker.make(~name="TestEC", ~eventTopics=allEventTopics, ~opts={})
+

package/tests/components/eventcollector/EventCollectorFixtures.res.mjs

@@ -0,0 +1,49 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as Adapter$ReventlessInfra from "@reventlessdev/reventless-infra/src/adapter/Adapter.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as EventCollector_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventCollector/EventCollector_Builder.res.mjs";
+import * as LocalRuntimeEnvironment$ReventlessLocal from "../../../src/adapter/Runtime/LocalRuntimeEnvironment.res.mjs";
+import * as LocalEventCollectorChannel$ReventlessLocal from "../../../src/adapter/EventCollector/LocalEventCollectorChannel.res.mjs";
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let topicName = "TestECEventTopic";
+
+let topicResource = Adapter$ReventlessInfra.make(Pulumi.output(topicName), Pulumi.output(topicName), Pulumi.output(topicName), Pulumi.output("memory:InMemory"), undefined, undefined, undefined, undefined, undefined, undefined);
+
+let allEventTopics = Object.fromEntries([[
+    topicName,
+    {
+      resources: [topicResource]
+    }
+  ]]);
+
+let capturedEvents = {
+  contents: []
+};
+
+let EventCollectorMaker = EventCollector_Builder$ReventlessCore.Make({
+  make: LocalRuntimeEnvironment$ReventlessLocal.make,
+  groupBySource: LocalRuntimeEnvironment$ReventlessLocal.groupBySource,
+  extractCorrelationId: LocalRuntimeEnvironment$ReventlessLocal.extractCorrelationId,
+  asEventHandler: prim => prim,
+  asEffectHandler: prim => prim
+})(LocalEventCollectorChannel$ReventlessLocal.Make(Bus));
+
+let eventCollector = EventCollectorMaker.make("TestEC", allEventTopics, {});
+
+export {
+  Bus,
+  topicName,
+  topicResource,
+  allEventTopics,
+  capturedEvents,
+  EventCollectorMaker,
+  eventCollector,
+}
+/* Bus Not a pure module */

package/tests/components/eventcollector/EventCollectorTest.res

@@ -0,0 +1,37 @@
+// Integration tests for EventCollector_Builder with in-memory channel.
+
+open TestFixtures
+open JestGlobals
+open EventCollectorFixtures
+
+describe("EventCollector (in-memory)", () => {
+  // Two resolves needed (same as ReadModel E2E):
+  //   1. eventCollector.operations chain — triggers EventCollectorChannel wiring
+  //   2. topicResource.name — triggers inner resource.name.apply to register bus subscription
+  let _ = beforeAllAsync(async () => {
+    let _ = await eventCollector->ReventlessCore.Component.operations->TestRunner.resolve
+    let _ = await topicResource.name->TestRunner.resolve
+  })
+
+  let _ = beforeEach(() => {
+    capturedEvents := []
+  })
+
+  testPromise("EventCollector component exists", async () => {
+    let ops = await eventCollector->ReventlessCore.Component.operations->TestRunner.resolve
+    // Verify the operations object has the expected enqueueEvent function
+    expect(ops.enqueueEvent->typeof)->toBe("function")
+  })
+
+  testPromise("bus publishes events to topic subscribers", async () => {
+    // The EventCollector itself doesn't expose a direct handler in our test setup —
+    // verify the bus subscription mechanism works
+    let received: ref<int> = ref(0)
+    Bus.subscribeToEvents(topicName, async (_, _, _) => {
+      received := received.contents + 1
+    })
+    let testEvent = JSON.Encode.object(Dict.fromArray([("type", JSON.Encode.string("TestEvent"))]))
+    await Bus.publishEvent(topicName, "test", testMeta, testEvent)
+    expect(received.contents)->toBe(1)
+  })
+})

package/tests/components/eventcollector/EventCollectorTest.res.mjs

@@ -0,0 +1,36 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as EventCollectorFixtures$ReventlessLocal from "./EventCollectorFixtures.res.mjs";
+
+globalThis.describe("EventCollector (in-memory)", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventCollectorFixtures$ReventlessLocal.eventCollector));
+    await TestRunner$ReventlessLocal.resolve(EventCollectorFixtures$ReventlessLocal.topicResource.name);
+  });
+  globalThis.beforeEach(() => {
+    EventCollectorFixtures$ReventlessLocal.capturedEvents.contents = [];
+  });
+  globalThis.test("EventCollector component exists", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(EventCollectorFixtures$ReventlessLocal.eventCollector));
+    globalThis.expect(typeof ops.enqueueEvent).toBe("function");
+  });
+  globalThis.test("bus publishes events to topic subscribers", async () => {
+    let received = {
+      contents: 0
+    };
+    EventCollectorFixtures$ReventlessLocal.Bus.subscribeToEvents(EventCollectorFixtures$ReventlessLocal.topicName, async (param, param$1, param$2) => {
+      received.contents = received.contents + 1 | 0;
+    });
+    let testEvent = Object.fromEntries([[
+        "type",
+        "TestEvent"
+      ]]);
+    await EventCollectorFixtures$ReventlessLocal.Bus.publishEvent(EventCollectorFixtures$ReventlessLocal.topicName, "test", TestFixtures$ReventlessLocal.testMeta, testEvent);
+    globalThis.expect(received.contents).toBe(1);
+  });
+});
+
+/*  Not a pure module */

package/tests/components/eventlog/EventLogAppendStreamTest.res

@@ -0,0 +1,93 @@
+// Tests for EventLog.appendStream (Phase H of effect-stream-integration plan).
+// Verifies that a Stream<Spec.event> can drive sequential appends, and that
+// the replayStream → appendStream pipeline works without an intermediate mapping step.
+// Each test uses a unique aggregate ID to avoid state sharing with other tests.
+
+open JestGlobals
+open EventLogFixtures
+
+describe("EventLog.appendStream (in-memory adapter)", () => {
+  let _ = beforeAllAsync(async () => {
+    let _ = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+  })
+
+  let _ = beforeEach(() => reset())
+
+  describe("basic append", () => {
+    testPromise("appendStream writes all events to storage", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let stream = [
+        ItemEventLogSpec.ItemCreated({name: "e1"}),
+        ItemEventLogSpec.ItemCreated({name: "e2"}),
+        ItemEventLogSpec.ItemCreated({name: "e3"}),
+      ]->Stream.fromIterable
+      let _ = await ops.appendStream(0, "as-basic-1", stream)->Effect.runPromise
+      let replayed = await ops.replay("as-basic-1")
+      expect(replayed->Array.length)->toBe(3)
+    })
+
+    testPromise("appendStream on empty stream writes nothing", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.appendStream(0, "as-empty-1", Stream.empty)->Effect.runPromise
+      let replayed = await ops.replay("as-empty-1")
+      expect(replayed->Array.length)->toBe(0)
+    })
+
+    testPromise("appendStream preserves event order", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let stream = [
+        ItemEventLogSpec.ItemCreated({name: "first"}),
+        ItemEventLogSpec.ItemDeleted({id: "second"}),
+      ]->Stream.fromIterable
+      let _ = await ops.appendStream(0, "as-order-1", stream)->Effect.runPromise
+      let replayed = await ops.replayStream("as-order-1")->Stream.runCollect->Effect.runPromise
+      let first = replayed->Array.getUnsafe(0)
+      expect(first)->toEqual(ItemEventLogSpec.ItemCreated({name: "first"}))
+    })
+
+    testPromise("appendStream after array append continues from correct sequenceNr", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append(
+        0,
+        "as-seq-1",
+        [makeEvent'("as-seq-1", ItemEventLogSpec.ItemCreated({name: "initial"}))],
+      )
+      let stream = [ItemEventLogSpec.ItemCreated({name: "streamed"})]->Stream.fromIterable
+      let _ = await ops.appendStream(1, "as-seq-1", stream)->Effect.runPromise
+      let replayed = await ops.replay("as-seq-1")
+      expect(replayed->Array.length)->toBe(2)
+    })
+  })
+
+  describe("replayStream → appendStream pipeline", () => {
+    testPromise("can copy events from one aggregate to another via streams", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append(
+        0,
+        "as-src-1",
+        [
+          makeEvent'("as-src-1", ItemEventLogSpec.ItemCreated({name: "a"})),
+          makeEvent'("as-src-1", ItemEventLogSpec.ItemDeleted({id: "b"})),
+        ],
+      )
+      let sourceStream = ops.replayStream("as-src-1")
+      let _ = await ops.appendStream(0, "as-dst-1", sourceStream)->Effect.runPromise
+      let destEvents = await ops.replay("as-dst-1")
+      expect(destEvents->Array.length)->toBe(2)
+    })
+
+    testPromise("copied events round-trip through decode correctly", async () => {
+      let ops = await eventLog->ReventlessCore.Component.operations->TestRunner.resolve
+      let _ = await ops.append(
+        0,
+        "as-src-2",
+        [makeEvent'("as-src-2", ItemEventLogSpec.ItemCreated({name: "copied"}))],
+      )
+      let sourceStream = ops.replayStream("as-src-2")
+      let _ = await ops.appendStream(0, "as-dst-2", sourceStream)->Effect.runPromise
+      let destEvents = await ops.replayStream("as-dst-2")->Stream.runCollect->Effect.runPromise
+      let first = destEvents->Array.getUnsafe(0)
+      expect(first)->toEqual(ItemEventLogSpec.ItemCreated({name: "copied"}))
+    })
+  })
+})