@reventlessdev/reventless-aws 3.0.0-alpha.279 → 3.0.0-alpha.281

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.281 (2026-08-10)
+
+### Features
+
+* **admin:** carry Internal queryables on their own manifest field ([f5aa03d](https://github.com/ReventlessDev/reventless-core/commit/f5aa03d60b0b2554d116fe9b3784d30f2c4ef356))
+
+
+# 3.0.0-alpha.280 (2026-08-10)
+
+### Bug Fixes
+
+* **aws:** keep the interceptor data source out of an option ([d908126](https://github.com/ReventlessDev/reventless-core/commit/d90812626d64b5c408c8185ac58a63db448e4082))
+
+
 # 3.0.0-alpha.279 (2026-08-10)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.279",
+  "version": "3.0.0-alpha.281",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -15,15 +15,15 @@
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.6",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-node": "2.0.0-alpha.3",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.69",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.222",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.223",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.133",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.86",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.106",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.132"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.87",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.107"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res

@@ -114,19 +114,33 @@ let isPublicQueryable = (q: JSON.t): bool =>
   | _ => true
   }
 
-// Drop Internal ReadModels / StateViewSlices from a persisted structure. A
-// missing/non-array field defaults to `[]` (mirrors the JS `?? []`).
+// Drop Internal ReadModels / StateViewSlices from a persisted structure, and
+// carry what was dropped on `internalQueryables` — the complement, so a client
+// can resolve a reference to an Internal view without any enumeration site
+// being able to see it. A missing/non-array field defaults to `[]` (mirrors the
+// JS `?? []`), which also covers a structure persisted before this field
+// existed: the complement is recomputed here, never read off the structure.
+//
+// The `~filter=false` path (Platform_PluginStructures) deliberately does not go
+// through here — it serves Internal components inline and must not grow a
+// duplicate list.
 let filterStructure = (structure: dict<JSON.t>): dict<JSON.t> => {
   let out = Dict.fromArray(structure->Dict.toArray)
-  let filterArr = key =>
-    out
-    ->Dict.get(key)
-    ->Option.flatMap(JSON.Decode.array)
-    ->Option.getOr([])
-    ->Array.filter(isPublicQueryable)
-    ->JSON.Encode.array
-  out->Dict.set("readModels", filterArr("readModels"))
-  out->Dict.set("stateViewSlices", filterArr("stateViewSlices"))
+  let arrAt = key =>
+    out->Dict.get(key)->Option.flatMap(JSON.Decode.array)->Option.getOr([])
+  let readModels = arrAt("readModels")
+  let stateViewSlices = arrAt("stateViewSlices")
+  out->Dict.set("readModels", readModels->Array.filter(isPublicQueryable)->JSON.Encode.array)
+  out->Dict.set(
+    "stateViewSlices",
+    stateViewSlices->Array.filter(isPublicQueryable)->JSON.Encode.array,
+  )
+  out->Dict.set(
+    "internalQueryables",
+    Array.concat(readModels, stateViewSlices)
+    ->Array.filter(q => !isPublicQueryable(q))
+    ->JSON.Encode.array,
+  )
   out
 }
 

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res.mjs

@@ -166,9 +166,12 @@ function isPublicQueryable(q) {
 
 function filterStructure(structure) {
   let out = Object.fromEntries(Object.entries(structure));
-  let filterArr = key => Stdlib_Option.getOr(Stdlib_Option.flatMap(out[key], Stdlib_JSON.Decode.array), []).filter(isPublicQueryable);
-  out["readModels"] = filterArr("readModels");
-  out["stateViewSlices"] = filterArr("stateViewSlices");
+  let arrAt = key => Stdlib_Option.getOr(Stdlib_Option.flatMap(out[key], Stdlib_JSON.Decode.array), []);
+  let readModels = arrAt("readModels");
+  let stateViewSlices = arrAt("stateViewSlices");
+  out["readModels"] = readModels.filter(isPublicQueryable);
+  out["stateViewSlices"] = stateViewSlices.filter(isPublicQueryable);
+  out["internalQueryables"] = readModels.concat(stateViewSlices).filter(q => !isPublicQueryable(q));
   return out;
 }
 

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res

@@ -109,15 +109,19 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
   // totals because one is queried through an index. A partial pipeline here would
   // make that skew invisible rather than absent.
   let interceptorFunction = (~resolverName) =>
-    QueryInterceptor_Provisioning.dataSourceName(~api, ~opts)->Option.map(interceptorDsName =>
-      Function.makeJs(
-        ~name=resolverName ++ "Interceptor",
-        ~api,
-        ~dataSource=interceptorDsName,
-        ~code=interceptorCode(name),
-        ~opts,
+    switch QueryInterceptor_Provisioning.dataSourceName(~api, ~opts) {
+    | Off => None
+    | On(interceptorDsName) =>
+      Some(
+        Function.makeJs(
+          ~name=resolverName ++ "Interceptor",
+          ~api,
+          ~dataSource=interceptorDsName,
+          ~code=interceptorCode(name),
+          ~opts,
+        ),
       )
-    )
+    }
 
   // Creates either a unit resolver (no interceptor) or a pipeline resolver
   // (interceptor Lambda → DynamoDB query), for the Query fields that have no

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res.mjs

@@ -66,7 +66,14 @@ function make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolve
   let fieldNameForSingle = registryEntry !== undefined ? registryEntry.singleFieldName : AppSync_Resolver_Functions$PulumiAws.uncapitalize(name$1);
   let includeIdParam = registryEntry !== undefined ? registryEntry.includeIdParam : true;
   let connectionSpec = registryEntry !== undefined ? registryEntry.connectionSpec : true;
-  let interceptorFunction = resolverName => Stdlib_Option.map(QueryInterceptor_Provisioning$ReventlessAws.dataSourceName(api, opts), interceptorDsName => AppSync_Function$PulumiAws.makeJs(resolverName + "Interceptor", api, interceptorDsName, interceptorCode(name$1), opts));
+  let interceptorFunction = resolverName => {
+    let interceptorDsName = QueryInterceptor_Provisioning$ReventlessAws.dataSourceName(api, opts);
+    if (typeof interceptorDsName !== "object") {
+      return;
+    } else {
+      return AppSync_Function$PulumiAws.makeJs(resolverName + "Interceptor", api, interceptorDsName._0, interceptorCode(name$1), opts);
+    }
+  };
   let makeQueryResolver = (resolverName, field, code) => {
     let interceptorFn = interceptorFunction(resolverName);
     if (interceptorFn === undefined) {

package/src/adapter/QueryDb/QueryInterceptor_Provisioning.res

@@ -138,18 +138,34 @@ let buildInterceptor = (~api: Types.AppSync.api, ~opts) => {
   dataSource.name->Pulumi.Output.asInput
 }
 
-/** The data source a Query resolver should put in front of its DynamoDB read, or
-    `None` when interception is off — in which case the caller builds the unit
-    resolver it always did and nothing here is provisioned. */
-let dataSourceName = (~api: Types.AppSync.api, ~opts): option<Pulumi.Input.t<string>> =>
+/** Whether a Query resolver fronts its DynamoDB read with the interceptor, and
+    the data source to front it with. `Off` means interception is switched off —
+    the caller builds the unit resolver it always did and nothing here is
+    provisioned.
+
+    A variant rather than an `option`, and that is load-bearing. The payload is a
+    Pulumi `Output`, which is a JS `Proxy` answering *every* property read with a
+    derived `Output`. The generic option runtime unwraps by probing the payload
+    for `BS_PRIVATE_NESTED_SOME_NONE`; on a `Proxy` that probe never reads
+    `undefined`, so it takes the nested-option branch and yields a wrapper object
+    where a data-source name belongs. AppSync then rejects the resource with
+    "Attribute must be a single value, not a map" — at deploy time, naming a
+    field the source never mentions. A variant keeps that runtime off the path
+    entirely, so no caller can reintroduce the fault by reaching for
+    `Option.map`. */
+type t =
+  | Off
+  | On(Pulumi.Input.t<string>)
+
+let dataSourceName = (~api: Types.AppSync.api, ~opts): t =>
   if !ReventlessCore.QueryInterception.isEnabled() {
-    None
+    Off
   } else {
     switch byApi->Map.get(api) {
-    | Some(existing) => Some(existing)
+    | Some(existing) => On(existing)
     | None =>
       let created = buildInterceptor(~api, ~opts)
       byApi->Map.set(api, created)
-      Some(created)
+      On(created)
     }
   }

package/src/adapter/QueryDb/QueryInterceptor_Provisioning.res.mjs

@@ -71,15 +71,21 @@ function buildInterceptor(api, opts) {
 
 function dataSourceName(api, opts) {
   if (!QueryInterception$ReventlessCore.isEnabled()) {
-    return;
+    return "Off";
   }
   let existing = byApi.get(api);
   if (existing !== undefined) {
-    return existing;
+    return {
+      TAG: "On",
+      _0: existing
+    };
   }
   let created = buildInterceptor(api, opts);
   byApi.set(api, created);
-  return created;
+  return {
+    TAG: "On",
+    _0: created
+  };
 }
 
 export {

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res

@@ -112,3 +112,67 @@ describe("toEntryWith heals a structure persisted before a required list existed
     expect(names)->toEqual(["Products"])
   })
 })
+
+// The persisted structure is pre-filter, so this handler is a twin of the
+// in-memory `encodePluginStructureEntry` rather than a consequence of it. A shell
+// reading `internalQueryables` against a platform that emits it on only one
+// transport gets working pickers locally and silent text inputs when deployed —
+// which is why the split is asserted here as well as in core.
+describe("toEntryWith carries Internal queryables on the filtered field", () => {
+  let mixed = Dict.fromArray([
+    (
+      "readModels",
+      JSON.Encode.array([
+        JSON.parseOrThrow(`{"name": "AvailableProducts", "visibility": "Internal"}`),
+        JSON.parseOrThrow(`{"name": "Products"}`),
+      ]),
+    ),
+    (
+      "stateViewSlices",
+      JSON.Encode.array([
+        JSON.parseOrThrow(`{"name": "PendingShipments", "visibility": "Internal"}`),
+      ]),
+    ),
+  ])->JSON.Encode.object
+
+  let namesAt = (~filter, collection) =>
+    entry(~filter, mixed)
+    ->Option.map(members(_, collection))
+    ->Option.getOr([])
+    ->Array.filterMap(m => m->Dict.get("name")->Option.flatMap(JSON.Decode.string))
+
+  testSync("emits the complement of the filter, fed by both source arrays", () =>
+    expect(namesAt(~filter=true, "internalQueryables"))->toEqual([
+      "AvailableProducts",
+      "PendingShipments",
+    ])
+  )
+
+  testSync("keeps the surface lists public-only", () => {
+    expect(namesAt(~filter=true, "readModels"))->toEqual(["Products"])
+    expect(namesAt(~filter=true, "stateViewSlices"))->toEqual([])
+  })
+
+  // Platform_PluginStructures serves Internal components inline; a duplicate list
+  // there would be a second answer to a question that already has one.
+  testSync("adds nothing to the complete field", () =>
+    expect(
+      entry(~filter=false, mixed)->Option.flatMap(o => o->Dict.get("internalQueryables")),
+    )->toEqual(None)
+  )
+
+  // A structure persisted before the field existed has no key for it, and must not
+  // grow one from its own contents — the complement is always recomputed.
+  testSync("computes the complement rather than reading it off the structure", () => {
+    let stale = Dict.fromArray([
+      ("internalQueryables", JSON.parseOrThrow(`[{"name": "Stale"}]`)),
+      ("readModels", JSON.parseOrThrow(`[{"name": "Products"}]`)),
+    ])->JSON.Encode.object
+    let names =
+      entry(~filter=true, stale)
+      ->Option.map(members(_, "internalQueryables"))
+      ->Option.getOr([])
+      ->Array.filterMap(m => m->Dict.get("name")->Option.flatMap(JSON.Decode.string))
+    expect(names)->toEqual([])
+  })
+})

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res.mjs

@@ -64,6 +64,50 @@ globalThis.describe("toEntryWith heals a structure persisted before a required l
   });
 });
 
+globalThis.describe("toEntryWith carries Internal queryables on the filtered field", () => {
+  let mixed = Object.fromEntries([
+    [
+      "readModels",
+      [
+        JSON.parse(`{"name": "AvailableProducts", "visibility": "Internal"}`),
+        JSON.parse(`{"name": "Products"}`)
+      ]
+    ],
+    [
+      "stateViewSlices",
+      [JSON.parse(`{"name": "PendingShipments", "visibility": "Internal"}`)]
+    ]
+  ]);
+  let namesAt = (filter, collection) => Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.map(entry(filter, mixed), __x => members(__x, collection)), []), m => Stdlib_Option.flatMap(m["name"], Stdlib_JSON.Decode.string));
+  globalThis.test("emits the complement of the filter, fed by both source arrays", () => {
+    globalThis.expect(namesAt(true, "internalQueryables")).toEqual([
+      "AvailableProducts",
+      "PendingShipments"
+    ]);
+  });
+  globalThis.test("keeps the surface lists public-only", () => {
+    globalThis.expect(namesAt(true, "readModels")).toEqual(["Products"]);
+    globalThis.expect(namesAt(true, "stateViewSlices")).toEqual([]);
+  });
+  globalThis.test("adds nothing to the complete field", () => {
+    globalThis.expect(Stdlib_Option.flatMap(entry(false, mixed), o => o["internalQueryables"])).toEqual(undefined);
+  });
+  globalThis.test("computes the complement rather than reading it off the structure", () => {
+    let stale = Object.fromEntries([
+      [
+        "internalQueryables",
+        JSON.parse(`[{"name": "Stale"}]`)
+      ],
+      [
+        "readModels",
+        JSON.parse(`[{"name": "Products"}]`)
+      ]
+    ]);
+    let names = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.map(entry(true, stale), __x => members(__x, "internalQueryables")), []), m => Stdlib_Option.flatMap(m["name"], Stdlib_JSON.Decode.string));
+    globalThis.expect(names).toEqual([]);
+  });
+});
+
 export {
   entry,
   members,