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

package/src/admin/Platform_ApiFragmentsApi.res.mjs

@@ -0,0 +1,52 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Plugin$ReventlessCore from "../plugin/component/Plugin.res.mjs";
+
+let sdlTypes = [`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 = "Platform_ApiFragments";
+
+let sdlQueryField = `  ` + queryFieldName + `: [Platform_ApiFragmentEntry!]!`;
+
+function encodeApiFragmentEntry(entry) {
+  return Object.fromEntries([
+    [
+      "pluginId",
+      Plugin$ReventlessCore.name(entry.pluginId)
+    ],
+    [
+      "apiTarget",
+      S.reverseConvertToJsonOrThrow(entry.apiTarget, Plugin$Reventless.apiTargetSchema)
+    ],
+    [
+      "pushStatus",
+      entry.pushStatus
+    ],
+    [
+      "pushMessage",
+      entry.pushMessage
+    ],
+    [
+      "pushedAt",
+      entry.pushedAt
+    ],
+    [
+      "registeredAt",
+      entry.registeredAt
+    ],
+    [
+      "updatedAt",
+      entry.updatedAt
+    ]
+  ]);
+}
+
+export {
+  sdlTypes,
+  queryFieldName,
+  sdlQueryField,
+  encodeApiFragmentEntry,
+}
+/* S Not a pure module */

package/src/admin/Platform_UIFragmentsApi.res

@@ -44,7 +44,7 @@ let encodePage = (p: pageManifestEntry): JSON.t =>
     ("requiredAccess", p.requiredAccess->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
   ])->JSON.Encode.object
 
-let encodeUIFragmentEntry = (entry: UIFragmentRegistryReadModelSpec.state): JSON.t =>
+let encodeUIFragmentEntry = (entry: UiFragments.state): JSON.t =>
   Dict.fromArray([
     ("pluginId", JSON.Encode.string(Plugin.name(entry.pluginId))),
     ("remoteEntryUrl", JSON.Encode.string(entry.remoteEntryUrl)),

package/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res

@@ -0,0 +1,50 @@
+// UiFragmentRegistry StateChangeSlice — the write side of the platform UI-fragment
+// registry, extracted off the Plugin aggregate (see
+// docs/plans/event-sourced-fragment-registries.md).
+//
+// Commands are driven by the plugin runtime's connect handshake and routed here by the
+// admin PluginExtensionPoint's UI-fragment mapping (RegisterUiFragment on ConnectPlugin,
+// DeregisterUiFragment on DisconnectPlugin — the disconnect schedule sends DisconnectPlugin
+// on heartbeat timeout too, so timeout deregistration flows through the same path).
+//
+// Keyed by plugin NAME (the `pluginId` tag carries the bare name), so a single row tracks
+// the current manifest across version supersession. The registry is idempotent: re-sending
+// an identical manifest is a no-op, deregistering an absent fragment is a no-op — it never
+// rejects a command.
+@@reventless.spec
+
+open Reventless.Plugin
+
+// `at` is the registration timestamp, stamped from the incoming command meta by the EP mapping
+// — the StateViewSlice projection has no event meta, so time must ride the payload. Inline
+// records let the ppx auto-tag `pluginId` (scoping the decision read to one plugin name).
+//
+// Whole-command `@noApi`: this registry has NO GraphQL surface — commands are driven by the
+// plugin runtime's connect/disconnect handshake and routed here by the admin
+// PluginExtensionPoint mapping (AWS) / direct admin-DCB dispatch (local), never by a mutation.
+// Without this marker the DCB builder would emit orphaned `Platform_RegisterUiFragment`
+// resolvers against a schema that never declares those fields.
+@noApi @schema
+type command =
+  | RegisterUiFragment({pluginId: string, manifest: uiFragmentManifest, at: string})
+  | DeregisterUiFragment({pluginId: string})
+
+// The registry never rejects (idempotent register/deregister); this variant is never returned.
+@schema
+type error = | RegistryError
+
+@schema
+type event =
+  | UiFragmentRegistered({pluginId: string, manifest: uiFragmentManifest, at: string})
+  | UiFragmentUpdated({
+      pluginId: string,
+      previousManifest: uiFragmentManifest,
+      newManifest: uiFragmentManifest,
+      at: string,
+    })
+  | UiFragmentDeregistered({pluginId: string})
+
+// This slice reads exactly the events it writes, so consumedEvent IS event — one inline event
+// type, no duplicate-constructor collision, ppx auto-tags `pluginId` on both roles.
+@schema
+type consumedEvent = event

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

@@ -0,0 +1,70 @@
+// 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: "RegisterUiFragment",
+    pluginId: s.m(DcbTag$Reventless.string),
+    manifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "DeregisterUiFragment",
+    pluginId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let errorSchema = S.literal("RegistryError");
+
+let eventSchema = S.union([
+  S.schema(s => ({
+    TAG: "UiFragmentRegistered",
+    pluginId: s.m(DcbTag$Reventless.string),
+    manifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "UiFragmentUpdated",
+    pluginId: s.m(DcbTag$Reventless.string),
+    previousManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    newManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "UiFragmentDeregistered",
+    pluginId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let commandSchema$1 = Api$ReventlessInfra.markNoApi(commandSchema);
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let name = "UiFragmentRegistry";
+
+let Id;
+
+let consumedEventSchema = eventSchema;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.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/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry_Behavior.res

@@ -0,0 +1,33 @@
+@@reventless.behavior
+
+open Reventless.Plugin
+
+// The current manifest for this plugin name, or None when no fragment is registered.
+type state = option<uiFragmentManifest>
+
+let initialState = None
+
+let evolve = (_state, event) =>
+  switch event {
+  | UiFragmentRegistered({manifest}) => Some(manifest)
+  | UiFragmentUpdated({newManifest}) => Some(newManifest)
+  | UiFragmentDeregistered(_) => None
+  }
+
+let decide = (state, command) =>
+  switch command {
+  | RegisterUiFragment({pluginId, manifest, at}) =>
+    switch state {
+    | None => Ok([UiFragmentRegistered({pluginId, manifest, at})])
+    // Idempotent: an unchanged re-registration (e.g. a redeploy carrying the same
+    // manifest, or a reconnect) emits nothing.
+    | Some(current) if current == manifest => Ok([])
+    | Some(current) =>
+      Ok([UiFragmentUpdated({pluginId, previousManifest: current, newManifest: manifest, at})])
+    }
+  | DeregisterUiFragment({pluginId}) =>
+    switch state {
+    | None => Ok([]) // idempotent — nothing registered
+    | Some(_) => Ok([UiFragmentDeregistered({pluginId: pluginId})])
+    }
+  }

package/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry_Behavior.res.mjs

@@ -0,0 +1,80 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function evolve(_state, event) {
+  switch (event.TAG) {
+    case "UiFragmentRegistered" :
+      return event.manifest;
+    case "UiFragmentUpdated" :
+      return event.newManifest;
+    case "UiFragmentDeregistered" :
+      return;
+  }
+}
+
+function decide(state, command) {
+  if (command.TAG !== "RegisterUiFragment") {
+    if (state !== undefined) {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "UiFragmentDeregistered",
+            pluginId: command.pluginId
+          }]
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    }
+  }
+  let at = command.at;
+  let manifest = command.manifest;
+  let pluginId = command.pluginId;
+  if (state !== undefined) {
+    if (Primitive_object.equal(state, manifest)) {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "UiFragmentUpdated",
+            pluginId: pluginId,
+            previousManifest: state,
+            newManifest: manifest,
+            at: at
+          }]
+      };
+    }
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "UiFragmentRegistered",
+          pluginId: pluginId,
+          manifest: manifest,
+          at: at
+        }]
+    };
+  }
+}
+
+let Spec;
+
+let initialState;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry_Behavior.res.mjs";
+
+export {
+  Spec,
+  initialState,
+  evolve,
+  decide,
+  moduleUrl,
+}
+/* No side effect */

package/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments.res

@@ -0,0 +1,33 @@
+// UiFragments StateViewSlice — the read side of the platform UI-fragment registry,
+// replacing UIFragmentRegistryReadModelSpec + UIFragmentRegistryProjection. Projects the
+// UiFragmentRegistry slice's events (from the shared admin DcbEventLog) into the
+// manifest-per-plugin table that backs the Platform_UIFragments query. The wire shape is
+// owned by Platform_UIFragmentsApi.res (SDL + encoder), pinned by the golden test
+// Platform_UIFragmentsApiTest.res — `state` here matches that encoder byte-for-byte.
+@@reventless.spec
+
+open Reventless.Plugin
+
+@schema
+type state = {
+  pluginId: string,
+  remoteEntryUrl: string,
+  panels: array<panelManifestEntry>,
+  pages: array<pageManifestEntry>,
+  registeredAt: string,
+  updatedAt: string,
+}
+
+// Consumes the UiFragmentRegistry 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 =
+  | UiFragmentRegistered({pluginId: string, manifest: uiFragmentManifest, at: string})
+  | UiFragmentUpdated({
+      pluginId: string,
+      previousManifest: uiFragmentManifest,
+      newManifest: uiFragmentManifest,
+      at: string,
+    })
+  | UiFragmentDeregistered({pluginId: string})

package/src/admin/{UIFragmentRegistryReadModelSpec.res.mjs → UiFragmentRegistry/StateViewSlice/UiFragments.res.mjs}

@@ -1,6 +1,7 @@
 // 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";
 
@@ -13,15 +14,35 @@ let stateSchema = S.schema(s => ({
   updatedAt: s.m(S.string)
 }));
 
+let consumedEventSchema = S.union([
+  S.schema(s => ({
+    TAG: "UiFragmentRegistered",
+    pluginId: s.m(DcbTag$Reventless.string),
+    manifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "UiFragmentUpdated",
+    pluginId: s.m(DcbTag$Reventless.string),
+    previousManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    newManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
+    at: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "UiFragmentDeregistered",
+    pluginId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
 let config = ReadModel$Reventless.config(undefined, undefined, undefined);
 
-let name = "UIFragmentRegistry";
+let name = "UiFragments";
 
 let Id;
 
 let subIdConfig;
 
-let moduleUrl = "@reventlessdev/reventless-core/src/admin/UIFragmentRegistryReadModelSpec.res.mjs";
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments.res.mjs";
 
 let authorization = "AllowAuthenticated";
 
@@ -31,6 +52,7 @@ export {
   name,
   Id,
   stateSchema,
+  consumedEventSchema,
   config,
   subIdConfig,
   moduleUrl,

package/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res

@@ -0,0 +1,34 @@
+@@reventless.projection
+
+// No `open Reventless.Plugin`: it would shadow the state labels (panels/pages/...) brought in
+// by the projection's spec open. `manifest.<field>` resolves type-directed from the event's
+// uiFragmentManifest payload.
+let project = event =>
+  switch event {
+  | UiFragmentRegistered({pluginId, manifest, at}) => [
+      Set(
+        pluginId,
+        {
+          pluginId,
+          remoteEntryUrl: manifest.remoteEntryUrl,
+          panels: manifest.panels,
+          pages: manifest.pages,
+          registeredAt: at,
+          updatedAt: at,
+        },
+      ),
+    ]
+  | UiFragmentUpdated({pluginId, newManifest, at}) => [
+      Update(
+        pluginId,
+        state => {
+          ...state,
+          remoteEntryUrl: newManifest.remoteEntryUrl,
+          panels: newManifest.panels,
+          pages: newManifest.pages,
+          updatedAt: at,
+        },
+      ),
+    ]
+  | UiFragmentDeregistered({pluginId}) => [Delete(pluginId)]
+  }

package/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res.mjs

@@ -0,0 +1,54 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function project(event) {
+  switch (event.TAG) {
+    case "UiFragmentRegistered" :
+      let at = event.at;
+      let manifest = event.manifest;
+      let pluginId = event.pluginId;
+      return [{
+          TAG: "Set",
+          _0: pluginId,
+          _1: {
+            pluginId: pluginId,
+            remoteEntryUrl: manifest.remoteEntryUrl,
+            panels: manifest.panels,
+            pages: manifest.pages,
+            registeredAt: at,
+            updatedAt: at
+          }
+        }];
+    case "UiFragmentUpdated" :
+      let at$1 = event.at;
+      let newManifest = event.newManifest;
+      return [{
+          TAG: "Update",
+          _0: event.pluginId,
+          _1: state => ({
+            pluginId: state.pluginId,
+            remoteEntryUrl: newManifest.remoteEntryUrl,
+            panels: newManifest.panels,
+            pages: newManifest.pages,
+            registeredAt: state.registeredAt,
+            updatedAt: at$1
+          })
+        }];
+    case "UiFragmentDeregistered" :
+      return [{
+          TAG: "Delete",
+          _0: event.pluginId
+        }];
+  }
+}
+
+let Spec;
+
+let moduleUrl = "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments_Projection.res.mjs";
+
+export {
+  Spec,
+  project,
+  moduleUrl,
+}
+/* No side effect */

package/src/components/Api/Api_Naming.res

@@ -49,7 +49,7 @@ let sliceMutationField = (~plugin: string, ~slice: string) => `${plugin}_${slice
 let dcbCommandMutationField = (~plugin: string, ~command: string) => `${plugin}_${command}`
 
 // AppSync hard limit: subscription field names may be at most 50 chars. Each mutation
-// field `f` produces a `@aws_subscribe` subscription `on${f}` (see
+// field `f` produces a mutation-sourced subscription `on${f}` (see
 // Plugin_SubscriptionSchema.sourceCFields), so the real cap on a mutation field is 48.
 // Fail at build with an actionable message rather than letting AppSync reject the
 // schema push at deploy time with an opaque 500.

package/src/components/Api/GraphQL_FragmentGenerator.res

@@ -598,15 +598,11 @@ let generate = (
     commandResultSdlTypes->Array.forEach(t => types->Array.push(t))
   }
 
-  let encoded =
-    JSON.Encode.object(
-      Dict.fromArray([
-        ("types", JSON.Encode.array(types->Array.map(JSON.Encode.string))),
-        ("mutations", JSON.Encode.array(mutations->Array.map(JSON.Encode.string))),
-        ("queries", JSON.Encode.array(queries->Array.map(JSON.Encode.string))),
-        ("subscriptions", JSON.Encode.array([])),
-      ]),
-    )->JSON.stringify
-
-  {Reventless.Plugin.encoded, protocol: "graphql"}
+  GraphQL_Stitcher.encode({
+    types,
+    mutations,
+    queries,
+    subscriptions: [],
+    subscriptionSources: [],
+  })
 }

package/src/components/Api/GraphQL_FragmentGenerator.res.mjs

@@ -5,6 +5,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as SchemaType$ReventlessCore from "./SchemaType.res.mjs";
 import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src/components/StateAnnotations.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "./GraphQL_Stitcher.res.mjs";
 
 let commandResultSdlTypes = [
   `union CommandResult = CommandAccepted | CommandRejected | CommandPending`,
@@ -453,28 +454,13 @@ function generate(mutationEntries, queryEntries) {
       types.push(t);
     });
   }
-  let encoded = JSON.stringify(Object.fromEntries([
-    [
-      "types",
-      types.map(prim => prim)
-    ],
-    [
-      "mutations",
-      mutations.map(prim => prim)
-    ],
-    [
-      "queries",
-      queries.map(prim => prim)
-    ],
-    [
-      "subscriptions",
-      []
-    ]
-  ]));
-  return {
-    encoded: encoded,
-    protocol: "graphql"
-  };
+  return GraphQL_Stitcher$ReventlessCore.encode({
+    types: types,
+    mutations: mutations,
+    queries: queries,
+    subscriptions: [],
+    subscriptionSources: []
+  });
 }
 
 export {

package/src/components/Api/GraphQL_PushPlanner.res

@@ -0,0 +1,65 @@
+// Generic, provider-neutral push planner for the event-sourced API-schema fragment registry.
+//
+// Given the fragments currently in the ApiFragmentRegistry (each tagged with the API it belongs to)
+// it groups them by target and produces one stitched-SDL push plan per API, honouring split vs.
+// unified mode. It encodes the SAME base-selection rules the deploy-time push
+// (`reventless-aws Platform.preResolversSchemaHook`) applies, so the reactive single writer stays
+// consistent with the deploy path:
+//   - split mode: the Platform API carries the admin base + Platform-target fragments; the Domain
+//     API carries an EMPTY base + Domain-target fragments (admin lives only on the Platform API).
+//   - unified mode: a single API carries the admin base + ALL fragments regardless of target.
+//
+// Neutral SDL only — the AWS adapter injects @aws_subscribe per plan and pushes each to the
+// matching AppSync API id; the local platform (scope 2) will consume the same plans in-process.
+
+open Reventless.Plugin
+
+type targetedFragment = {
+  fragment: apiSchemaFragment,
+  target: apiTarget,
+}
+
+// The destination API of a push plan. In unified mode every fragment collapses onto `DomainApi`
+// (the single shared API); the AWS adapter maps `PlatformApi` → the Platform AppSync id and
+// `DomainApi` → the Domain AppSync id.
+@schema
+type planTarget = DomainApi | PlatformApi
+
+type pushPlan = {
+  api: planTarget,
+  // Stitched neutral SDL for that API (admin/empty base + the target's fragments).
+  sdl: string,
+}
+
+// An empty base fragment — the Domain API's base in split mode (admin is on the Platform API).
+let emptyBase: apiSchemaFragment = GraphQL_Stitcher.encode({
+  types: [],
+  queries: [],
+  mutations: [],
+  subscriptions: [],
+  subscriptionSources: [],
+})
+
+let planPushes = (
+  ~adminBase: apiSchemaFragment,
+  ~fragments: array<targetedFragment>,
+  ~splitApi: bool,
+): array<pushPlan> =>
+  if splitApi {
+    let platformFrags =
+      fragments->Array.filter(f => f.target == Platform)->Array.map(f => f.fragment)
+    let domainFrags = fragments->Array.filter(f => f.target == Domain)->Array.map(f => f.fragment)
+    [
+      {
+        api: PlatformApi,
+        sdl: GraphQL_Stitcher.stitch(~baseFragment=adminBase, ~pluginFragments=platformFrags),
+      },
+      {
+        api: DomainApi,
+        sdl: GraphQL_Stitcher.stitch(~baseFragment=emptyBase, ~pluginFragments=domainFrags),
+      },
+    ]
+  } else {
+    let allFrags = fragments->Array.map(f => f.fragment)
+    [{api: DomainApi, sdl: GraphQL_Stitcher.stitch(~baseFragment=adminBase, ~pluginFragments=allFrags)}]
+  }

package/src/components/Api/GraphQL_PushPlanner.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as GraphQL_Stitcher$ReventlessCore from "./GraphQL_Stitcher.res.mjs";
+
+let planTargetSchema = S.union([
+  S.literal("DomainApi"),
+  S.literal("PlatformApi")
+]);
+
+let emptyBase = GraphQL_Stitcher$ReventlessCore.encode({
+  types: [],
+  mutations: [],
+  queries: [],
+  subscriptions: [],
+  subscriptionSources: []
+});
+
+function planPushes(adminBase, fragments, splitApi) {
+  if (splitApi) {
+    let platformFrags = fragments.filter(f => f.target === "Platform").map(f => f.fragment);
+    let domainFrags = fragments.filter(f => f.target === "Domain").map(f => f.fragment);
+    return [
+      {
+        api: "PlatformApi",
+        sdl: GraphQL_Stitcher$ReventlessCore.stitch(adminBase, platformFrags)
+      },
+      {
+        api: "DomainApi",
+        sdl: GraphQL_Stitcher$ReventlessCore.stitch(emptyBase, domainFrags)
+      }
+    ];
+  }
+  let allFrags = fragments.map(f => f.fragment);
+  return [{
+      api: "DomainApi",
+      sdl: GraphQL_Stitcher$ReventlessCore.stitch(adminBase, allFrags)
+    }];
+}
+
+export {
+  planTargetSchema,
+  emptyBase,
+  planPushes,
+}
+/* planTargetSchema Not a pure module */