@apollo/federation-internals 2.4.9 → 2.5.0

package/src/definitions.ts

@@ -561,10 +561,11 @@ export abstract class SchemaElement<TOwnType extends SchemaElement<any, TParent>
     args?: TApplicationArgs,
     asFirstDirective: boolean = false,
   ): Directive<TOwnType, TApplicationArgs> {
-    let name: string;
+    let toAdd: Directive<TOwnType, TApplicationArgs>;
     if (typeof nameOrDef === 'string') {
       this.checkUpdate();
-      const def = this.schema().directive(nameOrDef) ?? this.schema().blueprint.onMissingDirectiveDefinition(this.schema(), nameOrDef, args);
+      toAdd = new Directive<TOwnType, TApplicationArgs>(nameOrDef, args ?? Object.create(null));
+      const def = this.schema().directive(nameOrDef) ?? this.schema().blueprint.onMissingDirectiveDefinition(this.schema(), toAdd);
       if (!def) {
         throw this.schema().blueprint.onGraphQLJSValidationError(
           this.schema(),
@@ -574,12 +575,10 @@ export abstract class SchemaElement<TOwnType extends SchemaElement<any, TParent>
       if (Array.isArray(def)) {
         throw ErrGraphQLValidationFailed(def);
       }
-      name = nameOrDef;
     } else {
       this.checkUpdate(nameOrDef);
-      name = nameOrDef.name;
+      toAdd = new Directive<TOwnType, TApplicationArgs>(nameOrDef.name, args ?? Object.create(null));
     }
-    const toAdd = new Directive<TOwnType, TApplicationArgs>(name, args ?? Object.create(null));
     Element.prototype['setParent'].call(toAdd, this);
     // TODO: we should typecheck arguments or our TApplicationArgs business is just a lie.
     if (this._appliedDirectives) {
@@ -907,7 +906,7 @@ abstract class BaseExtensionMember<TExtended extends ExtendableElement> extends
 }
 
 export class SchemaBlueprint {
-  onMissingDirectiveDefinition(_schema: Schema, _name: string, _args?: {[key: string]: any}): DirectiveDefinition | GraphQLError[] | undefined {
+  onMissingDirectiveDefinition(_schema: Schema, _directive: Directive): DirectiveDefinition | GraphQLError[] | undefined {
     // No-op by default, but used for federation.
     return undefined;
   }
@@ -1576,6 +1575,22 @@ export class Schema {
     this.isValidated = false;
   }
 
+  /**
+   * Marks the schema as validated _without running actual validation_.
+   * Should obviously only be called when we know the built schema must be valid.
+   *
+   * Note that if `validate` is called after this, then it will exit immediately without validation as
+   * the schema will have been marked as validated. However, if this schema is further modified, then
+   * `invalidate` will be called, after which `validate` would run validation again.
+   */
+  assumeValid() {
+    this.runWithBuiltInModificationAllowed(() => {
+      addIntrospectionFields(this);
+    });
+
+    this.isValidated = true;
+  }
+
   validate() {
     if (this.isValidated) {
       return;
@@ -1609,9 +1624,7 @@ export class Schema {
     const cloned = new Schema(builtIns ?? this.blueprint);
     copy(this, cloned);
     if (this.isValidated) {
-      // TODO: when we do actual validation, no point in redoing it, but we should
-      // at least call builtIns.onValidation() and set the proper isConstructed/isValidated flags.
-      cloned.validate();
+      cloned.assumeValid();
     }
     return cloned;
   }

package/src/directiveAndTypeSpecification.ts

@@ -1,6 +1,7 @@
 import { ASTNode, DirectiveLocation, GraphQLError } from "graphql";
 import {
   ArgumentDefinition,
+  CoreFeature,
   DirectiveDefinition,
   EnumType,
   InputType,
@@ -22,17 +23,17 @@ import { valueEquals, valueToString } from "./values";
 import { sameType } from "./types";
 import { arrayEquals, assert } from "./utils";
 import { ArgumentCompositionStrategy } from "./argumentCompositionStrategies";
-import { FeatureDefinition } from "./coreSpec";
+import { FeatureDefinition, FeatureVersion } from "./coreSpec";
 
 export type DirectiveSpecification = {
   name: string,
-  checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => GraphQLError[],
+  checkOrAdd: (schema: Schema, feature?: CoreFeature, asBuiltIn?: boolean) => GraphQLError[],
   composition?: DirectiveCompositionSpecification,
 }
 
 export type DirectiveCompositionSpecification = {
-  supergraphSpecification: () => FeatureDefinition,
-  argumentsMerger?: (schema: Schema) => ArgumentMerger | GraphQLError,
+  supergraphSpecification: (federationVersion: FeatureVersion) => FeatureDefinition,
+  argumentsMerger?: (schema: Schema, feature: CoreFeature) => ArgumentMerger | GraphQLError,
 }
 
 export type ArgumentMerger = {
@@ -42,12 +43,12 @@ export type ArgumentMerger = {
 
 export type TypeSpecification = {
   name: string,
-  checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => GraphQLError[],
+  checkOrAdd: (schema: Schema, feature?: CoreFeature, asBuiltIn?: boolean) => GraphQLError[],
 }
 
 export type ArgumentSpecification = {
   name: string,
-  type: (schema: Schema, nameInSchema?: string) => InputType | GraphQLError[],
+  type: (schema: Schema, feature?: CoreFeature) => InputType | GraphQLError[],
   defaultValue?: any,
 }
 
@@ -80,17 +81,17 @@ export function createDirectiveSpecification({
   repeatable?: boolean,
   args?: DirectiveArgumentSpecification[],
   composes?: boolean,
-  supergraphSpecification?: () => FeatureDefinition,
+  supergraphSpecification?: (fedVersion: FeatureVersion) => FeatureDefinition,
 }): DirectiveSpecification {
   let composition: DirectiveCompositionSpecification | undefined = undefined;
   if (composes) {
     assert(supergraphSpecification, `Should provide a @link specification to use in supergraph for directive @${name} if it composes`);
     const argStrategies = new Map(args.filter((arg) => arg.compositionStrategy).map((arg) => [arg.name, arg.compositionStrategy!]));
-    let argumentsMerger: ((schema: Schema) => ArgumentMerger | GraphQLError) | undefined = undefined;
+    let argumentsMerger: ((schema: Schema, feature: CoreFeature) => ArgumentMerger | GraphQLError) | undefined = undefined;
     if (argStrategies.size > 0) {
       assert(!repeatable, () => `Invalid directive specification for @${name}: @${name} is repeatable and should not define composition strategy for its arguments`);
       assert(argStrategies.size === args.length, () => `Invalid directive specification for @${name}: not all arguments define a composition strategy`);
-      argumentsMerger = (schema) => {
+      argumentsMerger = (schema, feature) => {
         // Validate that the arguments have compatible types with the declared strategies (a bit unfortunate that we can't do this until
         // we have a schema but well, not a huge deal either).
         for (const { name: argName, type } of args) {
@@ -98,14 +99,14 @@ export function createDirectiveSpecification({
           // Note that we've built `argStrategies` from the declared args and checked that all argument had a strategy, so it would be
           // a bug in the code if we didn't get a strategy (not an issue in the directive declaration).
           assert(strategy, () => `Should have a strategy for ${argName}`);
-          const argType = type(schema);
+          const argType = type(schema, feature);
           // By the time we call this, the directive should have been added to the schema and so getting the type should not raise errors.
           assert(!Array.isArray(argType), () => `Should have gotten error getting type for @${name}(${argName}:), but got ${argType}`)
-          const strategyTypes = strategy.supportedTypes(schema);
-          if (!strategyTypes.some((t) => sameType(t, argType))) {
+          const { valid, supportedMsg } = strategy.isTypeSupported(schema, argType);
+          if (!valid) {
             return new GraphQLError(
               `Invalid composition strategy ${strategy.name} for argument @${name}(${argName}:) of type ${argType}; `
-              + `${strategy.name} only supports type(s) ${strategyTypes.join(', ')}`
+              + `${strategy.name} only supports ${supportedMsg}`
             );
           }
         };
@@ -133,11 +134,11 @@ export function createDirectiveSpecification({
   return {
     name,
     composition,
-    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
-      const actualName = nameInSchema ?? name;
+    checkOrAdd: (schema: Schema, feature?: CoreFeature, asBuiltIn?: boolean) => {
+      const actualName = feature?.directiveNameInSchema(name) ?? name;
       const { resolvedArgs, errors } = args.reduce<{ resolvedArgs: (ResolvedArgumentSpecification & { compositionStrategy?: ArgumentCompositionStrategy })[], errors: GraphQLError[] }>(
         ({ resolvedArgs, errors }, arg) => {
-          const typeOrErrors = arg.type(schema, actualName);
+          const typeOrErrors = arg.type(schema, feature);
           if (Array.isArray(typeOrErrors)) {
             errors.push(...typeOrErrors);
           } else {
@@ -169,8 +170,8 @@ export function createDirectiveSpecification({
 export function createScalarTypeSpecification({ name }: { name: string }): TypeSpecification {
   return {
     name,
-    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
-      const actualName = nameInSchema ?? name;
+    checkOrAdd: (schema: Schema, feature?: CoreFeature, asBuiltIn?: boolean) => {
+      const actualName = feature?.typeNameInSchema(name) ?? name;
       const existing = schema.type(actualName);
       if (existing) {
         return ensureSameTypeKind('ScalarType', existing);
@@ -191,8 +192,8 @@ export function createObjectTypeSpecification({
 }): TypeSpecification {
   return {
     name,
-    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
-      const actualName = nameInSchema ?? name;
+    checkOrAdd: (schema: Schema, feature?: CoreFeature, asBuiltIn?: boolean) => {
+      const actualName = feature?.typeNameInSchema(name) ?? name;
       const expectedFields = fieldsFct(schema);
       const existing = schema.type(actualName);
       if (existing) {
@@ -252,8 +253,8 @@ export function createUnionTypeSpecification({
 }): TypeSpecification {
   return {
     name,
-    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
-      const actualName = nameInSchema ?? name;
+    checkOrAdd: (schema: Schema, feature?: CoreFeature, asBuiltIn?: boolean) => {
+      const actualName = feature?.typeNameInSchema(name) ?? name;
       const existing = schema.type(actualName);
       const expectedMembers = membersFct(schema).sort((n1, n2) => n1.localeCompare(n2));
       if (expectedMembers.length === 0) {
@@ -301,8 +302,8 @@ export function createEnumTypeSpecification({
 }): TypeSpecification {
   return {
     name,
-    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
-      const actualName = nameInSchema ?? name;
+    checkOrAdd: (schema: Schema, feature?: CoreFeature, asBuiltIn?: boolean) => {
+      const actualName = feature?.typeNameInSchema(name) ?? name;
       const existing = schema.type(actualName);
       const expectedValueNames = values.map((v) => v.name).sort((n1, n2) => n1.localeCompare(n2));
       if (existing) {

package/src/error.ts

@@ -58,7 +58,7 @@ export function extractGraphQLErrorOptions(e: GraphQLError): GraphQLErrorOptions
 
 class AggregateGraphQLError extends GraphQLError {
   constructor(
-    code: String,
+    code: string,
     message: string,
     readonly causes: GraphQLError[],
     options?: GraphQLErrorOptions,
@@ -83,7 +83,7 @@ class AggregateGraphQLError extends GraphQLError {
   }
 }
 
-export function aggregateError(code: String, message: string, causes: GraphQLError[]): GraphQLError {
+export function aggregateError(code: string, message: string, causes: GraphQLError[]): GraphQLError {
   return new AggregateGraphQLError(code, message, causes);
 }