@reventlessdev/reventless-aws 3.0.0-alpha.232 → 3.0.0-alpha.234

package/src/adapter/Runtime/CounterEntryPoint.mjs

@@ -2,90 +2,36 @@
 // At cold start: reads HANDLER_CONFIG, dynamically imports Target Spec and Mappings,
 // wires Counter_Callback.Make + EventMapper_Callback.MakeCounterHandler.
 // Routes DynamoDB Stream events from references and counts tables.
-
-import { schema as surySchema, string as suryString, $$int as suryInt, parseJsonOrThrow } from "sury/src/S.res.mjs";
-import { patchSpecId, makeTableRef, makeQueueRef, log } from "./HandlerFactoryHelpers.mjs";
-import { parseDynamoDbStreamRecordState } from "@reventlessdev/reventless-aws/src/util/Util_DynamoDbStream_Runtime.res.mjs";
-import { Make as counterCallbackMake } from "@reventlessdev/reventless-core/src/components/Counter/Counter_Callback.res.mjs";
+//
+// Thin untyped shell ("typed core, thin shell" —
+// docs/plans/minimize-lambda-entrypoint-mjs-shell.md): this file owns ONLY the
+// seams that are inherently untyped — the dynamic `import()` of the
+// target-spec/mappings modules named in HANDLER_CONFIG, the `patchSpecId`
+// fix-up, and the MakeCounterHandler functor application consuming them.
+// HANDLER_CONFIG parsing, the Counter_Callback.Make application, and the
+// references/counts stream routing live type-checked in
+// CounterEntryPoint_Ops.res.
+
+import { patchSpecId } from "./HandlerFactoryHelpers.mjs";
 import { MakeCounterHandler } from "@reventlessdev/reventless-core/src/components/EventMapper/EventMapper_Callback.res.mjs";
-import { count as qdbCount } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
-import { publishJsons as sqsPublishJsons } from "@reventlessdev/reventless-aws/src/adapter/CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+import * as Ops from "./CounterEntryPoint_Ops.res.mjs";
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
-// Build the referencesView schema: {id: string, inc: int}
-const referencesViewSchema = surySchema(s => ({
-  id: s.m(suryString),
-  inc: s.m(suryInt),
-}));
-
-async function buildHandler() {
-  const configStr = process.env["HANDLER_CONFIG"] || "{}";
-  const config = JSON.parse(configStr);
+async function build() {
+  const config = Ops.parseHandlerConfig(process.env["HANDLER_CONFIG"] || "{}");
 
   const targetSpecModule = await dynamicImport(config.targetSpecModule);
   const mappingsModule = await dynamicImport(config.mappingsModule);
 
   const patchedTarget = patchSpecId(targetSpecModule);
-  const countsTable = makeTableRef(config.countsTableName);
-  const countsDbCount = qdbCount(countsTable);
-
-  const pubJsons = sqsPublishJsons(makeQueueRef(config.publishQueueUrl), "SQS_FIFO");
-  const queryEngine = { query: async () => [], queryAll: async () => [] };
+  const counterHandler = MakeCounterHandler(patchedTarget)(mappingsModule)(Ops.makeCounterOps(config));
 
-  const counterHandler = MakeCounterHandler(patchedTarget)(mappingsModule)({ publishJsons: pubJsons, queryEngine });
-  const callback = counterCallbackMake({
-    name: "BundledCounter",
-    countsDbCount,
-    jsonEventsHandler: counterHandler.handleCounterEvents,
-  });
-
-  return [config.referencesStreamArn, config.countsStreamArn, callback];
+  return Ops.makeHandler(config, counterHandler.handleCounterEvents);
 }
 
-const initPromise = buildHandler();
-
-export async function handler(event, _context) {
-  const [referencesStreamArn, countsStreamArn, callback] = await initPromise;
-  const records = event.Records || [];
-
-  const dynamoDbRecords = records.filter(r =>
-    r.eventSource === "aws:dynamodb" &&
-    (r.eventSourceARN === referencesStreamArn || r.eventSourceARN === countsStreamArn)
-  );
-
-  const referenceRecords = dynamoDbRecords.filter(r => r.eventSourceARN === referencesStreamArn);
-  const countRecords = dynamoDbRecords.filter(r => r.eventSourceARN === countsStreamArn);
-
-  const references = referenceRecords.flatMap(record => {
-    const state = parseDynamoDbStreamRecordState(record);
-    switch (state.TAG) {
-      case 0: { // NewImage(id, newImage)
-        const id = state._0;
-        let inc;
-        try {
-          inc = parseJsonOrThrow(state._1, referencesViewSchema).inc;
-        } catch (_) {
-          inc = 1;
-        }
-        return [[id, inc]];
-      }
-      case 2: // NewAndOldImage — duplicate
-        log.debug("ignoring duplicate id: " + state._0, { comp: "CounterEntryPoint" });
-        return [];
-      default:
-        return [];
-    }
-  });
-
-  const counts = countRecords.flatMap(record => {
-    const state = parseDynamoDbStreamRecordState(record);
-    if (state.TAG === 0 || state.TAG === 2) {
-      return [state._1];
-    }
-    return [];
-  });
+const initPromise = build();
 
-  await callback.counterHandler(references, counts);
-  return "";
+export async function handler(event, context) {
+  return (await initPromise)(event, context);
 }

package/src/adapter/Runtime/CounterEntryPoint_Ops.res

@@ -0,0 +1,145 @@
+// Typed cold-start core for the Counter Lambda entry point.
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md):
+// CounterEntryPoint.mjs keeps only the untyped seam — the dynamic `import()`
+// of the target-spec/mappings modules named in HANDLER_CONFIG, the
+// `patchSpecId` fix-up, and the EventMapper_Callback.MakeCounterHandler
+// functor application consuming them. HANDLER_CONFIG parsing, the
+// Counter_Callback.Make application (a functor over an inline module capturing
+// runtime values), and the references/counts stream routing (the runtime twin
+// of the deploy-time CounterHandler_DynamoDbStream_Runtime.handleStreamEvent,
+// over plain ARN strings instead of Pulumi resources) live here, fully
+// type-checked.
+//
+// Two shapes the former shell got wrong are repaired here:
+// - It read `config.publishQueueUrl`, but the deploy side
+//   (CounterHandler_DynamoDbStream.res) writes `publishChannelId` — the
+//   CountFinished publish went to an undefined queue URL.
+// - Its queryEngine stub had `query`/`queryAll` fields where
+//   QueryEngine.operations needs `scan`/`query`.
+
+type handlerConfig = {
+  targetSpecModule?: string,
+  mappingsModule?: string,
+  countsTableName?: string,
+  // The publish address of the target's command topic (SQS queue URL) — the
+  // field name the deploy side actually writes.
+  publishChannelId?: string,
+  referencesStreamArn?: string,
+  countsStreamArn?: string,
+}
+@val @scope("JSON") external jsonParse: string => handlerConfig = "parse"
+// A real binding (not a bare external) so the shell can import it.
+let parseHandlerConfig = (raw: string): handlerConfig => jsonParse(raw)
+
+// ── Counter-handler operations (third argument of MakeCounterHandler) ───────
+// The query engine is not available in the bundled handler; both operations
+// silently return [] (the former shell's stub intent).
+
+let makeCounterOps = (config: handlerConfig): EventMapperEntryPoint_Ops.counterOps => {
+  let queueUrl = config.publishChannelId->Option.getOr("")
+  let queue: Util_SQS_Runtime.resolvedQueue = {id: queueUrl, name: queueUrl, arn: ""}
+  {
+    publishJsons: queue->CommandTopicChannel_SQS_Runtime.publishJsons(AWS.SQS_FIFO),
+    queryEngine: {
+      scan: async (~readModelName as _, ~filterConfigs as _, ~limit as _) => [],
+      query: async (
+        ~readModelName as _,
+        ~key as _=?,
+        ~id as _,
+        ~subIdConfig as _=?,
+        ~filterConfigs as _=?,
+        ~ascending as _=?,
+        ~limit as _=?,
+      ) => [],
+    },
+  }
+}
+
+// ── Stream routing ──────────────────────────────────────────────────────────
+
+// The references view rows carry the increment to apply: {id, inc}.
+@schema
+type referencesView = {
+  id: string,
+  inc: int,
+}
+
+// Pure routing: split a mixed stream batch into reference increments and
+// count rows, keyed by the two source ARNs. Records from other sources are
+// dropped silently (the former shell's behavior).
+let splitRecords = (
+  ~referencesStreamArn: string,
+  ~countsStreamArn: string,
+  records: array<PulumiAws.DynamoDb.Stream.record>,
+): (array<(string, int)>, array<JSON.t>) => {
+  let dynamoDbRecords =
+    records->Array.filter(record =>
+      record.eventSource == "aws:dynamodb" &&
+        (record.eventSourceARN == referencesStreamArn ||
+          record.eventSourceARN == countsStreamArn)
+    )
+
+  let (referenceRecords, countRecords) =
+    dynamoDbRecords->Array.partition(record => record.eventSourceARN == referencesStreamArn)
+
+  let references = referenceRecords->Array.filterMap(record =>
+    switch record->Util_DynamoDbStream_Runtime.parseDynamoDbStreamRecordState {
+    | NewImage(id, newImage) =>
+      let inc = switch newImage->S.parseJsonOrThrow(referencesViewSchema) {
+      | {inc} => inc
+      | exception _ => 1
+      }
+      Some((id, inc))
+    | NewAndOldImage(id, _, _) =>
+      StreamRoutedEntryPoint_Ops.logDebug(
+        "ignoring duplicate id: " ++ id,
+        {comp: "CounterEntryPoint"},
+      )
+      None
+    | _ => None
+    }
+  )
+
+  let counts = countRecords->Array.filterMap(record =>
+    switch record->Util_DynamoDbStream_Runtime.parseDynamoDbStreamRecordState {
+    | NewImage(_, newImage) | NewAndOldImage(_, newImage, _) => Some(newImage)
+    | _ => None
+    }
+  )
+
+  (references, counts)
+}
+
+let makeHandler = (
+  config: handlerConfig,
+  jsonEventsHandler: ReventlessCore.Counter.jsonEventsHandler,
+) => {
+  module Callback = ReventlessCore.Counter_Callback.Make({
+    let name = "BundledCounter"
+    let countsDbCount = QueryDbStorage_DynamoDb_Runtime.count(
+      (
+        {
+          id: config.countsTableName->Option.getOr(""),
+          name: config.countsTableName->Option.getOr(""),
+          arn: "",
+          hashKey: "id",
+        }: Util_DynamoDb_Runtime.resolvedTable
+      ),
+    )
+    let jsonEventsHandler = jsonEventsHandler
+  })
+
+  let referencesStreamArn = config.referencesStreamArn->Option.getOr("")
+  let countsStreamArn = config.countsStreamArn->Option.getOr("")
+
+  async (event: PulumiAws.DynamoDb.Stream.event, _context: PulumiAws.Lambda.context) => {
+    let (references, counts) = splitRecords(
+      ~referencesStreamArn,
+      ~countsStreamArn,
+      event.records,
+    )
+    await Callback.counterHandler(~references, ~counts)
+    ""
+  }
+}

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

@@ -0,0 +1,129 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+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 Counter_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/Counter/Counter_Callback.res.mjs";
+import * as StreamRoutedEntryPoint_Ops$ReventlessAws from "./StreamRoutedEntryPoint_Ops.res.mjs";
+import * as Util_DynamoDbStream_Runtime$ReventlessAws from "../../util/Util_DynamoDbStream_Runtime.res.mjs";
+import * as CommandTopicChannel_SQS_Runtime$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Runtime.res.mjs";
+import * as QueryDbStorage_DynamoDb_Runtime$ReventlessAws from "../QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+
+function parseHandlerConfig(raw) {
+  return JSON.parse(raw);
+}
+
+function makeCounterOps(config) {
+  let queueUrl = Stdlib_Option.getOr(config.publishChannelId, "");
+  let queue = {
+    id: queueUrl,
+    name: queueUrl,
+    arn: ""
+  };
+  return {
+    publishJsons: CommandTopicChannel_SQS_Runtime$ReventlessAws.publishJsons(queue, "SQS_FIFO"),
+    queryEngine: {
+      scan: async (param, param$1, param$2) => [],
+      query: async (param, param$1, param$2, param$3, param$4, param$5, param$6) => []
+    }
+  };
+}
+
+let referencesViewSchema = S.schema(s => ({
+  id: s.m(S.string),
+  inc: s.m(S.int)
+}));
+
+function splitRecords(referencesStreamArn, countsStreamArn, records) {
+  let dynamoDbRecords = records.filter(record => {
+    if (record.eventSource === "aws:dynamodb") {
+      if (record.eventSourceARN === referencesStreamArn) {
+        return true;
+      } else {
+        return record.eventSourceARN === countsStreamArn;
+      }
+    } else {
+      return false;
+    }
+  });
+  let match = Stdlib_Array.partition(dynamoDbRecords, record => record.eventSourceARN === referencesStreamArn);
+  let references = Stdlib_Array.filterMap(match[0], record => {
+    let match = Util_DynamoDbStream_Runtime$ReventlessAws.parseDynamoDbStreamRecordState(record);
+    if (typeof match !== "object") {
+      return;
+    }
+    switch (match.TAG) {
+      case "NewImage" :
+        let inc;
+        let exit = 0;
+        let val;
+        try {
+          val = S.parseJsonOrThrow(match._1, referencesViewSchema);
+          exit = 1;
+        } catch (exn) {
+          inc = 1;
+        }
+        if (exit === 1) {
+          inc = val.inc;
+        }
+        return [
+          match._0,
+          inc
+        ];
+      case "OldImage" :
+        return;
+      case "NewAndOldImage" :
+        StreamRoutedEntryPoint_Ops$ReventlessAws.logDebug("ignoring duplicate id: " + match._0, {
+          comp: "CounterEntryPoint"
+        });
+        return;
+    }
+  });
+  let counts = Stdlib_Array.filterMap(match[1], record => {
+    let match = Util_DynamoDbStream_Runtime$ReventlessAws.parseDynamoDbStreamRecordState(record);
+    if (typeof match !== "object") {
+      return;
+    }
+    switch (match.TAG) {
+      case "OldImage" :
+        return;
+      case "NewImage" :
+      case "NewAndOldImage" :
+        return match._1;
+    }
+  });
+  return [
+    references,
+    counts
+  ];
+}
+
+function makeHandler(config, jsonEventsHandler) {
+  let countsDbCount = QueryDbStorage_DynamoDb_Runtime$ReventlessAws.count({
+    id: Stdlib_Option.getOr(config.countsTableName, ""),
+    name: Stdlib_Option.getOr(config.countsTableName, ""),
+    arn: "",
+    hashKey: "id"
+  });
+  let Callback = Counter_Callback$ReventlessCore.Make({
+    name: "BundledCounter",
+    countsDbCount: countsDbCount,
+    jsonEventsHandler: jsonEventsHandler
+  });
+  let referencesStreamArn = Stdlib_Option.getOr(config.referencesStreamArn, "");
+  let countsStreamArn = Stdlib_Option.getOr(config.countsStreamArn, "");
+  return async (event, _context) => {
+    let match = splitRecords(referencesStreamArn, countsStreamArn, event.Records);
+    await Callback.counterHandler(match[0], match[1]);
+    return "";
+  };
+}
+
+export {
+  parseHandlerConfig,
+  makeCounterOps,
+  referencesViewSchema,
+  splitRecords,
+  makeHandler,
+}
+/* referencesViewSchema Not a pure module */

package/src/adapter/Runtime/DcbCommandTopicEntryPoint.mjs

@@ -160,7 +160,20 @@ export async function buildHandlersForConfig(config, opts = {}) {
   await Promise.all(inboundModules.map(async ({ spec, translation, auditTableName }) => {
     const specModule = await loadModule(spec);
     const translationModule = await loadModule(translation);
-    const auditOps = (auditTableName && !config.pgConnection)
+    // auditTableName must be a real non-empty string. A non-string here (e.g. a
+    // mis-serialized deploy-time value) would build a QueryDb ops whose TableName
+    // is an object, and every PutCommand would crash in AWS endpoint resolution
+    // ("value.split is not a function") — silently, since the audit save is
+    // best-effort. Guard against that instead of trusting the config shape.
+    const hasAuditTable = typeof auditTableName === "string" && auditTableName.length > 0;
+    if (auditTableName != null && !hasAuditTable) {
+      log.warn(
+        "inbound audit table name is not a string; skipping audit persistence: " +
+          JSON.stringify(auditTableName),
+        { comp: "DcbCommandTopicRuntime" },
+      );
+    }
+    const auditOps = (hasAuditTable && !config.pgConnection)
       ? makeDynamoQueryDbOps(auditTableName)
       : undefined;
     const fieldName = config.pluginName + "_" + specModule.name;

package/src/adapter/Runtime/DcbCommandTopicEntryPoint_Ops.res

@@ -266,10 +266,30 @@ let buildInboundReceiver = (
         let json = row->S.reverseConvertToJsonOrThrow(
           ReventlessCore.InboundTranslationSlice_Callback.auditRowSchema,
         )
+        // A failed audit write must not fail the mutation (the command was
+        // already published), but it must not vanish either. `save` RESOLVES
+        // with `Error(_)` on a storage failure (it does not throw), so the
+        // result must be inspected — a bare `let _ = await ops.save(...)` would
+        // swallow the failure and leave the audit view permanently, silently
+        // empty. `try` still guards an unexpected reject.
         try {
-          let _ = await ops.save(id, json, ReventlessCore.QueryDb.Overwrite, None)
+          switch await ops.save(id, json, ReventlessCore.QueryDb.Overwrite, None) {
+          | Ok() => ()
+          | Error(err) =>
+            ReventlessCore.EffectLogger.logError(
+              ~comp="InboundTranslationSlice.audit",
+              `failed to persist audit row ${id}: ${err
+                ->ReventlessCore.QueryDb.storageErrorToString}`,
+            )->Effect.runSync
+          }
         } catch {
-        | _ => ()
+        | exn =>
+          let detail =
+            exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("unknown error")
+          ReventlessCore.EffectLogger.logError(
+            ~comp="InboundTranslationSlice.audit",
+            `failed to persist audit row ${id}: ${detail}`,
+          )->Effect.runSync
         }
       })
     | None => ()

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

@@ -2,13 +2,17 @@
 
 import * as S from "sury/src/S.res.mjs";
 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 Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 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 Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as QueryDb$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb.res.mjs";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
 import * as CommandTopic_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/components/CommandTopic/CommandTopic_Helpers.res.mjs";
 import * as InboundTranslationSlice_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/InboundTranslationSlice/InboundTranslationSlice_Callback.res.mjs";
 import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
@@ -105,13 +109,20 @@ function buildInboundReceiver(spec, translation, publishJsons, auditQueryDbOps)
     if (auditQueryDbOps !== undefined) {
       let rows = Object.entries(callback.auditLog);
       await Stdlib_Array.reduce(rows, Promise.resolve(), async (prev, param) => {
+        let id = param[0];
         await prev;
         let json = S.reverseConvertToJsonOrThrow(param[1], InboundTranslationSlice_Callback$ReventlessCore.auditRowSchema);
         try {
-          await auditQueryDbOps.save(param[0], json, "Overwrite", undefined);
-          return;
-        } catch (exn) {
-          return;
+          let err = await auditQueryDbOps.save(id, json, "Overwrite", undefined);
+          if (err.TAG === "Ok") {
+            return;
+          } else {
+            return Effect.runSync(EffectLogger$ReventlessCore.logError("InboundTranslationSlice.audit", undefined, `failed to persist audit row ` + id + `: ` + QueryDb$ReventlessCore.storageErrorToString(err._0)));
+          }
+        } catch (raw_exn) {
+          let exn = Primitive_exceptions.internalToException(raw_exn);
+          let detail = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "unknown error");
+          return Effect.runSync(EffectLogger$ReventlessCore.logError("InboundTranslationSlice.audit", undefined, `failed to persist audit row ` + id + `: ` + detail));
         }
       });
     }