@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/commandtopic/CommandTopicTest.res.mjs

@@ -0,0 +1,62 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+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 CommandTopicFixtures$ReventlessLocal from "./CommandTopicFixtures.res.mjs";
+
+globalThis.describe("CommandTopic (in-memory)", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(CommandTopicFixtures$ReventlessLocal.cmdTopic));
+  });
+  globalThis.test("publishJsons succeeds without throwing", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(CommandTopicFixtures$ReventlessLocal.cmdTopic));
+    let commandJson = Message$ReventlessCore.encode({
+      TAG: "CreateItem",
+      name: "Widget"
+    }, CommandTopicFixtures$ReventlessLocal.ItemSpec.commandSchema);
+    let didThrow = false;
+    try {
+      await ops.publishJsons([{
+          id: "item-1",
+          meta: TestFixtures$ReventlessLocal.testMeta,
+          commandJson: commandJson
+        }]);
+    } catch (exn) {
+      didThrow = true;
+    }
+    globalThis.expect(didThrow).toBe(false);
+  });
+  globalThis.test("publishJsons with empty array succeeds", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(CommandTopicFixtures$ReventlessLocal.cmdTopic));
+    let didThrow = false;
+    try {
+      await ops.publishJsons([]);
+    } catch (exn) {
+      didThrow = true;
+    }
+    globalThis.expect(didThrow).toBe(false);
+  });
+  globalThis.test("publishJsons dispatches to bus channel (TestCommandTopicCmdTopic)", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(Component$ReventlessCore.operations(CommandTopicFixtures$ReventlessLocal.cmdTopic));
+    let received = {
+      contents: false
+    };
+    CommandTopicFixtures$ReventlessLocal.Bus.registerCommandHandler("TestCommandTopicCmdTopic", async (_json, _ctx) => {
+      received.contents = true;
+    });
+    let commandJson = Message$ReventlessCore.encode({
+      TAG: "DeleteItem",
+      id: "item-99"
+    }, CommandTopicFixtures$ReventlessLocal.ItemSpec.commandSchema);
+    await ops.publishJsons([{
+        id: "item-99",
+        meta: TestFixtures$ReventlessLocal.testMeta,
+        commandJson: commandJson
+      }]);
+    globalThis.expect(received.contents).toBe(true);
+  });
+});
+
+/*  Not a pure module */

package/tests/components/counter/CounterFixtures.res

@@ -0,0 +1,42 @@
+// E2E test fixtures for Counter builder.
+// Verifies addToCounterTarget (in-memory deduplication) and count (ReferencesDb save).
+
+// ─────────────────────────────────────────────────────────────
+// Isolated bus for this test suite
+// ─────────────────────────────────────────────────────────────
+
+module Bus = LocalBus.Make()
+
+// ─────────────────────────────────────────────────────────────
+// Activate Pulumi mock mode (must be before any Component.make)
+// ─────────────────────────────────────────────────────────────
+
+let _ = TestRunner.setup()
+
+// ─────────────────────────────────────────────────────────────
+// Build Counter
+// jsonEventsHandler fires when a count reaches zero;
+// capture events for assertion.
+// ─────────────────────────────────────────────────────────────
+
+module CounterMaker = Counter_Builder.Make(Bus)
+
+let counterEvents: ref<array<JSON.t>> = ref([])
+
+let counter = CounterMaker.make(
+  ~name="TestCounter",
+  ~jsonEventsHandler=stream =>
+    stream
+    ->Stream.runCollect
+    ->Effect.map(chunk => {
+      counterEvents := counterEvents.contents->Array.concat(chunk)
+    }),
+)
+
+// ─────────────────────────────────────────────────────────────
+// Resolve counter operations.
+// ─────────────────────────────────────────────────────────────
+
+let resolveOps = async () => {
+  await CounterMaker.operations(counter)->TestRunner.resolve
+}

package/tests/components/counter/CounterFixtures.res.mjs

@@ -0,0 +1,34 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Effect from "effect/Effect";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as Counter_Builder$ReventlessLocal from "../../../src/components/Counter_Builder.res.mjs";
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+TestRunner$ReventlessLocal.setup();
+
+let CounterMaker = Counter_Builder$ReventlessLocal.Make(Bus);
+
+let counterEvents = {
+  contents: []
+};
+
+let counter = CounterMaker.make("TestCounter", stream => Effect.map(Stream.runCollect(stream), chunk => {
+  counterEvents.contents = counterEvents.contents.concat(chunk);
+}), undefined, undefined, undefined, undefined, undefined);
+
+async function resolveOps() {
+  return await TestRunner$ReventlessLocal.resolve(CounterMaker.operations(counter));
+}
+
+export {
+  Bus,
+  CounterMaker,
+  counterEvents,
+  counter,
+  resolveOps,
+}
+/* Bus Not a pure module */

package/tests/components/counter/CounterTest.res

@@ -0,0 +1,46 @@
+// E2E tests for Counter_Builder.
+// Verifies addToCounterTarget deduplication and count persistence.
+
+open JestGlobals
+open CounterFixtures
+
+describe("Counter E2E", () => {
+  // Resolve operations once before all tests.
+  let _ = beforeAllAsync(async () => {
+    let _ = await resolveOps()
+  })
+
+  // Reset in-memory counter state between tests.
+  let _ = beforeEach(() => {
+    LocalCounterHandler.reset()
+  })
+
+  testPromise("addToCounterTarget increments count", async () => {
+    let ops = await resolveOps()
+    await ops.addToCounterTarget({counterId: "item-1", target: 1, targetRef: "ref-1"})
+    expect(LocalCounterHandler.getCount("item-1"))->toBe(1)
+  })
+
+  testPromise("addToCounterTarget with same targetRef is deduplicated", async () => {
+    let ops = await resolveOps()
+    await ops.addToCounterTarget({counterId: "item-1", target: 1, targetRef: "ref-1"})
+    await ops.addToCounterTarget({counterId: "item-1", target: 1, targetRef: "ref-1"})
+    expect(LocalCounterHandler.getCount("item-1"))->toBe(1)
+  })
+
+  testPromise("addToCounterTarget with different targetRefs accumulates", async () => {
+    let ops = await resolveOps()
+    await ops.addToCounterTarget({counterId: "item-1", target: 1, targetRef: "ref-1"})
+    await ops.addToCounterTarget({counterId: "item-1", target: 1, targetRef: "ref-2"})
+    expect(LocalCounterHandler.getCount("item-1"))->toBe(2)
+  })
+
+  testPromise("count saves references to ReferencesDb", async () => {
+    let ops = await resolveOps()
+    let _ = await ops.count([{counterId: "counter-1", reference: "ref-1", inc: 1}])
+    // Counter component name = "TestCounter" ++ "Counter" = "TestCounterCounter"
+    // ReferencesDb name = CounterComponentName ++ "References"
+    let db = Bus.getQueryDb("TestCounterCounterReferences")
+    expect(db->Option.isSome)->toBe(true)
+  })
+})

package/tests/components/counter/CounterTest.res.mjs

@@ -0,0 +1,61 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as CounterFixtures$ReventlessLocal from "./CounterFixtures.res.mjs";
+import * as LocalCounterHandler$ReventlessLocal from "../../../src/adapter/Counter/LocalCounterHandler.res.mjs";
+
+globalThis.describe("Counter E2E", () => {
+  globalThis.beforeAll(async () => {
+    await CounterFixtures$ReventlessLocal.resolveOps();
+  });
+  globalThis.beforeEach(() => LocalCounterHandler$ReventlessLocal.reset());
+  globalThis.test("addToCounterTarget increments count", async () => {
+    let ops = await CounterFixtures$ReventlessLocal.resolveOps();
+    await ops.addToCounterTarget({
+      counterId: "item-1",
+      target: 1,
+      targetRef: "ref-1"
+    });
+    globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("item-1")).toBe(1);
+  });
+  globalThis.test("addToCounterTarget with same targetRef is deduplicated", async () => {
+    let ops = await CounterFixtures$ReventlessLocal.resolveOps();
+    await ops.addToCounterTarget({
+      counterId: "item-1",
+      target: 1,
+      targetRef: "ref-1"
+    });
+    await ops.addToCounterTarget({
+      counterId: "item-1",
+      target: 1,
+      targetRef: "ref-1"
+    });
+    globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("item-1")).toBe(1);
+  });
+  globalThis.test("addToCounterTarget with different targetRefs accumulates", async () => {
+    let ops = await CounterFixtures$ReventlessLocal.resolveOps();
+    await ops.addToCounterTarget({
+      counterId: "item-1",
+      target: 1,
+      targetRef: "ref-1"
+    });
+    await ops.addToCounterTarget({
+      counterId: "item-1",
+      target: 1,
+      targetRef: "ref-2"
+    });
+    globalThis.expect(LocalCounterHandler$ReventlessLocal.getCount("item-1")).toBe(2);
+  });
+  globalThis.test("count saves references to ReferencesDb", async () => {
+    let ops = await CounterFixtures$ReventlessLocal.resolveOps();
+    await ops.count([{
+        counterId: "counter-1",
+        reference: "ref-1",
+        inc: 1
+      }]);
+    let db = CounterFixtures$ReventlessLocal.Bus.getQueryDb("TestCounterCounterReferences");
+    globalThis.expect(Stdlib_Option.isSome(db)).toBe(true);
+  });
+});
+
+/*  Not a pure module */

package/tests/components/dcb/DcbCrossPartitionFixtures.res

@@ -0,0 +1,170 @@
+// E2E fixtures for the inferred cross-partition read (sibling-exclusion) — the
+// AddProduct scenario through real in-memory DcbEventLog storage.
+//
+// The slice is built with the values the inference derives and Dcb_Builder threads:
+//   crossPartitionTagKeys = ["categoryId"]   (a foreign reference, read in its own clause)
+//   tagKeysByEventType     = {ProductAdded: ["productId"], CategoryAdded: ["categoryId"]}
+// so the `categoryId` clause narrows `ProductAdded` out and reads only the category's
+// lifecycle — sibling products tagged the same `categoryId` are never returned.
+
+open TestFixtures
+
+// ─── DcbEventLog event types (used to encode preseeded events) ───
+module CatalogLog = {
+  @schema
+  type event =
+    | ProductAdded({
+        productId: @s.matches(Reventless.DcbTag.partition) string,
+        categoryId: @s.matches(Reventless.DcbTag.string) string,
+        name: string,
+      })
+    | CategoryAdded({categoryId: @s.matches(Reventless.DcbTag.string) string, name: string})
+}
+
+// ─── AddProduct StateChangeSlice ───
+module AddProductSpec = {
+  let name = "AddProduct"
+  module Id = Reventless.Id.String
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  @schema
+  type event =
+    | ProductAdded({
+        productId: @s.matches(Reventless.DcbTag.partition) string,
+        categoryId: @s.matches(Reventless.DcbTag.string) string,
+        name: string,
+      })
+
+  @schema
+  type consumedEvent =
+    | ProductAdded({productId: string})
+    | CategoryAdded({categoryId: string})
+
+  @schema
+  type command =
+    | AddProduct({
+        productId: @s.matches(Reventless.DcbTag.partition) string,
+        categoryId: @s.matches(Reventless.DcbTag.string) string,
+        name: string,
+      })
+
+  @schema
+  type error =
+    | ProductAlreadyExists
+    | CategoryNotFound
+
+  let commandSchema = commandSchema
+}
+
+module AddProductBehavior = {
+  module Spec = AddProductSpec
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  // `exists` flips true if the decision read returns ANY ProductAdded — so if a
+  // sibling leaked into the read, p2 would be wrongly rejected. `liveCats` holds
+  // categories seen via CategoryAdded.
+  type state = {exists: bool, liveCats: array<string>}
+  let initialState = {exists: false, liveCats: []}
+
+  let evolve = (state: state, event: Spec.consumedEvent): state =>
+    switch event {
+    | ProductAdded(_) => {...state, exists: true}
+    | CategoryAdded({categoryId}) => {...state, liveCats: Array.concat(state.liveCats, [categoryId])}
+    }
+
+  let decide = (state: state, command: Spec.command): result<array<Spec.event>, Spec.error> =>
+    switch command {
+    | AddProduct({productId, categoryId, name}) =>
+      if state.exists {
+        Error(ProductAlreadyExists)
+      } else if !(state.liveCats->Array.includes(categoryId)) {
+        Error(CategoryNotFound)
+      } else {
+        Ok([Spec.ProductAdded({productId, categoryId, name})])
+      }
+    }
+}
+
+// ─── Isolated bus + event-topic counter ───
+module Bus = LocalBus.Make()
+
+let capturedEventCount: ref<int> = ref(0)
+let _ = Bus.subscribeToEvents("CatalogLogEventTopic", async (_, _, _) => {
+  capturedEventCount := capturedEventCount.contents + 1
+})
+
+let _ = TestRunner.setup()
+
+// ─── DcbEventLog (partitioned by productId, with a categoryId secondary index) ───
+module CatalogLogMaker = DcbEventLog_Builder.Make(Bus)
+let eventLog = CatalogLogMaker.make(
+  ~name="CatalogLog",
+  ~partitionTag=Reventless.DcbTag.Simple({key: "productId"}),
+  ~indexes=["tag_categoryId"],
+)
+
+// ─── StateChangeSlice, threaded with the INFERRED scope ───
+module AddProductMaker = StateChangeSlice_Builder.Make(AddProductSpec, AddProductBehavior)
+
+let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async cmdJsons => {
+  let _ = await cmdJsons
+  ->Array.map(async cmdJson => {
+    let typeName = switch cmdJson.commandJson {
+    | JSON.Object(dict) =>
+      dict
+      ->Dict.get("TAG")
+      ->Option.flatMap(j =>
+        switch j {
+        | JSON.String(s) => Some(s)
+        | _ => None
+        }
+      )
+      ->Option.getOr("")
+    | _ => ""
+    }
+    let fullBody = JSON.Encode.object(
+      Dict.fromArray([
+        ("id", JSON.Encode.string(cmdJson.id)),
+        ("meta", cmdJson.meta->S.reverseConvertToJsonOrThrow(Reventless.Message.metaSchema)),
+        ("command", cmdJson.commandJson),
+      ]),
+    )
+    let handlers = ReventlessCore.CommandTopic.getHandlers(typeName)
+    let _ = await handlers
+    ->Array.map(async entry => {
+      let item: ReventlessInfra.CommandTopic.topicItem<JSON.t> = {
+        reference: cmdJson.id,
+        command: fullBody,
+      }
+      let _ = await entry.handler(Stream.fromIterable([item]))->Effect.runPromise
+    })
+    ->Promise.all
+  })
+  ->Promise.all
+}
+
+let publishJsonsOutput = publishJsons->Pulumi.Output.make
+
+let _addProductSlice = AddProductMaker.make(
+  ~dcbEventLog=eventLog,
+  ~publishJsons=publishJsonsOutput,
+  ~tagKeysByEventType=Dict.fromArray([("ProductAdded", ["productId"]), ("CategoryAdded", ["categoryId"])]),
+  ~crossPartitionTagKeys=["categoryId"],
+)
+
+// ─── Helpers ───
+let dispatch = async (commandJson, id) =>
+  await publishJsons([{Reventless.Message.id, meta: testMeta, commandJson}])
+
+let encodeEvent = (event: CatalogLog.event): ReventlessInfra.DcbEventLog.rawEvent => {
+  let json = event->S.reverseConvertToJsonOrThrow(CatalogLog.eventSchema)
+  let (eventType, data) = json->ReventlessCore.Message.splitMessage
+  let tags = Reventless.DcbTag.extractTags(CatalogLog.eventSchema, event)
+  let meta = ReventlessCore.Message.generateMeta(~service="test")
+  {eventType, data: JSON.Object(data), tags, meta}
+}
+
+let addProductJson = (productId, categoryId, name) =>
+  AddProductSpec.AddProduct({productId, categoryId, name})->S.reverseConvertToJsonOrThrow(
+    AddProductSpec.commandSchema,
+  )

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

@@ -0,0 +1,276 @@
+// 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 Message$ReventlessCore from "@reventlessdev/reventless-core/src/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.union([
+  S.schema(s => ({
+    TAG: "ProductAdded",
+    productId: s.m(DcbTag$Reventless.partition),
+    categoryId: s.m(DcbTag$Reventless.string),
+    name: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "CategoryAdded",
+    categoryId: s.m(DcbTag$Reventless.string),
+    name: s.m(S.string)
+  }))
+]);
+
+let CatalogLog = {
+  eventSchema: eventSchema
+};
+
+let name = "AddProduct";
+
+let moduleUrl = import.meta.url;
+
+let eventSchema$1 = S.schema(s => ({
+  TAG: "ProductAdded",
+  productId: s.m(DcbTag$Reventless.partition),
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ProductAdded",
+    productId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "CategoryAdded",
+    categoryId: s.m(S.string)
+  }))
+]);
+
+let commandSchema = S.schema(s => ({
+  TAG: "AddProduct",
+  productId: s.m(DcbTag$Reventless.partition),
+  categoryId: s.m(DcbTag$Reventless.string),
+  name: s.m(S.string)
+}));
+
+let errorSchema = S.union([
+  S.literal("ProductAlreadyExists"),
+  S.literal("CategoryNotFound")
+]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let AddProductSpec = {
+  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;
+
+let initialState_liveCats = [];
+
+let initialState = {
+  exists: false,
+  liveCats: initialState_liveCats
+};
+
+function evolve(state, event) {
+  if (event.TAG === "ProductAdded") {
+    return {
+      exists: true,
+      liveCats: state.liveCats
+    };
+  } else {
+    return {
+      exists: state.exists,
+      liveCats: state.liveCats.concat([event.categoryId])
+    };
+  }
+}
+
+function decide(state, command) {
+  if (state.exists) {
+    return {
+      TAG: "Error",
+      _0: "ProductAlreadyExists"
+    };
+  }
+  let categoryId = command.categoryId;
+  if (state.liveCats.includes(categoryId)) {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "ProductAdded",
+          productId: command.productId,
+          categoryId: categoryId,
+          name: command.name
+        }]
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: "CategoryNotFound"
+    };
+  }
+}
+
+let AddProductBehavior = {
+  Spec: undefined,
+  moduleUrl: moduleUrl$1,
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide
+};
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+let capturedEventCount = {
+  contents: 0
+};
+
+Bus.subscribeToEvents("CatalogLogEventTopic", async (param, param$1, param$2) => {
+  capturedEventCount.contents = capturedEventCount.contents + 1 | 0;
+});
+
+TestRunner$ReventlessLocal.setup();
+
+let CatalogLogMaker = DcbEventLog_Builder$ReventlessLocal.Make(Bus);
+
+let eventLog = CatalogLogMaker.make("CatalogLog", ["tag_categoryId"], {
+  TAG: "Simple",
+  _0: {
+    key: "productId"
+  }
+}, undefined);
+
+let AddProductMaker = 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: initialState,
+  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 _addProductSlice = AddProductMaker.make(eventLog, publishJsonsOutput, Object.fromEntries([
+  [
+    "ProductAdded",
+    ["productId"]
+  ],
+  [
+    "CategoryAdded",
+    ["categoryId"]
+  ]
+]), ["categoryId"], undefined);
+
+async function dispatch(commandJson, id) {
+  return await publishJsons([{
+      id: id,
+      meta: TestFixtures$ReventlessLocal.testMeta,
+      commandJson: commandJson
+    }]);
+}
+
+function encodeEvent(event) {
+  let json = S.reverseConvertToJsonOrThrow(event, eventSchema);
+  let match = Message$ReventlessCore.splitMessage(json);
+  let tags = DcbTag$Reventless.extractTags(eventSchema, event);
+  let meta = Message$ReventlessCore.generateMeta("test", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  return {
+    eventType: match[0],
+    data: match[1],
+    tags: tags,
+    meta: meta
+  };
+}
+
+function addProductJson(productId, categoryId, name) {
+  return S.reverseConvertToJsonOrThrow({
+    TAG: "AddProduct",
+    productId: productId,
+    categoryId: categoryId,
+    name: name
+  }, commandSchema);
+}
+
+export {
+  CatalogLog,
+  AddProductSpec,
+  AddProductBehavior,
+  Bus,
+  capturedEventCount,
+  CatalogLogMaker,
+  eventLog,
+  AddProductMaker,
+  publishJsons,
+  publishJsonsOutput,
+  _addProductSlice,
+  dispatch,
+  encodeEvent,
+  addProductJson,
+}
+/* eventSchema Not a pure module */