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

package/tests/TaskBucketEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,165 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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 TaskBucketEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/TaskBucketEntryPoint_Ops.res.mjs";
+
+function str(prim) {
+  return prim;
+}
+
+function obj(pairs) {
+  return Object.fromEntries(pairs);
+}
+
+globalThis.describe("TaskBucketEntryPoint_Ops.parseHandlerConfig", () => {
+  globalThis.test("empty raw config decodes to empty defaults", () => {
+    let c = TaskBucketEntryPoint_Ops$ReventlessAws.parseHandlerConfig("");
+    globalThis.expect(c.callbackModule).toBe("");
+    globalThis.expect(Object.entries(c.publishToAggregates).length).toBe(0);
+    globalThis.expect(Stdlib_Option.isNone(c.scheduler)).toBe(true);
+  });
+  globalThis.test("decodes callbackModule, publishToAggregates, and scheduler env names", () => {
+    let config = JSON.stringify(Object.fromEntries([
+      [
+        "callbackModule",
+        "@x/plugin/src/Task/ImportCatalog.res.mjs"
+      ],
+      [
+        "publishToAggregates",
+        Object.fromEntries([[
+            "Product",
+            "PTA_Product_QUEUE_URL"
+          ]])
+      ],
+      [
+        "scheduler",
+        Object.fromEntries([
+          [
+            "roleArnEnv",
+            "SCHEDULER_ROLE_ARN"
+          ],
+          [
+            "targetArnEnv",
+            "SCHEDULER_TARGET_ARN"
+          ],
+          [
+            "targetNameEnv",
+            "SCHEDULER_TARGET_NAME"
+          ]
+        ])
+      ]
+    ]));
+    let c = TaskBucketEntryPoint_Ops$ReventlessAws.parseHandlerConfig(config);
+    globalThis.expect(c.callbackModule).toBe("@x/plugin/src/Task/ImportCatalog.res.mjs");
+    globalThis.expect(c.publishToAggregates["Product"]).toEqual("PTA_Product_QUEUE_URL");
+    let s = c.scheduler;
+    if (s !== undefined) {
+      globalThis.expect(s.roleArnEnv).toBe("SCHEDULER_ROLE_ARN");
+      return;
+    } else {
+      return Stdlib_JsError.throwWithMessage("expected Some(scheduler)");
+    }
+  });
+});
+
+globalThis.describe("TaskBucketEntryPoint_Ops.buildPublishCommands", () => {
+  globalThis.test("resolves queue URLs via env vars, skipping unset or empty ones", () => {
+    process.env["TB_TEST_QUEUE_A"] = "https://sqs/a.fifo";
+    process.env["TB_TEST_QUEUE_EMPTY"] = "";
+    let map = Object.fromEntries([
+      [
+        "AggA",
+        "TB_TEST_QUEUE_A"
+      ],
+      [
+        "AggEmpty",
+        "TB_TEST_QUEUE_EMPTY"
+      ],
+      [
+        "AggUnset",
+        "TB_TEST_QUEUE_UNSET"
+      ]
+    ]);
+    let publish = TaskBucketEntryPoint_Ops$ReventlessAws.buildPublishCommands(map);
+    globalThis.expect(Stdlib_Option.isSome(publish["AggA"])).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(publish["AggEmpty"])).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(publish["AggUnset"])).toBe(true);
+  });
+});
+
+globalThis.describe("TaskBucketEntryPoint_Ops.dispatchTaskActions", () => {
+  let schedule = {
+    name: "sweep",
+    rate: {
+      TAG: "Minutes",
+      _0: 5
+    },
+    payload: "{}"
+  };
+  globalThis.test("routes PublishCommands to the aggregate's publish fn", async () => {
+    let published = [];
+    let publishCommands = Object.fromEntries([[
+        "Product",
+        async cmds => {
+          published.push(cmds);
+        }
+      ]]);
+    await TaskBucketEntryPoint_Ops$ReventlessAws.dispatchTaskActions([
+      {
+        TAG: "PublishCommands",
+        _0: "Product",
+        _1: []
+      },
+      {
+        TAG: "PublishCommands",
+        _0: "Nope",
+        _1: []
+      }
+    ], publishCommands, () => {});
+    globalThis.expect(published.length).toBe(1);
+  });
+  globalThis.test("routes schedule actions to the scheduler ops; skips when unconfigured", async () => {
+    let created = [];
+    let deleted = [];
+    let ops_createSchedule = async s => {
+      created.push(s.name);
+    };
+    let ops_deleteSchedule = async name => {
+      deleted.push(name);
+    };
+    let ops = {
+      createSchedule: ops_createSchedule,
+      deleteSchedule: ops_deleteSchedule
+    };
+    await TaskBucketEntryPoint_Ops$ReventlessAws.dispatchTaskActions([
+      {
+        TAG: "CreateSchedule",
+        _0: schedule
+      },
+      {
+        TAG: "DeleteSchedule",
+        _0: "sweep"
+      }
+    ], {}, () => ops);
+    globalThis.expect(created).toEqual(["sweep"]);
+    globalThis.expect(deleted).toEqual(["sweep"]);
+    await TaskBucketEntryPoint_Ops$ReventlessAws.dispatchTaskActions([
+      {
+        TAG: "CreateSchedule",
+        _0: schedule
+      },
+      {
+        TAG: "DeleteSchedule",
+        _0: "sweep"
+      }
+    ], {}, () => {});
+    globalThis.expect(created.length).toBe(1);
+  });
+});
+
+export {
+  str,
+  obj,
+}
+/*  Not a pure module */

package/tests/integration/StateViewSliceEntryPoint_IntegrationTest.res

@@ -1,5 +1,6 @@
 // Integration regression guard for the StateViewSlice projection Lambda entry
-// point (`StateViewSliceEntryPoint.mjs`), run against DynamoDB Local.
+// point (`StateViewSliceEntryPoint.mjs` + `StateViewSliceEntryPoint_Ops.res`),
+// run against DynamoDB Local.
 //
 // Covers the 2026-07-09 incident: the deployed runtime built its projection
 // loop with `handleAction(action, queryDbOps, undefined)` — hardcoding
@@ -8,8 +9,10 @@
 // then hit the `MissingSubIdConfig` guard and silently wrote nothing, while the
 // in-memory GWT/callback path (which threads `subIdConfig`) stayed green. This
 // is a deployed-runtime vs test-harness parity gap: a unit test on the callback
-// path cannot catch it, so this test drives the *real* `.mjs` entry point that
-// production uses.
+// path cannot catch it, so this test drives the real entry-point wiring the
+// production shell uses — `makeRegisteredHandler` with the modules record read
+// off the dynamically imported spec/projection modules, invoked with an
+// SQS-shaped Lambda record so the full decode path runs.
 //
 // The fixture `SvsTestSlice` is an `@subId productId` view slice whose only
 // projection path is `UpdateMultiState`. Before the fix both appends no-op and
@@ -48,26 +51,52 @@ let createViewTable = async (tableName): Util_DynamoDb_Runtime.resolvedTable =>
   }
 }
 
-// Drives the real entry point: builds the handler via its exported
-// `buildJsonEventsHandler` factory (DynamoDB path — `pgConnection`/`stateTopicName`
-// undefined), feeds one encoded event through the effect Stream, and runs the
-// resulting Effect through the request context the production handler supplies.
+// Drives the real entry-point wiring: mirrors the shell's untyped seam line for
+// line — a HANDLER_CONFIG-shaped entry (DynamoDB path — `pgConnection`/
+// `stateTopicName` undefined) plus the modules record read off the dynamically
+// imported spec/projection modules — then feeds one SQS-shaped Lambda record
+// through the registered stream handler, so the same decode path the deployed
+// Lambda runs (handleStreamEvent → envelope decode → schema parse → project →
+// handleAction) is exercised end to end.
 let runOneEvent: (string, JSON.t) => promise<unit> = %raw(`
   async (tableName, eventJson) => {
-    const { buildJsonEventsHandler } = await import(
-      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint.mjs"
+    const Ops = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res.mjs"
     );
     const specModule = await import("./SvsTestSlice.res.mjs");
     const projectionModule = await import("./SvsTestSlice_Projection.res.mjs");
     const Effect = await import("effect/Effect");
-    const Stream = await import("effect/Stream");
     const { tag: requestContextTag } = await import(
       "@reventlessdev/reventless-core/src/RequestContext.res.mjs"
     );
 
-    const handler = buildJsonEventsHandler(specModule, projectionModule, tableName, undefined, undefined);
-    const stream = Stream.fromIterable([eventJson]);
-    const effect = handler(stream)
+    const registered = Ops.makeRegisteredHandler(
+      {
+        specModule: "",
+        projectionModule: "",
+        queryDbTableName: tableName,
+        sourceUrn: "svs-test-urn",
+        stateTopicName: undefined,
+        pgConnection: undefined,
+      },
+      {
+        name: specModule.name,
+        consumedEventSchema: specModule.consumedEventSchema,
+        project: projectionModule.project,
+        config: specModule.config,
+        subIdConfig: specModule.subIdConfig,
+      },
+    );
+    const event = {
+      Records: [
+        {
+          eventSource: "aws:sqs",
+          eventSourceARN: "svs-test-urn",
+          body: JSON.stringify(eventJson),
+        },
+      ],
+    };
+    const effect = registered.handler(event, {})
       .pipe(Effect.provideService(requestContextTag, { correlationId: "svs-test" }));
     await Effect.runPromise(effect);
   }

package/tests/integration/StateViewSliceEntryPoint_IntegrationTest.res.mjs

@@ -69,20 +69,43 @@ async function createViewTable(tableName) {
 }
 
 let runOneEvent = (async (tableName, eventJson) => {
-    const { buildJsonEventsHandler } = await import(
-      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint.mjs"
+    const Ops = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint_Ops.res.mjs"
     );
     const specModule = await import("./SvsTestSlice.res.mjs");
     const projectionModule = await import("./SvsTestSlice_Projection.res.mjs");
     const Effect = await import("effect/Effect");
-    const Stream = await import("effect/Stream");
     const { tag: requestContextTag } = await import(
       "@reventlessdev/reventless-core/src/RequestContext.res.mjs"
     );
 
-    const handler = buildJsonEventsHandler(specModule, projectionModule, tableName, undefined, undefined);
-    const stream = Stream.fromIterable([eventJson]);
-    const effect = handler(stream)
+    const registered = Ops.makeRegisteredHandler(
+      {
+        specModule: "",
+        projectionModule: "",
+        queryDbTableName: tableName,
+        sourceUrn: "svs-test-urn",
+        stateTopicName: undefined,
+        pgConnection: undefined,
+      },
+      {
+        name: specModule.name,
+        consumedEventSchema: specModule.consumedEventSchema,
+        project: projectionModule.project,
+        config: specModule.config,
+        subIdConfig: specModule.subIdConfig,
+      },
+    );
+    const event = {
+      Records: [
+        {
+          eventSource: "aws:sqs",
+          eventSourceARN: "svs-test-urn",
+          body: JSON.stringify(eventJson),
+        },
+      ],
+    };
+    const effect = registered.handler(event, {})
       .pipe(Effect.provideService(requestContextTag, { correlationId: "svs-test" }));
     await Effect.runPromise(effect);
   });

package/src/adapter/Runtime/PgChangeFeedRelayEntryPoint.mjs

@@ -1,57 +0,0 @@
-// PgChangeFeedRelay Lambda entry point (scheduled poll — B2.3).
-//
-// Triggered on a schedule (EventBridge rate rule). Each invocation drains every
-// Postgres log listed in HANDLER_CONFIG from its checkpoint — DCB (`dcb_event`)
-// and classic aggregate (`event_log`) logs alike — and relays the events,
-// transformed into the {id, meta, event} shape, onto the plugin EventCollector
-// SQS queue — which then fans out to projections, aggregate command topics, and
-// the cross-plugin SNS EventTopic.
-// See docs/plans/done/aws-postgres-change-feed-bridge.md.
-//
-// HANDLER_CONFIG shape:
-//   { "logs": [ { "pgConnection": {host,port,database,username,secretArn},
-//                 "logName": string,          // dcb_event/event_log log_name
-//                 "subscriber": string,        // per-log checkpoint key
-//                 "targetQueueUrl": string,    // plugin EventCollector SQS URL
-//                 "kind"?: "classic",          // absent → DCB
-//                 "partitionTag"?: <derivedPartitionTag> } ] }  // DCB only
-
-import { relay, relayClassic } from "@reventlessdev/reventless-aws/src/adapter/Postgres/PgChangeFeedRelay_Runtime.res.mjs";
-import { sendMessage } from "@reventlessdev/reventless-aws/src/util/Util_SQS_Runtime.res.mjs";
-import { makeQueueRef, log } from "./HandlerFactoryHelpers.mjs";
-
-// Standard (non-FIFO) EventCollector queue — no message group id needed. The
-// SQS handler parses each body straight back to JSON (Util_SQS_Runtime.parseSqsRecord).
-function makeSendBatch(targetQueueUrl) {
-  const queue = makeQueueRef(targetQueueUrl);
-  return (jsons) =>
-    Promise.all(jsons.map((json) => sendMessage(queue, undefined, JSON.stringify(json)))).then(
-      () => {}
-    );
-}
-
-export async function handler(_event, _context) {
-  const configStr = process.env["HANDLER_CONFIG"] || '{"logs":[]}';
-  const config = JSON.parse(configStr);
-  const logs = config.logs || [];
-
-  await Promise.all(
-    logs.map(async (l) => {
-      const sendBatch = makeSendBatch(l.targetQueueUrl);
-      try {
-        const count =
-          l.kind === "classic"
-            ? await relayClassic(l.pgConnection, l.logName, l.subscriber, sendBatch)
-            : await relay(l.pgConnection, l.logName, l.subscriber, l.partitionTag, sendBatch);
-        log.debug("relayed " + count + " event(s) for " + l.logName, { comp: "PgChangeFeedRelay" });
-      } catch (err) {
-        // Log and continue — a failed log this tick is retried next tick from its
-        // unchanged checkpoint (at-least-once; projections are idempotent).
-        log.warn("relay failed for " + l.logName + ": " + (err?.message ?? String(err)), {
-          comp: "PgChangeFeedRelay",
-        });
-      }
-    })
-  );
-  return "";
-}

package/src/adapter/Runtime/PgMigrationEntryPoint.mjs

@@ -1,40 +0,0 @@
-// One-shot Postgres schema-migration Lambda entry point (A3).
-//
-// Invoked once during `pulumi up` by an `aws.lambda.Invocation` resource, from
-// INSIDE the DB's VPC, so the deploy runner needs no network path to a private
-// RDS instance. Runs the exact idempotent `PgSchema.ensureSchema` the local
-// backend runs at startup (reventless-local's `postgres` smart constructor), so
-// the AWS schema is byte-identical to local — zero drift. Every statement is
-// `IF NOT EXISTS`, so re-invocation (e.g. after a schema-DDL change bumps the
-// Lambda layer) is safe.
-//
-// HANDLER_CONFIG shape:
-//   { "pgConnection": { host, port, database, username, secretArn } }
-
-import { poolFor } from "@reventlessdev/reventless-aws/src/adapter/Postgres/PgRuntime.res.mjs";
-import { ensureSchema } from "@reventlessdev/reventless-postgres/src/PgSchema.res.mjs";
-import { log } from "./HandlerFactoryHelpers.mjs";
-
-// Config parse → pool → ensureSchema, with the pool source injectable so the
-// orchestration is integration-testable against a real Postgres without the
-// Secrets Manager round-trip (mirrors PgChangeFeedRelay_Runtime's
-// relayWithPool/relay split). `opts.makePool` defaults to the production `poolFor`.
-export async function runMigration(config, opts = {}) {
-  if (!config.pgConnection) {
-    throw new Error("PgMigrationEntryPoint: HANDLER_CONFIG has no pgConnection");
-  }
-  // `poolFor` memoises one pool per secret ARN per container and resolves the
-  // RDS-managed password from Secrets Manager via a cached provider.
-  const makePool = opts.makePool ?? poolFor;
-  const pool = makePool(config.pgConnection);
-  await ensureSchema(pool);
-  log.info("ensureSchema completed for " + config.pgConnection.database, {
-    comp: "PgMigration",
-  });
-  return "ok";
-}
-
-export async function handler(_event, _context) {
-  const config = JSON.parse(process.env["HANDLER_CONFIG"] || "{}");
-  return runMigration(config);
-}