@reventlessdev/reventless-aws 3.0.0-alpha.265 → 3.0.0-alpha.267

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.267 (2026-08-04)
+
+### Features
+
+* **admin:** serve the complete plugin structure to developer tooling ([e99cda0](https://github.com/ReventlessDev/reventless-core/commit/e99cda02a2f862b36bcfdb018a0fb34bb7426a2b))
+
+
+# 3.0.0-alpha.266 (2026-08-04)
+
+### Features
+
+* **geocoding:** serve geocoding through the platform GraphQL API (D9 half 2) ([914d3c0](https://github.com/ReventlessDev/reventless-core/commit/914d3c0a99a1b67ffb89e2b8259dd30f67ff9bae))
+
+
 # 3.0.0-alpha.265 (2026-08-04)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.265",
+  "version": "3.0.0-alpha.267",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -17,12 +17,12 @@
     "@reventlessdev/rescript-pulumi-aws": "2.4.0-alpha.65",
     "@reventlessdev/rescript-node": "2.0.0-alpha.1",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.126",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.212",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.76",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.210",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.125",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.74",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.100",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.30"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.100"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Platform.res

@@ -82,24 +82,21 @@ let objectStoreEndpointsRef: ref<array<objectStoreEndpoint>> = ref([])
     `getApiConfig` does. */
 let getObjectStoreEndpoints = () => objectStoreEndpointsRef.contents
 
-/** The geocoder endpoint this platform provisioned, for the monolithic case.
+/** The geocoding place index this platform provisioned, for the monolithic case.
 
-    In plugin mode the value crosses to the plugin stack as the `geocoderEndpoint`
+    In plugin mode the value crosses to the plugin stack as the `geocoderPlaceIndex`
     export; when platform and plugin are one program there is no stack to read, so
     `deployPlatform` records it here and `deployPlugin` picks it up — the same two
-    halves `objectStoreEndpointsRef` exists for.
+    halves `objectStoreEndpointsRef` exists for. Slice Lambdas call Amazon Location
+    directly with this index name; the browser reaches the same capability through
+    the platform API's `Query.geocode` resolver (D9 half 2), so there is no endpoint
+    to carry beside it.
 
     A plain Output with `""` as the "no geocoder" sentinel, never
     `option<Pulumi.Output.t<_>>`: any generic `Option.*` over an Output runs
     `valFromOption`, whose nested-option probe hits the Output proxy — where every
     property access returns a truthy Output — and corrupts it. Same reasoning, and
     the same sentinel, as `PluginRuntime_Builder.inboundSliceReg.auditTableName`. */
-let geocoderEndpointRef: ref<Pulumi.Output.t<string>> = ref(Pulumi.Output.make(""))
-
-/** The geocoding place index, for the monolithic case — the SDK-side half of the
-    same capability, carried for exactly the reasons above and with the same `""`
-    sentinel. Slice Lambdas call Amazon Location directly with this; only the
-    browser needs the Function URL. */
 let geocoderPlaceIndexRef: ref<Pulumi.Output.t<string>> = ref(Pulumi.Output.make(""))
 
 module MakeWithConfig = (
@@ -248,9 +245,15 @@ module MakeWithConfig = (
   // unified mode carries the admin base here instead; it declares no stores in practice,
   // so the upload resolvers below are never created there.)
   let domainBaseFragment = ReventlessCore.GraphQL_Stitcher.encode({
-    types: ReventlessCore.Platform_AdminApi.uploadTypes,
+    types: Array.concat(
+      ReventlessCore.Platform_AdminApi.uploadTypes,
+      ReventlessCore.Platform_AdminApi.geocodeTypes,
+    ),
     mutations: ReventlessCore.Platform_AdminApi.uploadMutationFields,
-    queries: ["  Platform_ping: String"],
+    queries: Array.concat(
+      ["  Platform_ping: String"],
+      ReventlessCore.Platform_AdminApi.geocodeQueryFields,
+    ),
     subscriptions: [],
     subscriptionSources: [],
   })
@@ -1152,10 +1155,10 @@ module MakeWithConfig = (
     // unchanged. Single-mode shape: one origin-relative file per deployment.
     uiHintsFile?: string,
     // Optional geocoding place index, as returned by
-    // `Capability_Geocoding_AwsLocation.make`. When set, the deploy provisions a
-    // public geocoder Lambda Function URL (Geocoder_AwsLocation) and threads its
-    // URL into config.json as `geocoderEndpoint`. Unset ⇒ no service, field
-    // omitted (byte-identical config.json).
+    // `Capability_Geocoding_AwsLocation.make`. When set, the deploy provisions the
+    // capability's client door — a Cognito-authenticated `Query.geocode` resolver
+    // on the domain API (`Geocoder_AwsLocation_Resolver`, split mode) — and exports
+    // the index name for the unattended slice path. Unset ⇒ no resolver, no export.
     geocoderPlaceIndex?: ReventlessInfra.Platform.geocoderIndex,
     // Optional object store for direct-to-S3 uploads, as returned by
     // `Capability_ObjectStore_S3.make`. When set, the deploy registers it with
@@ -1449,6 +1452,7 @@ module MakeWithConfig = (
         ~api=platformApi,
         ~pluginReadModelTableName=tableName,
         ~offloadBucketName,
+        ~schemaReady=admin.adminSchemaPushed,
         ~opts={},
       )
     | None => ()
@@ -2066,35 +2070,32 @@ module MakeWithConfig = (
       | None => Pulumi.Output.make(None)
       }
 
-      // Optional public geocoder Function URL. Provisioned only when a place
-      // index is configured; its resolved URL becomes config.json's
-      // `geocoderEndpoint`. Unset ⇒ Output<None> ⇒ field omitted below.
-      let geocoderEndpointOutput: Pulumi.Output.t<option<string>> = switch cfg.geocoderPlaceIndex {
-      | Some(index) =>
-        Geocoder_AwsLocation.make(
+      // The geocoding capability's client door (D9 half 2): a `Query.geocode`
+      // resolver on the domain API, provisioned only when a place index is
+      // configured. Authenticated by the API's Cognito authorizer, so it replaces
+      // the public unauthenticated Function URL the browser used to call — after
+      // which that endpoint has no callers at all (the unattended slice path reaches
+      // the same index through the SDK, via `geocoderPlaceIndex` below).
+      //
+      // Split-API only, for the same reason the upload resolvers are: `geocode`
+      // lives on the domain base document (`domainBaseFragment`), which a
+      // unified-mode deployment's single API does not carry.
+      switch cfg.geocoderPlaceIndex {
+      | Some(index) if Config.splitApi =>
+        let _geocodeService = Geocoder_AwsLocation_Resolver.make(
+          ~api=domainApi,
           ~placeIndexName=index.indexName,
-        ).url->Pulumi.Output.apply(u => Some(u))
-      | None => Pulumi.Output.make(None)
+          ~opts={},
+        )
+      | _ => ()
       }
 
-      // Exported as well as written into config.json, because the browser is no
-      // longer the only caller: a plugin stack's slice Lambdas geocode too, and a
-      // plugin stack has no other way to see a value computed in this one.
-      //
-      // `""` when unset rather than a missing output, so the read side has one
-      // shape to handle instead of two — and "" is already what a client reads as
-      // "no geocoder configured".
-      let geocoderEndpointFlat =
-        geocoderEndpointOutput->Pulumi.Output.apply(o => o->Option.getOr(""))
-      Pulumi.Pulumi.export("geocoderEndpoint", geocoderEndpointFlat)
-      geocoderEndpointRef := geocoderEndpointFlat
-
-      // The place index itself, exported beside the Function URL because the two
-      // callers need different things from the same capability. A browser cannot
-      // sign an SDK call and gets the URL; a slice's Lambda can, and gets the
-      // index name — no proxy hop, and no dependence on a public unauthenticated
-      // endpoint for an unattended path. `""` when unset, for the same
-      // one-shape-to-handle reason as the endpoint above.
+      // The place index itself, exported so the unattended slice path can reach the
+      // capability: a slice's Lambda signs an SDK call directly and needs the index
+      // name, not an endpoint (no proxy hop, no dependence on a public URL). The
+      // browser reaches the same capability through the `Query.geocode` resolver
+      // above. `""` when unset, so a plugin stack reading this output has one shape
+      // to handle rather than two.
       let geocoderPlaceIndexFlat = switch cfg.geocoderPlaceIndex {
       | Some(index) => index.indexName->Pulumi.Output.fromInput
       | None => Pulumi.Output.make("")
@@ -2116,14 +2117,9 @@ module MakeWithConfig = (
             cognitoPool.clientId,
           )->Pulumi.Output.all4,
           domainEventsEndpointOutput,
-          geocoderEndpointOutput,
         )
-        ->Pulumi.Output.all3
-        ->Pulumi.Output.apply(((
-          (domainEp, platformEp, poolId, clientId),
-          eventsEpOpt,
-          geocoderEpOpt,
-        )) => {
+        ->Pulumi.Output.all2
+        ->Pulumi.Output.apply((((domainEp, platformEp, poolId, clientId), eventsEpOpt)) => {
           let computed = [
             ("apiEndpoint", JSON.Encode.string(domainEp)),
             ("platformApiEndpoint", JSON.Encode.string(platformEp)),
@@ -2151,12 +2147,12 @@ module MakeWithConfig = (
             )
           | None => computed
           }
-          let withGeocoder = switch geocoderEpOpt {
-          | Some(ep) => Array.concat(withEvents, [("geocoderEndpoint", JSON.Encode.string(ep))])
-          | None => withEvents
-          }
+          // `geocoderEndpoint` is no longer written: the browser reaches geocoding
+          // through the platform API's `Query.geocode` resolver (D9 half 2), the
+          // same way uploads moved off a per-store URL onto `Upload_Presign`. The
+          // public Function URL and its config key are both gone.
           Util_ShellConfig.fields(
-            ~computed=withGeocoder,
+            ~computed=withEvents,
             ~viewModes=?cfg.viewModes,
             ~shellConfig=?cfg.shellConfig,
           )

package/src/Platform.res.mjs

@@ -59,7 +59,6 @@ import * as AppSync_SdlDecorate$ReventlessAws from "./components/Api/AppSync_Sdl
 import * as UiFragmentRegistry$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs";
 import * as Util_ResourceNaming$ReventlessAws from "./util/Util_ResourceNaming.res.mjs";
 import * as ClonerRunner_Fargate$ReventlessAws from "./plugin/cloner/ClonerRunner_Fargate.res.mjs";
-import * as Geocoder_AwsLocation$ReventlessAws from "./adapter/Geocoder/Geocoder_AwsLocation.res.mjs";
 import * as QueryEngine_DynamoDb$ReventlessAws from "./adapter/QueryEngine/QueryEngine_DynamoDb.res.mjs";
 import * as PluginRuntime_Builder$ReventlessAws from "./plugin/runtime/PluginRuntime_Builder.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
@@ -85,6 +84,7 @@ import * as CommandTopicChannel_SQS_Sync$ReventlessAws from "./adapter/CommandTo
 import * as EventLogSubscription_AppSync$ReventlessAws from "./adapter/EventLogSubscription/EventLogSubscription_AppSync.res.mjs";
 import * as UiFragmentRegistry_Behavior$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry_Behavior.res.mjs";
 import * as CommandTopicChannel_SQS_Async$ReventlessAws from "./adapter/CommandTopic/CommandTopicChannel_SQS_Async.res.mjs";
+import * as Geocoder_AwsLocation_Resolver$ReventlessAws from "./adapter/Geocoder/Geocoder_AwsLocation_Resolver.res.mjs";
 import * as Plugin_ExtensionPoint_Builder$ReventlessAws from "./plugin/stack/Plugin_ExtensionPoint_Builder.res.mjs";
 import * as QueryDbStorage_DynamoDbStream$ReventlessAws from "./adapter/QueryDb/QueryDbStorage_DynamoDbStream.res.mjs";
 import * as StateViewSlice_Builder_Stream$ReventlessAws from "./components/StateViewSlice_Builder_Stream.res.mjs";
@@ -130,10 +130,6 @@ function getObjectStoreEndpoints() {
   return objectStoreEndpointsRef.contents;
 }
 
-let geocoderEndpointRef = {
-  contents: Pulumi.output("")
-};
-
 let geocoderPlaceIndexRef = {
   contents: Pulumi.output("")
 };
@@ -193,9 +189,9 @@ function MakeWithConfig(Config) {
     }
   };
   let domainBaseFragment = GraphQL_Stitcher$ReventlessCore.encode({
-    types: Platform_AdminApi$ReventlessCore.uploadTypes,
+    types: Platform_AdminApi$ReventlessCore.uploadTypes.concat(Platform_AdminApi$ReventlessCore.geocodeTypes),
     mutations: Platform_AdminApi$ReventlessCore.uploadMutationFields,
-    queries: ["  Platform_ping: String"],
+    queries: ["  Platform_ping: String"].concat(Platform_AdminApi$ReventlessCore.geocodeQueryFields),
     subscriptions: [],
     subscriptionSources: []
   });
@@ -865,7 +861,7 @@ function MakeWithConfig(Config) {
     Pulumi$Pulumi.$$export("offloadBucket", offloadBucketName);
     if (pluginReadModelTableName !== undefined) {
       AggregateRuntime_Builder_Single$ReventlessAws.setPluginReadModelTable(pluginReadModelTableName);
-      Platform_ComponentDefinitions_Lambda$ReventlessAws.make(platformApi, pluginReadModelTableName, offloadBucketName, {});
+      Platform_ComponentDefinitions_Lambda$ReventlessAws.make(platformApi, pluginReadModelTableName, offloadBucketName, admin.adminSchemaPushed, {});
     }
     let rm = admin.stateViewSlicesOutputs["UiFragments"];
     if (rm !== undefined) {
@@ -1131,10 +1127,9 @@ function MakeWithConfig(Config) {
       let cognitoPool = Platform_Stack$ReventlessAws.resolveCognitoUserPool();
       let domainEventsEndpointOutput = domainEventsApiOpt !== undefined ? AppSync_EventsApi$ReventlessAws.httpEndpoint(domainEventsApiOpt).apply(ep => ep + "/event") : Pulumi.output(undefined);
       let index = hostUiBundle.geocoderPlaceIndex;
-      let geocoderEndpointOutput = index !== undefined ? Geocoder_AwsLocation$ReventlessAws.make(index.indexName, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
-      let geocoderEndpointFlat = geocoderEndpointOutput.apply(o => Stdlib_Option.getOr(o, ""));
-      Pulumi$Pulumi.$$export("geocoderEndpoint", geocoderEndpointFlat);
-      geocoderEndpointRef.contents = geocoderEndpointFlat;
+      if (index !== undefined && Config.splitApi) {
+        Geocoder_AwsLocation_Resolver$ReventlessAws.make(domainApi, index.indexName, undefined, {});
+      }
       let index$1 = hostUiBundle.geocoderPlaceIndex;
       let geocoderPlaceIndexFlat = index$1 !== undefined ? index$1.indexName : Pulumi.output("");
       Pulumi$Pulumi.$$export("geocoderPlaceIndex", geocoderPlaceIndexFlat);
@@ -1146,10 +1141,8 @@ function MakeWithConfig(Config) {
           cognitoPool.poolId,
           cognitoPool.clientId
         ]),
-        domainEventsEndpointOutput,
-        geocoderEndpointOutput
+        domainEventsEndpointOutput
       ]).apply(param => {
-        let geocoderEpOpt = param[2];
         let eventsEpOpt = param[1];
         let match = param[0];
         let computed = [
@@ -1196,11 +1189,7 @@ function MakeWithConfig(Config) {
               AppSync_EventsApi$ReventlessAws.clientNamespaceName
             ]
           ]) : computed;
-        let withGeocoder = geocoderEpOpt !== undefined ? withEvents.concat([[
-              "geocoderEndpoint",
-              geocoderEpOpt
-            ]]) : withEvents;
-        return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withGeocoder, hostUiBundle.viewModes, hostUiBundle.shellConfig));
+        return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withEvents, hostUiBundle.viewModes, hostUiBundle.shellConfig));
       });
       new (Aws.s3.BucketObject)("host-ui-config-json", {
         bucket: bucketName,
@@ -1452,9 +1441,9 @@ function Make($star) {
     }
   };
   let domainBaseFragment = GraphQL_Stitcher$ReventlessCore.encode({
-    types: Platform_AdminApi$ReventlessCore.uploadTypes,
+    types: Platform_AdminApi$ReventlessCore.uploadTypes.concat(Platform_AdminApi$ReventlessCore.geocodeTypes),
     mutations: Platform_AdminApi$ReventlessCore.uploadMutationFields,
-    queries: ["  Platform_ping: String"],
+    queries: ["  Platform_ping: String"].concat(Platform_AdminApi$ReventlessCore.geocodeQueryFields),
     subscriptions: [],
     subscriptionSources: []
   });
@@ -2107,7 +2096,7 @@ function Make($star) {
     Pulumi$Pulumi.$$export("offloadBucket", offloadBucketName);
     if (pluginReadModelTableName !== undefined) {
       AggregateRuntime_Builder_Single$ReventlessAws.setPluginReadModelTable(pluginReadModelTableName);
-      Platform_ComponentDefinitions_Lambda$ReventlessAws.make(platformApi, pluginReadModelTableName, offloadBucketName, {});
+      Platform_ComponentDefinitions_Lambda$ReventlessAws.make(platformApi, pluginReadModelTableName, offloadBucketName, admin.adminSchemaPushed, {});
     }
     let rm = admin.stateViewSlicesOutputs["UiFragments"];
     if (rm !== undefined) {
@@ -2367,10 +2356,9 @@ function Make($star) {
       let cognitoPool = Platform_Stack$ReventlessAws.resolveCognitoUserPool();
       let domainEventsEndpointOutput = domainEventsApiOpt !== undefined ? AppSync_EventsApi$ReventlessAws.httpEndpoint(domainEventsApiOpt).apply(ep => ep + "/event") : Pulumi.output(undefined);
       let index = hostUiBundle.geocoderPlaceIndex;
-      let geocoderEndpointOutput = index !== undefined ? Geocoder_AwsLocation$ReventlessAws.make(index.indexName, undefined, undefined).url.apply(u => u) : Pulumi.output(undefined);
-      let geocoderEndpointFlat = geocoderEndpointOutput.apply(o => Stdlib_Option.getOr(o, ""));
-      Pulumi$Pulumi.$$export("geocoderEndpoint", geocoderEndpointFlat);
-      geocoderEndpointRef.contents = geocoderEndpointFlat;
+      if (index !== undefined) {
+        Geocoder_AwsLocation_Resolver$ReventlessAws.make(domainApi, index.indexName, undefined, {});
+      }
       let index$1 = hostUiBundle.geocoderPlaceIndex;
       let geocoderPlaceIndexFlat = index$1 !== undefined ? index$1.indexName : Pulumi.output("");
       Pulumi$Pulumi.$$export("geocoderPlaceIndex", geocoderPlaceIndexFlat);
@@ -2382,10 +2370,8 @@ function Make($star) {
           cognitoPool.poolId,
           cognitoPool.clientId
         ]),
-        domainEventsEndpointOutput,
-        geocoderEndpointOutput
+        domainEventsEndpointOutput
       ]).apply(param => {
-        let geocoderEpOpt = param[2];
         let eventsEpOpt = param[1];
         let match = param[0];
         let computed = [
@@ -2432,11 +2418,7 @@ function Make($star) {
               AppSync_EventsApi$ReventlessAws.clientNamespaceName
             ]
           ]) : computed;
-        let withGeocoder = geocoderEpOpt !== undefined ? withEvents.concat([[
-              "geocoderEndpoint",
-              geocoderEpOpt
-            ]]) : withEvents;
-        return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withGeocoder, hostUiBundle.viewModes, hostUiBundle.shellConfig));
+        return JSON.stringify(Util_ShellConfig$ReventlessAws.fields(withEvents, hostUiBundle.viewModes, hostUiBundle.shellConfig));
       });
       new (Aws.s3.BucketObject)("host-ui-config-json", {
         bucket: bucketName,
@@ -2645,7 +2627,6 @@ export {
   getSplitApiOutputs,
   objectStoreEndpointsRef,
   getObjectStoreEndpoints,
-  geocoderEndpointRef,
   geocoderPlaceIndexRef,
   MakeWithConfig,
   Make,

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda.res

@@ -24,10 +24,29 @@ export function response(ctx) {
 }
 `->Pulumi.Input.make
 
+// `Platform_PluginStructures` — the same scan, unfiltered. The `complete` flag is
+// the whole difference; see the handler's `toEntryWith`.
+let completeResolverCode = `
+import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  return { operation: 'Invoke', payload: { complete: true } };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`->Pulumi.Input.make
+
 let make = (
   ~api: Pulumi.Output.t<AppSync.GraphQLApi.t>,
   ~pluginReadModelTableName: Pulumi.Output.t<string>,
   ~offloadBucketName: Pulumi.Output.t<string>,
+  // Resolves once the admin schema push is ACTIVE (Platform_Admin.adminSchemaPushed).
+  // Only the `Platform_PluginStructures` resolver is gated on it: that field is new,
+  // so CreateResolver would otherwise race StartSchemaCreation on the deploy that
+  // first ships it. `Platform_ComponentDefinitions` predates the gate and is left
+  // ungated so this change adds no dependency edge to an already-deployed resource.
+  ~schemaReady: Pulumi.Output.t<unit>,
   ~opts: Pulumi.ComponentResource.options,
 ) => {
   let opts = opts->ReventlessCore.Util.Pulumi.ComponentResourceOptions.toCustomResourceOptions
@@ -215,4 +234,21 @@ let make = (
     ~code=resolverCode,
     ~opts,
   )
+
+  // Second field, same DataSource and same Lambda — the developer-tooling read of
+  // the identical scan. Sharing the data source is what keeps the two answers from
+  // drifting: there is one place that decides what a deployed plugin's structure is.
+  // Created only after the schema carrying `Platform_PluginStructures` is ACTIVE.
+  let _structuresResolver =
+    schemaReady->Pulumi.Output.apply(() =>
+      AppSync_Resolver_Native.makeUnitJsResolver(
+        ~name=name ++ "StructuresResolver",
+        ~api,
+        ~dataSourceName=dataSource.name->Pulumi.Output.asInput,
+        ~type_="Query"->Pulumi.Input.make,
+        ~field="Platform_PluginStructures"->Pulumi.Input.make,
+        ~code=completeResolverCode,
+        ~opts,
+      )
+    )
 }

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

@@ -27,7 +27,18 @@ export function response(ctx) {
 }
 `;
 
-function make(api, pluginReadModelTableName, offloadBucketName, opts) {
+let completeResolverCode = `
+import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  return { operation: 'Invoke', payload: { complete: true } };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`;
+
+function make(api, pluginReadModelTableName, offloadBucketName, schemaReady, opts) {
   let opts$1 = Util_Pulumi$ReventlessCore.ComponentResourceOptions.toCustomResourceOptions(opts);
   let name = "PlatformUIDefinitions";
   let lambdaRole = IAM$PulumiAws.Role.makeWithDefaultPolicy(name + "Lambda", Pulumi.output(AWS$ReventlessAws.Lambda.principal), AWS_Tags$ReventlessAws.make(name + "Lambda", "Platform", "Identity", "Platform", undefined, undefined, undefined, undefined), opts$1);
@@ -131,10 +142,12 @@ function make(api, pluginReadModelTableName, offloadBucketName, opts) {
     serviceRoleArn: dataSourceRole.arn
   }, opts$1);
   AppSync_Resolver_Native$ReventlessAws.makeUnitJsResolver(name + "Resolver", api, dataSource.name, "Query", "Platform_ComponentDefinitions", resolverCode, opts$1);
+  schemaReady.apply(() => AppSync_Resolver_Native$ReventlessAws.makeUnitJsResolver(name + "StructuresResolver", api, dataSource.name, "Query", "Platform_PluginStructures", completeResolverCode, opts$1));
 }
 
 export {
   resolverCode,
+  completeResolverCode,
   make,
 }
 /* @pulumi/aws Not a pure module */

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res

@@ -43,11 +43,21 @@ let filterStructure = (structure: JSON.t): option<dict<JSON.t>> =>
     Some(out)
   }
 
-// `{pluginId: name, ...filterStructure(structure)}` — pluginId first so the
-// structure's fields win on the (never-expected) key collision, matching the JS
-// spread. Drops a row with no decodable structure (former `!item.structure`).
-let toEntry = (item: dict<JSON.t>, ~name: string): option<JSON.t> =>
-  switch item->Dict.get("structure")->Option.flatMap(filterStructure) {
+// `{pluginId: name, ...structure}` — pluginId first so the structure's fields win
+// on the (never-expected) key collision, matching the JS spread. Drops a row with
+// no decodable structure (former `!item.structure`).
+//
+// `~filter` is what separates the two fields this handler serves: AutoUI
+// (`Platform_ComponentDefinitions`) gets the public-queryable subset, developer
+// tooling (`Platform_PluginStructures`) gets the structure exactly as persisted,
+// including Internal components and the producer-side `extensionPoints` that the
+// AutoUI entry type does not declare.
+let toEntryWith = (~filter: bool, item: dict<JSON.t>, ~name: string): option<JSON.t> => {
+  let structure =
+    item
+    ->Dict.get("structure")
+    ->Option.flatMap(s => filter ? filterStructure(s) : s->JSON.Decode.object)
+  switch structure {
   | None => None
   | Some(structureObj) =>
     let entry = Dict.make()
@@ -55,10 +65,17 @@ let toEntry = (item: dict<JSON.t>, ~name: string): option<JSON.t> =>
     structureObj->Dict.toArray->Array.forEach(((k, v)) => entry->Dict.set(k, v))
     Some(JSON.Encode.object(entry))
   }
+}
+
 
 // The built-in Platform_Admin entry, injected at deploy time as the
 // ADMIN_ENTRY_JSON env var (the admin never Connects to itself, so its structure
 // never enters the Plugin read model).
+//
+// Shared by both fields. The admin structure has no Internal components and no
+// extension points, so its filtered and complete encodings carry the same
+// components; the structure-level fields the complete entry adds are absent from
+// this JSON and resolve to null, which is what `extensionPoints: None` means.
 let adminEntry: option<JSON.t> =
   switch NodeProcess.env->Dict.get("ADMIN_ENTRY_JSON") {
   | Some(s) if s != "" => Some(JSON.parseOrThrow(s))
@@ -94,7 +111,21 @@ let resolveStructure = (
     }
   }
 
-let handler = async (_event: JSON.t): array<JSON.t> => {
+// One Lambda serves both fields — the scan, the offload resolution and the
+// latest-version-per-plugin collapse are identical work, and duplicating them into
+// a second function would mean a second cold start and a second chance for the two
+// to disagree about what "the deployed structure" is. The resolver for
+// `Platform_PluginStructures` invokes with `{complete: true}`.
+let isComplete = (event: JSON.t): bool =>
+  event
+  ->JSON.Decode.object
+  ->Option.flatMap(o => o->Dict.get("complete"))
+  ->Option.flatMap(JSON.Decode.bool)
+  ->Option.getOr(false)
+
+let handler = async (event: JSON.t): array<JSON.t> => {
+  let complete = isComplete(event)
+  let toEntry = (item, ~name) => toEntryWith(~filter=!complete, item, ~name)
   let admin = adminEntry->Option.mapOr([], e => [e])
   switch NodeProcess.env->Dict.get("PLUGIN_RM_TABLE") {
   | None | Some("") =>

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

@@ -31,14 +31,20 @@ function filterStructure(structure) {
   return out;
 }
 
-function toEntry(item, name) {
-  let structureObj = Stdlib_Option.flatMap(item["structure"], filterStructure);
-  if (structureObj === undefined) {
+function toEntryWith(filter, item, name) {
+  let structure = Stdlib_Option.flatMap(item["structure"], s => {
+    if (filter) {
+      return filterStructure(s);
+    } else {
+      return Stdlib_JSON.Decode.object(s);
+    }
+  });
+  if (structure === undefined) {
     return;
   }
   let entry = {};
   entry["pluginId"] = name;
-  Object.entries(structureObj).forEach(param => {
+  Object.entries(structure).forEach(param => {
     entry[param[0]] = param[1];
   });
   return entry;
@@ -65,7 +71,13 @@ function resolveStructure(fetch, item) {
   }
 }
 
-async function handler(_event) {
+function isComplete(event) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(event), o => o["complete"]), Stdlib_JSON.Decode.bool), false);
+}
+
+async function handler(event) {
+  let complete = isComplete(event);
+  let toEntry = (item, name) => toEntryWith(!complete, item, name);
   let admin = Stdlib_Option.mapOr(adminEntry, [], e => [e]);
   let table = process.env["PLUGIN_RM_TABLE"];
   if (table !== undefined) {
@@ -94,9 +106,10 @@ export {
   str,
   isPublicQueryable,
   filterStructure,
-  toEntry,
+  toEntryWith,
   adminEntry,
   resolveStructure,
+  isComplete,
   handler,
 }
 /* s Not a pure module */