@theguild/federation-composition 0.0.0-alpha-20230916192321-bb37b43

package/cjs/supergraph/validation/rules/subgraph-name-rule.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubgraphNameRule = void 0;
+const graphql_1 = require("graphql");
+function SubgraphNameRule(context) {
+    for (const [_, subgraph] of context.subgraphStates) {
+        const id = subgraph.graph.id;
+        if (id.startsWith('__')) {
+            context.reportError(new graphql_1.GraphQLError(`Name "${id}" must not begin with "__", which is reserved by GraphQL introspection.`, {
+                extensions: {
+                    code: 'INVALID_GRAPHQL',
+                },
+            }));
+        }
+    }
+    return {};
+}
+exports.SubgraphNameRule = SubgraphNameRule;

package/cjs/supergraph/validation/rules/types-of-the-same-kind-rule.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypesOfTheSameKindRule = void 0;
+const graphql_1 = require("graphql");
+const state_js_1 = require("../../../subgraph/state.js");
+const mapIRKindToString = {
+    [state_js_1.TypeKind.OBJECT]: 'Object',
+    [state_js_1.TypeKind.INTERFACE]: 'Interface',
+    [state_js_1.TypeKind.UNION]: 'Union',
+    [state_js_1.TypeKind.ENUM]: 'Enum',
+    [state_js_1.TypeKind.INPUT_OBJECT]: 'InputObject',
+    [state_js_1.TypeKind.SCALAR]: 'Scalar',
+    [state_js_1.TypeKind.DIRECTIVE]: 'Directive',
+};
+function TypesOfTheSameKindRule(context) {
+    const typeToKindWithGraphs = new Map();
+    const typesWithConflict = new Set();
+    for (const [graph, state] of context.subgraphStates) {
+        state.types.forEach(type => {
+            const kindToGraphs = typeToKindWithGraphs.get(type.name);
+            if (kindToGraphs) {
+                const graphs = kindToGraphs.get(type.kind);
+                if (graphs) {
+                    graphs.add(graph);
+                }
+                else {
+                    kindToGraphs.set(type.kind, new Set([graph]));
+                }
+                if (kindToGraphs.size > 1) {
+                    typesWithConflict.add(type.name);
+                }
+            }
+            else {
+                typeToKindWithGraphs.set(type.name, new Map([[type.kind, new Set([graph])]]));
+            }
+        });
+    }
+    for (const typeName of typesWithConflict) {
+        const kindToGraphs = typeToKindWithGraphs.get(typeName);
+        const groups = Array.from(kindToGraphs.entries()).map(([kind, graphs]) => {
+            const plural = graphs.size > 1 ? 's' : '';
+            return `${mapIRKindToString[kind]} Type in subgraph${plural} "${Array.from(graphs)
+                .map(context.graphIdToName)
+                .join('", "')}"`;
+        });
+        const [first, second, ...rest] = groups;
+        context.reportError(new graphql_1.GraphQLError(`Type "${typeName}" has mismatched kind: it is defined as ${first} but ${second}${rest.length ? ` and ${rest.join(' and ')}` : ''}`, {
+            extensions: {
+                code: 'TYPE_KIND_MISMATCH',
+            },
+        }));
+    }
+}
+exports.TypesOfTheSameKindRule = TypesOfTheSameKindRule;

package/cjs/supergraph/validation/validate-supergraph.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSupergraph = void 0;
+const visitor_js_1 = require("../composition/visitor.js");
+const default_value_uses_inaccessible_rule_js_1 = require("./rules/default-value-uses-inaccessible-rule.js");
+const directive_composition_rule_js_1 = require("./rules/directive-composition-rule.js");
+const enum_values_rule_js_1 = require("./rules/enum-values-rule.js");
+const extension_with_base_js_1 = require("./rules/extension-with-base.js");
+const external_argument_missing_rule_js_1 = require("./rules/external-argument-missing-rule.js");
+const external_missing_on_base_rule_js_1 = require("./rules/external-missing-on-base-rule.js");
+const external_type_mismatch_rule_js_1 = require("./rules/external-type-mismatch-rule.js");
+const field_argument_default_mismatch_rule_js_1 = require("./rules/field-argument-default-mismatch-rule.js");
+const field_arguments_of_the_same_type_rule_js_1 = require("./rules/field-arguments-of-the-same-type-rule.js");
+const fields_of_the_same_type_rule_js_1 = require("./rules/fields-of-the-same-type-rule.js");
+const input_field_default_mismatch_rule_js_1 = require("./rules/input-field-default-mismatch-rule.js");
+const input_object_values_rule_js_1 = require("./rules/input-object-values-rule.js");
+const interface_key_missing_implementation_type_js_1 = require("./rules/interface-key-missing-implementation-type.js");
+const invalid_field_sharing_rule_js_1 = require("./rules/invalid-field-sharing-rule.js");
+const only_inaccessible_children_rule_js_1 = require("./rules/only-inaccessible-children-rule.js");
+const override_source_has_override_js_1 = require("./rules/override-source-has-override.js");
+const referenced_inaccessible_rule_js_1 = require("./rules/referenced-inaccessible-rule.js");
+const required_argument_missing_in_some_subgraph_rule_js_1 = require("./rules/required-argument-missing-in-some-subgraph-rule.js");
+const required_input_field_missing_in_some_subgraph_rule_js_1 = require("./rules/required-input-field-missing-in-some-subgraph-rule.js");
+const required_query_rule_js_1 = require("./rules/required-query-rule.js");
+const satisfiablity_rule_js_1 = require("./rules/satisfiablity-rule.js");
+const subgraph_name_rule_js_1 = require("./rules/subgraph-name-rule.js");
+const types_of_the_same_kind_rule_js_1 = require("./rules/types-of-the-same-kind-rule.js");
+const validation_context_js_1 = require("./validation-context.js");
+function validateSupergraph(subgraphStates, state, __internal) {
+    const context = (0, validation_context_js_1.createSupergraphValidationContext)(subgraphStates);
+    for (const subgraphState of subgraphStates.values()) {
+        state.addGraph(subgraphState.graph);
+    }
+    const preSupergraphRules = [required_query_rule_js_1.RequiredQueryRule, types_of_the_same_kind_rule_js_1.TypesOfTheSameKindRule];
+    const rulesToSkip = __internal?.disableValidationRules ?? [];
+    for (const rule of preSupergraphRules) {
+        if (rulesToSkip.includes(rule.name)) {
+            continue;
+        }
+        rule(context);
+    }
+    for (const subgraphState of subgraphStates.values()) {
+        state.visitSubgraphState(subgraphState);
+    }
+    const postSupergraphRules = [
+        extension_with_base_js_1.ExtensionWithBaseRule,
+        fields_of_the_same_type_rule_js_1.FieldsOfTheSameTypeRule,
+        field_arguments_of_the_same_type_rule_js_1.FieldArgumentsOfTheSameTypeRule,
+        enum_values_rule_js_1.EnumValuesRule,
+        override_source_has_override_js_1.OverrideSourceHasOverrideRule,
+        external_missing_on_base_rule_js_1.ExternalMissingOnBaseRule,
+        input_object_values_rule_js_1.InputObjectValuesRule,
+        required_argument_missing_in_some_subgraph_rule_js_1.RequiredArgumentMissingInSomeSubgraph,
+        required_input_field_missing_in_some_subgraph_rule_js_1.RequiredInputFieldMissingInSomeSubgraphRule,
+        external_argument_missing_rule_js_1.ExternalArgumentMissingRule,
+        input_field_default_mismatch_rule_js_1.InputFieldDefaultMismatchRule,
+        field_argument_default_mismatch_rule_js_1.FieldArgumentDefaultMismatchRule,
+        default_value_uses_inaccessible_rule_js_1.DefaultValueUsesInaccessibleRule,
+        only_inaccessible_children_rule_js_1.OnlyInaccessibleChildrenRule,
+        referenced_inaccessible_rule_js_1.ReferencedInaccessibleRule,
+        directive_composition_rule_js_1.DirectiveCompositionRule,
+        interface_key_missing_implementation_type_js_1.InterfaceKeyMissingImplementationTypeRule,
+        external_type_mismatch_rule_js_1.ExternalTypeMismatchRule,
+        invalid_field_sharing_rule_js_1.InvalidFieldSharingRule,
+        satisfiablity_rule_js_1.SatisfiabilityRule,
+        subgraph_name_rule_js_1.SubgraphNameRule,
+    ];
+    const supergraph = state.getSupergraphState();
+    (0, visitor_js_1.visitSupergraphState)(supergraph, postSupergraphRules.map(rule => {
+        if (rulesToSkip.includes(rule.name)) {
+            return {};
+        }
+        return rule(context, supergraph);
+    }));
+    return context.collectReportedErrors();
+}
+exports.validateSupergraph = validateSupergraph;

package/cjs/supergraph/validation/validation-context.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSupergraphValidationContext = void 0;
+function createSupergraphValidationContext(subgraphStates) {
+    let reportedErrors = [];
+    return {
+        subgraphStates,
+        graphIdToName(id) {
+            const found = subgraphStates.get(id);
+            if (!found) {
+                throw new Error(`Could not find subgraph with id ${id}`);
+            }
+            return found.graph.name;
+        },
+        reportError(error) {
+            reportedErrors.push(error);
+        },
+        collectReportedErrors() {
+            const errors = reportedErrors;
+            reportedErrors = [];
+            return errors;
+        },
+    };
+}
+exports.createSupergraphValidationContext = createSupergraphValidationContext;

package/cjs/utils/dependency-graph.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DepGraphCycleError = exports.DepGraph = void 0;
+function createDFS(edges, leavesOnly, result, circular) {
+    const visited = {};
+    return function (start) {
+        if (visited[start]) {
+            return;
+        }
+        const inCurrentPath = {};
+        const currentPath = [];
+        const todo = [];
+        todo.push({ node: start, processed: false });
+        while (todo.length > 0) {
+            const current = todo[todo.length - 1];
+            const processed = current.processed;
+            const node = current.node;
+            if (!processed) {
+                if (visited[node]) {
+                    todo.pop();
+                    continue;
+                }
+                else if (inCurrentPath[node]) {
+                    if (circular) {
+                        todo.pop();
+                        continue;
+                    }
+                    currentPath.push(node);
+                    throw new DepGraphCycleError(currentPath);
+                }
+                inCurrentPath[node] = true;
+                currentPath.push(node);
+                const nodeEdges = edges[node];
+                for (let i = nodeEdges.length - 1; i >= 0; i--) {
+                    todo.push({ node: nodeEdges[i], processed: false });
+                }
+                current.processed = true;
+            }
+            else {
+                todo.pop();
+                currentPath.pop();
+                inCurrentPath[node] = false;
+                visited[node] = true;
+                if (!leavesOnly || edges[node].length === 0) {
+                    result.push(node);
+                }
+            }
+        }
+    };
+}
+class DepGraph {
+    nodes = {};
+    outgoingEdges = {};
+    incomingEdges = {};
+    circular;
+    constructor(opts) {
+        this.circular = opts?.circular ?? false;
+    }
+    size() {
+        return Object.keys(this.nodes).length;
+    }
+    addNode(name, data) {
+        if (!this.hasNode(name)) {
+            if (arguments.length === 2) {
+                this.nodes[name] = data;
+            }
+            else {
+                this.nodes[name] = name;
+            }
+            this.outgoingEdges[name] = [];
+            this.incomingEdges[name] = [];
+        }
+    }
+    removeNode(name) {
+        if (this.hasNode(name)) {
+            delete this.nodes[name];
+            delete this.outgoingEdges[name];
+            delete this.incomingEdges[name];
+            [this.incomingEdges, this.outgoingEdges].forEach(edgeList => {
+                Object.keys(edgeList).forEach(key => {
+                    const idx = edgeList[key].indexOf(name);
+                    if (idx >= 0) {
+                        edgeList[key].splice(idx, 1);
+                    }
+                });
+            });
+        }
+    }
+    hasNode(name) {
+        return this.nodes.hasOwnProperty(name);
+    }
+    getNodeData(name) {
+        if (this.hasNode(name)) {
+            return this.nodes[name];
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    setNodeData(name, data) {
+        if (this.hasNode(name)) {
+            this.nodes[name] = data;
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    addDependency(from, to) {
+        if (!this.hasNode(from)) {
+            throw new Error('Node does not exist: ' + from);
+        }
+        if (!this.hasNode(to)) {
+            throw new Error('Node does not exist: ' + to);
+        }
+        if (this.outgoingEdges[from].indexOf(to) === -1) {
+            this.outgoingEdges[from].push(to);
+        }
+        if (this.incomingEdges[to].indexOf(from) === -1) {
+            this.incomingEdges[to].push(from);
+        }
+        return true;
+    }
+    removeDependency(from, to) {
+        let idx;
+        if (this.hasNode(from)) {
+            idx = this.outgoingEdges[from].indexOf(to);
+            if (idx >= 0) {
+                this.outgoingEdges[from].splice(idx, 1);
+            }
+        }
+        if (this.hasNode(to)) {
+            idx = this.incomingEdges[to].indexOf(from);
+            if (idx >= 0) {
+                this.incomingEdges[to].splice(idx, 1);
+            }
+        }
+    }
+    directDependenciesOf(name) {
+        if (this.hasNode(name)) {
+            return this.outgoingEdges[name].slice(0);
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    directDependantsOf(name) {
+        if (this.hasNode(name)) {
+            return this.incomingEdges[name].slice(0);
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    dependenciesOf(name, leavesOnly) {
+        if (this.hasNode(name)) {
+            const result = [];
+            const DFS = createDFS(this.outgoingEdges, leavesOnly, result, this.circular);
+            DFS(name);
+            const idx = result.indexOf(name);
+            if (idx >= 0) {
+                result.splice(idx, 1);
+            }
+            return result;
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    dependantsOf(name, leavesOnly) {
+        if (this.hasNode(name)) {
+            const result = [];
+            const DFS = createDFS(this.incomingEdges, leavesOnly, result, this.circular);
+            DFS(name);
+            const idx = result.indexOf(name);
+            if (idx >= 0) {
+                result.splice(idx, 1);
+            }
+            return result;
+        }
+        else {
+            throw new Error('Node does not exist: ' + name);
+        }
+    }
+    overallOrder(leavesOnly) {
+        const result = [];
+        const keys = Object.keys(this.nodes);
+        if (keys.length === 0) {
+            return result;
+        }
+        else {
+            if (!this.circular) {
+                const CycleDFS = createDFS(this.outgoingEdges, false, [], this.circular);
+                keys.forEach(function (n) {
+                    CycleDFS(n);
+                });
+            }
+            const DFS = createDFS(this.outgoingEdges, leavesOnly, result, this.circular);
+            keys
+                .filter(node => this.incomingEdges[node].length === 0)
+                .forEach(n => {
+                DFS(n);
+            });
+            if (this.circular) {
+                keys
+                    .filter(node => result.indexOf(node) === -1)
+                    .forEach(function (n) {
+                    DFS(n);
+                });
+            }
+            return result;
+        }
+    }
+    entryNodes() {
+        return Object.keys(this.nodes).filter(node => this.incomingEdges[node].length === 0);
+    }
+    directDependentsOf = this.directDependantsOf;
+    dependentsOf = this.dependantsOf;
+}
+exports.DepGraph = DepGraph;
+class DepGraphCycleError extends Error {
+    cyclePath;
+    constructor(cyclePath) {
+        super('Dependency Cycle Found: ' + cyclePath.join(' -> '));
+        this.cyclePath = cyclePath;
+    }
+}
+exports.DepGraphCycleError = DepGraphCycleError;

package/cjs/utils/format.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.andList = void 0;
+function andList(items, commaBeforeConjunction = true, wrapper) {
+    return formatList('and', items, commaBeforeConjunction, wrapper);
+}
+exports.andList = andList;
+function formatList(conjunction, items, commaBeforeConjunction = true, wrapper) {
+    if (items.length === 0) {
+        return '';
+    }
+    switch (items.length) {
+        case 1:
+            return withWrapper(items[0], wrapper);
+        case 2:
+            return (withWrapper(items[0], wrapper) + ' ' + conjunction + ' ' + withWrapper(items[1], wrapper));
+    }
+    const allButLast = items.slice(0, -1).map(item => withWrapper(item, wrapper));
+    const lastItem = withWrapper(items.at(-1), wrapper);
+    return (allButLast.join(', ') + (commaBeforeConjunction ? ', ' : ' ') + conjunction + ' ' + lastItem);
+}
+function withWrapper(text, wrapper) {
+    if (!wrapper) {
+        return text;
+    }
+    return wrapper + text + wrapper;
+}

package/cjs/utils/helpers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefined = void 0;
+function isDefined(value) {
+    return value !== undefined && value !== null;
+}
+exports.isDefined = isDefined;

package/cjs/utils/state.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isList = exports.isNonNull = exports.stripList = exports.stripNonNull = exports.stripTypeModifiers = void 0;
+function stripTypeModifiers(type) {
+    return type.replaceAll('!', '').replaceAll('[', '').replaceAll(']', '');
+}
+exports.stripTypeModifiers = stripTypeModifiers;
+function stripNonNull(type) {
+    return type.replace(/\!$/, '');
+}
+exports.stripNonNull = stripNonNull;
+function stripList(type) {
+    return type.replace(/^\[/, '').replace(/\]$/, '');
+}
+exports.stripList = stripList;
+function isNonNull(type) {
+    return type.endsWith('!');
+}
+exports.isNonNull = isNonNull;
+function isList(type) {
+    return type.endsWith(']');
+}
+exports.isList = isList;

package/cjs/validate.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validate = void 0;
+const constant_case_1 = require("constant-case");
+const federation_js_1 = require("./specifications/federation.js");
+const state_js_1 = require("./subgraph/state.js");
+const validate_subgraph_js_1 = require("./subgraph/validation/validate-subgraph.js");
+const state_js_2 = require("./supergraph/state.js");
+const validate_supergraph_js_1 = require("./supergraph/validation/validate-supergraph.js");
+const numberAtStartRegex = /^\d/;
+function startsWithNumber(value) {
+    return numberAtStartRegex.test(value);
+}
+function buildGraphList(subgraphs) {
+    const errors = [];
+    const graphs = [];
+    const names = new Set();
+    const idCounter = new Map();
+    for (const subgraph of subgraphs) {
+        const name = String(subgraph.name);
+        const nameStartsWithNumber = startsWithNumber(name);
+        if (names.has(name)) {
+            throw new Error(`A subgraph named ${name} already exists`);
+        }
+        const { url, typeDefs } = subgraph;
+        names.add(name);
+        let proposedId = (0, constant_case_1.constantCase)(name.replace(/[^A-Z0-9]/gi, '_'), {
+            stripRegexp: /[^A-Z0-9_]+/gi,
+        });
+        if (nameStartsWithNumber) {
+            proposedId = '_' + proposedId + '_';
+        }
+        let count = idCounter.get(proposedId);
+        if (typeof count === 'number') {
+            if (count === 1) {
+                graphs.find(g => g.id === proposedId).id += '_1';
+            }
+            graphs.push({
+                name,
+                id: proposedId + '_' + (count + 1),
+                url,
+                typeDefs,
+            });
+            idCounter.set(proposedId, count + 1);
+        }
+        else {
+            idCounter.set(proposedId, 1);
+            graphs.push({
+                name,
+                id: proposedId,
+                url,
+                typeDefs,
+            });
+        }
+    }
+    if (errors.length > 0) {
+        return {
+            success: false,
+            errors,
+        };
+    }
+    graphs.sort((a, b) => a.id.localeCompare(b.id));
+    return {
+        success: true,
+        graphs,
+    };
+}
+function validate(subgraphs, __internal) {
+    const graphList = buildGraphList(subgraphs);
+    if (!graphList.success) {
+        return {
+            success: false,
+            errors: graphList.errors,
+        };
+    }
+    const corePerSubgraph = graphList.graphs.map(subgraph => (0, validate_subgraph_js_1.validateSubgraphCore)(subgraph));
+    const coreErrors = corePerSubgraph.map(core => core.errors ?? []).flat(1);
+    if (coreErrors.length > 0) {
+        return {
+            success: false,
+            errors: coreErrors,
+        };
+    }
+    const detectedFederationSpec = new Map(graphList.graphs.map(graph => [graph.id, (0, federation_js_1.detectFederationVersion)(graph.typeDefs)]));
+    const subgraphStateBuilders = new Map(graphList.graphs.map((graph, i) => [
+        graph.id,
+        (0, state_js_1.createSubgraphStateBuilder)(graph, graph.typeDefs, detectedFederationSpec.get(graph.id).version, corePerSubgraph[i].links ?? []),
+    ]));
+    const subgraphErrors = graphList.graphs
+        .map(graph => (0, validate_subgraph_js_1.validateSubgraph)(graph, subgraphStateBuilders.get(graph.id), detectedFederationSpec.get(graph.id), __internal))
+        .flat(1);
+    if (subgraphErrors.length > 0) {
+        return {
+            success: false,
+            errors: subgraphErrors,
+        };
+    }
+    const state = (0, state_js_2.createSupergraphStateBuilder)();
+    const supergraphErrors = (0, validate_supergraph_js_1.validateSupergraph)(new Map(Array.from(subgraphStateBuilders.entries()).map(([id, builder]) => [
+        id,
+        (0, state_js_1.cleanSubgraphStateFromFederationSpec)((0, state_js_1.cleanSubgraphStateFromLinkSpec)(builder.state)),
+    ])), state, __internal);
+    if (supergraphErrors.length > 0) {
+        return {
+            success: false,
+            errors: supergraphErrors,
+        };
+    }
+    const nodes = state.build();
+    return {
+        success: true,
+        supergraph: nodes,
+        links: state.links(),
+        specs: state.getSupergraphState().specs,
+    };
+}
+exports.validate = validate;

package/esm/compose.js

@@ -0,0 +1,78 @@
+import { Kind } from 'graphql';
+import { print } from './graphql/printer.js';
+import { sdl as inaccessibleSDL } from './specifications/inaccessible.js';
+import { sdl as joinSDL } from './specifications/join.js';
+import { sdl as linkSDL, printLink } from './specifications/link.js';
+import { sdl as tagSDL } from './specifications/tag.js';
+import { validate } from './validate.js';
+export function composeServices(services, __internal) {
+    const validationResult = validate(services, __internal);
+    if (!validationResult.success) {
+        return {
+            errors: validationResult.errors,
+        };
+    }
+    const rootTypes = {
+        query: false,
+        mutation: false,
+        subscription: false,
+    };
+    for (const def of validationResult.supergraph) {
+        if (def.name.value === 'Query') {
+            rootTypes.query = true;
+        }
+        else if (def.name.value === 'Mutation') {
+            rootTypes.mutation = true;
+        }
+        else if (def.name.value === 'Subscription') {
+            rootTypes.subscription = true;
+        }
+        if (rootTypes.query === true &&
+            rootTypes.mutation === true &&
+            rootTypes.subscription === true) {
+            break;
+        }
+    }
+    const usedTagSpec = validationResult.specs.tag;
+    const usedInaccessibleSpec = validationResult.specs.inaccessible;
+    return {
+        supergraphSdl: `
+schema
+  @link(url: "https://specs.apollo.dev/link/v1.0")
+  @link(url: "https://specs.apollo.dev/join/v0.3", for: EXECUTION)
+  ${usedTagSpec ? '@link(url: "https://specs.apollo.dev/tag/v0.3")' : ''}
+  ${usedInaccessibleSpec
+            ? '@link(url: "https://specs.apollo.dev/inaccessible/v0.2", for: SECURITY)'
+            : ''}
+  ${validationResult.links.map(printLink).join('\n  ')}
+{
+  ${rootTypes.query ? 'query: Query' : ''}
+  ${rootTypes.mutation ? 'mutation: Mutation' : ''}
+  ${rootTypes.subscription ? 'subscription: Subscription' : ''}
+}
+
+${joinSDL}
+${linkSDL}
+${usedTagSpec ? tagSDL : ''}
+${usedInaccessibleSpec ? inaccessibleSDL : ''}
+
+${print({
+            kind: Kind.DOCUMENT,
+            definitions: validationResult.supergraph,
+        })}
+    `,
+    };
+}
+export function assertCompositionSuccess(compositionResult, message) {
+    if (compositionHasErrors(compositionResult)) {
+        throw new Error(message || 'Unexpected test failure');
+    }
+}
+export function assertCompositionFailure(compositionResult, message) {
+    if (!compositionHasErrors(compositionResult)) {
+        throw new Error(message || 'Unexpected test failure');
+    }
+}
+export function compositionHasErrors(compositionResult) {
+    return 'errors' in compositionResult && !!compositionResult.errors;
+}