@gql2ts/from-query/dist/index.js

generate typescript interfaces from a graphql schema and query

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const graphql_1 = require("graphql");
const util_1 = require("@gql2ts/util");
const language_typescript_1 = require("@gql2ts/language-typescript");
const flattenQuery_1 = require("./flattenQuery");
const ir_1 = require("./ir");
const generate_1 = require("./generate");
const doIt = (schema, query, typeMap = {}, providedOptions = {}) => {
    const options = Object.assign({}, language_typescript_1.DEFAULT_OPTIONS, providedOptions, { typeMap: Object.assign({}, language_typescript_1.DEFAULT_TYPE_MAP, language_typescript_1.DEFAULT_OPTIONS.typeMap, (providedOptions.typeMap ? providedOptions.typeMap : {}), typeMap) });
    const { wrapList, printType, formatInput, generateQueryName, interfaceBuilder, generateInterfaceDeclaration, exportFunction, postProcessor, generateInputName, typeMap: TypeMap, } = options;
    const parsedSchema = util_1.schemaFromInputs(schema);
    const parsedSelection = graphql_1.parse(query);
    const handleInputObject = (type, isNonNull) => {
        const variables = Object.keys(type.getFields()).map(k => type.getFields()[k]);
        const variableDeclarations = variables.map(v => {
            // TODO fix this
            const convertedType = convertToType(v.type);
            return formatInput(v.name, convertedType.endsWith('null'), convertedType);
        });
        const builder = generateInterfaceDeclaration(variableDeclarations);
        return printType(builder, isNonNull);
    };
    const typeUnion = types => types.join(' | ');
    const handleEnum = (type, isNonNull) => (printType(typeUnion(type.getValues().map(({ value }) => `'${value}'`)), isNonNull));
    const handleNamedTypeInput = (type, isNonNull) => {
        if (type.kind === 'NamedType' && type.name.kind === 'Name' && type.name.value) {
            const newType = parsedSchema.getType(type.name.value);
            if (newType instanceof graphql_1.GraphQLEnumType) {
                return handleEnum(newType, isNonNull);
            }
            else if (newType instanceof graphql_1.GraphQLInputObjectType) {
                return handleInputObject(newType, isNonNull);
            }
        }
    };
    const handleRegularType = (type, isNonNull, replacement) => {
        const typeValue = (typeof type.name === 'string') ? type.toString() : type.name.value;
        const showValue = replacement || typeValue;
        const show = TypeMap[showValue] || (replacement ? showValue : TypeMap.__DEFAULT);
        return printType(show, isNonNull);
    };
    const convertVariable = (type, isNonNull = false, replacement = null) => {
        if (type.kind === 'ListType') {
            return printType(wrapList(convertVariable(type.type, false, replacement)), isNonNull);
        }
        else if (type.kind === 'NonNullType') {
            return convertVariable(type.type, true, replacement);
        }
        else {
            return handleNamedTypeInput(type, isNonNull) || handleRegularType(type, isNonNull, replacement);
        }
    };
    const convertToType = (type, isNonNull = false, replacement = null) => {
        if (util_1.isList(type)) {
            return printType(wrapList(convertToType(type.ofType, false, replacement)), isNonNull);
        }
        else if (util_1.isNonNullable(type)) {
            return convertToType(type.ofType, true, replacement);
        }
        else if (util_1.isEnum(type)) {
            return handleEnum(type, isNonNull);
        }
        else if (type instanceof graphql_1.GraphQLInputObjectType) {
            return handleInputObject(type, isNonNull);
        }
        else {
            return handleRegularType(type, isNonNull, replacement);
        }
    };
    const getVariables = variables => (variables.map(v => {
        const optional = v.type.kind !== 'NonNullType';
        return formatInput(v.variable.name.value, optional, convertVariable(v.type));
    }));
    const variablesToInterface = (opName, variables) => {
        if (!variables || !variables.length) {
            return '';
        }
        const variableTypeDefs = getVariables(variables);
        return exportFunction(interfaceBuilder(generateInputName(opName), generateInterfaceDeclaration(variableTypeDefs)));
    };
    const flattenedQuery = flattenQuery_1.flattenFragments(parsedSelection, parsedSchema);
    const internalRepresentation = ir_1.default(parsedSchema, flattenedQuery);
    const variableInterfaces = parsedSelection.definitions.map(def => {
        if (def.kind !== 'OperationDefinition') {
            return '';
        }
        const ifaceName = generateQueryName(def);
        return variablesToInterface(ifaceName, def.variableDefinitions);
    });
    return postProcessor(util_1.filterAndJoinArray([
        generate_1.default(options)(internalRepresentation),
        '\n',
        ...variableInterfaces // Query / Mutation variable interfaces. TODO: Move into IR.extractVariables
    ]));
};
exports.default = doIt;
//# sourceMappingURL=index.js.map