@apollo/federation-internals 2.9.0-connectors.9 → 2.9.0

package/src/error.ts

@@ -591,10 +591,123 @@ const INTERFACE_KEY_MISSING_IMPLEMENTATION_TYPE = makeCodeDefinition(
   { addedIn: '2.3.0' },
 )
 
+const SOURCE_FEDERATION_VERSION_REQUIRED = makeCodeDefinition(
+  'SOURCE_FEDERATION_VERSION_REQUIRED',
+  'Schemas using `@source{API,Type,Field}` directives must @link-import v2.7 or later of federation',
+  { addedIn: '2.7.1' },
+);
+
+const SOURCE_API_NAME_INVALID = makeCodeDefinition(
+  'SOURCE_API_NAME_INVALID',
+  'Each `@sourceAPI` directive must take a unique and valid name as an argument',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_API_PROTOCOL_INVALID = makeCodeDefinition(
+  'SOURCE_API_PROTOCOL_INVALID',
+  'Each `@sourceAPI` directive must specify exactly one of the known protocols',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_API_HTTP_BASE_URL_INVALID = makeCodeDefinition(
+  'SOURCE_API_HTTP_BASE_URL_INVALID',
+  'The `@sourceAPI` directive must specify a valid http.baseURL',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_HTTP_HEADERS_INVALID = makeCodeDefinition(
+  'SOURCE_HTTP_HEADERS_INVALID',
+  'The `http.headers` argument of `@source*` directives must specify valid HTTP headers',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_TYPE_API_ERROR = makeCodeDefinition(
+  'SOURCE_TYPE_API_ERROR',
+  'The `api` argument of the `@sourceType` directive must match a valid `@sourceAPI` name',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_TYPE_PROTOCOL_INVALID = makeCodeDefinition(
+  'SOURCE_TYPE_PROTOCOL_INVALID',
+  'The `@sourceType` directive must specify the same protocol as its corresponding `@sourceAPI`',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_TYPE_HTTP_METHOD_INVALID = makeCodeDefinition(
+  'SOURCE_TYPE_HTTP_METHOD_INVALID',
+  'The `@sourceType` directive must specify exactly one of `http.GET` or `http.POST`',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_TYPE_HTTP_PATH_INVALID = makeCodeDefinition(
+  'SOURCE_TYPE_HTTP_PATH_INVALID',
+  'The `@sourceType` directive must specify a valid URL template for `http.GET` or `http.POST`',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_TYPE_HTTP_BODY_INVALID = makeCodeDefinition(
+  'SOURCE_TYPE_HTTP_BODY_INVALID',
+  'If the `@sourceType` specifies `http.body`, it must be a valid `JSONSelection`',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_TYPE_ON_NON_OBJECT_OR_NON_ENTITY = makeCodeDefinition(
+  'SOURCE_TYPE_ON_NON_OBJECT_OR_NON_ENTITY',
+  'The `@sourceType` directive must be applied to an object or interface type that also has `@key`',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_TYPE_SELECTION_INVALID = makeCodeDefinition(
+  'SOURCE_TYPE_SELECTION_INVALID',
+  'The `selection` argument of the `@sourceType` directive must be a valid `JSONSelection` that outputs fields of the GraphQL type',
+);
+
+const SOURCE_FIELD_API_ERROR = makeCodeDefinition(
+  'SOURCE_FIELD_API_ERROR',
+  'The `api` argument of the `@sourceField` directive must match a valid `@sourceAPI` name',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_FIELD_PROTOCOL_INVALID = makeCodeDefinition(
+  'SOURCE_FIELD_PROTOCOL_INVALID',
+  'If `@sourceField` specifies a protocol, it must match the corresponding `@sourceAPI` protocol',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_FIELD_HTTP_METHOD_INVALID = makeCodeDefinition(
+  'SOURCE_FIELD_HTTP_METHOD_INVALID',
+  'The `@sourceField` directive must specify at most one of `http.{GET,POST,PUT,PATCH,DELETE}`',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_FIELD_HTTP_PATH_INVALID = makeCodeDefinition(
+  'SOURCE_FIELD_HTTP_PATH_INVALID',
+  'The `@sourceField` directive must specify a valid URL template for `http.{GET,POST,PUT,PATCH,DELETE}`',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_FIELD_HTTP_BODY_INVALID = makeCodeDefinition(
+  'SOURCE_FIELD_HTTP_BODY_INVALID',
+  'If `@sourceField` specifies http.body, it must be a valid `JSONSelection` matching available arguments and fields',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_FIELD_SELECTION_INVALID = makeCodeDefinition(
+  'SOURCE_FIELD_SELECTION_INVALID',
+  'The `selection` argument of the `@sourceField` directive must be a valid `JSONSelection` that outputs fields of the GraphQL type',
+  { addedIn: '2.7.0' },
+);
+
+const SOURCE_FIELD_NOT_ON_ROOT_OR_ENTITY_FIELD = makeCodeDefinition(
+  'SOURCE_FIELD_NOT_ON_ROOT_OR_ENTITY_FIELD',
+  'The `@sourceField` directive must be applied to a field of the `Query` or `Mutation` types, or of an entity type',
+  { addedIn: '2.7.0' },
+);
+
 const CONTEXTUAL_ARGUMENT_NOT_CONTEXTUAL_IN_ALL_SUBGRAPHS = makeCodeDefinition(
-    'CONTEXTUAL_ARGUMENT_NOT_CONTEXTUAL_IN_ALL_SUBGRAPHS',
-    'Argument on field is marked contextual in only some subgraphs',
-    { addedIn: '2.7.0' },
+  'CONTEXTUAL_ARGUMENT_NOT_CONTEXTUAL_IN_ALL_SUBGRAPHS',
+  'Argument on field is marked contextual in only some subgraphs',
+  { addedIn: '2.7.0' },
 );
 
 export const ERROR_CATEGORIES = {
@@ -690,7 +803,27 @@ export const ERRORS = {
   INTERFACE_OBJECT_USAGE_ERROR,
   INTERFACE_KEY_NOT_ON_IMPLEMENTATION,
   INTERFACE_KEY_MISSING_IMPLEMENTATION_TYPE,
-    CONTEXTUAL_ARGUMENT_NOT_CONTEXTUAL_IN_ALL_SUBGRAPHS,
+  // Errors related to @sourceAPI, @sourceType, and/or @sourceField
+  SOURCE_FEDERATION_VERSION_REQUIRED,
+  SOURCE_API_NAME_INVALID,
+  SOURCE_API_PROTOCOL_INVALID,
+  SOURCE_API_HTTP_BASE_URL_INVALID,
+  SOURCE_HTTP_HEADERS_INVALID,
+  SOURCE_TYPE_API_ERROR,
+  SOURCE_TYPE_PROTOCOL_INVALID,
+  SOURCE_TYPE_HTTP_METHOD_INVALID,
+  SOURCE_TYPE_HTTP_PATH_INVALID,
+  SOURCE_TYPE_HTTP_BODY_INVALID,
+  SOURCE_TYPE_ON_NON_OBJECT_OR_NON_ENTITY,
+  SOURCE_TYPE_SELECTION_INVALID,
+  SOURCE_FIELD_API_ERROR,
+  SOURCE_FIELD_PROTOCOL_INVALID,
+  SOURCE_FIELD_HTTP_METHOD_INVALID,
+  SOURCE_FIELD_HTTP_PATH_INVALID,
+  SOURCE_FIELD_HTTP_BODY_INVALID,
+  SOURCE_FIELD_SELECTION_INVALID,
+  SOURCE_FIELD_NOT_ON_ROOT_OR_ENTITY_FIELD,
+  CONTEXTUAL_ARGUMENT_NOT_CONTEXTUAL_IN_ALL_SUBGRAPHS,
 };
 
 const codeDefByCode = Object.values(ERRORS).reduce((obj: {[code: string]: ErrorCodeDefinition}, codeDef: ErrorCodeDefinition) => { obj[codeDef.code] = codeDef; return obj; }, {});

package/src/extractSubgraphsFromSupergraph.ts

@@ -40,7 +40,7 @@ import { parseSelectionSet } from "./operations";
 import fs from 'fs';
 import path from 'path';
 import { validateStringContainsBoolean } from "./utils";
-import { CONTEXT_VERSIONS, ContextSpecDefinition, DirectiveDefinition, errorCauses, isFederationDirectiveDefinedInSchema, printErrors } from ".";
+import { CONTEXT_VERSIONS, ContextSpecDefinition, DirectiveDefinition, FeatureUrl, FederationDirectiveName, SchemaElement, errorCauses, isFederationDirectiveDefinedInSchema, printErrors } from ".";
 
 function filteredTypes(
   supergraph: Schema,
@@ -224,11 +224,13 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema, validateExtra
     }
 
     const types = filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition);
+    const originalDirectiveNames = getApolloDirectiveNames(supergraph);
     const args: ExtractArguments = {
        supergraph,
        subgraphs,
        joinSpec,
        filteredTypes: types,
+       originalDirectiveNames,
        getSubgraph,
        getSubgraphEnumValue,
     };
@@ -292,6 +294,7 @@ type ExtractArguments = {
   subgraphs: Subgraphs,
   joinSpec: JoinSpecDefinition,
   filteredTypes: NamedType[],
+  originalDirectiveNames: Record<string, string>,
   getSubgraph: (application: Directive<any, { graph?: string }>) => Subgraph | undefined,
   getSubgraphEnumValue: (subgraphName: string) => string
 }
@@ -348,7 +351,8 @@ function addAllEmptySubgraphTypes(args: ExtractArguments): TypesInfo {
         for (const application of typeApplications) {
           const subgraph = getSubgraph(application);
           assert(subgraph, () => `Should have found the subgraph for ${application}`);
-          subgraph.schema.addType(newNamedType(type.kind, type.name));
+          const subgraphType = subgraph.schema.addType(newNamedType(type.kind, type.name));
+          propagateDemandControlDirectives(type, subgraphType, subgraph, args.originalDirectiveNames);
         }
         break;
     }
@@ -434,6 +438,8 @@ function extractObjOrItfContent(args: ExtractArguments, info: TypeInfo<ObjectTyp
   const implementsDirective = args.joinSpec.implementsDirective(args.supergraph);
   assert(implementsDirective, '@join__implements should existing for a fed2 supergraph');
 
+  const originalDirectiveNames = args.originalDirectiveNames;
+
   for (const { type, subgraphsInfo } of info) {
     const implementsApplications = type.appliedDirectivesOf(implementsDirective);
     for (const application of implementsApplications) {
@@ -444,13 +450,17 @@ function extractObjOrItfContent(args: ExtractArguments, info: TypeInfo<ObjectTyp
       subgraphInfo.type.addImplementedInterface(args.interface);
     }
 
+    for (const { type: subgraphType, subgraph } of subgraphsInfo.values()) {
+      propagateDemandControlDirectives(type, subgraphType, subgraph, args.originalDirectiveNames);
+    }
+
     for (const field of type.fields()) {
       const fieldApplications = field.appliedDirectivesOf(fieldDirective);
       if (fieldApplications.length === 0) {
         // In fed2 subgraph, no @join__field means that the field is in all the subgraphs in which the type is.
         const isShareable = isObjectType(type) && subgraphsInfo.size > 1;
         for (const { type: subgraphType, subgraph } of subgraphsInfo.values()) {
-          addSubgraphField({ field, type: subgraphType, subgraph, isShareable });
+          addSubgraphField({ field, type: subgraphType, subgraph, isShareable, originalDirectiveNames });
         }
       } else {
         const isShareable = isObjectType(type)
@@ -468,15 +478,58 @@ function extractObjOrItfContent(args: ExtractArguments, info: TypeInfo<ObjectTyp
           }
 
           const { type: subgraphType, subgraph } = subgraphsInfo.get(joinFieldArgs.graph)!;
-          addSubgraphField({ field, type: subgraphType, subgraph, isShareable, joinFieldArgs });
+          addSubgraphField({ field, type: subgraphType, subgraph, isShareable, joinFieldArgs, originalDirectiveNames });
         }
       }
     }
   }
 }
 
+/**
+ * Builds a map of original name to new name for Apollo feature directives. This is
+ * used to handle cases where a directive is renamed via an import statement. For
+ * example, importing a directive with a custom name like
+ * ```graphql
+ * @link(url: "https://specs.apollo.dev/cost/v0.1", import: [{ name: "@cost", as: "@renamedCost" }])
+ * ```
+ * results in a map entry of `cost -> renamedCost` with the `@` prefix removed.
+ * 
+ * If the directive is imported under its default name, that also results in an entry. So,
+ * ```graphql
+ * @link(url: "https://specs.apollo.dev/cost/v0.1", import: ["@cost"])
+ * ```
+ * results in a map entry of `cost -> cost`. This duals as a way to check if a directive
+ * is included in the supergraph schema.
+ * 
+ * **Important:** This map does _not_ include directives imported from identities other
+ * than `specs.apollo.dev`. This helps us avoid extracting directives to subgraphs
+ * when a custom directive's name conflicts with that of a default one.
+ */
+function getApolloDirectiveNames(supergraph: Schema): Record<string, string> {
+  const originalDirectiveNames: Record<string, string> = {};
+  for (const linkDirective of supergraph.schemaDefinition.appliedDirectivesOf("link")) {
+    if (linkDirective.arguments().url && linkDirective.arguments().import) {
+      const url = FeatureUrl.maybeParse(linkDirective.arguments().url);
+      if (!url?.identity.includes("specs.apollo.dev")) {
+        continue;
+      }
+
+      for (const importedDirective of linkDirective.arguments().import) {
+        if (importedDirective.name && importedDirective.as) {
+          originalDirectiveNames[importedDirective.name.replace('@', '')] = importedDirective.as.replace('@', '');
+        } else if (typeof importedDirective === 'string') {
+          originalDirectiveNames[importedDirective.replace('@', '')] = importedDirective.replace('@', '');
+        }
+      }
+    }
+  }
+
+  return originalDirectiveNames;
+}
+
 function extractInputObjContent(args: ExtractArguments, info: TypeInfo<InputObjectType>[]) {
   const fieldDirective = args.joinSpec.fieldDirective(args.supergraph);
+  const originalDirectiveNames = args.originalDirectiveNames;
 
   for (const { type, subgraphsInfo } of info) {
     for (const field of type.fields()) {
@@ -484,7 +537,7 @@ function extractInputObjContent(args: ExtractArguments, info: TypeInfo<InputObje
       if (fieldApplications.length === 0) {
         // In fed2 subgraph, no @join__field means that the field is in all the subgraphs in which the type is.
         for (const { type: subgraphType, subgraph } of subgraphsInfo.values()) {
-          addSubgraphInputField({ field, type: subgraphType, subgraph });
+          addSubgraphInputField({ field, type: subgraphType, subgraph, originalDirectiveNames });
         }
       } else {
         for (const application of fieldApplications) {
@@ -496,7 +549,7 @@ function extractInputObjContent(args: ExtractArguments, info: TypeInfo<InputObje
           }
 
           const { type: subgraphType, subgraph } = subgraphsInfo.get(args.graph)!;
-          addSubgraphInputField({ field, type: subgraphType, subgraph, joinFieldArgs: args});
+          addSubgraphInputField({ field, type: subgraphType, subgraph, joinFieldArgs: args, originalDirectiveNames });
         }
       }
     }
@@ -506,8 +559,13 @@ function extractInputObjContent(args: ExtractArguments, info: TypeInfo<InputObje
 function extractEnumTypeContent(args: ExtractArguments, info: TypeInfo<EnumType>[]) {
   // This was added in join 0.3, so it can genuinely be undefined.
   const enumValueDirective = args.joinSpec.enumValueDirective(args.supergraph);
+  const originalDirectiveNames = args.originalDirectiveNames;
 
   for (const { type, subgraphsInfo } of info) {
+    for (const { type: subgraphType, subgraph } of subgraphsInfo.values()) {
+      propagateDemandControlDirectives(type, subgraphType, subgraph, originalDirectiveNames);
+    }
+
     for (const value of type.values) {
       const enumValueApplications = enumValueDirective ? value.appliedDirectivesOf(enumValueDirective) : [];
       if (enumValueApplications.length === 0) {
@@ -620,6 +678,24 @@ function maybeDumpSubgraphSchema(subgraph: Subgraph): string {
   }
 }
 
+function propagateDemandControlDirectives(source: SchemaElement<any, any>, dest: SchemaElement<any, any>, subgraph: Subgraph, originalDirectiveNames?: Record<string, string>) {
+  const costDirectiveName = originalDirectiveNames?.[FederationDirectiveName.COST];
+  if (costDirectiveName) {
+    const costDirective = source.appliedDirectivesOf(costDirectiveName).pop();
+    if (costDirective) {
+      dest.applyDirective(subgraph.metadata().costDirective().name, costDirective.arguments());
+    }
+  }
+
+  const listSizeDirectiveName = originalDirectiveNames?.[FederationDirectiveName.LIST_SIZE];
+  if (listSizeDirectiveName) {
+    const listSizeDirective = source.appliedDirectivesOf(listSizeDirectiveName).pop();
+    if (listSizeDirective) {
+      dest.applyDirective(subgraph.metadata().listSizeDirective().name, listSizeDirective.arguments());
+    }
+  }
+}
+
 function errorToString(e: any,): string {
   const causes = errorCauses(e);
   return causes ? printErrors(causes) : String(e);
@@ -631,12 +707,14 @@ function addSubgraphField({
   subgraph,
   isShareable,
   joinFieldArgs,
+  originalDirectiveNames,
 }: {
   field: FieldDefinition<ObjectType | InterfaceType>,
   type: ObjectType | InterfaceType,
   subgraph: Subgraph,
   isShareable: boolean,
   joinFieldArgs?: JoinFieldDirectiveArguments,
+  originalDirectiveNames?: Record<string, string>,
 }): FieldDefinition<ObjectType | InterfaceType> {
   const copiedFieldType = joinFieldArgs?.type
     ? decodeType(joinFieldArgs.type, subgraph.schema, subgraph.name)
@@ -644,7 +722,8 @@ function addSubgraphField({
 
   const subgraphField = type.addField(field.name, copiedFieldType);
   for (const arg of field.arguments()) {
-    subgraphField.addArgument(arg.name, copyType(arg.type!, subgraph.schema, subgraph.name), arg.defaultValue);
+    const argDef = subgraphField.addArgument(arg.name, copyType(arg.type!, subgraph.schema, subgraph.name), arg.defaultValue);
+    propagateDemandControlDirectives(arg, argDef, subgraph, originalDirectiveNames)
   }
   if (joinFieldArgs?.requires) {
     subgraphField.applyDirective(subgraph.metadata().requiresDirective(), {'fields': joinFieldArgs.requires});
@@ -689,6 +768,9 @@ function addSubgraphField({
   if (isShareable && !external && !usedOverridden) {
     subgraphField.applyDirective(subgraph.metadata().shareableDirective());
   }
+
+  propagateDemandControlDirectives(field, subgraphField, subgraph, originalDirectiveNames);
+
   return subgraphField;
 }
 
@@ -697,11 +779,13 @@ function addSubgraphInputField({
   type,
   subgraph,
   joinFieldArgs,
+  originalDirectiveNames,
 }: {
   field: InputFieldDefinition,
   type: InputObjectType,
   subgraph: Subgraph,
   joinFieldArgs?: JoinFieldDirectiveArguments,
+  originalDirectiveNames?: Record<string, string>
 }): InputFieldDefinition {
   const copiedType = joinFieldArgs?.type
     ? decodeType(joinFieldArgs?.type, subgraph.schema, subgraph.name)
@@ -709,6 +793,9 @@ function addSubgraphInputField({
 
   const inputField = type.addField(field.name, copiedType);
   inputField.defaultValue = field.defaultValue
+
+  propagateDemandControlDirectives(field, inputField, subgraph, originalDirectiveNames);
+
   return inputField;
 }