@apollo/federation-internals 2.0.0-preview.9 → 2.0.0

package/src/federation.ts

@@ -45,6 +45,7 @@ import { KnownTypeNamesInFederationRule } from "./validation/KnownTypeNamesInFed
 import { buildSchema, buildSchemaFromAST } from "./buildSchema";
 import { parseSelectionSet, selectionOfElement, SelectionSet } from './operations';
 import { TAG_VERSIONS } from "./tagSpec";
+import { INACCESSIBLE_VERSIONS } from "./inaccessibleSpec";
 import {
   errorCodeDef,
   ErrorCodeDefinition,
@@ -79,10 +80,10 @@ import {
 import { defaultPrintOptions, PrintOptions as PrintOptions, printSchema } from "./print";
 import { createObjectTypeSpecification, createScalarTypeSpecification, createUnionTypeSpecification } from "./directiveAndTypeSpecification";
 import { didYouMean, suggestionList } from "./suggestions";
-import { inaccessibleDirectiveSpec } from "./inaccessibleSpec";
 
 const linkSpec = LINK_VERSIONS.latest();
 const tagSpec = TAG_VERSIONS.latest();
+const inaccessibleSpec = INACCESSIBLE_VERSIONS.latest();
 const federationSpec = FEDERATION_VERSIONS.latest();
 
 // We don't let user use this as a subgraph name. That allows us to use it in `query graphs` to name the source of roots
@@ -91,6 +92,8 @@ const federationSpec = FEDERATION_VERSIONS.latest();
 // disallowing it feels like more a good thing than a real restriction).
 export const FEDERATION_RESERVED_SUBGRAPH_NAME = '_';
 
+export const FEDERATION_UNNAMED_SUBGRAPH_NAME = '<unnamed>';
+
 const FEDERATION_OMITTED_VALIDATION_RULES = [
   // We allow subgraphs to declare an extension even if the subgraph itself doesn't have a corresponding definition.
   // The implication being that the definition is in another subgraph.
@@ -287,7 +290,7 @@ export function collectUsedFields(metadata: FederationMetadata): Set<FieldDefini
   );
 
   // Collects all fields used to satisfy an interface constraint
-  for (const itfType of metadata.schema.types<InterfaceType>('InterfaceType')) {
+  for (const itfType of metadata.schema.interfaceTypes()) {
     const runtimeTypes = itfType.possibleRuntimeTypes();
     for (const field of itfType.fields()) {
       for (const runtimeType of runtimeTypes) {
@@ -351,7 +354,7 @@ function validateAllExternalFieldsUsed(metadata: FederationMetadata, errorCollec
 }
 
 function validateNoExternalOnInterfaceFields(metadata: FederationMetadata, errorCollector: GraphQLError[]) {
-  for (const itf of metadata.schema.types<InterfaceType>('InterfaceType')) {
+  for (const itf of metadata.schema.interfaceTypes()) {
     for (const field of itf.fields()) {
       if (metadata.isFieldExternal(field)) {
         errorCollector.push(ERRORS.EXTERNAL_ON_INTERFACE.err({
@@ -565,7 +568,9 @@ export class FederationMetadata {
   }
 
   inaccessibleDirective(): DirectiveDefinition<{}> {
-    return this.getFederationDirective(inaccessibleDirectiveSpec.name);
+    return this.getFederationDirective(
+      inaccessibleSpec.inaccessibleDirectiveSpec.name
+    );
   }
 
   allFederationDirectives(): DirectiveDefinition[] {
@@ -614,6 +619,10 @@ export class FederationMetadata {
 }
 
 export class FederationBlueprint extends SchemaBlueprint {
+  constructor(private readonly withRootTypeRenaming: boolean) {
+    super();
+  }
+
   onAddedCoreFeature(schema: Schema, feature: CoreFeature) {
     super.onAddedCoreFeature(schema, feature);
     if (feature.url.identity === federationIdentity) {
@@ -672,22 +681,24 @@ export class FederationBlueprint extends SchemaBlueprint {
 
     // We rename all root type to their default names (we do here rather than in `prepareValidation` because
     // that can actually fail).
-    for (const k of allSchemaRootKinds) {
-      const type = schema.schemaDefinition.root(k)?.type;
-      const defaultName = defaultRootName(k);
-      if (type && type.name !== defaultName) {
-        // We first ensure there is no other type using the default root name. If there is, this is a
-        // composition error.
-        const existing = schema.type(defaultName);
-        if (existing) {
-          errors.push(ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err({
-            message: `The schema has a type named "${defaultName}" but it is not set as the ${k} root type ("${type.name}" is instead): `
+    if (this.withRootTypeRenaming) {
+      for (const k of allSchemaRootKinds) {
+        const type = schema.schemaDefinition.root(k)?.type;
+        const defaultName = defaultRootName(k);
+        if (type && type.name !== defaultName) {
+          // We first ensure there is no other type using the default root name. If there is, this is a
+          // composition error.
+          const existing = schema.type(defaultName);
+          if (existing) {
+            errors.push(ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err({
+              message: `The schema has a type named "${defaultName}" but it is not set as the ${k} root type ("${type.name}" is instead): `
               + 'this is not supported by federation. '
               + 'If a root type does not use its default name, there should be no other type with that default name.',
-            nodes: sourceASTs(type, existing),
-          }));
+              nodes: sourceASTs(type, existing),
+            }));
+          }
+          type.rename(defaultName);
         }
-        type.rename(defaultName);
       }
     }
 
@@ -772,7 +783,7 @@ export class FederationBlueprint extends SchemaBlueprint {
       }
     }
 
-    for (const itf of schema.types<InterfaceType>('InterfaceType')) {
+    for (const itf of schema.interfaceTypes()) {
       validateInterfaceRuntimeImplementationFieldsTypes(itf, metadata, errors);
     }
 
@@ -829,8 +840,6 @@ export class FederationBlueprint extends SchemaBlueprint {
   }
 }
 
-const federationBlueprint = new FederationBlueprint();
-
 function findUnusedNamedForLinkDirective(schema: Schema): string | undefined {
   if (!schema.directive(linkSpec.url.name)) {
     return undefined;
@@ -946,10 +955,11 @@ export function isEntityType(type: NamedType): boolean {
 export function buildSubgraph(
   name: string,
   url: string,
-  source: DocumentNode | string
+  source: DocumentNode | string,
+  withRootTypeRenaming: boolean = true,
 ): Subgraph {
   const buildOptions = {
-    blueprint: federationBlueprint,
+    blueprint: new FederationBlueprint(withRootTypeRenaming),
     validate: false,
   };
   let subgraph: Subgraph;
@@ -959,7 +969,7 @@ export function buildSubgraph(
       : buildSchemaFromAST(source, buildOptions)
     subgraph = new Subgraph(name, url, schema);
   } catch (e) {
-    if (e instanceof GraphQLError) {
+    if (e instanceof GraphQLError && name !== FEDERATION_UNNAMED_SUBGRAPH_NAME) {
       throw addSubgraphToError(e, name, ERRORS.INVALID_GRAPHQL);
     } else {
       throw e;
@@ -969,7 +979,7 @@ export function buildSubgraph(
 }
 
 export function newEmptyFederation2Schema(): Schema {
-  const schema = new Schema(federationBlueprint);
+  const schema = new Schema(new FederationBlueprint(true));
   setSchemaAsFed2Subgraph(schema);
   return schema;
 }
@@ -1250,7 +1260,7 @@ export const serviceTypeSpec = createObjectTypeSpecification({
 export const entityTypeSpec = createUnionTypeSpecification({
   name: '_Entity',
   membersFct: (schema) => {
-    return schema.types<ObjectType>("ObjectType").filter(isEntityType).map((t) => t.name);
+    return schema.objectTypes().filter(isEntityType).map((t) => t.name);
   },
 });
 
@@ -1311,7 +1321,7 @@ export class Subgraph {
     }
 
     if (!queryType.field(serviceFieldName)) {
-      queryType.addField(serviceFieldName, metadata.serviceType());
+      queryType.addField(serviceFieldName, new NonNullType(metadata.serviceType()));
     }
   }
 

package/src/federationSpec.ts

@@ -14,7 +14,7 @@ import { assert } from "./utils";
 import { TAG_VERSIONS } from "./tagSpec";
 import { federationMetadata } from "./federation";
 import { registerKnownFeature } from "./knownCoreFeatures";
-import { inaccessibleDirectiveSpec } from "./inaccessibleSpec";
+import { INACCESSIBLE_VERSIONS } from "./inaccessibleSpec";
 
 export const federationIdentity = 'https://specs.apollo.dev/federation';
 
@@ -91,7 +91,7 @@ function fieldSetType(schema: Schema): InputType {
 
 export const FEDERATION2_ONLY_SPEC_DIRECTIVES = [
   shareableDirectiveSpec,
-  inaccessibleDirectiveSpec,
+  INACCESSIBLE_VERSIONS.latest().inaccessibleDirectiveSpec,
   overrideDirectiveSpec,
 ];