[resolvers] Refactor to remove NameNode override and simplify federation functions (#10377)

* Remove NameNode override and refactor relevant references

* Simplify federation utils by making functions handle nodes

* Fix lint issue

Author: eddeee888

packages/plugins/other/visitor-plugin-common/src/base-resolvers-visitor.ts

@@ -20,7 +20,6 @@ import {
   isUnionType,
   ListTypeNode,
   NamedTypeNode,
-  NameNode,
   NonNullTypeNode,
   ObjectTypeDefinitionNode,
   ScalarTypeDefinitionNode,
@@ -1495,13 +1494,6 @@ export class BaseResolversVisitor<
     return '';
   }
 
-  // FIXME: this Name method causes a lot of type inconsistencies
-  // because the type of nodes no longer matches the `graphql-js` types
-  // So, we should update this and remove any relevant `as any as string` or `as unknown as string`
-  Name(node: NameNode): string {
-    return node.value;
-  }
-
   ListType(node: ListTypeNode): string {
     const asString = node.type as any as string;
 
@@ -1515,7 +1507,7 @@ export class BaseResolversVisitor<
   }
 
   NamedType(node: NamedTypeNode): string {
-    const nameStr = node.name as any as string;
+    const nameStr = node.name.value;
 
     if (this.config.scalars[nameStr]) {
       return this._getScalar(nameStr);
@@ -1563,10 +1555,10 @@ export class BaseResolversVisitor<
     return {
       node: original,
       printContent: (parentNode, avoidResolverOptionals) => {
-        const parentName = parentNode.name as unknown as string;
+        const parentName = parentNode.name.value;
         const parentType = this.schema.getType(parentName);
         const meta: ReturnType<FieldDefinitionPrintFn>['meta'] = {};
-        const typeName = node.name as unknown as string;
+        const typeName = node.name.value;
 
         const fieldsToGenerate = this._federation.findFieldNodesToGenerate({ node: parentNode });
         const shouldGenerateField =
@@ -1634,7 +1626,7 @@ export class BaseResolversVisitor<
 
           const directiveMappings =
             node.directives
-              ?.map(directive => this._directiveResolverMappings[directive.name as any])
+              ?.map(directive => this._directiveResolverMappings[directive.name.value])
               .filter(Boolean)
               .reverse() ?? [];
 
@@ -1681,8 +1673,8 @@ export class BaseResolversVisitor<
   }
 
   private getFieldContextType(parentName: string, node: FieldDefinitionNode): string {
-    if (this._fieldContextTypeMap[`${parentName}.${node.name}`]) {
-      return this._fieldContextTypeMap[`${parentName}.${node.name}`].type;
+    if (this._fieldContextTypeMap[`${parentName}.${node.name.value}`]) {
+      return this._fieldContextTypeMap[`${parentName}.${node.name.value}`].type;
     }
     return 'ContextType';
   }
@@ -1691,7 +1683,7 @@ export class BaseResolversVisitor<
     let contextType = this.getFieldContextType(parentName, node);
 
     for (const directive of node.directives) {
-      const name = directive.name as unknown as string;
+      const name = directive.name.value;
       const directiveMap = this._directiveContextTypesMap[name];
       if (directiveMap) {
         contextType = `${directiveMap.type}<${contextType}>`;
@@ -1750,7 +1742,7 @@ export class BaseResolversVisitor<
   }
 
   ObjectTypeDefinition(node: ObjectTypeDefinitionNode): string | null {
-    const typeName = node.name as unknown as string;
+    const typeName = node.name.value;
     const fieldsToGenerate = this._federation.findFieldNodesToGenerate({ node });
     if (fieldsToGenerate.length === 0) {
       return null;
@@ -1817,7 +1809,7 @@ export class BaseResolversVisitor<
       .withName(name, `<${genericTypes.join(', ')}>`)
       .withBlock(fieldsContent.join('\n'));
 
-    this._collectedResolvers[node.name as any] = {
+    this._collectedResolvers[node.name.value] = {
       typename: name + '<ContextType>',
       baseGeneratedTypename: name,
     };
@@ -1836,11 +1828,11 @@ export class BaseResolversVisitor<
       .map(f => `'${f}'`)
       .join(' | ');
 
-    this._collectedResolvers[node.name as any] = {
+    this._collectedResolvers[node.name.value] = {
       typename: name + '<ContextType>',
       baseGeneratedTypename: name,
     };
-    const parentType = this.getParentTypeToUse(node.name as any as string);
+    const parentType = this.getParentTypeToUse(node.name.value);
 
     return new DeclarationBlock(this._declarationBlockConfig)
       .export()
@@ -1856,15 +1848,15 @@ export class BaseResolversVisitor<
   }
 
   ScalarTypeDefinition(node: ScalarTypeDefinitionNode): string {
-    const nameAsString = node.name as any as string;
+    const nameAsString = node.name.value;
     const baseName = this.getTypeToUse(nameAsString);
 
     if (this._federation.skipScalar(nameAsString)) {
       return null;
     }
 
     this._hasScalars = true;
-    this._collectedResolvers[node.name as any] = {
+    this._collectedResolvers[node.name.value] = {
       typename: 'GraphQLScalarType',
     };
 
@@ -1882,11 +1874,11 @@ export class BaseResolversVisitor<
         }),
         ` extends GraphQLScalarTypeConfig<${baseName}, any>`
       )
-      .withBlock(indent(`name: '${node.name}'${this.getPunctuation('interface')}`)).string;
+      .withBlock(indent(`name: '${node.name.value}'${this.getPunctuation('interface')}`)).string;
   }
 
   DirectiveDefinition(node: DirectiveDefinitionNode, key: string | number, parent: any): string {
-    if (this._federation.skipDirective(node.name as any)) {
+    if (this._federation.skipDirective(node.name.value)) {
       return null;
     }
 
@@ -1896,7 +1888,7 @@ export class BaseResolversVisitor<
     const sourceNode = parent[key] as DirectiveDefinitionNode;
     const hasArguments = sourceNode.arguments && sourceNode.arguments.length > 0;
 
-    this._collectedDirectiveResolvers[node.name as any] = directiveName + '<any, any, ContextType>';
+    this._collectedDirectiveResolvers[node.name.value] = directiveName + '<any, any, ContextType>';
 
     const directiveArgsTypeName = this.convertName(node, {
       suffix: 'DirectiveArgs',
@@ -1945,7 +1937,7 @@ export class BaseResolversVisitor<
   }
 
   EnumTypeDefinition(node: EnumTypeDefinitionNode): string {
-    const rawTypeName = node.name as any;
+    const rawTypeName = node.name.value;
 
     // If we have enumValues set, and it's point to an external enum - we need to allow internal values resolvers
     // In case we have enumValues set but as explicit values, no need to to do mapping since it's already
@@ -1978,7 +1970,7 @@ export class BaseResolversVisitor<
       suffix: this.config.resolverTypeSuffix,
     });
     const declarationKind = 'type';
-    const typeName = node.name as any as string;
+    const typeName = node.name.value;
     const implementingTypes = Object.keys(this._parsedSchemaMeta.types.interface[typeName].implementingTypes);
 
     this._collectedResolvers[typeName] = {

packages/plugins/typescript/resolvers/src/visitor.ts

@@ -109,7 +109,7 @@ export class TypeScriptResolversVisitor extends BaseResolversVisitor<
 
   protected buildEnumResolverContentBlock(node: EnumTypeDefinitionNode, mappedEnumType: string): string {
     const valuesMap = `{ ${(node.values || [])
-      .map(v => `${v.name as any as string}${this.config.avoidOptionals.resolvers ? '' : '?'}: any`)
+      .map(v => `${v.name.value}${this.config.avoidOptionals.resolvers ? '' : '?'}: any`)
       .join(', ')} }`;
 
     this._globalDeclarations.add(ENUM_RESOLVERS_SIGNATURE);
@@ -123,7 +123,7 @@ export class TypeScriptResolversVisitor extends BaseResolversVisitor<
   ): string {
     return `{ ${(node.values || [])
       .map(v => {
-        const valueName = v.name as any as string;
+        const valueName = v.name.value;
         const mappedValue = valuesMapping[valueName];
 
         return `${valueName}: ${typeof mappedValue === 'number' ? mappedValue : `'${mappedValue}'`}`;

packages/utils/plugins-helpers/src/federation.ts

@@ -9,7 +9,6 @@ import {
   GraphQLObjectType,
   GraphQLSchema,
   InterfaceTypeDefinitionNode,
-  isInterfaceType,
   isObjectType,
   ObjectTypeDefinitionNode,
   OperationDefinitionNode,
@@ -239,7 +238,8 @@ export function addFederationReferencesToSchema(schema: GraphQLSchema): {
 
   const transformedSchema = mapSchema(schema, {
     [MapperKind.INTERFACE_TYPE]: type => {
-      const federationDetails = checkTypeFederationDetails(type, schema);
+      const node = astFromInterfaceType(type, schema);
+      const federationDetails = checkTypeFederationDetails(node, schema);
       if (federationDetails && federationDetails.resolvableKeyDirectives.length > 0) {
         const typeConfig = type.toConfig();
         typeConfig.fields = {
@@ -277,7 +277,8 @@ export function addFederationReferencesToSchema(schema: GraphQLSchema): {
       return type;
     },
     [MapperKind.OBJECT_TYPE]: type => {
-      const federationDetails = checkTypeFederationDetails(type, schema);
+      const node = astFromObjectType(type, schema);
+      const federationDetails = checkTypeFederationDetails(node, schema);
       if (federationDetails && federationDetails.resolvableKeyDirectives.length > 0) {
         const typeConfig = type.toConfig();
 
@@ -417,7 +418,7 @@ export class ApolloFederation {
   }: {
     node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode;
   }): readonly FieldDefinitionNode[] {
-    const nodeName = node.name as unknown as string;
+    const nodeName = node.name.value;
     if (this.fieldsToGenerate[nodeName]) {
       return this.fieldsToGenerate[nodeName];
     }
@@ -496,7 +497,7 @@ export class ApolloFederation {
   }
 
   private hasProvides(node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode, fieldName: string): boolean {
-    const fields = this.providesMap[node.name as unknown as string];
+    const fields = this.providesMap[node.name.value];
 
     if (fields?.length) {
       return fields.includes(fieldName);
@@ -534,22 +535,16 @@ export class ApolloFederation {
  * @param node Type
  */
 function checkTypeFederationDetails(
-  typeOrNode: ObjectTypeDefinitionNode | GraphQLObjectType | InterfaceTypeDefinitionNode | GraphQLInterfaceType,
+  node: ObjectTypeDefinitionNode | InterfaceTypeDefinitionNode,
   schema: GraphQLSchema
 ): { resolvableKeyDirectives: readonly DirectiveNode[] } | false {
-  const node = isObjectType(typeOrNode)
-    ? astFromObjectType(typeOrNode, schema)
-    : isInterfaceType(typeOrNode)
-    ? astFromInterfaceType(typeOrNode, schema)
-    : typeOrNode;
-
-  const name = node.name.value || (typeOrNode.name as unknown as string);
+  const name = node.name.value;
   const directives = node.directives;
 
   const rootTypeNames = getRootTypeNames(schema);
   const isNotRoot = !rootTypeNames.has(name);
   const isNotIntrospection = !name.startsWith('__');
-  const keyDirectives = directives.filter(d => d.name.value === 'key' || (d.name as unknown as string) === 'key');
+  const keyDirectives = directives.filter(d => d.name.value === 'key');
 
   const check = isNotRoot && isNotIntrospection && keyDirectives.length > 0;
 
@@ -576,24 +571,9 @@ function checkTypeFederationDetails(
  */
 function getDirectivesByName(
   name: string,
-  node: ObjectTypeDefinitionNode | GraphQLObjectType | FieldDefinitionNode | InterfaceTypeDefinitionNode
+  node: ObjectTypeDefinitionNode | FieldDefinitionNode | InterfaceTypeDefinitionNode
 ): readonly DirectiveNode[] {
-  let astNode: ObjectTypeDefinitionNode | FieldDefinitionNode | InterfaceTypeDefinitionNode;
-
-  if (isObjectType(node) || isInterfaceType(node)) {
-    astNode = node.astNode;
-  } else {
-    astNode = node;
-  }
-
-  return (
-    astNode?.directives?.filter(d => {
-      // A ObjectTypeDefinitionNode's directive looks like `{ kind: 'Directive', name: 'external', arguments: [] }`
-      // However, other directives looks like `{ kind: 'Directive', name: { kind: 'Name', value: 'external' }, arguments: [] }`
-      // Therefore, we need to check for both `d.name.value` and d.name
-      return d.name.value === name || (d.name as unknown as string) === name;
-    }) || []
-  );
+  return node?.directives?.filter(d => d.name.value === name) || [];
 }
 
 function extractReferenceSelectionSet(directive: DirectiveNode): ReferenceSelectionSet {