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

package/cjs/subgraph/validation/rules/elements/compose-directive.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComposeDirectiveRules = void 0;
+const graphql_1 = require("graphql");
+const helpers_js_1 = require("../../../helpers.js");
+function ComposeDirectiveRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.validateDirectiveAgainstOriginal)(node, 'composeDirective', context);
+        },
+        Directive(node) {
+            if (!context.isAvailableFederationDirective('composeDirective', node)) {
+                return;
+            }
+            if (!context.satisfiesVersionRange('>= v2.1')) {
+                return;
+            }
+            const nameArg = node.arguments?.find(arg => arg.name.value === 'name');
+            if (!nameArg || nameArg.value.kind !== graphql_1.Kind.STRING) {
+                return;
+            }
+            const name = nameArg.value.value.replace(/^@/, '');
+            const definedDirectives = context.getDocument().definitions.filter(helpers_js_1.isDirectiveDefinitionNode);
+            const matchingDirective = definedDirectives.find(directive => directive.name.value === name);
+            if (matchingDirective) {
+                context.stateBuilder.directive.setComposed(matchingDirective.name.value);
+                context.stateBuilder.composedDirectives.add(matchingDirective.name.value);
+            }
+            else {
+                context.reportError(new graphql_1.GraphQLError(`Could not find matching directive definition for argument to @composeDirective "@${name}" in subgraph "${context.getSubgraphName()}".`, {
+                    nodes: node,
+                    extensions: {
+                        code: 'DIRECTIVE_COMPOSITION_ERROR',
+                        subgraphName: context.getSubgraphName(),
+                    },
+                }));
+            }
+        },
+    };
+}
+exports.ComposeDirectiveRules = ComposeDirectiveRules;

package/cjs/subgraph/validation/rules/elements/extends.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsRules = void 0;
+const graphql_1 = require("graphql");
+const helpers_js_1 = require("../../../helpers.js");
+function ExtendsRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.validateDirectiveAgainstOriginal)(node, 'extends', context);
+        },
+        Directive(node) {
+            if (!context.isAvailableFederationDirective('extends', node)) {
+                return;
+            }
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            if (!typeDef ||
+                !(typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                    typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION)) {
+                return;
+            }
+            if (typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION) {
+                context.stateBuilder.objectType.setExtension(typeDef.name.value, '@extends');
+            }
+            else {
+                context.stateBuilder.interfaceType.setExtension(typeDef.name.value);
+            }
+            const fields = typeDef.fields;
+            for (const field of fields ?? []) {
+                context.markAsUsed('@extends', typeDef.kind, typeDef.name.value, field.name.value);
+            }
+        },
+    };
+}
+exports.ExtendsRules = ExtendsRules;

package/cjs/subgraph/validation/rules/elements/external.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalRules = void 0;
+const graphql_1 = require("graphql");
+const printer_js_1 = require("../../../../graphql/printer.js");
+const helpers_js_1 = require("../../../helpers.js");
+function ExternalRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.validateDirectiveAgainstOriginal)(node, 'external', context);
+        },
+        Directive(node) {
+            if (!context.isAvailableFederationDirective('external', node)) {
+                return;
+            }
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            const fieldDef = context.typeNodeInfo.getFieldDef();
+            if (!typeDef ||
+                !(typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                    typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION)) {
+                return;
+            }
+            const fieldDefinitions = [];
+            if (fieldDef) {
+                if (fieldDef.kind !== graphql_1.Kind.FIELD_DEFINITION) {
+                    return;
+                }
+                fieldDefinitions.push(fieldDef);
+            }
+            else {
+                const fields = typeDef.fields;
+                if (fields) {
+                    if (context.satisfiesVersionRange('>= v2.0')) {
+                        fieldDefinitions.push(...fields);
+                    }
+                }
+            }
+            for (const field of fieldDefinitions) {
+                context.markAsExternal(`${typeDef.name.value}.${field.name.value}`);
+                const conflictingDirectives = field.directives?.filter(directive => context.isAvailableFederationDirective('tag', directive) ||
+                    context.isAvailableFederationDirective('inaccessible', directive));
+                if (conflictingDirectives?.length && context.satisfiesVersionRange('>= v2.0')) {
+                    for (const directive of conflictingDirectives) {
+                        context.reportError(new graphql_1.GraphQLError(`Cannot apply merged directive ${(0, printer_js_1.print)(directive).trim()} to external field "${typeDef.name.value}.${field.name.value}"`, {
+                            nodes: node,
+                            extensions: { code: 'MERGED_DIRECTIVE_APPLICATION_ON_EXTERNAL' },
+                        }));
+                    }
+                }
+                else {
+                    context.stateBuilder.objectType.field.setExternal(typeDef.name.value, field.name.value);
+                }
+            }
+        },
+    };
+}
+exports.ExternalRules = ExternalRules;

package/cjs/subgraph/validation/rules/elements/field-set.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldSetRules = void 0;
+const graphql_1 = require("graphql");
+function FieldSetRules(context) {
+    function validateFieldSet(node, receivedType) {
+        if (node.name.value === 'FieldSet' && context.isAvailableFederationType('FieldSet')) {
+            context.reportError(new graphql_1.GraphQLError(`Invalid definition for type FieldSet: FieldSet should be a ScalarType but is defined as a ${receivedType}`, {
+                nodes: node,
+                extensions: { code: 'TYPE_DEFINITION_INVALID' },
+            }));
+        }
+    }
+    return {
+        ScalarTypeDefinition(node) {
+            if (node.name.value === 'FieldSet' && context.isAvailableFederationType('FieldSet')) {
+                context.markAsFederationDefinitionReplacement('FieldSet');
+            }
+        },
+        ObjectTypeDefinition(node) {
+            validateFieldSet(node, 'ObjectType');
+        },
+        InterfaceTypeDefinition(node) {
+            validateFieldSet(node, 'InterfaceType');
+        },
+        UnionTypeDefinition(node) {
+            validateFieldSet(node, 'UnionType');
+        },
+        EnumTypeDefinition(node) {
+            validateFieldSet(node, 'EnumType');
+        },
+        InputObjectTypeDefinition(node) {
+            validateFieldSet(node, 'InputObjectType');
+        },
+    };
+}
+exports.FieldSetRules = FieldSetRules;

package/cjs/subgraph/validation/rules/elements/inaccessible.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InaccessibleRules = void 0;
+const graphql_1 = require("graphql");
+const helpers_js_1 = require("../../../helpers.js");
+function InaccessibleRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.validateDirectiveAgainstOriginal)(node, 'inaccessible', context);
+        },
+        Directive(node, _key, _parent, paths, ancestors) {
+            if (!context.isAvailableFederationDirective('inaccessible', node)) {
+                return;
+            }
+            const directivesKeyAt = paths.findIndex(path => path === 'directives');
+            if (directivesKeyAt === -1) {
+                throw new Error('Could not find "directives" key in ancestors');
+            }
+            const parent = ancestors[directivesKeyAt];
+            if (!parent) {
+                throw new Error('Could not find the node annotated with @inaccessible');
+            }
+            if (Array.isArray(parent)) {
+                throw new Error('Expected parent to be a single node');
+            }
+            if (!('kind' in parent)) {
+                throw new Error('Expected parent to be a node');
+            }
+            switch (parent.kind) {
+                case graphql_1.Kind.SCALAR_TYPE_DEFINITION:
+                case graphql_1.Kind.SCALAR_TYPE_EXTENSION:
+                    context.stateBuilder.scalarType.setInaccessible(parent.name.value);
+                    break;
+                case graphql_1.Kind.FIELD_DEFINITION: {
+                    const typeDef = context.typeNodeInfo.getTypeDef();
+                    if (!typeDef) {
+                        throw new Error('Could not find the parent type of the field annotated with @inaccessible');
+                    }
+                    if (typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                        typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
+                        context.stateBuilder.interfaceType.field.setInaccessible(typeDef.name.value, parent.name.value);
+                    }
+                    else {
+                        context.stateBuilder.objectType.field.setInaccessible(typeDef.name.value, parent.name.value);
+                    }
+                    break;
+                }
+                case graphql_1.Kind.INPUT_VALUE_DEFINITION: {
+                    const typeDef = context.typeNodeInfo.getTypeDef();
+                    if (!typeDef) {
+                        throw new Error('Could not find the parent type of the field annotated with @inaccessible');
+                    }
+                    if (typeDef.kind === graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION ||
+                        typeDef.kind === graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION) {
+                        context.stateBuilder.inputObjectType.field.setInaccessible(typeDef.name.value, parent.name.value);
+                    }
+                    else if (typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                        typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                        const fieldDef = context.typeNodeInfo.getFieldDef();
+                        if (!fieldDef) {
+                            throw new Error('Could not find the parent field of the input value annotated with @inaccessible');
+                        }
+                        context.stateBuilder.objectType.field.arg.setInaccessible(typeDef.name.value, fieldDef.name.value, parent.name.value);
+                    }
+                    else if (typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                        typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION) {
+                        const fieldDef = context.typeNodeInfo.getFieldDef();
+                        if (!fieldDef) {
+                            throw new Error('Could not find the parent field of the input value annotated with @inaccessible');
+                        }
+                        context.stateBuilder.interfaceType.field.arg.setInaccessible(typeDef.name.value, fieldDef.name.value, parent.name.value);
+                    }
+                    else if (typeDef.kind === graphql_1.Kind.DIRECTIVE_DEFINITION) {
+                        context.stateBuilder.directive.arg.setInaccessible(typeDef.name.value, parent.name.value);
+                    }
+                    break;
+                }
+                case graphql_1.Kind.OBJECT_TYPE_DEFINITION:
+                case graphql_1.Kind.OBJECT_TYPE_EXTENSION:
+                    context.stateBuilder.objectType.setInaccessible(parent.name.value);
+                    break;
+                case graphql_1.Kind.INTERFACE_TYPE_DEFINITION:
+                case graphql_1.Kind.INTERFACE_TYPE_EXTENSION:
+                    context.stateBuilder.interfaceType.setInaccessible(parent.name.value);
+                    break;
+                case graphql_1.Kind.UNION_TYPE_DEFINITION:
+                case graphql_1.Kind.UNION_TYPE_EXTENSION:
+                    context.stateBuilder.unionType.setInaccessible(parent.name.value);
+                    break;
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+                case graphql_1.Kind.INPUT_OBJECT_TYPE_EXTENSION:
+                    context.stateBuilder.inputObjectType.setInaccessible(parent.name.value);
+                    break;
+                case graphql_1.Kind.ENUM_TYPE_DEFINITION:
+                case graphql_1.Kind.ENUM_TYPE_EXTENSION:
+                    context.stateBuilder.enumType.setInaccessible(parent.name.value);
+                    break;
+                case graphql_1.Kind.ENUM_VALUE_DEFINITION: {
+                    const enumValue = parent.name.value;
+                    const typeDef = context.typeNodeInfo.getTypeDef();
+                    if (!typeDef) {
+                        throw new Error('Could not find the parent type of the enum value annotated with @inaccessible');
+                    }
+                    context.stateBuilder.enumType.value.setInaccessible(typeDef.name.value, enumValue);
+                    break;
+                }
+            }
+            context.stateBuilder.markSpecAsUsed('inaccessible');
+        },
+    };
+}
+exports.InaccessibleRules = InaccessibleRules;

package/cjs/subgraph/validation/rules/elements/key.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyRules = void 0;
+const graphql_1 = require("graphql");
+const printer_js_1 = require("../../../../graphql/printer.js");
+const helpers_js_1 = require("../../../helpers.js");
+function KeyRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.validateDirectiveAgainstOriginal)(node, 'key', context);
+        },
+        Directive(directiveNode) {
+            if (!context.isAvailableFederationDirective('key', directiveNode)) {
+                return;
+            }
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            if (!typeDef) {
+                return;
+            }
+            const typeCoordinate = typeDef.name.value;
+            const usedOnInterface = typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION;
+            const usedOnObject = typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION || typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION;
+            if (!usedOnObject && !usedOnInterface) {
+                return;
+            }
+            if (usedOnInterface &&
+                context.satisfiesVersionRange('> v1.0') &&
+                context.satisfiesVersionRange('< v2.3')) {
+                context.reportError(new graphql_1.GraphQLError(`Cannot use @key on interface "${typeCoordinate}": @key is not yet supported on interfaces`, {
+                    nodes: directiveNode,
+                    extensions: { code: 'KEY_UNSUPPORTED_ON_INTERFACE' },
+                }));
+                return;
+            }
+            const fieldsArg = (0, helpers_js_1.getFieldsArgument)(directiveNode);
+            if (!fieldsArg) {
+                return;
+            }
+            const printedFieldsValue = (0, printer_js_1.print)(fieldsArg.value);
+            if (fieldsArg.value.kind !== graphql_1.Kind.STRING) {
+                context.reportError(new graphql_1.GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): Invalid value for argument "fields": must be a string.`, {
+                    nodes: directiveNode,
+                    extensions: {
+                        code: 'KEY_INVALID_FIELDS_TYPE',
+                    },
+                }));
+                return;
+            }
+            let selectionSet;
+            try {
+                selectionSet = (0, helpers_js_1.parseFields)(fieldsArg.value.value);
+            }
+            catch (error) {
+                if (error instanceof graphql_1.GraphQLError) {
+                    context.reportError(new graphql_1.GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): ${error.message}`, {
+                        nodes: directiveNode,
+                        extensions: {
+                            code: 'KEY_INVALID_FIELDS',
+                        },
+                    }));
+                    return;
+                }
+                throw error;
+            }
+            if (!selectionSet) {
+                return;
+            }
+            const knownObjectsAndInterfaces = context.getSubgraphObjectOrInterfaceTypes();
+            let isValid = true;
+            const fieldsUsedInKey = new Set();
+            (0, helpers_js_1.visitFields)({
+                context,
+                selectionSet,
+                typeDefinition: typeDef,
+                interceptField(info) {
+                    if (info.typeDefinition.name.value === typeDef.name.value) {
+                        fieldsUsedInKey.add(info.fieldName);
+                        context.markAsKeyField(`${info.typeDefinition.name}.${info.fieldName}`);
+                    }
+                },
+                interceptUnknownField(info) {
+                    isValid = false;
+                    context.reportError(new graphql_1.GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): Cannot query field "${info.fieldName}" on type "${info.typeDefinition.name.value}" (the field should either be added to this subgraph or, if it should not be resolved by this subgraph, you need to add it to this subgraph with @external).`, { nodes: directiveNode, extensions: { code: 'KEY_INVALID_FIELDS' } }));
+                },
+                interceptDirective(info) {
+                    isValid = false;
+                    if (info.isKnown) {
+                        context.reportError(new graphql_1.GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): cannot have directive applications in the @key(fields:) argument but found @${info.directiveName}.`, {
+                            nodes: directiveNode,
+                            extensions: { code: 'KEY_DIRECTIVE_IN_FIELDS_ARG' },
+                        }));
+                    }
+                    else {
+                        context.reportError(new graphql_1.GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): Unknown directive "@${info.directiveName}"`, {
+                            nodes: directiveNode,
+                            extensions: { code: 'KEY_INVALID_FIELDS' },
+                        }));
+                    }
+                },
+                interceptArguments(info) {
+                    isValid = false;
+                    context.reportError(new graphql_1.GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): field ${info.typeDefinition.name.value}.${info.fieldName} cannot be included because it has arguments (fields with argument are not allowed in @key)`, { nodes: directiveNode, extensions: { code: 'KEY_FIELDS_HAS_ARGS' } }));
+                },
+                interceptInterfaceType(info) {
+                    isValid = false;
+                    context.reportError(new graphql_1.GraphQLError(`On type "${typeCoordinate}", for @key(fields: ${printedFieldsValue}): field "${info.typeDefinition.name.value}.${info.fieldName}" is a Interface type which is not allowed in @key`, { nodes: directiveNode, extensions: { code: 'KEY_FIELDS_SELECT_INVALID_TYPE' } }));
+                },
+            });
+            if (usedOnInterface) {
+                const expectedFieldsValue = fieldsArg.value.value;
+                knownObjectsAndInterfaces.forEach(def => {
+                    if (def.interfaces?.some(i => i.name.value === typeDef.name.value)) {
+                        let shouldError = true;
+                        const keyDirectives = def.directives?.filter(d => context.isAvailableFederationDirective('key', d));
+                        if (!!keyDirectives?.length) {
+                            for (const keyDirective of keyDirectives) {
+                                const fieldsArg = (0, helpers_js_1.getFieldsArgument)(keyDirective);
+                                if (fieldsArg &&
+                                    fieldsArg.value.kind === graphql_1.Kind.STRING &&
+                                    fieldsArg.value.value === expectedFieldsValue) {
+                                    shouldError = false;
+                                }
+                            }
+                        }
+                        if (shouldError && context.satisfiesVersionRange('> v1.0')) {
+                            isValid = false;
+                            context.reportError(new graphql_1.GraphQLError(`Key @key(fields: ${printedFieldsValue}) on interface type "${typeDef.name.value}" is missing on implementation type "${def.name.value}".`, {
+                                nodes: directiveNode,
+                                extensions: { code: 'INTERFACE_KEY_NOT_ON_IMPLEMENTATION' },
+                            }));
+                        }
+                    }
+                });
+            }
+            if (isValid) {
+                const resolvableArgValue = directiveNode.arguments?.find(arg => arg.name.value === 'resolvable' && arg.value.kind === graphql_1.Kind.BOOLEAN)?.value;
+                const resolvable = resolvableArgValue?.value ?? true;
+                if (usedOnInterface) {
+                    context.stateBuilder.interfaceType.setKey(typeDef.name.value, fieldsArg.value.value, fieldsUsedInKey, resolvable);
+                    return;
+                }
+                context.stateBuilder.objectType.setKey(typeDef.name.value, fieldsArg.value.value, fieldsUsedInKey, resolvable);
+            }
+        },
+    };
+}
+exports.KeyRules = KeyRules;

package/cjs/subgraph/validation/rules/elements/override.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverrideRules = void 0;
+const graphql_1 = require("graphql");
+const helpers_js_1 = require("../../../helpers.js");
+function OverrideRules(context) {
+    return {
+        DirectiveDefinition(node) {
+            (0, helpers_js_1.validateDirectiveAgainstOriginal)(node, 'override', context);
+        },
+        Directive(node) {
+            if (!context.isAvailableFederationDirective('override', node)) {
+                return;
+            }
+            const fieldDef = context.typeNodeInfo.getFieldDef();
+            const typeDef = context.typeNodeInfo.getTypeDef();
+            if (!fieldDef || !typeDef) {
+                return;
+            }
+            if ((typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_DEFINITION ||
+                typeDef.kind === graphql_1.Kind.INTERFACE_TYPE_EXTENSION) &&
+                context.satisfiesVersionRange('>= v2.3')) {
+                context.reportError(new graphql_1.GraphQLError(`@override cannot be used on field "${typeDef.name.value}.${fieldDef.name.value}" on subgraph "${context.getSubgraphName()}": @override is not supported on interface type fields.`, { nodes: node, extensions: { code: 'OVERRIDE_ON_INTERFACE' } }));
+                return;
+            }
+            const fromArg = node.arguments?.find(arg => arg.name.value === 'from');
+            if (!fromArg || fromArg.value.kind !== graphql_1.Kind.STRING) {
+                return;
+            }
+            if (!typeDef) {
+                throw new Error('Parent type not found but `@override` directive is present on a field.');
+            }
+            const conflictingDirectives = fieldDef.directives?.filter(directive => context.isAvailableFederationDirective('external', directive));
+            if (conflictingDirectives?.length) {
+                conflictingDirectives.forEach(directive => {
+                    context.reportError(new graphql_1.GraphQLError(`@override cannot be used on field "${typeDef.name.value}.${fieldDef.name.value}" on subgraph "${context.getSubgraphName()}" since "${typeDef.name.value}.${fieldDef.name.value}" on "${context.getSubgraphName()}" is marked with directive "@${directive.name.value}"`, {
+                        extensions: {
+                            code: 'OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE',
+                        },
+                    }));
+                });
+            }
+            if (fromArg.value.value === context.getSubgraphName()) {
+                context.reportError(new graphql_1.GraphQLError(`Source and destination subgraphs "${fromArg.value.value}" are the same for overridden field "${typeDef.name.value}.${fieldDef.name.value}"`, { nodes: node, extensions: { code: 'OVERRIDE_FROM_SELF_ERROR' } }));
+            }
+            if (typeDef.kind === graphql_1.Kind.OBJECT_TYPE_DEFINITION ||
+                typeDef.kind === graphql_1.Kind.OBJECT_TYPE_EXTENSION) {
+                context.stateBuilder.objectType.field.setOverride(typeDef.name.value, fieldDef.name.value, fromArg.value.value);
+            }
+            else {
+                context.stateBuilder.interfaceType.field.setOverride(typeDef.name.value, fieldDef.name.value, fromArg.value.value);
+            }
+        },
+    };
+}
+exports.OverrideRules = OverrideRules;