@trackunit/graphql-build-tools 0.0.18-alpha-6a85feaada3.0 → 0.0.18

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.0.18 (2026-06-29)
+
+This was a version bump only for graphql-build-tools to align it with other projects, there were no code changes.
+
+## 0.0.17 (2026-06-25)
+
+This was a version bump only for graphql-build-tools to align it with other projects, there were no code changes.
+
+## 0.0.16 (2026-06-24)
+
+### 🩹 Fixes
+
+- **graphql-build-tools:** preserve schema directives and drop emptied root types when reconciling root operations ([fdc403007aa](https://github.com/Trackunit/manager/commit/fdc403007aa))
+- **graphql-build-tools:** drop dangling root operation bindings when @hidden empties a root type ([af908369e9f](https://github.com/Trackunit/manager/commit/af908369e9f))
+
+### ❤️ Thank You
+
+- Claude Opus 4.8
+- Cursor @cursoragent
+- Kieran Prince
+- Ulrik Jørgensen
+
 ## 0.0.15 (2026-06-23)
 
 ### 🩹 Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/graphql-build-tools",
-  "version": "0.0.18-alpha-6a85feaada3.0",
+  "version": "0.0.18",
   "license": "SEE LICENSE IN LICENSE.txt",
   "engines": {
     "node": ">=24.x"

package/src/transformers/reconcile-root-operation-types.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLSchema } from "graphql";
+export declare const reconcileRootOperationTypes: (schema: GraphQLSchema) => GraphQLSchema;

package/src/transformers/reconcile-root-operation-types.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileRootOperationTypes = void 0;
+const graphql_1 = require("graphql");
+/**
+ * Per-server @hidden filtering can prune a root operation type (query/mutation/subscription) away while
+ * the original explicit `schema {}` block still binds it. `printSchemaWithDirectives` then emits a
+ * dangling binding (e.g. `mutation: Mutation` with no `type Mutation`), which fails stitching
+ * composition with `Unknown type Mutation.`. A subgraph legitimately having no query or no mutation for
+ * a server is fine — only the dangling reference is not.
+ *
+ * This rebinds each operation to a live, non-empty root type and rewrites the schema-definition AST so it
+ * only lists operations whose root type is still live. Schema-level directives / extensions on that AST
+ * are preserved (they live nowhere else), and any now-empty root type is dropped from the type map so we
+ * never emit an empty `type X {}`. Returns the schema untouched when nothing dangles, keeping the common
+ * case byte-for-byte identical.
+ */
+const isNonEmptyObjectType = (type) => type !== null && type !== undefined && Object.keys(type.getFields()).length > 0;
+// Operations still bound by the schema-definition AST (what astFromSchema would print).
+const boundOperationsFromAst = (schema) => {
+    const operations = new Set();
+    const nodes = [schema.astNode, ...schema.extensionASTNodes];
+    for (const node of nodes) {
+        if (node === null || node === undefined) {
+            continue;
+        }
+        for (const operationType of node.operationTypes ?? []) {
+            operations.add(operationType.operation);
+        }
+    }
+    return operations;
+};
+// Keep only the operation bindings whose root type is still live, dropping the dangling ones.
+const liveOperationTypeNodes = (operationTypes, liveOperations) => (operationTypes ?? []).filter(operationType => liveOperations.has(operationType.operation));
+const reconcileRootOperationTypes = (schema) => {
+    const config = schema.toConfig();
+    const liveQuery = isNonEmptyObjectType(config.query) ? config.query : undefined;
+    const liveMutation = isNonEmptyObjectType(config.mutation) ? config.mutation : undefined;
+    const liveSubscription = isNonEmptyObjectType(config.subscription) ? config.subscription : undefined;
+    const emptiedAnOperation = liveQuery !== config.query || liveMutation !== config.mutation || liveSubscription !== config.subscription;
+    const boundOperations = boundOperationsFromAst(schema);
+    const hasDanglingBinding = (boundOperations.has(graphql_1.OperationTypeNode.QUERY) && liveQuery === undefined) ||
+        (boundOperations.has(graphql_1.OperationTypeNode.MUTATION) && liveMutation === undefined) ||
+        (boundOperations.has(graphql_1.OperationTypeNode.SUBSCRIPTION) && liveSubscription === undefined);
+    // No emptied root and no dangling binding — leave the output identical.
+    if (!emptiedAnOperation && !hasDanglingBinding) {
+        return schema;
+    }
+    const liveOperations = new Set();
+    if (liveQuery !== undefined) {
+        liveOperations.add(graphql_1.OperationTypeNode.QUERY);
+    }
+    if (liveMutation !== undefined) {
+        liveOperations.add(graphql_1.OperationTypeNode.MUTATION);
+    }
+    if (liveSubscription !== undefined) {
+        liveOperations.add(graphql_1.OperationTypeNode.SUBSCRIPTION);
+    }
+    // Root types that are no longer live must leave the type map, otherwise an empty `type X {}` is printed.
+    const deadRootTypeNames = new Set();
+    const markDeadRoot = (original, live) => {
+        if (original !== null && original !== undefined && live === undefined) {
+            deadRootTypeNames.add(original.name);
+        }
+    };
+    markDeadRoot(config.query, liveQuery);
+    markDeadRoot(config.mutation, liveMutation);
+    markDeadRoot(config.subscription, liveSubscription);
+    const reconciledAstNode = config.astNode === null || config.astNode === undefined
+        ? config.astNode
+        : { ...config.astNode, operationTypes: liveOperationTypeNodes(config.astNode.operationTypes, liveOperations) };
+    return new graphql_1.GraphQLSchema({
+        ...config,
+        query: liveQuery,
+        mutation: liveMutation,
+        subscription: liveSubscription,
+        // Drop dead roots from the explicit type list. `new GraphQLSchema` re-collects any type still
+        // referenced by a live field, so a former root that is also used as a field type survives as a
+        // regular type — only the genuinely unreferenced root is removed.
+        types: config.types.filter(type => !deadRootTypeNames.has(type.name)),
+        // Keep schema-level directives/extensions; only strip operation entries whose root type is gone.
+        astNode: reconciledAstNode,
+        extensionASTNodes: config.extensionASTNodes.map(node => ({
+            ...node,
+            operationTypes: liveOperationTypeNodes(node.operationTypes, liveOperations),
+        })),
+    });
+};
+exports.reconcileRootOperationTypes = reconcileRootOperationTypes;
+//# sourceMappingURL=reconcile-root-operation-types.js.map

package/src/transformers/transformer-chain.js

@@ -8,6 +8,7 @@ const complexity_directive_1 = require("./complexity-directive");
 const global_id_transformer_1 = require("./global-id-transformer");
 const hidden_directive_1 = require("./hidden-directive");
 const preview_directive_1 = require("./preview-directive");
+const reconcile_root_operation_types_1 = require("./reconcile-root-operation-types");
 exports.graphqlGatewayNames = ["internal", "public", "report", "v3-mobile"];
 const applySdlDirectiveTransformers = (schema, gatewayName, { preserveStitchingEntrypoints = false } = {}) => {
     const { complexityDirectiveTransformer } = (0, complexity_directive_1.complexityDirective)();
@@ -16,7 +17,10 @@ const applySdlDirectiveTransformers = (schema, gatewayName, { preserveStitchingE
     const { authorizationDirectiveTransformer } = (0, authorization_directive_1.authorizationDirective)();
     const hiddenSchema = hiddenDirectiveTransformer(schema);
     const previewSchema = gatewayName === "report" ? hiddenSchema : previewDirectiveTransformer(hiddenSchema);
-    return authorizationDirectiveTransformer(complexityDirectiveTransformer((0, global_id_transformer_1.globalIdTransformer)(previewSchema)));
+    const transformedSchema = authorizationDirectiveTransformer(complexityDirectiveTransformer((0, global_id_transformer_1.globalIdTransformer)(previewSchema)));
+    // Drop dangling/empty root operations left when @hidden empties a root type. Complements
+    // preserveStitchingEntrypoints, which only rescues roots whose fields carry a stitching directive.
+    return (0, reconcile_root_operation_types_1.reconcileRootOperationTypes)(transformedSchema);
 };
 exports.applySdlDirectiveTransformers = applySdlDirectiveTransformers;
 exports.applyDirectiveTransformers = exports.applySdlDirectiveTransformers;