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

package/cjs/subgraph/validation/rules/known-type-names-rule.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownTypeNamesRule = void 0;
+const graphql_1 = require("graphql");
+function isTypeDefinitionOrExtensionNode(node) {
+    return (0, graphql_1.isTypeDefinitionNode)(node) || (0, graphql_1.isTypeExtensionNode)(node);
+}
+function KnownTypeNamesRule(context) {
+    const { definitions } = context.getDocument();
+    const typeNames = new Set(definitions.filter(isTypeDefinitionOrExtensionNode).map(def => def.name.value));
+    return {
+        NamedType(node, _1, parent, _2, ancestors) {
+            const typeName = node.name.value;
+            if (!typeNames.has(typeName)) {
+                const definitionNode = ancestors[2] ?? parent;
+                const isSDL = definitionNode != null && isSDLNode(definitionNode);
+                if (isSDL && standardTypeNames.has(typeName)) {
+                    return;
+                }
+                context.reportError(new graphql_1.GraphQLError(`Unknown type ${typeName}`, {
+                    nodes: node,
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+        },
+    };
+}
+exports.KnownTypeNamesRule = KnownTypeNamesRule;
+const standardTypeNames = new Set([...graphql_1.specifiedScalarTypes].map(type => type.name));
+function isSDLNode(value) {
+    return 'kind' in value && ((0, graphql_1.isTypeSystemDefinitionNode)(value) || (0, graphql_1.isTypeSystemExtensionNode)(value));
+}

package/cjs/subgraph/validation/rules/lone-schema-definition-rule.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoneSchemaDefinitionRule = void 0;
+const graphql_1 = require("graphql");
+function LoneSchemaDefinitionRule(context) {
+    let schemaDefinitionsCount = 0;
+    return {
+        SchemaDefinition() {
+            if (schemaDefinitionsCount > 0) {
+                context.reportError(new graphql_1.GraphQLError('Must provide only one schema definition.', {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            ++schemaDefinitionsCount;
+        },
+    };
+}
+exports.LoneSchemaDefinitionRule = LoneSchemaDefinitionRule;

package/cjs/subgraph/validation/rules/provided-arguments-on-directives-rule.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProvidedArgumentsOnDirectivesRule = void 0;
+const graphql_1 = require("graphql");
+const printer_js_1 = require("../../../graphql/printer.js");
+const helpers_js_1 = require("../../helpers.js");
+function ProvidedArgumentsOnDirectivesRule(context) {
+    return {
+        Directive: {
+            leave(directiveNode, _k, _p, _pp, ancestors) {
+                const directiveName = directiveNode.name.value;
+                const directiveDefinition = context.getKnownDirectiveDefinition(directiveName);
+                if (!directiveDefinition) {
+                    return;
+                }
+                const args = directiveNode.arguments;
+                if (args && directiveDefinition.arguments) {
+                    const coordinate = context.getSchemaCoordinate(ancestors);
+                    for (const arg of args) {
+                        const argDefinition = directiveDefinition.arguments.find(a => a.name.value === arg.name.value);
+                        if (argDefinition && arg.value) {
+                            if (argDefinition.type.kind === graphql_1.Kind.NON_NULL_TYPE && arg.value.kind === graphql_1.Kind.NULL) {
+                                continue;
+                            }
+                            const printedType = printTypeNode(argDefinition.type, context);
+                            const printedValue = printValueNode(arg.value);
+                            if (!printedType) {
+                                continue;
+                            }
+                            if (printedType !== 'Any' && printedType !== printedValue) {
+                                const namedType = (0, helpers_js_1.namedTypeFromTypeNode)(argDefinition.type);
+                                const typeName = namedType.name.value;
+                                if (printedValue === 'Int' && typeName === 'Float') {
+                                    continue;
+                                }
+                                context.reportError(new graphql_1.GraphQLError(`Invalid value for "@${directiveName}(${arg.name.value}:)" of type "${(0, printer_js_1.print)(argDefinition.type)}" in application of "@${directiveName}" to "${coordinate}".`, {
+                                    nodes: arg,
+                                    extensions: {
+                                        code: 'INVALID_GRAPHQL',
+                                    },
+                                }));
+                            }
+                        }
+                    }
+                }
+            },
+        },
+    };
+}
+exports.ProvidedArgumentsOnDirectivesRule = ProvidedArgumentsOnDirectivesRule;
+function printValueNode(valueNode) {
+    switch (valueNode.kind) {
+        case graphql_1.Kind.LIST:
+            if (!valueNode.values.length) {
+                return '[]';
+            }
+            return printValueNode(valueNode.values[0]);
+        case graphql_1.Kind.ENUM:
+            return 'Enum';
+        case graphql_1.Kind.NULL:
+            return 'Null';
+        case graphql_1.Kind.INT:
+            return 'Int';
+        case graphql_1.Kind.FLOAT:
+            return 'Float';
+        case graphql_1.Kind.STRING:
+            return 'String';
+        case graphql_1.Kind.BOOLEAN:
+            return 'Boolean';
+        case graphql_1.Kind.OBJECT:
+            return 'Object';
+    }
+    throw new Error(`Unknown value node kind: ${valueNode}`);
+}
+function printTypeNode(typeNode, context) {
+    if (typeNode.kind === graphql_1.Kind.NAMED_TYPE) {
+        const def = context.getKnownTypeDefinition(typeNode.name.value);
+        if (!def) {
+            const specifiedScalar = graphql_1.specifiedScalarTypes.find(s => s.name === typeNode.name.value);
+            if (specifiedScalar) {
+                return specifiedScalar.name;
+            }
+            return null;
+        }
+        switch (def.kind) {
+            case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+            case graphql_1.Kind.SCALAR_TYPE_EXTENSION:
+                return 'Any';
+            case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+            case graphql_1.Kind.ENUM_TYPE_EXTENSION:
+                return 'Enum';
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            case graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+            case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+            case graphql_1.Kind.OBJECT_TYPE_EXTENSION:
+            case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+            case graphql_1.Kind.INTERFACE_TYPE_EXTENSION:
+            case graphql_1.Kind.UNION_TYPE_DEFINITION:
+            case graphql_1.Kind.UNION_TYPE_EXTENSION:
+                return 'Object';
+        }
+    }
+    return printTypeNode(typeNode.type, context);
+}

package/cjs/subgraph/validation/rules/provided-required-arguments-on-directives-rule.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProvidedRequiredArgumentsOnDirectivesRule = void 0;
+const graphql_1 = require("graphql");
+const printer_js_1 = require("../../../graphql/printer.js");
+function ProvidedRequiredArgumentsOnDirectivesRule(context) {
+    const requiredArgsMap = Object.create(null);
+    const astDefinitions = context.getDocument().definitions;
+    for (const def of astDefinitions) {
+        if (def.kind === graphql_1.Kind.DIRECTIVE_DEFINITION) {
+            const argNodes = def.arguments ?? [];
+            const requiredArgs = argNodes.filter(isRequiredArgumentNode);
+            requiredArgsMap[def.name.value] = {};
+            for (const requiredArg of requiredArgs) {
+                requiredArgsMap[def.name.value][requiredArg.name.value] = requiredArg;
+            }
+        }
+    }
+    return {
+        Directive: {
+            leave(directiveNode) {
+                const directiveName = directiveNode.name.value;
+                const requiredArgs = requiredArgsMap[directiveName];
+                if (requiredArgs) {
+                    const argNodes = directiveNode.arguments ?? [];
+                    const argNodeMap = new Set(argNodes.map(arg => arg.name.value));
+                    for (const [argName, argDef] of Object.entries(requiredArgs)) {
+                        if (!argNodeMap.has(argName)) {
+                            const argType = (0, printer_js_1.print)(argDef.type);
+                            context.reportError(new graphql_1.GraphQLError(`Directive "@${directiveName}" argument "${argName}" of type "${argType}" is required, but it was not provided.`, {
+                                nodes: directiveNode,
+                                extensions: {
+                                    code: 'INVALID_GRAPHQL',
+                                },
+                            }));
+                        }
+                    }
+                }
+            },
+        },
+    };
+}
+exports.ProvidedRequiredArgumentsOnDirectivesRule = ProvidedRequiredArgumentsOnDirectivesRule;
+function isRequiredArgumentNode(arg) {
+    return arg.type.kind === graphql_1.Kind.NON_NULL_TYPE && arg.defaultValue == null;
+}

package/cjs/subgraph/validation/rules/query-root-type-inaccessible-rule.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryRootTypeInaccessibleRule = void 0;
+const graphql_1 = require("graphql");
+function QueryRootTypeInaccessibleRule(context) {
+    let rootTypeName = 'Query';
+    return {
+        SchemaDefinition(node) {
+            const nonQueryType = node.operationTypes?.find(operationType => operationType.operation === graphql_1.OperationTypeNode.QUERY &&
+                operationType.type.name.value !== 'Query');
+            if (nonQueryType) {
+                rootTypeName = nonQueryType.type.name.value;
+            }
+        },
+        SchemaExtension(node) {
+            const nonQueryType = node.operationTypes?.find(operationType => operationType.operation === graphql_1.OperationTypeNode.QUERY &&
+                operationType.type.name.value !== 'Query');
+            if (nonQueryType) {
+                rootTypeName = nonQueryType.type.name.value;
+            }
+        },
+        ObjectTypeDefinition(node) {
+            const name = node.name.value;
+            if (name !== rootTypeName) {
+                return;
+            }
+            if (node.directives?.some(directive => context.isAvailableFederationDirective('inaccessible', directive))) {
+                context.reportError(new graphql_1.GraphQLError(`Type "Query" is @inaccessible but is the root query type, which must be in the API schema.`, { nodes: node, extensions: { code: 'QUERY_ROOT_TYPE_INACCESSIBLE' } }));
+            }
+        },
+    };
+}
+exports.QueryRootTypeInaccessibleRule = QueryRootTypeInaccessibleRule;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReservedSubgraphNameRule = void 0;
+const graphql_1 = require("graphql");
+function ReservedSubgraphNameRule(context) {
+    if (context.getSubgraphName() === '_') {
+        context.reportError(new graphql_1.GraphQLError(`Invalid name _ for a subgraph: this name is reserved`, {
+            extensions: {
+                code: 'INVALID_SUBGRAPH_NAME',
+            },
+        }));
+    }
+    return {};
+}
+exports.ReservedSubgraphNameRule = ReservedSubgraphNameRule;

package/cjs/subgraph/validation/rules/root-type-used-rule.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootTypeUsedRule = void 0;
+const graphql_1 = require("graphql");
+function findDefaultRootTypes(definitions) {
+    const foundRootTypes = {
+        query: null,
+        mutation: null,
+        subscription: null,
+    };
+    const found = new Set();
+    for (const definition of definitions) {
+        if (found.size === 3) {
+            break;
+        }
+        if ((0, graphql_1.isTypeDefinitionNode)(definition)) {
+            if (definition.name.value === 'Query') {
+                foundRootTypes.query = 'Query';
+                found.add(graphql_1.OperationTypeNode.QUERY);
+            }
+            else if (definition.name.value === 'Mutation') {
+                foundRootTypes.mutation = 'Mutation';
+                found.add(graphql_1.OperationTypeNode.MUTATION);
+            }
+            else if (definition.name.value === 'Subscription') {
+                foundRootTypes.subscription = 'Subscription';
+                found.add(graphql_1.OperationTypeNode.SUBSCRIPTION);
+            }
+        }
+    }
+    return foundRootTypes;
+}
+function validateSchemaNode(node, definitions, context) {
+    const definedDefaultRootTypes = findDefaultRootTypes(definitions);
+    for (const operationType of node.operationTypes ?? []) {
+        const defaultRootType = definedDefaultRootTypes[operationType.operation];
+        const usedRootTypeName = operationType.type.name.value;
+        if (defaultRootType && defaultRootType !== usedRootTypeName) {
+            context.reportError(new graphql_1.GraphQLError(`The schema has a type named "${defaultRootType}" but it is not set as the ${operationType.operation} root type ("${usedRootTypeName}" is instead): this is not supported by federation. If a root type does not use its default name, there should be no other type with that default name.`, {
+                nodes: node,
+                extensions: {
+                    code: `ROOT_${operationType.operation.toUpperCase()}_USED`,
+                },
+            }));
+        }
+    }
+}
+function RootTypeUsedRule(context) {
+    const { definitions } = context.getDocument();
+    return {
+        SchemaDefinition(node) {
+            validateSchemaNode(node, definitions, context);
+        },
+        SchemaExtension(node) {
+            validateSchemaNode(node, definitions, context);
+        },
+    };
+}
+exports.RootTypeUsedRule = RootTypeUsedRule;

package/cjs/subgraph/validation/rules/unique-argument-definition-names-rule.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueArgumentDefinitionNamesRule = void 0;
+const graphql_1 = require("graphql");
+function UniqueArgumentDefinitionNamesRule(context) {
+    return {
+        DirectiveDefinition(directiveNode) {
+            const argumentNodes = directiveNode.arguments ?? [];
+            return checkArgUniqueness(`@${directiveNode.name.value}`, argumentNodes);
+        },
+        InterfaceTypeDefinition: checkArgUniquenessPerField,
+        InterfaceTypeExtension: checkArgUniquenessPerField,
+        ObjectTypeDefinition: checkArgUniquenessPerField,
+        ObjectTypeExtension: checkArgUniquenessPerField,
+    };
+    function checkArgUniquenessPerField(typeNode) {
+        const typeName = typeNode.name.value;
+        const fieldNodes = typeNode.fields ?? [];
+        for (const fieldDef of fieldNodes) {
+            const fieldName = fieldDef.name.value;
+            const argumentNodes = fieldDef.arguments ?? [];
+            checkArgUniqueness(`${typeName}.${fieldName}`, argumentNodes);
+        }
+        return false;
+    }
+    function checkArgUniqueness(parentName, argumentNodes) {
+        const visitedArgumentNames = new Set();
+        for (const argDef of argumentNodes) {
+            if (visitedArgumentNames.has(argDef.name.value)) {
+                context.reportError(new graphql_1.GraphQLError(`Argument "${parentName}(${argDef.name.value}:)" can only be defined once.`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                visitedArgumentNames.add(argDef.name.value);
+            }
+        }
+    }
+}
+exports.UniqueArgumentDefinitionNamesRule = UniqueArgumentDefinitionNamesRule;

package/cjs/subgraph/validation/rules/unique-argument-names-rule.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueArgumentNamesRule = void 0;
+const graphql_1 = require("graphql");
+function UniqueArgumentNamesRule(context) {
+    return {
+        Field: checkArgUniqueness,
+        Directive: checkArgUniqueness,
+    };
+    function checkArgUniqueness(parentNode) {
+        const argumentNodes = parentNode.arguments ?? [];
+        const seenArgs = new Set();
+        for (const argumentNode of argumentNodes) {
+            if (seenArgs.has(argumentNode.name.value)) {
+                context.reportError(new graphql_1.GraphQLError(`There can be only one argument named "${argumentNode.name.value}".`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                seenArgs.add(argumentNode.name.value);
+            }
+        }
+    }
+}
+exports.UniqueArgumentNamesRule = UniqueArgumentNamesRule;

package/cjs/subgraph/validation/rules/unique-directive-names-rule.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueDirectiveNamesRule = void 0;
+const graphql_1 = require("graphql");
+function UniqueDirectiveNamesRule(context) {
+    const knownDirectiveNameNodes = new Set();
+    return {
+        DirectiveDefinition(node) {
+            const directiveName = node.name.value;
+            const existingNameNode = knownDirectiveNameNodes.has(directiveName);
+            if (existingNameNode) {
+                context.reportError(new graphql_1.GraphQLError(`There can be only one directive named "@${directiveName}".`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                knownDirectiveNameNodes.add(directiveName);
+            }
+        },
+    };
+}
+exports.UniqueDirectiveNamesRule = UniqueDirectiveNamesRule;

package/cjs/subgraph/validation/rules/unique-directives-per-location-rule.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueDirectivesPerLocationRule = void 0;
+const graphql_1 = require("graphql");
+function UniqueDirectivesPerLocationRule(context) {
+    const uniqueDirectiveMap = new Map();
+    const astDefinitions = context.getDocument().definitions;
+    for (const def of astDefinitions) {
+        if (def.kind === graphql_1.Kind.DIRECTIVE_DEFINITION) {
+            uniqueDirectiveMap.set(def.name.value, !def.repeatable);
+        }
+    }
+    const schemaDirectives = new Set();
+    const typeDirectivesMap = new Map();
+    return {
+        enter(node) {
+            if (!('directives' in node) || !node.directives) {
+                return;
+            }
+            let seenDirectives;
+            if (node.kind === graphql_1.Kind.SCHEMA_DEFINITION || node.kind === graphql_1.Kind.SCHEMA_EXTENSION) {
+                seenDirectives = schemaDirectives;
+            }
+            else if ((0, graphql_1.isTypeDefinitionNode)(node) || (0, graphql_1.isTypeExtensionNode)(node)) {
+                const typeName = node.name.value;
+                if (!typeDirectivesMap.has(typeName)) {
+                    typeDirectivesMap.set(typeName, new Set());
+                }
+                seenDirectives = typeDirectivesMap.get(typeName);
+            }
+            else {
+                seenDirectives = new Set();
+            }
+            for (const directive of node.directives) {
+                const directiveName = directive.name.value;
+                if (uniqueDirectiveMap.get(directiveName)) {
+                    if (seenDirectives.has(directiveName)) {
+                        context.reportError(new graphql_1.GraphQLError(`The directive "@${directiveName}" can only be used once at this location.`, {
+                            extensions: {
+                                code: 'INVALID_GRAPHQL',
+                            },
+                        }));
+                    }
+                    else {
+                        seenDirectives.add(directive.name.value);
+                    }
+                }
+            }
+        },
+    };
+}
+exports.UniqueDirectivesPerLocationRule = UniqueDirectivesPerLocationRule;

package/cjs/subgraph/validation/rules/unique-enum-value-names-rule.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueEnumValueNamesRule = void 0;
+const graphql_1 = require("graphql");
+function UniqueEnumValueNamesRule(context) {
+    const knownValueNames = new Map();
+    return {
+        EnumTypeDefinition: checkValueUniqueness,
+        EnumTypeExtension: checkValueUniqueness,
+    };
+    function checkValueUniqueness(node) {
+        const typeName = node.name.value;
+        if (!knownValueNames.has(typeName)) {
+            knownValueNames.set(typeName, new Set());
+        }
+        const valueNodes = node.values ?? [];
+        const valueNames = knownValueNames.get(typeName);
+        for (const valueDef of valueNodes) {
+            const valueName = valueDef.name.value;
+            if (valueNames.has(valueName)) {
+                context.reportError(new graphql_1.GraphQLError(`Enum value "${typeName}.${valueName}" can only be defined once.`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                valueNames.add(valueName);
+            }
+        }
+    }
+}
+exports.UniqueEnumValueNamesRule = UniqueEnumValueNamesRule;

package/cjs/subgraph/validation/rules/unique-field-definition-names-rule.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueFieldDefinitionNamesRule = void 0;
+const graphql_1 = require("graphql");
+function UniqueFieldDefinitionNamesRule(context) {
+    const knownFieldNames = new Map();
+    return {
+        InputObjectTypeDefinition: checkFieldUniqueness,
+        InputObjectTypeExtension: checkFieldUniqueness,
+        InterfaceTypeDefinition: checkFieldUniqueness,
+        InterfaceTypeExtension: checkFieldUniqueness,
+        ObjectTypeDefinition: checkFieldUniqueness,
+        ObjectTypeExtension: checkFieldUniqueness,
+    };
+    function checkFieldUniqueness(node) {
+        const typeName = node.name.value;
+        if (!knownFieldNames.has(typeName)) {
+            knownFieldNames.set(typeName, new Set());
+        }
+        const fieldNodes = node.fields ?? [];
+        const fieldNames = knownFieldNames.get(typeName);
+        for (const fieldDef of fieldNodes) {
+            const fieldName = fieldDef.name.value;
+            if (fieldNames.has(fieldName)) {
+                context.reportError(new graphql_1.GraphQLError(`Field "${typeName}.${fieldName}" can only be defined once.`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                fieldNames.add(fieldName);
+            }
+        }
+    }
+}
+exports.UniqueFieldDefinitionNamesRule = UniqueFieldDefinitionNamesRule;

package/cjs/subgraph/validation/rules/unique-input-field-names-rule.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueInputFieldNamesRule = void 0;
+const graphql_1 = require("graphql");
+function UniqueInputFieldNamesRule(context) {
+    const knownNameStack = [];
+    let knownNames = new Set();
+    return {
+        ObjectValue: {
+            enter() {
+                knownNameStack.push(knownNames);
+                knownNames = new Set();
+            },
+            leave() {
+                const prevKnownNames = knownNameStack.pop();
+                if (!prevKnownNames) {
+                    throw new Error('Assertion failed: nothing else in the stack');
+                }
+                knownNames = prevKnownNames;
+            },
+        },
+        ObjectField(node) {
+            const fieldName = node.name.value;
+            if (knownNames.has(fieldName)) {
+                context.reportError(new graphql_1.GraphQLError(`There can be only one input field named "${fieldName}".`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                knownNames.add(fieldName);
+            }
+        },
+    };
+}
+exports.UniqueInputFieldNamesRule = UniqueInputFieldNamesRule;

package/cjs/subgraph/validation/rules/unique-operation-types-rule.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueOperationTypesRule = void 0;
+const graphql_1 = require("graphql");
+function UniqueOperationTypesRule(context) {
+    const definedOperationTypes = new Set();
+    return {
+        SchemaDefinition: checkOperationTypes,
+        SchemaExtension: checkOperationTypes,
+    };
+    function checkOperationTypes(node) {
+        const operationTypesNodes = node.operationTypes || [];
+        for (const operationType of operationTypesNodes) {
+            const operation = operationType.operation;
+            const alreadyDefinedOperationType = definedOperationTypes.has(operation);
+            if (alreadyDefinedOperationType) {
+                context.reportError(new graphql_1.GraphQLError(`There can be only one ${operation} type in schema.`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                definedOperationTypes.add(operation);
+            }
+        }
+    }
+}
+exports.UniqueOperationTypesRule = UniqueOperationTypesRule;

package/cjs/subgraph/validation/rules/unique-type-names-rule.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueTypeNamesRule = void 0;
+const graphql_1 = require("graphql");
+function UniqueTypeNamesRule(context) {
+    const knownTypeNames = new Set();
+    return {
+        ScalarTypeDefinition: checkTypeName,
+        ObjectTypeDefinition: checkTypeName,
+        InterfaceTypeDefinition: checkTypeName,
+        UnionTypeDefinition: checkTypeName,
+        EnumTypeDefinition: checkTypeName,
+        InputObjectTypeDefinition: checkTypeName,
+    };
+    function checkTypeName(node) {
+        const typeName = node.name.value;
+        if (knownTypeNames.has(typeName)) {
+            context.reportError(new graphql_1.GraphQLError(`There can be only one type named "${typeName}".`, {
+                extensions: {
+                    code: 'INVALID_GRAPHQL',
+                },
+            }));
+        }
+        else {
+            knownTypeNames.add(typeName);
+        }
+    }
+}
+exports.UniqueTypeNamesRule = UniqueTypeNamesRule;