Object.keys(typeMap).forEach(typeName => {
   const type = typeMap[typeName];
   if (isAbstractType(type)) {
     const targetType = targetSchema.getType(typeName);
     if (!isAbstractType(targetType)) {
       const implementations = transformedSchema.getPossibleTypes(type) || [];
       mapping[typeName] = implementations
         .filter(impl => targetSchema.getType(impl.name))
         .map(impl => impl.name);
     }
   }
 });

 function getResolver(type:GraphQLOutputType, field) {
   if (type instanceof GraphQLNonNull)
     return getResolver(type.ofType, field);
   if (type instanceof GraphQLList)
     return arrayResolver(getResolver(type.ofType, field));
   if (isAbstractType(type))
     return abstractTypeResolver(type);
   if (isLeafType(type))
     return getLeafResolver(type, field);
   // TODO: error on fake directive
   // TODO: handle @examples
   return () => ({});
 }

  const typeToInterface: TypeToInterface = (type, ignoredTypes, supportsNullability) => {
    if (isScalar(type)) {
      return null;
    }

    if (isUnion(type)) {
      return generateAbstractTypeDeclaration(type, ignoredTypes);
    }

    if (isEnum(type)) {
      return generateEnumDeclaration(type.description, type.name, type.getValues());
    }

    const isInput: boolean = type instanceof GraphQLInputObjectType;
    const f1: GraphQLInputFieldMap | GraphQLFieldMap<any, any> = type.getFields();
    const f: Array<GraphQLField<any, any> | GraphQLInputField> = Object.keys(f1).map(k => f1[k]);

    const filteredFields: Array<GraphQLField<any, any> | GraphQLInputField> = f.filter(field => filterField(field, ignoredTypes));

    const fields: string[] = filteredFields
      .map(field => [generateDocumentation(buildDocumentation(field)), fieldToDefinition(field, isInput, supportsNullability)])
      .reduce((acc, val) => [...acc, ...val], [])
      .filter(Boolean);

    const interfaceDeclaration: string = generateInterfaceName(type.name);
    let additionalInfo: string = '';

    if (isAbstractType(type)) {
      additionalInfo = generateAbstractTypeDeclaration(type, ignoredTypes);
    }

    return filterAndJoinArray(
      [
        generateInterfaceDeclaration(type, interfaceDeclaration, fields, additionalInfo, isInput),
        ...filteredFields.map(field => generateArgumentsDeclaration(field, type.name, supportsNullability))
      ],
      '\n\n'
    );
  };

 const resolveInterfaceName: ResolveInterfaceName = (type, isNonNull = false) => {
   if (isList(type)) {
     return {
       value: resolveInterfaceName(type.ofType, false),
       isList: true,
       isNonNull
     };
   }
   if (isNonNullable(type)) {
     return resolveInterfaceName(type.ofType, true);
   }
   if (isScalar(type)) {
     return {
       value: TYPE_MAP[type.name] || TYPE_MAP.__DEFAULT,
       isList: false,
       isNonNull
     };
   }
   if (isAbstractType(type)) {
     return {
       value: generateTypeName(type.name),
       isList: false,
       isNonNull
     };
   }
   if (isEnum(type)) {
     return {
       value: generateEnumName(type.name),
       isList: false,
       isNonNull
     };
   }
   return {
     value: generateInterfaceName(type.name),
     isList: false,
     isNonNull
   };
 };

const inferUnionOrInterfaceType = (value: unknown, info: GraphQLResolveInfo) => {
  const returnType = info.returnType

  if (!isAbstractType(returnType)) {
    return value
  }

  // remember that typeof null === 'object'
  if (typeof value !== "object") {
    throw error(
      info,
      ({ type, path }) => `Expected object of type '${type}' but got '${typeof value}' at path '${path}'`
    )
  }

  if (value == null || "__typename" in value) {
    return value
  }

  const unionMemberTypes = info.schema.getPossibleTypes(returnType)

  // try to find keys in the object which are unique to one type
  for (const key of Object.keys(value)) {
    const matchingTypes = unionMemberTypes.filter(type => type.getFields()[key])
    if (matchingTypes.length === 1) {
      return { ...value, __typename: matchingTypes[0].name }
    }
  }

  // failed to find unique keys so the object is ambiguous and we need to ask for a __typename
  const possibleTypes = unionMemberTypes.map(type => type.name).join(", ")
  throw error(
    info,
    ({ path }) => `Ambiguous object at path '${path}'. Add a __typename from this list: [${possibleTypes}]`
  )
}

function stripQuery(schema, queryAST, operationName, extensionFields) {
  const typeInfo = new TypeInfo(schema);

  const changedAST = visit(queryAST, visitWithTypeInfo(typeInfo, {
    [Kind.FIELD]: () => {
      const typeName = typeInfo.getParentType().name;
      const fieldName = typeInfo.getFieldDef().name;

      if (fieldName.startsWith('__'))
        return null;
      if ((extensionFields[typeName] || []).includes(fieldName))
        return null;
    },
    [Kind.SELECTION_SET]: {
      leave(node) {
        const type = typeInfo.getParentType()
        if (isAbstractType(type) || node.selections.length === 0)
          return injectTypename(node);
      }
    },
  }), null);

  return print(extractOperation(changedAST, operationName));
}

export function fakeSchema(schema) {
  const mutationTypeName = (schema.getMutationType() || {}).name;
  const jsonType = schema.getTypeMap()['examples__JSON'];
  jsonType.parseLiteral = astToJSON;

  for (let type of Object.values(schema.getTypeMap())) {
    if (type instanceof GraphQLScalarType && !stdTypeNames.includes(type.name))
      type.serialize = (value => value);
    if (type instanceof GraphQLObjectType && !type.name.startsWith('__'))
      addFakeProperties(type);
    if (isAbstractType(type))
      type.resolveType = (obj => obj.__typename);
  };

  function addFakeProperties(objectType:GraphQLObjectType) {
    const isMutation = (objectType.name === mutationTypeName);

    for (let field of Object.values(objectType.getFields())) {
      if (isMutation && isRelayMutation(field))
        field.resolve = getRelayMutationResolver();
      else
        field.resolve = getFieldResolver(field);
    }
  }

  function isRelayMutation(field) {
    const args = field.args;
    if (args.length !== 1 || args[0].name !== 'input')
      return false;

    const inputType = args[0].type;
    // TODO: check presence of 'clientMutationId'
    return (
      inputType instanceof GraphQLNonNull &&
      inputType.ofType instanceof GraphQLInputObjectType &&
      field.type instanceof GraphQLObjectType
    );
  }

  function getFieldResolver(field) {
    const type = field.type as GraphQLOutputType;
    const fakeResolver = getResolver(type, field);
    return (source, _0, _1, info) => {
      const value = getCurrentSourceProperty(source, info.path);
      return (value !== undefined) ? value : fakeResolver();
    }
  }

  function getRelayMutationResolver() {
    return (source, args, _1, info) => {
      const value = getCurrentSourceProperty(source, info.path);
      if (value instanceof Error)
        return value;
      return {...args['input'], ...value};
    }
  }

  // get value or Error instance injected by the proxy
  function getCurrentSourceProperty(source, path) {
    const key = path && path.key;
    return source && source[key];
  }

  function getResolver(type:GraphQLOutputType, field) {
    if (type instanceof GraphQLNonNull)
      return getResolver(type.ofType, field);
    if (type instanceof GraphQLList)
      return arrayResolver(getResolver(type.ofType, field));
    if (isAbstractType(type))
      return abstractTypeResolver(type);
    if (isLeafType(type))
      return getLeafResolver(type, field);
    // TODO: error on fake directive
    // TODO: handle @examples
    return () => ({});
  }

  function abstractTypeResolver(type:GraphQLAbstractType) {
    const possibleTypes = schema.getPossibleTypes(type);
    return () => ({__typename: getRandomItem(possibleTypes)});
  }
}

  const getChildSelections: GetChildSelectionsType = (operation, selection, parent?, isUndefined = false): IChildSelection => {
    let str: string = '';
    let isFragment: boolean = false;
    let isPartial: boolean = false;
    let complexTypes: IComplexTypeSignature[] = [];
    if (selection.kind === 'Field') {
      const field: GraphQLField<any, any> = getField(operation, selection, parent);
      const originalName: string = selection.name.value;
      const selectionName: string = selection.alias ? selection.alias.value : originalName;
      let childType: string | undefined;

      isUndefined = isUndefined || isUndefinedFromDirective(selection.directives);
      let resolvedType: string;
      if (originalName === '__typename') {
        if (!parent) {
          resolvedType = TypeMap.String;
        } else if (isAbstractType(parent)) {
          const possibleTypes: GraphQLObjectType[] = parsedSchema.getPossibleTypes(parent);
          /**
           * @TODO break this OR logic out of here (and the other places) and put into a printer
           * @TODO break out the string-literal type out of here as it probably isn't supported by other languages
           */
          resolvedType = possibleTypes.map(({ name }) => `'${name}'`).join(' | ');
        } else {
          resolvedType = `'${parent.toString()}'`;
        }
      } else if (!!selection.selectionSet) {
        let newParent: GraphQLCompositeType | undefined;
        const fieldType: GraphQLNamedType = rootIntrospectionTypes.has(originalName) ? parsedSchema.getType(
          rootIntrospectionTypes.get(originalName)!
        ) : getNamedType(field.type);
        if (isCompositeType(fieldType)) {
          newParent = fieldType;
        }

        const selections: IChildSelection[] =
          selection.selectionSet.selections.map(sel => getChildSelections(operation, sel, newParent));

        const nonFragments: IChildSelection[] = selections.filter(s => !s.isFragment);
        const fragments: IChildSelection[] = selections.filter(s => s.isFragment);
        const andOps: string[] = [];

        complexTypes.push(...flattenComplexTypes(selections));

        if (nonFragments.length) {
          const nonPartialNonFragments: IChildSelection[] = nonFragments.filter(nf => !nf.isPartial);
          const partialNonFragments: IChildSelection[] = nonFragments.filter(nf => nf.isPartial);

          if (nonPartialNonFragments.length) {
            const interfaceDeclaration: string = generateInterfaceDeclaration(nonPartialNonFragments.map(f => f.iface));
            const subtypeInfo: ISubtypeMetadata | null = getSubtype(selection, interfaceDeclaration, generateSubTypeInterfaceName);
            const newInterfaceName: string | null = subtypeInfo ? subtypeInfo.name : null;
            andOps.push(newInterfaceName || interfaceDeclaration);
            if (newInterfaceName && subtypeInfo && !subtypeInfo.dupe) {
              complexTypes.push({ iface: interfaceDeclaration, isPartial: false, name: newInterfaceName });
            }
          }

          if (partialNonFragments.length) {
            const interfaceDeclaration: string =
              wrapPartial(generateInterfaceDeclaration(partialNonFragments.map(f => f.iface)));
            const subtypeInfo: ISubtypeMetadata | null = getSubtype(selection, interfaceDeclaration, generateSubTypeInterfaceName);
            const newInterfaceName: string | null = subtypeInfo ? subtypeInfo.name : null;
            andOps.push(newInterfaceName || interfaceDeclaration);
            if (newInterfaceName && subtypeInfo && !subtypeInfo.dupe) {
              complexTypes.push({ iface: interfaceDeclaration, isPartial: true, name: newInterfaceName });
            }
          }
        }

        andOps.push(...fragments.map(wrapPossiblePartial));
        childType = typeJoiner(andOps);
        resolvedType = convertToType(field ? field.type : fieldType, false, childType);
      } else {
        resolvedType = convertToType(field.type, false, childType);
      }
      str = formatInput(selectionName, isUndefined, resolvedType);
    } else if (selection.kind === 'FragmentSpread') {
      str = generateFragmentName(selection.name.value);
      isFragment = true;
      isPartial = isUndefinedFromDirective(selection.directives);
    } else if (selection.kind === 'InlineFragment') {
      const anon: boolean = !selection.typeCondition;
      let fragName: string = '';

      if (!anon && selection.typeCondition) {
        const typeName: string = selection.typeCondition.name.value;
        parent = parsedSchema.getType(typeName);
        isFragment = true;
        fragName = generateFragmentName(`SpreadOn${typeName}`);
      }

      const selections: IChildSelection[] =
        selection.selectionSet.selections.map(sel => getChildSelections(operation, sel, parent, false));

      const fragmentSelections: IChildSelection[] = selections.filter(({ isFragment: frag }) => frag);
      const nonFragmentSelections: IChildSelection[] = selections.filter(({ isFragment: frag }) => !frag);

      /**
       * @TODO need to handle fragments of fragments better
//.........这里部分代码省略.........