@apollo/federation-internals 2.12.0-preview.3 → 2.12.0

package/src/specs/connectSpec.ts

@@ -1,4 +1,4 @@
-import { DirectiveLocation, GraphQLError } from 'graphql';
+import { DirectiveLocation } from 'graphql';
 import {
   CorePurpose,
   FeatureDefinition,
@@ -7,23 +7,33 @@ import {
   FeatureVersion,
 } from './coreSpec';
 import {
-  Schema,
-  NonNullType,
+  CoreFeature,
   InputObjectType,
-  InputFieldDefinition,
+  isInputObjectType,
+  isNonNullType,
   ListType,
+  NamedType,
+  NonNullType,
+  ScalarType,
+  Schema,
 } from '../definitions';
 import { registerKnownFeature } from '../knownCoreFeatures';
 import {
   createDirectiveSpecification,
   createScalarTypeSpecification,
+  ensureSameTypeKind,
+  InputFieldSpecification,
+  TypeSpecification,
 } from '../directiveAndTypeSpecification';
+import { ERRORS } from '../error';
+import { sameType } from '../types';
+import { assert } from '../utils';
+import { valueEquals, valueToString } from '../values';
 
 export const connectIdentity = 'https://specs.apollo.dev/connect';
 
 const CONNECT = 'connect';
 const SOURCE = 'source';
-const ID = 'id';
 const URL_PATH_TEMPLATE = 'URLPathTemplate';
 const JSON_SELECTION = 'JSONSelection';
 const CONNECT_HTTP = 'ConnectHTTP';
@@ -42,62 +52,47 @@ export class ConnectSpecDefinition extends FeatureDefinition {
       minimumFederationVersion,
     );
 
-    this.registerDirective(
-      createDirectiveSpecification({
-        name: CONNECT,
-        locations: [DirectiveLocation.FIELD_DEFINITION],
-        repeatable: true,
-        // We "compose" these directives using the  `@join__directive` mechanism,
-        // so they do not need to be composed in the way passing `composes: true`
-        // here implies.
-        composes: false,
-      }),
-    );
+    function lookupFeatureTypeInSchema<T extends NamedType>(name: string, kind: T['kind'], schema: Schema, feature?: CoreFeature): T {
+      assert(feature, `Shouldn't be added without being attached to a @connect spec`);
+      const typeName = feature.typeNameInSchema(name);
+      const type = schema.typeOfKind<T>(typeName, kind);
+      assert(type, () => `Expected "${typeName}" to be defined`);
+      return type;
+    }
 
-    this.registerDirective(
-      createDirectiveSpecification({
-        name: SOURCE,
-        locations: [DirectiveLocation.SCHEMA],
-        repeatable: true,
-        composes: false,
-      }),
-    );
 
+    /* scalar URLPathTemplate */
     this.registerType(
-      createScalarTypeSpecification({ name: URL_PATH_TEMPLATE }),
+        createScalarTypeSpecification({ name: URL_PATH_TEMPLATE }),
     );
-    this.registerType(createScalarTypeSpecification({ name: JSON_SELECTION }));
-    this.registerType({ name: CONNECT_HTTP, checkOrAdd: () => [] });
-    this.registerType({ name: SOURCE_HTTP, checkOrAdd: () => [] });
-    this.registerType({ name: HTTP_HEADER_MAPPING, checkOrAdd: () => [] });
-  }
-
-  addElementsToSchema(schema: Schema): GraphQLError[] {
-    /* scalar URLPathTemplate */
-    const URLPathTemplate = this.addScalarType(schema, URL_PATH_TEMPLATE);
-
     /* scalar JSONSelection */
-    const JSONSelection = this.addScalarType(schema, JSON_SELECTION);
+    this.registerType(createScalarTypeSpecification({ name: JSON_SELECTION }));
 
     /*
-      directive @connect(
-        source: String
-        http: ConnectHTTP
-        selection: JSONSelection!
-        entity: Boolean = false
-        errors: ConnectorErrors
-        isSuccess: JSONSelection
-      ) repeatable on FIELD_DEFINITION
-        | OBJECT # added in v0.2, validation enforced in rust
+      input ConnectorErrors {
+        message: JSONSelection
+        extensions: JSONSelection
+      }
     */
-    const connect = this.addDirective(schema, CONNECT).addLocations(
-      DirectiveLocation.FIELD_DEFINITION,
-      DirectiveLocation.OBJECT,
+    this.registerType(
+        createInputObjectTypeSpecification({
+          name: CONNECTOR_ERRORS,
+          inputFieldsFct: (schema, feature) => {
+            const jsonSelectionType =
+                lookupFeatureTypeInSchema<ScalarType>(JSON_SELECTION, 'ScalarType', schema, feature);
+            return [
+              {
+                name: 'message',
+                type: jsonSelectionType
+              },
+              {
+                name: 'extensions',
+                type: jsonSelectionType
+              },
+            ]
+          }
+        })
     );
-    connect.repeatable = true;
-
-    connect.addArgument(SOURCE, schema.stringType());
-    connect.addArgument(ID, schema.stringType());
 
     /*
       input HTTPHeaderMapping {
@@ -106,15 +101,82 @@ export class ConnectSpecDefinition extends FeatureDefinition {
         value: String
       }
     */
-    const HTTPHeaderMapping = schema.addType(
-      new InputObjectType(this.typeNameInSchema(schema, HTTP_HEADER_MAPPING)!),
+    this.registerType(
+        createInputObjectTypeSpecification({
+          name: HTTP_HEADER_MAPPING,
+          inputFieldsFct: (schema) => [
+            {
+              name: 'name',
+              type: new NonNullType(schema.stringType())
+            },
+            {
+              name: 'from',
+              type: schema.stringType()
+            },
+            {
+              name: 'value',
+              type: schema.stringType()
+            },
+          ]
+        })
+    );
+
+    /*
+      input ConnectBatch {
+        maxSize: Int
+      }
+     */
+    this.registerType(
+        createInputObjectTypeSpecification({
+          name: CONNECT_BATCH,
+          inputFieldsFct: (schema) => [
+            {
+              name: 'maxSize',
+              type: schema.intType()
+            }
+          ]
+        })
+    )
+
+    /*
+      input SourceHTTP {
+        baseURL: String!
+        headers: [HTTPHeaderMapping!]
+
+        # added in v0.2
+        path: JSONSelection
+        queryParams: JSONSelection
+      }
+    */
+    this.registerType(
+        createInputObjectTypeSpecification({
+          name: SOURCE_HTTP,
+          inputFieldsFct: (schema, feature) => {
+            const jsonSelectionType =
+                lookupFeatureTypeInSchema<ScalarType>(JSON_SELECTION, 'ScalarType', schema, feature);
+            const httpHeaderMappingType =
+                lookupFeatureTypeInSchema<InputObjectType>(HTTP_HEADER_MAPPING, 'InputObjectType', schema, feature);
+            return [
+              {
+                name: 'baseURL',
+                type: new NonNullType(schema.stringType())
+              },
+              {
+                name: 'headers',
+                type: new ListType(new NonNullType(httpHeaderMappingType))
+              },
+              {
+                name: 'path',
+                type: jsonSelectionType
+              },
+              {
+                name: 'queryParams',
+                type: jsonSelectionType
+              }
+            ];
+          }
+        })
     );
-    HTTPHeaderMapping.addField(new InputFieldDefinition('name')).type =
-      new NonNullType(schema.stringType());
-    HTTPHeaderMapping.addField(new InputFieldDefinition('from')).type =
-      schema.stringType();
-    HTTPHeaderMapping.addField(new InputFieldDefinition('value')).type =
-      schema.stringType();
 
     /*
       input ConnectHTTP {
@@ -128,85 +190,172 @@ export class ConnectSpecDefinition extends FeatureDefinition {
 
         # added in v0.2
         path: JSONSelection
-        query: JSONSelection
+        queryParams: JSONSelection
       }
     */
-    const ConnectHTTP = schema.addType(
-      new InputObjectType(this.typeNameInSchema(schema, CONNECT_HTTP)!),
+    this.registerType(
+      createInputObjectTypeSpecification({
+        name: CONNECT_HTTP,
+        inputFieldsFct: (schema, feature) => {
+          const urlPathTemplateType =
+              lookupFeatureTypeInSchema<ScalarType>(URL_PATH_TEMPLATE, 'ScalarType', schema, feature);
+          const jsonSelectionType =
+              lookupFeatureTypeInSchema<ScalarType>(JSON_SELECTION, 'ScalarType', schema, feature);
+          const httpHeaderMappingType =
+              lookupFeatureTypeInSchema<InputObjectType>(HTTP_HEADER_MAPPING, 'InputObjectType', schema, feature);
+          return [
+            {
+              name: 'GET',
+              type: urlPathTemplateType
+            },
+            {
+              name: 'POST',
+              type: urlPathTemplateType
+            },
+            {
+              name: 'PUT',
+              type: urlPathTemplateType
+            },
+            {
+              name: 'PATCH',
+              type: urlPathTemplateType
+            },
+            {
+              name: 'DELETE',
+              type: urlPathTemplateType
+            },
+            {
+              name: 'body',
+              type: jsonSelectionType
+            },
+            {
+              name: 'headers',
+              type: new ListType(new NonNullType(httpHeaderMappingType))
+            },
+            {
+              name: 'path',
+              type: jsonSelectionType
+            },
+            {
+              name: 'queryParams',
+              type: jsonSelectionType
+            },
+          ];
+        }
+      })
     );
-    ConnectHTTP.addField(new InputFieldDefinition('GET')).type =
-      URLPathTemplate;
-    ConnectHTTP.addField(new InputFieldDefinition('POST')).type =
-      URLPathTemplate;
-    ConnectHTTP.addField(new InputFieldDefinition('PUT')).type =
-      URLPathTemplate;
-    ConnectHTTP.addField(new InputFieldDefinition('PATCH')).type =
-      URLPathTemplate;
-    ConnectHTTP.addField(new InputFieldDefinition('DELETE')).type =
-      URLPathTemplate;
-    ConnectHTTP.addField(new InputFieldDefinition('body')).type = JSONSelection;
-    ConnectHTTP.addField(new InputFieldDefinition('headers')).type =
-      new ListType(new NonNullType(HTTPHeaderMapping));
-
-    ConnectHTTP.addField(new InputFieldDefinition('path')).type = JSONSelection;
-    ConnectHTTP.addField(new InputFieldDefinition('queryParams')).type =
-      JSONSelection;
-
-    connect.addArgument('http', new NonNullType(ConnectHTTP));
-
-    const ConnectBatch  = schema.addType(new InputObjectType(this.typeNameInSchema(schema, CONNECT_BATCH)!));
-    ConnectBatch.addField(new InputFieldDefinition('maxSize')).type = schema.intType();
-    connect.addArgument('batch', ConnectBatch);
-
-    const ConnectorErrors  = schema.addType(new InputObjectType(this.typeNameInSchema(schema, CONNECTOR_ERRORS)!));
-    ConnectorErrors.addField(new InputFieldDefinition('message')).type = JSONSelection;
-    ConnectorErrors.addField(new InputFieldDefinition('extensions')).type = JSONSelection;
-    connect.addArgument('errors', ConnectorErrors);
-
-    connect.addArgument('selection', new NonNullType(JSONSelection));
-    connect.addArgument('entity', schema.booleanType(), false);
-    connect.addArgument('isSuccess', JSONSelection);
 
     /*
-      directive @source(
-        name: String!
-        http: ConnectHTTP
+      directive @connect(
+        source: String
+        id: String
+        http: ConnectHTTP!
+        batch: ConnectBatch
         errors: ConnectorErrors
+        selection: JSONSelection!
+        entity: Boolean = false
         isSuccess: JSONSelection
-      ) repeatable on SCHEMA
+      ) repeatable on FIELD_DEFINITION
+        | OBJECT # added in v0.2, validation enforced in rust
     */
-    const source = this.addDirective(schema, SOURCE).addLocations(
-      DirectiveLocation.SCHEMA,
+    this.registerDirective(
+      createDirectiveSpecification({
+        name: CONNECT,
+        locations: [DirectiveLocation.FIELD_DEFINITION, DirectiveLocation.OBJECT],
+        repeatable: true,
+        args: [
+          {
+            name: 'source',
+            type: (schema) => schema.stringType()
+          },
+          {
+            name: 'id',
+            type: (schema) => schema.stringType()
+          },
+          {
+            name: 'http',
+            type: (schema, feature) => {
+              const connectHttpType =
+                  lookupFeatureTypeInSchema<InputObjectType>(CONNECT_HTTP, 'InputObjectType', schema, feature);
+              return new NonNullType(connectHttpType);
+            }
+          },
+          {
+            name: 'batch',
+            type: (schema, feature) =>
+                lookupFeatureTypeInSchema<InputObjectType>(CONNECT_BATCH, 'InputObjectType', schema, feature)
+          },
+          {
+            name: 'errors',
+            type: (schema, feature) =>
+                lookupFeatureTypeInSchema<InputObjectType>(CONNECTOR_ERRORS, 'InputObjectType', schema, feature)
+          },
+          {
+            name: 'selection',
+            type: (schema, feature) => {
+              const jsonSelectionType =
+                  lookupFeatureTypeInSchema<ScalarType>(JSON_SELECTION, 'ScalarType', schema, feature);
+              return new NonNullType(jsonSelectionType);
+            }
+          },
+          {
+            name: 'entity',
+            type: (schema) => schema.booleanType(),
+            defaultValue: false
+          },
+          {
+            name: 'isSuccess',
+            type: (schema, feature) =>
+                lookupFeatureTypeInSchema<ScalarType>(JSON_SELECTION, 'ScalarType', schema, feature)
+          }
+        ],
+        // We "compose" these directives using the  `@join__directive` mechanism,
+        // so they do not need to be composed in the way passing `composes: true`
+        // here implies.
+        composes: false,
+      }),
     );
-    source.repeatable = true;
-    source.addArgument('name', new NonNullType(schema.stringType()));
 
     /*
-      input SourceHTTP {
-        baseURL: String!
-        headers: [HTTPHeaderMapping!]
-
-        # added in v0.2
-        path: JSONSelection
-        query: JSONSelection
-      }
+      directive @source(
+        name: String!
+        http: SourceHTTP!
+        errors: ConnectorErrors
+        isSuccess: JSONSelection
+      ) repeatable on SCHEMA
     */
-    const SourceHTTP = schema.addType(
-      new InputObjectType(this.typeNameInSchema(schema, SOURCE_HTTP)!),
+    this.registerDirective(
+      createDirectiveSpecification({
+        name: SOURCE,
+        locations: [DirectiveLocation.SCHEMA],
+        repeatable: true,
+        composes: false,
+        args: [
+          {
+            name: 'name',
+            type: (schema) => new NonNullType(schema.stringType())
+          },
+          {
+            name: 'http',
+            type: (schema, feature) => {
+              const sourceHttpType =
+                  lookupFeatureTypeInSchema<InputObjectType>(SOURCE_HTTP, 'InputObjectType', schema, feature);
+              return new NonNullType(sourceHttpType);
+            }
+          },
+          {
+            name: 'errors',
+            type: (schema, feature) =>
+                lookupFeatureTypeInSchema<InputObjectType>(CONNECTOR_ERRORS, 'InputObjectType', schema, feature)
+          },
+          {
+            name: 'isSuccess',
+            type: (schema, feature) =>
+                lookupFeatureTypeInSchema<ScalarType>(JSON_SELECTION, 'ScalarType', schema, feature)
+          }
+        ]
+      }),
     );
-    SourceHTTP.addField(new InputFieldDefinition('baseURL')).type =
-      new NonNullType(schema.stringType());
-    SourceHTTP.addField(new InputFieldDefinition('headers')).type =
-      new ListType(new NonNullType(HTTPHeaderMapping));
-
-    SourceHTTP.addField(new InputFieldDefinition('path')).type = JSONSelection;
-    SourceHTTP.addField(new InputFieldDefinition('queryParams')).type = JSONSelection;
-
-    source.addArgument('http', new NonNullType(SourceHTTP));
-    source.addArgument('errors', ConnectorErrors);
-    source.addArgument('isSuccess', JSONSelection);
-
-    return [];
   }
 
   get defaultCorePurpose(): CorePurpose {
@@ -237,3 +386,108 @@ export const CONNECT_VERSIONS = new FeatureDefinitions<ConnectSpecDefinition>(
   );
 
 registerKnownFeature(CONNECT_VERSIONS);
+
+// This function is purposefully declared only in this file and without export.
+//
+// Do NOT add this to "internals-js/src/directiveAndTypeSpecification.ts", and
+// do NOT export this function.
+//
+// Subgraph schema building, at this time of writing, does not really support
+// input objects in specs. We did a number of one-off things to support them in
+// the connect spec's case, and it will be non-maintainable/bug-prone to do them
+// again.
+// 
+// There's work to be done to support input objects more generally; please see
+// https://github.com/apollographql/federation/pull/3311 for more information. 
+function createInputObjectTypeSpecification({
+  name,
+  inputFieldsFct,
+}: {
+  name: string,
+  inputFieldsFct: (schema: Schema, feature?: CoreFeature) => InputFieldSpecification[],
+}): TypeSpecification {
+  return {
+    name,
+    checkOrAdd: (schema: Schema, feature?: CoreFeature, asBuiltIn?: boolean) => {
+      const actualName = feature?.typeNameInSchema(name) ?? name;
+      const expectedFields = inputFieldsFct(schema, feature);
+      const existing = schema.type(actualName);
+      if (existing) {
+        let errors = ensureSameTypeKind('InputObjectType', existing);
+        if (errors.length > 0) {
+          return errors;
+        }
+        assert(isInputObjectType(existing), 'Should be an input object type');
+        // The following mimics `ensureSameArguments()`, but with some changes.
+        for (const { name: fieldName, type, defaultValue } of expectedFields) {
+          const existingField = existing.field(fieldName);
+          if (!existingField) {
+            // Not declaring an optional input field is ok: that means you won't
+            // be able to pass a non-default value in your schema, but we allow
+            // you that. But missing a required input field it not ok.
+            if (isNonNullType(type) && defaultValue === undefined) {
+              errors.push(ERRORS.TYPE_DEFINITION_INVALID.err(
+                `Invalid definition for type ${name}: missing required input field "${fieldName}"`,
+                { nodes: existing.sourceAST },
+              ));
+            }
+            continue;
+          }
+
+          let existingType = existingField.type!;
+          if (isNonNullType(existingType) && !isNonNullType(type)) {
+            // It's ok to redefine an optional input field as mandatory. For
+            // instance, if you want to force people on your team to provide a
+            // "maxSize", you can redefine ConnectBatch as
+            // `input ConnectBatch { maxSize: Int! }` to get validation. In
+            // other words, you are allowed to always pass an input field that
+            // is optional if you so wish.
+            existingType = existingType.ofType;
+          }
+          // Note that while `ensureSameArguments()` allows input type
+          // redefinitions (e.g. allowing users to declare `String` instead of a
+          // custom scalar), this behavior can be confusing/error-prone more
+          // generally, so we forbid this for now. We can relax this later on a
+          // case-by-case basis if needed.
+          //
+          // Further, `ensureSameArguments()` would skip default value checking
+          // if the input type was non-nullable. It's unclear why this is there;
+          // it may have been a mistake due to the impression that non-nullable
+          // inputs can't have default values (they can), or this may have been
+          // to avoid some breaking change, but there's no such limitation in
+          // the case of input objects, so we always validate default values
+          // here.
+          if (!sameType(type, existingType)) {
+            errors.push(ERRORS.TYPE_DEFINITION_INVALID.err(
+              `Invalid definition for type ${name}: input field "${fieldName}" should have type "${type}" but found type "${existingField.type!}"`,
+              { nodes: existingField.sourceAST },
+            ));
+          } else if (!valueEquals(defaultValue, existingField.defaultValue)) {
+            errors.push(ERRORS.TYPE_DEFINITION_INVALID.err(
+              `Invalid definition type ${name}: input field "${fieldName}" should have default value ${valueToString(defaultValue)} but found default value ${valueToString(existingField.defaultValue)}`,
+              { nodes: existingField.sourceAST },
+            ));
+          }
+        }
+        for (const existingField of existing.fields()) {
+          // If it's an expected input field, we already validated it. But we
+          // still need to reject unknown input fields.
+          if (!expectedFields.some((field) => field.name === existingField.name)) {
+            errors.push(ERRORS.TYPE_DEFINITION_INVALID.err(
+              `Invalid definition for type ${name}: unknown/unsupported input field "${existingField.name}"`,
+              { nodes: existingField.sourceAST },
+            ));
+          }
+        }
+        return errors;
+      } else {
+        const createdType = schema.addType(new InputObjectType(actualName, asBuiltIn));
+        for (const { name, type, defaultValue } of expectedFields) {
+          const newField = createdType.addField(name, type);
+          newField.defaultValue = defaultValue;
+        }
+        return [];
+      }
+    },
+  }
+}

package/src/specs/policySpec.ts

@@ -6,7 +6,7 @@ import {
   FeatureUrl,
   FeatureVersion,
 } from "./coreSpec";
-import { ListType, NonNullType } from "../definitions";
+import {DirectiveDefinition, ListType, NonNullType, Schema} from "../definitions";
 import { createDirectiveSpecification, createScalarTypeSpecification } from "../directiveAndTypeSpecification";
 import { registerKnownFeature } from "../knownCoreFeatures";
 import { ARGUMENT_COMPOSITION_STRATEGIES } from "../argumentCompositionStrategies";
@@ -42,7 +42,7 @@ export class PolicySpecDefinition extends FeatureDefinition {
           assert(PolicyType, () => `Expected "${policyName}" to be defined`);
           return new NonNullType(new ListType(new NonNullType(new ListType(new NonNullType(PolicyType)))));
         },
-        compositionStrategy: ARGUMENT_COMPOSITION_STRATEGIES.UNION,
+        compositionStrategy: ARGUMENT_COMPOSITION_STRATEGIES.DNF_CONJUNCTION,
       }],
       locations: [
         DirectiveLocation.FIELD_DEFINITION,
@@ -56,6 +56,10 @@ export class PolicySpecDefinition extends FeatureDefinition {
     }));
   }
 
+  policyDirective(schema: Schema): DirectiveDefinition<{policies: string[][]}> | undefined {
+    return this.directive(schema, PolicySpecDefinition.directiveName);
+  }
+
   get defaultCorePurpose(): CorePurpose {
     return 'SECURITY';
   }

package/src/specs/requiresScopesSpec.ts

@@ -6,7 +6,7 @@ import {
   FeatureUrl,
   FeatureVersion,
 } from "./coreSpec";
-import { ListType, NonNullType } from "../definitions";
+import {DirectiveDefinition, ListType, NonNullType, Schema} from "../definitions";
 import { createDirectiveSpecification, createScalarTypeSpecification } from "../directiveAndTypeSpecification";
 import { registerKnownFeature } from "../knownCoreFeatures";
 import { ARGUMENT_COMPOSITION_STRATEGIES } from "../argumentCompositionStrategies";
@@ -43,7 +43,7 @@ export class RequiresScopesSpecDefinition extends FeatureDefinition {
           assert(scopeType, () => `Expected "${scopeName}" to be defined`);
           return new NonNullType(new ListType(new NonNullType(new ListType(new NonNullType(scopeType)))));
         },
-        compositionStrategy: ARGUMENT_COMPOSITION_STRATEGIES.UNION,
+        compositionStrategy: ARGUMENT_COMPOSITION_STRATEGIES.DNF_CONJUNCTION,
       }],
       locations: [
         DirectiveLocation.FIELD_DEFINITION,
@@ -57,6 +57,10 @@ export class RequiresScopesSpecDefinition extends FeatureDefinition {
     }));
   }
 
+  requiresScopesDirective(schema: Schema): DirectiveDefinition<{scopes: string[][]}> | undefined {
+    return this.directive(schema, RequiresScopesSpecDefinition.directiveName);
+  }
+
   get defaultCorePurpose(): CorePurpose {
     return 'SECURITY';
   }