@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/components/StateChangeSlice_Builder.res

@@ -0,0 +1,19 @@
+// StateChangeSlice builder — no platform-specific adapters needed.
+
+module Make = (
+  Spec: Reventless.StateChangeSlice.Spec,
+  Behavior: Reventless.StateChangeSlice.Behavior with module Spec := Spec,
+) => {
+  module Inner = ReventlessCore.StateChangeSlice_Builder.Make(Spec, Behavior)
+  module Spec = Spec
+  module Behavior = Behavior
+  let isAsync = Inner.isAsync
+  type component = Inner.component
+  let make: (
+    ~dcbEventLog: ReventlessInfra.DcbEventLog.component,
+    ~publishJsons: Pulumi.Output.t<ReventlessInfra.CommandTopic.publishJsons>,
+    ~tagKeysByEventType: Dict.t<array<string>>=?,
+    ~crossPartitionTagKeys: array<string>=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component = Inner.make
+}

package/src/components/StateChangeSlice_Builder.res.mjs

@@ -0,0 +1,21 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as StateChangeSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Builder.res.mjs";
+
+function Make(Spec) {
+  return Behavior => {
+    let Inner = StateChangeSlice_Builder$ReventlessCore.Make(Spec)(Behavior);
+    return {
+      Inner: Inner,
+      Spec: Spec,
+      Behavior: Behavior,
+      isAsync: Inner.isAsync,
+      make: Inner.make
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* StateChangeSlice_Builder-ReventlessCore Not a pure module */

package/src/components/StateViewSlice_Builder.res

@@ -0,0 +1,42 @@
+// In-memory StateViewSlice builder.
+// Wires in-memory adapters and delegates to the core ReventlessCore.StateViewSlice_Builder.
+
+module Make = (Bus: LocalBus.T) => {
+  module RuntimeEnvironment = LocalRuntimeEnvironment
+  module EventCollectorChannel = LocalEventCollectorChannel.Make(Bus)
+  module EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder.Make(
+    Bus,
+    EventCollectorChannel,
+  )
+  module QueryDbStorage = QueryDbStorage_InMemory.Make(Bus)
+  module QueryDbResolvers = QueryDbResolvers_GraphQL.Make(Bus)
+
+  // InMemory api/apiRole are both unit
+  module Api = {
+    let api = () => ()
+    let apiRole = () => ()
+  }
+
+  module CoreMaker = ReventlessCore.StateViewSlice_Builder.Make(
+    RuntimeEnvironment,
+    QueryDbStorage,
+    QueryDbResolvers,
+    EventCollectorChannel,
+    EventCollectorRuntimeBuilder,
+    Api,
+  )
+
+  module Make = (
+    Spec: Reventless.StateViewSlice.Spec,
+    Projection: Reventless.StateViewSlice.Projection with module Spec := Spec,
+  ) => {
+    module Inner = CoreMaker.Make(Spec, Projection)
+    module Spec = Spec
+    module Projection = Projection
+    type component = Inner.component
+    let make = Inner.make
+    // Re-expose operations for test resolution
+    let operations: component => Pulumi.Output.t<ReventlessCore.StateViewSlice.operations> =
+      ReventlessCore.Component.operations
+  }
+}

package/src/components/StateViewSlice_Builder.res.mjs

@@ -0,0 +1,58 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as StateViewSlice_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs";
+import * as LocalRuntimeEnvironment$ReventlessLocal from "../adapter/Runtime/LocalRuntimeEnvironment.res.mjs";
+import * as QueryDbStorage_InMemory$ReventlessLocal from "../adapter/QueryDb/QueryDbStorage_InMemory.res.mjs";
+import * as QueryDbResolvers_GraphQL$ReventlessLocal from "../adapter/QueryDb/QueryDbResolvers_GraphQL.res.mjs";
+import * as LocalEventCollectorChannel$ReventlessLocal from "../adapter/EventCollector/LocalEventCollectorChannel.res.mjs";
+import * as LocalEventCollectorRuntime_Builder$ReventlessLocal from "../adapter/Runtime/LocalEventCollectorRuntime_Builder.res.mjs";
+
+function Make(Bus) {
+  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.Make(Bus);
+  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)(EventCollectorChannel);
+  let QueryDbStorage = QueryDbStorage_InMemory$ReventlessLocal.Make(Bus);
+  let QueryDbResolvers = QueryDbResolvers_GraphQL$ReventlessLocal.Make(Bus);
+  let api = () => {};
+  let apiRole = () => {};
+  let Api = {
+    api: api,
+    apiRole: apiRole
+  };
+  let CoreMaker = StateViewSlice_Builder$ReventlessCore.Make({
+    make: LocalRuntimeEnvironment$ReventlessLocal.make,
+    groupBySource: LocalRuntimeEnvironment$ReventlessLocal.groupBySource,
+    extractCorrelationId: LocalRuntimeEnvironment$ReventlessLocal.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })({
+    make: QueryDbStorage.make
+  })({
+    make: QueryDbResolvers.make
+  })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(Api);
+  let Make$1 = Spec => (Projection => {
+    let Inner = CoreMaker.Make(Spec)(Projection);
+    return {
+      Inner: Inner,
+      Spec: Spec,
+      Projection: Projection,
+      make: Inner.make,
+      operations: Component$ReventlessCore.operations
+    };
+  });
+  return {
+    RuntimeEnvironment: undefined,
+    EventCollectorChannel: EventCollectorChannel,
+    EventCollectorRuntimeBuilder: EventCollectorRuntimeBuilder,
+    QueryDbStorage: QueryDbStorage,
+    QueryDbResolvers: QueryDbResolvers,
+    Api: Api,
+    CoreMaker: CoreMaker,
+    Make: Make$1
+  };
+}
+
+export {
+  Make,
+}
+/* Component-ReventlessCore Not a pure module */

package/src/components/Task_Builder.res

@@ -0,0 +1,28 @@
+// In-memory Task builder.
+
+module Make = (Bus: LocalBus.T) => {
+  module RuntimeEnvironment = LocalRuntimeEnvironment
+  module EventCollectorChannel = LocalEventCollectorChannel.Make(Bus)
+  module EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder.Make(
+    Bus,
+    EventCollectorChannel,
+  )
+  module TaskRuntimeBuilder = ReventlessCore.TaskRuntime_Builder_PerBucket.Make(
+    RuntimeEnvironment,
+    LocalTaskBucket,
+  )
+  module SideEffectHandler = LocalSideEffectHandler
+
+  module Make = (
+    Spec: ReventlessCore.Task.Spec,
+  ): (ReventlessCore.Task.T with module Spec = Spec) =>
+    ReventlessCore.Task_Builder.Make(
+      Spec,
+      RuntimeEnvironment,
+      EventCollectorChannel,
+      EventCollectorRuntimeBuilder,
+      TaskRuntimeBuilder,
+      LocalTaskBucket,
+      SideEffectHandler,
+    )
+}

package/src/components/Task_Builder.res.mjs

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Task_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/components/Task/Task_Builder.res.mjs";
+import * as LocalTaskBucket$ReventlessLocal from "../adapter/Task/LocalTaskBucket.res.mjs";
+import * as LocalSideEffectHandler$ReventlessLocal from "../adapter/LocalSideEffectHandler.res.mjs";
+import * as LocalRuntimeEnvironment$ReventlessLocal from "../adapter/Runtime/LocalRuntimeEnvironment.res.mjs";
+import * as LocalEventCollectorChannel$ReventlessLocal from "../adapter/EventCollector/LocalEventCollectorChannel.res.mjs";
+import * as TaskRuntime_Builder_PerBucket$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/Runtime/TaskRuntime_Builder_PerBucket.res.mjs";
+import * as LocalEventCollectorRuntime_Builder$ReventlessLocal from "../adapter/Runtime/LocalEventCollectorRuntime_Builder.res.mjs";
+
+function Make(Bus) {
+  let EventCollectorChannel = LocalEventCollectorChannel$ReventlessLocal.Make(Bus);
+  let EventCollectorRuntimeBuilder = LocalEventCollectorRuntime_Builder$ReventlessLocal.Make(Bus)(EventCollectorChannel);
+  let TaskRuntimeBuilder = TaskRuntime_Builder_PerBucket$ReventlessCore.Make({
+    make: LocalRuntimeEnvironment$ReventlessLocal.make,
+    groupBySource: LocalRuntimeEnvironment$ReventlessLocal.groupBySource,
+    extractCorrelationId: LocalRuntimeEnvironment$ReventlessLocal.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })(LocalTaskBucket$ReventlessLocal);
+  let Make$1 = Spec => Task_Builder$ReventlessCore.Make(Spec)({
+    make: LocalRuntimeEnvironment$ReventlessLocal.make,
+    groupBySource: LocalRuntimeEnvironment$ReventlessLocal.groupBySource,
+    extractCorrelationId: LocalRuntimeEnvironment$ReventlessLocal.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })(EventCollectorChannel)(EventCollectorRuntimeBuilder)(TaskRuntimeBuilder)(LocalTaskBucket$ReventlessLocal)(LocalSideEffectHandler$ReventlessLocal);
+  return {
+    RuntimeEnvironment: undefined,
+    EventCollectorChannel: EventCollectorChannel,
+    EventCollectorRuntimeBuilder: EventCollectorRuntimeBuilder,
+    TaskRuntimeBuilder: TaskRuntimeBuilder,
+    SideEffectHandler: undefined,
+    Make: Make$1
+  };
+}
+
+export {
+  Make,
+}
+/* Task_Builder-ReventlessCore Not a pure module */

package/src/reexport/CommandTopic.res

@@ -0,0 +1,3 @@
+// Re-exported from ReventlessCore so that consuming packages (examples, app plugins)
+// only need to depend on reventless-local, not reventless, for testing.
+include ReventlessCore.CommandTopic

package/src/reexport/CommandTopic.res.mjs

@@ -0,0 +1,55 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+
+let componentType = CommandTopic$ReventlessCore.componentType;
+
+let NotPublishedToChannel = CommandTopic$ReventlessCore.NotPublishedToChannel;
+
+let acceptedResultChannel = CommandTopic$ReventlessCore.acceptedResultChannel;
+
+let rejectedResultChannel = CommandTopic$ReventlessCore.rejectedResultChannel;
+
+let reportAccepted = CommandTopic$ReventlessCore.reportAccepted;
+
+let reportRejected = CommandTopic$ReventlessCore.reportRejected;
+
+let commandOutcomeToJson = CommandTopic$ReventlessCore.commandOutcomeToJson;
+
+let encodeCommandJson = CommandTopic$ReventlessCore.encodeCommandJson;
+
+let runInlineAndCollect = CommandTopic$ReventlessCore.runInlineAndCollect;
+
+let callHandlerWithArray = CommandTopic$ReventlessCore.callHandlerWithArray;
+
+let extractTypeNamesFromSchema = CommandTopic$ReventlessCore.extractTypeNamesFromSchema;
+
+let globalRegistry = CommandTopic$ReventlessCore.globalRegistry;
+
+let registerHandler = CommandTopic$ReventlessCore.registerHandler;
+
+let getHandlers = CommandTopic$ReventlessCore.getHandlers;
+
+let toResolvedOutputs = CommandTopic$ReventlessCore.toResolvedOutputs;
+
+let filter = CommandTopic$ReventlessCore.filter;
+
+export {
+  componentType,
+  NotPublishedToChannel,
+  acceptedResultChannel,
+  rejectedResultChannel,
+  reportAccepted,
+  reportRejected,
+  commandOutcomeToJson,
+  encodeCommandJson,
+  runInlineAndCollect,
+  callHandlerWithArray,
+  extractTypeNamesFromSchema,
+  globalRegistry,
+  registerHandler,
+  getHandlers,
+  toResolvedOutputs,
+  filter,
+}
+/* CommandTopic-ReventlessCore Not a pure module */

package/src/test/Mocks/MockDcbEventLogStorage.res

@@ -0,0 +1,136 @@
+// Mock in-memory DCB event log storage.
+// Conforms to ReventlessCore.DcbEventLog_Adapter.storage.
+// Extracted from DcbFixtures.makeMockStorage with reset() and failNextAppends.
+
+open ReventlessCore
+
+type publishedEvent = {
+  service: string,
+  meta: Reventless.Message.meta,
+  json: JSON.t,
+}
+
+type t = {
+  storage: DcbEventLog_Adapter.storage,
+  getEvents: unit => array<DcbEventLog_Adapter.rawSequencedEvent>,
+  publishedEvents: ref<array<publishedEvent>>,
+  mockPublishJson: ReventlessInfra.EventTopic.publishJson,
+  failNextAppends: ref<int>,
+  reset: unit => unit,
+}
+
+let posToInt = (pos: string) => pos->Int.fromString->Option.getOr(0)
+
+let matchesQuery = (event: DcbEventLog_Adapter.rawSequencedEvent, query: Reventless.DcbTag.query) =>
+  if query->Array.length == 0 {
+    true
+  } else {
+    query->Array.some(queryItem => {
+      let typeMatch = switch queryItem.eventTypes {
+      | Some(types) => types->Array.includes(event.eventType)
+      | None => true
+      }
+      let tagMatch = switch queryItem.tags {
+      | Some(tags) =>
+        tags->Array.every(tag =>
+          event.tags->Array.some(et => et.key == tag.key && et.value == tag.value)
+        )
+      | None => true
+      }
+      typeMatch && tagMatch
+    })
+  }
+
+let make = (~name="mock-dcb-log", ~indexes: array<string>=[], ~opts: Pulumi.CustomResourceOptions.t={}) => {
+  let _ = (name, indexes, opts)
+  let events: ref<array<DcbEventLog_Adapter.rawSequencedEvent>> = ref([])
+  let position = ref(0)
+  let publishedEventsRef: ref<array<publishedEvent>> = ref([])
+  let failNextAppends = ref(0)
+
+  let read = async (~query, ~after=?) => {
+    let filtered = events.contents->Array.filter(event => {
+      let afterMatch = switch after {
+      | Some(afterPos) => event.position->posToInt > afterPos->posToInt
+      | None => true
+      }
+      afterMatch && matchesQuery(event, query)
+    })
+    let headPosition =
+      events.contents
+      ->Array.get(events.contents->Array.length - 1)
+      ->Option.map(e => e.position)
+    {
+      DcbEventLog_Adapter.events: filtered,
+      ?headPosition,
+    }
+  }
+
+  let append = async (newEvents, ~condition=?) => {
+    if failNextAppends.contents > 0 {
+      failNextAppends := failNextAppends.contents - 1
+      Error("mock append failure")
+    } else {
+      let conflictDetected = switch condition {
+      | Some(cond: Reventless.DcbTag.appendCondition) =>
+        events.contents->Array.some(event => {
+          let afterMatch = switch cond.after {
+          | Some(pos) => event.position->posToInt > pos->posToInt
+          | None => true
+          }
+          afterMatch && matchesQuery(event, cond.query)
+        })
+      | None => false
+      }
+      if conflictDetected {
+        Error("conflict: condition check failed")
+      } else {
+        let storedEvents = newEvents->Array.map((event: DcbEventLog_Adapter.rawStoredEvent) => {
+          position := position.contents + 1
+          let pos = position.contents->Int.toString
+          {
+            DcbEventLog_Adapter.position: pos,
+            eventType: event.eventType,
+            data: event.data,
+            tags: event.tags,
+            meta: event.meta,
+            recordedAt: Message.nowAsISOString(),
+          }
+        })
+        events := events.contents->Array.concat(storedEvents)
+        Ok(position.contents->Int.toString)
+      }
+    }
+  }
+
+  let mockPublishJson: ReventlessInfra.EventTopic.publishJson = async (service, meta, json) => {
+    publishedEventsRef := publishedEventsRef.contents->Array.concat([{service, meta, json}])
+  }
+
+  let readStream = (~query, ~after=?, ~strongConsistency as _=?) =>
+    Effect.promise(() => read(~query, ~after?))
+    ->Effect.map(result => result.events)
+    ->Stream.fromEffect
+    ->Stream.flatMap(arr => Stream.fromIterable(arr))
+
+  let storage: DcbEventLog_Adapter.storage = {
+    resources: [],
+    operations: Pulumi.Output.make({DcbEventLog_Adapter.read, append, readStream}),
+  }
+
+  let reset = () => {
+    events := []
+    position := 0
+    publishedEventsRef := []
+    failNextAppends := 0
+  }
+
+  {
+    storage,
+    getEvents: () => events.contents,
+    publishedEvents: publishedEventsRef,
+    mockPublishJson,
+    failNextAppends,
+    reset,
+  }
+}

package/src/test/Mocks/MockDcbEventLogStorage.res.mjs

@@ -0,0 +1,146 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+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 Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+
+function posToInt(pos) {
+  return Stdlib_Option.getOr(Stdlib_Int.fromString(pos, undefined), 0);
+}
+
+function matchesQuery(event, query) {
+  if (query.length === 0) {
+    return true;
+  } else {
+    return query.some(queryItem => {
+      let types = queryItem.eventTypes;
+      let typeMatch = types !== undefined ? types.includes(event.eventType) : true;
+      let tags = queryItem.tags;
+      let tagMatch = tags !== undefined ? tags.every(tag => event.tags.some(et => {
+          if (et.key === tag.key) {
+            return et.value === tag.value;
+          } else {
+            return false;
+          }
+        })) : true;
+      if (typeMatch) {
+        return tagMatch;
+      } else {
+        return false;
+      }
+    });
+  }
+}
+
+function make(nameOpt, indexesOpt, optsOpt) {
+  let events = {
+    contents: []
+  };
+  let position = {
+    contents: 0
+  };
+  let publishedEventsRef = {
+    contents: []
+  };
+  let failNextAppends = {
+    contents: 0
+  };
+  let read = async (query, after) => {
+    let filtered = events.contents.filter(event => {
+      let afterMatch = after !== undefined ? posToInt(event.position) > posToInt(after) : true;
+      if (afterMatch) {
+        return matchesQuery(event, query);
+      } else {
+        return false;
+      }
+    });
+    let headPosition = Stdlib_Option.map(events.contents[events.contents.length - 1 | 0], e => e.position);
+    return {
+      events: filtered,
+      headPosition: headPosition
+    };
+  };
+  let append = async (newEvents, condition) => {
+    if (failNextAppends.contents > 0) {
+      failNextAppends.contents = failNextAppends.contents - 1 | 0;
+      return {
+        TAG: "Error",
+        _0: "mock append failure"
+      };
+    }
+    let conflictDetected = condition !== undefined ? events.contents.some(event => {
+        let pos = condition.after;
+        let afterMatch = pos !== undefined ? posToInt(event.position) > posToInt(pos) : true;
+        if (afterMatch) {
+          return matchesQuery(event, condition.query);
+        } else {
+          return false;
+        }
+      }) : false;
+    if (conflictDetected) {
+      return {
+        TAG: "Error",
+        _0: "conflict: condition check failed"
+      };
+    }
+    let storedEvents = newEvents.map(event => {
+      position.contents = position.contents + 1 | 0;
+      let pos = position.contents.toString();
+      return {
+        position: pos,
+        eventType: event.eventType,
+        data: event.data,
+        tags: event.tags,
+        meta: event.meta,
+        recordedAt: Message$ReventlessCore.nowAsISOString()
+      };
+    });
+    events.contents = events.contents.concat(storedEvents);
+    return {
+      TAG: "Ok",
+      _0: position.contents.toString()
+    };
+  };
+  let mockPublishJson = async (service, meta, json) => {
+    publishedEventsRef.contents = publishedEventsRef.contents.concat([{
+        service: service,
+        meta: meta,
+        json: json
+      }]);
+  };
+  let readStream = (query, after, param) => Stream.flatMap(Stream.fromEffect(Effect.map(Effect.promise(() => read(query, after)), result => result.events)), arr => Stream.fromIterable(arr));
+  let storage_resources = [];
+  let storage_operations = Pulumi.output({
+    read: read,
+    append: append,
+    readStream: readStream
+  });
+  let storage = {
+    resources: storage_resources,
+    operations: storage_operations
+  };
+  let reset = () => {
+    events.contents = [];
+    position.contents = 0;
+    publishedEventsRef.contents = [];
+    failNextAppends.contents = 0;
+  };
+  return {
+    storage: storage,
+    getEvents: () => events.contents,
+    publishedEvents: publishedEventsRef,
+    mockPublishJson: mockPublishJson,
+    failNextAppends: failNextAppends,
+    reset: reset
+  };
+}
+
+export {
+  posToInt,
+  matchesQuery,
+  make,
+}
+/* effect/Effect Not a pure module */

package/src/test/Mocks/MockEventLogStorage.res

@@ -0,0 +1,57 @@
+// Mock in-memory event log storage.
+// Conforms to ReventlessCore.EventLog_Adapter.storage.
+// Adds reset() and failNextAppends counter for test isolation and failure injection.
+
+type t = {
+  storage: ReventlessCore.EventLog_Adapter.storage,
+  failNextAppends: ref<int>,
+  reset: unit => unit,
+}
+
+let make = (~name as _="mock-event-log", ~opts as _: Pulumi.CustomResourceOptions.t={}) => {
+  let events: ref<dict<array<JSON.t>>> = ref(Dict.make())
+  let failNextAppends = ref(0)
+
+  let append: ReventlessCore.EventLog.append<string, JSON.t> = async (_seqNr, id, jsons) => {
+    if failNextAppends.contents > 0 {
+      failNextAppends := failNextAppends.contents - 1
+      Error("mock append failure")
+    } else {
+      let existing = events.contents->Dict.get(id)->Option.getOr([])
+      events.contents->Dict.set(id, existing->Array.concat(jsons))
+      Ok()
+    }
+  }
+
+  let replay: ReventlessCore.EventLog.replay<string, JSON.t> = async id => {
+    events.contents->Dict.get(id)->Option.getOr([])
+  }
+
+  let replayStream: string => Stream.t<JSON.t, string, unit> = id =>
+    events.contents->Dict.get(id)->Option.getOr([])->Stream.fromIterable
+
+  let appendStream: ReventlessCore.EventLog.appendStream<string, JSON.t> = (_startingSeqNr, id, stream) =>
+    stream->Stream.runForEach(json =>
+      Effect.sync(() => {
+        let existing = events.contents->Dict.get(id)->Option.getOr([])
+        events.contents->Dict.set(id, existing->Array.concat([json]))
+      })
+    )
+
+  let storage: ReventlessCore.EventLog_Adapter.storage = {
+    resources: [],
+    operations: Pulumi.Output.make({
+      ReventlessCore.EventLog_Adapter.append,
+      replay,
+      replayStream,
+      appendStream,
+    }),
+  }
+
+  let reset = () => {
+    events := Dict.make()
+    failNextAppends := 0
+  }
+
+  {storage, failNextAppends, reset}
+}

package/src/test/Mocks/MockEventLogStorage.res.mjs

@@ -0,0 +1,65 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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";
+
+function make($staropt$star, $staropt$star$1) {
+  $staropt$star !== undefined;
+  if ($staropt$star$1 === undefined) {
+    
+  }
+  let events = {
+    contents: {}
+  };
+  let failNextAppends = {
+    contents: 0
+  };
+  let append = async (_seqNr, id, jsons) => {
+    if (failNextAppends.contents > 0) {
+      failNextAppends.contents = failNextAppends.contents - 1 | 0;
+      return {
+        TAG: "Error",
+        _0: "mock append failure"
+      };
+    }
+    let existing = Stdlib_Option.getOr(events.contents[id], []);
+    events.contents[id] = existing.concat(jsons);
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
+  let replay = async id => Stdlib_Option.getOr(events.contents[id], []);
+  let replayStream = id => Stream.fromIterable(Stdlib_Option.getOr(events.contents[id], []));
+  let appendStream = (_startingSeqNr, id, stream) => Stream.runForEach(stream, json => Effect.sync(() => {
+    let existing = Stdlib_Option.getOr(events.contents[id], []);
+    events.contents[id] = existing.concat([json]);
+  }));
+  let storage_resources = [];
+  let storage_operations = Pulumi.output({
+    append: append,
+    replay: replay,
+    replayStream: replayStream,
+    appendStream: appendStream
+  });
+  let storage = {
+    resources: storage_resources,
+    operations: storage_operations
+  };
+  let reset = () => {
+    events.contents = {};
+    failNextAppends.contents = 0;
+  };
+  return {
+    storage: storage,
+    failNextAppends: failNextAppends,
+    reset: reset
+  };
+}
+
+export {
+  make,
+}
+/* effect/Effect Not a pure module */