TypeScript graphql.isNamedType函数代码示例

 const resolveType = <T extends GraphQLType>(type: T): T | GraphQLType => {
   if (type instanceof GraphQLList) {
     const innerType = resolveType(type.ofType);
     if (innerType === null) {
       return null;
     } else {
       return new GraphQLList(innerType) as T;
     }
   } else if (type instanceof GraphQLNonNull) {
     const innerType = resolveType(type.ofType);
     if (innerType === null) {
       return null;
     } else {
       return new GraphQLNonNull(innerType) as T;
     }
   } else if (isNamedType(type)) {
     const typeName = getNamedType(type).name;
     switch (typeName) {
       case GraphQLInt.name:
         return GraphQLInt;
       case GraphQLFloat.name:
         return GraphQLFloat;
       case GraphQLString.name:
         return GraphQLString;
       case GraphQLBoolean.name:
         return GraphQLBoolean;
       case GraphQLID.name:
         return GraphQLID;
       default:
         return getType(typeName, type);
     }
   } else {
     return type;
   }
 };

 public resolveType<T extends GraphQLType>(type: T): T {
   if (type instanceof GraphQLList) {
     return new GraphQLList(this.resolveType(type.ofType)) as T;
   } else if (type instanceof GraphQLNonNull) {
     return new GraphQLNonNull(this.resolveType(type.ofType)) as T;
   } else if (isNamedType(type)) {
     return this.getType(getNamedType(type).name) as T;
   } else {
     return type;
   }
 }

export default function isSpecifiedScalarType(type: any): boolean {
  return (
    isNamedType(type) &&
    // Would prefer to use specifiedScalarTypes.some(), however %checks needs
    // a simple expression.
    (type.name === GraphQLString.name ||
      type.name === GraphQLInt.name ||
      type.name === GraphQLFloat.name ||
      type.name === GraphQLBoolean.name ||
      type.name === GraphQLID.name)
  );
}

 Object.keys(typeMap).forEach(typeName => {
   const type: GraphQLType = typeMap[typeName];
   if (
     isNamedType(type) &&
     getNamedType(type).name.slice(0, 2) !== '__' &&
     type !== queryType &&
     type !== mutationType
   ) {
     let newType;
     if (isCompositeType(type) || type instanceof GraphQLInputObjectType) {
       newType = recreateCompositeType(schema, type, typeRegistry);
     } else {
       newType = getNamedType(type);
     }
     typeRegistry.addType(newType.name, newType, onTypeConflict);
   }
 });

 function healType<T extends GraphQLType>(type: T): T {
   // Unwrap the two known wrapper types
   if (type instanceof GraphQLList) {
     type = new GraphQLList(healType(type.ofType)) as T;
   } else if (type instanceof GraphQLNonNull) {
     type = new GraphQLNonNull(healType(type.ofType)) as T;
   } else if (isNamedType(type)) {
     // If a type annotation on a field or an argument or a union member is
     // any `GraphQLNamedType` with a `name`, then it must end up identical
     // to `schema.getType(name)`, since `schema.getTypeMap()` is the source
     // of truth for all named schema types.
     const namedType = type as GraphQLNamedType;
     const officialType = schema.getType(namedType.name);
     if (officialType && namedType !== officialType) {
       return officialType as T;
     }
   }
   return type;
 }

 Object.keys(typeMap).map((typeName: string) => {
   const type = typeMap[typeName];
   if (isNamedType(type) && getNamedType(type).name.slice(0, 2) !== '__') {
     const specifiers = getTypeSpecifiers(type, schema);
     const typeVisitor = getVisitor(visitor, specifiers);
     if (typeVisitor) {
       const result: GraphQLNamedType | null | undefined = typeVisitor(
         type,
         schema,
       );
       if (typeof result === 'undefined') {
         types[typeName] = recreateType(type, resolveType, !stripResolvers);
       } else if (result === null) {
         types[typeName] = null;
       } else {
         types[typeName] = recreateType(result, resolveType, !stripResolvers);
       }
     } else {
       types[typeName] = recreateType(type, resolveType, !stripResolvers);
     }
   }
 });