@apollo/federation-internals 2.13.2 → 2.14.0

package/dist/definitions.js

@@ -6,6 +6,7 @@ const graphql_1 = require("graphql");
 const coreSpec_1 = require("./specs/coreSpec");
 const utils_1 = require("./utils");
 const values_1 = require("./values");
+const tagSpec_1 = require("./specs/tagSpec");
 const inaccessibleSpec_1 = require("./specs/inaccessibleSpec");
 const print_1 = require("./print");
 const types_1 = require("./types");
@@ -725,6 +726,8 @@ class CoreFeatures {
         this.coreItself = coreItself;
         this.byAlias = new Map();
         this.byIdentity = new Map();
+        this.byImportName = new Map();
+        this.conflictsByAlias = new utils_1.SetMultiMap();
         this.add(coreItself);
         const coreDef = (0, coreSpec_1.findCoreSpecVersion)(coreItself.url);
         if (!coreDef) {
@@ -733,16 +736,44 @@ class CoreFeatures {
         this.coreDefinition = coreDef;
     }
     getByIdentity(identity) {
-        return this.byIdentity.get(identity);
+        var _a;
+        return (_a = this.byIdentity.get(identity)) === null || _a === void 0 ? void 0 : _a[0];
     }
     allFeatures() {
-        return this.byIdentity.values();
+        return [...this.byIdentity.values()].map(([feature]) => feature);
     }
     removeFeature(featureIdentity) {
-        const feature = this.byIdentity.get(featureIdentity);
-        if (feature) {
+        const entry = this.byIdentity.get(featureIdentity);
+        if (entry) {
+            const [feature] = entry;
             this.byIdentity.delete(featureIdentity);
-            this.byAlias.delete(feature.nameInSchema);
+            const alias = feature.nameInSchema;
+            this.byAlias.delete(alias);
+            for (const { name: importInSpec, as } of feature.imports) {
+                const importInSchema = as !== null && as !== void 0 ? as : importInSpec;
+                const isDirective = importInSpec.charAt(0) === "@";
+                const nameInSchema = isDirective
+                    ? importInSchema.slice(1)
+                    : importInSchema;
+                this.byImportName.delete(importInSchema);
+                const split = CoreFeatures.splitPrefixedName(nameInSchema);
+                if (!split) {
+                    continue;
+                }
+                const [splitAlias] = split;
+                if (splitAlias === alias) {
+                    continue;
+                }
+                let conflicts = this.conflictsByAlias.get(importInSchema);
+                if (!conflicts) {
+                    continue;
+                }
+                conflicts.delete(importInSchema);
+                if (conflicts.size) {
+                    continue;
+                }
+                this.conflictsByAlias.delete(importInSchema);
+            }
         }
     }
     maybeAddFeature(directive) {
@@ -753,10 +784,6 @@ class CoreFeatures {
         const typedDirective = directive;
         const args = typedDirective.arguments();
         const url = this.coreDefinition.extractFeatureUrl(args);
-        const existing = this.byIdentity.get(url.identity);
-        if (existing) {
-            throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Duplicate inclusion of feature ${url.identity}`);
-        }
         const imports = (0, coreSpec_1.extractCoreFeatureImports)(url, typedDirective);
         const feature = new CoreFeature(url, (_b = args.as) !== null && _b !== void 0 ? _b : url.name, directive, imports, args.for);
         this.add(feature);
@@ -764,44 +791,404 @@ class CoreFeatures {
         return feature;
     }
     add(feature) {
-        this.byAlias.set(feature.nameInSchema, feature);
-        this.byIdentity.set(feature.url.identity, feature);
+        var _a, _b;
+        const identity = feature.url.identity;
+        if (this.byIdentity.has(identity)) {
+            throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot link feature "${identity}" since it has already been linked in the schema.`);
+        }
+        const alias = feature.nameInSchema;
+        if (!(identity === tagSpec_1.tagIdentity &&
+            alias === 'federation__tag' &&
+            feature.imports.length === 0) &&
+            !(identity === inaccessibleSpec_1.inaccessibleIdentity &&
+                alias === 'federation__inaccessible' &&
+                feature.imports.length === 0)) {
+            if (alias.indexOf('__') !== -1) {
+                throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot link feature "${identity}" as "${alias}" since it contains "__". Please rename to a compliant name via "as".`);
+            }
+        }
+        if (alias.charAt(alias.length - 1) === '_') {
+            throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot link feature "${identity}" as "${alias}" since it ends in "_". Please rename to a compliant name via "as".`);
+        }
+        if (!aliasRegexp.test(alias)) {
+            throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot link feature "${identity}" as "${alias}" since it is not a valid GraphQL name. Please rename to a compliant name via "as".`);
+        }
+        const conflicts = this.conflictsByAlias.get(alias);
+        if (conflicts) {
+            const importInSchema = (_b = (_a = conflicts === null || conflicts === void 0 ? void 0 : conflicts.values()) === null || _a === void 0 ? void 0 : _a.next()) === null || _b === void 0 ? void 0 : _b.value;
+            (0, utils_1.assert)(importInSchema !== undefined, `Unexpectedly empty conflicts set`);
+            const entry = this.byImportName.get(importInSchema);
+            (0, utils_1.assert)(entry, `Unexpectedly cannot find feature for import`);
+            const [conflictFeature, importInSpec] = entry;
+            const conflictIdentity = conflictFeature.url.identity;
+            this.checkTagInaccessibleConflict(conflictIdentity, identity);
+            const importInErrorMessage = importInSchema !== importInSpec
+                ? `"${importInSpec}" as "${importInSchema}"`
+                : `"${importInSpec}"`;
+            throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${conflictIdentity}" since it can be confused with a namespaced name from another linked feature "${identity}". Please rename the import or feature to avoid conflicts via "as".`);
+        }
+        const importInSchema = "@" + alias;
+        const entry = this.byImportName.get(importInSchema);
+        if (entry) {
+            const [conflictFeature, importInSpec] = entry;
+            const conflictIdentity = conflictFeature.url.identity;
+            this.checkTagInaccessibleConflict(conflictIdentity, identity);
+            const importInErrorMessage = importInSchema !== importInSpec
+                ? `"${importInSpec}" as "${importInSchema}"`
+                : `"${importInSpec}"`;
+            throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${conflictIdentity}" since it can be confused with a namespaced name from another linked feature "${identity}". Please rename the import or feature to avoid conflicts via "as".`);
+        }
+        const existingFeature = this.byAlias.get(alias);
+        if (existingFeature !== undefined) {
+            const existingIdentity = existingFeature.url.identity;
+            this.checkTagInaccessibleConflict(existingIdentity, identity);
+            throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot link feature ${identity} as "${alias}" since another feature "${existingIdentity}" already uses that alias. Please rename the feature to avoid conflicts via "as".`);
+        }
+        const importsMap = new Map();
+        for (const { name: importInSpec, as } of feature.imports) {
+            const importInSchema = as !== null && as !== void 0 ? as : importInSpec;
+            const importInErrorMessage = importInSchema !== importInSpec
+                ? `"${importInSpec}" as "${importInSchema}"`
+                : `"${importInSpec}"`;
+            const isDirective = importInSpec.charAt(0) === "@";
+            const nameInSpec = isDirective
+                ? importInSpec.slice(1)
+                : importInSpec;
+            const nameInSchema = isDirective
+                ? importInSchema.slice(1)
+                : importInSchema;
+            const split = CoreFeatures.splitPrefixedName(nameInSchema);
+            if (split) {
+                const [splitAlias, splitNameInSpec] = split;
+                if (splitAlias === alias) {
+                    if (splitNameInSpec !== nameInSpec) {
+                        const splitImportInSpec = isDirective
+                            ? "@" + splitNameInSpec
+                            : splitNameInSpec;
+                        throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${identity}" since it can be confused with the namespaced name for "${splitImportInSpec}". Please rename the import to avoid conflicts via "as".`);
+                    }
+                }
+                else {
+                    const conflictFeature = this.byAlias.get(splitAlias);
+                    if (conflictFeature) {
+                        const conflictIdentity = conflictFeature.url.identity;
+                        this.checkTagInaccessibleConflict(conflictIdentity, identity);
+                        throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${identity}" since it can be confused with a namespaced name from another linked feature "${conflictIdentity}". Please rename the import or feature to avoid conflicts via "as".`);
+                    }
+                    else {
+                        this.conflictsByAlias.add(splitAlias, importInSchema);
+                    }
+                }
+            }
+            if (isDirective) {
+                if (nameInSchema === alias) {
+                    if (nameInSpec !== feature.url.name) {
+                        throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${identity}" since it can be confused with the namespaced name for "@${feature.url.name}". Please rename the import to avoid conflicts via "as".`);
+                    }
+                }
+                else {
+                    const conflictFeature = this.byAlias.get(nameInSchema);
+                    if (conflictFeature) {
+                        const conflictIdentity = conflictFeature.url.identity;
+                        this.checkTagInaccessibleConflict(conflictIdentity, identity);
+                        throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${identity}" since it can be confused with a namespaced name from another linked feature "${conflictIdentity}". Please rename the import or feature to avoid conflicts via "as".`);
+                    }
+                }
+            }
+            const existingImportInSchema = importsMap.get(importInSpec);
+            if (existingImportInSchema === undefined) {
+                importsMap.set(importInSpec, importInSchema);
+            }
+            else {
+                if (existingImportInSchema !== importInSchema) {
+                    throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${identity}" since it was previously imported as "${existingImportInSchema}". Please remove one of these imports.`);
+                }
+            }
+            const entry = this.byImportName.get(importInSchema);
+            if (entry === undefined) {
+                this.byImportName.set(importInSchema, [feature, importInSpec]);
+            }
+            else {
+                const [existingFeature, existingImportInSpec] = entry;
+                const existingIdentity = existingFeature.url.identity;
+                if (existingIdentity !== identity) {
+                    this.checkTagInaccessibleConflict(existingIdentity, identity);
+                    throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${identity}" since it was previously imported from feature "${existingIdentity}". Please rename the import to avoid conflicts via "as".`);
+                }
+                if (existingImportInSpec !== importInSpec) {
+                    throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${identity}" since it was previously imported for "${existingImportInSpec}". Please rename the import to avoid conflicts via "as".`);
+                }
+            }
+        }
+        this.byAlias.set(alias, feature);
+        this.byIdentity.set(identity, [feature, importsMap]);
+    }
+    isAliasValid(alias, identity, importConflictsByIdentity) {
+        if (alias.indexOf('__') !== -1) {
+            return false;
+        }
+        if (alias.charAt(alias.length - 1) === '_') {
+            return false;
+        }
+        if (!nameRegexp.test(alias)) {
+            return false;
+        }
+        for (const [otherIdentity, importConflicts] of importConflictsByIdentity.entries()) {
+            if (identity === otherIdentity) {
+                if (importConflicts.self.has(alias)) {
+                    return false;
+                }
+            }
+            else {
+                if (importConflicts.other.has(alias)) {
+                    return false;
+                }
+            }
+        }
+        if (this.byAlias.has(alias)) {
+            return false;
+        }
+        return true;
+    }
+    static computeAliasConflicts(specAliases, elementNames) {
+        const trieNames = elementNames;
+        const importConflictsByIdentity = new Map();
+        for (const { url, alias, imports } of specAliases) {
+            trieNames.add(alias);
+            const self = new Set();
+            const other = new Set();
+            for (const { name: importInSpec, as } of imports) {
+                const importInSchema = as !== null && as !== void 0 ? as : importInSpec;
+                const isDirective = importInSpec.charAt(0) === "@";
+                const nameInSpec = isDirective
+                    ? importInSpec.slice(1)
+                    : importInSpec;
+                const nameInSchema = isDirective
+                    ? importInSchema.slice(1)
+                    : importInSchema;
+                trieNames.add(nameInSchema);
+                const split = CoreFeatures.splitPrefixedName(nameInSchema);
+                if (split) {
+                    const [splitAlias, splitNameInSpec] = split;
+                    if (splitNameInSpec !== nameInSpec) {
+                        self.add(splitAlias);
+                    }
+                    other.add(splitAlias);
+                }
+                if (isDirective) {
+                    if (nameInSpec !== url.name) {
+                        self.add(nameInSchema);
+                    }
+                    other.add(nameInSchema);
+                }
+            }
+            importConflictsByIdentity.set(url.identity, { self, other });
+        }
+        let prefix = null;
+        let index = 0;
+        let computeUniqueAlias = (specName) => {
+            if (prefix === null) {
+                const aliasStart = [
+                    '_',
+                    'abcdefghijklmnopqrstuvwxyz',
+                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+                ].join('');
+                const aliasContinue = [
+                    'abcdefghijklmnopqrstuvwxyz',
+                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+                    '0123456789',
+                ].join('');
+                const root = { children: new Map(), parent: null, char: '' };
+                for (const name of trieNames) {
+                    let node = root;
+                    for (const char of name) {
+                        let child = node.children.get(char);
+                        if (!child) {
+                            child = { children: new Map(), parent: node, char };
+                            node.children.set(char, child);
+                        }
+                        node = child;
+                    }
+                }
+                const queue = [root];
+                let head = 0;
+                while (prefix === null) {
+                    const possibleChars = head === 0 ? aliasStart : aliasContinue;
+                    const node = queue[head++];
+                    for (const char of possibleChars) {
+                        const child = node.children.get(char);
+                        if (child) {
+                            queue.push(child);
+                        }
+                        else {
+                            const chars = [char];
+                            for (let cur = node; cur === null || cur === void 0 ? void 0 : cur.parent; cur = cur.parent) {
+                                chars.push(cur.char);
+                            }
+                            prefix = chars.reverse().join('');
+                            break;
+                        }
+                    }
+                }
+            }
+            const suffix = specName.replace(/[^a-zA-Z]/g, '');
+            return `${prefix}${index++}${suffix}`;
+        };
+        return {
+            importConflictsByIdentity,
+            computeUniqueAlias,
+        };
+    }
+    checkTagInaccessibleConflict(identity1, identity2) {
+        const federationIdentity = 'https://specs.apollo.dev/federation';
+        const identities = new Set([identity1, identity2]);
+        if (!identities.has(federationIdentity)) {
+            return;
+        }
+        const [directive, identity] = identities.has(tagSpec_1.tagIdentity)
+            ? ['tag', tagSpec_1.tagIdentity]
+            : identities.has(inaccessibleSpec_1.inaccessibleIdentity)
+                ? ['inaccessible', inaccessibleSpec_1.inaccessibleIdentity]
+                : [undefined, undefined];
+        if (directive && identity) {
+            throw error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Please import "@${directive}" from the feature "${federationIdentity}" instead of using "${identity}" to avoid potential unexpected behavior in the future.`);
+        }
     }
     sourceFeature(element) {
         const isDirective = element instanceof DirectiveDefinition || element instanceof Directive;
-        const splitted = element.name.split('__');
-        if (splitted.length > 1) {
-            const feature = this.byAlias.get(splitted[0]);
-            return feature ? {
+        const importName = isDirective ? '@' + element.name : element.name;
+        const entry = this.byImportName.get(importName);
+        if (entry) {
+            const [feature, importInSpec] = entry;
+            return {
                 feature,
-                nameInFeature: splitted.slice(1).join('__'),
-                isImported: false,
-            } : undefined;
+                nameInFeature: isDirective ? importInSpec.slice(1) : importInSpec,
+                isImported: true,
+            };
         }
-        else {
-            const importName = isDirective ? '@' + element.name : element.name;
-            const allFeatures = [this.coreItself, ...this.byIdentity.values()];
-            for (const feature of allFeatures) {
-                for (const { as, name } of feature.imports) {
-                    if ((as !== null && as !== void 0 ? as : name) === importName) {
-                        return {
-                            feature,
-                            nameInFeature: isDirective ? name.slice(1) : name,
-                            isImported: true,
-                        };
+        const defaultEntry = this.sourceDefaultName(isDirective, element.name);
+        if (!defaultEntry) {
+            return undefined;
+        }
+        const [feature, nameInSpec] = defaultEntry;
+        const importInSpec = isDirective ? '@' + nameInSpec : nameInSpec;
+        return {
+            feature,
+            nameInFeature: this.getImportName(feature, importInSpec) === undefined
+                ? nameInSpec
+                : null,
+            isImported: false,
+        };
+    }
+    validateNoShadowingImports(schema) {
+        const errors = [];
+        for (const element of [...schema.allTypes(), ...schema.allDirectives()]) {
+            const shadowingImport = this.getShadowingImport(element);
+            if (!shadowingImport) {
+                continue;
+            }
+            const isUsed = element instanceof DirectiveDefinition
+                ? element.applications().size !== 0
+                : this.getReferencingRootElements(element)
+                    .some((referencer) => {
+                    return referencer.kind === 'SchemaDefinition'
+                        ? true
+                        : !this.getShadowingImport(referencer);
+                });
+            if (!isUsed) {
+                continue;
+            }
+            const { feature, importInSpec, importInSchema } = shadowingImport;
+            const importInErrorMessage = importInSchema !== importInSpec
+                ? `"${importInSpec}" as "${importInSchema}"`
+                : `"${importInSpec}"`;
+            errors.push(error_1.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Cannot import ${importInErrorMessage} from feature "${feature.url.identity}" since there's a used definition for the namespaced name "${element.coordinate}". Please switch usages of the namespaced name to the import name and remove the definition.`));
+        }
+        return errors;
+    }
+    getShadowingImport(element) {
+        const isDirective = element instanceof DirectiveDefinition || element instanceof Directive;
+        const defaultEntry = this.sourceDefaultName(isDirective, element.name);
+        if (!defaultEntry) {
+            return undefined;
+        }
+        const importName = isDirective ? '@' + element.name : element.name;
+        const [feature, nameInSpec] = defaultEntry;
+        const importInSpec = isDirective ? '@' + nameInSpec : nameInSpec;
+        const importInSchema = this.getImportName(feature, importInSpec);
+        return importInSchema !== undefined && importInSchema !== importName
+            ? {
+                feature,
+                importInSpec,
+                importInSchema,
+            }
+            : undefined;
+    }
+    getReferencingRootElements(element) {
+        const referencers = [];
+        for (const referencer of element.referencers()) {
+            switch (referencer.kind) {
+                case 'ObjectType':
+                    referencers.push(referencer);
+                    break;
+                case 'InterfaceType':
+                    referencers.push(referencer);
+                    break;
+                case 'UnionType':
+                    referencers.push(referencer);
+                    break;
+                case 'SchemaDefinition':
+                    referencers.push(referencer);
+                    break;
+                case 'FieldDefinition':
+                    referencers.push(referencer.parent);
+                    break;
+                case 'InputFieldDefinition':
+                    referencers.push(referencer.parent);
+                    break;
+                case 'ArgumentDefinition':
+                    const parent = referencer.parent;
+                    switch (parent.kind) {
+                        case 'DirectiveDefinition':
+                            referencers.push(parent);
+                            break;
+                        case 'FieldDefinition':
+                            referencers.push(parent.parent);
+                            break;
+                        default:
+                            (0, utils_1.assertUnreachable)(parent);
                     }
-                }
+                    break;
+                default:
+                    (0, utils_1.assertUnreachable)(referencer);
             }
-            const directFeature = this.byAlias.get(element.name);
-            if (directFeature && isDirective) {
-                return {
-                    feature: directFeature,
-                    nameInFeature: element.name,
-                    isImported: false,
-                };
+        }
+        return referencers;
+    }
+    getImportName(feature, importInSpec) {
+        var _a, _b;
+        return (_b = (_a = this.byIdentity.get(feature.url.identity)) === null || _a === void 0 ? void 0 : _a[1]) === null || _b === void 0 ? void 0 : _b.get(importInSpec);
+    }
+    sourceDefaultName(isDirective, name) {
+        const split = CoreFeatures.splitPrefixedName(name);
+        if (split) {
+            const [alias, nameInSpec] = split;
+            const feature = this.byAlias.get(alias);
+            if (feature) {
+                return [feature, nameInSpec];
             }
+        }
+        if (!isDirective) {
             return undefined;
         }
+        const feature = this.byAlias.get(name);
+        return feature ? [feature, feature.url.name] : undefined;
+    }
+    static splitPrefixedName(name) {
+        const splitIndex = name.indexOf('__');
+        return splitIndex !== -1
+            ? [name.slice(0, splitIndex), name.slice(splitIndex + 2)]
+            : undefined;
     }
 }
 exports.CoreFeatures = CoreFeatures;
@@ -846,6 +1233,8 @@ const graphQLBuiltInDirectivesSpecifications = [
         ],
     }),
 ];
+const aliasRegexp = /^[_A-Za-z][_0-9A-Za-z.-]*$/;
+const nameRegexp = /^[_A-Za-z][_0-9A-Za-z]*$/;
 const coordinateRegexp = /^@?[_A-Za-z][_0-9A-Za-z]*(\.[_A-Za-z][_0-9A-Za-z]*)?(\([_A-Za-z][_0-9A-Za-z]*:\))?$/;
 class Schema {
     constructor(blueprint = exports.defaultSchemaBlueprint, config = {}) {
@@ -1148,6 +1537,7 @@ class Schema {
         this.isValidated = true;
     }
     validate() {
+        var _a, _b;
         if (this.isValidated) {
             return;
         }
@@ -1156,6 +1546,7 @@ class Schema {
         });
         let errors = (0, validate_1.validateSDL)(this.toAST(), undefined, this.blueprint.validationRules()).map((e) => this.blueprint.onGraphQLJSValidationError(this, e));
         errors = errors.concat((0, validate_2.validateSchema)(this));
+        errors = errors.concat((_b = (_a = this.coreFeatures) === null || _a === void 0 ? void 0 : _a.validateNoShadowingImports(this)) !== null && _b !== void 0 ? _b : []);
         if (errors.length === 0) {
             this.runWithBuiltInModificationAllowed(() => {
                 errors = this.blueprint.onValidation(this);