@reventlessdev/reventless-core 3.0.0-alpha.165 → 3.0.0-alpha.167

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.167 (2026-07-14)
+
+**Note:** Version bump only for package @reventlessdev/reventless-core
+
+
+
+
+
+# 3.0.0-alpha.166 (2026-07-14)
+
+### Features
+
+* **api:** merge-path codegen — stitchStandalone subgraph SDL + [@canonical](https://github.com/canonical) stamping (Phase 2) ([02ae93b](https://github.com/ReventlessDev/reventless-core/commit/02ae93b1c84a116ae47fb656cab17858a5df2c97))
+
+
 # 3.0.0-alpha.165 (2026-07-13)
 
 **Note:** Version bump only for package @reventlessdev/reventless-core

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.165",
+  "version": "3.0.0-alpha.167",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.12",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.27",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.11",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
     "@reventlessdev/rescript-node-streams": "1.1.0-alpha.11",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.15",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.7",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.12",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.15",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.15",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.98",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.76",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.26"
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.26",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.99",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.76"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/src/admin/AdminApi.res

@@ -9,46 +9,14 @@ let cloneMutationEntry: mutationSchemaEntry = {
   description: "Clone the system to a specific point in time",
 }
 
-// ApiFragmentRegistry admin mutations — the real GraphQL surface of the ApiFragmentRegistry
-// singleton aggregate: the plugin / standalone-service deploy calls
-// `Platform_ApiFragmentRegistry_RegisterApiFragment` / `..._DeregisterApiFragment` as a SigV4
-// system caller. Derived from the aggregate's `commandSchema` exactly like the Plugin aggregate's
-// entries (`PluginBaseFragment.pluginAggregateMutationEntries`) — one `Platform_<Spec>_<Command>`
-// field per non-`@noApi` variant (`RecordApiFragmentPush` is `@noApi`, filtered out). The matching
-// resolver wiring is fired by `Plugin_Helpers.registerAdminAggregateMutations` over the same
-// `~aggregates` list in `Platform_Admin.construct`, so the SDL field and the auto-bound resolver
-// carry byte-identical names.
-let apiFragmentRegistryMutationEntries: array<mutationSchemaEntry> = {
-  let commandSchema = ApiFragmentRegistrySpec.commandSchema->S.castToUnknown
-  let constructorNames = Reventless.DcbTag.extractAllVariantNames(ApiFragmentRegistrySpec.commandSchema)
-  let filteredConstructorNames = ApiNoApiHelpers.filterNoApiVariants(constructorNames, commandSchema)
-  let fieldNames =
-    filteredConstructorNames->Array.map(cname =>
-      Api_Naming.adminField(~name=ApiFragmentRegistrySpec.name ++ "_" ++ cname)
-    )
-  if fieldNames->Array.length === 0 {
-    []
-  } else {
-    [
-      {
-        ReventlessInfra.Api.fieldNames,
-        commandSchema,
-      },
-    ]
-  }
-}
-
 // Aggregate-derived admin mutations come from `PluginBaseFragment.pluginAggregateMutationEntries`
-// (Plugin aggregate) + `apiFragmentRegistryMutationEntries` (ApiFragmentRegistry aggregate) so they
-// end up in the stitched SDL AND in the static `baseFragment` the AWS path pushes directly. The
-// corresponding resolver wiring is fired in parallel by
-// `Plugin_Helpers.registerAdminAggregateMutations` from `Platform_Admin.construct` over the same
-// `~aggregates` list.
+// (Plugin aggregate) so they end up in the admin base document. The corresponding resolver wiring
+// is fired in parallel by `Plugin_Helpers.registerAdminAggregateMutations` from
+// `Platform_Admin.construct` over the same `~aggregates` list.
+// (The ApiFragmentRegistry aggregate's entries were retired with the merged-API cutover —
+// schema composition is push-free, so no deploy-time register/deregister surface exists.)
 let mutationEntries = (~cloner: bool) => {
-  let base = Array.concat(
-    PluginBaseFragment.pluginAggregateMutationEntries,
-    apiFragmentRegistryMutationEntries,
-  )
+  let base = PluginBaseFragment.pluginAggregateMutationEntries
   if cloner {
     Array.concat(base, [cloneMutationEntry])
   } else {
@@ -58,17 +26,6 @@ let mutationEntries = (~cloner: bool) => {
 
 let queryEntries = PluginBaseFragment.queryEntries
 
-// Admin fields a deploy-time system caller (machine credentials — SigV4/IAM on AWS) invokes: the
-// two ApiFragmentRegistry mutations (the deploy's register/deregister write path) and
-// `Platform_ApiFragments` (the deploy waiter's push-status poll). Provider-neutral by design — the
-// AWS adapter threads these into `injectAwsAuthAll`'s `~iamFieldNames` so only these fields carry
-// the dual-auth (`@aws_cognito_user_pools @aws_iam`) directive; every other admin field stays
-// Cognito-only. Derived from the same mutation entries so the names never drift from the SDL.
-let systemCallerFieldNames =
-  apiFragmentRegistryMutationEntries
-  ->Array.flatMap(e => e.fieldNames)
-  ->Array.concat([Platform_ApiFragmentsApi.queryFieldName])
-
 // UIFragment lifecycle Source C subscriptions.
 // Mutations are called by the backend when UIFragment events occur; the
 // subscription→mutation fan-in is carried as neutral `subscriptionSource`
@@ -132,35 +89,25 @@ let baseFragment = (~cloner: bool) => {
   // matching SDL fields, AppSync's CreateResolver fails with "Type not found".
   let (pluginAggregateSubscriptionFields, pluginAggregateSubscriptionSources) =
     Plugin_SubscriptionSchema.sourceCFields(~mutationEntries=PluginBaseFragment.pluginAggregateMutationEntries)
-  // The ApiFragmentRegistry aggregate's mutations go through the same CommandGenerator
-  // auto-flow, which creates an `on<field>` subscription resolver per mutation. On the
-  // static-push platform (AWS) those resolvers orphan unless the fields are declared in the
-  // pushed baseFragment — so generate them here too, symmetric with the Plugin aggregate.
-  let (apiFragmentAggregateSubscriptionFields, apiFragmentAggregateSubscriptionSources) =
-    Plugin_SubscriptionSchema.sourceCFields(~mutationEntries=apiFragmentRegistryMutationEntries)
   GraphQL_Stitcher.encode({
     types: parts.types
     ->Array.concat(uiFragmentSubscriptionTypes)
     ->Array.concat(pluginStatusSubscriptionTypes)
     ->Array.concat(Platform_ComponentDefinitionsApi.sdlTypes)
-    ->Array.concat(Platform_UIFragmentsApi.sdlTypes)
-    ->Array.concat(Platform_ApiFragmentsApi.sdlTypes),
+    ->Array.concat(Platform_UIFragmentsApi.sdlTypes),
     queries: Array.concat(
       parts.queries,
       [
         Platform_ComponentDefinitionsApi.sdlQueryField,
         Platform_UIFragmentsApi.sdlQueryField,
-        Platform_ApiFragmentsApi.sdlQueryField,
       ],
     ),
     mutations: parts.mutations
     ->Array.concat(uiFragmentMutationFields)
     ->Array.concat(pluginStatusMutationFields),
     subscriptions: [uiFragmentSubscriptionField, pluginStatusSubscriptionField]
-    ->Array.concat(pluginAggregateSubscriptionFields)
-    ->Array.concat(apiFragmentAggregateSubscriptionFields),
+    ->Array.concat(pluginAggregateSubscriptionFields),
     subscriptionSources: [uiFragmentSubscriptionSource, pluginStatusSubscriptionSource]
-    ->Array.concat(pluginAggregateSubscriptionSources)
-    ->Array.concat(apiFragmentAggregateSubscriptionSources),
+    ->Array.concat(pluginAggregateSubscriptionSources),
   })
 }

package/src/admin/AdminApi.res.mjs

@@ -1,14 +1,10 @@
 // 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 Api_Naming$ReventlessCore from "../components/Api/Api_Naming.res.mjs";
-import * as ApiNoApiHelpers$ReventlessCore from "../components/Api/ApiNoApiHelpers.res.mjs";
 import * as GraphQL_Stitcher$ReventlessCore from "../components/Api/GraphQL_Stitcher.res.mjs";
 import * as PluginBaseFragment$ReventlessCore from "../plugin/api/PluginBaseFragment.res.mjs";
-import * as ApiFragmentRegistrySpec$ReventlessCore from "./ApiFragmentRegistry/ApiFragmentRegistrySpec.res.mjs";
 import * as Platform_UIFragmentsApi$ReventlessCore from "./Platform_UIFragmentsApi.res.mjs";
-import * as Platform_ApiFragmentsApi$ReventlessCore from "./Platform_ApiFragmentsApi.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "../components/Api/GraphQL_FragmentGenerator.res.mjs";
 import * as Plugin_SubscriptionSchema$ReventlessCore from "../plugin/component/Plugin_SubscriptionSchema.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "./Platform_ComponentDefinitionsApi.res.mjs";
@@ -27,28 +23,14 @@ let cloneMutationEntry = {
   description: cloneMutationEntry_description
 };
 
-let constructorNames = DcbTag$Reventless.extractAllVariantNames(ApiFragmentRegistrySpec$ReventlessCore.commandSchema);
-
-let filteredConstructorNames = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(constructorNames, ApiFragmentRegistrySpec$ReventlessCore.commandSchema);
-
-let fieldNames = filteredConstructorNames.map(cname => Api_Naming$ReventlessCore.adminField(ApiFragmentRegistrySpec$ReventlessCore.name + "_" + cname));
-
-let apiFragmentRegistryMutationEntries = fieldNames.length === 0 ? [] : [{
-      fieldNames: fieldNames,
-      commandSchema: ApiFragmentRegistrySpec$ReventlessCore.commandSchema
-    }];
-
 function mutationEntries(cloner) {
-  let base = PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries.concat(apiFragmentRegistryMutationEntries);
   if (cloner) {
-    return base.concat([cloneMutationEntry]);
+    return PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries.concat([cloneMutationEntry]);
   } else {
-    return base;
+    return PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries;
   }
 }
 
-let systemCallerFieldNames = apiFragmentRegistryMutationEntries.flatMap(e => e.fieldNames).concat([Platform_ApiFragmentsApi$ReventlessCore.queryFieldName]);
-
 let uiFragmentSubscriptionTypes = [
   `enum UIFragmentChangeKind {\n  Registered\n  Updated\n  Deregistered\n}`,
   `type UIFragmentChangeEvent {\n  pluginId: ID!\n  changeKind: UIFragmentChangeKind!\n  manifest: String\n}`
@@ -93,23 +75,21 @@ function baseFragment(cloner) {
   let base = GraphQL_FragmentGenerator$ReventlessCore.generate(mutationEntries(cloner), PluginBaseFragment$ReventlessCore.queryEntries);
   let parts = GraphQL_Stitcher$ReventlessCore.decode(base);
   let match = Plugin_SubscriptionSchema$ReventlessCore.sourceCFields(PluginBaseFragment$ReventlessCore.pluginAggregateMutationEntries);
-  let match$1 = Plugin_SubscriptionSchema$ReventlessCore.sourceCFields(apiFragmentRegistryMutationEntries);
   return GraphQL_Stitcher$ReventlessCore.encode({
-    types: parts.types.concat(uiFragmentSubscriptionTypes).concat(pluginStatusSubscriptionTypes).concat(Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes).concat(Platform_UIFragmentsApi$ReventlessCore.sdlTypes).concat(Platform_ApiFragmentsApi$ReventlessCore.sdlTypes),
+    types: parts.types.concat(uiFragmentSubscriptionTypes).concat(pluginStatusSubscriptionTypes).concat(Platform_ComponentDefinitionsApi$ReventlessCore.sdlTypes).concat(Platform_UIFragmentsApi$ReventlessCore.sdlTypes),
     mutations: parts.mutations.concat(uiFragmentMutationFields).concat(pluginStatusMutationFields),
     queries: parts.queries.concat([
       Platform_ComponentDefinitionsApi$ReventlessCore.sdlQueryField,
-      Platform_UIFragmentsApi$ReventlessCore.sdlQueryField,
-      Platform_ApiFragmentsApi$ReventlessCore.sdlQueryField
+      Platform_UIFragmentsApi$ReventlessCore.sdlQueryField
     ]),
     subscriptions: [
       uiFragmentSubscriptionField,
       pluginStatusSubscriptionField
-    ].concat(match[0]).concat(match$1[0]),
+    ].concat(match[0]),
     subscriptionSources: [
       uiFragmentSubscriptionSource,
       pluginStatusSubscriptionSource
-    ].concat(match[1]).concat(match$1[1])
+    ].concat(match[1])
   });
 }
 
@@ -118,10 +98,8 @@ let queryEntries = PluginBaseFragment$ReventlessCore.queryEntries;
 export {
   cloneArgsSchema,
   cloneMutationEntry,
-  apiFragmentRegistryMutationEntries,
   mutationEntries,
   queryEntries,
-  systemCallerFieldNames,
   uiFragmentSubscriptionTypes,
   uiFragmentMutationFields,
   uiFragmentSubscriptionField,

package/src/components/Api/GraphQL_Stitcher.res

@@ -172,21 +172,23 @@ let relayBaseQueries = [
 ]
 
 /**
-Stitch a base fragment with plugin fragments into a complete GraphQL SDL string.
+Assemble fragments into a complete GraphQL SDL string.
 
-- Base fragment is always first (defines core types + Plugin mutations/queries).
-- Plugin fragments add their own types, mutations, and queries.
+- Fragments are processed in order (first wins on collisions).
 - Collision detection: duplicate type definitions and field names are logged and skipped.
-- Relay base types (Node interface, PageInfo) and node query are always injected.
+- Relay base types (Node interface, PageInfo) are always injected; the global
+  `node` query only when `includeGlobalNodeQuery` (stitched schemas yes,
+  standalone subgraph documents no).
 
 Returns the full SDL string ready for use with AppSync or graphql-yoga.
+Public entry points: `stitch` (base + plugins, the whole-schema path) and
+`stitchStandalone` (one fragment as a self-contained subgraph document).
 */
-let stitch = (
-  ~baseFragment: Reventless.Plugin.apiSchemaFragment,
-  ~pluginFragments: array<Reventless.Plugin.apiSchemaFragment>,
+let assembleSdl = (
+  ~fragments: array<Reventless.Plugin.apiSchemaFragment>,
+  ~includeGlobalNodeQuery: bool,
 ): string => {
-  let allFragments = Array.concat([baseFragment], pluginFragments)
-  let parts = allFragments->Array.map(decode)
+  let parts = fragments->Array.map(decode)
 
   // Collect all type definitions — detect collisions by type name
   // Start with Relay base types (Node interface, PageInfo)
@@ -229,14 +231,18 @@ let stitch = (
   )
 
   // Collect all query fields — detect collisions by field name
-  // Start with Relay node query
+  // Start with Relay node query (single-resolver-owned: omitted from
+  // standalone subgraph documents, where the platform's canonical source
+  // owns the global `node` field)
   let seenQueryFields: Set.t<string> = Set.make()
   let allQueries: array<string> = []
-  relayBaseQueries->Array.forEach(field => {
-    let fieldName = extractLeadingName(field)
-    seenQueryFields->Set.add(fieldName)
-    allQueries->Array.push(field)
-  })
+  if includeGlobalNodeQuery {
+    relayBaseQueries->Array.forEach(field => {
+      let fieldName = extractLeadingName(field)
+      seenQueryFields->Set.add(fieldName)
+      allQueries->Array.push(field)
+    })
+  }
 
   parts->Array.forEach(({queries}) =>
     queries->Array.forEach(field => {
@@ -291,115 +297,27 @@ let stitch = (
   sdlParts->Array.join("\n\n")
 }
 
-let isIdentStart = (line: string): bool =>
-  switch line->String.codePointAt(0) {
-  // A-Z (65-90), a-z (97-122), or `_` (95)
-  | Some(c) => (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c == 95
-  | None => false
-  }
-
-/**
-List the field NAMES defined inside a root object type (`Mutation` / `Query` /
-`Subscription`) of a full SDL string.
-
-This is the identity-aware primitive underlying every schema-clobber guard:
-`countRootTypeFields` is just its length, and the deploy-time repair / shrink
-guards compare the returned NAME SETS rather than cardinalities so they catch
-field *swaps* and equal-cardinality drift that a count comparison misses.
-
-Heuristic but adequate: root operation fields are flat single-line declarations
-(`name(args): T` or `name: T`), so we slice the `type <typeName> { … }` block at
-its first `{`/`}` and read the leading identifier of each indented line that
-begins with an identifier character, ignoring directive-only lines (`@…`),
-comments (`#…`) and braces.
-*/
-let rootTypeFieldNames = (~sdl: string, ~typeName: string): array<string> => {
-  let marker = `type ${typeName}`
-  switch sdl->String.indexOfOpt(marker) {
-  | None => []
-  | Some(typeStart) =>
-    let rest = sdl->String.slice(~start=typeStart)
-    switch (rest->String.indexOfOpt("{"), rest->String.indexOfOpt("}")) {
-    | (Some(openIdx), Some(closeIdx)) if closeIdx > openIdx =>
-      rest
-      ->String.slice(~start=openIdx + 1, ~end=closeIdx)
-      ->String.split("\n")
-      ->Array.filterMap(line => {
-        let trimmed = line->String.trim
-        if trimmed->String.length > 0 && isIdentStart(trimmed) {
-          // `name(args): T` → extractLeadingName strips the arg list; `name: T`
-          // (no args) leaves a trailing colon on the token — drop it so a field
-          // reads the same whether or not it takes arguments.
-          let name = extractLeadingName(trimmed)
-          let name = name->String.endsWith(":")
-            ? name->String.slice(~start=0, ~end=name->String.length - 1)
-            : name
-          name->String.length > 0 ? Some(name) : None
-        } else {
-          None
-        }
-      })
-    | _ => []
-    }
-  }
-}
-
-/**
-Count the field definitions inside a root object type (`Mutation` / `Query`) of a
-full SDL string. Length of `rootTypeFieldNames`.
-*/
-let countRootTypeFields = (~sdl: string, ~typeName: string): int =>
-  rootTypeFieldNames(~sdl, ~typeName)->Array.length
-
-// The three GraphQL root operation types every clobber guard reasons over.
-let rootTypeNames = ["Mutation", "Query", "Subscription"]
-
-/**
-Union of every root-operation field name across `Mutation` + `Query` +
-`Subscription`. The identity set the deploy-time repair and shrink guards diff.
-*/
-let allRootFieldNames = (~sdl: string): array<string> =>
-  rootTypeNames->Array.flatMap(typeName => rootTypeFieldNames(~sdl, ~typeName))
+let stitch = (
+  ~baseFragment: Reventless.Plugin.apiSchemaFragment,
+  ~pluginFragments: array<Reventless.Plugin.apiSchemaFragment>,
+): string =>
+  assembleSdl(
+    ~fragments=Array.concat([baseFragment], pluginFragments),
+    ~includeGlobalNodeQuery=true,
+  )
 
 /**
-Root-operation field names present in `expectedSdl` but MISSING from `liveSdl`
-(across Mutation + Query + Subscription). Non-empty ⇒ the live schema is not a
-superset of what we expect and a repair push is warranted — this heals field
-*swaps* and equal-cardinality drift that a bare count comparison would skip.
+Render ONE fragment as a standalone schema document for merge-based
+composition (plugin = subgraph, platform = merge). The relay base types are
+included so the document is self-contained and valid on its own; the global
+`node(id: ID!)` root query is omitted — exactly one source (the platform's
+canonical one) may own that field's resolver, so only the canonical base
+document carries it (via `stitch`).
 */
-let missingRootFields = (~expectedSdl: string, ~liveSdl: string): array<string> => {
-  let liveSet = allRootFieldNames(~sdl=liveSdl)->Set.fromArray
-  allRootFieldNames(~sdl=expectedSdl)->Array.filter(name => !(liveSet->Set.has(name)))
-}
-
-/**
-Decide whether replacing the live schema (`currentSdl`) with `newSdl` would drop
-root-operation fields the pushing stack does not carry — i.e. an almost-certainly
-transient/incomplete stitch rather than an intentional removal.
-
-Identity-based (across `Mutation` + `Query` + `Subscription`):
-- When `newSdl`'s field-name set is a SUPERSET of the live set — nothing is
-  dropped — it is purely additive (or unchanged) and never a clobber, so this
-  returns `false` even when the pushing stack is legitimately adding its own
-  fields.
-- Otherwise it falls back to the cardinality threshold on the union of the three
-  root types: `true` only when the new total drops below `threshold` × the
-  current total. A small intentional removal (above threshold) is allowed.
+let stitchStandalone = (~fragment: Reventless.Plugin.apiSchemaFragment): string =>
+  assembleSdl(~fragments=[fragment], ~includeGlobalNodeQuery=false)
 
-When the current schema has no countable root fields (e.g. first deploy, or
-introspection was unavailable so `currentSdl` is empty) it returns `false` so the
-initial push always proceeds.
-*/
-let isCatastrophicSchemaShrink = (~currentSdl: string, ~newSdl: string, ~threshold: float): bool => {
-  let currentNames = allRootFieldNames(~sdl=currentSdl)
-  let newSet = allRootFieldNames(~sdl=newSdl)->Set.fromArray
-  let dropped = currentNames->Array.filter(name => !(newSet->Set.has(name)))
-  if dropped->Array.length == 0 {
-    // Additive or unchanged push — the new schema keeps every live field.
-    false
-  } else {
-    let current = currentNames->Array.length
-    let next = allRootFieldNames(~sdl=newSdl)->Array.length
-    current > 0 && next->Int.toFloat < current->Int.toFloat *. threshold
-  }
-}
+// (The schema-clobber guard family — rootTypeFieldNames / countRootTypeFields /
+// missingRootFields / isCatastrophicSchemaShrink — was retired with the push
+// machinery: under merged-API composition every source API is a single writer,
+// so no whole-replace push exists to guard.)

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

@@ -3,7 +3,6 @@
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 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 Logger$ReventlessCore from "../../util/Logger.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
@@ -132,9 +131,8 @@ let relayBaseTypes = [
 
 let relayBaseQueries = [`  node(id: ID!): Node`];
 
-function stitch(baseFragment, pluginFragments) {
-  let allFragments = [baseFragment].concat(pluginFragments);
-  let parts = allFragments.map(decode);
+function assembleSdl(fragments, includeGlobalNodeQuery) {
+  let parts = fragments.map(decode);
   let seenTypeNames = new Set();
   let allTypes = [];
   relayBaseTypes.forEach(typeDef => {
@@ -173,11 +171,13 @@ function stitch(baseFragment, pluginFragments) {
   });
   let seenQueryFields = new Set();
   let allQueries = [];
-  relayBaseQueries.forEach(field => {
-    let fieldName = extractLeadingName(field);
-    seenQueryFields.add(fieldName);
-    allQueries.push(field);
-  });
+  if (includeGlobalNodeQuery) {
+    relayBaseQueries.forEach(field => {
+      let fieldName = extractLeadingName(field);
+      seenQueryFields.add(fieldName);
+      allQueries.push(field);
+    });
+  }
   parts.forEach(param => {
     param.queries.forEach(field => {
       let fieldName = extractLeadingName(field);
@@ -217,86 +217,12 @@ function stitch(baseFragment, pluginFragments) {
   return sdlParts.join("\n\n");
 }
 
-function isIdentStart(line) {
-  let c = line.codePointAt(0);
-  if (c !== undefined) {
-    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
-      return true;
-    } else {
-      return c === 95;
-    }
-  } else {
-    return false;
-  }
-}
-
-function rootTypeFieldNames(sdl, typeName) {
-  let marker = `type ` + typeName;
-  let typeStart = Stdlib_String.indexOfOpt(sdl, marker);
-  if (typeStart === undefined) {
-    return [];
-  }
-  let rest = sdl.slice(typeStart);
-  let match = Stdlib_String.indexOfOpt(rest, "{");
-  let match$1 = Stdlib_String.indexOfOpt(rest, "}");
-  if (match !== undefined) {
-    if (match$1 !== undefined) {
-      if (match$1 > match) {
-        return Stdlib_Array.filterMap(rest.slice(match + 1 | 0, match$1).split("\n"), line => {
-          let trimmed = line.trim();
-          if (!(trimmed.length > 0 && isIdentStart(trimmed))) {
-            return;
-          }
-          let name = extractLeadingName(trimmed);
-          let name$1 = name.endsWith(":") ? name.slice(0, name.length - 1 | 0) : name;
-          if (name$1.length > 0) {
-            return name$1;
-          }
-        });
-      } else {
-        return [];
-      }
-    } else {
-      return [];
-    }
-  } else {
-    return [];
-  }
-}
-
-function countRootTypeFields(sdl, typeName) {
-  return rootTypeFieldNames(sdl, typeName).length;
-}
-
-let rootTypeNames = [
-  "Mutation",
-  "Query",
-  "Subscription"
-];
-
-function allRootFieldNames(sdl) {
-  return rootTypeNames.flatMap(typeName => rootTypeFieldNames(sdl, typeName));
-}
-
-function missingRootFields(expectedSdl, liveSdl) {
-  let liveSet = new Set(allRootFieldNames(liveSdl));
-  return allRootFieldNames(expectedSdl).filter(name => !liveSet.has(name));
+function stitch(baseFragment, pluginFragments) {
+  return assembleSdl([baseFragment].concat(pluginFragments), true);
 }
 
-function isCatastrophicSchemaShrink(currentSdl, newSdl, threshold) {
-  let currentNames = allRootFieldNames(currentSdl);
-  let newSet = new Set(allRootFieldNames(newSdl));
-  let dropped = currentNames.filter(name => !newSet.has(name));
-  if (dropped.length === 0) {
-    return false;
-  }
-  let current = currentNames.length;
-  let next = allRootFieldNames(newSdl).length;
-  if (current > 0) {
-    return next < current * threshold;
-  } else {
-    return false;
-  }
+function stitchStandalone(fragment) {
+  return assembleSdl([fragment], false);
 }
 
 export {
@@ -308,13 +234,8 @@ export {
   extractLeadingName,
   relayBaseTypes,
   relayBaseQueries,
+  assembleSdl,
   stitch,
-  isIdentStart,
-  rootTypeFieldNames,
-  countRootTypeFields,
-  rootTypeNames,
-  allRootFieldNames,
-  missingRootFields,
-  isCatastrophicSchemaShrink,
+  stitchStandalone,
 }
 /* log Not a pure module */