@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -0,0 +1,464 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
+import * as Heartbeat$ReventlessCore from "@reventlessdev/reventless-core/src/components/Heartbeat/Heartbeat.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as PluginSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginSpec.res.mjs";
+import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
+import * as EventCollector$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventCollector/EventCollector.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "../../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
+import * as StateChangeSliceRuntime_Builder_Single$ReventlessAws from "../../adapter/Runtime/StateChangeSliceRuntime_Builder_Single.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let configRef = {
+  contents: {
+    eventTopicArn: undefined,
+    pluginReadModelTableName: undefined,
+    pluginSchemaPersistenceTableName: undefined,
+    schedulerRoleArn: undefined,
+    schedulerQueueArn: undefined,
+    schedulerQueueName: undefined,
+    appSyncApiId: undefined,
+    clonerEnabled: false
+  }
+};
+
+let dcbConfigRef = {
+  contents: {
+    pluginName: "",
+    dcbTableName: undefined,
+    stateChangeSliceModulePaths: []
+  }
+};
+
+let registeredSliceModulePaths = [];
+
+function registerStateChangeSliceSpec(specPath, behaviorPath) {
+  registeredSliceModulePaths.push({
+    specPath: specPath,
+    behaviorPath: behaviorPath
+  });
+}
+
+function registerDcbConfig(pluginName, dcbTableName, stateChangeSliceModulePathsOpt, param) {
+  let stateChangeSliceModulePaths = stateChangeSliceModulePathsOpt !== undefined ? stateChangeSliceModulePathsOpt : [];
+  dcbConfigRef.contents = {
+    pluginName: pluginName,
+    dcbTableName: dcbTableName,
+    stateChangeSliceModulePaths: stateChangeSliceModulePaths
+  };
+  return stateChangeSliceModulePaths.length;
+}
+
+function registerDcbTableName(dcbTableName) {
+  let init = dcbConfigRef.contents;
+  dcbConfigRef.contents = {
+    pluginName: init.pluginName,
+    dcbTableName: dcbTableName,
+    stateChangeSliceModulePaths: init.stateChangeSliceModulePaths
+  };
+}
+
+let heartbeatConfigRef = {
+  contents: {
+    pluginId: "",
+    heartbeatTimeout: 10,
+    epQueueUrl: undefined
+  }
+};
+
+function registerHeartbeatConfig(pluginId, heartbeatTimeoutOpt, epQueueUrl, param) {
+  let heartbeatTimeout = heartbeatTimeoutOpt !== undefined ? heartbeatTimeoutOpt : 10;
+  heartbeatConfigRef.contents = {
+    pluginId: pluginId,
+    heartbeatTimeout: heartbeatTimeout,
+    epQueueUrl: epQueueUrl
+  };
+}
+
+let syncStateChangesConfigRef = {
+  contents: {}
+};
+
+let asyncStateChangesConfigRef = {
+  contents: {}
+};
+
+function setStateChangesConfig(sync, async, param) {
+  Stdlib_Option.forEach(sync, c => {
+    syncStateChangesConfigRef.contents = c;
+  });
+  Stdlib_Option.forEach(async, c => {
+    asyncStateChangesConfigRef.contents = c;
+  });
+}
+
+function registerConfig(eventTopicArn, pluginReadModelTableName, pluginSchemaPersistenceTableName, schedulerRoleArn, schedulerQueueArn, schedulerQueueName, appSyncApiId, clonerEnabledOpt, param) {
+  let clonerEnabled = clonerEnabledOpt !== undefined ? clonerEnabledOpt : false;
+  configRef.contents = {
+    eventTopicArn: eventTopicArn,
+    pluginReadModelTableName: pluginReadModelTableName,
+    pluginSchemaPersistenceTableName: pluginSchemaPersistenceTableName,
+    schedulerRoleArn: schedulerRoleArn,
+    schedulerQueueArn: schedulerQueueArn,
+    schedulerQueueName: schedulerQueueName,
+    appSyncApiId: appSyncApiId,
+    clonerEnabled: clonerEnabled
+  };
+}
+
+function Make(EventCollectorChannel) {
+  let registerPluginName = pluginName => {
+    let init = dcbConfigRef.contents;
+    dcbConfigRef.contents = {
+      pluginName: pluginName,
+      dcbTableName: init.dcbTableName,
+      stateChangeSliceModulePaths: init.stateChangeSliceModulePaths
+    };
+  };
+  let outputOrPlaceholder = opt => {
+    if (opt !== undefined) {
+      return opt;
+    } else {
+      return Pulumi.output("NOT_AVAILABLE");
+    }
+  };
+  let synthesizeAdminContext = () => {
+    let config = configRef.contents;
+    let fakePluginDefinitionJson = Pulumi.output(`{"id":"Admin@INTERNAL","name":"Admin","version":"INTERNAL","extensionPoints":[],"extensions":[],"eventCollector":"NOT-SET","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"uiFragments":null,"structure":null}`);
+    let arn = config.eventTopicArn;
+    let adminEpEventTopicArn = arn !== undefined ? arn : Pulumi.output("NOT_AVAILABLE");
+    return {
+      pluginDefinitionJson: fakePluginDefinitionJson,
+      extensionPoints: [{
+          specModule: Plugin_Helpers$ReventlessCore.adminPluginExtensionPointSpecModule,
+          mappingsModule: Plugin_Helpers$ReventlessCore.adminPluginExtensionPointMappingsModule,
+          eventTopicArn: adminEpEventTopicArn,
+          aggregateNames: [PluginSpec$ReventlessCore.name]
+        }],
+      connectExtension: undefined,
+      extensions: [],
+      pluginExtensionPointCmdTopicUrl: Pulumi.output(""),
+      publishToAggregates: {},
+      readModelQueueUrls: {},
+      readModelNamesForSourceName: {}
+    };
+  };
+  let forPluginEventCollector = (param, eventTopics, resources, memorySizeOpt, timeoutOpt, eventCollector) => {
+    let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+    let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+    let resource = Component$ReventlessCore.toPulumiResource(eventCollector);
+    let name = ComponentType$ReventlessCore.nameOpt(resource.__name, EventCollector$ReventlessCore.componentType);
+    let opts_parent = resource;
+    let opts = {
+      parent: opts_parent
+    };
+    let config = configRef.contents;
+    let channel = eventCollector.channel;
+    let channelParts = channel.parts;
+    let queue = channelParts.queue;
+    let ctx = Plugin_Helpers$ReventlessCore.eventCollectorContextRef.contents[name];
+    let context = ctx !== undefined ? ctx : synthesizeAdminContext();
+    let envVars = {};
+    Object.entries(context.publishToAggregates).forEach(param => {
+      let envVarName = `PTA_` + param[0] + `_QUEUE_URL`;
+      envVars[envVarName] = param[1];
+    });
+    Object.entries(context.readModelQueueUrls).forEach(param => {
+      let envVarName = `PRM_` + param[0] + `_QUEUE_URL`;
+      envVars[envVarName] = param[1];
+    });
+    let epEventTopicArnsOutput = Pulumi.all(context.extensionPoints.map(ep => ep.eventTopicArn));
+    let handlerConfigJson = Pulumi.all([
+      queue.id,
+      context.pluginExtensionPointCmdTopicUrl,
+      outputOrPlaceholder(config.eventTopicArn),
+      outputOrPlaceholder(config.pluginReadModelTableName),
+      outputOrPlaceholder(config.schedulerRoleArn),
+      outputOrPlaceholder(config.schedulerQueueArn),
+      outputOrPlaceholder(config.schedulerQueueName),
+      outputOrPlaceholder(config.appSyncApiId),
+      epEventTopicArnsOutput,
+      outputOrPlaceholder(config.pluginSchemaPersistenceTableName)
+    ]).apply(values => {
+      let queueUrl = values[0];
+      let pluginEpCmdTopicUrl = values[1];
+      let topLevelEventTopicArn = values[2];
+      let rmTable = values[3];
+      let schedRoleArn = values[4];
+      let schedQueueArn = values[5];
+      let schedQueueName = values[6];
+      let appSyncApiId = values[7];
+      let epEventTopicArns = values[8];
+      let schemaPersistenceTable = values[9];
+      let dict = {};
+      dict["queueUrl"] = queueUrl;
+      dict["pluginExtensionPointCmdTopicUrl"] = pluginEpCmdTopicUrl;
+      dict["eventTopicArn"] = topLevelEventTopicArn;
+      dict["pluginReadModelTableName"] = rmTable;
+      dict["pluginSchemaPersistenceTableName"] = schemaPersistenceTable;
+      dict["appSyncApiId"] = appSyncApiId;
+      dict["clonerEnabled"] = config.clonerEnabled;
+      dict["schedulerRoleArn"] = schedRoleArn;
+      dict["schedulerQueueArn"] = schedQueueArn;
+      dict["schedulerQueueName"] = schedQueueName;
+      let extensionPointsArr = context.extensionPoints.map((ep, i) => [
+        ep,
+        epEventTopicArns[i]
+      ]).toSorted((param, param$1) => Primitive_string.compare(param[0].specModule, param$1[0].specModule)).map(param => {
+        let ep = param[0];
+        let entryDict = {};
+        entryDict["specModule"] = ep.specModule;
+        entryDict["mappingsModule"] = ep.mappingsModule;
+        entryDict["eventTopicArn"] = param[1];
+        entryDict["aggregateNames"] = ep.aggregateNames.map(prim => prim);
+        return entryDict;
+      });
+      dict["extensionPoints"] = extensionPointsArr;
+      let ce = context.connectExtension;
+      let connectExtensionValue;
+      if (ce !== undefined) {
+        let ceDict = {};
+        ceDict["specModule"] = ce.specModule;
+        ceDict["mappingsModule"] = ce.mappingsModule;
+        ceDict["extensionPointName"] = ce.extensionPointName;
+        connectExtensionValue = ceDict;
+      } else {
+        connectExtensionValue = null;
+      }
+      dict["connectExtension"] = connectExtensionValue;
+      let extensionsArr = context.extensions.toSorted((a, b) => Primitive_string.compare(a.name, b.name)).map(ext => {
+        let entryDict = {};
+        entryDict["name"] = ext.name;
+        entryDict["specModule"] = ext.specModule;
+        entryDict["mappingsModule"] = ext.mappingsModule;
+        entryDict["delegateModule"] = ext.delegateModule;
+        entryDict["extensionPointName"] = ext.extensionPointName;
+        entryDict["aggregateNames"] = ext.aggregateNames.map(prim => prim);
+        entryDict["readModelNames"] = ext.readModelNames.map(prim => prim);
+        return entryDict;
+      });
+      dict["extensions"] = extensionsArr;
+      let publishToAggregatesDict = {};
+      Object.keys(context.publishToAggregates).forEach(aggName => {
+        publishToAggregatesDict[aggName] = `PTA_` + aggName + `_QUEUE_URL`;
+      });
+      dict["publishToAggregates"] = publishToAggregatesDict;
+      let readModelQueueUrlsDict = {};
+      Object.keys(context.readModelQueueUrls).forEach(rmName => {
+        readModelQueueUrlsDict[rmName] = `PRM_` + rmName + `_QUEUE_URL`;
+      });
+      dict["readModelQueueUrls"] = readModelQueueUrlsDict;
+      let rmNamesForSourceDict = {};
+      Object.entries(context.readModelNamesForSourceName).forEach(param => {
+        rmNamesForSourceDict[param[0]] = param[1].map(prim => prim);
+      });
+      dict["readModelNamesForSourceName"] = rmNamesForSourceDict;
+      return JSON.stringify(dict);
+    });
+    envVars["HANDLER_CONFIG"] = handlerConfigJson;
+    let packageDirs = {};
+    let addPackageFor = spec => {
+      let pkgName = Util_Bundle$ReventlessAws.extractPackageName(spec);
+      packageDirs[pkgName] = Util_Bundle$ReventlessAws.resolvePackageRoot(pkgName);
+    };
+    context.extensions.forEach(ext => {
+      [
+        ext.specModule,
+        ext.mappingsModule,
+        ext.delegateModule
+      ].forEach(addPackageFor);
+    });
+    context.extensionPoints.forEach(ep => {
+      [
+        ep.specModule,
+        ep.mappingsModule
+      ].forEach(addPackageFor);
+    });
+    let ce = context.connectExtension;
+    if (ce !== undefined) {
+      [
+        ce.specModule,
+        ce.mappingsModule
+      ].forEach(addPackageFor);
+    }
+    packageDirs["@reventlessdev/reventless-aws"] = Util_Bundle$ReventlessAws.resolvePackageRoot("@reventlessdev/reventless-aws");
+    packageDirs["@reventlessdev/reventless-core"] = Util_Bundle$ReventlessAws.resolvePackageRoot("@reventlessdev/reventless-core");
+    let bundleOutput = context.pluginDefinitionJson.apply(pluginDefinitionJson => {
+      let extraStringAssets = {};
+      extraStringAssets["pluginDefinition.json"] = pluginDefinitionJson;
+      return Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/AdminEventCollectorEntryPoint.mjs", packageDirs, extraStringAssets);
+    });
+    let codeOutput = bundleOutput.apply(b => b.code);
+    let sourceCodeHashOutput = bundleOutput.apply(b => b.sourceCodeHash);
+    let runtime = RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, codeOutput, sourceCodeHashOutput, envVars, memorySize, timeout, undefined, undefined, undefined, undefined, opts);
+    EventCollectorChannel.connect(name, [{
+        channel: eventCollector.channel,
+        eventTopics: eventTopics,
+        resources: resources
+      }], runtime, opts);
+    let isAdminEventCollector = Stdlib_Option.isNone(Plugin_Helpers$ReventlessCore.eventCollectorContextRef.contents[name]);
+    if (isAdminEventCollector) {
+      new (Aws.iam.RolePolicy)(name + `-snsManageSubs`, {
+        policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + `SnsManageSubsPolicy`, [
+          {
+            Sid: "AllowAdminManageCrossPluginSnsSubscriptions",
+            Effect: "Allow",
+            Action: [
+              "sns:Subscribe",
+              "sns:Unsubscribe",
+              "sns:ListSubscriptionsByTopic",
+              "sns:GetSubscriptionAttributes"
+            ],
+            Resource: "*"
+          },
+          {
+            Sid: "AllowAdminStartSchemaCreation",
+            Effect: "Allow",
+            Action: [
+              "appsync:StartSchemaCreation",
+              "appsync:GetSchemaCreationStatus",
+              "appsync:GetIntrospectionSchema"
+            ],
+            Resource: "*"
+          }
+        ])),
+        role: runtime.parts.lambdaRole.id
+      });
+      let rmTableOutput = config.pluginReadModelTableName;
+      if (rmTableOutput !== undefined) {
+        let policyJson = rmTableOutput.apply(tableName => PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + `PluginRmScanPolicy`, [{
+            Sid: "AllowAdminScanPluginRm",
+            Effect: "Allow",
+            Action: ["dynamodb:Scan"],
+            Resource: "arn:aws:dynamodb:*:*:table/" + tableName
+          }])));
+        new (Aws.iam.RolePolicy)(name + `-pluginRmScan`, {
+          policy: policyJson,
+          role: runtime.parts.lambdaRole.id
+        });
+      }
+      let schemaTableOutput = config.pluginSchemaPersistenceTableName;
+      if (schemaTableOutput !== undefined) {
+        let policyJson$1 = schemaTableOutput.apply(tableName => PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + `PluginSchemaScanPolicy`, [{
+            Sid: "AllowAdminScanPluginSchemaPersistence",
+            Effect: "Allow",
+            Action: ["dynamodb:Scan"],
+            Resource: "arn:aws:dynamodb:*:*:table/" + tableName
+          }])));
+        new (Aws.iam.RolePolicy)(name + `-pluginSchemaScan`, {
+          policy: policyJson$1,
+          role: runtime.parts.lambdaRole.id
+        });
+      }
+    }
+    let aggregateNameSet = {};
+    context.extensions.forEach(ext => {
+      ext.aggregateNames.forEach(aggName => {
+        aggregateNameSet[aggName] = undefined;
+      });
+    });
+    let queueUrlOutputs = Stdlib_Array.filterMap(Object.keys(aggregateNameSet), aggName => context.publishToAggregates[aggName]);
+    if (queueUrlOutputs.length !== 0) {
+      let policyJsonOutput = Pulumi.all(queueUrlOutputs).apply(urls => {
+        let queueArns = urls.filter(url => typeof url === "string").map(url => {
+          let match = url.split("/");
+          if (match.length !== 5) {
+            return url;
+          }
+          let host = match[2];
+          let acct = match[3];
+          let name = match[4];
+          let region = Stdlib_Option.getOr(host.split(".")[1], "eu-west-1");
+          return `arn:aws:sqs:` + region + `:` + acct + `:` + name;
+        });
+        if (queueArns.length === 0) {
+          return;
+        } else {
+          return PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + `PublishToAggregatesPolicy`, [{
+              Sid: "AllowEcPublishToAggregateCmdTopics",
+              Effect: "Allow",
+              Action: "sqs:SendMessage",
+              Resource: queueArns
+            }]));
+        }
+      });
+      policyJsonOutput.apply(policyOpt => {
+        if (policyOpt !== undefined) {
+          new (Aws.iam.RolePolicy)(name + `-publishToAggregates`, {
+            policy: policyOpt,
+            role: runtime.parts.lambdaRole.id
+          });
+          return;
+        }
+      });
+    }
+  };
+  let forPluginHeartbeat = (param, connect, memorySizeOpt, timeoutOpt, heartbeat) => {
+    let memorySize = memorySizeOpt !== undefined ? memorySizeOpt : 1024;
+    let timeout = timeoutOpt !== undefined ? timeoutOpt : 30;
+    let hbConfig = heartbeatConfigRef.contents;
+    let epQueueUrl = hbConfig.epQueueUrl;
+    if (epQueueUrl === undefined) {
+      return log.warn("PluginRuntime_Builder", undefined, "forPluginHeartbeat skipped (no EP queue URL)");
+    }
+    let resource = Component$ReventlessCore.toPulumiResource(heartbeat);
+    let name = ComponentType$ReventlessCore.nameOpt(resource.__name, Heartbeat$ReventlessCore.componentType);
+    let opts_parent = resource;
+    let opts = {
+      parent: opts_parent
+    };
+    let envVars = {};
+    envVars["EP_QUEUE_URL"] = epQueueUrl;
+    envVars["PLUGIN_ID"] = Pulumi.output(hbConfig.pluginId);
+    envVars["HEARTBEAT_TIMEOUT"] = Pulumi.output(hbConfig.heartbeatTimeout.toString());
+    let match = Util_Bundle$ReventlessAws.buildCodeArchive("@reventlessdev/reventless-aws/src/adapter/Runtime/HeartbeatEntryPoint.mjs", {}, undefined);
+    connect(RuntimeEnvironment_Lambda$ReventlessAws.makeFromCodeAsset(name, match.code, match.sourceCodeHash, envVars, memorySize, timeout, undefined, undefined, undefined, undefined, opts));
+  };
+  let forDcbCommandTopic = (param, connect, $staropt$star, $staropt$star$1, dcbCommandTopic) => {
+    $staropt$star !== undefined;
+    $staropt$star$1 !== undefined;
+    let dcbConfig = dcbConfigRef.contents;
+    let slicePaths = registeredSliceModulePaths.concat(dcbConfig.stateChangeSliceModulePaths).map(param => [
+      param.specPath,
+      param.behaviorPath
+    ]);
+    StateChangeSliceRuntime_Builder_Single$ReventlessAws.forDcbCommandTopic(slicePaths, dcbConfig.dcbTableName, dcbConfig.pluginName, syncStateChangesConfigRef.contents, asyncStateChangesConfigRef.contents, connect, dcbCommandTopic);
+  };
+  let finish = () => {};
+  return {
+    EventCollectorChannel: EventCollectorChannel,
+    registerPluginName: registerPluginName,
+    forPluginEventCollector: forPluginEventCollector,
+    forPluginHeartbeat: forPluginHeartbeat,
+    forDcbCommandTopic: forDcbCommandTopic,
+    finish: finish
+  };
+}
+
+export {
+  log,
+  configRef,
+  dcbConfigRef,
+  registeredSliceModulePaths,
+  registerStateChangeSliceSpec,
+  registerDcbConfig,
+  registerDcbTableName,
+  heartbeatConfigRef,
+  registerHeartbeatConfig,
+  syncStateChangesConfigRef,
+  asyncStateChangesConfigRef,
+  setStateChangesConfig,
+  registerConfig,
+  Make,
+}
+/* log Not a pure module */

package/src/plugin/runtime/Util_PluginMessage_Runtime.res

@@ -0,0 +1,13 @@
+let sendMessage = (~channelId, ~messageBody) =>
+  Effect.tryPromise(
+    ~catch=SQS_Error.classify,
+    () => AwsSdk.SQS_Helpers.sendMessage(~queueId=channelId, ~messageBody),
+  )
+  ->Effect.map(_ => ())
+  ->Effect.retry(SQS_Error.retrySchedule)
+  ->Effect.catchAll(err => {
+    let msg = SQS_Error.message(err)
+    ReventlessCore.EffectLogger.logError(~comp=__MODULE__, "Failed to send message to channel: " ++ msg)
+    ->Effect.flatMap(_ => Effect.fail(err))
+  })
+  ->Effect.runPromise

package/src/plugin/runtime/Util_PluginMessage_Runtime.res.mjs

@@ -0,0 +1,19 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as Effect$1 from "effect/Effect";
+import * as SQS_Helpers$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/SQS_Helpers.res.mjs";
+import * as SQS_Error$ReventlessAws from "../../errors/SQS_Error.res.mjs";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
+
+function sendMessage(channelId, messageBody) {
+  return Effect$1.runPromise(Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(SQS_Error$ReventlessAws.classify, () => SQS_Helpers$AwsSdk.sendMessage(channelId, messageBody, undefined, undefined, undefined)), () => {}), SQS_Error$ReventlessAws.retrySchedule), err => {
+    let msg = SQS_Error$ReventlessAws.message(err);
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logError("Util_PluginMessage_Runtime-ReventlessAws", undefined, "Failed to send message to channel: " + msg), () => Effect$1.fail(err));
+  }));
+}
+
+export {
+  sendMessage,
+}
+/* Effect Not a pure module */

package/src/plugin/stack/Plugin_ExtensionPoint_Builder.res

@@ -0,0 +1,28 @@
+module CommandTopicChannel = CommandTopicChannel.SQS_Sync
+module RuntimeEnvironment = RuntimeEnvironment.Lambda
+module ExtensionPointRuntimeBuilder = PluginExtensionPointRuntime_Builder
+
+module MakeWithConfig = (
+  Config: {
+    let updateApiSchema: option<Reventless.QueryEngine.operations => promise<unit>>
+    let manageSubscriptions: option<
+      (Reventless.Plugin.pluginDefinition, [#connect | #disconnect]) => promise<unit>,
+    >
+  },
+): ReventlessCore.ExtensionPoint.T => ReventlessCore.PluginExtensionPoint_Builder.Make(
+  {
+    let runtimeOps = PluginRuntimeOperations.operations
+    let environment = PulumiAws.Lambda.environment->Option.getOr("unknown")
+    let updateApiSchema = Config.updateApiSchema
+    let manageSubscriptions = Config.manageSubscriptions
+  },
+  RuntimeEnvironment,
+  CommandTopicChannel,
+  EventTopicPublisher.SNS,
+  ExtensionPointRuntimeBuilder,
+)
+
+module Make: ReventlessCore.ExtensionPoint.T = MakeWithConfig({
+  let updateApiSchema = None
+  let manageSubscriptions = None
+})

package/src/plugin/stack/Plugin_ExtensionPoint_Builder.res.mjs

@@ -0,0 +1,67 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as EventTopicPublisher_SNS$ReventlessAws from "../../adapter/EventTopic/EventTopicPublisher_SNS.res.mjs";
+import * as PluginRuntimeOperations$ReventlessAws from "../runtime/PluginRuntimeOperations.res.mjs";
+import * as RuntimeEnvironment_Lambda$ReventlessAws from "../../adapter/Runtime/RuntimeEnvironment_Lambda.res.mjs";
+import * as CommandTopicChannel_SQS_Sync$ReventlessAws from "../../adapter/CommandTopic/CommandTopicChannel_SQS_Sync.res.mjs";
+import * as PluginExtensionPoint_Builder$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/connect/PluginExtensionPoint_Builder.res.mjs";
+import * as PluginExtensionPointRuntime_Builder$ReventlessAws from "../runtime/PluginExtensionPointRuntime_Builder.res.mjs";
+
+function MakeWithConfig(Config) {
+  let environment = Stdlib_Option.getOr(process.env.Environment, "unknown");
+  return PluginExtensionPoint_Builder$ReventlessCore.Make({
+    runtimeOps: PluginRuntimeOperations$ReventlessAws.operations,
+    environment: environment,
+    updateApiSchema: Config.updateApiSchema,
+    manageSubscriptions: Config.manageSubscriptions
+  })({
+    make: RuntimeEnvironment_Lambda$ReventlessAws.make,
+    groupBySource: RuntimeEnvironment_Lambda$ReventlessAws.groupBySource,
+    extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
+    asEventHandler: prim => prim,
+    asEffectHandler: prim => prim
+  })({
+    make: CommandTopicChannel_SQS_Sync$ReventlessAws.make
+  })({
+    make: EventTopicPublisher_SNS$ReventlessAws.make
+  })({
+    forCommandTopic: PluginExtensionPointRuntime_Builder$ReventlessAws.forCommandTopic
+  });
+}
+
+let environment = Stdlib_Option.getOr(process.env.Environment, "unknown");
+
+let Make = PluginExtensionPoint_Builder$ReventlessCore.Make({
+  runtimeOps: PluginRuntimeOperations$ReventlessAws.operations,
+  environment: environment,
+  updateApiSchema: undefined,
+  manageSubscriptions: undefined
+})({
+  make: RuntimeEnvironment_Lambda$ReventlessAws.make,
+  groupBySource: RuntimeEnvironment_Lambda$ReventlessAws.groupBySource,
+  extractCorrelationId: RuntimeEnvironment_Lambda$ReventlessAws.extractCorrelationId,
+  asEventHandler: prim => prim,
+  asEffectHandler: prim => prim
+})({
+  make: CommandTopicChannel_SQS_Sync$ReventlessAws.make
+})({
+  make: EventTopicPublisher_SNS$ReventlessAws.make
+})({
+  forCommandTopic: PluginExtensionPointRuntime_Builder$ReventlessAws.forCommandTopic
+});
+
+let CommandTopicChannel;
+
+let RuntimeEnvironment;
+
+let ExtensionPointRuntimeBuilder;
+
+export {
+  CommandTopicChannel,
+  RuntimeEnvironment,
+  ExtensionPointRuntimeBuilder,
+  MakeWithConfig,
+  Make,
+}
+/* Make Not a pure module */