@reventlessdev/reventless-aws 3.0.0-alpha.186 → 3.0.0-alpha.187

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.187 (2026-07-09)
+
+### Bug Fixes
+
+* **reventless-aws:** thread subIdConfig into deployed StateViewSlice projection runtime ([78ebf80](https://github.com/ReventlessDev/reventless-core/commit/78ebf8086406327a6d665d5dcf034630650c6803))
+
+
 # 3.0.0-alpha.186 (2026-07-08)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.186",
+  "version": "3.0.0-alpha.187",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -9,16 +9,16 @@
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "2.2.0-alpha.20",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.47",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.25",
-    "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
     "@reventlessdev/reventless-core": "3.0.0-alpha.147",
+    "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.91",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.11",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.69",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.11"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.69"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/adapter/Runtime/StateViewSliceEntryPoint.mjs

@@ -45,7 +45,7 @@ function groupBySource(records) {
 // `pgConnection`, when present, selects the Postgres QueryDb runtime for this
 // slice's view table (`queryDbTableName` is then the slice spec name, the shared
 // `qdb_<name>` discriminator). Absent → the DynamoDB path is byte-identical.
-function buildJsonEventsHandler(specModule, projectionModule, queryDbTableName, pgConnection, stateTopicName) {
+export function buildJsonEventsHandler(specModule, projectionModule, queryDbTableName, pgConnection, stateTopicName) {
   let queryDbOps;
   if (pgConnection) {
     const indexes = (specModule.config && specModule.config.indexes) || [];
@@ -92,7 +92,12 @@ function buildJsonEventsHandler(specModule, projectionModule, queryDbTableName,
       actions => Stream.fromIterable(actions)
     ),
     action => Effect.map(
-      Effect.promise(() => handleAction(action, queryDbOps, undefined)),
+      // Thread the slice's `subIdConfig` (generated from `@subId`) so sub-id-dependent
+      // actions like `UpdateMultiState` can resolve the sort key. Dropping it here made
+      // every such action hit the `MissingSubIdConfig` guard and silently write nothing,
+      // while the test-harness callback path (which threads it) stayed green. `undefined`
+      // for slices without an `@subId` is correct — those never emit sub-id actions.
+      Effect.promise(() => handleAction(action, queryDbOps, specModule.subIdConfig)),
       _ => {}
     )
   );

package/tests/integration/StateViewSliceEntryPoint_IntegrationTest.res

@@ -0,0 +1,123 @@
+// Integration regression guard for the StateViewSlice projection Lambda entry
+// point (`StateViewSliceEntryPoint.mjs`), run against DynamoDB Local.
+//
+// Covers the 2026-07-09 incident: the deployed runtime built its projection
+// loop with `handleAction(action, queryDbOps, undefined)` — hardcoding
+// `subIdConfig` to `undefined` instead of threading the slice's
+// `specModule.subIdConfig`. Every sub-id-dependent action (`UpdateMultiState`)
+// 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.
+//
+// The fixture `SvsTestSlice` is an `@subId productId` view slice whose only
+// projection path is `UpdateMultiState`. Before the fix both appends no-op and
+// the table stays empty; after the fix each product is a distinct row.
+//
+// Boots via the same `pnpm run test:integration` Docker-gated suite as the DCB
+// entry-point test; reuses `DcbIntegrationHarness` for table lifecycle commands.
+
+open JestGlobals
+
+module H = DcbIntegrationHarness
+
+let s = JSON.Encode.string
+
+// A view table for a `@subId` slice is a composite-key table: HASH `id`
+// (primary id attribute injected by the QueryDb runtime) + RANGE `productId`
+// (the slice's `subIdField`, carried as a plain attribute of each state row).
+let createViewTable = async (tableName): Util_DynamoDb_Runtime.resolvedTable => {
+  let attrDef = name =>
+    Dict.fromArray([("AttributeName", s(name)), ("AttributeType", s("S"))])->JSON.Encode.object
+  let keyEl = (name, keyType) =>
+    Dict.fromArray([("AttributeName", s(name)), ("KeyType", s(keyType))])->JSON.Encode.object
+  let input =
+    Dict.fromArray([
+      ("TableName", s(tableName)),
+      ("AttributeDefinitions", [attrDef("id"), attrDef("productId")]->JSON.Encode.array),
+      ("KeySchema", [keyEl("id", "HASH"), keyEl("productId", "RANGE")]->JSON.Encode.array),
+      ("BillingMode", s("PAY_PER_REQUEST")),
+    ])->JSON.Encode.object
+  let _ = await H.send(H.createTableCommand(input))
+  {
+    Util_DynamoDb_Runtime.id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/${tableName}`,
+    hashKey: "id",
+  }
+}
+
+// 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.
+let runOneEvent: (string, JSON.t) => promise<unit> = %raw(`
+  async (tableName, eventJson) => {
+    const { buildJsonEventsHandler } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint.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)
+      .pipe(Effect.provideService(requestContextTag, { correlationId: "svs-test" }));
+    await Effect.runPromise(effect);
+  }
+`)
+
+// Encode the consumed event exactly as the runtime decodes it: the entry point
+// calls `parseJsonOrThrow(eventJson, consumedEventSchema)`, so we produce the
+// JSON via the same schema to guarantee a faithful round-trip.
+let encodeEvent = (event): JSON.t =>
+  event->S.reverseConvertToJsonOrThrow(SvsTestSlice.consumedEventSchema)
+
+describe("StateViewSliceEntryPoint integration", () => {
+  testAsync(
+    "UpdateMultiState on an @subId view slice persists a row per product (was silent no-op)",
+    async () => {
+      let table = await createViewTable("SvsIt_" ++ Date.now()->Float.toString)
+
+      // Two products added to the same cart → two distinct sub-id rows under the
+      // same primary id. The second append also reads back the first row, so a
+      // dropped `subIdConfig` (the bug) leaves the table empty at both steps.
+      await runOneEvent(
+        table.name,
+        encodeEvent(ItemAddedToCart({cartId: "cart-1", productId: "prod-a", qty: 2})),
+      )
+      await runOneEvent(
+        table.name,
+        encodeEvent(ItemAddedToCart({cartId: "cart-1", productId: "prod-b", qty: 5})),
+      )
+
+      let rows = switch await QueryDbStorage_DynamoDb_Runtime.load(table)("cart-1") {
+      | Ok(rows) => rows
+      | Error(_) => []
+      }
+
+      // Before the fix: 0 rows (both UpdateMultiState actions no-op with
+      // `MissingSubIdConfig`). After the fix: one row per product.
+      expect(rows->Array.length)->toBe(2)
+
+      let productIds =
+        rows
+        ->Array.filterMap(row =>
+          row
+          ->JSON.Decode.object
+          ->Option.flatMap(o => o->Dict.get("productId"))
+          ->Option.flatMap(JSON.Decode.string)
+        )
+        ->Array.toSorted(String.compare)
+      expect(productIds)->toEqual(["prod-a", "prod-b"])
+
+      await H.deleteTable(table)
+    },
+  )
+})

package/tests/integration/StateViewSliceEntryPoint_IntegrationTest.res.mjs

@@ -0,0 +1,131 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+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_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
+import * as SvsTestSlice$ReventlessAws from "./SvsTestSlice.res.mjs";
+import * as DcbIntegrationHarness$ReventlessAws from "./DcbIntegrationHarness.res.mjs";
+import * as QueryDbStorage_DynamoDb_Runtime$ReventlessAws from "../../src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+
+function s(prim) {
+  return prim;
+}
+
+async function createViewTable(tableName) {
+  let attrDef = name => Object.fromEntries([
+    [
+      "AttributeName",
+      name
+    ],
+    [
+      "AttributeType",
+      "S"
+    ]
+  ]);
+  let keyEl = (name, keyType) => Object.fromEntries([
+    [
+      "AttributeName",
+      name
+    ],
+    [
+      "KeyType",
+      keyType
+    ]
+  ]);
+  let input = Object.fromEntries([
+    [
+      "TableName",
+      tableName
+    ],
+    [
+      "AttributeDefinitions",
+      [
+        attrDef("id"),
+        attrDef("productId")
+      ]
+    ],
+    [
+      "KeySchema",
+      [
+        keyEl("id", "HASH"),
+        keyEl("productId", "RANGE")
+      ]
+    ],
+    [
+      "BillingMode",
+      "PAY_PER_REQUEST"
+    ]
+  ]);
+  await DcbIntegrationHarness$ReventlessAws.send(new ClientDynamodb.CreateTableCommand(input));
+  return {
+    id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/` + tableName,
+    hashKey: "id"
+  };
+}
+
+let runOneEvent = (async (tableName, eventJson) => {
+    const { buildJsonEventsHandler } = await import(
+      "@reventlessdev/reventless-aws/src/adapter/Runtime/StateViewSliceEntryPoint.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)
+      .pipe(Effect.provideService(requestContextTag, { correlationId: "svs-test" }));
+    await Effect.runPromise(effect);
+  });
+
+function encodeEvent(event) {
+  return S.reverseConvertToJsonOrThrow(event, SvsTestSlice$ReventlessAws.consumedEventSchema);
+}
+
+globalThis.describe("StateViewSliceEntryPoint integration", () => {
+  globalThis.test("UpdateMultiState on an @subId view slice persists a row per product (was silent no-op)", async () => {
+    let table = await createViewTable("SvsIt_" + Date.now().toString());
+    await runOneEvent(table.name, S.reverseConvertToJsonOrThrow({
+      TAG: "ItemAddedToCart",
+      cartId: "cart-1",
+      productId: "prod-a",
+      qty: 2
+    }, SvsTestSlice$ReventlessAws.consumedEventSchema));
+    await runOneEvent(table.name, S.reverseConvertToJsonOrThrow({
+      TAG: "ItemAddedToCart",
+      cartId: "cart-1",
+      productId: "prod-b",
+      qty: 5
+    }, SvsTestSlice$ReventlessAws.consumedEventSchema));
+    let rows = await QueryDbStorage_DynamoDb_Runtime$ReventlessAws.load(table)("cart-1");
+    let rows$1;
+    rows$1 = rows.TAG === "Ok" ? rows._0 : [];
+    globalThis.expect(rows$1.length).toBe(2);
+    let productIds = Stdlib_Array.filterMap(rows$1, row => Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(row), o => o["productId"]), Stdlib_JSON.Decode.string)).toSorted(Primitive_string.compare);
+    globalThis.expect(productIds).toEqual([
+      "prod-a",
+      "prod-b"
+    ]);
+    return await DcbIntegrationHarness$ReventlessAws.deleteTable(table);
+  });
+});
+
+let H;
+
+export {
+  H,
+  s,
+  createViewTable,
+  runOneEvent,
+  encodeEvent,
+}
+/* runOneEvent Not a pure module */

package/tests/integration/SvsTestSlice.res

@@ -0,0 +1,32 @@
+// Tiny StateViewSlice spec exercised by
+// `StateViewSliceEntryPoint_IntegrationTest`. Standalone schema — does not
+// depend on the example apps — so the fixture's shape can drift independently
+// of any shipped slice.
+//
+// Hand-written explicit form rather than the `@@reventless.spec` PPX shorthand:
+// the reventless-ppx is only wired into reventless-core's rescript.json, not
+// reventless-aws's. So `consumedEventSchema`, `subIdConfig` etc. are declared
+// directly.
+//
+// The slice models a per-cart, per-product line: primary id = `cartId`,
+// sub-id = `productId`. Its projection uses `UpdateMultiState`, the action that
+// hits the runtime's `subIdConfig` guard — the exact path the deployed entry
+// point used to no-op by hardcoding `subIdConfig = undefined`.
+
+@schema
+type consumedEvent = ItemAddedToCart({cartId: string, productId: string, qty: int})
+
+@schema
+type state = {
+  cartId: string,
+  productId: string,
+  qty: int,
+}
+
+// `Some({subIdField, getSubId})` — the compiled per-slice spec that a real
+// `@subId productId` view slice carries. `subIdField` is the DynamoDB range-key
+// attribute; `getSubId` extracts it from a projected state row.
+let subIdConfig: option<Reventless.ReadModel.subIdConfig<state>> = Some({
+  subIdField: "productId",
+  getSubId: state => state.productId,
+})

package/tests/integration/SvsTestSlice.res.mjs

@@ -0,0 +1,28 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let consumedEventSchema = S.schema(s => ({
+  TAG: "ItemAddedToCart",
+  cartId: s.m(S.string),
+  productId: s.m(S.string),
+  qty: s.m(S.int)
+}));
+
+let stateSchema = S.schema(s => ({
+  cartId: s.m(S.string),
+  productId: s.m(S.string),
+  qty: s.m(S.int)
+}));
+
+let subIdConfig = {
+  subIdField: "productId",
+  getSubId: state => state.productId
+};
+
+export {
+  consumedEventSchema,
+  stateSchema,
+  subIdConfig,
+}
+/* consumedEventSchema Not a pure module */

package/tests/integration/SvsTestSlice_Projection.res

@@ -0,0 +1,24 @@
+// Projection for `SvsTestSlice`. Hand-written `open` (no `@@reventless.projection`
+// PPX in reventless-aws): `open Reventless.Projection` brings the action
+// constructors (`UpdateMultiState`, …) into scope; `open SvsTestSlice` brings the
+// consumed-event/state types.
+//
+// Every event upserts the cart's line for one product via `UpdateMultiState`,
+// keyed by `productId` (the sub-id). This is the multi-state path that silently
+// no-oped in the deployed runtime before `subIdConfig` was threaded.
+
+open Reventless.Projection
+open SvsTestSlice
+
+let project = event =>
+  switch event {
+  | ItemAddedToCart({cartId, productId, qty}) => [
+      UpdateMultiState(
+        cartId,
+        states => {
+          let others = states->Array.filter(s => s.productId != productId)
+          others->Array.concat([{cartId, productId, qty}])
+        },
+      ),
+    ]
+  }

package/tests/integration/SvsTestSlice_Projection.res.mjs

@@ -0,0 +1,25 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function project(event) {
+  let qty = event.qty;
+  let productId = event.productId;
+  let cartId = event.cartId;
+  return [{
+      TAG: "UpdateMultiState",
+      _0: cartId,
+      _1: states => {
+        let others = states.filter(s => s.productId !== productId);
+        return others.concat([{
+            cartId: cartId,
+            productId: productId,
+            qty: qty
+          }]);
+      }
+    }];
+}
+
+export {
+  project,
+}
+/* No side effect */