@reventlessdev/reventless-aws 3.0.0-alpha.318 → 3.0.0-alpha.319

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.319 (2026-08-22)
+
+* feat(core)!: a slice that has given up says so ([f5559ab](https://github.com/ReventlessDev/reventless-core/commit/f5559abede3a9cf2c9a48aadc69a666c46cc75bf))
+
+### BREAKING CHANGES
+
+* `onExhausted` is required on the Translation and Automation
+module types. ReScript has no optional module-type fields, so the alternative
+was a PPX-injected default — and defaulting this one to silence is the bug.
+A slice now states what abandonment means for its domain, `None` included.
+GeocodeCustomerAddress answers with MarkAddressUnresolvable; the others say
+nothing, on purpose.
+
+
+
 # 3.0.0-alpha.318 (2026-08-21)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.318",
+  "version": "3.0.0-alpha.319",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -15,15 +15,15 @@
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.12",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.2",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.246",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.149",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.247",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.150",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.33",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.121",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.110"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.122",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.111"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/Runtime/AutomationSliceEntryPoint_Ops.res

@@ -148,9 +148,12 @@ let makeSyncTodoItems = (
 // by definition no fresher.
 //
 // Only `Pending` and `Failed` are read. `Completed` rows are the bulk of a
-// mature table and are never actionable. Retry-exhausted rows are not excluded —
-// `maxRetries` is Spec-level and not known here — but `phase2` filters them, so
-// they are inert rather than wrong.
+// mature table and are never actionable, and neither are `Abandoned` ones — a
+// row whose retry budget is spent is terminal, so it is left in the table rather
+// than carried into memory. That the status says so is what lets this filter
+// decide it: `maxRetries` is Spec-level and still not known here, and before the
+// status existed an exhausted row had to be loaded and then filtered out by
+// `phase2`.
 let makeLoadTodoItems = (
   ~queryDbTableName: string,
   ~todoItems: dict<'row>,

package/tests/PgQueryResolver_LambdaTest.res

@@ -612,3 +612,169 @@ describe("owner scoping", () => {
     expect(r->ids)->toEqual(["p-1", "p-3"])
   })
 })
+
+// ── nested union member types ───────────────────────────────────────────────
+//
+// The `__typename` a union member is resolved from is written into the stored
+// row, above the DynamoDB/Postgres branch (`withUnionMemberTypes` wraps the
+// result of `makeQueryDbOps`), and this resolver stamps only the *top level* of
+// a `node` answer. So the Postgres door's whole claim is that it hands a nested
+// union back exactly as stored — which no test made, and which no deploy can
+// make either: nothing runs the Postgres backend, so this door cannot be called
+// against a deployment the way the AppSync ones were.
+//
+// Losing the nested key is not visible as an error: the member resolves to null
+// and the null takes its non-nullable parent, so rows leave the answer.
+
+let geoRow = (id, status) => {
+  let geo = Dict.make()
+  geo->Dict.set("__typename", JSON.Encode.string("GeolocationLocated"))
+  geo->Dict.set("lat", JSON.Encode.float(48.2082))
+  geo->Dict.set("lng", JSON.Encode.float(16.3738))
+  let o = Dict.make()
+  o->Dict.set("id", JSON.Encode.string(id))
+  o->Dict.set("status", JSON.Encode.string(status))
+  o->Dict.set("name", JSON.Encode.string("Geo " ++ id))
+  o->Dict.set("owner", JSON.Encode.string("u-a"))
+  o->Dict.set("geolocation", JSON.Encode.object(geo))
+  JSON.Encode.object(o)
+}
+
+let geoStore = Dict.fromArray([("g-1", geoRow("g-1", "active")), ("g-2", geoRow("g-2", "active"))])
+let geoItems = () => geoStore->Dict.valuesToArray
+
+let geoConnection = (): JSON.t =>
+  JSON.Encode.object(
+    Dict.fromArray([
+      (
+        "edges",
+        JSON.Encode.array(
+          geoItems()->Array.map(item =>
+            JSON.Encode.object(
+              Dict.fromArray([("cursor", JSON.Encode.string("c")), ("node", item)]),
+            )
+          ),
+        ),
+      ),
+    ]),
+  )
+
+let geoBinding = (): PgQueryResolver_Lambda.binding => {
+  ops: {
+    ...ops,
+    load: async id => Ok(geoStore->Dict.get(id)->Option.mapOr([], i => [i])),
+  },
+  pushdowns: {
+    indexLookup: async (~readModelName as _, _field, _value) => geoItems(),
+    byIds: async (~readModelName as _, ids) => ids->Array.filterMap(id => geoStore->Dict.get(id)),
+    listPage: async (
+      ~readModelName as _,
+      ~argsDict as _,
+      ~capability as _,
+      ~labelField as _,
+      ~ownerScope as _=?,
+      ~retiredScope as _=?,
+    ) => Some(geoConnection()),
+    itemsPage: async (
+      ~readModelName as _,
+      ~subIdField as _,
+      ~id as _,
+      ~argsDict as _,
+      ~ownerScope as _=?,
+      ~retiredScope as _=?,
+    ) => geoConnection(),
+    scanAll: async (~readModelName as _) => geoItems(),
+  },
+  indexes: [
+    {index: "byStatus", type_: "S", idField: "status", projectionType: Reventless.ReadModel.ALL},
+  ],
+  subIdField: Some("lineNo"),
+  capability,
+  labelField: "name",
+  includeIdParam: true,
+  authorization: Reventless.Authorization.AllowAnonymous,
+  ownerField: None,
+  retiredField: None,
+  retiredValues: None,
+  namedWhenRetired: false,
+}
+
+// The member type of the first row a door answers with, whatever shape it took.
+let memberOf = (r: JSON.t): option<string> => {
+  let fromRow = row =>
+    row->field("geolocation")->Option.flatMap(g => g->str("__typename"))
+  switch r->JSON.Decode.array {
+  | Some(rows) => rows->Array.get(0)->Option.flatMap(fromRow)
+  | None =>
+    switch r->field("edges")->Option.flatMap(JSON.Decode.array) {
+    | Some(edges) => edges->Array.get(0)->Option.flatMap(e => e->field("node"))->Option.flatMap(fromRow)
+    | None => fromRow(r)
+    }
+  }
+}
+
+describe("PgQueryResolver — a nested union survives every door", () => {
+  let doors = [
+    ("getById", mkPayload(~kind="getById", ~args=objArgs([("id", JSON.Encode.string("g-1"))]), ())),
+    (
+      "byIds",
+      mkPayload(~kind="byIds", ~args=objArgs([("ids", JSON.Encode.array([JSON.Encode.string("g-1")]))]), ()),
+    ),
+    (
+      "index",
+      mkPayload(~kind="index", ~index="byStatus", ~args=objArgs([("byStatus", JSON.Encode.string("active"))]), ()),
+    ),
+    ("list", mkPayload(~kind="list", ())),
+    ("items", mkPayload(~kind="items", ~args=objArgs([("id", JSON.Encode.string("g-1"))]), ())),
+    // The cross-table doors answer with the *target's* rows, so a union on the
+    // target travels through a field on some other view's type.
+    (
+      "resolveOne",
+      {
+        readModelName: "Geos",
+        kind: "resolveOne",
+        target: "Geos",
+        source: objArgs([("ref", JSON.Encode.string("g-1"))]),
+        sourceIdField: "ref",
+        multi: false,
+        arguments: objArgs([]),
+        identity: Reventless.Identity.anonymous,
+      },
+    ),
+    (
+      "resolveMany",
+      {
+        readModelName: "Geos",
+        kind: "resolveMany",
+        target: "Geos",
+        source: objArgs([("refs", JSON.Encode.array([JSON.Encode.string("g-1")]))]),
+        sourceIdsField: "refs",
+        arguments: objArgs([]),
+        identity: Reventless.Identity.anonymous,
+      },
+    ),
+  ]
+
+  doors->Array.forEach(((label, payload)) =>
+    testPromise(label ++ " hands the member type back as stored", async () => {
+      let r = await PgQueryResolver_Lambda.dispatch(~binding=geoBinding(), ~payload)
+      expect(memberOf(r))->toEqual(Some("GeolocationLocated"))
+    })
+  )
+
+  // `node` is the one door that writes a `__typename` of its own, at the top
+  // level. It must not reach down and overwrite the member's.
+  testPromise("node stamps the top level without disturbing the member", async () => {
+    PgQueryResolver_Lambda.register(~readModelName="Geos", geoBinding())
+    PgQueryResolver_Lambda.registerNodeType(~typeName="Geo", ~readModelName="Geos")
+    let payload: PgQueryResolver_Lambda.payload = {
+      readModelName: "",
+      kind: "node",
+      arguments: objArgs([("id", JSON.Encode.string(btoa("Geo:g-1")))]),
+      identity: Reventless.Identity.anonymous,
+    }
+    let r = await PgQueryResolver_Lambda.handler(payload, Obj.magic(Nullable.null))
+    expect(r->str("__typename"))->toEqual(Some("Geo"))
+    expect(memberOf(r))->toEqual(Some("GeolocationLocated"))
+  })
+})

package/tests/PgQueryResolver_LambdaTest.res.mjs

@@ -629,6 +629,196 @@ globalThis.describe("owner scoping", () => {
   });
 });
 
+function geoRow(id, status) {
+  let geo = {};
+  geo["__typename"] = "GeolocationLocated";
+  geo["lat"] = 48.2082;
+  geo["lng"] = 16.3738;
+  let o = {};
+  o["id"] = id;
+  o["status"] = status;
+  o["name"] = "Geo " + id;
+  o["owner"] = "u-a";
+  o["geolocation"] = geo;
+  return o;
+}
+
+let geoStore = Object.fromEntries([
+  [
+    "g-1",
+    geoRow("g-1", "active")
+  ],
+  [
+    "g-2",
+    geoRow("g-2", "active")
+  ]
+]);
+
+function geoItems() {
+  return Object.values(geoStore);
+}
+
+function geoConnection() {
+  return Object.fromEntries([[
+      "edges",
+      Object.values(geoStore).map(item => Object.fromEntries([
+        [
+          "cursor",
+          "c"
+        ],
+        [
+          "node",
+          item
+        ]
+      ]))
+    ]]);
+}
+
+function geoBinding() {
+  return {
+    ops: {
+      load: async id => ({
+        TAG: "Ok",
+        _0: Stdlib_Option.mapOr(geoStore[id], [], i => [i])
+      }),
+      loadStream: 0,
+      save: 0,
+      saveBatch: 0,
+      count: 0,
+      delete: 0,
+      deleteBatch: 0
+    },
+    pushdowns: {
+      indexLookup: async (param, _field, _value) => Object.values(geoStore),
+      byIds: async (param, ids) => Stdlib_Array.filterMap(ids, id => geoStore[id]),
+      listPage: async (param, param$1, param$2, param$3, param$4, param$5) => geoConnection(),
+      itemsPage: async (param, param$1, param$2, param$3, param$4, param$5) => geoConnection(),
+      scanAll: async param => Object.values(geoStore)
+    },
+    indexes: [{
+        index: "byStatus",
+        type_: "S",
+        idField: "status",
+        projectionType: "ALL"
+      }],
+    subIdField: "lineNo",
+    capability: capability,
+    labelField: "name",
+    includeIdParam: true,
+    authorization: "AllowAnonymous",
+    ownerField: undefined,
+    retiredField: undefined,
+    retiredValues: undefined,
+    namedWhenRetired: false
+  };
+}
+
+function memberOf(r) {
+  let fromRow = row => Stdlib_Option.flatMap(field(row, "geolocation"), g => str(g, "__typename"));
+  let rows = Stdlib_JSON.Decode.array(r);
+  if (rows !== undefined) {
+    return Stdlib_Option.flatMap(rows[0], fromRow);
+  }
+  let edges = Stdlib_Option.flatMap(field(r, "edges"), Stdlib_JSON.Decode.array);
+  if (edges !== undefined) {
+    return Stdlib_Option.flatMap(Stdlib_Option.flatMap(edges[0], e => field(e, "node")), fromRow);
+  } else {
+    return fromRow(r);
+  }
+}
+
+globalThis.describe("PgQueryResolver — a nested union survives every door", () => {
+  let doors = [
+    [
+      "getById",
+      mkPayload("getById", undefined, Object.fromEntries([[
+          "id",
+          "g-1"
+        ]]), undefined, undefined)
+    ],
+    [
+      "byIds",
+      mkPayload("byIds", undefined, Object.fromEntries([[
+          "ids",
+          ["g-1"]
+        ]]), undefined, undefined)
+    ],
+    [
+      "index",
+      mkPayload("index", "byStatus", Object.fromEntries([[
+          "byStatus",
+          "active"
+        ]]), undefined, undefined)
+    ],
+    [
+      "list",
+      mkPayload("list", undefined, undefined, undefined, undefined)
+    ],
+    [
+      "items",
+      mkPayload("items", undefined, Object.fromEntries([[
+          "id",
+          "g-1"
+        ]]), undefined, undefined)
+    ],
+    [
+      "resolveOne",
+      {
+        readModelName: "Geos",
+        kind: "resolveOne",
+        target: "Geos",
+        source: Object.fromEntries([[
+            "ref",
+            "g-1"
+          ]]),
+        sourceIdField: "ref",
+        multi: false,
+        arguments: Object.fromEntries([]),
+        identity: Identity$Reventless.anonymous
+      }
+    ],
+    [
+      "resolveMany",
+      {
+        readModelName: "Geos",
+        kind: "resolveMany",
+        target: "Geos",
+        source: Object.fromEntries([[
+            "refs",
+            ["g-1"]
+          ]]),
+        sourceIdsField: "refs",
+        arguments: Object.fromEntries([]),
+        identity: Identity$Reventless.anonymous
+      }
+    ]
+  ];
+  doors.forEach(param => {
+    let payload = param[1];
+    globalThis.test(param[0] + " hands the member type back as stored", async () => {
+      let r = await PgQueryResolver_Lambda$ReventlessAws.dispatch(geoBinding(), undefined, payload);
+      globalThis.expect(memberOf(r)).toEqual("GeolocationLocated");
+    });
+  });
+  globalThis.test("node stamps the top level without disturbing the member", async () => {
+    PgQueryResolver_Lambda$ReventlessAws.register("Geos", geoBinding());
+    PgQueryResolver_Lambda$ReventlessAws.registerNodeType("Geo", "Geos");
+    let payload_arguments = Object.fromEntries([[
+        "id",
+        btoa("Geo:g-1")
+      ]]);
+    let payload = {
+      readModelName: "",
+      kind: "node",
+      arguments: payload_arguments,
+      identity: Identity$Reventless.anonymous
+    };
+    let r = await PgQueryResolver_Lambda$ReventlessAws.handler(payload, null);
+    globalThis.expect(str(r, "__typename")).toEqual("Geo");
+    globalThis.expect(memberOf(r)).toEqual("GeolocationLocated");
+  });
+});
+
 export {
   mk,
   store,
@@ -647,5 +837,11 @@ export {
   field,
   str,
   ids,
+  geoRow,
+  geoStore,
+  geoItems,
+  geoConnection,
+  geoBinding,
+  memberOf,
 }
 /* store Not a pure module */