@reventlessdev/reventless-aws 3.0.0-alpha.231 → 3.0.0-alpha.233

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res.mjs

@@ -0,0 +1,651 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+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 Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as SNS_Helpers$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/SNS_Helpers.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as HandlerFactoryHelpersMjs from "./HandlerFactoryHelpers.mjs";
+import * as Plugin_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Callback.res.mjs";
+import * as Util_PluginMessage_Runtime$ReventlessAws from "../../plugin/runtime/Util_PluginMessage_Runtime.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+import * as EventTopicPublisher_SNS_Runtime$ReventlessAws from "../EventTopic/EventTopicPublisher_SNS_Runtime.res.mjs";
+import * as EventCollectorChannel_SQS_Runtime$ReventlessAws from "../EventCollector/EventCollectorChannel_SQS_Runtime.res.mjs";
+import * as ScheduledPublisher_CloudWatchEvents_Runtime$ReventlessAws from "../ScheduledPublisher/ScheduledPublisher_CloudWatchEvents_Runtime.res.mjs";
+
+function setRequestId(prim) {
+  HandlerFactoryHelpersMjs.setRequestId(prim);
+}
+
+function runEffect(prim0, prim1) {
+  return HandlerFactoryHelpersMjs.runEffect(prim0, prim1);
+}
+
+function extractMetaField(prim0, prim1) {
+  return HandlerFactoryHelpersMjs.extractMetaField(prim0, prim1);
+}
+
+function extractSentTimestamp(prim) {
+  return HandlerFactoryHelpersMjs.extractSentTimestamp(prim);
+}
+
+function extractRetryCount(prim) {
+  return HandlerFactoryHelpersMjs.extractRetryCount(prim);
+}
+
+function logDebug(prim0, prim1) {
+  HandlerFactoryHelpersMjs.log.debug(prim0, prim1);
+}
+
+function logInfo(prim0, prim1) {
+  HandlerFactoryHelpersMjs.log.info(prim0, prim1);
+}
+
+function logWarn(prim0, prim1) {
+  HandlerFactoryHelpersMjs.log.warn(prim0, prim1);
+}
+
+function logError(prim0, prim1) {
+  HandlerFactoryHelpersMjs.log.error(prim0, prim1);
+}
+
+function scanByTableName(prim0, prim1, prim2) {
+  return HandlerFactoryHelpersMjs.scanByTableName(prim0, prim1, prim2);
+}
+
+function exnMessage(exn) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown error");
+}
+
+function jsOption(v) {
+  if (v == null) {
+    return;
+  } else {
+    return Primitive_option.some(v);
+  }
+}
+
+function strOf(obj, key) {
+  return Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.string);
+}
+
+function strArrOf(obj, key) {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.string);
+}
+
+function strDictOf(obj, key) {
+  return Object.fromEntries(Stdlib_Array.filterMap(Object.entries(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.object), {})), param => {
+    let k = param[0];
+    return Stdlib_Option.map(Stdlib_JSON.Decode.string(param[1]), s => [
+      k,
+      s
+    ]);
+  }));
+}
+
+function parseHandlerConfig(rawJson) {
+  if (rawJson === "") {
+    Stdlib_JsError.throwWithMessage("HANDLER_CONFIG env var is empty");
+  }
+  let json;
+  try {
+    json = JSON.parse(rawJson);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    json = Stdlib_JsError.throwWithMessage("HANDLER_CONFIG JSON parse error: " + exnMessage(exn));
+  }
+  let o = Stdlib_JSON.Decode.object(json);
+  let obj = o !== undefined ? o : Stdlib_JsError.throwWithMessage("HANDLER_CONFIG is not a JSON object");
+  [
+    "queueUrl",
+    "pluginExtensionPointCmdTopicUrl",
+    "eventTopicArn",
+    "pluginReadModelTableName",
+    "appSyncApiId",
+    "schedulerRoleArn",
+    "schedulerQueueArn",
+    "schedulerQueueName",
+    "extensionPoints",
+    "extensions",
+    "publishToAggregates"
+  ].forEach(k => {
+    if (Stdlib_Option.isNone(obj[k])) {
+      return Stdlib_JsError.throwWithMessage("HANDLER_CONFIG missing required field: " + k);
+    }
+  });
+  let items = Stdlib_Option.flatMap(obj["extensionPoints"], Stdlib_JSON.Decode.array);
+  let extensionPoints = items !== undefined ? Stdlib_Array.filterMap(items, item => Stdlib_Option.map(Stdlib_JSON.Decode.object(item), ep => ({
+      specModule: Stdlib_Option.getOr(strOf(ep, "specModule"), ""),
+      mappingsModule: Stdlib_Option.getOr(strOf(ep, "mappingsModule"), ""),
+      eventTopicArn: Stdlib_Option.getOr(strOf(ep, "eventTopicArn"), ""),
+      aggregateNames: strArrOf(ep, "aggregateNames")
+    }))) : Stdlib_JsError.throwWithMessage("HANDLER_CONFIG.extensionPoints must be an array");
+  let items$1 = Stdlib_Option.flatMap(obj["extensions"], Stdlib_JSON.Decode.array);
+  let extensions = items$1 !== undefined ? Stdlib_Array.filterMap(items$1, item => Stdlib_Option.map(Stdlib_JSON.Decode.object(item), ext => {
+      let extensionPointName = Stdlib_Option.getOr(strOf(ext, "extensionPointName"), "");
+      return {
+        name: Stdlib_Option.getOr(strOf(ext, "name"), extensionPointName === "" ? "unknown" : extensionPointName),
+        specModule: Stdlib_Option.getOr(strOf(ext, "specModule"), ""),
+        mappingsModule: Stdlib_Option.getOr(strOf(ext, "mappingsModule"), ""),
+        delegateModule: Stdlib_Option.getOr(strOf(ext, "delegateModule"), ""),
+        extensionPointName: extensionPointName,
+        aggregateNames: strArrOf(ext, "aggregateNames"),
+        readModelNames: strArrOf(ext, "readModelNames")
+      };
+    })) : Stdlib_JsError.throwWithMessage("HANDLER_CONFIG.extensions must be an array");
+  let connectExtension = Stdlib_Option.map(Stdlib_Option.flatMap(obj["connectExtension"], Stdlib_JSON.Decode.object), ce => ({
+    specModule: Stdlib_Option.getOr(strOf(ce, "specModule"), ""),
+    mappingsModule: Stdlib_Option.getOr(strOf(ce, "mappingsModule"), ""),
+    extensionPointName: Stdlib_Option.getOr(strOf(ce, "extensionPointName"), "")
+  }));
+  let readModelNamesForSourceName = Object.fromEntries(Object.entries(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["readModelNamesForSourceName"], Stdlib_JSON.Decode.object), {})).map(param => [
+    param[0],
+    Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_JSON.Decode.array(param[1]), []), Stdlib_JSON.Decode.string)
+  ]));
+  return {
+    queueUrl: Stdlib_Option.getOr(strOf(obj, "queueUrl"), ""),
+    pluginExtensionPointCmdTopicUrl: Stdlib_Option.getOr(strOf(obj, "pluginExtensionPointCmdTopicUrl"), ""),
+    eventTopicArn: Stdlib_Option.getOr(strOf(obj, "eventTopicArn"), ""),
+    pluginReadModelTableName: Stdlib_Option.getOr(strOf(obj, "pluginReadModelTableName"), ""),
+    appSyncApiId: Stdlib_Option.getOr(strOf(obj, "appSyncApiId"), ""),
+    schedulerRoleArn: Stdlib_Option.getOr(strOf(obj, "schedulerRoleArn"), ""),
+    schedulerQueueArn: Stdlib_Option.getOr(strOf(obj, "schedulerQueueArn"), ""),
+    schedulerQueueName: Stdlib_Option.getOr(strOf(obj, "schedulerQueueName"), ""),
+    extensionPoints: extensionPoints,
+    connectExtension: connectExtension,
+    extensions: extensions,
+    publishToAggregates: strDictOf(obj, "publishToAggregates"),
+    readModelQueueUrls: strDictOf(obj, "readModelQueueUrls"),
+    readModelNamesForSourceName: readModelNamesForSourceName
+  };
+}
+
+function projectPluginRow(row) {
+  let obj = Stdlib_JSON.Decode.object(row);
+  if (obj === undefined) {
+    return;
+  }
+  let match = strOf(obj, "id");
+  let match$1 = strOf(obj, "status");
+  if (match === undefined) {
+    return;
+  }
+  if (match$1 === undefined) {
+    return;
+  }
+  let dcbEventLog = Stdlib_Option.flatMap(Stdlib_Option.flatMap(obj["dcbEventLog"], Stdlib_JSON.Decode.object), d => {
+    let match = strOf(d, "name");
+    let match$1 = strOf(d, "eventTopicArn");
+    if (match !== undefined && match$1 !== undefined) {
+      return {
+        name: match,
+        eventTopicArn: match$1
+      };
+    }
+  });
+  let extensions = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["extensions"], Stdlib_JSON.Decode.array), []), e => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(e), eo => Stdlib_Option.map(strOf(eo, "extensionPointName"), extensionPointName => ({
+    name: Stdlib_Option.getOr(strOf(eo, "name"), ""),
+    extensionPointName: extensionPointName,
+    dcbSources: strArrOf(eo, "dcbSources")
+  }))));
+  let extensionPoints = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["extensionPoints"], Stdlib_JSON.Decode.array), []), ep => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(ep), epo => {
+    let match = strOf(epo, "name");
+    let match$1 = strOf(epo, "eventTopic");
+    if (match !== undefined && match$1 !== undefined) {
+      return {
+        name: match,
+        commandTopic: Stdlib_Option.getOr(strOf(epo, "commandTopic"), ""),
+        eventTopic: match$1
+      };
+    }
+  }));
+  return {
+    id: match,
+    status: match$1,
+    eventCollector: Stdlib_Option.getOr(strOf(obj, "eventCollector"), ""),
+    extensions: extensions,
+    extensionPoints: extensionPoints,
+    dcbEventLog: dcbEventLog
+  };
+}
+
+function projectionOfDefinition(d) {
+  return {
+    id: d.id,
+    status: "",
+    eventCollector: d.eventCollector,
+    extensions: d.extensions,
+    extensionPoints: d.extensionPoints,
+    dcbEventLog: Primitive_option.fromNullable(d.dcbEventLog)
+  };
+}
+
+function pluginNameOfId(id) {
+  return Stdlib_Option.getOr(id.split("@")[0], "");
+}
+
+async function trySubscribe(queueArn, topicArn, label) {
+  if (queueArn === "" || topicArn === "") {
+    return;
+  }
+  try {
+    await SNS_Helpers$AwsSdk.subscribeQueueToTopic(queueArn, topicArn);
+    HandlerFactoryHelpersMjs.log.info(`subscribed ` + label + `: ` + topicArn + ` -> ` + queueArn, {
+      comp: "manageSubscriptions"
+    });
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let prim1_comp = "manageSubscriptions";
+    let prim1_detail = exnMessage(exn);
+    let prim1 = {
+      comp: prim1_comp,
+      detail: prim1_detail
+    };
+    HandlerFactoryHelpersMjs.log.error(`subscribe failed ` + label + `: ` + topicArn + ` -> ` + queueArn, prim1);
+    return;
+  }
+}
+
+async function tryUnsubscribe(queueArn, topicArn, label) {
+  if (queueArn === "" || topicArn === "") {
+    return;
+  }
+  try {
+    await SNS_Helpers$AwsSdk.unsubscribeQueueFromTopic(queueArn, topicArn);
+    HandlerFactoryHelpersMjs.log.info(`unsubscribed ` + label + `: ` + topicArn + ` -> ` + queueArn, {
+      comp: "manageSubscriptions"
+    });
+    return;
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let prim1_comp = "manageSubscriptions";
+    let prim1_detail = exnMessage(exn);
+    let prim1 = {
+      comp: prim1_comp,
+      detail: prim1_detail
+    };
+    HandlerFactoryHelpersMjs.log.error(`unsubscribe failed ` + label + `: ` + topicArn + ` -> ` + queueArn, prim1);
+    return;
+  }
+}
+
+let connectedFilter = [[
+    "status",
+    "Contains",
+    {
+      TAG: "String",
+      _0: "Connected"
+    }
+  ]];
+
+async function scanConnectedPeers(tableName, excludeId) {
+  let rows = await HandlerFactoryHelpersMjs.scanByTableName(tableName, connectedFilter, 1000);
+  return Stdlib_Array.filterMap(rows, projectPluginRow).filter(state => state.id !== excludeId);
+}
+
+function makeManageSubscriptions(tableName) {
+  if (tableName === "" || tableName === "NOT_AVAILABLE") {
+    return;
+  } else {
+    return async (pluginDef, action) => {
+      let isConnect = action === "connect";
+      let op = isConnect ? trySubscribe : tryUnsubscribe;
+      let peers = await scanConnectedPeers(tableName, pluginDef.id);
+      let skip;
+      if (isConnect) {
+        skip = false;
+      } else {
+        let myName = pluginNameOfId(pluginDef.id);
+        let sibling = peers.find(p => pluginNameOfId(p.id) === myName);
+        if (sibling !== undefined) {
+          HandlerFactoryHelpersMjs.log.info(`disconnect skipped for ` + pluginDef.id + `: sibling version ` + sibling.id + ` still Connected and shares the same EC queue / EP topics`, {
+            comp: "manageSubscriptions"
+          });
+          skip = true;
+        } else {
+          skip = false;
+        }
+      }
+      if (skip) {
+        return;
+      }
+      for (let i = 0, i_finish = pluginDef.extensions.length; i < i_finish; ++i) {
+        let ext = pluginDef.extensions[i];
+        for (let j = 0, j_finish = peers.length; j < j_finish; ++j) {
+          let peer = peers[j];
+          let peerEp = peer.extensionPoints.find(ep => ep.name === ext.extensionPointName);
+          if (peerEp !== undefined) {
+            await op(pluginDef.eventCollector, peerEp.eventTopic, ext.extensionPointName + ` -> ` + pluginDef.id);
+          }
+        }
+      }
+      for (let i$1 = 0, i_finish$1 = pluginDef.extensionPoints.length; i$1 < i_finish$1; ++i$1) {
+        let ep = pluginDef.extensionPoints[i$1];
+        for (let j$1 = 0, j_finish$1 = peers.length; j$1 < j_finish$1; ++j$1) {
+          let peer$1 = peers[j$1];
+          let match = peer$1.extensions.find(e => e.extensionPointName === ep.name);
+          if (match !== undefined) {
+            await op(peer$1.eventCollector, ep.eventTopic, ep.name + ` -> ` + peer$1.id);
+          }
+        }
+      }
+      for (let i$2 = 0, i_finish$2 = pluginDef.extensions.length; i$2 < i_finish$2; ++i$2) {
+        let ext$1 = pluginDef.extensions[i$2];
+        for (let j$2 = 0, j_finish$2 = ext$1.dcbSources.length; j$2 < j_finish$2; ++j$2) {
+          let dcbSourceName = ext$1.dcbSources[j$2];
+          let peer$2 = peers.find(p => {
+            let l = p.dcbEventLog;
+            if (l !== undefined) {
+              return l.name === dcbSourceName;
+            } else {
+              return false;
+            }
+          });
+          if (peer$2 !== undefined) {
+            let l = peer$2.dcbEventLog;
+            if (l !== undefined) {
+              await op(pluginDef.eventCollector, l.eventTopicArn, `dcb ` + dcbSourceName + ` -> ` + pluginDef.id);
+            }
+          }
+        }
+      }
+      let myDcb = pluginDef.dcbEventLog;
+      if (myDcb === undefined) {
+        return;
+      }
+      for (let j$3 = 0, j_finish$3 = peers.length; j$3 < j_finish$3; ++j$3) {
+        let peer$3 = peers[j$3];
+        let consuming = peer$3.extensions.some(e => e.dcbSources.includes(myDcb.name));
+        if (consuming) {
+          await op(peer$3.eventCollector, myDcb.eventTopicArn, `dcb ` + myDcb.name + ` -> ` + peer$3.id);
+        }
+      }
+    };
+  }
+}
+
+function manageForDefinition(manage) {
+  return Stdlib_Option.map(manage, m => ((d, a) => m(projectionOfDefinition(d), a)));
+}
+
+async function reconcileSubscriptionsOnce(tableName, manage) {
+  if (manage === undefined) {
+    return;
+  }
+  if (tableName === "" || tableName === "NOT_AVAILABLE") {
+    return;
+  }
+  try {
+    let rows = await HandlerFactoryHelpersMjs.scanByTableName(tableName, connectedFilter, 1000);
+    for (let i = 0, i_finish = rows.length; i < i_finish; ++i) {
+      let state = projectPluginRow(rows[i]);
+      if (state !== undefined) {
+        try {
+          await manage(state, "connect");
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          let prim1_comp = "reconcileSubscriptions";
+          let prim1_detail = exnMessage(exn);
+          let prim1 = {
+            comp: prim1_comp,
+            detail: prim1_detail
+          };
+          HandlerFactoryHelpersMjs.log.warn("manageSubscriptions failed", prim1);
+        }
+      }
+    }
+    return;
+  } catch (raw_exn$1) {
+    let exn$1 = Primitive_exceptions.internalToException(raw_exn$1);
+    let prim1_comp$1 = "reconcileSubscriptions";
+    let prim1_detail$1 = exnMessage(exn$1);
+    let prim1$1 = {
+      comp: prim1_comp$1,
+      detail: prim1_detail$1
+    };
+    HandlerFactoryHelpersMjs.log.warn("scan failed", prim1$1);
+    return;
+  }
+}
+
+let environment = Stdlib_Option.getOr(process.env["Environment"], "unknown");
+
+let runtimeOps = {
+  messagePublish: {
+    sendMessageToChannel: Util_PluginMessage_Runtime$ReventlessAws.sendMessage
+  }
+};
+
+let invalidNameChars = /[^.\-_a-zA-Z0-9]/g;
+
+function resourceNaming_validateName(n) {
+  return n.replace(invalidNameChars, "_");
+}
+
+function resourceNaming_urnName(arn) {
+  return Stdlib_Option.getOr(Stdlib_Option.filter(arn.split(":")[5], s => s !== ""), "unknown");
+}
+
+let resourceNaming = {
+  validateName: resourceNaming_validateName,
+  urnName: resourceNaming_urnName
+};
+
+function makeQueryEngine(pluginReadModelTableName) {
+  return {
+    scan: (param, filterConfigs, limit) => HandlerFactoryHelpersMjs.scanByTableName(pluginReadModelTableName, filterConfigs, limit),
+    query: async (param, param$1, param$2, param$3, param$4, param$5, param$6) => Stdlib_JsError.throwWithMessage("QueryEngine.query not available in bundled Plugin EventCollector")
+  };
+}
+
+function makeScheduler(schedulerRoleArn) {
+  return {
+    createSchedule: ScheduledPublisher_CloudWatchEvents_Runtime$ReventlessAws.createSchedule(schedulerRoleArn),
+    deleteSchedule: ScheduledPublisher_CloudWatchEvents_Runtime$ReventlessAws.deleteSchedule
+  };
+}
+
+function makeCommandTopicResources(config) {
+  if (config.schedulerQueueArn === "") {
+    return [];
+  } else {
+    return [{
+        name: config.schedulerQueueName,
+        id: config.schedulerQueueName,
+        urn: config.schedulerQueueArn,
+        resourceInfo: "NoInfo",
+        service: "unknown",
+        role: "",
+        region: "",
+        resourceType: "",
+        configuration: {},
+        tags: {}
+      }];
+  }
+}
+
+function makePublishToEventTopic(eventTopicArn) {
+  let topic = {
+    id: eventTopicArn,
+    name: eventTopicArn,
+    arn: eventTopicArn
+  };
+  return (id, meta, json) => EventTopicPublisher_SNS_Runtime$ReventlessAws.publish(topic, id, meta, json);
+}
+
+function makePublishJsons(queueUrl) {
+  let queue = {
+    id: queueUrl,
+    name: queueUrl,
+    arn: ""
+  };
+  return CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO");
+}
+
+function buildPublishToAggregates(map) {
+  return Object.fromEntries(Object.entries(map).map(param => [
+    param[0],
+    makePublishJsons(Stdlib_Option.getOr(process.env[param[1]], ""))
+  ]));
+}
+
+function extensionPublishDicts(config, ext) {
+  let resolve = (names, envVarNames) => Object.fromEntries(Stdlib_Array.filterMap(names, name => Stdlib_Option.map(Stdlib_Option.filter(Stdlib_Option.flatMap(envVarNames[name], envVarName => process.env[envVarName]), queueUrl => queueUrl !== ""), queueUrl => [
+    name,
+    makePublishJsons(queueUrl)
+  ])));
+  return {
+    publishToAggregates: resolve(ext.aggregateNames, config.publishToAggregates),
+    publishToReadModels: resolve(ext.readModelNames, config.readModelQueueUrls),
+    readModelNamesForSourceName: Object.fromEntries([[
+        ext.extensionPointName,
+        Stdlib_Option.getOr(config.readModelNamesForSourceName[ext.extensionPointName], [])
+      ]])
+  };
+}
+
+function warnSkippedExtension(ext) {
+  HandlerFactoryHelpersMjs.log.warn(`extension '` + ext.name + `' missing module specifier(s); skipping. specModule=` + ext.specModule + `, mappingsModule=` + ext.mappingsModule + `, delegateModule=` + ext.delegateModule, {
+    comp: "EventCollectorEntryPoint"
+  });
+}
+
+function loadPluginDefinition() {
+  try {
+    return JSON.parse(Nodefs.readFileSync(new URL("./pluginDefinition.json", `file://` + process.cwd() + `/`), "utf-8"));
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    return Stdlib_JsError.throwWithMessage("Failed to load pluginDefinition.json from asset zip: " + exnMessage(exn));
+  }
+}
+
+function loadUiFragments() {
+  try {
+    let json = JSON.parse(Nodefs.readFileSync(new URL("./uiFragments.json", `file://` + process.cwd() + `/`), "utf-8"));
+    if (json === null) {
+      return;
+    } else {
+      return json;
+    }
+  } catch (exn) {
+    return;
+  }
+}
+
+function pushHandler(d, key, h) {
+  let arr = d[key];
+  if (arr !== undefined) {
+    arr.push(h);
+  } else {
+    d[key] = [h];
+  }
+}
+
+function makeSqsHandlerBundle(input) {
+  let outgoingExtensionPointEventHandlers = {};
+  input.epHandlers.forEach(eph => {
+    eph.aggregateNames.forEach(k => pushHandler(outgoingExtensionPointEventHandlers, k, eph.outgoingHandler));
+  });
+  let c = input.connectExtensionHandler;
+  let incomingConnectExtensionEventHandlers = c !== undefined ? Object.fromEntries([[
+        c.extensionPointName,
+        [c.incomingHandler]
+      ]]) : ({});
+  let outgoingExtensionEventHandlers = {};
+  let incomingExtensionEventHandlers = {};
+  input.extensionHandlers.forEach(eh => {
+    eh.aggregateNames.forEach(k => pushHandler(outgoingExtensionEventHandlers, k, eh.outgoingHandler));
+    pushHandler(incomingExtensionEventHandlers, eh.extensionPointName, eh.incomingHandler);
+  });
+  let pluginDefinition = input.pluginDefinition;
+  let Callback = Plugin_Callback$ReventlessCore.Make({
+    pluginDefinition: pluginDefinition,
+    incomingConnectExtensionEventHandlers: incomingConnectExtensionEventHandlers,
+    outgoingExtensionPointEventHandlers: outgoingExtensionPointEventHandlers,
+    outgoingExtensionEventHandlers: outgoingExtensionEventHandlers,
+    incomingExtensionEventHandlers: incomingExtensionEventHandlers
+  });
+  let queue_id = input.queueUrl;
+  let queue_name = input.queueUrl;
+  let queue = {
+    id: queue_id,
+    name: queue_name,
+    arn: ""
+  };
+  return {
+    sqsHandler: EventCollectorChannel_SQS_Runtime$ReventlessAws.handleDynamoDbOrSqsEvent(queue, Callback.handleJsonEvents),
+    comp: `Plugin(` + input.pluginDefinition.id + `)`
+  };
+}
+
+function makeHandler(bundlePromise) {
+  return async (event, context) => {
+    HandlerFactoryHelpersMjs.setRequestId(context.awsRequestId);
+    let records = event.Records;
+    let prim0 = `processing ` + records.length.toString() + ` record(s)`;
+    HandlerFactoryHelpersMjs.log.debug(prim0, {
+      comp: "PluginEventCollectorRuntime"
+    });
+    let bundle = await bundlePromise;
+    await HandlerFactoryHelpersMjs.runEffect(bundle.sqsHandler(event, context), {
+      correlationId: HandlerFactoryHelpersMjs.extractMetaField(records, "correlationId"),
+      causationId: HandlerFactoryHelpersMjs.extractMetaField(records, "causationId"),
+      comp: bundle.comp,
+      timestamp: HandlerFactoryHelpersMjs.extractSentTimestamp(records),
+      retryCount: HandlerFactoryHelpersMjs.extractRetryCount(records)
+    });
+    return "";
+  };
+}
+
+export {
+  setRequestId,
+  runEffect,
+  extractMetaField,
+  extractSentTimestamp,
+  extractRetryCount,
+  logDebug,
+  logInfo,
+  logWarn,
+  logError,
+  scanByTableName,
+  exnMessage,
+  jsOption,
+  strOf,
+  strArrOf,
+  strDictOf,
+  parseHandlerConfig,
+  projectPluginRow,
+  projectionOfDefinition,
+  pluginNameOfId,
+  trySubscribe,
+  tryUnsubscribe,
+  connectedFilter,
+  scanConnectedPeers,
+  makeManageSubscriptions,
+  manageForDefinition,
+  reconcileSubscriptionsOnce,
+  environment,
+  runtimeOps,
+  invalidNameChars,
+  resourceNaming,
+  makeQueryEngine,
+  makeScheduler,
+  makeCommandTopicResources,
+  makePublishToEventTopic,
+  makePublishJsons,
+  buildPublishToAggregates,
+  extensionPublishDicts,
+  warnSkippedExtension,
+  loadPluginDefinition,
+  loadUiFragments,
+  pushHandler,
+  makeSqsHandlerBundle,
+  makeHandler,
+}
+/* environment Not a pure module */