@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -0,0 +1,299 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+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$1 from "effect/Stream";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Lru$ReventlessCore from "../../util/Lru.res.mjs";
+import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
+import * as Message$ReventlessCore from "../../Message.res.mjs";
+import * as Metrics$ReventlessCore from "../../util/Metrics.res.mjs";
+import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
+import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
+import * as CommandTopic_Helpers$ReventlessCore from "../CommandTopic/CommandTopic_Helpers.res.mjs";
+
+function Make(Spec) {
+  return Behavior => {
+    let comp = `StateChangeSlice(` + Spec.name + `)`;
+    let decoder = DcbDecode$Reventless.makeDecoder(Spec.consumedEventSchema);
+    let queryEventTypes = decoder.eventTypes;
+    let derivedPartitionTag = DcbTag$Reventless.derivePartitionTag([[
+        Spec.name,
+        Behavior.moduleUrl,
+        Spec.eventSchema
+      ]]);
+    let readEventId = tags => {
+      let ownTagValues = () => {
+        let vals = Stdlib_Array.reduce(tags.filter(t => t.key !== "originatorSlice"), [], (acc, t) => {
+          if (acc.includes(t.value)) {
+            return acc;
+          } else {
+            return acc.concat([t.value]);
+          }
+        });
+        if (vals.length === 0) {
+          return;
+        } else {
+          return vals.join(",");
+        }
+      };
+      if (derivedPartitionTag.TAG !== "Simple") {
+        return DcbTag$Reventless.getCompositePartitionKeyValue(tags, derivedPartitionTag._0);
+      }
+      let pt = derivedPartitionTag._0;
+      let v = Stdlib_Array.findMap(tags, t => {
+        if (t.key === pt.key) {
+          return t.value;
+        }
+      });
+      if (v !== undefined) {
+        return v;
+      } else {
+        return ownTagValues();
+      }
+    };
+    let projectionCache = Lru$ReventlessCore.make(100);
+    let resetCache = () => Lru$ReventlessCore.clear(projectionCache);
+    let handleSingleCommand = (tagKeysByEventType, crossPartitionTagKeys, dcbEventLog, command$p) => {
+      let cmdJson = Message$ReventlessCore.commandJsonOfCommand$p(Id$Reventless.$$String.toString, Spec.commandSchema, command$p);
+      Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, cmdJson.commandJson, `handling command: ` + LogFormat$ReventlessCore.cmdDetailNoId(cmdJson)));
+      let query = DcbTag$Reventless.buildQueryFromCommand(queryEventTypes, Spec.commandSchema, command$p.command, tagKeysByEventType, crossPartitionTagKeys);
+      let queryDetail = query.map(qi => {
+        let ts = qi.eventTypes;
+        let types = ts !== undefined ? ts.map(LogFormat$ReventlessCore.bold).join("|") : "*";
+        let ts$1 = qi.tags;
+        let tags = ts$1 !== undefined ? ts$1.map(t => t.key + `=` + t.value).join(",") : "";
+        if (tags === "") {
+          return types;
+        } else {
+          return types + `{` + tags + `}`;
+        }
+      }).join(" OR ");
+      Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, undefined, `query: ` + queryDetail));
+      let entityId;
+      if (derivedPartitionTag.TAG === "Simple") {
+        entityId = DcbTag$Reventless.getPartitionTagValue(query, derivedPartitionTag._0);
+      } else {
+        let tags = DcbTag$Reventless.extractTags(Spec.commandSchema, command$p.command);
+        entityId = DcbTag$Reventless.getCompositePartitionKeyValue(tags, derivedPartitionTag._0);
+      }
+      let cacheKey = Stdlib_Option.getOr(JSON.stringify(query), "");
+      let seed = {
+        contents: Lru$ReventlessCore.get(projectionCache, cacheKey)
+      };
+      let attempt = retries => {
+        let match = seed.contents;
+        let match$1 = match !== undefined ? [
+            match[0],
+            match[1]
+          ] : [
+            Behavior.initialState,
+            undefined
+          ];
+        let afterPos = match$1[1];
+        let cacheHit = Stdlib_Option.isSome(seed.contents);
+        let strongConsistency;
+        switch (Spec.readConsistency) {
+          case "EscalateOnRetry" :
+            strongConsistency = retries < 3;
+            break;
+          case "AlwaysStrong" :
+            strongConsistency = true;
+            break;
+          case "AlwaysEventual" :
+            strongConsistency = false;
+            break;
+        }
+        return Effect.flatMap(Effect.tap(Stream$1.runFold(Stream$1.flatMap(Stream$1.map(dcbEventLog.readStream(query, afterPos, strongConsistency), raw => {
+          let decoded = decoder.decode(raw.eventType, Stdlib_Option.getOr(Stdlib_JSON.Decode.object(raw.data), {}));
+          return Stdlib_Option.map(decoded, event => [
+            event,
+            raw.position,
+            raw.eventType,
+            readEventId(raw.tags)
+          ]);
+        }), opt => {
+          if (opt !== undefined) {
+            return Stream$1.fromIterable([opt]);
+          } else {
+            return Stream$1.empty;
+          }
+        }), [
+          match$1[0],
+          afterPos,
+          []
+        ], (param, param$1) => {
+          let eventId = param$1[3];
+          let eventType = param$1[2];
+          return [
+            Behavior.evolve(param[0], param$1[0]),
+            param$1[1],
+            param[2].concat([eventId !== undefined ? LogFormat$ReventlessCore.bold(eventType) + `(` + eventId + `)` : LogFormat$ReventlessCore.bold(eventType)])
+          ];
+        }), param => {
+          let reads = param[2];
+          return EffectLogger$ReventlessCore.logInfo(comp, undefined, `read` + (
+            cacheHit ? " (cached, delta)" : ""
+          ) + `: ` + reads.length.toString() + ` event(s)` + (
+            reads.length === 0 ? "" : ` [` + reads.join(", ") + `]`
+          ));
+        }), param => {
+          let headPosition = param[1];
+          let state = param[0];
+          return Effect.flatMap(EffectLogger$ReventlessCore.logDebug(comp, undefined, `deciding on state: ` + Stdlib_Option.getOr(JSON.stringify(state), "<unserializable>")), () => {
+            let newEvents = Behavior.decide(state, command$p.command);
+            if (newEvents.TAG === "Ok") {
+              let newEvents$1 = newEvents._0;
+              if (newEvents$1.length === 0) {
+                Lru$ReventlessCore.put(projectionCache, cacheKey, [
+                  state,
+                  headPosition
+                ]);
+                CommandTopic_Helpers$ReventlessCore.reportAccepted(cmdJson.meta.msgId, entityId !== undefined ? ({
+                    entityId: entityId,
+                    eventCount: 0
+                  }) : ({
+                    eventCount: 0
+                  }));
+                return Effect.map(EffectLogger$ReventlessCore.logInfo(comp, undefined, "no events produced"), () => ({
+                  TAG: "Ok",
+                  _0: "ok"
+                }));
+              }
+              let rawEvents = newEvents$1.map(e => {
+                let parentMeta = command$p.meta;
+                let json = JSON.parse(Stdlib_Option.getOrThrow(JSON.stringify(e), undefined));
+                let match = Message$ReventlessCore.splitMessage(json);
+                let eventType = match[0];
+                let baseTags = DcbTag$Reventless.extractTagsExpanded(Spec.eventSchema, e);
+                let keys = tagKeysByEventType[eventType];
+                let indexedTags = keys !== undefined ? baseTags.filter(t => keys.includes(t.key)) : baseTags;
+                let tags = indexedTags.concat([{
+                    key: "originatorSlice",
+                    value: Spec.name
+                  }]);
+                let meta = Message$ReventlessCore.deriveMeta(parentMeta, undefined);
+                return {
+                  eventType: eventType,
+                  data: match[1],
+                  tags: tags,
+                  meta: meta
+                };
+              });
+              let eventCount = rawEvents.length.toString();
+              let eventDetails = rawEvents.map(e => {
+                let dict = e.data;
+                let fields;
+                if (typeof dict === "object" && dict !== null && !Array.isArray(dict)) {
+                  let f = Object.entries(dict).map(param => param[0] + `:` + JSON.stringify(param[1])).join(",");
+                  fields = f === "" ? "" : `({` + f + `})`;
+                } else {
+                  fields = "";
+                }
+                return LogFormat$ReventlessCore.bold(e.eventType) + fields;
+              }).join(", ");
+              let eventJsons = rawEvents.map(e => e.data);
+              let condition = {
+                query: query,
+                after: headPosition
+              };
+              return Effect.flatMap(Effect.flatMap(EffectLogger$ReventlessCore.logInfo(comp, eventJsons, `produced ` + eventCount + ` event(s): [` + eventDetails + `]`), () => Effect.promise(() => dcbEventLog.append(rawEvents, condition))), appendResult => {
+                if (appendResult.TAG === "Ok") {
+                  Lru$ReventlessCore.put(projectionCache, cacheKey, [
+                    state,
+                    headPosition
+                  ]);
+                  CommandTopic_Helpers$ReventlessCore.reportAccepted(cmdJson.meta.msgId, entityId !== undefined ? ({
+                      entityId: entityId,
+                      eventCount: rawEvents.length
+                    }) : ({
+                      eventCount: rawEvents.length
+                    }));
+                  return Effect.map(EffectLogger$ReventlessCore.logInfo(comp, undefined, `append: ` + eventCount + ` event(s)`), () => ({
+                    TAG: "Ok",
+                    _0: "ok"
+                  }));
+                }
+                let err = appendResult._0;
+                if (retries > 0) {
+                  seed.contents = [
+                    state,
+                    headPosition
+                  ];
+                  Metrics$ReventlessCore.emitCount("AppendRetry", Spec.name, undefined);
+                  return Effect.flatMap(EffectLogger$ReventlessCore.logWarn(comp, undefined, `append failed (retrying ` + ((3 - retries | 0) + 1 | 0).toString() + `/` + (3).toString() + `): ` + err), () => attempt(retries - 1 | 0));
+                }
+                Lru$ReventlessCore.invalidate(projectionCache, cacheKey);
+                let errorCode = err.startsWith("Conflict") ? "Conflict" : "AppendFailed";
+                if (errorCode === "Conflict") {
+                  Metrics$ReventlessCore.emitCount("AppendConflict", Spec.name, undefined);
+                }
+                CommandTopic_Helpers$ReventlessCore.reportRejected(cmdJson.meta.msgId, {
+                  errorCode: errorCode,
+                  errorDetail: err
+                });
+                return Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `append failed, retries exhausted: ` + err), () => ({
+                  TAG: "Error",
+                  _0: err
+                }));
+              });
+            }
+            Lru$ReventlessCore.put(projectionCache, cacheKey, [
+              state,
+              headPosition
+            ]);
+            let errorJson = S.reverseConvertToJsonOrThrow(newEvents._0, Spec.errorSchema);
+            let errorCode = Message$ReventlessCore.variantNameOfJson(errorJson);
+            let match = Message$ReventlessCore.splitMessage(errorJson);
+            let payloadDict = match[1];
+            let errorDetail = Object.entries(payloadDict).length === 0 ? "" : JSON.stringify(payloadDict);
+            CommandTopic_Helpers$ReventlessCore.reportRejected(cmdJson.meta.msgId, {
+              errorCode: errorCode,
+              errorDetail: errorDetail
+            });
+            return Effect.map(EffectLogger$ReventlessCore.logError(comp, undefined, `decide rejected: ` + errorCode + ` ` + errorDetail), () => ({
+              TAG: "Ok",
+              _0: "rejected"
+            }));
+          });
+        });
+      };
+      return attempt(3);
+    };
+    let handleCommands = (tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, dcbEventLog, stream) => {
+      let tagKeysByEventType = tagKeysByEventTypeOpt !== undefined ? tagKeysByEventTypeOpt : ({});
+      let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+      return Stream.runCollect(Stream$1.mapEffect(stream, param => {
+        let reference = param.reference;
+        return Effect.map(handleSingleCommand(tagKeysByEventType, crossPartitionTagKeys, dcbEventLog, param.command), result => {
+          if (result.TAG === "Ok") {
+            return {
+              TAG: "Ok",
+              _0: reference
+            };
+          } else {
+            return {
+              TAG: "Error",
+              _0: reference
+            };
+          }
+        });
+      }));
+    };
+    return {
+      Spec: Spec,
+      handleCommands: handleCommands,
+      resetCache: resetCache
+    };
+  };
+}
+
+export {
+  Make,
+}
+/* S Not a pure module */

package/src/components/StateTopic.res

@@ -0,0 +1,91 @@
+open ReventlessInfra.Adapter
+
+let componentType = ComponentType.EventTopic
+
+type outputs = {resource: resource}
+
+type t
+type component = Component.t<t, outputs, unit>
+
+module type T = {
+  module Spec: {
+    module Id: Reventless.Id.T
+    let name: string
+    @schema
+    type state
+  }
+
+  let make: (
+    ~name: string,
+    ~opts: Pulumi.ComponentResource.options=?,
+    ~allQueryDbs: QueryDb.allOutputs,
+  ) => component
+}
+
+module Adapter = {
+  type publisher = {resource: resource}
+  type publisherMaker = (
+    ~name: string,
+    ~opts: Pulumi.CustomResourceOptions.t,
+    ~allQueryDbs: QueryDb.allOutputs,
+  ) => publisher
+
+  module type Publisher = {
+    let make: publisherMaker
+  }
+}
+
+module Make = (
+  Spec: {
+    module Id: Reventless.Id.T
+    let name: string
+    @schema
+    type state
+  },
+  Publisher: Adapter.Publisher,
+): (
+  T with module Spec = Spec
+) => {
+  module Spec = Spec
+
+  type constructed
+  type construct = (component, string, QueryDb.allOutputs) => constructed
+
+  @module("./Component") @new
+  external make: (
+    ~componentType: string,
+    ~name: string,
+    ~construct: construct,
+    ~opts: option<Pulumi.ComponentResource.options>,
+    ~allQueryDbs: QueryDb.allOutputs,
+  ) => component = "default"
+
+  @send
+  external registerOutputs: (component, outputs) => constructed = "registerOutputs"
+  @send external setOutputs: (component, outputs) => unit = "setOutputs"
+  let setOutputs = (self, outputs) => {
+    self->setOutputs(outputs)
+    self->registerOutputs(outputs)
+  }
+
+  let construct = (self, name, allQueryDbs) => {
+    let opts = {Pulumi.CustomResourceOptions.parent: self->Component.toPulumiResource}
+
+    let publisher = Publisher.make(
+      ~name=name->ComponentType.name(componentType),
+      ~opts,
+      ~allQueryDbs,
+    )
+
+    self->setOutputs({resource: publisher.resource})
+  }
+
+  let make = (~name, ~opts=?, ~allQueryDbs) =>
+    make(
+      ~componentType=componentType->ComponentType.toString,
+      ~name,
+      ~construct,
+      ~opts,
+      ~allQueryDbs,
+    )
+}

package/src/components/StateTopic.res.mjs

@@ -0,0 +1,41 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import Component from "./Component";
+import * as Component$ReventlessCore from "./Component.res.mjs";
+import * as ComponentType$ReventlessCore from "../ComponentType.res.mjs";
+
+let Adapter = {};
+
+function Make(Spec) {
+  return Publisher => {
+    let construct = (self, name, allQueryDbs) => {
+      let opts_parent = Component$ReventlessCore.toPulumiResource(self);
+      let opts = {
+        parent: opts_parent
+      };
+      let publisher = Publisher.make(ComponentType$ReventlessCore.name(name, "EventTopic"), opts, allQueryDbs);
+      let outputs = {
+        resource: publisher.resource
+      };
+      self.setOutputs(outputs);
+      return self.registerOutputs(outputs);
+    };
+    let make = (name, opts, allQueryDbs) => {
+      let prim0 = ComponentType$ReventlessCore.toString("EventTopic");
+      return new Component(prim0, name, construct, opts, allQueryDbs);
+    };
+    return {
+      Spec: Spec,
+      make: make
+    };
+  };
+}
+
+let componentType = "EventTopic";
+
+export {
+  componentType,
+  Adapter,
+  Make,
+}
+/* ./Component Not a pure module */

package/src/components/StateViewSlice/StateViewSlice.res

@@ -0,0 +1,33 @@
+let componentType = ComponentType.StateViewSlice
+
+type t = ReventlessInfra.StateViewSlice.t
+type outputs = ReventlessInfra.StateViewSlice.outputs
+type operations = ReventlessInfra.StateViewSlice.operations
+type component = Component.t<t, outputs, operations>
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.StateViewSlice.resolvedOutputs> =>
+  (
+    outputs.resources->Adapter.resourcesToInterop,
+    outputs.queryDb.resources->Adapter.resourcesToInterop,
+  )
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.apply(((resources, queryDbResources)) => {
+    let resolved: ReventlessInterop.StateViewSlice.resolvedOutputs = {
+      resources: resources,
+      queryDb: {resources: queryDbResources},
+    }
+    resolved
+  })
+
+module type T = {
+  module Spec: Reventless.StateViewSlice.Spec
+  module Projection: Reventless.StateViewSlice.Projection with module Spec := Spec
+  type component = Component.t<t, outputs, operations>
+
+  let make: (
+    ~dcbEventLog: DcbEventLog.component,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/StateViewSlice/StateViewSlice.res.mjs

@@ -0,0 +1,24 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+
+function toResolvedOutputs(outputs) {
+  return Pulumi.all([
+    Adapter$ReventlessCore.resourcesToInterop(outputs.resources),
+    Adapter$ReventlessCore.resourcesToInterop(outputs.queryDb.resources)
+  ]).apply(param => ({
+    resources: param[0],
+    queryDb: {
+      resources: param[1]
+    }
+  }));
+}
+
+let componentType = "StateViewSlice";
+
+export {
+  componentType,
+  toResolvedOutputs,
+}
+/* @pulumi/pulumi Not a pure module */

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -0,0 +1,176 @@
+// Capture the framework's Projection module before the inner functor arg shadows it.
+module FrameworkProjection = Projection
+
+module Make = (
+  RuntimeEnvironment: Runtime.Environment,
+  QueryDbStorage: QueryDb_Adapter.Storage,
+  QueryDbResolvers: QueryDb_Adapter.Resolvers
+    with type api = QueryDbStorage.api
+    and type role = QueryDbStorage.role,
+  EventCollectorChannel: EventCollector_Adapter.Channel
+    with type runtimeParts = RuntimeEnvironment.parts,
+  EventCollectorRuntimeBuilder: EventCollectorRuntime_Builder.T
+    with module EventCollectorChannel = EventCollectorChannel,
+  Api: {
+    let api: unit => QueryDbStorage.api
+    let apiRole: unit => QueryDbStorage.role
+  },
+) => {
+  let finish = EventCollectorRuntimeBuilder.finish
+  module Make = (
+    Spec: Reventless.StateViewSlice.Spec,
+    Projection: Reventless.StateViewSlice.Projection with module Spec := Spec,
+  ): StateViewSlice.T => {
+    module Spec = Spec
+    module Projection = Projection
+    type component = StateViewSlice.component
+
+    module SvQueryDbSpec = {
+      module Id = Reventless.Id.String
+      let name = Spec.name
+      let moduleUrl: string = %raw(`import.meta.url`)
+      type state = Spec.state
+      let stateSchema = Spec.stateSchema
+      let config = Spec.config
+      let subIdConfig = Spec.subIdConfig
+      let authorization = Spec.authorization
+      let visibility = Spec.visibility
+    }
+
+    module SpecificQueryDb = QueryDb_Builder.Make(SvQueryDbSpec, QueryDbStorage, QueryDbResolvers)
+    module SpecificEventCollector = EventCollector_Builder.Make(RuntimeEnvironment, EventCollectorChannel)
+
+    let toProjectionOps = (ops: SpecificQueryDb.operations): QueryDb.operations<string, Spec.state> => {
+      load: id => ops.load(id->Reventless.Id.String.makeFromString),
+      loadStream: id => ops.loadStream(id->Reventless.Id.String.makeFromString),
+      save: (id, s, sm, ttl) => ops.save(id->Reventless.Id.String.makeFromString, s, sm, ttl),
+      saveBatch: batch =>
+        ops.saveBatch(
+          batch->Array.map(((id, s, ttl)) => (id->Reventless.Id.String.makeFromString, s, ttl)),
+        ),
+      count: (id, f, n) => ops.count(id->Reventless.Id.String.makeFromString, f, n),
+      delete: (id, sub) => ops.delete(id->Reventless.Id.String.makeFromString, sub),
+      deleteBatch: ids =>
+        ops.deleteBatch(
+          ids->Array.map(((id, sort)) => (id->Reventless.Id.String.makeFromString, sort)),
+        ),
+    }
+
+    let decoder = Reventless.DcbDecode.makeDecoder(Spec.consumedEventSchema)
+
+    let construct = (~dcbEventLog: DcbEventLog.component, self, _name) => {
+      let opts = {Pulumi.ComponentResource.parent: self->Component.toPulumiResource}
+
+      let queryDb = SpecificQueryDb.make(~api=Api.api(), ~apiRole=Api.apiRole(), ~opts)
+
+      let dcbEventTopicOutputs: EventTopic.outputs = (dcbEventLog->Component.outputs).eventTopic
+      let allEventTopics = Dict.fromArray([(Spec.name, dcbEventTopicOutputs)])
+
+      let eventCollector =
+        queryDb
+        ->Component.operations
+        ->Pulumi.Output.apply(queryDbOps => {
+          let projectionOps = toProjectionOps(queryDbOps)
+
+          let ec = SpecificEventCollector.make(~name=Spec.name, ~eventTopics=allEventTopics, ~opts)
+
+          let comp = `StateViewSlice(${Spec.name})`
+
+          let jsonEventsHandler: EventCollector.jsonEventsHandler = stream =>
+            stream
+            ->Stream.runCollect
+            ->Effect.flatMap(events => {
+              let total = events->Array.length->Int.toString
+              events
+              ->Array.mapWithIndex((json, i) => {
+                let rawEvent =
+                  json
+                  ->JSON.Decode.object
+                  ->Option.flatMap(d => d->Dict.get("event"))
+                  ->Option.getOr(json)
+                let (eventType, dataDict) = rawEvent->Message.splitMessage
+                switch decoder.decode(~eventType, ~data=dataDict) {
+                | Some(event) =>
+                  let actions =
+                    try Projection.project(event)
+                    catch {
+                    | exn =>
+                      let errMsg =
+                        exn
+                        ->JsExn.fromException
+                        ->Option.flatMap(JsExn.message)
+                        ->Option.getOr("unknown")
+                      EffectLogger.logError(
+                        ~comp,
+                        `project failed for ${eventType}: ${errMsg}`,
+                      )->Effect.runSync
+                      []
+                    }
+                  let idxStr = (i + 1)->Int.toString
+                  let actionsStr = LogFormat.actionNames(actions)
+                  let eventData = dataDict->JSON.Encode.object
+                  let fieldsStr = {
+                    let f =
+                      dataDict
+                      ->Dict.toArray
+                      ->Array.map(((k, v)) => `${k}:${v->JSON.stringify}`)
+                      ->Array.join(",")
+                    f == "" ? "" : `({${f}})`
+                  }
+                  EffectLogger.logInfo(
+                    ~comp,
+                    ~detail=eventData,
+                    `handling event ${idxStr}/${total}: ${LogFormat.bold(eventType)}${fieldsStr} ${actionsStr}`,
+                  )->Effect.runSync
+                  actions
+                | None => []
+                }
+              })
+              ->Array.flat
+              ->Array.reduce(Effect.succeed(), (acc, action) =>
+                acc->Effect.flatMap(_ =>
+                  Effect.promise(() =>
+                    FrameworkProjection.handleAction(action, projectionOps, Spec.subIdConfig)
+                  )->Effect.map(_ => ())
+                )
+              )
+            })
+
+          let handler = SpecificEventCollector.makeHandler(
+            ~eventCollector=ec,
+            ~jsonEventsHandler,
+          )
+          let resources = (queryDb->Component.outputs).resources
+          ec->EventCollectorRuntimeBuilder.forEventCollector(
+            ~handler,
+            ~eventTopics=allEventTopics,
+            ~resources,
+          )
+          ec
+        })
+
+      self->Component.setOperations(
+        eventCollector
+        ->Pulumi.Output.flatMap(ec => ec->Component.operations)
+        ->Pulumi.Output.apply(({enqueueEvent}) => {
+          let ops: StateViewSlice.operations = {enqueueEvent: enqueueEvent}
+          ops
+        }),
+      )
+
+      let outputs: StateViewSlice.outputs = {
+        resources: dcbEventTopicOutputs.resources,
+        queryDb: queryDb->Component.outputs,
+      }
+      self->Component.setOutputs(outputs)
+    }
+
+    let make = (~dcbEventLog, ~opts=?): StateViewSlice.component =>
+      Component.make(
+        ~componentType=StateViewSlice.componentType->ComponentType.toString,
+        ~name=Spec.name,
+        ~construct=construct(~dcbEventLog, ...),
+        ~opts,
+      )
+  }
+}