exportSchema.ts

import { writeFile } from "node:fs/promises";
import type { URL } from "node:url";
import { inspect } from "node:util";

import generate from "@babel/generator";
import { parse } from "@babel/parser";
import type { TemplateBuilderOptions } from "@babel/template";
import template from "@babel/template";
import type { NodePath } from "@babel/traverse";
import traverse from "@babel/traverse";
import * as t from "@babel/types";
import type {
  GraphQLArgumentConfig,
  GraphQLDirective,
  GraphQLDirectiveConfig,
  GraphQLEnumTypeConfig,
  GraphQLEnumValueConfig,
  GraphQLFieldConfig,
  GraphQLFieldConfigArgumentMap,
  GraphQLFieldConfigMap,
  GraphQLInputFieldConfig,
  GraphQLInputFieldConfigMap,
  GraphQLInputObjectTypeConfig,
  GraphQLInterfaceTypeConfig,
  GraphQLNamedType,
  GraphQLObjectTypeConfig,
  GraphQLScalarTypeConfig,
  GraphQLSchema,
  GraphQLSchemaConfig,
  GraphQLType,
  GraphQLUnionTypeConfig,
} from "grafast/graphql";
import {
  GraphQLEnumType,
  GraphQLInputObjectType,
  GraphQLInterfaceType,
  GraphQLList,
  GraphQLNonNull,
  GraphQLObjectType,
  GraphQLScalarType,
  GraphQLUnionType,
  isDirective,
  isNamedType,
  isSchema,
  printSchema,
} from "grafast/graphql";
import type { GraphQLSchemaNormalizedConfig } from "graphql/type/schema";
import type { PgSQL, SQL } from "pg-sql2";

import type { ExportOptions } from "./interfaces.js";
import { optimize } from "./optimize/index.js";
import { reservedWords } from "./reservedWords.js";
import { wellKnown } from "./wellKnown.js";

// Cannot import sql because it's optional
//     import { sql } from "pg-sql2";
// Instead:
let sql: PgSQL | undefined;
import("pg-sql2").then(
  (pgSql2) => {
    sql = pgSql2.sql;
  },
  (_e) => {
    // no pg-sql2 module; no matter
  },
);

function isSQL(thing: unknown): thing is SQL {
  if (sql !== undefined) {
    return sql.isSQL(thing);
  } else {
    // An approximation
    if (typeof sql === "object" && sql !== null) {
      return Object.getOwnPropertySymbols(thing).some(
        (s) => s.description === "pg-sql2-type",
      );
    } else {
      return false;
    }
  }
}

// Do **NOT** allow variables that start with `__`!
export const canRepresentAsIdentifier = (key: string) =>
  /^(?:[a-z$]|_[a-z0-9$])[a-z0-9_$]*$/i.test(key);

function identifierOrLiteral(key: string | number) {
  if (typeof key === "number") {
    return t.numericLiteral(key);
  }
  if (canRepresentAsIdentifier(key)) {
    return t.identifier(key);
  } else {
    return t.stringLiteral(key);
  }
}
function literal(key: string | number) {
  if (typeof key === "number") {
    return t.numericLiteral(key);
  } else {
    return t.stringLiteral(key);
  }
}

function locationHintToIdentifierName(locationHint: string): string {
  let result = locationHint;
  result = result.replace(/[[.]/g, "__").replace(/\]/g, "");
  result = result.replace(/[^a-z0-9_]+/gi, "");
  result = result.replace(/^([0-9])/, "_$1");
  if (result.includes("scope")) {
    console.log({ locationHint, result });
  }
  return result;
}

function getNameForThing(
  thing: any,
  locationHint: string,
  baseNameHint: string,
): string {
  if (thing.$exporter$name) {
    return thing.$exporter$name;
  } else if (typeof thing === "function") {
    if (baseNameHint) {
      return baseNameHint;
    }
    const thingName = (thing as any).name ?? (thing as any).displayName ?? null;
    if (thingName) {
      return (baseNameHint ? baseNameHint + "-" : "") + thingName;
    }
    return locationHintToIdentifierName(locationHint);
  } else {
    const thingConstructor = thing.constructor;
    const thingConstructorNameRaw =
      thingConstructor?.$exporter$name ??
      thingConstructor?.name ??
      thingConstructor?.displayName ??
      null;
    const thingConstructorName = ["Array", "Object", "Set", "Map"].includes(
      thingConstructorNameRaw,
    )
      ? null
      : thingConstructorNameRaw;
    const thingName = (thing as any).name ?? (thing as any).displayName ?? null;
    const name =
      thingConstructorName && thingName
        ? `${thingName}${thingConstructorName}`
        : (thingName ?? thingConstructorName ?? null);
    return baseNameHint || name
      ? (baseNameHint ?? "") + (baseNameHint && name ? "-" : "") + (name ?? "")
      : "value";
  }
}

function trimDef(def: string): string {
  const str = def.replace(/\s+/g, " ");
  const PREFIX_LENGTH = 60;
  const SUFFIX_LENGTH = 10;
  if (str.length < PREFIX_LENGTH + SUFFIX_LENGTH + 10) {
    return str;
  } else {
    return (
      str.slice(0, 0 + PREFIX_LENGTH) +
      "..." +
      str.slice(str.length - SUFFIX_LENGTH)
    );
  }
}

//const reallyGenerate = (generate as any).default as typeof generate;
const reallyGenerate = generate;

const templateOptions: TemplateBuilderOptions = {
  plugins: ["typescript"],
};

export function isNotNullish<T>(input: T | null | undefined): input is T {
  return input != null;
}

function isImportable(
  thing: unknown,
): thing is { $$export: { moduleName: string; exportName: string } } {
  return (
    (typeof thing === "object" || typeof thing === "function") &&
    thing !== null &&
    "$$export" in (thing as object | AnyFunction)
  );
}

type AnyFunction = {
  (...args: any[]): any;
  displayName?: string;
};

type ExportedFromFactory<T, TTuple extends any[]> = T & {
  $exporter$args: [...TTuple];
  $exporter$factory: (...args: TTuple) => T;
  $exporter$name: string | undefined;
};

function isExportedFromFactory<T, TTuple extends any[]>(
  thing: T,
): thing is ExportedFromFactory<T, TTuple> {
  return (
    (typeof thing === "object" || typeof thing === "function") &&
    thing !== null &&
    "$exporter$factory" in thing
  );
}

const BUILTINS = ["Int", "Float", "Boolean", "ID", "String"];
function isBuiltinType(type: GraphQLNamedType): boolean {
  return type.name.startsWith("__") || BUILTINS.includes(type.name);
}

const RESERVED_VARIABLES: Record<string, true> = {
  // Reserved variables
  AbortController: true,
  Array: true,
  Buffer: true,
  DOMException: true,
  Error: true,
  Event: true,
  EventTarget: true,
  JSON: true,
  Math: true,
  MessageChannel: true,
  MessageEvent: true,
  MessagePort: true,
  Object: true,
  TextDecoder: true,
  TextEncoder: true,
  URL: true,
  URLSearchParams: true,
  WebAssembly: true,
  __dirname: true,
  __filename: true,
  atob: true,
  btoa: true,
  clearImmediate: true,
  clearInterval: true,
  clearTimeout: true,
  console: true,
  exports: true,
  global: true,
  module: true,
  performance: true,
  process: true,
  queueMicrotask: true,
  require: true,
  setImmediate: true,
  setInterval: true,
  setTimeout: true,
  structuredClone: true,
};
for (const reservedWord of reservedWords) {
  RESERVED_VARIABLES[reservedWord] = true;
}
Object.freeze(RESERVED_VARIABLES);

class CodegenFile {
  _variables: {
    [name: string]: true;
  } = Object.assign(Object.create(null), RESERVED_VARIABLES);

  _imports: {
    [fromModule: string]: {
      [exportName: "default" | "*" | string]: {
        variableName: t.Identifier;
        asType?: boolean;
      };
    };
  } = Object.create(null);

  _types: {
    [typeName: string]: {
      type: GraphQLNamedType;
      variableName: t.Identifier;
      declaration: t.Statement | null;
    };
  } = Object.create(null);

  _directives: {
    [typeName: string]: {
      directive: GraphQLDirective;
      variableName: t.Identifier;
      declaration: t.Statement | null;
    };
  } = Object.create(null);

  _statements: t.Statement[] = [];

  _values: Map<any, t.Expression> = new Map();

  _funcToAstCache: Map<AnyFunction, FunctionExpressionIncludingAttributes> =
    new Map();

  constructor(public options: ExportOptions) {}

  addStatements(statements: t.Statement | t.Statement[]): void {
    if (Array.isArray(statements)) {
      this._statements.push(...statements);
    } else {
      this._statements.push(statements);
    }
  }

  makeVariable(preferredName: string): t.Identifier {
    const allowedName = preferredName.replace(/[^_a-z0-9]+/gi, "_");
    for (let i = 0; i < 10000; i++) {
      const variableName = allowedName + (i > 0 ? String(i + 1) : "");
      if (!this._variables[variableName]) {
        this._variables[variableName] = true;
        return t.identifier(variableName);
      }
    }
    throw new Error("Could not find a suitable variable name");
  }

  import(
    fromModule: string,
    exportNames: "default" | "*" | string | string[] = "default",
    asType = false,
  ): t.Identifier | t.MemberExpression {
    if (Array.isArray(exportNames)) {
      const [exportName, ...path] = exportNames;
      if (!exportName) {
        throw new Error("Could not determine the export name");
      }
      const variable = this.importOnly(fromModule, exportName, asType);
      if (path.length) {
        let result: t.Node = variable;
        for (const pathSegment of path) {
          result = t.memberExpression(result, identifierOrLiteral(pathSegment));
        }
        return result;
      } else {
        return variable;
      }
    } else {
      const variable = this.importOnly(fromModule, exportNames, asType);
      return variable;
    }
  }

  importOnly(
    fromModule: string,
    exportName: "default" | "*" | string = "default",
    asType = false,
  ): t.Identifier {
    const importedModule =
      this._imports[fromModule] ??
      (this._imports[fromModule] = Object.create(
        null,
      ) as (typeof this._imports)[string]);
    const existing = importedModule[exportName];
    if (existing) {
      if (!asType) {
        existing.asType = false;
      }
      return existing.variableName;
    } else {
      const preferredName =
        exportName === "default" || exportName === "*"
          ? fromModule
          : exportName;
      const variableName = this.makeVariable(preferredName);
      importedModule[exportName] = {
        variableName,
        asType,
      };
      return variableName;
    }
  }

  declareType(type: GraphQLNamedType): t.Identifier {
    const existing = this._types[type.name];
    if (existing) {
      if (existing.type !== type) {
        throw new Error("Duplicate types with same name found! Error!");
      }
      return existing.variableName;
    }
    if (BUILTINS.includes(type.name)) {
      return this.importOnly("graphql", "GraphQL" + type.name);
    }
    if (isBuiltinType(type)) {
      throw new Error(
        `declareType called with introspection type '${type.name}'`,
      );
    }
    const VARIABLE_NAME = this.makeVariable(type.name);
    const spec: CodegenFile["_types"][string] = {
      type,
      variableName: VARIABLE_NAME,
      declaration: null,
    };
    this._types[type.name] = spec;
    // Must perform declaration _AFTER_ registering type, otherwise we might
    // get infinite recursion.
    spec.declaration = this.makeTypeDeclaration(type, VARIABLE_NAME);
    this.addStatements(spec.declaration);
    return VARIABLE_NAME;
  }

  declareDirective(directive: GraphQLDirective): t.Identifier {
    const existing = this._directives[directive.name];
    if (existing) {
      if (existing.directive !== directive) {
        throw new Error("Duplicate types with same name found! Error!");
      }
      return existing.variableName;
    }
    const config = directive.toConfig();
    const VARIABLE_NAME = this.makeVariable(config.name);
    const spec: CodegenFile["_directives"][string] = {
      directive,
      variableName: VARIABLE_NAME,
      declaration: null,
    };
    this._directives[config.name] = spec;
    const locationHint = `@${config.name}`;
    // Must perform declaration _AFTER_ registering type, otherwise we might
    // get infinite recursion.
    const iDirectiveLocation = this.import("graphql", "DirectiveLocation");
    spec.declaration = declareGraphQLEntity(
      this,
      VARIABLE_NAME,
      "GraphQLDirective",
      {
        name: t.stringLiteral(config.name),
        description: desc(config.description),
        locations: t.arrayExpression(
          config.locations.map((l) =>
            t.memberExpression(
              iDirectiveLocation,
              identifierOrLiteral(String(l)),
            ),
          ),
        ),
        args:
          config.args && Object.keys(config.args).length > 0
            ? this.makeFieldArgs(
                config.args,
                `${locationHint}.args`,
                `@${config.name}.args`,
              )
            : null,
        isRepeatable: t.booleanLiteral(config.isRepeatable),
        extensions: extensions(
          this,
          config.extensions,
          `${config.name}.extensions`,
          `@${config.name}.extensions`,
        ),
      },
    );
    this.addStatements(spec.declaration);
    return VARIABLE_NAME;
  }

  private typeExpression(type: GraphQLType): t.Expression {
    if (type instanceof GraphQLNonNull) {
      const iGraphQLNonNull = this.import("graphql", "GraphQLNonNull");
      return t.newExpression(iGraphQLNonNull, [
        this.typeExpression(type.ofType),
      ]);
    } else if (type instanceof GraphQLList) {
      const iGraphQLList = this.import("graphql", "GraphQLList");
      return t.newExpression(iGraphQLList, [this.typeExpression(type.ofType)]);
    } else {
      return this.declareType(type);
    }
  }

  private makeEnumValue(
    config: GraphQLEnumValueConfig,
    typeName: string,
    enumValueName: string,
  ): t.Expression {
    const locationHint = `${typeName}.values[${JSON.stringify(enumValueName)}]`;
    const mappedConfig: {
      [key in keyof GraphQLEnumValueConfig as Exclude<
        keyof GraphQLEnumValueConfig,
        "astNode"
      >]-?: t.Expression | null;
    } = {
      description: desc(config.description),
      value: convertToIdentifierViaAST(
        this,
        config.value,
        `${typeName}.${enumValueName}`,
        `${locationHint}.value`,
      ),
      extensions: extensions(
        this,
        config.extensions,
        `${locationHint}.extensions`,
        `${typeName}.extensions`,
      ),
      deprecationReason: desc(config.deprecationReason),
    };
    return configToAST(mappedConfig);
  }

  // For objects and interfaces
  private makeObjectFields(
    fields: GraphQLFieldConfigMap<any, any>,
    typeName: string,
  ): t.Expression {
    const obj = Object.entries(fields).reduce(
      (memo, [fieldName, config]) => {
        if (!fieldName.startsWith("__")) {
          const locationHint = `${typeName}.fields[${fieldName}]`;
          const mappedConfig: {
            [key in keyof GraphQLFieldConfig<any, any> as Exclude<
              keyof GraphQLFieldConfig<any, any>,
              "astNode"
            >]-?: t.Expression | null;
          } = {
            description: desc(config.description),
            type: this.typeExpression(config.type),
            args:
              config.args && Object.keys(config.args).length > 0
                ? this.makeFieldArgs(
                    config.args,
                    `${typeName}.fields[${fieldName}].args`,
                    `${typeName}.${fieldName}`,
                  )
                : null,
            resolve: config.resolve
              ? func(
                  this,
                  config.resolve,
                  `${locationHint}.resolve`,
                  `${typeName}.${fieldName}.resolve`,
                )
              : null,
            subscribe: config.subscribe
              ? func(
                  this,
                  config.subscribe,
                  `${locationHint}.subscribe`,
                  `${typeName}.${fieldName}.subscribe`,
                )
              : null,
            deprecationReason: desc(config.deprecationReason),
            extensions: extensions(
              this,
              config.extensions,
              `${locationHint}.extensions`,
              `${typeName}.${fieldName}.extensions`,
            ),
          };
          memo[fieldName] = configToAST(mappedConfig);
        }
        return memo;
      },
      {} as { [key: string]: t.Expression | null },
    );
    return t.objectExpression(objectToObjectProperties(obj));
  }

  private makeInputObjectFields(
    fields: GraphQLInputFieldConfigMap,
    typeName: string,
  ): t.Expression {
    const obj = Object.entries(fields).reduce(
      (memo, [fieldName, config]) => {
        if (!fieldName.startsWith("__")) {
          const locationHint = `${typeName}.fields[${fieldName}]`;
          const mappedConfig: {
            [key in keyof GraphQLInputFieldConfig as Exclude<
              keyof GraphQLInputFieldConfig,
              "astNode"
            >]-?: t.Expression | null;
          } = {
            description: desc(config.description),
            type: this.typeExpression(config.type),
            defaultValue:
              config.defaultValue !== undefined
                ? convertToIdentifierViaAST(
                    this,
                    config.defaultValue,
                    `${typeName}.${fieldName}.defaultValue`,
                    `${locationHint}.defaultValue`,
                  )
                : null,
            deprecationReason: desc(config.deprecationReason),
            extensions: extensions(
              this,
              config.extensions,
              `${locationHint}.extensions`,
              `${typeName}.${fieldName}.extensions`,
            ),
          };
          memo[fieldName] = configToAST(mappedConfig);
        }
        return memo;
      },
      {} as { [key: string]: t.Expression | null },
    );
    return t.objectExpression(objectToObjectProperties(obj));
  }

  private makeFieldArgs(
    args: GraphQLFieldConfigArgumentMap,
    baseLocationHint: string,
    nameHint: string,
  ): t.Expression {
    const obj = Object.entries(args).reduce(
      (memo, [argName, config]) => {
        if (!argName.startsWith("__")) {
          const locationHint = `${baseLocationHint}[${argName}]`;
          const mappedConfig: {
            [key in keyof GraphQLArgumentConfig as Exclude<
              keyof GraphQLArgumentConfig,
              "astNode"
            >]-?: t.Expression | null;
          } = {
            description: desc(config.description),
            type: this.typeExpression(config.type),
            defaultValue:
              config.defaultValue !== undefined
                ? convertToIdentifierViaAST(
                    this,
                    config.defaultValue,
                    `${nameHint}.${argName}.defaultValue`,
                    `${locationHint}.defaultValue`,
                  )
                : null,
            deprecationReason: desc(config.deprecationReason),
            extensions: extensions(
              this,
              config.extensions,
              `${locationHint}.extensions`,
              `${nameHint}.${argName}.extensions`,
            ),
          };
          memo[argName] = configToAST(mappedConfig);
        }
        return memo;
      },
      {} as { [key: string]: t.Expression | null },
    );
    return t.objectExpression(objectToObjectProperties(obj));
  }

  private makeTypeDeclaration(
    type: GraphQLNamedType,
    VARIABLE_NAME: t.Identifier,
  ): t.Statement {
    if (type instanceof GraphQLObjectType) {
      const config = type.toConfig();
      return declareGraphQLEntity(this, VARIABLE_NAME, "GraphQLObjectType", {
        name: t.stringLiteral(config.name),
        description: desc(config.description),
        isTypeOf: config.isTypeOf
          ? func(
              this,
              config.isTypeOf,
              `${config.name}.isTypeOf`,
              `${config.name}.isTypeOf`,
            )
          : null,
        extensions: extensions(
          this,
          config.extensions,
          `${config.name}.extensions`,
          `${config.name}.extensions`,
        ),
        fields: t.arrowFunctionExpression(
          [],
          this.makeObjectFields(config.fields, config.name),
        ),
        interfaces:
          config.interfaces.length > 0
            ? t.arrowFunctionExpression(
                [],
                t.arrayExpression(
                  config.interfaces.map((interfaceType) =>
                    this.declareType(interfaceType),
                  ),
                ),
              )
            : null,
      });
    } else if (type instanceof GraphQLInterfaceType) {
      const config = type.toConfig();
      return declareGraphQLEntity(this, VARIABLE_NAME, "GraphQLInterfaceType", {
        name: t.stringLiteral(config.name),
        description: desc(config.description),
        resolveType: config.resolveType
          ? func(
              this,
              config.resolveType,
              `${config.name}.resolveType`,
              `${config.name}.resolveType`,
            )
          : null,
        extensions: extensions(
          this,
          config.extensions,
          `${config.name}.extensions`,
          `${config.name}.extensions`,
        ),
        fields: t.arrowFunctionExpression(
          [],
          this.makeObjectFields(config.fields, config.name),
        ),
        interfaces:
          config.interfaces.length > 0
            ? t.arrayExpression(
                config.interfaces.map((interfaceType) =>
                  this.declareType(interfaceType),
                ),
              )
            : null,
      });
    } else if (type instanceof GraphQLUnionType) {
      const config = type.toConfig();
      return declareGraphQLEntity(this, VARIABLE_NAME, "GraphQLUnionType", {
        name: t.stringLiteral(config.name),
        description: desc(config.description),
        resolveType: config.resolveType
          ? func(
              this,
              config.resolveType,
              `${config.name}.resolveType`,
              `${config.name}.resolveType`,
            )
          : null,
        extensions: extensions(
          this,
          config.extensions,
          `${config.name}.extensions`,
          `${config.name}.extensions`,
        ),
        types: t.arrowFunctionExpression(
          [],
          t.arrayExpression(config.types.map((t) => this.declareType(t))),
        ),
      });
    } else if (type instanceof GraphQLInputObjectType) {
      const config = type.toConfig();
      return declareGraphQLEntity(
        this,
        VARIABLE_NAME,
        "GraphQLInputObjectType",
        {
          name: t.stringLiteral(config.name),
          description: desc(config.description),
          extensions: extensions(
            this,
            config.extensions,
            `${config.name}.extensions`,
            `${config.name}.extensions`,
          ),
          fields: t.arrowFunctionExpression(
            [],
            this.makeInputObjectFields(config.fields, config.name),
          ),
        },
      );
    } else if (type instanceof GraphQLScalarType) {
      const config = type.toConfig();
      return declareGraphQLEntity(this, VARIABLE_NAME, "GraphQLScalarType", {
        name: t.stringLiteral(config.name),
        description: desc(config.description),
        specifiedByURL: desc(config.specifiedByURL),
        serialize: func(
          this,
          config.serialize,
          `${config.name}.serialize`,
          `${config.name}.serialize`,
        ),
        parseValue: func(
          this,
          config.parseValue,
          `${config.name}.parseValue`,
          `${config.name}.parseValue`,
        ),
        parseLiteral: func(
          this,
          config.parseLiteral,
          `${config.name}.parseLiteral`,
          `${config.name}.parseLiteral`,
        ),
        extensions: extensions(
          this,
          config.extensions,
          `${config.name}.extensions`,
          `${config.name}.extensions`,
        ),
      });
    } else if (type instanceof GraphQLEnumType) {
      const config = type.toConfig();
      return declareGraphQLEntity(this, VARIABLE_NAME, "GraphQLEnumType", {
        name: t.stringLiteral(config.name),
        description: desc(config.description),
        extensions: extensions(
          this,
          config.extensions,
          `${config.name}.extensions`,
          `${config.name}.extensions`,
        ),
        values: objectNullPrototype(
          Object.entries(config.values).map(([key, value]) =>
            t.objectProperty(
              identifierOrLiteral(key),
              this.makeEnumValue(value, config.name, key),
            ),
          ),
        ),
      });
    } else {
      const never: never = type;
      throw new Error(
        `Did not understand type: ${(never as any).constructor.name}`,
      );
    }
  }

  toAST(): t.File {
    const importStatements: t.Statement[] = [];
    Object.keys(this._imports)
      .sort()
      .forEach((moduleName) => {
        const importedModule = this._imports[moduleName];
        const MODULE_NAME = t.stringLiteral(moduleName);
        if (!importedModule) {
          return;
        }
        const {
          "*": starImport,
          default: defaultImport,
          ...rest
        } = importedModule;
        if (starImport) {
          const VARIABLE_NAME = starImport.variableName;
          importStatements.push(
            starImport.asType
              ? importStarAsType({ MODULE_NAME, VARIABLE_NAME })
              : importStar({ MODULE_NAME, VARIABLE_NAME }),
          );
        }
        const exportNames = Object.keys(rest).sort();
        if (defaultImport || exportNames.length > 0) {
          const importStatement = t.importDeclaration(
            [
              ...(defaultImport
                ? [t.importDefaultSpecifier(defaultImport.variableName)]
                : []),
              ...(exportNames.length
                ? exportNames.map((name) =>
                    t.importSpecifier(
                      rest[name]!.variableName,
                      t.identifier(name),
                    ),
                  )
                : []),
            ],
            MODULE_NAME,
          );
          importStatements.push(importStatement);
        }
      });
    const allStatements = [...importStatements, ...this._statements];
    return t.file(t.program(allStatements));
  }
}

const importStarAsType = template.statement(
  `\
import type VARIABLE_NAME from MODULE_NAME;
`,
  templateOptions,
);
/**
 * A manual way of doing this (which doesn't seem to work).
 *
 * ```
 * const importStar = template.statement(
 *   `import * as VARIABLE_NAME from MODULE_NAME;`,
 *   templateOptions,
 * );
 * ```
 */
const importStar = (args: {
  VARIABLE_NAME: t.Identifier;
  MODULE_NAME: t.StringLiteral;
}) =>
  t.importDeclaration(
    [t.importNamespaceSpecifier(args.VARIABLE_NAME)],
    args.MODULE_NAME,
  );

const declareConstructorWithConfig = template.statement(
  `\
export const VARIABLE_NAME = new CONSTRUCTOR(CONFIG);
`,
  templateOptions,
);

type GraphQLEntityName =
  | "GraphQLSchema"
  | "GraphQLDirective"
  | "GraphQLObjectType"
  | "GraphQLInterfaceType"
  | "GraphQLUnionType"
  | "GraphQLInputObjectType"
  | "GraphQLScalarType"
  | "GraphQLEnumType";
type ConfigForGraphQLEntity<TKey extends GraphQLEntityName> =
  TKey extends "GraphQLSchema"
    ? GraphQLSchemaConfig
    : TKey extends "GraphQLDirective"
      ? GraphQLDirectiveConfig
      : TKey extends "GraphQLObjectType"
        ? GraphQLObjectTypeConfig<unknown, unknown>
        : TKey extends "GraphQLInterfaceType"
          ? GraphQLInterfaceTypeConfig<unknown, unknown>
          : TKey extends "GraphQLUnionType"
            ? GraphQLUnionTypeConfig<unknown, unknown>
            : TKey extends "GraphQLInputObjectType"
              ? GraphQLInputObjectTypeConfig
              : TKey extends "GraphQLScalarType"
                ? GraphQLScalarTypeConfig<unknown, unknown>
                : TKey extends "GraphQLEnumType"
                  ? GraphQLEnumTypeConfig
                  : never;

function declareGraphQLEntity<TKey extends GraphQLEntityName>(
  file: CodegenFile,
  VARIABLE_NAME: t.Identifier,
  constructorName: TKey,
  config: {
    [key in keyof ConfigForGraphQLEntity<TKey> as Exclude<
      keyof ConfigForGraphQLEntity<TKey>,
      "astNode" | "extensionASTNodes"
    >]-?: t.Expression | null;
  },
) {
  return declareConstructorWithConfig({
    VARIABLE_NAME,
    CONSTRUCTOR: file.import("graphql", constructorName),
    CONFIG: configToAST(config),
  });
}

function desc(description: string | null | undefined): t.Expression | null {
  return description ? t.stringLiteral(description) : null;
}

/**
 * Returns if the key can be used as a regular object key (and will be seen as
 * one of the "own" properties of the object) when created using object literal
 * syntax.
 *
 * I.e. returns `true` unless key is `__proto__`
 *
 * @see {@link https://tc39.es/ecma262/#sec-runtime-semantics-propertydefinitionevaluation}
 */
function canBeRegularObjectKey(key: string): boolean {
  return key !== "__proto__";
}

function _convertToAST(
  file: CodegenFile,
  thing: unknown,
  locationHint: string,
  nameHint: string,
  depth: number,
  reference: t.Expression,
): t.Expression {
  const handleSubvalue = (
    value: any,
    tKey: t.Expression,
    key: string | number,
  ) => {
    const existingIdentifier = getExistingIdentifier(file, value);
    if (existingIdentifier) {
      return existingIdentifier;
    } else if (isExportedFromFactory(value)) {
      const val = convertToIdentifierViaAST(
        file,
        value,
        nameHint + `.${key}`,
        locationHint + `[${JSON.stringify(key)}]`,
        depth + 1,
      );
      return val;
    } else {
      const newReference = t.memberExpression(
        reference,
        tKey,
        !t.isIdentifier(tKey),
      );
      file._values.set(value, newReference);