output.ts

import type {
  GraphQLFieldExtensions,
  GraphQLObjectTypeConfig,
  GraphQLResolveInfo,
  GraphQLUnionTypeConfig,
  GraphQLArgumentConfig,
  GraphQLInputFieldConfig,
  GraphQLScalarTypeConfig,
  FieldDefinitionNode,
} from "graphql";
import {
  GArg,
  GEnumType,
  GEnumTypeConfig,
  GEnumValueConfig,
  GField,
  GInputObjectType,
  GInputObjectTypeConfig,
  GInputType,
  GInterfaceField,
  GInterfaceType,
  GInterfaceTypeConfig,
  GList,
  GNonNull,
  GNullableInputType,
  GNullableType,
  GObjectType,
  GOutputType,
  GScalarType,
  GType,
  GUnionType,
  InferValueFromOutputType,
  InferValueFromArgs,
  InferValueFromInputType,
} from "./types";
import {
  GraphQLBoolean,
  GraphQLID,
  GraphQLInt,
  GraphQLFloat,
  GraphQLString,
} from "graphql";
import type { g } from "./g-for-doc-references";

type SomeTypeThatIsntARecordOfArgs = string;

type ImpliedResolver<
  Args extends { [Key in keyof Args]: GArg<GInputType> },
  Type extends GOutputType<Context>,
  Context,
> =
  | InferValueFromOutputType<Type>
  | ((
      args: InferValueFromArgs<Args>,
      context: Context,
      info: GraphQLResolveInfo
    ) => InferValueFromOutputType<Type>);

type Maybe<T> = T | null | undefined;

type FieldFuncArgs<
  Source,
  Args extends { [Key in keyof Args]: GArg<GInputType> },
  Type extends GOutputType<Context>,
  Context,
> = {
  args?: Args;
  type: Type;
  description?: Maybe<string>;
  deprecationReason?: Maybe<string>;
  extensions?: Maybe<Readonly<GraphQLFieldExtensions<Source, Context>>>;
  astNode?: Maybe<FieldDefinitionNode>;
};

/** @deprecated */
export type InterfaceToInterfaceFields<
  Interface extends GInterfaceType<any, any, any>,
> = Interface extends GInterfaceType<any, infer Fields, any> ? Fields : never;

type InterfaceFieldsToOutputFields<
  Source,
  Context,
  Fields extends { [key: string]: GInterfaceField<any, any, any> },
> = {
  [Key in keyof Fields]: Fields[Key] extends GInterfaceField<
    infer Args,
    infer OutputType,
    any
  >
    ? GField<
        Source,
        Args,
        OutputType,
        Key extends keyof Source ? Source[Key] : unknown,
        Context
      >
    : never;
};

/** @deprecated */
export type _InterfacesToOutputFields<
  Source,
  Context,
  Interfaces extends readonly GInterfaceType<Source, any, Context>[],
> = InterfacesToOutputFields<Source, Context, Interfaces>;
export type { _InterfacesToOutputFields as InterfacesToOutputFields };

type InterfacesToOutputFields<
  Source,
  Context,
  Interfaces extends readonly GInterfaceType<Source, any, any>[],
> = MergeTuple<
  {
    [Key in keyof Interfaces]: Interfaces[Key] extends GInterfaceType<
      Source,
      infer Fields,
      any
    >
      ? InterfaceFieldsToOutputFields<Source, Context, Fields>
      : never;
  },
  {}
>;

export type InterfacesToInterfaceFields<
  Interfaces extends readonly GInterfaceType<any, any, any>[],
> = MergeTuple<
  {
    [Key in keyof Interfaces]: Interfaces[Key] extends GInterfaceType<
      any,
      infer Fields,
      any
    >
      ? Fields
      : never;
  },
  {}
>;

type MergeTuple<T, Merged> = T extends readonly [infer U, ...infer Rest]
  ? MergeTuple<Rest, Merged & U>
  : Merged;

export type GWithContext<Context> = {
  /**
   * Creates a GraphQL object type.
   *
   * Note this is an **output** type, if you want an input object, use
   * `g.inputObject`.
   *
   * When calling `g.object`, you must provide a type parameter that is the
   * source of the object type. The source is what you receive as the first
   * argument of resolvers on this type and what you must return from resolvers
   * of fields that return this type.
   *
   * ```ts
   * const Person = g.object<{ name: string }>()({
   *   name: "Person",
   *   fields: {
   *     name: g.field({ type: g.String }),
   *   },
   * });
   * // ==
   * graphql`
   *   type Person {
   *     name: String
   *   }
   * `;
   * ```
   *
   * ## Writing resolvers
   *
   * To do anything other than just return a field from the source type, you
   * need to provide a resolver.
   *
   * Note: TypeScript will force you to provide a resolve function if the field
   * in the source type and the GraphQL field don't match
   *
   * ```ts
   * const Person = g.object<{ name: string }>()({
   *   name: "Person",
   *   fields: {
   *     name: g.field({ type: g.String }),
   *     excitedName: g.field({
   *       type: g.String,
   *       resolve(source, args, context, info) {
   *         return `${source.name}!`;
   *       },
   *     }),
   *   },
   * });
   * ```
   *
   * ## Circularity
   *
   * GraphQL types will often contain references to themselves and to make
   * TypeScript allow that, you need have an explicit type annotation of
   * `g<typeof g.object<Source>>` along with making `fields` a function that
   * returns the object.
   *
   * ```ts
   * type PersonSource = { name: string; friends: PersonSource[] };
   *
   * const Person: g<typeof g.object<PersonSource>> =
   *   g.object<PersonSource>()({
   *     name: "Person",
   *     fields: () => ({
   *       name: g.field({ type: g.String }),
   *       friends: g.field({ type: g.list(Person) }),
   *     }),
   *   });
   * ```
   */
  object: <
    Source,
  >(youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction?: {
    youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction: true;
  }) => <
    Fields extends {
      [Key in keyof Fields]: GField<
        Source,
        any,
        any,
        Key extends keyof Source ? Source[Key] : unknown,
        Context
      >;
    } & InterfaceFieldsToOutputFields<
      Source,
      Context,
      InterfacesToInterfaceFields<Interfaces>
    >,
    const Interfaces extends readonly GInterfaceType<
      Source,
      any,
      Context
    >[] = [],
  >(
    config: {
      fields: Fields | (() => Fields);
      interfaces?: [...Interfaces];
    } & Omit<GraphQLObjectTypeConfig<Source, Context>, "fields" | "interfaces">
  ) => GObjectType<Source, Context>;
  /**
   * Create a GraphQL union type.
   *
   * A union type represents an object that could be one of a list of types.
   * Note it is similar to an {@link GInterfaceType interface type} except that a
   * union doesn't imply having a common set of fields among the member types.
   *
   * ```ts
   * const A = g.object<{ __typename: "A" }>()({
   *   name: "A",
   *   fields: {
   *     something: g.field({ type: g.String }),
   *   },
   * });
   * const B = g.object<{ __typename: "B" }>()({
   *   name: "B",
   *   fields: {
   *     differentThing: g.field({ type: g.String }),
   *   },
   * });
   * const AOrB = g.union({
   *   name: "AOrB",
   *   types: [A, B],
   * });
   * ```
   */
  union: <Type extends GObjectType<any, Context>>(
    config: Flatten<
      Omit<
        GraphQLUnionTypeConfig<
          Type extends GObjectType<infer Source, Context> ? Source : never,
          Context
        >,
        "types"
      > & {
        types: readonly Type[] | (() => readonly Type[]);
      }
    >
  ) => GUnionType<
    Type extends GObjectType<infer Source, Context> ? Source : never,
    Context
  >;
  /**
   * Creates a GraphQL field.
   *
   * These will generally be passed directly to the `fields` object in a
   * `g.object` call.
   *
   * ```ts
   * const Something = g.object<{ thing: string }>()({
   *   name: "Something",
   *   fields: {
   *     thing: g.field({ type: g.String }),
   *   },
   * });
   * ```
   */
  field: <
    Source,
    Type extends GOutputType<Context>,
    Resolve,
    Args extends { [Key in keyof Args]: GArg<GInputType> } = {},
  >(
    field: FieldFuncArgs<Source, Args, Type, Context> &
      (Resolve extends {}
        ? {
            resolve: ((
              source: Source,
              args: InferValueFromArgs<
                SomeTypeThatIsntARecordOfArgs extends Args ? {} : Args
              >,
              context: Context,
              info: GraphQLResolveInfo
            ) => InferValueFromOutputType<Type>) &
              Resolve;
          }
        : {
            resolve?: ((
              source: Source,
              args: InferValueFromArgs<
                SomeTypeThatIsntARecordOfArgs extends Args ? {} : Args
              >,
              context: Context,
              info: GraphQLResolveInfo
            ) => InferValueFromOutputType<Type>) &
              Resolve;
          })
  ) => GField<
    Source,
    Args,
    Type,
    Resolve extends {} ? unknown : ImpliedResolver<Args, Type, Context>,
    Context
  >;
  /**
   * A helper to declare fields while providing the source type a single time
   * rather than in every resolver.
   *
   * ```ts
   * const nodeFields = g.fields<{ id: string }>()({
   *   id: g.field({ type: g.ID }),
   *   relatedIds: g.field({
   *     type: g.list(g.ID),
   *     resolve(source) {
   *       return loadRelatedIds(source.id);
   *     },
   *   }),
   *   otherRelatedIds: g.field({
   *     type: g.list(g.ID),
   *     resolve(source) {
   *       return loadOtherRelatedIds(source.id);
   *     },
   *   }),
   * });
   *
   * const Person = g.object<{
   *   id: string;
   *   name: string;
   * }>()({
   *   name: "Person",
   *   fields: {
   *     ...nodeFields,
   *     name: g.field({ type: g.String }),
   *   },
   * });
   * ```
   */
  fields: <
    Source,
  >(youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction?: {
    youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction: true;
  }) => <
    Fields extends Record<
      string,
      GField<Source, any, GOutputType<Context>, any, Context>
    > & {
      [Key in keyof Source]?: GField<
        Source,
        any,
        GOutputType<Context>,
        Source[Key],
        Context
      >;
    },
  >(
    fields: Fields
  ) => Fields;
  /**
   * Creates a GraphQL interface field.
   *
   * These will generally be passed directly to the `fields` object in a
   * {@link g.interface} call. Interfaces fields are similar to
   * {@link GField regular fields} except that they **don't define how the field
   * is resolved**.
   *
   * ```ts
   * const Entity = g.interface()({
   *   name: "Entity",
   *   fields: {
   *     name: g.interfaceField({ type: g.String }),
   *   },
   * });
   * ```
   *
   * Note that {@link GField regular fields} are assignable to
   * {@link GInterfaceField interface fields} but the opposite is not true. This
   * means that you can use a regular field in an
   * {@link GInterfaceType interface type}.
   */
  interfaceField: <
    Args extends { [Key in keyof Args]: GArg<GInputType> },
    Type extends GOutputType<Context>,
  >(
    field: GInterfaceField<Args, Type, Context>
  ) => GInterfaceField<Args, Type, Context>;
  /**
   * Creates a GraphQL interface type that can be implemented by other GraphQL
   * object and interface types.
   *
   * ```ts
   * const Entity = g.interface()({
   *   name: "Entity",
   *   fields: {
   *     name: g.interfaceField({ type: g.String }),
   *   },
   * });
   *
   * type PersonSource = { __typename: "Person"; name: string };
   *
   * const Person = g.object<PersonSource>()({
   *   name: "Person",
   *   interfaces: [Entity],
   *   fields: {
   *     name: g.field({ type: g.String }),
   *   },
   * });
   *
   * type OrganisationSource = {
   *   __typename: "Organisation";
   *   name: string;
   * };
   *
   * const Organisation = g.object<OrganisationSource>()({
   *   name: "Organisation",
   *   interfaces: [Entity],
   *   fields: {
   *     name: g.field({ type: g.String }),
   *   },
   * });
   * ```
   *
   * ## Resolving Types
   *
   * When using GraphQL interface and union types, there needs to a way to
   * determine which concrete object type has been returned from a resolver.
   * With `graphql-js` and `@graphql-ts/schema`, this is done with `isTypeOf` on
   * object types and `resolveType` on interface and union types. Note
   * `@graphql-ts/schema` **does not aim to strictly type the implementation of
   * `resolveType` and `isTypeOf`**. If you don't provide `resolveType` or
   * `isTypeOf`, a `__typename` property on the source type will be used, if
   * that fails, an error will be thrown at runtime.
   *
   * ## Fields vs Interface Fields
   *
   * You might have noticed that `g.interfaceField` was used instead of
   * `g.field` for the fields on the interfaces. This is because **interfaces
   * aren't defining implementation of fields** which means that fields on an
   * interface don't need define resolvers.
   *
   * ## Sharing field implementations
   *
   * Even though interfaces don't contain field implementations, you may still
   * want to share field implementations between interface implementations. You
   * can use `g.fields` to do that. See `g.fields` for more information about
   * why you should use `g.fields` instead of just defining an object the fields
   * and spreading that.
   *
   * ```ts
   * const nodeFields = g.fields<{ id: string }>({
   *   id: g.field({ type: g.ID }),
   * });
   *
   * const Node = g.field({
   *   name: "Node",
   *   fields: nodeFields,
   * });
   *
   * const Person = g.object<{
   *   __typename: "Person";
   *   id: string;
   *   name: string;
   * }>()({
   *   name: "Person",
   *   interfaces: [Node],
   *   fields: {
   *     ...nodeFields,
   *     name: g.field({ type: g.String }),
   *   },
   * });
   * ```
   */
  interface: <
    Source,
  >(youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction?: {
    youOnlyNeedToPassATypeParameterToThisFunctionYouPassTheActualRuntimeArgsOnTheResultOfThisFunction: true;
  }) => <
    Fields extends {
      [Key in keyof Fields]: GInterfaceField<
        any,
        GOutputType<Context>,
        Context
      >;
    } & InterfacesToInterfaceFields<Interfaces>,
    const Interfaces extends readonly GInterfaceType<
      Source,
      any,
      Context
    >[] = [],
  >(
    config: GInterfaceTypeConfig<Source, Fields, Interfaces, Context>
  ) => GInterfaceType<Source, Fields, Context>;
  /**
   * A shorthand to easily create {@link GEnumValueConfig enum values} to pass to
   * {@link g.enum}.
   *
   * If you need to set a `description` or `deprecationReason` for an enum
   * variant, you should pass values directly to `g.enum` without using
   * `g.enumValues`.
   *
   * ```ts
   * const MyEnum = g.enum({
   *   name: "MyEnum",
   *   values: g.enumValues(["a", "b"]),
   * });
   * ```
   *
   * ```ts
   * const values = g.enumValues(["a", "b"]);
   *
   * assertDeepEqual(values, {
   *   a: { value: "a" },
   *   b: { value: "b" },
   * });
   * ```
   */
  enumValues: <const Values extends readonly string[]>(
    values: readonly [...Values]
  ) => {
    [Key in Values[number]]: GEnumValueConfig<Key>;
  };

  /**
   * Creates an {@link GEnumType enum type} with a number of
   * {@link GEnumValueConfig enum values}.
   *
   * ```ts
   * const MyEnum = g.enum({
   *   name: "MyEnum",
   *   values: g.enumValues(["a", "b"]),
   * });
   * // ==
   * graphql`
   *   enum MyEnum {
   *     a
   *     b
   *   }
   * `;
   * ```
   *
   * ```ts
   * const MyEnum = g.enum({
   *   name: "MyEnum",
   *   description: "My enum does things",
   *   values: {
   *     something: {
   *       description: "something something",
   *       value: "something",
   *     },
   *     thing: {
   *       description: "thing thing",
   *       deprecationReason: "something should be used instead of thing",
   *       value: "thing",
   *     },
   *   },
   * });
   * // ==
   * graphql`
   *   """
   *   My enum does things
   *   """
   *   enum MyEnum {
   *     """
   *     something something
   *     """
   *     something
   *     """
   *     thing thing
   *     """
   *     thing @\deprecated(reason: "something should be used instead of thing")
   *   }
   * `;)
   * ```
   */
  enum: <const Values extends Record<string, unknown>>(
    config: GEnumTypeConfig<Values>
  ) => GEnumType<Values>;
  /**
   * Creates a {@link GArg GraphQL argument}.
   *
   * Args can can be used as arguments on output fields:
   *
   * ```ts
   * g.field({
   *   type: g.String,
   *   args: {
   *     something: g.arg({ type: g.String }),
   *   },
   *   resolve(source, { something }) {
   *     return something || somethingElse;
   *   },
   * });
   * // ==
   * graphql`(something: String): String`;
   * ```
   *
   * Or as fields on input objects:
   *
   * ```ts
   * const Something = g.inputObject({
   *   name: "Something",
   *   fields: {
   *     something: g.arg({ type: g.String }),
   *   },
   * });
   * // ==
   * graphql`
   *   input Something {
   *     something: String
   *   }
   * `;
   * ```
   */
  arg: <
    Type extends GInputType,
    DefaultValue extends InferValueFromInputType<Type> | undefined = undefined,
  >(
    arg: Flatten<
      {
        type: Type;
      } & Omit<
        GraphQLInputFieldConfig & GraphQLArgumentConfig,
        "type" | "defaultValue"
      >
    > &
      (undefined extends DefaultValue
        ? { defaultValue?: DefaultValue }
        : { defaultValue: DefaultValue })
  ) => GArg<Type, DefaultValue extends undefined ? false : true>;
  /**
   * Creates an {@link GInputObjectType input object type}
   *
   * ```ts
   * const Something = g.inputObject({
   *   name: "Something",
   *   fields: {
   *     something: g.arg({ type: g.String }),
   *   },
   * });
   * // ==
   * graphql`
   *   input Something {
   *     something: String
   *   }
   * `;
   * ```
   *
   * ### Handling circular objects
   *
   * Circular input objects require explicitly specifying the fields on the
   * object in the type because of TypeScript's limits with circularity.
   *
   * ```ts
   * import { GInputObjectType } from "@graphql-ts/schema";
   *
   * type SomethingInputType = GInputObjectType<{
   *   something: g<typeof g.arg<SomethingInputType>>;
   * }>;
   * const Something: SomethingInputType = g.inputObject({
   *   name: "Something",
   *   fields: () => ({
   *     something: g.arg({ type: Something }),
   *   }),
   * });
   * ```
   *
   * You can specify all of your non-circular fields outside of the fields
   * object and then use `typeof` to get the type to avoid writing the
   * non-circular fields as types again.
   *
   * ```ts
   * import { GInputObjectType } from "@graphql-ts/schema";
   *
   * const nonCircularFields = {
   *   thing: g.arg({ type: g.String }),
   * };
   * type SomethingInputType = GInputObjectType<
   *   typeof nonCircularFields & {
   *     something: g<typeof g.arg<SomethingInputType>>;
   *   }
   * >;
   * const Something: SomethingInputType = g.inputObject({
   *   name: "Something",
   *   fields: () => ({
   *     ...nonCircularFields,
   *     something: g.arg({ type: Something }),
   *   }),
   * });
   * ```
   */
  inputObject: <
    Fields extends {
      [key: string]: IsOneOf extends true
        ? GArg<GNullableInputType, false>
        : GArg<GInputType>;
    },
    IsOneOf extends boolean = false,
  >(
    config: GInputObjectTypeConfig<Fields, IsOneOf>
  ) => GInputObjectType<Fields, IsOneOf>;
  /**
   * Wraps any GraphQL type in a {@link GList list type}.
   *
   * ```ts
   * const stringListType = g.list(g.String);
   * // ==
   * graphql`[String]`;
   * ```
   *
   * When used as an input type, you will recieve an array of the inner type.
   *
   * ```ts
   * g.field({
   *   type: g.String,
   *   args: { thing: g.arg({ type: g.list(g.String) }) },
   *   resolve(source, { thing }) {
   *     const theThing: undefined | null | Array<string | null> = thing;
   *     return "";
   *   },
   * });
   * ```
   *
   * When used as an output type, you can return an iterable of the inner type
   * that also matches `typeof val === 'object'` so for example, you'll probably
   * return an Array most of the time but you could also return a Set you
   * couldn't return a string though, even though a string is an iterable, it
   * doesn't match `typeof val === 'object'`.
   *
   * ```ts
   * g.field({
   *   type: g.list(g.String),
   *   resolve() {
   *     return [""];
   *   },
   * });
   * ```
   *
   * ```ts
   * g.field({
   *   type: g.list(g.String),
   *   resolve() {
   *     return new Set([""]);
   *   },
   * });
   * ```
   *
   * ```ts
   * g.field({
   *   type: g.list(g.String),
   *   resolve() {
   *     // this will not be allowed
   *     return "some things";
   *   },
   * });
   * ```
   */
  list: <Of extends GType<any>>(of: Of) => GList<Of>;
  /**
   * Wraps a {@link GNullableType nullable type} with a
   * {@link GNonNull non-nullable type}.
   *
   * Types in GraphQL are always nullable by default so if you want to enforce
   * that a type must always be there, you can use the non-null type.
   *
   * ```ts
   * const nonNullableString = g.nonNull(g.String);
   * // ==
   * graphql`String!`;
   * ```
   *
   * When using a non-null type as an input type, your resolver will never
   * recieve null and consumers of your GraphQL API **must** provide a value for
   * it unless you provide a default value.
   *
   * ```ts
   * g.field({
   *   args: {
   *     someNonNullAndRequiredArg: g.arg({
   *       type: g.nonNull(g.String),
   *     }),
   *     someNonNullButOptionalArg: g.arg({
   *       type: g.nonNull(g.String),
   *       defaultValue: "some default",
   *     }),
   *   },
   *   type: g.String,
   *   resolve(source, args) {
   *     // both of these will always be a string
   *     args.someNonNullAndRequiredArg;
   *     args.someNonNullButOptionalArg;
   *
   *     return "";
   *   },
   * });
   * // ==
   * graphql`
   *   fieldName(
   *     someNonNullAndRequiredArg: String!
   *     someNonNullButOptionalArg: String! = "some default"
   *   ): String
   * `;
   * ```
   *
   * When using a non-null type as an output type, your resolver must never
   * return null. If you do return null(which unless you do
   * type-casting/ts-ignore/etc. `@graphql-ts/schema` will not let you do)
   * graphql-js will return an error to consumers of your GraphQL API.
   *
   * Non-null types should be used very carefully on output types. If you have
   * to do a fallible operation like a network request or etc. to get the value,
   * it probably shouldn't be non-null. If you make a field non-null and doing
   * the fallible operation fails, consumers of your GraphQL API will be unable
   * to see any of the other fields on the object that the non-null field was
   * on. For example, an id on some type is a good candidate for being non-null
   * because if you have the item, you will already have the id so getting the
   * id will never fail but fetching a related item from a database would be
   * fallible so even if it will never be null in the success case, you should
   * make it nullable.
   *
   * ```ts
   * g.field({
   *   type: g.nonNull(g.String),
   *   resolve(source, args) {
   *     return "something";
   *   },
   * });
   * // ==
   * graphql`
   *   fieldName: String!
   * `;
   * ```
   *
   * If you try to wrap another non-null type in a non-null type again, you will
   * get a type error.
   *
   * ```ts
   * // Argument of type 'NonNullType<ScalarType<string>>'
   * // is not assignable to parameter of type 'NullableType'.
   * g.nonNull(g.nonNull(g.String));
   * ```
   */
  nonNull: <Of extends GNullableType<any>>(of: Of) => GNonNull<Of>;
  /**
   * Creates a {@link GScalarType scalar type}.
   *
   * ```ts
   * const BigInt = g.scalar({
   *   name: "BigInt",
   *   serialize(value) {
   *     if (typeof value !== "bigint")
   *       throw new GraphQLError(
   *         `unexpected value provided to BigInt scalar: ${value}`
   *       );
   *     return value.toString();
   *   },
   *   parseLiteral(value) {
   *     if (value.kind !== "StringValue")
   *       throw new GraphQLError("BigInt only accepts values as strings");
   *     return globalThis.BigInt(value.value);
   *   },
   *   parseValue(value) {
   *     if (typeof value === "bigint") return value;
   *     if (typeof value !== "string")
   *       throw new GraphQLError("BigInt only accepts values as strings");
   *     return globalThis.BigInt(value);
   *   },
   * });
   * // for fields on output types
   * g.field({ type: someScalar });
   *
   * // for args on output fields or fields on input types
   * g.arg({ type: someScalar });
   * ```
   *
   * Note, while graphql-js allows you to express scalar types like the `ID`
   * type which accepts integers and strings as both input values and return
   * values from resolvers which are transformed into strings before calling
   * resolvers and returning the query respectively, the type you use should be
   * `string` for `ID` since that is what it is transformed into.
   * `@graphql-ts/schema` doesn't currently express the coercion of scalars, you
   * should instead convert values to the canonical form yourself before
   * returning from resolvers.
   */
  scalar: <Internal, External = Internal>(
    config: GraphQLScalarTypeConfig<Internal, External>
  ) => GScalarType<Internal, External>;
  ID: GScalarType<string>;
  String: GScalarType<string>;
  Float: GScalarType<number>;
  Int: GScalarType<number>;
  Boolean: GScalarType<boolean>;
};

/**
 * The `gWithContext` function accepts a `Context` type parameter which binds
 * the returned functions so they can be used to compose GraphQL types into a
 * GraphQL schema.
 *
 * A simple schema with only a query type looks like this:
 *
 * ```ts
 * import { gWithContext } from "@graphql-ts/schema";
 * import { GraphQLSchema, graphql } from "graphql";
 *
 * type Context = {};
 *
 * const g = gWithContext<Context>();
 * type g<T> = gWithContext.infer<T>;
 *
 * const Query = g.object()({
 *   name: "Query",
 *   fields: {
 *     hello: g.field({
 *       type: g.String,
 *       resolve() {
 *         return "Hello!";
 *       },
 *     }),
 *   },
 * });
 *
 * const schema = new GraphQLSchema({
 *   query: Query,
 * });
 *
 * graphql({
 *   source: `
 *       query {
 *         hello
 *       }
 *     `,
 *   schema,
 * }).then((result) => {
 *   console.log(result);
 * });
 * ```
 *
 * You can use pass the `schema` to `ApolloServer` and other GraphQL servers.
 *
 * You can also create a more advanced schema with other object types, circular
 * types, args, and mutations. See {@link GWithContext} for what the other
 * functions on `g` do.
 *
 * ```ts
 * import { gWithContext } from "@graphql-ts/schema";
 * import { GraphQLSchema, graphql } from "graphql";
 * import { deepEqual } from "node:assert";
 *
 * type Context = {
 *   todos: Map<string, TodoItem>;
 * };
 *
 * const g = gWithContext<Context>();
 * type g<T> = gWithContext.infer<T>;
 *
 * type TodoItem = {
 *   id: string;
 *   title: string;
 *   relatedTodos: string[];
 * };
 *
 * const Todo: g<typeof g.object<TodoItem>> = g.object<TodoItem>()({
 *   name: "Todo",
 *   fields: () => ({
 *     id: g.field({ type: g.nonNull(g.ID) }),
 *     title: g.field({ type: g.nonNull(g.String) }),
 *     relatedTodos: g.field({
 *       type: g.list(Todo),
 *       resolve(source, _args, context) {
 *         return source.relatedTodos
 *           .map((id) => context.todos.get(id))
 *           .filter((todo) => todo !== undefined);
 *       },
 *     }),
 *   }),
 * });
 *
 * const Query = g.object()({
 *   name: "Query",
 *   fields: {
 *     todos: g.field({
 *       type: g.list(Todo),
 *       resolve(_source, _args, context) {
 *         return context.todos.values();
 *       },
 *     }),
 *   },
 * });
 *
 * const Mutation = g.object()({
 *   name: "Mutation",
 *   fields: {
 *     createTodo: g.field({
 *       args: {
 *         title: g.arg({ type: g.nonNull(g.String) }),
 *         relatedTodos: g.arg({
 *           type: g.nonNull(g.list(g.nonNull(g.ID))),
 *           defaultValue: [],
 *         }),
 *       },
 *       type: Todo,
 *       resolve(_source, { title, relatedTodos }, context) {
 *         const todo = { title, relatedTodos, id: crypto.randomUUID() };
 *         context.todos.set(todo.id, todo);
 *         return todo;
 *       },
 *     }),
 *   },
 * });
 *
 * const schema = new GraphQLSchema({
 *   query: Query,
 *   mutation: Mutation,
 * });
 *
 * (async () => {
 *   const contextValue: Context = { todos: new Map() };
 *   {
 *     const result = await graphql({
 *       source: `
 *         query {
 *           todos {
 *             title
 *           }
 *         }
 *       `,
 *       schema,
 *       contextValue,
 *     });
 *     deepEqual(result, { data: { todos: [] } });
 *   }
 *
 *   {
 *     const result = await graphql({
 *       source: `
 *         mutation {
 *           createTodo(title: "Try graphql-ts") {
 *             title
 *           }
 *         }
 *       `,
 *       schema,
 *       contextValue,
 *     });
 *     deepEqual(result, {
 *       data: { createTodo: { title: "Try graphql-ts" } },
 *     });
 *   }
 *   {
 *     const result = await graphql({
 *       source: `
 *         query {
 *           todos {
 *             title
 *           }
 *         }
 *       `,
 *       schema,
 *       contextValue,
 *     });
 *     deepEqual(result, {
 *       data: { todos: [{ title: "Try graphql-ts" }] },
 *     });
 *   }
 * })();
 * ```
 */
export function gWithContext<Context>(): GWithContext<Context> {
  return {
    scalar(config) {
      return new GScalarType(config);
    },
    list(of) {
      return new GList(of);
    },
    nonNull(of) {
      return new GNonNull(of);
    },
    inputObject(config) {
      return new GInputObjectType(config);
    },
    enum(config) {
      return new GEnumType(config);
    },
    union(config) {
      return new GUnionType(config as any);
    },
    object() {
      return function objectInner(config) {
        return new GObjectType(config);
      };
    },
    interface() {
      return function interfaceInner(config) {
        return new GInterfaceType(config);
      };
    },
    fields() {
      return function fieldsInner(fields) {
        return fields;
      };
    },
    field(field) {
      if (!field.type) {
        throw new Error("A type must be passed to g.field()");
      }
      return field as any;
    },
    interfaceField(field) {
      if (!field.type) {
        throw new Error("A type must be passed to g.interfaceField()");
      }
      return field;
    },
    arg(arg) {
      if (!arg.type) {
        throw new Error("A type must be passed to g.arg()");
      }
      return arg as any;
    },
    enumValues(values) {
      return Object.fromEntries(
        values.map((value) => [value, { value }])
      ) as any;
    },
    Int: GraphQLInt,
    Float: GraphQLFloat,
    String: GraphQLString,
    Boolean: GraphQLBoolean,
    ID: GraphQLID,
  };
}

// eslint-disable-next-line @typescript-eslint/no-namespace
export declare namespace gWithContext {
  /**
   * The `gWithContext.infer` type is useful particularly when defining circular
   * types to resolve errors from TypeScript because of the circularity.
   *
   * We recommend aliasing `gWithContext.infer` to your `g` like this to make it
   * easier to use:
   *
   * ```ts
   * import { gWithContext } from "@graphql-ts/schema";
   * type Context = {};
   *
   * const g = gWithContext<Context>();
   * type g<T> = gWithContext.infer<T>;
   *
   * type PersonSource = { name: string; friends: PersonSource[] };
   *
   * const Person: g<typeof g.object<PersonSource>> =
   *   g.object<PersonSource>()({
   *     name: "Person",
   *     fields: () => ({
   *       name: g.field({ type: g.String }),
   *       friends: g.field({ type: g.list(Person) }),
   *     }),
   *   });
   * ```
   */
  export type infer<T> = T extends () => (args: any) => infer R
    ? R
    : T extends (args: any) => infer R
      ? R
      : never;
}

type Flatten<T> = {
  [Key in keyof T]: T[Key];
} & {};