@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -0,0 +1,572 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.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 Pulumi from "@pulumi/pulumi";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as Component$ReventlessCore from "../Component.res.mjs";
+import * as DcbValidation$Reventless from "@reventlessdev/reventless-spec/src/components/DcbValidation.res.mjs";
+import * as Api_Naming$ReventlessCore from "../Api/Api_Naming.res.mjs";
+import * as DcbScopeInference$Reventless from "@reventlessdev/reventless-spec/src/components/DcbScopeInference.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "../../plugin/component/Plugin_Helpers.res.mjs";
+import * as ApiNoApiHelpers$ReventlessCore from "../Api/ApiNoApiHelpers.res.mjs";
+import * as Plugin_Structure$ReventlessCore from "../../plugin/component/Plugin_Structure.res.mjs";
+import * as DcbEventLog_Builder$ReventlessCore from "../DcbEventLog/DcbEventLog_Builder.res.mjs";
+import * as CommandTopic_Builder$ReventlessCore from "../CommandTopic/CommandTopic_Builder.res.mjs";
+import * as AutomationSlice_Callback$ReventlessCore from "../AutomationSlice/AutomationSlice_Callback.res.mjs";
+import * as CommandGenerator_Callback$ReventlessCore from "../CommandGenerator/CommandGenerator_Callback.res.mjs";
+import * as InboundTranslationSlice_Callback$ReventlessCore from "../InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
+import * as OutboundTranslationSlice_Callback$ReventlessCore from "../OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let toRelativePath = (function toRelativePath(moduleUrl) {
+  try {
+    const fs = process.getBuiltinModule('node:fs');
+    const path = process.getBuiltinModule('node:path');
+    const { fileURLToPath } = process.getBuiltinModule('node:url');
+    const builderReal = fs.realpathSync(fileURLToPath(import.meta.url));
+    const sliceReal = fs.realpathSync(fileURLToPath(moduleUrl));
+    let dir = path.dirname(builderReal);
+    while (dir !== path.dirname(dir)) {
+      if (fs.existsSync(path.join(dir, 'lerna.json'))) break;
+      dir = path.dirname(dir);
+    }
+    return path.relative(dir, sliceReal).replace(/\.mjs$/, '.res');
+  } catch(e) {
+    return moduleUrl.replace('file://', '');
+  }
+});
+
+let emptyResult_stateChangeSlicesOutputs = {};
+
+let emptyResult_stateViewSlicesOutputs = {};
+
+let emptyResult_automationSlicesOutputs = {};
+
+let emptyResult_outboundTranslationSlicesOutputs = {};
+
+let emptyResult_inboundTranslationSlicesOutputs = {};
+
+let emptyResult_mutationEntries = [];
+
+let emptyResult_queryEntries = [];
+
+let emptyResult_eventLogEntries = [];
+
+let emptyResult = {
+  dcbEventLogOutputs: undefined,
+  stateChangeSlicesOutputs: emptyResult_stateChangeSlicesOutputs,
+  stateViewSlicesOutputs: emptyResult_stateViewSlicesOutputs,
+  automationSlicesOutputs: emptyResult_automationSlicesOutputs,
+  outboundTranslationSlicesOutputs: emptyResult_outboundTranslationSlicesOutputs,
+  inboundTranslationSlicesOutputs: emptyResult_inboundTranslationSlicesOutputs,
+  dcbRuntimeSetup: undefined,
+  dcbPublishJsons: undefined,
+  dcbCommandTopicQueueUrl: undefined,
+  mutationEntries: emptyResult_mutationEntries,
+  queryEntries: emptyResult_queryEntries,
+  eventLogEntries: emptyResult_eventLogEntries
+};
+
+function Make(DcbEventLogStorage) {
+  return DcbEventTopicPublisher => (DcbCommandTopicChannel => (DcbCommandTopicChannelAsync => (RuntimeBuilder => (HooksConfig => {
+    let construct = (name, childName, environmentOpt, platformNameOpt, aggregateEventTopicsOpt, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, pluginStructure, opts) => {
+      let environment = environmentOpt !== undefined ? environmentOpt : "";
+      let platformName = platformNameOpt !== undefined ? platformNameOpt : "";
+      let aggregateEventTopics = aggregateEventTopicsOpt !== undefined ? aggregateEventTopicsOpt : ({});
+      let hasDcb = stateChangeSlices.length !== 0;
+      if (!hasDcb) {
+        return emptyResult;
+      }
+      let syncSlices = stateChangeSlices.filter(M => !M.isAsync);
+      let asyncSlices = stateChangeSlices.filter(M => M.isAsync);
+      let produced = stateChangeSlices.map(Sc => [
+        Sc.Spec.name,
+        Sc.Spec.eventSchema
+      ]);
+      let producedNamed = stateChangeSlices.map(Sc => [
+        Sc.Spec.name,
+        toRelativePath(Sc.Spec.moduleUrl),
+        Sc.Spec.eventSchema
+      ]);
+      let consumed = stateChangeSlices.map(Sc => [
+        Sc.Spec.name,
+        Sc.Spec.consumedEventSchema
+      ]).concat(stateViewSlices.map(V => [
+        V.Spec.name,
+        V.Spec.consumedEventSchema
+      ])).concat(automationSlices.flatMap(A => A.Automation.mappings.map(M => [
+        A.Spec.name,
+        M.sourceEventSchema
+      ]))).concat(outboundTranslationSlices.map(O => [
+        O.Spec.name,
+        O.Spec.consumedEventSchema
+      ]));
+      let errors = DcbValidation$Reventless.validateProducedAndConsumed(produced, consumed);
+      if (errors.TAG !== "Ok") {
+        errors._0.forEach(err => log.error("Dcb_Builder", undefined, `DCB validation error (` + err.sliceName + `): ` + err.message));
+      }
+      let producedSchemas = produced.map(param => param[1]);
+      let arr = producedSchemas.flatMap(DcbTag$Reventless.extractTaggedFields);
+      let seen = new Set();
+      let indexes = arr.filter(f => {
+        if (seen.has(f)) {
+          return false;
+        } else {
+          seen.add(f);
+          return true;
+        }
+      }).map(tagKey => `tag_` + tagKey);
+      let indexes$1 = indexes.length > 1 ? indexes.concat(["tag_composite"]) : indexes;
+      let partitionTag = DcbTag$Reventless.derivePartitionTag(producedNamed);
+      let arr$1 = producedSchemas.flatMap(DcbTag$Reventless.extractCrossPartitionTagKeys);
+      let seen$1 = new Set();
+      let crossPartitionTagKeys = arr$1.filter(f => {
+        if (seen$1.has(f)) {
+          return false;
+        } else {
+          seen$1.add(f);
+          return true;
+        }
+      });
+      DcbValidation$Reventless.validateCrossPartitionScope(produced).forEach(err => log.error("Dcb_Builder", undefined, `DCB cross-partition scope error (` + err.sliceName + `): ` + err.message));
+      let tagKeysByEventType = DcbTag$Reventless.mergeTagKeysByEventType(producedSchemas.map(DcbTag$Reventless.extractTagKeysByEventType));
+      DcbValidation$Reventless.validateCompositeReads(stateChangeSlices.map(Sc => [
+        Sc.Spec.name,
+        Sc.Spec.commandSchema,
+        Sc.Spec.consumedEventSchema
+      ]), tagKeysByEventType).forEach(w => log.warn("Dcb_Builder", undefined, `DCB composite-read warning (` + w.sliceName + `): ` + w.message));
+      let inferenceShapes = stateChangeSlices.map(Sc => DcbTag$Reventless.sliceShapeFromSchemas(Sc.Spec.name, Sc.Spec.commandSchema, Sc.Spec.consumedEventSchema, Sc.Spec.eventSchema));
+      let inferred = DcbScopeInference$Reventless.infer(inferenceShapes);
+      if (Primitive_object.notequal(inferred.crossPartitionTagKeys, crossPartitionTagKeys)) {
+        log.info("Dcb_Builder", undefined, `DCB scope-inference diff: crossPartitionTagKeys annotated=[` + crossPartitionTagKeys.join(", ") + `] inferred=[` + inferred.crossPartitionTagKeys.join(", ") + `]`);
+      }
+      Object.entries(inferred.tagKeysByEventType).forEach(param => {
+        let inferredKeys = param[1];
+        let eventType = param[0];
+        let annotatedKeys = Stdlib_Option.getOr(tagKeysByEventType[eventType], []);
+        let dropped = annotatedKeys.filter(k => !inferredKeys.includes(k));
+        if (dropped.length !== 0) {
+          return log.info("Dcb_Builder", undefined, `DCB scope-inference diff: ` + eventType + ` indexes [` + inferredKeys.join(", ") + `] (inferred) vs [` + annotatedKeys.join(", ") + `] (annotated) — payload now: [` + dropped.join(", ") + `]`);
+        }
+      });
+      inferred.ambiguities.forEach(param => log.warn("Dcb_Builder", undefined, `DCB scope-inference ambiguity (` + param[0] + `): ` + param[1]));
+      let scopeAnnotations = stateChangeSlices.map(Sc => [
+        Sc.Spec.name,
+        DcbTag$Reventless.extractCrossPartitionTagKeys(Sc.Spec.eventSchema)
+      ]);
+      let scopeIssues = DcbValidation$Reventless.validateScopeVsInference(scopeAnnotations, inferred);
+      scopeIssues.contradictions.forEach(e => log.warn("Dcb_Builder", undefined, `DCB scope contradiction (` + e.sliceName + `): ` + e.message));
+      scopeIssues.redundancies.forEach(e => log.info("Dcb_Builder", undefined, `DCB scope (` + e.sliceName + `): ` + e.message));
+      let useInferred = inferred.ambiguities.length === 0;
+      let effectiveCrossPartitionTagKeys = useInferred ? inferred.crossPartitionTagKeys : crossPartitionTagKeys;
+      let effectiveTagKeysByEventType = useInferred ? inferred.tagKeysByEventType : tagKeysByEventType;
+      let DcbEventLog = DcbEventLog_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher);
+      let dcbEventLog = DcbEventLog.make(name, indexes$1, partitionTag, effectiveCrossPartitionTagKeys, opts);
+      Stdlib_Option.forEach(HooksConfig.hooks.onDcbEventLogCreated, hook => hook(dcbEventLog));
+      let DcbCommandTopic = CommandTopic_Builder$ReventlessCore.Make({
+        Id: Id$Reventless.$$String,
+        name: childName,
+        commandSchema: S.json
+      })(DcbCommandTopicChannel);
+      let dcbCommandTopic = DcbCommandTopic.make(name + `Dcb`, opts);
+      Stdlib_Option.forEach(HooksConfig.hooks.onDcbCommandTopicCreated, hook => hook(dcbCommandTopic));
+      let publishJsons = Component$ReventlessCore.operations(dcbCommandTopic).apply(ops => ops.publishJsons);
+      let name$1 = childName + "Async";
+      let DcbAsyncCommandTopic = CommandTopic_Builder$ReventlessCore.Make({
+        Id: Id$Reventless.$$String,
+        name: name$1,
+        commandSchema: S.json
+      })(DcbCommandTopicChannelAsync);
+      let asyncDcbCommandTopicOpt;
+      if (asyncSlices.length !== 0) {
+        let t = DcbAsyncCommandTopic.make(name + `DcbAsync`, opts);
+        Stdlib_Option.forEach(HooksConfig.hooks.onDcbCommandTopicCreated, hook => hook(t));
+        asyncDcbCommandTopicOpt = Primitive_option.some(t);
+      } else {
+        asyncDcbCommandTopicOpt = undefined;
+      }
+      let stateChangeSlicesOutputs = Object.fromEntries(syncSlices.map(StateChangeSlice => {
+        let ch = StateChangeSlice.make(dcbEventLog, publishJsons, effectiveTagKeysByEventType, effectiveCrossPartitionTagKeys, opts);
+        return [
+          StateChangeSlice.Spec.name,
+          Component$ReventlessCore.outputs(ch)
+        ];
+      }));
+      let asyncStateChangeSlicesOutputs;
+      if (asyncDcbCommandTopicOpt !== undefined) {
+        let asyncPublishJsons = Component$ReventlessCore.operations(Primitive_option.valFromOption(asyncDcbCommandTopicOpt)).apply(ops => ops.publishJsons);
+        asyncStateChangeSlicesOutputs = Object.fromEntries(asyncSlices.map(StateChangeSlice => {
+          let ch = StateChangeSlice.make(dcbEventLog, asyncPublishJsons, effectiveTagKeysByEventType, effectiveCrossPartitionTagKeys, opts);
+          return [
+            StateChangeSlice.Spec.name,
+            Component$ReventlessCore.outputs(ch)
+          ];
+        }));
+      } else {
+        asyncStateChangeSlicesOutputs = {};
+      }
+      let registerResolver = HooksConfig.hooks.mutationResolverHook;
+      if (registerResolver !== undefined) {
+        syncSlices.forEach(S => {
+          let commandSchema = S.Spec.commandSchema;
+          if (!ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
+            return registerResolver("Dcb", [Api_Naming$ReventlessCore.sliceMutationField(name, S.Spec.name)], commandSchema, S.Spec.commandAuthorization);
+          }
+        });
+        asyncSlices.forEach(S => {
+          let commandSchema = S.Spec.commandSchema;
+          if (!ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
+            return registerResolver("Dcb", [Api_Naming$ReventlessCore.sliceMutationField(name, S.Spec.name)], commandSchema, S.Spec.commandAuthorization);
+          }
+        });
+      }
+      let bindHandler = HooksConfig.hooks.mutationBindHook;
+      if (bindHandler !== undefined) {
+        Component$ReventlessCore.operations(dcbCommandTopic).apply(ops => {
+          syncSlices.forEach(S => {
+            let commandSchema = S.Spec.commandSchema;
+            if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
+              return;
+            }
+            let fieldName = Api_Naming$ReventlessCore.sliceMutationField(name, S.Spec.name);
+            let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(ops.publishJsons, ops.publishJsonsAndWait, S.Spec.name, S.Spec.commandSchema, "StateChangeSlice", false);
+            bindHandler(fieldName, generateCommand);
+          });
+        });
+        if (asyncDcbCommandTopicOpt !== undefined) {
+          Component$ReventlessCore.operations(Primitive_option.valFromOption(asyncDcbCommandTopicOpt)).apply(asyncOps => {
+            asyncSlices.forEach(S => {
+              let commandSchema = S.Spec.commandSchema;
+              if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
+                return;
+              }
+              let fieldName = Api_Naming$ReventlessCore.sliceMutationField(name, S.Spec.name);
+              let generateCommand = CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(asyncOps.publishJsons, asyncOps.publishJsonsAndWait, S.Spec.name, S.Spec.commandSchema, "StateChangeSlice", false);
+              bindHandler(fieldName, generateCommand);
+            });
+          });
+        }
+      }
+      stateViewSlices.forEach(V => {
+        let qn = Api_Naming$ReventlessCore.queryFieldNamesForStateView(name, V.Spec.name, undefined);
+        let match = Plugin_Structure$ReventlessCore.labelFieldsFromStateSchema(V.Spec.name, V.Spec.stateSchema);
+        let newrecord = {...qn};
+        newrecord.labelField = match[0];
+        newrecord.connectionFilterTypeName = qn.returnTypeName + "Filter";
+        let match$1 = V.Spec.subIdConfig;
+        let qn$1;
+        if (match$1 !== undefined) {
+          let newrecord$1 = {...newrecord};
+          newrecord$1.itemsFilterTypeName = newrecord.returnTypeName + "ItemsFilter";
+          newrecord$1.itemsFieldName = newrecord.singleFieldName + "Items";
+          qn$1 = newrecord$1;
+        } else {
+          qn$1 = newrecord;
+        }
+        Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[V.Spec.name] = qn$1;
+        Plugin_Helpers$ReventlessCore.stateSchemaRegistry[V.Spec.name] = V.Spec.stateSchema;
+      });
+      automationSlices.forEach(A => {
+        let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, A.queryDbName, undefined);
+        Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[A.queryDbName] = qn;
+      });
+      outboundTranslationSlices.forEach(O => {
+        let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, O.queryDbName, undefined);
+        Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[O.queryDbName] = qn;
+      });
+      inboundTranslationSlices.forEach(I => {
+        let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, I.queryDbName, undefined);
+        Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[I.queryDbName] = qn;
+      });
+      let stateViewSlicesOutputs = Object.fromEntries(stateViewSlices.map(StateViewSlice => {
+        let sv = StateViewSlice.make(dcbEventLog, opts);
+        return [
+          StateViewSlice.Spec.name,
+          Component$ReventlessCore.outputs(sv)
+        ];
+      }));
+      let allEventTopics = Object.assign({}, aggregateEventTopics);
+      allEventTopics[name + "DcbEventLog"] = Component$ReventlessCore.outputs(dcbEventLog).eventTopic;
+      let automationSlicesOutputs = Object.fromEntries(automationSlices.map(AutoSlice => {
+        let context_sliceName = AutoSlice.Spec.name;
+        let context = {
+          environment: environment,
+          platformName: platformName,
+          pluginName: name,
+          sliceName: context_sliceName
+        };
+        let as_ = AutoSlice.make(allEventTopics, publishJsons, context, opts);
+        return [
+          AutoSlice.Spec.name,
+          Component$ReventlessCore.outputs(as_)
+        ];
+      }));
+      let outboundTranslationSlicesOutputs = Object.fromEntries(outboundTranslationSlices.map(OTS => {
+        let ots = OTS.make(dcbEventLog, publishJsons, opts);
+        return [
+          OTS.Spec.name,
+          Component$ReventlessCore.outputs(ots)
+        ];
+      }));
+      let inboundTranslationSliceData = inboundTranslationSlices.map(ITS => {
+        let its = ITS.make(publishJsons, opts);
+        let fieldName = Api_Naming$ReventlessCore.sliceMutationField(name, ITS.Spec.name);
+        let registerResolver = HooksConfig.hooks.inboundMutationResolverHook;
+        if (registerResolver !== undefined) {
+          registerResolver(fieldName, ITS.Spec.externalInputSchema);
+        }
+        let bindReceive = HooksConfig.hooks.inboundMutationBindReceiveHook;
+        if (bindReceive !== undefined) {
+          Component$ReventlessCore.operations(its).apply(ops => bindReceive(fieldName, ops.receive));
+        }
+        return [
+          ITS.Spec.name,
+          fieldName,
+          its,
+          ITS.Spec.externalInputSchema
+        ];
+      });
+      let inboundTranslationSlicesOutputs = Object.fromEntries(inboundTranslationSliceData.map(param => [
+        param[0],
+        Component$ReventlessCore.outputs(param[2])
+      ]));
+      let inboundReceiversOutput = Pulumi.all(inboundTranslationSliceData.map(param => {
+        let fieldName = param[1];
+        return Component$ReventlessCore.operations(param[2]).apply(ops => [
+          fieldName,
+          ops.receive
+        ]);
+      })).apply(pairs => Object.fromEntries(pairs));
+      let dcbHandlerBase = DcbCommandTopic.makeFilteringHandler(dcbCommandTopic);
+      let dcbGenerateCommandOutput = Component$ReventlessCore.operations(dcbCommandTopic).apply(ops => CommandGenerator_Callback$ReventlessCore.makeGenerateCommand(ops.publishJsons, ops.publishJsonsAndWait, name, S.json, "StateChangeSlice", false));
+      let dcbHandler = Pulumi.all([
+        dcbHandlerBase,
+        inboundReceiversOutput,
+        dcbGenerateCommandOutput
+      ]).apply(param => {
+        let generateCommand = param[2];
+        let receivers = param[1];
+        let baseHandler = param[0];
+        return (event, ctx) => {
+          let match = event["__inboundTranslation"];
+          if (match !== undefined) {
+            let fieldName = Stdlib_Option.getOr(Stdlib_Option.flatMap(event["fieldName"], Stdlib_JSON.Decode.string), "");
+            let args = Stdlib_Option.getOr(event["arguments"], null);
+            let receiveFn = receivers[fieldName];
+            if (receiveFn !== undefined) {
+              return Effect.promise(async () => {
+                let result = await receiveFn(args);
+                if (result.TAG === "Ok") {
+                  return result._0.map(prim => prim);
+                } else {
+                  return result._0;
+                }
+              });
+            } else {
+              return baseHandler(event, ctx);
+            }
+          }
+          let match$1 = event["command"];
+          let match$2 = event["arguments"];
+          if (typeof match$1 === "string" && match$2 !== undefined) {
+            return Effect.map(generateCommand(event), msgId => msgId);
+          } else {
+            return baseHandler(event, ctx);
+          }
+        };
+      });
+      let dcbResources = Object.values(stateChangeSlicesOutputs).flatMap(outputs => outputs.resources).concat(Object.values(inboundTranslationSlicesOutputs).flatMap(outputs => outputs.resources));
+      let asyncDcbResources = Object.values(asyncStateChangeSlicesOutputs).flatMap(outputs => outputs.resources);
+      let inboundFieldNames = inboundTranslationSliceData.map(param => param[1]);
+      let inboundSchemas = inboundTranslationSliceData.map(param => param[3]);
+      let dcbMutationData = Stdlib_Array.filterMap(stateChangeSlices, S => {
+        let commandSchema = S.Spec.commandSchema;
+        if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
+          return;
+        }
+        let fieldName = Api_Naming$ReventlessCore.sliceMutationField(name, S.Spec.name);
+        let constructorNames = DcbTag$Reventless.extractAllVariantNames(S.Spec.commandSchema);
+        let tag = Stdlib_Option.getOr(constructorNames[0], S.Spec.name);
+        return [
+          fieldName,
+          tag
+        ];
+      });
+      let dcbFieldNames = dcbMutationData.map(param => param[0]);
+      let dcbTags = dcbMutationData.map(param => param[1]);
+      let dcbConnectFn = runtime => {
+        DcbCommandTopic.connect(runtime, dcbResources, dcbCommandTopic);
+        if (inboundFieldNames.length !== 0) {
+          let hook = HooksConfig.hooks.inboundAppSyncResolverHook;
+          if (hook !== undefined) {
+            hook({
+              runtime: runtime,
+              fieldNames: inboundFieldNames,
+              externalInputSchemas: inboundSchemas,
+              opts: opts
+            });
+          }
+        }
+        if (dcbFieldNames.length === 0) {
+          return;
+        }
+        let hook$1 = HooksConfig.hooks.dcbAppSyncResolverHook;
+        if (hook$1 !== undefined) {
+          return hook$1({
+            runtime: runtime,
+            fieldNames: dcbFieldNames,
+            tags: dcbTags,
+            opts: opts
+          });
+        }
+      };
+      Stdlib_Option.forEach(HooksConfig.hooks.onDcbSlicesCreated, hook => hook(dcbEventLog));
+      let dcbRuntimeSetup = () => {
+        RuntimeBuilder.forDcbCommandTopic(dcbHandler, dcbConnectFn, undefined, undefined, dcbCommandTopic);
+        Stdlib_Option.forEach(asyncDcbCommandTopicOpt, asyncDcbCommandTopic => {
+          let asyncDcbHandler = DcbAsyncCommandTopic.makeFilteringHandler(asyncDcbCommandTopic);
+          let asyncDcbConnectFn = runtime => DcbAsyncCommandTopic.connect(runtime, asyncDcbResources, asyncDcbCommandTopic);
+          RuntimeBuilder.forDcbCommandTopic(asyncDcbHandler, asyncDcbConnectFn, undefined, undefined, asyncDcbCommandTopic);
+        });
+      };
+      let permissionForFirstConstructor = (commandSchema, commandAuthorization) => {
+        let names = DcbTag$Reventless.extractAllVariantNames(commandSchema);
+        let first = names[0];
+        if (first === undefined) {
+          return;
+        }
+        let hasPayload = DcbTag$Reventless.isVariantPayloadBearing(commandSchema, first);
+        let syntheticCmd = hasPayload ? ({
+            TAG: first
+          }) : first;
+        return commandAuthorization(syntheticCmd);
+      };
+      let mutationEntriesFromSlices = Stdlib_Array.filterMap(stateChangeSlices, S => {
+        let commandSchema = S.Spec.commandSchema;
+        if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
+          return;
+        }
+        let sliceDef = Stdlib_Option.flatMap(pluginStructure, s => s.stateChangeSlices.find(d => d.name === S.Spec.name));
+        let fieldName = Api_Naming$ReventlessCore.sliceMutationField(name, S.Spec.name);
+        let fieldPermissions = {};
+        let rule = permissionForFirstConstructor(commandSchema, S.Spec.commandAuthorization);
+        if (rule !== undefined) {
+          fieldPermissions[fieldName] = rule;
+        }
+        return {
+          fieldNames: [fieldName],
+          commandSchema: commandSchema,
+          fieldPermissions: fieldPermissions,
+          linkedViews: Stdlib_Option.map(sliceDef, d => d.linkedViews),
+          consistencyRead: Stdlib_Option.flatMap(sliceDef, d => d.consistencyRead)
+        };
+      });
+      let mutationEntriesFromInboundSlices = inboundTranslationSlices.map(ITS => {
+        let fieldName = Api_Naming$ReventlessCore.sliceMutationField(name, ITS.Spec.name);
+        let fieldPermissions = {};
+        let rule = permissionForFirstConstructor(ITS.Spec.commandSchema, ITS.Spec.commandAuthorization);
+        if (rule !== undefined) {
+          fieldPermissions[fieldName] = rule;
+        }
+        return {
+          fieldNames: [fieldName],
+          commandSchema: ITS.Spec.externalInputSchema,
+          fieldPermissions: fieldPermissions
+        };
+      });
+      let stateViewEntries = stateViewSlices.map(V => {
+        let qn = Api_Naming$ReventlessCore.queryFieldNamesForStateView(name, V.Spec.name, undefined);
+        let subIdField = Stdlib_Option.map(V.Spec.subIdConfig, c => c.subIdField);
+        let indexes = V.Spec.config.indexes;
+        let indexQueries = indexes.length !== 0 ? indexes : undefined;
+        return {
+          singleFieldName: qn.singleFieldName,
+          listFieldName: qn.listFieldName,
+          returnTypeName: qn.returnTypeName,
+          stateSchema: V.Spec.stateSchema,
+          authorization: undefined,
+          permission: V.Spec.authorization,
+          includeIdParam: qn.includeIdParam,
+          connectionSpec: true,
+          subIdField: subIdField,
+          indexQueries: indexQueries
+        };
+      });
+      let automationEntries = automationSlices.map(A => {
+        let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, A.queryDbName, undefined);
+        return {
+          singleFieldName: qn.singleFieldName,
+          listFieldName: qn.listFieldName,
+          returnTypeName: qn.returnTypeName,
+          stateSchema: AutomationSlice_Callback$ReventlessCore.todoRowSchema,
+          authorization: undefined,
+          connectionSpec: true
+        };
+      });
+      let outboundEntries = outboundTranslationSlices.map(O => {
+        let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, O.queryDbName, undefined);
+        return {
+          singleFieldName: qn.singleFieldName,
+          listFieldName: qn.listFieldName,
+          returnTypeName: qn.returnTypeName,
+          stateSchema: OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema,
+          authorization: undefined,
+          connectionSpec: true
+        };
+      });
+      let inboundEntries = inboundTranslationSlices.map(I => {
+        let qn = Api_Naming$ReventlessCore.queryFieldNamesForSliceQueryDb(name, I.queryDbName, undefined);
+        return {
+          singleFieldName: qn.singleFieldName,
+          listFieldName: qn.listFieldName,
+          returnTypeName: qn.returnTypeName,
+          stateSchema: InboundTranslationSlice_Callback$ReventlessCore.auditRowSchema,
+          authorization: undefined,
+          connectionSpec: true
+        };
+      });
+      let allProducedSchemas = stateChangeSlices.map(Sc => Sc.Spec.eventSchema);
+      let outputs = Component$ReventlessCore.outputs(dcbCommandTopic);
+      let r = outputs.resources[0];
+      let dcbCommandTopicQueueUrl = r !== undefined ? r.id : undefined;
+      return {
+        dcbEventLogOutputs: Component$ReventlessCore.outputs(dcbEventLog),
+        stateChangeSlicesOutputs: Object.fromEntries(Object.entries(stateChangeSlicesOutputs).concat(Object.entries(asyncStateChangeSlicesOutputs))),
+        stateViewSlicesOutputs: stateViewSlicesOutputs,
+        automationSlicesOutputs: automationSlicesOutputs,
+        outboundTranslationSlicesOutputs: outboundTranslationSlicesOutputs,
+        inboundTranslationSlicesOutputs: inboundTranslationSlicesOutputs,
+        dcbRuntimeSetup: dcbRuntimeSetup,
+        dcbPublishJsons: publishJsons,
+        dcbCommandTopicQueueUrl: dcbCommandTopicQueueUrl,
+        mutationEntries: mutationEntriesFromSlices.concat(mutationEntriesFromInboundSlices),
+        queryEntries: stateViewEntries.concat(automationEntries).concat(outboundEntries).concat(inboundEntries),
+        eventLogEntries: allProducedSchemas.length !== 0 ? [{
+              busKey: name + "DcbEventLog",
+              displayName: name,
+              eventSchema: allProducedSchemas[0]
+            }] : []
+      };
+    };
+    return {
+      construct: construct
+    };
+  }))));
+}
+
+export {
+  log,
+  toRelativePath,
+  emptyResult,
+  Make,
+}
+/* log Not a pure module */

package/src/components/DcbEventLog/DcbEventLog.res

@@ -0,0 +1,43 @@
+let componentType = ComponentType.DcbEventLog
+
+type outputs = ReventlessInfra.DcbEventLog.outputs
+
+type t = ReventlessInfra.DcbEventLog.t
+
+type rawEvent = ReventlessInfra.DcbEventLog.rawEvent
+type rawSequencedEvent = ReventlessInfra.DcbEventLog.rawSequencedEvent
+type readResult = ReventlessInfra.DcbEventLog.readResult
+type read = ReventlessInfra.DcbEventLog.read
+type append = ReventlessInfra.DcbEventLog.append
+type readStream = ReventlessInfra.DcbEventLog.readStream
+type appendStream = ReventlessInfra.DcbEventLog.appendStream
+type operations = ReventlessInfra.DcbEventLog.operations
+type component = ReventlessInfra.DcbEventLog.component
+
+let toResolvedOutputs = (
+  outputs: outputs,
+): Pulumi.Output.t<ReventlessInterop.DcbEventLog.resolvedOutputs> =>
+  (
+    outputs.resources->Adapter.resourcesToInterop,
+    outputs.eventTopic.resources->Adapter.resourcesToInterop,
+  )
+  ->Pulumi.Output.all2
+  ->Pulumi.Output.apply(((resources, eventTopicResources)) => {
+    let resolved: ReventlessInterop.DcbEventLog.resolvedOutputs = {
+      resources: resources,
+      eventTopic: {resources: eventTopicResources},
+    }
+    resolved
+  })
+
+module type T = {
+  type component = component
+
+  let make: (
+    ~name: string,
+    ~indexes: array<string>=?,
+    ~partitionTag: Reventless.DcbTag.derivedPartitionTag,
+    ~crossPartitionTagKeys: array<string>=?,
+    ~opts: Pulumi.ComponentResource.options=?,
+  ) => component
+}

package/src/components/DcbEventLog/DcbEventLog.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.eventTopic.resources)
+  ]).apply(param => ({
+    resources: param[0],
+    eventTopic: {
+      resources: param[1]
+    }
+  }));
+}
+
+let componentType = "DcbEventLog";
+
+export {
+  componentType,
+  toResolvedOutputs,
+}
+/* @pulumi/pulumi Not a pure module */