function defaultCase <TKey>(keyType: Type<TKey>): CollectionKeyInputHelpers<TKey> {
    const fieldName = formatName.arg(collectionKey.name)
    const { gqlType, fromGqlInput } = getGqlInputType(buildToken, keyType)

    return {
      fieldEntries: [
        [fieldName, {
          description: `The ${scrib.type(gqlType)} to use when reading a single value.`,
          type: new GraphQLNonNull(getNullableType(gqlType)),
        }],
      ],
      getKeyFromInput: fromGqlInput,
    }
  }

  public mock(
    root: any,
    args: { [key: string]: any },
    context: any,
    info: GraphQLResolveInfo,
    fieldType: GraphQLList<any>,
    mockTypeFunc: IMockTypeFn,
  ) {
    let arr: any[];
    if (Array.isArray(this.len)) {
      arr = new Array(this.randint(this.len[0], this.len[1]));
    } else {
      arr = new Array(this.len);
    }

    for (let i = 0; i < arr.length; i++) {
      if (typeof this.wrappedFunction === 'function') {
        const res = this.wrappedFunction(root, args, context, info);
        if (res instanceof MockList) {
          const nullableType = getNullableType(fieldType.ofType) as GraphQLList<
            any
          >;
          arr[i] = res.mock(
            root,
            args,
            context,
            info,
            nullableType,
            mockTypeFunc,
          );
        } else {
          arr[i] = res;
        }
      } else {
        arr[i] = mockTypeFunc(fieldType.ofType)(root, args, context, info);
      }
    }
    return arr;
  }

  function assignResolveType(type: GraphQLType) {
    const fieldType = getNullableType(type);
    const namedFieldType = getNamedType(fieldType);

    const oldResolveType = getResolveType(namedFieldType);
    if (preserveResolvers && oldResolveType && oldResolveType.length) {
      return;
    }

    if (
      namedFieldType instanceof GraphQLUnionType ||
      namedFieldType instanceof GraphQLInterfaceType
    ) {
      // the default `resolveType` always returns null. We add a fallback
      // resolution that works with how unions and interface are mocked
      namedFieldType.resolveType = (
        data: any,
        context: any,
        info: GraphQLResolveInfo,
      ) => {
        return info.schema.getType(data.__typename) as GraphQLObjectType;
      };
    }
  }

    return (
      root: any,
      args: { [key: string]: any },
      context: any,
      info: GraphQLResolveInfo,
    ): any => {
      // nullability doesn't matter for the purpose of mocking.
      const fieldType = getNullableType(type);
      const namedFieldType = getNamedType(fieldType);

      if (root && typeof root[fieldName] !== 'undefined') {
        let result: any;

        // if we're here, the field is already defined
        if (typeof root[fieldName] === 'function') {
          result = root[fieldName](root, args, context, info);
          if (result instanceof MockList) {
            result = result.mock(
              root,
              args,
              context,
              info,
              fieldType as GraphQLList<any>,
              mockType,
            );
          }
        } else {
          result = root[fieldName];
        }

        // Now we merge the result with the default mock for this type.
        // This allows overriding defaults while writing very little code.
        if (mockFunctionMap.has(namedFieldType.name)) {
          result = mergeMocks(
            mockFunctionMap
              .get(namedFieldType.name)
              .bind(null, root, args, context, info),
            result,
          );
        }
        return result;
      }

      if (fieldType instanceof GraphQLList) {
        return [
          mockType(fieldType.ofType)(root, args, context, info),
          mockType(fieldType.ofType)(root, args, context, info),
        ];
      }
      if (
        mockFunctionMap.has(fieldType.name) &&
        !(
          fieldType instanceof GraphQLUnionType ||
          fieldType instanceof GraphQLInterfaceType
        )
      ) {
        // the object passed doesn't have this field, so we apply the default mock
        return mockFunctionMap.get(fieldType.name)(root, args, context, info);
      }
      if (fieldType instanceof GraphQLObjectType) {
        // objects don't return actual data, we only need to mock scalars!
        return {};
      }
      // if a mock function is provided for unionType or interfaceType, execute it to resolve the concrete type
      // otherwise randomly pick a type from all implementation types
      if (
        fieldType instanceof GraphQLUnionType ||
        fieldType instanceof GraphQLInterfaceType
      ) {
        let implementationType;
        if (mockFunctionMap.has(fieldType.name)) {
          const interfaceMockObj = mockFunctionMap.get(fieldType.name)(
            root,
            args,
            context,
            info,
          );
          if (!interfaceMockObj || !interfaceMockObj.__typename) {
            return Error(`Please return a __typename in "${fieldType.name}"`);
          }
          implementationType = schema.getType(interfaceMockObj.__typename);
        } else {
          const possibleTypes = schema.getPossibleTypes(fieldType);
          implementationType = getRandomElement(possibleTypes);
        }
        return Object.assign(
          { __typename: implementationType },
          mockType(implementationType)(root, args, context, info),
        );
      }

      if (fieldType instanceof GraphQLEnumType) {
        return getRandomElement(fieldType.getValues()).value;
      }

      if (defaultMockMap.has(fieldType.name)) {
        return defaultMockMap.get(fieldType.name)(root, args, context, info);
      }

      // if we get to here, we don't have a value, and we don't have a mock for this type,
//.........这里部分代码省略.........

 resolveType: (value: {}) => value === $$isQuery ? getQueryGqlType(buildToken) : getNullableType(value[$$nodeType]),

 ({ name, gqlType }) =>
   [formatName.arg(name), {
     // No description…
     type: pgProcedure.isStrict ? new GraphQLNonNull(getNullableType(gqlType)) : gqlType,
   }],

 fields: buildObject(fieldFixtures.map(({ key, field, gqlType }) => ({
   key,
   value: {
     description: field.description,
     type: field.hasDefault ? getNullableGqlType(gqlType) : gqlType,
   },
 }))),

 nullable: <TNonNullValue>(type: NullableType<TNonNullValue>): GetGqlInputReturn<TNonNullValue | null> => {
   const { gqlType: nonNullGqlType, fromGqlInput: fromNonNullGqlInput } = getGqlInputType(buildToken, type.nonNullType)
   return {
     gqlType: getNullableGqlType(nonNullGqlType),
     fromGqlInput: gqlInput =>
       gqlInput == null
         ? null
         : fromNonNullGqlInput(gqlInput),
   }
 },

 nullable: <TNonNullValue>(type: NullableType<TNonNullValue>): GetGqlOutputTypeReturn<TNonNullValue | null> => {
   const { gqlType: nonNullGqlType, intoGqlOutput: intoNonNullGqlOutput } = getGqlOutputType(buildToken, type.nonNullType)
   return {
     gqlType: getNullableGqlType(nonNullGqlType),
     intoGqlOutput: value =>
       type.isNonNull(value)
         ? intoNonNullGqlOutput(value)
         : null,
   }
 },