@reventlessdev/reventless-aws 3.0.0-alpha.229 → 3.0.0-alpha.230

package/src/adapter/Geocoder/Geocoder_AwsLocation_Ops.res.mjs

@@ -0,0 +1,124 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as ClientLocation from "@aws-sdk/client-location";
+
+function getEnv(k) {
+  let v = process.env[k];
+  if (v !== undefined && v !== "") {
+    return v;
+  }
+}
+
+function corsHeaders() {
+  return Object.fromEntries([
+    [
+      "content-type",
+      "application/json"
+    ],
+    [
+      "access-control-allow-origin",
+      "*"
+    ],
+    [
+      "access-control-allow-methods",
+      "GET,OPTIONS"
+    ],
+    [
+      "access-control-allow-headers",
+      "*"
+    ]
+  ]);
+}
+
+function readQueryParam(event) {
+  let q = Stdlib_Option.flatMap(event.queryStringParameters, p => p["q"]);
+  if (q !== undefined) {
+    return q;
+  } else {
+    return Stdlib_Option.flatMap(event.rawQueryString, raw => Stdlib_Array.findMap(raw.split("&"), pair => {
+      let match = pair.split("=");
+      if (match.length !== 2) {
+        return;
+      }
+      let k = match[0];
+      let v = match[1];
+      if (k === "q") {
+        return decodeURIComponent(v);
+      }
+    }));
+  }
+}
+
+async function handler(event) {
+  try {
+    let indexName = Stdlib_Option.getOr(getEnv("PLACE_INDEX_NAME"), "");
+    let q = Stdlib_Option.getOr(readQueryParam(event), "");
+    if (indexName === "" || q === "") {
+      return {
+        statusCode: 200,
+        headers: corsHeaders(),
+        body: "[]"
+      };
+    }
+    let client = new ClientLocation.LocationClient();
+    let resp = await client.send(new ClientLocation.SearchPlaceIndexForTextCommand({
+      IndexName: indexName,
+      Text: q,
+      MaxResults: 5
+    }));
+    let results = Stdlib_Array.filterMap(Stdlib_Option.getOr(resp.Results, []), r => {
+      let place = r.Place;
+      if (place === undefined) {
+        return;
+      }
+      let label = Stdlib_Option.getOr(place.Label, "");
+      let pt = Stdlib_Option.flatMap(place.Geometry, g => g.Point);
+      if (pt === undefined) {
+        return;
+      }
+      if (pt.length < 2) {
+        return;
+      }
+      let lng = pt[0];
+      let lat = pt[1];
+      return Object.fromEntries([
+        [
+          "label",
+          label
+        ],
+        [
+          "lat",
+          lat
+        ],
+        [
+          "lng",
+          lng
+        ]
+      ]);
+    });
+    return {
+      statusCode: 200,
+      headers: corsHeaders(),
+      body: JSON.stringify(results)
+    };
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    console.error("Geocoder: search failed", exn);
+    return {
+      statusCode: 200,
+      headers: corsHeaders(),
+      body: "[]"
+    };
+  }
+}
+
+export {
+  getEnv,
+  corsHeaders,
+  readQueryParam,
+  handler,
+}
+/* @aws-sdk/client-location Not a pure module */

package/src/adapter/Runtime/HeartbeatEntryPoint.res

@@ -0,0 +1,44 @@
+// Heartbeat Lambda entry point — compiled, type-checked ReScript (replaces the
+// hand-written HeartbeatEntryPoint.mjs shell; no dynamic user-module import, so
+// no untyped seam is needed).
+//
+// Publishes a Heartbeat(timeout) command to the PluginExtensionPoint
+// CommandTopic. Triggered by CloudWatch Events on a schedule. Runtime-pure: no
+// Pulumi value reaches this module's import graph (deploy-time wiring lives in
+// PluginRuntime_Builder.forPluginHeartbeat).
+
+@val @scope("process") external processEnv: dict<string> = "env"
+
+// === Initialize eagerly at module load (Lambda cold start) ===
+
+let epQueueUrl = processEnv->Dict.get("EP_QUEUE_URL")->Option.getOr("")
+let pluginId = processEnv->Dict.get("PLUGIN_ID")->Option.getOr("")
+// Mirrors the former shell's `parseInt(…) || 10`: unset, unparsable, and 0 all
+// fall back to the 10-minute default.
+let timeout =
+  processEnv
+  ->Dict.get("HEARTBEAT_TIMEOUT")
+  ->Option.flatMap(s => Int.fromString(s))
+  ->Option.filter(n => n != 0)
+  ->Option.getOr(10)
+
+let queue: Util_SQS_Runtime.resolvedQueue = {id: epQueueUrl, name: epQueueUrl, arn: ""}
+let publishJsons = queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO)
+
+// === Exported handler ===
+
+let handler = async (_event: JSON.t, _context: PulumiAws.Lambda.context) => {
+  let message: ReventlessCore.Message.commandJson = {
+    id: pluginId,
+    meta: ReventlessCore.Message.generateMeta(
+      ~service=ReventlessInfra.PluginExtensionPointSpec.name,
+      ~ip="",
+      ~user="Heartbeat",
+    ),
+    commandJson: ReventlessInfra.PluginExtensionPointSpec.Heartbeat(
+      timeout,
+    )->S.reverseConvertToJsonOrThrow(ReventlessInfra.PluginExtensionPointSpec.commandSchema),
+  }
+  await publishJsons([message])
+  ""
+}

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

@@ -0,0 +1,47 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+
+let epQueueUrl = Stdlib_Option.getOr(process.env["EP_QUEUE_URL"], "");
+
+let pluginId = Stdlib_Option.getOr(process.env["PLUGIN_ID"], "");
+
+let timeout = Stdlib_Option.getOr(Stdlib_Option.filter(Stdlib_Option.flatMap(process.env["HEARTBEAT_TIMEOUT"], s => Stdlib_Int.fromString(s, undefined)), n => n !== 0), 10);
+
+let queue = {
+  id: epQueueUrl,
+  name: epQueueUrl,
+  arn: ""
+};
+
+let publishJsons = CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO");
+
+async function handler(_event, _context) {
+  let message_meta = Message$ReventlessCore.generateMeta(PluginExtensionPointSpec$ReventlessInfra.name, "", "Heartbeat", undefined, undefined, undefined, undefined, undefined);
+  let message_commandJson = S.reverseConvertToJsonOrThrow({
+    TAG: "Heartbeat",
+    _0: timeout
+  }, PluginExtensionPointSpec$ReventlessInfra.commandSchema);
+  let message = {
+    id: pluginId,
+    meta: message_meta,
+    commandJson: message_commandJson
+  };
+  await publishJsons([message]);
+  return "";
+}
+
+export {
+  epQueueUrl,
+  pluginId,
+  timeout,
+  queue,
+  publishJsons,
+  handler,
+}
+/* epQueueUrl Not a pure module */

package/src/adapter/Runtime/PluginExtensionPointEntryPoint.res

@@ -0,0 +1,234 @@
+// PluginExtensionPoint Lambda entry point — compiled, type-checked ReScript
+// (replaces the hand-written PluginExtensionPointEntryPoint.mjs shell).
+//
+// All wiring is framework modules — no user modules, hence no dynamic-import
+// seam and no reason to stay untyped. Handles Heartbeat, Cloner, and other
+// plugin-level extension point commands.
+//
+// The former shell's `patchSpecId` hack (re-adding the `Id` module that the
+// ESM export of a `module Id = …` alias drops) disappears: `SpecWithId` below
+// binds the Id module at the ReScript level, mirroring ExtensionPoint_Builder.
+// Runtime-pure: no Pulumi value reaches this module's import graph.
+
+@val @scope("process") external processEnv: dict<string> = "env"
+
+// ── Shim bindings (HandlerFactoryHelpers.mjs) ───────────────────────────────
+// The structured-log + Effect dispatch boundary shared by every deployed entry
+// point (single place where invocations get their log annotations and
+// RequestContext), and the DynamoDB scan backing the read-model query engine.
+
+// Extra fields threaded onto the dispatch boundary / log lines. The shim reads
+// them structurally, so one record serves both `runEffect` and `log.debug`.
+type dispatchOpts = {
+  correlationId?: string,
+  causationId?: string,
+  comp?: string,
+  timestamp?: float,
+  retryCount?: int,
+}
+
+@module("./HandlerFactoryHelpers.mjs")
+external setRequestId: string => unit = "setRequestId"
+@module("./HandlerFactoryHelpers.mjs")
+external runEffect: (Effect.t<'a, 'e, 'r>, dispatchOpts) => promise<unit> = "runEffect"
+@module("./HandlerFactoryHelpers.mjs")
+external extractMetaField: (array<PulumiAws.SQS.Queue.record>, string) => option<string> =
+  "extractMetaField"
+@module("./HandlerFactoryHelpers.mjs")
+external extractSentTimestamp: array<PulumiAws.SQS.Queue.record> => option<float> =
+  "extractSentTimestamp"
+@module("./HandlerFactoryHelpers.mjs")
+external extractRetryCount: array<PulumiAws.SQS.Queue.record> => int = "extractRetryCount"
+@module("./HandlerFactoryHelpers.mjs") @scope("log")
+external logDebug: (string, dispatchOpts) => unit = "debug"
+@module("./HandlerFactoryHelpers.mjs")
+external scanByTableName: (
+  string,
+  array<Reventless.QueryEngine.Filter.config>,
+  int,
+) => promise<array<JSON.t>> = "scanByTableName"
+
+// ── HANDLER_CONFIG ──────────────────────────────────────────────────────────
+// Written by PluginExtensionPointRuntime_Builder.forCommandTopic; all fields
+// optional so a partial config degrades like the former shell's `|| ""` reads.
+
+type handlerConfig = {
+  queueUrl?: string,
+  pluginReadModelTableName?: string,
+  schedulerRoleArn?: string,
+  schedulerQueueArn?: string,
+  schedulerQueueName?: string,
+  publishToAggregates?: dict<string>,
+}
+@val @scope("JSON") external parseHandlerConfig: string => handlerConfig = "parse"
+
+// === Initialize eagerly at module load (Lambda cold start) ===
+
+let config = processEnv->Dict.get("HANDLER_CONFIG")->Option.getOr("{}")->parseHandlerConfig
+
+// Instantiate the Plugin EP mapping. updateApiSchema and manageSubscriptions
+// are admin-only hooks; this Lambda only handles incoming commands (Heartbeat,
+// ForwardCommand) so they stay None here. Only sendMessageToChannel is used by
+// the incoming-command path (ForwardCommand) — cross-plugin subscribe /
+// unsubscribe directives were retired in Phase 3 Step 3.
+//
+// `environment` prefixes the disconnect schedule's EventBridge rule name, so it
+// must be stable across deploys and unique per stack. The stack name is both;
+// AWS_LAMBDA_FUNCTION_NAME is neither — it carries a content hash, so replacing
+// this Lambda would orphan every outstanding rule the previous generation
+// created. EventCollectorEntryPoint instantiates the same EP module and must
+// agree, or one Lambda creates rules the other cannot delete.
+module EpSpec = {
+  let runtimeOps: ReventlessCore.PluginRuntimeOperations.operations = {
+    messagePublish: {sendMessageToChannel: Util_PluginMessage_Runtime.sendMessage},
+  }
+  let environment = processEnv->Dict.get("Environment")->Option.getOr("unknown")
+  let updateApiSchema: option<Reventless.QueryEngine.operations => promise<unit>> = None
+  let manageSubscriptions: option<
+    (Reventless.Plugin.pluginDefinition, [#connect | #disconnect]) => promise<unit>,
+  > = None
+}
+module PluginMappingInstance = ReventlessCore.PluginExtensionPoint_Plugin.Make(EpSpec)
+
+module Mappings = {
+  module type Mapping = ReventlessInfra.ExtensionPointMapping.T
+    with module ExtensionPoint := ReventlessInfra.PluginExtensionPointSpec
+  // Parity with the former shell: only the Plugin lifecycle mapping. The
+  // in-process wiring (PluginExtensionPoint_Builder) additionally registers
+  // PluginExtensionPoint_UiFragment.Mapping — divergence tracked in
+  // docs/plans/entry-point-rescript-conversion.md.
+  let mappings: array<module(Mapping)> = [module(PluginMappingInstance.Mapping)]
+}
+
+// Reconstruct publishToAggregates. The deploy-side builder writes
+// HANDLER_CONFIG.publishToAggregates as { aggregateName: envVarName }
+// (see PluginExtensionPointRuntime_Builder.res), so iterate accordingly.
+let publishToAggregates: dict<ReventlessCore.CommandTopic.publishJsons> =
+  config.publishToAggregates
+  ->Option.getOr(Dict.make())
+  ->Dict.toArray
+  ->Array.map(((aggName, envVarName)) => {
+    let queueUrl = processEnv->Dict.get(envVarName)->Option.getOr("")
+    let queue: Util_SQS_Runtime.resolvedQueue = {id: queueUrl, name: queueUrl, arn: ""}
+    (aggName, queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO))
+  })
+  ->Dict.fromArray
+
+// Reconstruct queryEngine: scans go to the plugin read-model table; query is
+// not available in this bundled handler (same restriction as the former shell).
+let pluginReadModelTableName = config.pluginReadModelTableName->Option.getOr("")
+let queryEngine: Reventless.QueryEngine.operations = {
+  scan: (~readModelName as _, ~filterConfigs, ~limit) =>
+    scanByTableName(pluginReadModelTableName, filterConfigs, limit),
+  query: async (
+    ~readModelName as _,
+    ~key as _=?,
+    ~id as _,
+    ~subIdConfig as _=?,
+    ~filterConfigs as _=?,
+    ~ascending as _=?,
+    ~limit as _=?,
+  ) => JsError.throwWithMessage("QueryEngine.query not available in bundled Plugin EP handler"),
+}
+
+// Reconstruct scheduler
+let scheduler: ReventlessCore.Scheduler.operations = {
+  createSchedule: ScheduledPublisher_CloudWatchEvents_Runtime.createSchedule(
+    ~roleArn=config.schedulerRoleArn->Option.getOr(""),
+  ),
+  deleteSchedule: ScheduledPublisher_CloudWatchEvents_Runtime.deleteSchedule,
+}
+
+// CommandTopic resources for scheduler targets
+let commandTopicResources: array<ReventlessInfra.Adapter.resolvedResource> = {
+  let schedulerQueueArn = config.schedulerQueueArn->Option.getOr("")
+  let schedulerQueueName = config.schedulerQueueName->Option.getOr("")
+  schedulerQueueArn == ""
+    ? []
+    : [
+        {
+          name: schedulerQueueName,
+          id: schedulerQueueName,
+          urn: schedulerQueueArn,
+          service: "unknown",
+          resourceInfo: ReventlessInfra.Adapter.NoInfo,
+          role: "",
+          region: "",
+          resourceType: "",
+          configuration: Dict.make(),
+          tags: Dict.make(),
+        },
+      ]
+}
+
+let invalidNameChars = %re("/[^.\-_a-zA-Z0-9]/g")
+let resourceNaming: ReventlessInfra.ResourceNaming.operations = {
+  validateName: n => n->String.replaceRegExp(invalidNameChars, "_"),
+  urnName: arn =>
+    arn
+    ->String.split(":")
+    ->Array.get(5)
+    ->Option.filter(s => s != "")
+    ->Option.getOr("unknown"),
+}
+
+module Callback = ReventlessCore.ExtensionPoint_Callback.Make(
+  {
+    let publishToAggregates = publishToAggregates
+    let commandTopicResources = commandTopicResources
+    let scheduler = scheduler
+    let queryEngine = queryEngine
+    let resourceNaming = resourceNaming
+  },
+  ReventlessInfra.PluginExtensionPointSpec,
+  Mappings,
+)
+
+module SpecWithId = {
+  module Id = Reventless.Id.String
+  let name = ReventlessInfra.PluginExtensionPointSpec.name
+  type command = ReventlessInfra.PluginExtensionPointSpec.command
+  let commandSchema = ReventlessInfra.PluginExtensionPointSpec.commandSchema
+}
+
+module CommandTopicCallback = ReventlessCore.CommandTopic_Callback.Make(
+  SpecWithId,
+  {
+    module Spec = SpecWithId
+    let commandsHandler = Callback.handleIncomingCommands
+  },
+)
+
+let queue: Util_SQS_Runtime.resolvedQueue = {
+  id: config.queueUrl->Option.getOr(""),
+  name: config.queueUrl->Option.getOr(""),
+  arn: "",
+}
+let sqsHandler = CommandTopicChannel_SQS_Runtime.handleQueueEvent(
+  queue,
+  CommandTopicCallback.handleJsonCommands,
+)
+let comp = `ExtensionPoint(${ReventlessInfra.PluginExtensionPointSpec.name})`
+
+// === Exported handler ===
+
+let handler = async (event: PulumiAws.SQS.Queue.event, context: PulumiAws.Lambda.context) => {
+  setRequestId(context.awsRequestId)
+  let records = event.records
+
+  logDebug(
+    `processing ${records->Array.length->Int.toString} record(s)`,
+    {comp: "PluginExtensionPointRuntime"},
+  )
+  await runEffect(
+    sqsHandler(event, context),
+    {
+      correlationId: ?extractMetaField(records, "correlationId"),
+      causationId: ?extractMetaField(records, "causationId"),
+      comp,
+      timestamp: ?extractSentTimestamp(records),
+      retryCount: extractRetryCount(records),
+    },
+  )
+  ""
+}

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

@@ -0,0 +1,226 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as HandlerFactoryHelpersMjs from "./HandlerFactoryHelpers.mjs";
+import * as CommandTopic_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Callback.res.mjs";
+import * as ExtensionPoint_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/ExtensionPoint/ExtensionPoint_Callback.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+import * as Util_PluginMessage_Runtime$ReventlessAws from "../../plugin/runtime/Util_PluginMessage_Runtime.res.mjs";
+import * as PluginExtensionPoint_Plugin$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "../CommandTopic/CommandTopicChannel_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 scanByTableName(prim0, prim1, prim2) {
+  return HandlerFactoryHelpersMjs.scanByTableName(prim0, prim1, prim2);
+}
+
+let config = JSON.parse(Stdlib_Option.getOr(process.env["HANDLER_CONFIG"], "{}"));
+
+let runtimeOps = {
+  messagePublish: {
+    sendMessageToChannel: Util_PluginMessage_Runtime$ReventlessAws.sendMessage
+  }
+};
+
+let environment = Stdlib_Option.getOr(process.env["Environment"], "unknown");
+
+let EpSpec = {
+  runtimeOps: runtimeOps,
+  environment: environment,
+  updateApiSchema: undefined,
+  manageSubscriptions: undefined
+};
+
+let PluginMappingInstance = PluginExtensionPoint_Plugin$ReventlessCore.Make(EpSpec);
+
+let mappings = [PluginMappingInstance.Mapping];
+
+let Mappings = {
+  mappings: mappings
+};
+
+let publishToAggregates = Object.fromEntries(Object.entries(Stdlib_Option.getOr(config.publishToAggregates, {})).map(param => {
+  let queueUrl = Stdlib_Option.getOr(process.env[param[1]], "");
+  let queue = {
+    id: queueUrl,
+    name: queueUrl,
+    arn: ""
+  };
+  return [
+    param[0],
+    CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO")
+  ];
+}));
+
+let pluginReadModelTableName = Stdlib_Option.getOr(config.pluginReadModelTableName, "");
+
+function queryEngine_scan(param, filterConfigs, limit) {
+  return HandlerFactoryHelpersMjs.scanByTableName(pluginReadModelTableName, filterConfigs, limit);
+}
+
+async function queryEngine_query(param, param$1, param$2, param$3, param$4, param$5, param$6) {
+  return Stdlib_JsError.throwWithMessage("QueryEngine.query not available in bundled Plugin EP handler");
+}
+
+let queryEngine = {
+  scan: queryEngine_scan,
+  query: queryEngine_query
+};
+
+let scheduler_createSchedule = ScheduledPublisher_CloudWatchEvents_Runtime$ReventlessAws.createSchedule(Stdlib_Option.getOr(config.schedulerRoleArn, ""));
+
+let scheduler = {
+  createSchedule: scheduler_createSchedule,
+  deleteSchedule: ScheduledPublisher_CloudWatchEvents_Runtime$ReventlessAws.deleteSchedule
+};
+
+let schedulerQueueArn = Stdlib_Option.getOr(config.schedulerQueueArn, "");
+
+let schedulerQueueName = Stdlib_Option.getOr(config.schedulerQueueName, "");
+
+let commandTopicResources = schedulerQueueArn === "" ? [] : [{
+      name: schedulerQueueName,
+      id: schedulerQueueName,
+      urn: schedulerQueueArn,
+      resourceInfo: "NoInfo",
+      service: "unknown",
+      role: "",
+      region: "",
+      resourceType: "",
+      configuration: {},
+      tags: {}
+    }];
+
+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
+};
+
+let Callback = ExtensionPoint_Callback$ReventlessCore.Make({
+  publishToAggregates: publishToAggregates,
+  commandTopicResources: commandTopicResources,
+  scheduler: scheduler,
+  queryEngine: queryEngine,
+  resourceNaming: resourceNaming
+})({
+  name: PluginExtensionPointSpec$ReventlessInfra.name,
+  moduleUrl: PluginExtensionPointSpec$ReventlessInfra.moduleUrl,
+  commandSchema: PluginExtensionPointSpec$ReventlessInfra.commandSchema,
+  eventSchema: PluginExtensionPointSpec$ReventlessInfra.eventSchema,
+  directiveSchema: PluginExtensionPointSpec$ReventlessInfra.directiveSchema
+})(Mappings);
+
+let SpecWithId = {
+  Id: undefined,
+  name: PluginExtensionPointSpec$ReventlessInfra.name,
+  commandSchema: PluginExtensionPointSpec$ReventlessInfra.commandSchema
+};
+
+let CommandTopicCallback = CommandTopic_Callback$ReventlessCore.Make({
+  Id: Id$Reventless.$$String,
+  name: PluginExtensionPointSpec$ReventlessInfra.name,
+  commandSchema: PluginExtensionPointSpec$ReventlessInfra.commandSchema
+})({
+  Spec: {
+    Id: Id$Reventless.$$String,
+    name: PluginExtensionPointSpec$ReventlessInfra.name,
+    commandSchema: PluginExtensionPointSpec$ReventlessInfra.commandSchema
+  },
+  commandsHandler: Callback.handleIncomingCommands
+});
+
+let queue_id = Stdlib_Option.getOr(config.queueUrl, "");
+
+let queue_name = Stdlib_Option.getOr(config.queueUrl, "");
+
+let queue = {
+  id: queue_id,
+  name: queue_name,
+  arn: ""
+};
+
+let sqsHandler = CommandTopicChannel_SQS_Runtime$ReventlessAws.handleQueueEvent(queue, CommandTopicCallback.handleJsonCommands);
+
+let comp = `ExtensionPoint(` + PluginExtensionPointSpec$ReventlessInfra.name + `)`;
+
+async function handler(event, context) {
+  HandlerFactoryHelpersMjs.setRequestId(context.awsRequestId);
+  let records = event.Records;
+  let prim0 = `processing ` + records.length.toString() + ` record(s)`;
+  HandlerFactoryHelpersMjs.log.debug(prim0, {
+    comp: "PluginExtensionPointRuntime"
+  });
+  await HandlerFactoryHelpersMjs.runEffect(sqsHandler(event, context), {
+    correlationId: HandlerFactoryHelpersMjs.extractMetaField(records, "correlationId"),
+    causationId: HandlerFactoryHelpersMjs.extractMetaField(records, "causationId"),
+    comp: comp,
+    timestamp: HandlerFactoryHelpersMjs.extractSentTimestamp(records),
+    retryCount: HandlerFactoryHelpersMjs.extractRetryCount(records)
+  });
+  return "";
+}
+
+export {
+  setRequestId,
+  runEffect,
+  extractMetaField,
+  extractSentTimestamp,
+  extractRetryCount,
+  logDebug,
+  scanByTableName,
+  config,
+  EpSpec,
+  PluginMappingInstance,
+  Mappings,
+  publishToAggregates,
+  pluginReadModelTableName,
+  queryEngine,
+  scheduler,
+  commandTopicResources,
+  invalidNameChars,
+  resourceNaming,
+  Callback,
+  SpecWithId,
+  CommandTopicCallback,
+  queue,
+  sqsHandler,
+  comp,
+  handler,
+}
+/* config Not a pure module */