@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/EventCollector/EventCollector_Builder.res.mjs

@@ -0,0 +1,64 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stream from "effect/Stream";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as EventCollector$ReventlessCore from "./EventCollector.res.mjs";
+
+function makeStreamHandler(eventCollector, schema, jsonEventsHandler) {
+  let jsonHandler = stream => jsonEventsHandler(Stream.mapEffect(stream, json => Effect.trySync(_exn => "decode error", () => S.parseOrThrow(json, schema))));
+  let channel = eventCollector.channel;
+  return channel.handleChannelEvent(jsonHandler);
+}
+
+function Make(RuntimeEnvironment) {
+  return Channel => {
+    let connect = (eventTopics, resources, runtime, eventCollector) => {
+      let eventCollectorResource = Component$ReventlessCore.toPulumiResource(eventCollector);
+      let name = ComponentType$ReventlessCore.name(Stdlib_Option.getOr(eventCollectorResource.__name, "Unnamed"), EventCollector$ReventlessCore.componentType);
+      Channel.connect(name, [{
+          channel: eventCollector.channel,
+          eventTopics: eventTopics,
+          resources: resources
+        }], runtime, {
+        parent: eventCollectorResource
+      });
+    };
+    let makeHandler = (eventCollector, jsonEventsHandler) => {
+      let channel = eventCollector.channel;
+      return channel.handleChannelEvent(jsonEventsHandler);
+    };
+    let make = (name, eventTopics, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(EventCollector$ReventlessCore.componentType), name, (extra, extra$1) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(extra);
+      let opts = {
+        parent: opts_parent
+      };
+      let name = ComponentType$ReventlessCore.name(extra$1, EventCollector$ReventlessCore.componentType);
+      let channel = Channel.make(name, eventTopics, opts);
+      extra.channel = channel;
+      Component$ReventlessCore.setOperations(extra, channel.enqueueEvent.apply(enqueueEvent => ({
+        enqueueEvent: enqueueEvent
+      })));
+      let outputs_resources = channel.resources;
+      let outputs = {
+        name: name,
+        resources: outputs_resources
+      };
+      return Component$ReventlessCore.setOutputs(extra, outputs);
+    }, opts);
+    return {
+      connect: connect,
+      makeHandler: makeHandler,
+      make: make
+    };
+  };
+}
+
+export {
+  makeStreamHandler,
+  Make,
+}
+/* S Not a pure module */

package/src/components/EventLog/EventLog.res

@@ -0,0 +1,27 @@
+let componentType = ComponentType.EventLog
+
+type outputs = ReventlessInfra.EventLog.outputs
+
+type t
+type component<'operations> = Component.t<t, outputs, 'operations>
+
+exception ReplayError(string)
+
+type append<'id, 'event> = (int, 'id, array<'event>) => promise<result<unit, string>>
+type replay<'id, 'event> = 'id => promise<array<'event>>
+type replayStream<'id, 'event> = 'id => Stream.t<'event, string, unit>
+type appendStream<'id, 'event> = (int, 'id, Stream.t<'event, string, unit>) => Effect.t<unit, string, unit>
+
+module type T = {
+  module Spec: ReventlessInfra.EventLog.T
+
+  type operations = {
+    append: append<Spec.Id.t, Message.event'<Spec.Id.t, Spec.event>>,
+    replay: replay<Spec.Id.t, Spec.event>,
+    replayStream: replayStream<Spec.Id.t, Spec.event>,
+    appendStream: appendStream<Spec.Id.t, Spec.event>,
+  }
+  type component = component<operations>
+
+  let make: (~name: string, ~opts: Pulumi.ComponentResource.options=?) => component
+}

package/src/components/EventLog/EventLog.res.mjs

@@ -0,0 +1,13 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+
+let ReplayError = /* @__PURE__ */Primitive_exceptions.create("EventLog-ReventlessCore.ReplayError");
+
+let componentType = "EventLog";
+
+export {
+  componentType,
+  ReplayError,
+}
+/* No side effect */

package/src/components/EventLog/EventLog_Adapter.res

@@ -0,0 +1,15 @@
+type operations = {
+  append: EventLog.append<string, JSON.t>,
+  replay: EventLog.replay<string, JSON.t>,
+  replayStream: string => Stream.t<JSON.t, string, unit>,
+  appendStream: EventLog.appendStream<string, JSON.t>,
+}
+type storage = {
+  resources: array<ReventlessInfra.Adapter.resource>,
+  operations: Pulumi.Output.t<operations>,
+}
+type storageMaker = (~name: string, ~opts: Pulumi.CustomResourceOptions.t) => storage
+
+module type Storage = {
+  let make: storageMaker
+}

package/src/components/EventLog/EventLog_Adapter.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/components/EventLog/EventLog_Builder.res

@@ -0,0 +1,65 @@
+module Make = (
+  Spec: ReventlessInfra.EventLog.T,
+  Storage: EventLog_Adapter.Storage,
+  EventTopicPublisher: EventTopic_Adapter.Publisher,
+): (EventLog.T with module Spec = Spec) => {
+  module Spec = Spec
+
+  type operations = {
+    append: EventLog.append<Spec.Id.t, Message.event'<Spec.Id.t, Spec.event>>,
+    replay: EventLog.replay<Spec.Id.t, Spec.event>,
+    replayStream: EventLog.replayStream<Spec.Id.t, Spec.event>,
+    appendStream: EventLog.appendStream<Spec.Id.t, Spec.event>,
+  }
+  type component = Component.t<EventLog.t, EventLog.outputs, operations>
+
+  let construct = (self, name) => {
+    let opts = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
+
+    let storage = Storage.make(~name=name->ComponentType.name(EventLog.componentType), ~opts)
+
+    module SpecificEventTopic = EventTopic_Builder.Make(Spec, EventTopicPublisher)
+    let eventTopic = SpecificEventTopic.make(
+      ~name,
+      ~storageResources=storage.resources,
+      ~opts=opts->Util.Pulumi.ComponentResourceOptions.ofCustomResourceOptions,
+    )
+
+    self->Component.setOperations(
+      (storage.operations, eventTopic->Component.operations)
+      ->Pulumi.Output.all2
+      ->Pulumi.Output.apply(((storageOps, eventTopicOps)) => {
+        module Ops = EventLog_Operations.Make(
+          Spec,
+          {
+            module Spec = Spec
+            module EventTopic = SpecificEventTopic
+            let eventTopic = eventTopicOps
+            let storage = storageOps
+          },
+        )
+
+        {
+          append: Ops.append,
+          replay: Ops.replay,
+          replayStream: Ops.replayStream,
+          appendStream: Ops.appendStream,
+        }
+      }),
+    )
+
+    let outputs: EventLog.outputs = {
+      resources: storage.resources,
+      eventTopic: eventTopic->Component.outputs,
+    }
+    self->Component.setOutputs(outputs)
+  }
+
+  let make = (~name, ~opts=?): component =>
+    Component.make(
+      ~componentType=EventLog.componentType->ComponentType.toString,
+      ~name,
+      ~construct,
+      ~opts,
+    )
+}

package/src/components/EventLog/EventLog_Builder.res.mjs

@@ -0,0 +1,57 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as EventLog$ReventlessCore from "./EventLog.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as Util_Pulumi$ReventlessCore from "../../util/Util_Pulumi.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as EventTopic_Builder$ReventlessCore from "../EventTopic/EventTopic_Builder.res.mjs";
+import * as EventLog_Operations$ReventlessCore from "./EventLog_Operations.res.mjs";
+
+function Make(Spec) {
+  return Storage => (EventTopicPublisher => {
+    let construct = (self, name) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(self);
+      let opts = {
+        parent: opts_parent
+      };
+      let storage = Storage.make(ComponentType$ReventlessCore.name(name, EventLog$ReventlessCore.componentType), opts);
+      let SpecificEventTopic = EventTopic_Builder$ReventlessCore.Make(Spec)(EventTopicPublisher);
+      let eventTopic = SpecificEventTopic.make(name, storage.resources, Util_Pulumi$ReventlessCore.ComponentResourceOptions.ofCustomResourceOptions(opts));
+      Component$ReventlessCore.setOperations(self, Pulumi.all([
+        storage.operations,
+        Component$ReventlessCore.operations(eventTopic)
+      ]).apply(param => {
+        let Ops = EventLog_Operations$ReventlessCore.Make(Spec)({
+          Spec: Spec,
+          EventTopic: SpecificEventTopic,
+          eventTopic: param[1],
+          storage: param[0]
+        });
+        return {
+          append: Ops.append,
+          replay: Ops.replay,
+          replayStream: Ops.replayStream,
+          appendStream: Ops.appendStream
+        };
+      }));
+      let outputs_resources = storage.resources;
+      let outputs_eventTopic = Component$ReventlessCore.outputs(eventTopic);
+      let outputs = {
+        resources: outputs_resources,
+        eventTopic: outputs_eventTopic
+      };
+      return Component$ReventlessCore.setOutputs(self, outputs);
+    };
+    let make = (name, opts) => Component$ReventlessCore.make(ComponentType$ReventlessCore.toString(EventLog$ReventlessCore.componentType), name, construct, opts);
+    return {
+      Spec: Spec,
+      make: make
+    };
+  });
+}
+
+export {
+  Make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/EventLog/EventLog_Operations.res

@@ -0,0 +1,209 @@
+module type Ops = {
+  module Spec: ReventlessInfra.EventLog.T
+  module EventTopic: EventTopic.T with module Spec.Id = Spec.Id and type Spec.event = Spec.event
+  let eventTopic: EventTopic.operations
+  let storage: EventLog_Adapter.operations
+}
+
+module type T = {
+  module Spec: ReventlessInfra.EventLog.T
+  let append: EventLog.append<Spec.Id.t, Message.event'<Spec.Id.t, Spec.event>>
+  let replay: EventLog.replay<Spec.Id.t, Spec.event>
+  let replayStream: EventLog.replayStream<Spec.Id.t, Spec.event>
+  let appendStream: EventLog.appendStream<Spec.Id.t, Spec.event>
+}
+
+// Retry schedule for transient storage errors.
+// Exponential backoff: 100ms, ~200ms, ~400ms, ~800ms, ~1600ms — max 5 retries.
+// Only retries on recognised transient error messages; permanent errors propagate immediately.
+let isTransient = (msg: string) =>
+  msg->String.includes("ThrottlingException") ||
+  msg->String.includes("ProvisionedThroughputExceededException") ||
+  msg->String.includes("ServiceUnavailable") ||
+  msg->String.includes("RequestLimitExceeded") ||
+  msg->String.includes("InternalServerError")
+
+let storageRetrySchedule: Schedule.t<(Duration.t, int), string, unit> =
+  Schedule.exponential(Duration.millis(100))
+  ->Schedule.jittered
+  ->Schedule.intersect(Schedule.recurs(5))
+  ->Schedule.whileInput(isTransient)
+
+module Make = (Spec: ReventlessInfra.EventLog.T, Ops: Ops with module Spec = Spec): (
+  T with module Spec = Spec
+) => {
+  module Spec = Spec
+
+  let encodeEvent' = (id, sequenceNr, event') => {
+    let json = event'.Reventless.Message.event->Message.encode(Spec.eventSchema)
+    let (eventType, data) = json->Message.splitMessage
+    let stored: Reventless.StoredEvent.storedEvent<Spec.Id.t> = {
+      id,
+      position: sequenceNr->Int.toString->String.padStart(9, "0"),
+      event: eventType,
+      data: JSON.Object(data),
+      meta: event'.meta,
+      recordedAt: Message.nowAsISOString(),
+    }
+    stored->Message.storedEventToFlatJson(Spec.Id.schema)
+  }
+
+  let encodeEvents' = (events', id, startingSeqNr) =>
+    events'->Array.mapWithIndex((event, i) => encodeEvent'(id, startingSeqNr + i, event))
+
+  let makePublishedEvent = (idStr, eventsJson, meta): EventPublish_Callback.publishedEvent => {
+    componentName: Spec.name,
+    entityId: idStr,
+    eventCount: eventsJson->Array.length,
+    eventsJson,
+    meta,
+  }
+
+  let runBeforePublishHook = async (idStr, eventsJson, meta) =>
+    switch EventPublish_Callback.beforePublishHook.contents {
+    | None => ()
+    | Some(hook) =>
+      try {
+        let _ = await hook(makePublishedEvent(idStr, eventsJson, meta))
+      } catch {
+      | err =>
+        let errMsg =
+          err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`EventLog(${Spec.name})`,
+          `beforePublishHook error: ${errMsg}`,
+        )->Effect.runSync
+      }
+    }
+
+  let runAfterPublishHook = async (idStr, eventsJson, meta) =>
+    switch EventPublish_Callback.afterPublishHook.contents {
+    | None => ()
+    | Some(hook) =>
+      try {
+        let _ = await hook(makePublishedEvent(idStr, eventsJson, meta))
+      } catch {
+      | err =>
+        let errMsg =
+          err->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown")
+        EffectLogger.logError(
+          ~comp=`EventLog(${Spec.name})`,
+          `afterPublishHook error: ${errMsg}`,
+        )->Effect.runSync
+      }
+    }
+
+  // Returns result<unit, string> — never throws. Publish failures are surfaced as Error.
+  let publishToEventTopic = async (id, events': array<Message.event'<_, _>>, eventsJson) => {
+    let idStr = id->Spec.Id.toString
+    let firstEvent = events'->Array.getUnsafe(0)
+    let meta = firstEvent.meta
+    await runBeforePublishHook(idStr, eventsJson, meta)
+    try {
+      let _ = await Ops.eventTopic.publish(events')
+      await runAfterPublishHook(idStr, eventsJson, meta)
+      Ok()
+    } catch {
+    | JsExn(err) =>
+      let msg =
+        `EventLog.append(${idStr}): EventTopic.publish Error: ` ++
+        err->JsExn.message->Option.getOr("no error message given")
+      Error(msg)
+    }
+  }
+
+  // append returns result<unit, string> — never throws.
+  // Storage errors are retried with exponential backoff (up to 5 times for transient errors).
+  // After exhausting retries, or on permanent errors, returns Error.
+  let isConflict = (msg: string) => msg->String.includes("conflict")
+
+  let append = async (sequenceNr, id, events') => {
+    let eventsJson = events'->encodeEvents'(id, sequenceNr)
+    let idStr = id->Spec.Id.toString
+    // Build an Effect that fails with a string on storage error (enabling retry)
+    let storageEffect =
+      Effect.tryPromise(
+        ~catch=(err: unknown) => Util.Error.messageFromUnknown(err, "storage error"),
+        () => Ops.storage.append(sequenceNr, idStr, eventsJson),
+      )
+      ->Effect.flatMap(result =>
+        switch result {
+        | Ok(_) => Effect.succeed(())
+        | Error(msg) => Effect.fail(msg)
+        }
+      )
+      ->Effect.retry(storageRetrySchedule)
+    let exit = await storageEffect->Effect.runPromiseExit
+    if exit->Exit.isSuccess {
+      await publishToEventTopic(id, events', eventsJson)
+    } else {
+      // Retry exhausted — extract the final error message from the Cause.
+      // Use Cause.pretty so defects (uncaught throws) are surfaced too, not
+      // just typed failures from Cause.failures.
+      let failMsg = exit->Exit.match(
+        ~onFailure=cause => cause->Cause.pretty,
+        ~onSuccess=_ => "storage error", // unreachable: we are in the isFailure branch
+      )
+      // Propagate conflict errors without wrapping so callers can detect them
+      if isConflict(failMsg) {
+        Error("conflict")
+      } else {
+        Error(`EventLog: Error: Couldn't append for ${Spec.name}(${idStr}): ${failMsg}`)
+      }
+    }
+  }
+
+  let decodeEvent = (id, json) =>
+    try {
+      JSON.Decode.object(json)
+      ->Option.map(dict =>
+        switch (dict->Dict.get("event"), dict->Dict.get("data")) {
+        | (Some(JSON.String(eventType)), Some(JSON.Object(data))) =>
+          Message.combineMessage(eventType, data)
+        | (Some(JSON.String(eventType)), None) => Message.combineMessage(eventType, Dict.make())
+        | _ => JsError.throwWithMessage("event type or data incorrect")
+        }
+      )
+      ->Option.getOrThrow
+      ->Message.decode(Spec.eventSchema)
+    } catch {
+    | JsExn(e) =>
+      let eventStr = json->JSON.stringify
+      let message = e->Util.Error.message
+      JsError.throwWithMessage(
+        `EventLog.replay: Error: id:${id}: Couldn't decode ${eventStr}: ${message}`,
+      )
+    }
+
+  let decodeEvents = (jsons, id) => jsons->Array.map(json => decodeEvent(id, json))
+
+  let replay = async id => {
+    let eventsJson = await Ops.storage.replay(id->Spec.Id.toString)
+    eventsJson->decodeEvents(id->Spec.Id.toString)
+  }
+
+  // Lazy streaming replay — wraps decodeEvent in Effect.sync so thrown exceptions
+  // surface through the stream's error channel rather than as unhandled exceptions.
+  let replayStream = id =>
+    Ops.storage.replayStream(id->Spec.Id.toString)
+    ->Stream.mapEffect(json =>
+      Effect.sync(() => decodeEvent(id->Spec.Id.toString, json))
+    )
+
+  // Streaming append — encodes each Spec.event to the {type, data} storage format
+  // and writes sequentially via the storage adapter.
+  // Accepts Spec.event items (symmetric with replayStream) to enable direct
+  // replayStream → appendStream pipelines without an intermediate mapping step.
+  let appendStream = (startingSeqNr, id, stream) =>
+    Ops.storage.appendStream(
+      startingSeqNr,
+      id->Spec.Id.toString,
+      stream->Stream.map(event => {
+        let json = event->Message.encode(Spec.eventSchema)
+        let (eventType, data) = json->Message.splitMessage
+        [("event", JSON.String(eventType)), ("data", JSON.Object(data))]
+        ->Dict.fromArray
+        ->JSON.Encode.object
+      }),
+    )
+}

package/src/components/EventLog/EventLog_Operations.res.mjs

@@ -0,0 +1,202 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Exit from "@reventlessdev/rescript-effect/src/Exit.res.mjs";
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Exit$1 from "effect/Exit";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Cause from "effect/Cause";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect$1 from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Duration from "effect/Duration";
+import * as Schedule from "effect/Schedule";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as Util_Error$ReventlessCore from "../../util/Util_Error.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as EventPublish_Callback$ReventlessCore from "./EventPublish_Callback.res.mjs";
+
+function isTransient(msg) {
+  if (msg.includes("ThrottlingException") || msg.includes("ProvisionedThroughputExceededException") || msg.includes("ServiceUnavailable") || msg.includes("RequestLimitExceeded")) {
+    return true;
+  } else {
+    return msg.includes("InternalServerError");
+  }
+}
+
+let storageRetrySchedule = Schedule.whileInput(Schedule.intersect(Schedule.jittered(Schedule.exponential(Duration.millis(100))), Schedule.recurs(5)), isTransient);
+
+function Make(Spec) {
+  return Ops => {
+    let encodeEvents$p = (events$p, id, startingSeqNr) => events$p.map((event, i) => {
+      let sequenceNr = startingSeqNr + i | 0;
+      let json = Message$ReventlessCore.encode(event.event, Spec.eventSchema);
+      let match = Message$ReventlessCore.splitMessage(json);
+      let stored_position = sequenceNr.toString().padStart(9, "0");
+      let stored_event = match[0];
+      let stored_data = match[1];
+      let stored_meta = event.meta;
+      let stored_recordedAt = Message$ReventlessCore.nowAsISOString();
+      let stored = {
+        id: id,
+        position: stored_position,
+        event: stored_event,
+        data: stored_data,
+        meta: stored_meta,
+        recordedAt: stored_recordedAt
+      };
+      return Message$ReventlessCore.storedEventToFlatJson(stored, Spec.Id.schema);
+    });
+    let makePublishedEvent = (idStr, eventsJson, meta) => ({
+      componentName: Spec.name,
+      entityId: idStr,
+      eventCount: eventsJson.length,
+      eventsJson: eventsJson,
+      meta: meta
+    });
+    let runBeforePublishHook = async (idStr, eventsJson, meta) => {
+      let hook = EventPublish_Callback$ReventlessCore.beforePublishHook.contents;
+      if (hook === undefined) {
+        return;
+      }
+      try {
+        await hook(makePublishedEvent(idStr, eventsJson, meta));
+        return;
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown");
+        return Effect$1.runSync(EffectLogger$ReventlessCore.logError(`EventLog(` + Spec.name + `)`, undefined, `beforePublishHook error: ` + errMsg));
+      }
+    };
+    let runAfterPublishHook = async (idStr, eventsJson, meta) => {
+      let hook = EventPublish_Callback$ReventlessCore.afterPublishHook.contents;
+      if (hook === undefined) {
+        return;
+      }
+      try {
+        await hook(makePublishedEvent(idStr, eventsJson, meta));
+        return;
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        let errMsg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(err), Stdlib_JsExn.message), "unknown");
+        return Effect$1.runSync(EffectLogger$ReventlessCore.logError(`EventLog(` + Spec.name + `)`, undefined, `afterPublishHook error: ` + errMsg));
+      }
+    };
+    let publishToEventTopic = async (id, events$p, eventsJson) => {
+      let idStr = Spec.Id.toString(id);
+      let firstEvent = events$p[0];
+      let meta = firstEvent.meta;
+      await runBeforePublishHook(idStr, eventsJson, meta);
+      try {
+        await Ops.eventTopic.publish(events$p);
+        await runAfterPublishHook(idStr, eventsJson, meta);
+        return {
+          TAG: "Ok",
+          _0: undefined
+        };
+      } catch (raw_err) {
+        let err = Primitive_exceptions.internalToException(raw_err);
+        if (err.RE_EXN_ID === "JsExn") {
+          let msg = `EventLog.append(` + idStr + `): EventTopic.publish Error: ` + Stdlib_Option.getOr(Stdlib_JsExn.message(err._1), "no error message given");
+          return {
+            TAG: "Error",
+            _0: msg
+          };
+        }
+        throw err;
+      }
+    };
+    let append = async (sequenceNr, id, events$p) => {
+      let eventsJson = encodeEvents$p(events$p, id, sequenceNr);
+      let idStr = Spec.Id.toString(id);
+      let storageEffect = Effect$1.retry(Effect$1.flatMap(Effect.tryPromise(err => Util_Error$ReventlessCore.messageFromUnknown(err, "storage error"), () => Ops.storage.append(sequenceNr, idStr, eventsJson)), result => {
+        if (result.TAG === "Ok") {
+          return Effect$1.succeed();
+        } else {
+          return Effect$1.fail(result._0);
+        }
+      }), storageRetrySchedule);
+      let exit = await Effect$1.runPromiseExit(storageEffect);
+      if (Exit$1.isSuccess(exit)) {
+        return await publishToEventTopic(id, events$p, eventsJson);
+      }
+      let failMsg = Exit.match(exit, cause => Cause.pretty(cause), () => "storage error");
+      if (failMsg.includes("conflict")) {
+        return {
+          TAG: "Error",
+          _0: "conflict"
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: `EventLog: Error: Couldn't append for ` + Spec.name + `(` + idStr + `): ` + failMsg
+        };
+      }
+    };
+    let decodeEvent = (id, json) => {
+      try {
+        return Message$ReventlessCore.decode(Stdlib_Option.getOrThrow(Stdlib_Option.map(Stdlib_JSON.Decode.object(json), dict => {
+          let match = dict["event"];
+          let match$1 = dict["data"];
+          if (typeof match === "string") {
+            if (match$1 !== undefined) {
+              if (typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
+                return Message$ReventlessCore.combineMessage(match, match$1);
+              } else {
+                return Stdlib_JsError.throwWithMessage("event type or data incorrect");
+              }
+            } else {
+              return Message$ReventlessCore.combineMessage(match, {});
+            }
+          } else {
+            return Stdlib_JsError.throwWithMessage("event type or data incorrect");
+          }
+        }), undefined), Spec.eventSchema);
+      } catch (raw_e) {
+        let e = Primitive_exceptions.internalToException(raw_e);
+        if (e.RE_EXN_ID === "JsExn") {
+          let eventStr = JSON.stringify(json);
+          let message = Util_Error$ReventlessCore.message(undefined, e._1);
+          return Stdlib_JsError.throwWithMessage(`EventLog.replay: Error: id:` + id + `: Couldn't decode ` + eventStr + `: ` + message);
+        }
+        throw e;
+      }
+    };
+    let replay = async id => {
+      let eventsJson = await Ops.storage.replay(Spec.Id.toString(id));
+      let id$1 = Spec.Id.toString(id);
+      return eventsJson.map(json => decodeEvent(id$1, json));
+    };
+    let replayStream = id => Stream.mapEffect(Ops.storage.replayStream(Spec.Id.toString(id)), json => Effect$1.sync(() => decodeEvent(Spec.Id.toString(id), json)));
+    let appendStream = (startingSeqNr, id, stream) => Ops.storage.appendStream(startingSeqNr, Spec.Id.toString(id), Stream.map(stream, event => {
+      let json = Message$ReventlessCore.encode(event, Spec.eventSchema);
+      let match = Message$ReventlessCore.splitMessage(json);
+      return Object.fromEntries([
+        [
+          "event",
+          match[0]
+        ],
+        [
+          "data",
+          match[1]
+        ]
+      ]);
+    }));
+    return {
+      Spec: Spec,
+      append: append,
+      replay: replay,
+      replayStream: replayStream,
+      appendStream: appendStream
+    };
+  };
+}
+
+export {
+  isTransient,
+  storageRetrySchedule,
+  Make,
+}
+/* storageRetrySchedule Not a pure module */