@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/CommandGenerator/InboundTranslationResolvers_GraphQL.res

@@ -0,0 +1,76 @@
+// GraphQL mutation resolvers for in-memory InboundTranslationSlices.
+// Registers one GraphQL mutation field per InboundTranslationSlice.
+// Each resolver calls `receive(argsJson)` directly — the InboundTranslationSlice
+// handles parsing, validation, translation, and command publishing internally.
+
+@@warning("-44")
+open ReventlessCore
+
+// Mutable registry: fieldName → receive function.
+// Pre-populated synchronously in Phase 1 via a queuing forwarder so callers
+// (e.g. PlatformInspector's onPlatformDeployedHook) can invoke receive before
+// Phase 2 bindReceive runs. Calls park in a Promise queue and drain once bound.
+let receiveRegistry: dict<JSON.t => promise<result<array<string>, string>>> = Dict.make()
+
+type pendingCall = {
+  inputJson: JSON.t,
+  resolve: result<array<string>, string> => unit,
+}
+
+// Per-field pending-call queues — drained when bindReceive fires.
+let pendingQueueRegistry: dict<ref<array<pendingCall>>> = Dict.make()
+
+// Phase 1: Register SDL + resolver stub synchronously (before server starts).
+// Also pre-registers a queuing forwarder in receiveRegistry so callers can
+// invoke receive immediately; calls are parked until bindReceive drains them.
+let register = (~fieldName: string, ~externalInputSchema: S.t<unknown>, ~server: GraphQL_ServerInstance.t) => {
+  let sdlFields = switch GraphQL_FragmentGenerator.deriveMutationFieldFromObject(
+    ~fieldName,
+    ~collectedTypes=[],
+    ~seenTypes=Set.make(),
+    externalInputSchema,
+  ) {
+  | Some(field) => [field]
+  | None => [`  ${fieldName}: String!`]
+  }
+
+  // Queue of pending calls when receive is not yet bound.
+  let pendingQueue: ref<array<pendingCall>> = ref([])
+  pendingQueueRegistry->Dict.set(fieldName, pendingQueue)
+
+  // Queuing forwarder: parks calls until bindReceive populates receiveRegistry.
+  let queuingReceive = (inputJson: JSON.t) =>
+    Promise.make((resolve, _reject) => {
+      pendingQueue.contents->Array.push({inputJson, resolve})
+    })
+  receiveRegistry->Dict.set(fieldName, queuingReceive)
+
+  let resolver: GraphQL_ServerInstance.resolverFn = async (_root, args, _ctx) => {
+    let inputJson: JSON.t = args->Obj.magic
+    let receive = receiveRegistry->Dict.getUnsafe(fieldName)
+    let result = await receive(inputJson)
+    switch result {
+    | Ok(targetIds) => targetIds->Array.map(JSON.Encode.string)->JSON.Encode.array
+    | Error(msg) => msg->JSON.Encode.string
+    }
+  }
+
+  let resolvers = Dict.make()
+  resolvers->Dict.set(fieldName, resolver)
+  server.registerMutations(~sdlFields, ~resolvers)
+}
+
+// Phase 2: Bind the real receive function once Output.apply resolves.
+// Replaces the queuing forwarder in receiveRegistry and drains pending calls.
+let bindReceive = (~fieldName: string, ~receive: JSON.t => promise<result<array<string>, string>>) => {
+  receiveRegistry->Dict.set(fieldName, receive)
+  switch pendingQueueRegistry->Dict.get(fieldName) {
+  | Some(pendingQueue) =>
+    let pending = pendingQueue.contents
+    pendingQueue.contents = []
+    pending->Array.forEach(({inputJson, resolve}) => {
+      let _ = receive(inputJson)->Promise.thenResolve(result => resolve(result))
+    })
+  | None => ()
+  }
+}

package/src/adapter/CommandGenerator/InboundTranslationResolvers_GraphQL.res.mjs

@@ -0,0 +1,57 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+
+let receiveRegistry = {};
+
+let pendingQueueRegistry = {};
+
+function register(fieldName, externalInputSchema, server) {
+  let field = GraphQL_FragmentGenerator$ReventlessCore.deriveMutationFieldFromObject(fieldName, [], new Set(), externalInputSchema);
+  let sdlFields = field !== undefined ? [field] : [`  ` + fieldName + `: String!`];
+  let pendingQueue = {
+    contents: []
+  };
+  pendingQueueRegistry[fieldName] = pendingQueue;
+  let queuingReceive = inputJson => new Promise((resolve, _reject) => {
+    pendingQueue.contents.push({
+      inputJson: inputJson,
+      resolve: resolve
+    });
+  });
+  receiveRegistry[fieldName] = queuingReceive;
+  let resolver = async (_root, args, _ctx) => {
+    let receive = receiveRegistry[fieldName];
+    let result = await receive(args);
+    if (result.TAG === "Ok") {
+      return result._0.map(prim => prim);
+    } else {
+      return result._0;
+    }
+  };
+  let resolvers = {};
+  resolvers[fieldName] = resolver;
+  server.registerMutations(sdlFields, resolvers);
+}
+
+function bindReceive(fieldName, receive) {
+  receiveRegistry[fieldName] = receive;
+  let pendingQueue = pendingQueueRegistry[fieldName];
+  if (pendingQueue === undefined) {
+    return;
+  }
+  let pending = pendingQueue.contents;
+  pendingQueue.contents = [];
+  pending.forEach(param => {
+    let resolve = param.resolve;
+    receive(param.inputJson).then(result => resolve(result));
+  });
+}
+
+export {
+  receiveRegistry,
+  pendingQueueRegistry,
+  register,
+  bindReceive,
+}
+/* GraphQL_FragmentGenerator-ReventlessCore Not a pure module */

package/src/adapter/CommandGenerator/LocalCommandGeneratorResolvers.res

@@ -0,0 +1,19 @@
+// No-op CommandGenerator resolvers for in-memory (no AppSync).
+
+open ReventlessCore
+
+type api = unit
+type runtimeParts = LocalRuntimeEnvironment.parts
+
+let handleResolversEvent = (generateCommand: CommandGenerator.commandGenerator) =>
+  Pulumi.Output.make((event, _context) => event->generateCommand)
+
+let make: CommandGenerator_Adapter.resolversMaker<unit, runtimeParts> = (
+  ~name as _,
+  ~api as _,
+  ~fields as _,
+  ~commandSchema as _,
+  ~runtime as _,
+  ~resources as _,
+  ~opts as _,
+) => {resources: []}

package/src/adapter/CommandGenerator/LocalCommandGeneratorResolvers.res.mjs

@@ -0,0 +1,19 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+
+function handleResolversEvent(generateCommand) {
+  return Pulumi.output((event, _context) => generateCommand(event));
+}
+
+function make(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return {
+    resources: []
+  };
+}
+
+export {
+  handleResolversEvent,
+  make,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/adapter/CommandTopic/LocalCommandTopicChannel.res

@@ -0,0 +1,104 @@
+// In-memory CommandTopic channel.
+// publishJsons encodes each command as {id, meta, command} (full message body) and dispatches via Bus.
+// connect wires the channel to the runtime handler via Bus.registerCommandHandler.
+// The full body format matches what CommandTopic_Callback.handleJsonCommands expects to decode.
+
+module Make = (Bus: LocalBus.T) => {
+  type callbackEvent = JSON.t
+  type runtimeParts = LocalRuntimeEnvironment.parts
+  type channelParts = {name: string}
+
+  // Extract aggregate id (used as reference) from the full message body
+  let decodeId = (body: JSON.t): string =>
+    switch body {
+    | JSON.Object(d) =>
+      d
+      ->Dict.get("id")
+      ->Option.flatMap(j =>
+        switch j {
+        | JSON.String(s) => Some(s)
+        | _ => None
+        }
+      )
+      ->Option.getOr("")
+    | _ => ""
+    }
+
+  let make: ReventlessCore.CommandTopic_Adapter.channelMaker<
+    callbackEvent,
+    'context,
+    channelParts,
+    runtimeParts,
+  > = (~name, ~opts as _=?) => {
+    // Captured when handleChannelEvent is called; used by publishJsonsAndWait to
+    // run the handler inline and collect typed outcomes without going through the bus.
+    let handleCmdsRef: ref<
+      option<ReventlessCore.CommandTopic.jsonCommandsHandler>,
+    > = ref(None)
+
+    let publishJsons: ReventlessInfra.CommandTopic.publishJsons = async jsons => {
+      let _ =
+        await jsons
+        ->Array.map(async (cmdJson: Reventless.Message.commandJson) => {
+          await Bus.dispatchCommand(name, ReventlessCore.CommandTopic.encodeCommandJson(cmdJson))
+        })
+        ->Promise.all
+    }
+
+    let publishJsonsStream: ReventlessInfra.CommandTopic.publishJsonsStream = stream =>
+      stream
+      ->Stream.grouped(10)
+      ->Stream.runForEach(jsons => Effect.promise(() => publishJsons(jsons)))
+
+    let publishJsonsAndWait: ReventlessCore.CommandTopic.publishJsonsAndWait = async jsons => {
+      switch handleCmdsRef.contents {
+      | None =>
+        // Handler not yet registered — fall back to fire-and-forget, return Pending
+        let _ = await publishJsons(jsons)
+        jsons->Array.map(cmdJson =>
+          ReventlessCore.CommandTopic.Pending({msgId: cmdJson.meta.msgId})
+        )
+      | Some(handleCmds) =>
+        await ReventlessCore.CommandTopic.runInlineAndCollect(jsons, handleCmds)
+      }
+    }
+
+    let handleChannelEvent = (
+      handleCmds: ReventlessCore.CommandTopic.jsonCommandsHandler,
+    ): Pulumi.Output.t<ReventlessCore.Runtime.effectHandler<callbackEvent, 'context, unit, string>> => {
+      handleCmdsRef.contents = Some(handleCmds)
+      (
+        (fullBody: JSON.t, _ctx) => {
+          // Pass the full body as `command` — that's what handleJsonCommands decodes
+          let reference = decodeId(fullBody)
+          let item: ReventlessInfra.CommandTopic.topicItem<JSON.t> = {command: fullBody, reference}
+          handleCmds(Stream.fromIterable([item]))->Effect.map(_ => ())
+        }
+      )->Pulumi.Output.make
+    }
+
+    let connect: ReventlessCore.CommandTopic_Adapter.connect<
+      callbackEvent,
+      'context,
+      channelParts,
+      runtimeParts,
+    > = (~name as _, ~channel, ~runtime, ~resources as _, ~opts as _) => {
+      Bus.registerCommandHandler(channel.parts.name, async (json, ctx) => {
+        let handler =
+          await runtime.parts.handlerDeferred->Deferred.await_->Effect.runPromise
+        await handler(json, ctx)
+      })
+      []
+    }
+
+    {
+      parts: {name: name},
+      resources: [],
+      publishJsons: publishJsons->Pulumi.Output.make,
+      publishJsonsStream: publishJsonsStream->Pulumi.Output.make,
+      publishJsonsAndWait: Some(publishJsonsAndWait)->Pulumi.Output.make,
+      handleChannelEvent,
+      connect,
+    }
+  }
+}

package/src/adapter/CommandTopic/LocalCommandTopicChannel.res.mjs

@@ -0,0 +1,82 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Deferred from "effect/Deferred";
+import * as CommandTopic$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic.res.mjs";
+
+function Make(Bus) {
+  let decodeId = body => {
+    if (typeof body === "object" && body !== null && !Array.isArray(body)) {
+      return Stdlib_Option.getOr(Stdlib_Option.flatMap(body["id"], j => {
+        if (typeof j === "string") {
+          return j;
+        }
+      }), "");
+    } else {
+      return "";
+    }
+  };
+  let make = (name, param) => {
+    let handleCmdsRef = {
+      contents: undefined
+    };
+    let publishJsons = async jsons => {
+      await Promise.all(jsons.map(async cmdJson => await Bus.dispatchCommand(name, CommandTopic$ReventlessCore.encodeCommandJson(cmdJson))));
+    };
+    let publishJsonsStream = stream => Stream$1.runForEach(Stream.grouped(stream, 10), jsons => Effect.promise(() => publishJsons(jsons)));
+    let publishJsonsAndWait = async jsons => {
+      let handleCmds = handleCmdsRef.contents;
+      if (handleCmds !== undefined) {
+        return await CommandTopic$ReventlessCore.runInlineAndCollect(jsons, handleCmds);
+      } else {
+        await publishJsons(jsons);
+        return jsons.map(cmdJson => ({
+          TAG: "Pending",
+          msgId: cmdJson.meta.msgId
+        }));
+      }
+    };
+    let handleChannelEvent = handleCmds => {
+      handleCmdsRef.contents = handleCmds;
+      return Pulumi.output((fullBody, _ctx) => {
+        let reference = decodeId(fullBody);
+        let item = {
+          command: fullBody,
+          reference: reference
+        };
+        return Effect.map(handleCmds(Stream$1.fromIterable([item])), param => {});
+      });
+    };
+    let connect = (param, channel, runtime, param$1, param$2) => {
+      Bus.registerCommandHandler(channel.parts.name, async (json, ctx) => {
+        let handler = await Effect.runPromise(Deferred.await(runtime.parts.handlerDeferred));
+        return await handler(json, ctx);
+      });
+      return [];
+    };
+    return {
+      parts: {
+        name: name
+      },
+      resources: [],
+      publishJsons: Pulumi.output(publishJsons),
+      publishJsonsStream: Pulumi.output(publishJsonsStream),
+      publishJsonsAndWait: Pulumi.output(publishJsonsAndWait),
+      handleChannelEvent: handleChannelEvent,
+      connect: connect
+    };
+  };
+  return {
+    decodeId: decodeId,
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* Stream Not a pure module */

package/src/adapter/CommandTopic/LocalCommandTopicRemoteChannel.res

@@ -0,0 +1,32 @@
+// In-memory CommandTopic remote channel — satisfies CommandTopic_Adapter.RemoteChannel.
+// Dispatches "remote" commands directly to the in-memory Bus.
+
+module Make = (Bus: LocalBus.T) => {
+  let make: ReventlessCore.CommandTopic_Adapter.remoteChannelMaker = resources => {
+    resources,
+    remotePublish: async jsons => {
+      let _ =
+        await jsons
+        ->Array.map(async (cmdJson: Reventless.Message.commandJson) => {
+          // Encode the same way LocalCommandTopicChannel does
+          let body = JSON.Encode.object(
+            Dict.fromArray([
+              ("id", JSON.Encode.string(cmdJson.id)),
+              (
+                "meta",
+                cmdJson.meta->S.reverseConvertToJsonOrThrow(Reventless.Message.metaSchema),
+              ),
+              ("command", cmdJson.commandJson),
+            ]),
+          )
+          // Dispatch to the first resource's name (the channel name)
+          let channelName = switch resources {
+          | [] => ""
+          | resources => (resources->Array.getUnsafe(0)).name
+          }
+          await Bus.dispatchCommand(channelName, body)
+        })
+        ->Promise.all
+    },
+  }
+}

package/src/adapter/CommandTopic/LocalCommandTopicRemoteChannel.res.mjs

@@ -0,0 +1,38 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+
+function Make(Bus) {
+  let make = resources => ({
+    resources: resources,
+    remotePublish: async jsons => {
+      await Promise.all(jsons.map(async cmdJson => {
+        let body = Object.fromEntries([
+          [
+            "id",
+            cmdJson.id
+          ],
+          [
+            "meta",
+            S.reverseConvertToJsonOrThrow(cmdJson.meta, Message$Reventless.metaSchema)
+          ],
+          [
+            "command",
+            cmdJson.commandJson
+          ]
+        ]);
+        let channelName = resources.length !== 0 ? resources[0].name : "";
+        return await Bus.dispatchCommand(channelName, body);
+      }));
+    }
+  });
+  return {
+    make: make
+  };
+}
+
+export {
+  Make,
+}
+/* S Not a pure module */

package/src/adapter/Counter/LocalCounterHandler.res

@@ -0,0 +1,42 @@
+// In-memory counter handler — tracks counter values in module-level dicts.
+// Deduplicates: a given (counterId, targetRef) pair is only counted once.
+//
+// Call LocalCounterHandler.reset() in beforeEach to isolate tests.
+
+open ReventlessCore
+
+let counterStore: ref<dict<int>> = ref(Dict.make())
+let targetRefStore: ref<dict<bool>> = ref(Dict.make())
+
+let make: Counter_Adapter.handlerMaker = (
+  ~name as _,
+  ~referencesName as _,
+  ~referencesDb as _,
+  ~countsName as _,
+  ~countsDb as _,
+  ~counterHandler as _,
+  ~specModulePath as _,
+  ~mappingsModulePath as _,
+  ~publishChannelId as _,
+  ~opts as _,
+) => {
+  addToCounterTarget: async ({ReventlessInfra.Counter.counterId, target, targetRef}) => {
+    let refKey = counterId ++ ":" ++ targetRef
+    switch targetRefStore.contents->Dict.get(refKey) {
+    | Some(_) => () // Already counted this (counterId, targetRef) pair — skip
+    | None =>
+      targetRefStore.contents->Dict.set(refKey, true)
+      let current = counterStore.contents->Dict.get(counterId)->Option.getOr(0)
+      counterStore.contents->Dict.set(counterId, current + target)
+    }
+  },
+}
+
+// Returns the current count for a given counterId.
+let getCount = counterId => counterStore.contents->Dict.get(counterId)->Option.getOr(0)
+
+// Reset all counters — call in beforeEach for test isolation.
+let reset = () => {
+  counterStore.contents = Dict.make()
+  targetRefStore.contents = Dict.make()
+}

package/src/adapter/Counter/LocalCounterHandler.res.mjs

@@ -0,0 +1,45 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let counterStore = {
+  contents: {}
+};
+
+let targetRefStore = {
+  contents: {}
+};
+
+function make(param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8, param$9) {
+  return {
+    addToCounterTarget: async param => {
+      let counterId = param.counterId;
+      let refKey = counterId + ":" + param.targetRef;
+      let match = targetRefStore.contents[refKey];
+      if (match !== undefined) {
+        return;
+      }
+      targetRefStore.contents[refKey] = true;
+      let current = Stdlib_Option.getOr(counterStore.contents[counterId], 0);
+      counterStore.contents[counterId] = current + param.target | 0;
+    }
+  };
+}
+
+function getCount(counterId) {
+  return Stdlib_Option.getOr(counterStore.contents[counterId], 0);
+}
+
+function reset() {
+  counterStore.contents = {};
+  targetRefStore.contents = {};
+}
+
+export {
+  counterStore,
+  targetRefStore,
+  make,
+  getCount,
+  reset,
+}
+/* No side effect */

package/src/adapter/DcbEventLog/DcbEventLogStorage_InMemory.res

@@ -0,0 +1,131 @@
+// In-memory DCB event log storage.
+// Mirrors the mock storage in packages/reventless/tests/dcb/DcbFixtures.res
+
+open ReventlessCore
+
+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 makeStorage = (~name as _name, ~indexes as _, ~partitionTag as _, ~opts as _) => {
+  let events: ref<array<DcbEventLog_Adapter.rawSequencedEvent>> = ref([])
+  let position = 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=?) => {
+    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)
+    }
+  }
+
+  // ~strongConsistency is a DynamoDB read-replica concept; the in-memory backend
+  // is always consistent, so it is accepted (interface parity) and ignored.
+  let readStream = (~query, ~after=?, ~strongConsistency as _=?) =>
+    Effect.promise(() => read(~query, ~after?))
+    ->Effect.map(result => result.events)
+    ->Stream.fromEffect
+    ->Stream.flatMap(arr => Stream.fromIterable(arr))
+
+  (
+    _name,
+    read,
+    {
+      DcbEventLog_Adapter.resources: [],
+      operations: Pulumi.Output.make({DcbEventLog_Adapter.read, append, readStream}),
+    },
+  )
+}
+
+// Local backends evaluate the DCB condition literally against the event list
+// (true DCB semantics), so a single-tag clause already matches every carrier of
+// the tag regardless of partition — cross-partition reads work without special
+// routing. The flag is accepted for interface parity and ignored.
+let make: DcbEventLog_Adapter.storageMaker = (~name, ~indexes, ~partitionTag, ~crossPartitionTagKeys as _=?, ~opts) => {
+  let (_, _, storage) = makeStorage(~name, ~indexes, ~partitionTag, ~opts)
+  storage
+}
+
+module Make = (Bus: LocalBus.T) => {
+  let make: DcbEventLog_Adapter.storageMaker = (~name, ~indexes, ~partitionTag, ~crossPartitionTagKeys as _=?, ~opts) => {
+    switch BackendState.getDb() {
+    | Some(db) =>
+      let (storageName, read, storage) = DcbEventLogStorage_Sqlite.makeStorage(
+        ~db,
+        ~bus=(_, _) => (),
+        ~publishToTopic=(~topicName as _, ~json as _) => (),
+        ~name,
+        ~indexes,
+        ~partitionTag,
+        ~opts,
+      )
+      Bus.registerDcbEventLogRead(storageName, read)
+      storage
+    | None =>
+      let (storageName, read, storage) = makeStorage(~name, ~indexes, ~partitionTag, ~opts)
+      Bus.registerDcbEventLogRead(storageName, read)
+      storage
+    }
+  }
+}