@apollo/federation-internals 2.1.0-alpha.0 → 2.1.0-alpha.1

package/dist/definitions.js

@@ -256,7 +256,7 @@ function typeFromAST(schema, node) {
         default:
             const type = schema.type(node.name.value);
             if (!type) {
-                throw new graphql_1.GraphQLError(`Unknown type "${node.name.value}"`, node);
+                throw error_2.ERRORS.INVALID_GRAPHQL.err(`Unknown type "${node.name.value}"`, { nodes: node });
             }
             return type;
     }
@@ -365,9 +365,7 @@ class Element {
     onAttached() {
     }
     checkUpdate() {
-        if (!this.isAttached()) {
-            throw error(`Cannot modify detached element ${this}`);
-        }
+        (0, utils_1.assert)(this.isAttached(), () => `Cannot modify detached element ${this}`);
     }
 }
 class Extension {
@@ -404,7 +402,7 @@ class SchemaElement extends Element {
             this.checkUpdate();
             const def = (_a = this.schema().directive(nameOrDef)) !== null && _a !== void 0 ? _a : this.schema().blueprint.onMissingDirectiveDefinition(this.schema(), nameOrDef, args);
             if (!def) {
-                throw this.schema().blueprint.onGraphQLJSValidationError(this.schema(), new graphql_1.GraphQLError(`Unknown directive "@${nameOrDef}".`));
+                throw this.schema().blueprint.onGraphQLJSValidationError(this.schema(), error_2.ERRORS.INVALID_GRAPHQL.err(`Unknown directive "@${nameOrDef}".`));
             }
             if (Array.isArray(def)) {
                 throw (0, exports.ErrGraphQLValidationFailed)(def);
@@ -444,26 +442,20 @@ class SchemaElement extends Element {
         this.removeTypeReference(type);
     }
     checkRemoval() {
-        if (this.isElementBuiltIn() && !Schema.prototype['canModifyBuiltIn'].call(this.schema())) {
-            throw error(`Cannot modify built-in ${this}`);
-        }
+        (0, utils_1.assert)(!this.isElementBuiltIn() || Schema.prototype['canModifyBuiltIn'].call(this.schema()), () => `Cannot modify built-in ${this}`);
     }
     checkUpdate(addedElement) {
         super.checkUpdate();
         if (!Schema.prototype['canModifyBuiltIn'].call(this.schema())) {
             let thisElement = this;
             while (thisElement && thisElement instanceof SchemaElement) {
-                if (thisElement.isElementBuiltIn()) {
-                    throw error(`Cannot modify built-in (or part of built-in) ${this}`);
-                }
+                (0, utils_1.assert)(!thisElement.isElementBuiltIn(), () => `Cannot modify built-in (or part of built-in) ${this}`);
                 thisElement = thisElement.parent;
             }
         }
         if (addedElement && addedElement.isAttached()) {
             const thatSchema = addedElement.schema();
-            if (thatSchema && thatSchema != this.schema()) {
-                throw error(`Cannot add element ${addedElement} to ${this} as it is attached to another schema`);
-            }
+            (0, utils_1.assert)(!thatSchema || thatSchema === this.schema(), () => `Cannot add element ${addedElement} to ${this} as it is attached to another schema`);
         }
     }
 }
@@ -508,9 +500,7 @@ class BaseNamedType extends NamedSchemaElement {
         if (this._extensions.has(extension)) {
             return extension;
         }
-        if (extension.extendedElement) {
-            throw error(`Cannot add extension to type ${this}: it is already added to another type`);
-        }
+        (0, utils_1.assert)(!extension.extendedElement, () => `Cannot add extension to type ${this}: it is already added to another type`);
         this._extensions.add(extension);
         Extension.prototype['setExtendedElement'].call(extension, this);
         this.onModification();
@@ -603,9 +593,6 @@ class NamedSchemaElementWithType extends NamedSchemaElement {
     }
 }
 exports.NamedSchemaElementWithType = NamedSchemaElementWithType;
-function error(message) {
-    return new graphql_1.GraphQLError(message);
-}
 class BaseExtensionMember extends Element {
     ofExtension() {
         return this._extension;
@@ -616,9 +603,7 @@ class BaseExtensionMember extends Element {
     setOfExtension(extension) {
         var _a;
         this.checkUpdate();
-        if (extension && !((_a = this._parent) === null || _a === void 0 ? void 0 : _a.extensions().has(extension))) {
-            throw error(`Cannot set object as part of the provided extension: it is not an extension of parent ${this.parent}`);
-        }
+        (0, utils_1.assert)(!extension || ((_a = this._parent) === null || _a === void 0 ? void 0 : _a.extensions().has(extension)), () => `Cannot set object as part of the provided extension: it is not an extension of parent ${this.parent}`);
         this._extension = extension;
     }
     remove() {
@@ -712,7 +697,7 @@ class CoreFeatures {
         this.add(coreItself);
         const coreDef = (0, coreSpec_1.findCoreSpecVersion)(coreItself.url);
         if (!coreDef) {
-            throw error(`Schema uses unknown version ${coreItself.url.version} of the ${coreItself.url.name} spec`);
+            throw error_2.ERRORS.UNKNOWN_LINK_VERSION.err(`Schema uses unknown version ${coreItself.url.version} of the ${coreItself.url.name} spec`);
         }
         this.coreDefinition = coreDef;
     }
@@ -739,7 +724,7 @@ class CoreFeatures {
         const url = this.coreDefinition.extractFeatureUrl(args);
         const existing = this.byIdentity.get(url.identity);
         if (existing) {
-            throw error(`Duplicate inclusion of feature ${url.identity}`);
+            throw error_2.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);
@@ -986,25 +971,15 @@ class Schema {
     addType(type) {
         const existing = this.type(type.name);
         if (existing) {
-            if (existing.isBuiltIn) {
-            }
-            else {
-                throw error(`Type ${type} already exists in this schema`);
-            }
+            (0, utils_1.assert)(existing.isBuiltIn, () => `Type ${type} already exists in this schema`);
         }
         if (type.isAttached()) {
-            if (type.parent == this) {
-                return type;
-            }
-            throw error(`Cannot add type ${type} to this schema; it is already attached to another schema`);
+            (0, utils_1.assert)(type.parent == this, () => `Cannot add type ${type} to this schema; it is already attached to another schema`);
+            return type;
         }
         if (type.isBuiltIn) {
-            if (!this.isConstructed) {
-                this._builtInTypes.set(type.name, type);
-            }
-            else {
-                throw error(`Cannot add built-in ${type} to this schema (built-ins can only be added at schema construction time)`);
-            }
+            (0, utils_1.assert)(!this.isConstructed, `Cannot add built-in ${type} to this schema (built-ins can only be added at schema construction time)`);
+            this._builtInTypes.set(type.name, type);
         }
         else {
             this._types.set(type.name, type);
@@ -1055,22 +1030,14 @@ class Schema {
     addDirectiveDefinition(directiveOrName) {
         const definition = typeof directiveOrName === 'string' ? new DirectiveDefinition(directiveOrName) : directiveOrName;
         const existing = this.directive(definition.name);
-        if (existing && !existing.isBuiltIn) {
-            throw error(`Directive ${definition} already exists in this schema`);
-        }
+        (0, utils_1.assert)(!existing || existing.isBuiltIn, () => `Directive ${definition} already exists in this schema`);
         if (definition.isAttached()) {
-            if (definition.parent == this) {
-                return definition;
-            }
-            throw error(`Cannot add directive ${definition} to this schema; it is already attached to another schema`);
+            (0, utils_1.assert)(definition.parent == this, () => `Cannot add directive ${definition} to this schema; it is already attached to another schema`);
+            return definition;
         }
         if (definition.isBuiltIn) {
-            if (!this.isConstructed) {
-                this._builtInDirectives.set(definition.name, definition);
-            }
-            else {
-                throw error(`Cannot add built-in ${definition} to this schema (built-ins can only be added at schema construction time)`);
-            }
+            (0, utils_1.assert)(!this.isConstructed, () => `Cannot add built-in ${definition} to this schema (built-ins can only be added at schema construction time)`);
+            this._builtInDirectives.set(definition.name, definition);
         }
         else {
             this._directives.set(definition.name, definition);
@@ -1129,7 +1096,7 @@ class Schema {
     }
     elementByCoordinate(coordinate) {
         if (!coordinate.match(coordinateRegexp)) {
-            throw error(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
+            throw error_2.ERRORS.INVALID_GRAPHQL.err(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
         }
         const argStartIdx = coordinate.indexOf('(');
         const start = argStartIdx < 0 ? coordinate : coordinate.slice(0, argStartIdx);
@@ -1140,7 +1107,7 @@ class Schema {
         const isDirective = typeOrDirectiveName.startsWith('@');
         if (isDirective) {
             if (fieldOrEnumName) {
-                throw error(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
+                throw error_2.ERRORS.INVALID_GRAPHQL.err(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
             }
             const directive = this.directive(typeOrDirectiveName.slice(1));
             return argName ? directive === null || directive === void 0 ? void 0 : directive.argument(argName) : directive;
@@ -1157,16 +1124,16 @@ class Schema {
                     return argName ? field === null || field === void 0 ? void 0 : field.argument(argName) : field;
                 case 'InputObjectType':
                     if (argName) {
-                        throw error(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
+                        throw error_2.ERRORS.INVALID_GRAPHQL.err(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
                     }
                     return type.field(fieldOrEnumName);
                 case 'EnumType':
                     if (argName) {
-                        throw error(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
+                        throw error_2.ERRORS.INVALID_GRAPHQL.err(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
                     }
                     return type.value(fieldOrEnumName);
                 default:
-                    throw error(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
+                    throw error_2.ERRORS.INVALID_GRAPHQL.err(`Invalid argument "${coordinate}: it is not a syntactically valid graphQL coordinate."`);
             }
         }
     }
@@ -1204,7 +1171,7 @@ class SchemaDefinition extends SchemaElement {
         const coreFeatures = schema.coreFeatures;
         if ((0, coreSpec_1.isCoreSpecDirectiveApplication)(applied)) {
             if (coreFeatures) {
-                throw error(`Invalid duplicate application of @core/@link`);
+                throw error_2.ERRORS.INVALID_LINK_DIRECTIVE_USAGE.err(`Invalid duplicate application of @core/@link`);
             }
             const schemaDirective = applied;
             const args = schemaDirective.arguments();
@@ -1235,10 +1202,10 @@ class SchemaDefinition extends SchemaElement {
             this.checkUpdate();
             const obj = this.schema().type(nameOrType);
             if (!obj) {
-                throw new graphql_1.GraphQLError(`Cannot set schema ${rootKind} root to unknown type ${nameOrType}`);
+                throw error_2.ERRORS.INVALID_GRAPHQL.err(`Cannot set schema ${rootKind} root to unknown type ${nameOrType}`);
             }
             else if (obj.kind != 'ObjectType') {
-                throw new graphql_1.GraphQLError(`${defaultRootName(rootKind)} root type must be an Object type${rootKind === 'query' ? '' : ' if provided'}, it cannot be set to ${nameOrType} (an ${obj.kind}).`);
+                throw error_2.ERRORS.INVALID_GRAPHQL.err(`${defaultRootName(rootKind)} root type must be an Object type${rootKind === 'query' ? '' : ' if provided'}, it cannot be set to ${nameOrType} (an ${obj.kind}).`);
             }
             toSet = new RootType(rootKind, obj);
         }
@@ -1267,9 +1234,7 @@ class SchemaDefinition extends SchemaElement {
         if (this._extensions.has(extension)) {
             return extension;
         }
-        if (extension.extendedElement) {
-            throw error(`Cannot add extension to this schema: extension is already added to another schema`);
-        }
+        (0, utils_1.assert)(!extension.extendedElement, 'Cannot add extension to this schema: extension is already added to another schema');
         this._extensions.add(extension);
         Extension.prototype['setExtendedElement'].call(extension, this);
         this.onModification();
@@ -1372,10 +1337,10 @@ class FieldBasedType extends BaseNamedType {
                 this.checkUpdate();
                 const maybeItf = this.schema().type(nameOrItfOrItfImpl);
                 if (!maybeItf) {
-                    throw new graphql_1.GraphQLError(`Cannot implement unknown type ${nameOrItfOrItfImpl}`);
+                    throw error_2.ERRORS.INVALID_GRAPHQL.err(`Cannot implement unknown type ${nameOrItfOrItfImpl}`);
                 }
                 else if (maybeItf.kind != 'InterfaceType') {
-                    throw new graphql_1.GraphQLError(`Cannot implement non-interface type ${nameOrItfOrItfImpl} (of type ${maybeItf.kind})`);
+                    throw error_2.ERRORS.INVALID_GRAPHQL.err(`Cannot implement non-interface type ${nameOrItfOrItfImpl} (of type ${maybeItf.kind})`);
                 }
                 itf = maybeItf;
             }
@@ -1428,10 +1393,10 @@ class FieldBasedType extends BaseNamedType {
             toAdd = nameOrField;
         }
         if (this.field(toAdd.name)) {
-            throw error(`Field ${toAdd.name} already exists on ${this}`);
+            throw error_2.ERRORS.INVALID_GRAPHQL.err(`Field ${toAdd.name} already exists on ${this}`);
         }
         if (type && !isOutputType(type)) {
-            throw error(`Invalid input type ${type} for field ${toAdd.name}: object and interface field types should be output types.`);
+            throw error_2.ERRORS.INVALID_GRAPHQL.err(`Invalid input type ${type} for field ${toAdd.name}: object and interface field types should be output types.`);
         }
         this._fields.set(toAdd.name, toAdd);
         this._cachedNonBuiltInFields = undefined;
@@ -1577,10 +1542,10 @@ class UnionType extends BaseNamedType {
                 this.checkUpdate();
                 const maybeObj = this.schema().type(nameOrTypeOrMember);
                 if (!maybeObj) {
-                    throw new graphql_1.GraphQLError(`Cannot add unknown type ${nameOrTypeOrMember} as member of union type ${this.name}`);
+                    throw error_2.ERRORS.INVALID_GRAPHQL.err(`Cannot add unknown type ${nameOrTypeOrMember} as member of union type ${this.name}`);
                 }
                 else if (maybeObj.kind != 'ObjectType') {
-                    throw new graphql_1.GraphQLError(`Cannot add non-object type ${nameOrTypeOrMember} (of type ${maybeObj.kind}) as member of union type ${this.name}`);
+                    throw error_2.ERRORS.INVALID_GRAPHQL.err(`Cannot add non-object type ${nameOrTypeOrMember} (of type ${maybeObj.kind}) as member of union type ${this.name}`);
                 }
                 obj = maybeObj;
             }
@@ -1720,10 +1685,10 @@ class InputObjectType extends BaseNamedType {
         const toAdd = typeof nameOrField === 'string' ? new InputFieldDefinition(nameOrField) : nameOrField;
         this.checkUpdate(toAdd);
         if (this.field(toAdd.name)) {
-            throw error(`Field ${toAdd.name} already exists on ${this}`);
+            throw error_2.ERRORS.INVALID_GRAPHQL.err(`Field ${toAdd.name} already exists on ${this}`);
         }
         if (type && !isInputType(type)) {
-            throw error(`Invalid output type ${type} for field ${toAdd.name}: input field types should be input types.`);
+            throw error_2.ERRORS.INVALID_GRAPHQL.err(`Invalid output type ${type} for field ${toAdd.name}: input field types should be input types.`);
         }
         this._fields.set(toAdd.name, toAdd);
         this._cachedFieldsArray = undefined;
@@ -1843,15 +1808,15 @@ class FieldDefinition extends NamedSchemaElementWithType {
         const existing = this.argument(toAdd.name);
         if (existing) {
             if (type && existing.type && !(0, types_1.sameType)(type, existing.type)) {
-                throw error(`Argument ${toAdd.name} already exists on field ${this.name} with a different type (${existing.type})`);
+                throw error_2.ERRORS.INVALID_GRAPHQL.err(`Argument ${toAdd.name} already exists on field ${this.name} with a different type (${existing.type})`);
             }
             if (defaultValue && (!existing.defaultValue || !(0, values_1.valueEquals)(defaultValue, existing.defaultValue))) {
-                throw error(`Argument ${toAdd.name} already exists on field ${this.name} with a different default value (${(0, values_1.valueToString)(existing.defaultValue)})`);
+                throw error_2.ERRORS.INVALID_GRAPHQL.err(`Argument ${toAdd.name} already exists on field ${this.name} with a different default value (${(0, values_1.valueToString)(existing.defaultValue)})`);
             }
             return existing;
         }
         if (type && !isInputType(type)) {
-            throw error(`Invalid output type ${type} for argument ${toAdd.name} of ${this}: arguments should be input types.`);
+            throw error_2.ERRORS.INVALID_GRAPHQL.err(`Invalid output type ${type} for argument ${toAdd.name} of ${this}: arguments should be input types.`);
         }
         this._args.set(toAdd.name, toAdd);
         Element.prototype['setParent'].call(toAdd, this);
@@ -1870,9 +1835,7 @@ class FieldDefinition extends NamedSchemaElementWithType {
     setOfExtension(extension) {
         var _a;
         this.checkUpdate();
-        if (extension && !((_a = this._parent) === null || _a === void 0 ? void 0 : _a.extensions().has(extension))) {
-            throw error(`Cannot mark field ${this.name} as part of the provided extension: it is not an extension of field parent type ${this.parent}`);
-        }
+        (0, utils_1.assert)(!extension || ((_a = this._parent) === null || _a === void 0 ? void 0 : _a.extensions().has(extension)), () => `Cannot mark field ${this.name} as part of the provided extension: it is not an extension of field parent type ${this.parent}`);
         this._extension = extension;
         this.onModification();
     }
@@ -1944,9 +1907,7 @@ class InputFieldDefinition extends NamedSchemaElementWithType {
     setOfExtension(extension) {
         var _a;
         this.checkUpdate();
-        if (extension && !((_a = this._parent) === null || _a === void 0 ? void 0 : _a.extensions().has(extension))) {
-            throw error(`Cannot mark field ${this.name} as part of the provided extension: it is not an extension of field parent type ${this.parent}`);
-        }
+        (0, utils_1.assert)(!extension || ((_a = this._parent) === null || _a === void 0 ? void 0 : _a.extensions().has(extension)), () => `Cannot mark field ${this.name} as part of the provided extension: it is not an extension of field parent type ${this.parent}`);
         this._extension = extension;
         this.onModification();
     }
@@ -2039,9 +2000,7 @@ class EnumValue extends NamedSchemaElement {
     setOfExtension(extension) {
         var _a;
         this.checkUpdate();
-        if (extension && !((_a = this._parent) === null || _a === void 0 ? void 0 : _a.extensions().has(extension))) {
-            throw error(`Cannot mark field ${this.name} as part of the provided extension: it is not an extension of field parent type ${this.parent}`);
-        }
+        (0, utils_1.assert)(!extension || ((_a = this._parent) === null || _a === void 0 ? void 0 : _a.extensions().has(extension)), () => `Cannot mark field ${this.name} as part of the provided extension: it is not an extension of enum value parent type ${this.parent}`);
         this._extension = extension;
         this.onModification();
     }
@@ -2100,7 +2059,7 @@ class DirectiveDefinition extends NamedSchemaElement {
             toAdd = nameOrArg;
         }
         if (this.argument(toAdd.name)) {
-            throw error(`Argument ${toAdd.name} already exists on field ${this.name}`);
+            throw error_2.ERRORS.INVALID_GRAPHQL.err(`Argument ${toAdd.name} already exists on field ${this.name}`);
         }
         this._args.set(toAdd.name, toAdd);
         Element.prototype['setParent'].call(toAdd, this);
@@ -2208,9 +2167,7 @@ class Directive extends Element {
             return this._args;
         }
         const definition = this.definition;
-        if (!definition) {
-            throw error(`Cannot include default values for arguments: cannot find directive definition for ${this.name}`);
-        }
+        (0, utils_1.assert)(definition, () => `Cannot include default values for arguments: cannot find directive definition for ${this.name}`);
         const updated = Object.create(null);
         for (const argDef of definition.arguments()) {
             updated[argDef.name] = (0, values_1.withDefaultValues)(this._args[argDef.name], argDef);
@@ -2259,14 +2216,8 @@ class Directive extends Element {
         this.checkUpdate();
         if (extension) {
             const parent = this.parent;
-            if (parent instanceof SchemaDefinition || parent instanceof BaseNamedType) {
-                if (!parent.extensions().has(extension)) {
-                    throw error(`Cannot mark directive ${this.name} as part of the provided extension: it is not an extension of parent ${parent}`);
-                }
-            }
-            else {
-                throw error(`Can only mark directive parts of extensions when directly apply to type or schema definition.`);
-            }
+            (0, utils_1.assert)(parent instanceof SchemaDefinition || parent instanceof BaseNamedType, 'Can only mark directive parts of extensions when directly apply to type or schema definition.');
+            (0, utils_1.assert)(parent.extensions().has(extension), () => `Cannot mark directive ${this.name} as part of the provided extension: it is not an extension of parent ${parent}`);
         }
         this._extension = extension;
         this.onModification();
@@ -2491,7 +2442,7 @@ function variableDefinitionsFromAST(schema, definitionNodes) {
     for (const definitionNode of definitionNodes) {
         if (!definitions.add(variableDefinitionFromAST(schema, definitionNode))) {
             const name = definitionNode.variable.name.value;
-            throw new graphql_1.GraphQLError(`Duplicate definition for variable ${name}`, definitionNodes.filter(n => n.variable.name.value === name));
+            throw error_2.ERRORS.INVALID_GRAPHQL.err(`Duplicate definition for variable ${name}`, { nodes: definitionNodes.filter(n => n.variable.name.value === name) });
         }
     }
     return definitions;
@@ -2501,7 +2452,7 @@ function variableDefinitionFromAST(schema, definitionNode) {
     const variable = new Variable(definitionNode.variable.name.value);
     const type = typeFromAST(schema, definitionNode.type);
     if (!isInputType(type)) {
-        throw new graphql_1.GraphQLError(`Invalid type "${type}" for variable $${variable}: not an input type`, definitionNode.type);
+        throw error_2.ERRORS.INVALID_GRAPHQL.err(`Invalid type "${type}" for variable $${variable}: not an input type`, { nodes: definitionNode.type });
     }
     const def = new VariableDefinition(schema, variable, type, definitionNode.defaultValue ? (0, values_1.valueFromAST)(definitionNode.defaultValue, type) : undefined);
     return def;