Function makeExecutableSchema

packages/schema/src/makeExecutableSchema.ts:51–107

({
  typeDefs,
  resolvers = {},
  resolverValidationOptions = {},
  inheritResolversFromInterfaces = false,
  updateResolversInPlace = false,
  schemaExtensions,
  defaultFieldResolver,
  ...otherOptions
}: IExecutableSchemaDefinition<TContext>)

 * ```
 */
export function makeExecutableSchema<TContext = any>({
  typeDefs,
  resolvers = {},
  resolverValidationOptions = {},
  inheritResolversFromInterfaces = false,
  updateResolversInPlace = false,
  schemaExtensions,
  defaultFieldResolver,
  ...otherOptions
}: IExecutableSchemaDefinition<TContext>) {
  // Validate and clean up arguments
  if (typeof resolverValidationOptions !== 'object') {
    throw new Error('Expected `resolverValidationOptions` to be an object');
  }

  if (!typeDefs) {
    throw new Error('Must provide typeDefs');
  }

  let schema: GraphQLSchema;

  if (isSchema(typeDefs)) {
    schema = typeDefs;
  } else if (otherOptions?.commentDescriptions) {
    const mergedTypeDefs = mergeTypeDefs(typeDefs, {
      ...otherOptions,
      commentDescriptions: true,
    });
    schema = buildSchema(mergedTypeDefs, otherOptions);
  } else {
    const mergedTypeDefs = mergeTypeDefs(typeDefs, otherOptions);
    schema = buildASTSchema(mergedTypeDefs, otherOptions);
  }

  // We allow passing in an array of resolver maps, in which case we merge them

  schema = addResolversToSchema({
    schema,
    resolvers: mergeResolvers(resolvers),
    resolverValidationOptions,
    inheritResolversFromInterfaces,
    updateResolversInPlace,
    defaultFieldResolver,
  });

  if (Object.keys(resolverValidationOptions).length > 0) {
    assertResolversPresent(schema, resolverValidationOptions);
  }

  if (schemaExtensions) {
    for (const schemaExtension of asArray(schemaExtensions)) {
      applyExtensions(schema, schemaExtension);
    }
  }

  return schema;
}