convert-schema-enum-to-declaration-block-string.ts

import {
  isEnumType,
  type EnumTypeDefinitionNode,
  type EnumValueDefinitionNode,
  type GraphQLSchema,
} from 'graphql';
import { convertName } from './naming.js';
import type { ConvertFn, ParsedEnumValuesMap } from './types.js';
import {
  DeclarationBlock,
  getNodeComment,
  indent,
  transformComment,
  wrapWithSingleQuotes,
  type DeclarationBlockConfig,
} from './utils.js';

export interface ConvertSchemaEnumToDeclarationBlockString {
  schema: GraphQLSchema;
  node: EnumTypeDefinitionNode;
  enumName: string;
  enumValues: ParsedEnumValuesMap;
  futureProofEnums: boolean;
  ignoreEnumValuesFromSchema: boolean;
  naming: {
    convert: ConvertFn;
    options: {
      typesPrefix: string;
      typesSuffix: string;
      useTypesPrefix?: boolean;
      useTypesSuffix?: boolean;
    };
  };

  outputType: 'string-literal' | 'native-numeric' | 'const' | 'native-const' | 'native';
  declarationBlockConfig: DeclarationBlockConfig;
}

export const convertSchemaEnumToDeclarationBlockString = ({
  schema,
  node,
  enumName,
  enumValues,
  futureProofEnums,
  ignoreEnumValuesFromSchema,
  outputType,
  declarationBlockConfig,
  naming,
}: ConvertSchemaEnumToDeclarationBlockString): string => {
  if (enumValues[enumName]?.sourceFile) {
    return `export { ${enumValues[enumName].typeIdentifierConverted} };\n`;
  }

  const getValueFromConfig = (enumValue: string | number) => {
    if (typeof enumValues[enumName]?.mappedValues?.[enumValue] !== 'undefined') {
      return enumValues[enumName].mappedValues[enumValue];
    }
    return null;
  };

  const withFutureAddedValue = [
    futureProofEnums ? [indent('| ' + wrapWithSingleQuotes('%future added value'))] : [],
  ];

  const enumTypeName = convertName({
    convert: () => naming.convert(node),
    options: naming.options,
  });

  if (outputType === 'string-literal') {
    return new DeclarationBlock(declarationBlockConfig)
      .export()
      .asKind('type')
      .withComment(node.description?.value)
      .withName(enumTypeName)
      .withContent(
        '\n' +
          (node.values || [])
            .map(enumOption => {
              const name = enumOption.name.value;
              const enumValue: string | number = getValueFromConfig(name) ?? name;
              const comment = transformComment(enumOption.description?.value, 1);

              return comment + indent('| ' + wrapWithSingleQuotes(enumValue));
            })
            .concat(...withFutureAddedValue)
            .join('\n'),
      ).string;
  }

  if (outputType === 'native-numeric') {
    return new DeclarationBlock(declarationBlockConfig)
      .export()
      .withComment(node.description?.value)
      .withName(enumTypeName)
      .asKind('enum')
      .withBlock(
        (node.values || [])
          .map((enumOption, i) => {
            const valueFromConfig = getValueFromConfig(enumOption.name.value);
            const enumValue: string | number = valueFromConfig ?? i;
            const comment = transformComment(enumOption.description?.value, 1);
            const optionName = makeValidEnumIdentifier(
              convertName({
                options: {
                  typesPrefix: naming.options.typesPrefix,
                  typesSuffix: naming.options.typesSuffix,
                  useTypesPrefix: false,
                },
                convert: () => naming.convert(enumOption, { transformUnderscore: true }),
              }),
            );
            return comment + indent(optionName) + ` = ${enumValue}`;
          })
          .concat(...withFutureAddedValue)
          .join(',\n'),
      ).string;
  }

  if (outputType === 'const') {
    const typeName = `export type ${enumTypeName} = typeof ${enumTypeName}[keyof typeof ${enumTypeName}];`;
    const enumAsConst = new DeclarationBlock({
      ...declarationBlockConfig,
      blockTransformer: block => {
        return block + ' as const';
      },
    })
      .export()
      .asKind('const')
      .withName(enumTypeName)
      .withComment(node.description?.value)
      .withBlock(
        (node.values || [])
          .map(enumOption => {
            const optionName = makeValidEnumIdentifier(
              convertName({
                options: {
                  typesPrefix: naming.options.typesPrefix,
                  typesSuffix: naming.options.typesSuffix,
                },
                convert: () =>
                  naming.convert(enumOption, {
                    transformUnderscore: true,
                  }),
              }),
            );
            const comment = transformComment(enumOption.description?.value, 1);
            const name = enumOption.name.value;
            const enumValue: string | number = getValueFromConfig(name) ?? name;

            return comment + indent(`${optionName}: ${wrapWithSingleQuotes(enumValue)}`);
          })
          .join(',\n'),
      ).string;

    return [enumAsConst, typeName].join('\n');
  }

  return new DeclarationBlock(declarationBlockConfig)
    .export()
    .asKind(outputType === 'native-const' ? 'const enum' : 'enum')
    .withName(enumTypeName)
    .withComment(node.description?.value)
    .withBlock(
      buildEnumValuesBlock({
        typeName: enumName,
        values: node.values || [],
        schema,
        naming,
        ignoreEnumValuesFromSchema,
        declarationBlockConfig,
        enumValues,
      }),
    ).string;
};

export const buildEnumValuesBlock = ({
  typeName,
  values,
  schema,
  naming,
  ignoreEnumValuesFromSchema,
  declarationBlockConfig,
  enumValues,
}: Pick<
  ConvertSchemaEnumToDeclarationBlockString,
  'schema' | 'naming' | 'ignoreEnumValuesFromSchema' | 'declarationBlockConfig' | 'enumValues'
> & {
  typeName: string;
  values: ReadonlyArray<EnumValueDefinitionNode>;
}): string => {
  const schemaType = schema?.getType(typeName);
  const schemaEnumType = isEnumType(schemaType) ? schemaType : undefined;

  return values
    .map(enumOption => {
      const onlyUnderscoresPattern = /^_+$/;
      const optionName = makeValidEnumIdentifier(
        convertName({
          options: {
            useTypesPrefix: false,
            typesPrefix: naming.options.typesPrefix,
            typesSuffix: naming.options.typesSuffix,
          },
          convert: () =>
            naming.convert(enumOption, {
              // We can only strip out the underscores if the value contains other
              // characters. Otherwise we'll generate syntactically invalid code.
              transformUnderscore: !onlyUnderscoresPattern.test(enumOption.name.value),
            }),
        }),
      );
      const comment = getNodeComment(enumOption);
      let schemaEnumValue;
      if (schemaEnumType && !ignoreEnumValuesFromSchema) {
        const schemaEnumValueDefinition = schemaEnumType.getValue(enumOption.name.value);
        if (!schemaEnumValueDefinition) {
          throw new Error(
            `Enum value "${enumOption.name.value}" is not defined on enum "${typeName}" in the schema`,
          );
        }
        schemaEnumValue = schemaEnumValueDefinition.value;
      }
      let enumValue: string | number =
        typeof schemaEnumValue === 'undefined' ? enumOption.name.value : schemaEnumValue;

      if (typeof enumValues[typeName]?.mappedValues?.[enumValue] !== 'undefined') {
        enumValue = enumValues[typeName].mappedValues[enumValue];
      }

      return (
        comment +
        indent(
          `${optionName}${declarationBlockConfig.enumNameValueSeparator} ${wrapWithSingleQuotes(
            enumValue,
            typeof schemaEnumValue !== 'undefined',
          )}`,
        )
      );
    })
    .join(',\n');
};

const makeValidEnumIdentifier = (identifier: string): string => {
  if (/^[0-9]/.exec(identifier)) {
    return wrapWithSingleQuotes(identifier, true);
  }
  return identifier;
};