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

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

@@ -0,0 +1,29 @@
+import { GraphQLError, OperationTypeNode } from 'graphql';
+export function QueryRootTypeInaccessibleRule(context) {
+    let rootTypeName = 'Query';
+    return {
+        SchemaDefinition(node) {
+            const nonQueryType = node.operationTypes?.find(operationType => operationType.operation === OperationTypeNode.QUERY &&
+                operationType.type.name.value !== 'Query');
+            if (nonQueryType) {
+                rootTypeName = nonQueryType.type.name.value;
+            }
+        },
+        SchemaExtension(node) {
+            const nonQueryType = node.operationTypes?.find(operationType => operationType.operation === 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 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' } }));
+            }
+        },
+    };
+}

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

@@ -0,0 +1,11 @@
+import { GraphQLError } from 'graphql';
+export function ReservedSubgraphNameRule(context) {
+    if (context.getSubgraphName() === '_') {
+        context.reportError(new GraphQLError(`Invalid name _ for a subgraph: this name is reserved`, {
+            extensions: {
+                code: 'INVALID_SUBGRAPH_NAME',
+            },
+        }));
+    }
+    return {};
+}

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

@@ -0,0 +1,55 @@
+import { GraphQLError, isTypeDefinitionNode, OperationTypeNode, } from '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 (isTypeDefinitionNode(definition)) {
+            if (definition.name.value === 'Query') {
+                foundRootTypes.query = 'Query';
+                found.add(OperationTypeNode.QUERY);
+            }
+            else if (definition.name.value === 'Mutation') {
+                foundRootTypes.mutation = 'Mutation';
+                found.add(OperationTypeNode.MUTATION);
+            }
+            else if (definition.name.value === 'Subscription') {
+                foundRootTypes.subscription = 'Subscription';
+                found.add(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 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`,
+                },
+            }));
+        }
+    }
+}
+export function RootTypeUsedRule(context) {
+    const { definitions } = context.getDocument();
+    return {
+        SchemaDefinition(node) {
+            validateSchemaNode(node, definitions, context);
+        },
+        SchemaExtension(node) {
+            validateSchemaNode(node, definitions, context);
+        },
+    };
+}

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

@@ -0,0 +1,38 @@
+import { GraphQLError, } from 'graphql';
+export 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 GraphQLError(`Argument "${parentName}(${argDef.name.value}:)" can only be defined once.`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                visitedArgumentNames.add(argDef.name.value);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+import { GraphQLError } from 'graphql';
+export 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 GraphQLError(`There can be only one argument named "${argumentNode.name.value}".`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                seenArgs.add(argumentNode.name.value);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+import { GraphQLError } from 'graphql';
+export 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 GraphQLError(`There can be only one directive named "@${directiveName}".`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                knownDirectiveNameNodes.add(directiveName);
+            }
+        },
+    };
+}

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

@@ -0,0 +1,48 @@
+import { GraphQLError, isTypeDefinitionNode, isTypeExtensionNode, Kind, } from 'graphql';
+export function UniqueDirectivesPerLocationRule(context) {
+    const uniqueDirectiveMap = new Map();
+    const astDefinitions = context.getDocument().definitions;
+    for (const def of astDefinitions) {
+        if (def.kind === 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 === Kind.SCHEMA_DEFINITION || node.kind === Kind.SCHEMA_EXTENSION) {
+                seenDirectives = schemaDirectives;
+            }
+            else if (isTypeDefinitionNode(node) || 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 GraphQLError(`The directive "@${directiveName}" can only be used once at this location.`, {
+                            extensions: {
+                                code: 'INVALID_GRAPHQL',
+                            },
+                        }));
+                    }
+                    else {
+                        seenDirectives.add(directive.name.value);
+                    }
+                }
+            }
+        },
+    };
+}

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

@@ -0,0 +1,29 @@
+import { GraphQLError } from 'graphql';
+export 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 GraphQLError(`Enum value "${typeName}.${valueName}" can only be defined once.`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                valueNames.add(valueName);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+import { GraphQLError, } from 'graphql';
+export 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 GraphQLError(`Field "${typeName}.${fieldName}" can only be defined once.`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                fieldNames.add(fieldName);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,33 @@
+import { GraphQLError } from 'graphql';
+export 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 GraphQLError(`There can be only one input field named "${fieldName}".`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                knownNames.add(fieldName);
+            }
+        },
+    };
+}

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

@@ -0,0 +1,25 @@
+import { GraphQLError, } from 'graphql';
+export 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 GraphQLError(`There can be only one ${operation} type in schema.`, {
+                    extensions: {
+                        code: 'INVALID_GRAPHQL',
+                    },
+                }));
+            }
+            else {
+                definedOperationTypes.add(operation);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+import { GraphQLError } from 'graphql';
+export 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 GraphQLError(`There can be only one type named "${typeName}".`, {
+                extensions: {
+                    code: 'INVALID_GRAPHQL',
+                },
+            }));
+        }
+        else {
+            knownTypeNames.add(typeName);
+        }
+    }
+}