@reventlessdev/reventless-core 3.0.0-alpha.155 → 3.0.0-alpha.157

package/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry.res.mjs

@@ -0,0 +1,87 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
+
+let commandSchema = S.union([
+  S.schema(s => ({
+    TAG: "RegisterApiFragment",
+    pluginId: s.m(DcbTag$Reventless.string),
+    fragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "DeregisterApiFragment",
+    pluginId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "RecordApiFragmentPush",
+    pluginId: s.m(DcbTag$Reventless.string),
+    ok: s.m(S.bool),
+    message: s.m(S.string),
+    at: s.m(S.string)
+  }))
+]);
+
+let errorSchema = S.literal("RegistryError");
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ApiFragmentRegistered",
+    pluginId: s.m(DcbTag$Reventless.string),
+    fragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentUpdated",
+    pluginId: s.m(DcbTag$Reventless.string),
+    previousFragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    newFragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentDeregistered",
+    pluginId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentPushRecorded",
+    pluginId: s.m(DcbTag$Reventless.string),
+    ok: s.m(S.bool),
+    message: s.m(S.string),
+    at: s.m(S.string)
+  }))
+]);
+
+let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, ["RecordApiFragmentPush"]);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "ApiFragmentRegistry";
+
+let Id;
+
+let consumedEventSchema = eventSchema;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry.res.mjs";
+
+let readConsistency = "EscalateOnRetry";
+
+export {
+  name,
+  Id,
+  errorSchema,
+  eventSchema,
+  consumedEventSchema,
+  commandSchema$1 as commandSchema,
+  moduleUrl,
+  commandAuthorization,
+  readConsistency,
+}
+/* commandSchema Not a pure module */

package/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry_Behavior.res

@@ -0,0 +1,58 @@
+@@reventless.behavior
+
+open Reventless.Plugin
+
+// The current fragment for this plugin name plus its target API and the last recorded push
+// outcome (kept only to dedupe at-least-once redelivery of RecordApiFragmentPush), or None
+// when no fragment is registered.
+type registryEntry = {
+  fragment: apiSchemaFragment,
+  apiTarget: apiTarget,
+  lastPush: option<(bool, string, string)>, // (ok, message, at)
+}
+type state = option<registryEntry>
+
+let initialState = None
+
+let evolve = (state, event) =>
+  switch event {
+  | ApiFragmentRegistered({fragment, apiTarget}) => Some({fragment, apiTarget, lastPush: None})
+  | ApiFragmentUpdated({newFragment, apiTarget}) =>
+    Some({fragment: newFragment, apiTarget, lastPush: None})
+  | ApiFragmentDeregistered(_) => None
+  | ApiFragmentPushRecorded({ok, message, at}) =>
+    state->Option.map(entry => {...entry, lastPush: Some((ok, message, at))})
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | RegisterApiFragment({pluginId, fragment, apiTarget, at}) =>
+    switch state {
+    | None => Ok([ApiFragmentRegistered({pluginId, fragment, apiTarget, at})])
+    // Idempotent: an unchanged re-registration (same fragment AND same target — e.g. a
+    // redeploy carrying the same schema, or a version supersession that didn't change the
+    // SDL) emits nothing. A target change with an identical fragment IS meaningful (the
+    // fields move between the Domain and Platform APIs), so it is not a no-op.
+    | Some({fragment: current, apiTarget: currentTarget})
+      if current == fragment && currentTarget == apiTarget =>
+      Ok([])
+    | Some({fragment: current}) =>
+      Ok([
+        ApiFragmentUpdated({pluginId, previousFragment: current, newFragment: fragment, apiTarget, at}),
+      ])
+    }
+  | DeregisterApiFragment({pluginId}) =>
+    switch state {
+    | None => Ok([]) // idempotent — nothing registered
+    | Some(_) => Ok([ApiFragmentDeregistered({pluginId: pluginId})])
+    }
+  | RecordApiFragmentPush({pluginId, ok, message, at}) =>
+    switch state {
+    | None => Ok([]) // fragment deregistered in the meantime — nowhere to record
+    // Idempotent: an at-least-once redelivery carries the identical payload.
+    | Some({lastPush: Some((lastOk, lastMessage, lastAt))})
+      if lastOk == ok && lastMessage == message && lastAt == at =>
+      Ok([])
+    | Some(_) => Ok([ApiFragmentPushRecorded({pluginId, ok, message, at})])
+    }
+  }

package/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry_Behavior.res.mjs

@@ -0,0 +1,135 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function evolve(state, event) {
+  switch (event.TAG) {
+    case "ApiFragmentRegistered" :
+      return {
+        fragment: event.fragment,
+        apiTarget: event.apiTarget,
+        lastPush: undefined
+      };
+    case "ApiFragmentUpdated" :
+      return {
+        fragment: event.newFragment,
+        apiTarget: event.apiTarget,
+        lastPush: undefined
+      };
+    case "ApiFragmentDeregistered" :
+      return;
+    case "ApiFragmentPushRecorded" :
+      let at = event.at;
+      let message = event.message;
+      let ok = event.ok;
+      return Stdlib_Option.map(state, entry => ({
+        fragment: entry.fragment,
+        apiTarget: entry.apiTarget,
+        lastPush: [
+          ok,
+          message,
+          at
+        ]
+      }));
+  }
+}
+
+function decide(state, command) {
+  switch (command.TAG) {
+    case "RegisterApiFragment" :
+      let at = command.at;
+      let apiTarget = command.apiTarget;
+      let fragment = command.fragment;
+      let pluginId = command.pluginId;
+      if (state === undefined) {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "ApiFragmentRegistered",
+              pluginId: pluginId,
+              fragment: fragment,
+              apiTarget: apiTarget,
+              at: at
+            }]
+        };
+      }
+      let current = state.fragment;
+      if (Primitive_object.equal(current, fragment) && state.apiTarget === apiTarget) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "ApiFragmentUpdated",
+              pluginId: pluginId,
+              previousFragment: current,
+              newFragment: fragment,
+              apiTarget: apiTarget,
+              at: at
+            }]
+        };
+      }
+    case "DeregisterApiFragment" :
+      if (state !== undefined) {
+        return {
+          TAG: "Ok",
+          _0: [{
+              TAG: "ApiFragmentDeregistered",
+              pluginId: command.pluginId
+            }]
+        };
+      } else {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+    case "RecordApiFragmentPush" :
+      if (state === undefined) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      let match = state.lastPush;
+      let at$1 = command.at;
+      let message = command.message;
+      let ok = command.ok;
+      if (match !== undefined && match[0] === ok && match[1] === message && match[2] === at$1) {
+        return {
+          TAG: "Ok",
+          _0: []
+        };
+      }
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "ApiFragmentPushRecorded",
+            pluginId: command.pluginId,
+            ok: ok,
+            message: message,
+            at: at$1
+          }]
+      };
+      break;
+  }
+}
+
+let Spec;
+
+let initialState;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/StateChangeSlice/ApiFragmentRegistry_Behavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */

package/src/admin/ApiFragmentRegistry/StateViewSlice/ApiFragments.res

@@ -0,0 +1,44 @@
+// ApiFragments StateViewSlice — the read side of the platform API-schema fragment
+// registry: the current fragment per plugin name plus the outcome of the last schema
+// push that included it. Replaces the raw `deploy-schema:*` rows as the durable source
+// the single-writer stitch automation and the runtime re-stitcher read, and backs the
+// push-status poll of the deploy waiter.
+//
+// `pushStatus` is "pending" from registration/update until the automation records the
+// push outcome ("ok" / "error"); `pushMessage`/`pushedAt` are "" until then (plain
+// strings, no option fields — see the producer spec).
+@@reventless.spec
+
+@schema
+type state = {
+  pluginId: string,
+  encoded: string,
+  protocol: string,
+  apiTarget: Reventless.Plugin.apiTarget,
+  registeredAt: string,
+  updatedAt: string,
+  pushStatus: string,
+  pushMessage: string,
+  pushedAt: string,
+}
+
+// Consumes the ApiFragmentRegistry slice's events (from the shared admin DcbEventLog).
+// Inline records with the same constructors/fields as the producer's `event` — decodes
+// byte-identically and the ppx auto-tags `pluginId`.
+@schema
+type consumedEvent =
+  | ApiFragmentRegistered({
+      pluginId: string,
+      fragment: Reventless.Plugin.apiSchemaFragment,
+      apiTarget: Reventless.Plugin.apiTarget,
+      at: string,
+    })
+  | ApiFragmentUpdated({
+      pluginId: string,
+      previousFragment: Reventless.Plugin.apiSchemaFragment,
+      newFragment: Reventless.Plugin.apiSchemaFragment,
+      apiTarget: Reventless.Plugin.apiTarget,
+      at: string,
+    })
+  | ApiFragmentDeregistered({pluginId: string})
+  | ApiFragmentPushRecorded({pluginId: string, ok: bool, message: string, at: string})

package/src/admin/ApiFragmentRegistry/StateViewSlice/ApiFragments.res.mjs

@@ -0,0 +1,74 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+
+let stateSchema = S.schema(s => ({
+  pluginId: s.m(S.string),
+  encoded: s.m(S.string),
+  protocol: s.m(S.string),
+  apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+  registeredAt: s.m(S.string),
+  updatedAt: s.m(S.string),
+  pushStatus: s.m(S.string),
+  pushMessage: s.m(S.string),
+  pushedAt: s.m(S.string)
+}));
+
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "ApiFragmentRegistered",
+    pluginId: s.m(DcbTag$Reventless.string),
+    fragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentUpdated",
+    pluginId: s.m(DcbTag$Reventless.string),
+    previousFragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    newFragment: s.m(Plugin$Reventless.apiSchemaFragmentSchema),
+    apiTarget: s.m(Plugin$Reventless.apiTargetSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentDeregistered",
+    pluginId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "ApiFragmentPushRecorded",
+    pluginId: s.m(DcbTag$Reventless.string),
+    ok: s.m(S.bool),
+    message: s.m(S.string),
+    at: s.m(S.string)
+  }))
+]);
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let name = "ApiFragments";
+
+let Id;
+
+let subIdConfig;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/StateViewSlice/ApiFragments.res.mjs";
+
+let authorization = "AllowAuthenticated";
+
+let visibility = "Public";
+
+export {
+  name,
+  Id,
+  stateSchema,
+  consumedEventSchema,
+  config,
+  subIdConfig,
+  moduleUrl,
+  authorization,
+  visibility,
+}
+/* stateSchema Not a pure module */

package/src/admin/ApiFragmentRegistry/StateViewSlice/ApiFragments_Projection.res

@@ -0,0 +1,50 @@
+@@reventless.projection
+
+// A fragment change resets the row to "pending" — the automation's push outcome for the
+// new fragment arrives as a subsequent ApiFragmentPushRecorded. The Update on a deleted
+// row (a push recorded after deregistration) is a no-op by Update semantics.
+let project = event =>
+  switch event {
+  | ApiFragmentRegistered({pluginId, fragment, apiTarget, at}) => [
+      Set(
+        pluginId,
+        {
+          pluginId,
+          encoded: fragment.encoded,
+          protocol: fragment.protocol,
+          apiTarget,
+          registeredAt: at,
+          updatedAt: at,
+          pushStatus: "pending",
+          pushMessage: "",
+          pushedAt: "",
+        },
+      ),
+    ]
+  | ApiFragmentUpdated({pluginId, newFragment, apiTarget, at}) => [
+      Update(
+        pluginId,
+        state => {
+          ...state,
+          encoded: newFragment.encoded,
+          protocol: newFragment.protocol,
+          apiTarget,
+          updatedAt: at,
+          pushStatus: "pending",
+          pushMessage: "",
+        },
+      ),
+    ]
+  | ApiFragmentDeregistered({pluginId}) => [Delete(pluginId)]
+  | ApiFragmentPushRecorded({pluginId, ok, message, at}) => [
+      Update(
+        pluginId,
+        state => {
+          ...state,
+          pushStatus: ok ? "ok" : "error",
+          pushMessage: message,
+          pushedAt: at,
+        },
+      ),
+    ]
+  }

package/src/admin/ApiFragmentRegistry/StateViewSlice/ApiFragments_Projection.res.mjs

@@ -0,0 +1,80 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function project(event) {
+  switch (event.TAG) {
+    case "ApiFragmentRegistered" :
+      let at = event.at;
+      let fragment = event.fragment;
+      let pluginId = event.pluginId;
+      return [{
+          TAG: "Set",
+          _0: pluginId,
+          _1: {
+            pluginId: pluginId,
+            encoded: fragment.encoded,
+            protocol: fragment.protocol,
+            apiTarget: event.apiTarget,
+            registeredAt: at,
+            updatedAt: at,
+            pushStatus: "pending",
+            pushMessage: "",
+            pushedAt: ""
+          }
+        }];
+    case "ApiFragmentUpdated" :
+      let at$1 = event.at;
+      let apiTarget = event.apiTarget;
+      let newFragment = event.newFragment;
+      return [{
+          TAG: "Update",
+          _0: event.pluginId,
+          _1: state => ({
+            pluginId: state.pluginId,
+            encoded: newFragment.encoded,
+            protocol: newFragment.protocol,
+            apiTarget: apiTarget,
+            registeredAt: state.registeredAt,
+            updatedAt: at$1,
+            pushStatus: "pending",
+            pushMessage: "",
+            pushedAt: state.pushedAt
+          })
+        }];
+    case "ApiFragmentDeregistered" :
+      return [{
+          TAG: "Delete",
+          _0: event.pluginId
+        }];
+    case "ApiFragmentPushRecorded" :
+      let at$2 = event.at;
+      let message = event.message;
+      let ok = event.ok;
+      return [{
+          TAG: "Update",
+          _0: event.pluginId,
+          _1: state => ({
+            pluginId: state.pluginId,
+            encoded: state.encoded,
+            protocol: state.protocol,
+            apiTarget: state.apiTarget,
+            registeredAt: state.registeredAt,
+            updatedAt: state.updatedAt,
+            pushStatus: ok ? "ok" : "error",
+            pushMessage: message,
+            pushedAt: at$2
+          })
+        }];
+  }
+}
+
+let Spec;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/ApiFragmentRegistry/StateViewSlice/ApiFragments_Projection.res.mjs";
+
+export {
+  Spec,
+  project,
+  moduleUrl,
+}
+/* No side effect */

package/src/admin/Platform_Admin.res

@@ -77,7 +77,6 @@ module Make = (
           extensionProtocols: [],
           apiSchemaFragment: None,
           apiTarget: None,
-          uiFragments: None,
           structure: None,
           dcbEventLog: None,
           kind: Domain,
@@ -141,6 +140,17 @@ module Make = (
     let dcbResult = DcbBuilder.construct(
       ~name,
       ~childName=name,
+      // Admin slice command mutations render `Platform_*` (not `Admin_*`), byte-aligned with the
+      // hand-declared admin SDL (`AdminApi.baseFragment`, via `Api_Naming.adminField`) so the
+      // auto-bound DCB resolver targets the exact field name that is pushed to the schema.
+      ~apiNamePrefix="Platform",
+      // The API-schema registry's Register/Deregister mutations are invoked by the plugin/standalone
+      // deploy as a SigV4 system caller — mark them systemCallable so the AWS provider stamps the
+      // dual-auth (`@aws_cognito_user_pools @aws_iam`) directive on the constructed fragment entries.
+      ~systemCallableComponents=["ApiFragmentRegistry"],
+      // Admin DCB mutation resolvers bind to the Platform API (split mode), not the deploy-target
+      // Domain API — routes the provider hook to `hooks.adminApi`.
+      ~onAdminApi=true,
       ~aggregateEventTopics,
       ~stateChangeSlices,
       ~stateViewSlices,
@@ -150,6 +160,19 @@ module Make = (
       ~opts,
     )
 
+    // Register admin DCB StateChangeSlice publish functions in publishToAggregates so an
+    // ExtensionPointMapping whose Delegate is an admin slice (e.g. the UI-fragment mapping →
+    // UiFragmentRegistry) can dispatch commands to it. Mirrors Plugin_Builder's merge; admin
+    // slices share the single admin DCB command topic (same publishJsons). Absent when no
+    // StateChangeSlice was passed (dcbPublishJsons = None) — the historical empty-slice case.
+    switch dcbResult.dcbPublishJsons {
+    | Some(slicePublishJsons) =>
+      stateChangeSlices->Array.forEach((module(Sc: ReventlessInfra.StateChangeSlice.T)) =>
+        publishToAggregates->Dict.set(Sc.Spec.name, slicePublishJsons)
+      )
+    | None => ()
+    }
+
     // Admin schema — composed from actual config. `AdminApi.mutationEntries`
     // already includes the auto-derived `Platform_Plugin_Activate`/`Deactivate`
     // entries (via `PluginBaseFragment.pluginAggregateMutationEntries`) so the
@@ -348,6 +371,19 @@ module Make = (
 
         let aggregatesOutputs = addEventMappers(allEventTopics, queryEngine)
         let eventTopics = aggregatesOutputs->Aggregate.filterEventTopics(aggregateNames)
+        // 2e: also subscribe the admin EventCollector to the admin DcbEventLog's
+        // event topic (a DynamoDB stream on AWS) so the reactive ApiFragmentRegistry
+        // single writer receives ApiFragment* events. The EventCollector channel
+        // already provisions the stream subscription + read IAM for stream-backed
+        // event-topic resources. Copy the filtered dict so the shared aggregate
+        // outputs stay untouched.
+        let eventTopics = switch dcbResult.dcbEventLogOutputs {
+        | Some(dcbOutputs) =>
+          let augmented = eventTopics->Dict.copy
+          augmented->Dict.set(name ++ "DcbEventLog", dcbOutputs.eventTopic)
+          augmented
+        | None => eventTopics
+        }
 
         module EventCollectorHelper = MakeEventCollectorHelper(
           RuntimeEnvironment,

package/src/admin/Platform_Admin.res.mjs

@@ -44,7 +44,6 @@ function Make(RuntimeEnvironment) {
             extensionProtocols: [],
             apiSchemaFragment: undefined,
             apiTarget: undefined,
-            uiFragments: undefined,
             structure: undefined,
             dcbEventLog: undefined,
             kind: "Domain"
@@ -72,7 +71,13 @@ function Make(RuntimeEnvironment) {
       let aggregatesWithoutEventMappers = Builder_Helpers$ReventlessCore.createAggregatesWithoutEventMappers(aggregates, api, opts);
       let aggregateEventTopics = Aggregate$ReventlessCore.allEventTopics(aggregatesWithoutEventMappers);
       Plugin_Helpers$ReventlessCore.registerAdminAggregateMutations(aggregates, Config.hooks);
-      let dcbResult = DcbBuilder.construct(name, name, undefined, undefined, aggregateEventTopics, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, undefined, undefined, opts);
+      let dcbResult = DcbBuilder.construct(name, name, "Platform", true, undefined, undefined, aggregateEventTopics, stateChangeSlices, stateViewSlices, automationSlices, outboundTranslationSlices, inboundTranslationSlices, ["ApiFragmentRegistry"], undefined, opts);
+      let slicePublishJsons = dcbResult.dcbPublishJsons;
+      if (slicePublishJsons !== undefined) {
+        stateChangeSlices.forEach(Sc => {
+          Builder_Helpers$ReventlessCore.publishToAggregates[Sc.Spec.name] = slicePublishJsons;
+        });
+      }
       let adminMutationEntries = AdminApi$ReventlessCore.mutationEntries(Config.cloner);
       let allMutationEntries = adminMutationEntries.concat(dcbResult.mutationEntries);
       let allQueryEntries = AdminApi$ReventlessCore.queryEntries.concat(dcbResult.queryEntries);
@@ -164,6 +169,15 @@ function Make(RuntimeEnvironment) {
         let aggregateNames = Stdlib_Array.reduce(extensionPointsOutputs.map(extensionPointOutputs => Belt_SetString.fromArray(extensionPointOutputs.aggregateNames)), undefined, Belt_SetString.union);
         let aggregatesOutputs = Builder_Helpers$ReventlessCore.addEventMappers(aggregateEventTopics, queryEngine);
         let eventTopics = Aggregate$ReventlessCore.filterEventTopics(aggregatesOutputs, aggregateNames);
+        let dcbOutputs = dcbResult.dcbEventLogOutputs;
+        let eventTopics$1;
+        if (dcbOutputs !== undefined) {
+          let augmented = Object.assign({}, eventTopics);
+          augmented[name + "DcbEventLog"] = dcbOutputs.eventTopic;
+          eventTopics$1 = augmented;
+        } else {
+          eventTopics$1 = eventTopics;
+        }
         let AdminEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
         let make = (name, eventTopics, opts) => {
           let eventCollector = AdminEventCollector.make(name, eventTopics, opts);
@@ -186,7 +200,6 @@ function Make(RuntimeEnvironment) {
               extensionProtocols: [],
               apiSchemaFragment: undefined,
               apiTarget: undefined,
-              uiFragments: undefined,
               structure: undefined,
               dcbEventLog: undefined,
               kind: "Domain"
@@ -199,9 +212,9 @@ function Make(RuntimeEnvironment) {
             AdminRuntimeBuilder.forPluginEventCollector(handler, eventTopics, resources, undefined, undefined, eventCollector);
           });
         };
-        let match$1 = make(name, eventTopics, opts);
+        let match$1 = make(name, eventTopics$1, opts);
         let eventCollector = match$1[0];
-        Output$Pulumi.flatMap(Pulumi.all(match[1]), extensionPointsOutgoingJsonEventsHandlers => connect(eventCollector, eventTopics, extensionPointsOutputs, extensionPointsOutgoingJsonEventsHandlers));
+        Output$Pulumi.flatMap(Pulumi.all(match[1]), extensionPointsOutgoingJsonEventsHandlers => connect(eventCollector, eventTopics$1, extensionPointsOutputs, extensionPointsOutgoingJsonEventsHandlers));
         Stdlib_Option.forEach(dcbResult.dcbRuntimeSetup, dcbRuntimeSetup => dcbRuntimeSetup());
         return extensionPointsOutputs;
       });

package/src/admin/Platform_ApiFragmentsApi.res

@@ -0,0 +1,32 @@
+// SDL type and JSON encoder for the Platform_ApiFragments GraphQL query — the
+// deploy-facing status surface of the API-schema fragment registry. Shared
+// between the in-memory adapter (which resolves from the in-process ApiFragments
+// StateViewSlice QueryDb) and the AWS adapter (which scans the ApiFragments
+// DynamoDB table), so the wire shape is byte-identical and one client query
+// string works against either.
+//
+// The deploy waiter polls this to confirm its plugin's fragment reached ACTIVE
+// (pushStatus "ok") or to surface a stitch error (pushStatus "error" +
+// pushMessage). It exposes status only — NOT the encoded SDL, which the waiter
+// does not need.
+
+let sdlTypes: array<string> = [
+  `type Platform_ApiFragmentEntry {\n  pluginId: String!\n  apiTarget: String!\n  pushStatus: String!\n  pushMessage: String!\n  pushedAt: String!\n  registeredAt: String!\n  updatedAt: String!\n}`,
+]
+
+let queryFieldName: string = "Platform_ApiFragments"
+
+let sdlQueryField: string = `  ${queryFieldName}: [Platform_ApiFragmentEntry!]!`
+
+let encodeApiFragmentEntry = (entry: ApiFragments.state): JSON.t =>
+  Dict.fromArray([
+    ("pluginId", JSON.Encode.string(Plugin.name(entry.pluginId))),
+    // apiTarget is a payload-less variant — its schema serializes to the bare
+    // JSON string "Domain" / "Platform".
+    ("apiTarget", entry.apiTarget->S.reverseConvertToJsonOrThrow(Reventless.Plugin.apiTargetSchema)),
+    ("pushStatus", JSON.Encode.string(entry.pushStatus)),
+    ("pushMessage", JSON.Encode.string(entry.pushMessage)),
+    ("pushedAt", JSON.Encode.string(entry.pushedAt)),
+    ("registeredAt", JSON.Encode.string(entry.registeredAt)),
+    ("updatedAt", JSON.Encode.string(entry.updatedAt)),
+  ])->JSON.Encode.object