graphql-typescript-definitions/lib/print/document/language.js

"use strict";
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const t = __importStar(require("@babel/types"));
const graphql_1 = require("graphql");
const graphql_tool_utilities_1 = require("graphql-tool-utilities");
const utilities_1 = require("../utilities");
function tsInterfaceBodyForObjectField({ fields = [] }, graphQLType, stack, context, requiresTypename = false) {
    const { schema } = context.ast;
    const isRootType = !Array.isArray(graphQLType) &&
        (graphQLType === schema.getQueryType() ||
            graphQLType === schema.getMutationType() ||
            graphQLType === schema.getSubscriptionType());
    const uniqueFields = fields.filter((field) => {
        if (stack.hasSeenField(field)) {
            return false;
        }
        stack.sawField(field);
        return true;
    });
    const typenameField = {
        fieldName: '__typename',
        responseName: '__typename',
        type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString),
        isConditional: false,
    };
    const typename = ((context.options.addTypename && !isRootType) || requiresTypename) &&
        !stack.hasSeenField(typenameField)
        ? tsPropertyForField(typenameField, graphQLType, stack, context, requiresTypename)
        : null;
    const body = uniqueFields.map((field) => tsPropertyForField(field, graphQLType, stack, context, requiresTypename));
    return t.tsInterfaceBody(typename ? [typename, ...body] : body);
}
exports.tsInterfaceBodyForObjectField = tsInterfaceBodyForObjectField;
function tsTypeForInlineFragment(inlineFragment, _graphQLType, stack, context, requiresTypename = false) {
    const { typeCondition } = inlineFragment;
    const interfaceDeclaration = t.tsInterfaceDeclaration(t.identifier(stack.name), null, null, tsInterfaceBodyForObjectField(inlineFragment, typeCondition, stack, context, requiresTypename));
    return context.export(interfaceDeclaration);
}
function tsTypeForObjectField(field, graphQLType, stack, context) {
    const { inlineFragments = [] } = field;
    const possibleTypes = graphql_1.isInterfaceType(graphQLType) || graphql_1.isUnionType(graphQLType)
        ? context.ast.schema.getPossibleTypes(graphQLType)
        : [];
    if (inlineFragments.length) {
        const fragmentTypes = [...inlineFragments].map((inlineFragment) => tsTypeForInlineFragment(inlineFragment, graphQLType, stack.fragment(inlineFragment.typeCondition), context, context.options.partial));
        const typesCoveredByInlineFragments = new Set([...inlineFragments].reduce((types, inlineFragment) => [...types, ...inlineFragment.possibleTypes], []));
        const missingPossibleTypes = possibleTypes.filter((possibleType) => {
            return !typesCoveredByInlineFragments.has(possibleType);
        });
        const otherStack = stack.fragment();
        const otherTypeInterface = t.tsInterfaceDeclaration(t.identifier(otherStack.name), null, null, tsInterfaceBodyForObjectField(field, missingPossibleTypes, otherStack, context, context.options.partial));
        const otherType = context.export(otherTypeInterface);
        return t.tsUnionType([...fragmentTypes, otherType]);
    }
    else if (possibleTypes.length === 1) {
        // When we have an interface or union type, but no inline fragments, it
        // means that there is only one conforming type for the union/ interface.
        // Here, we construct a "nothing" type that stands in for future additions
        // to the membership of the union/ interface.
        const otherStack = stack.fragment();
        const otherTypeInterface = t.tsInterfaceDeclaration(t.identifier(otherStack.name), null, null, tsInterfaceBodyForObjectField({ fields: [] }, [], otherStack, context, context.options.partial));
        const interfaceStack = stack.fragment(possibleTypes[0]);
        const interfaceDeclaration = t.tsInterfaceDeclaration(t.identifier(interfaceStack.name), null, null, tsInterfaceBodyForObjectField(field, graphQLType, interfaceStack, context));
        return t.tsUnionType([
            context.export(interfaceDeclaration),
            context.export(otherTypeInterface),
        ]);
    }
    const interfaceDeclaration = t.tsInterfaceDeclaration(t.identifier(stack.name), null, null, tsInterfaceBodyForObjectField(field, graphQLType, stack, context));
    return context.export(interfaceDeclaration);
}
function tsTypenameForGraphQLType(type) {
    return t.tsLiteralType(t.stringLiteral(type.name));
}
function tsPropertyForField(field, parentType, stack, context, isRequiredTypename = false) {
    if (field.fieldName === '__typename' && parentType) {
        const optional = !isRequiredTypename &&
            (context.options.partial ||
                field.isConditional ||
                !graphql_1.isNonNullType(field.type));
        const parentTypes = Array.isArray(parentType) ? parentType : [parentType];
        const allPossibleTypes = parentTypes.reduce((all, type) => [
            ...all,
            ...(graphql_1.isAbstractType(type)
                ? context.ast.schema.getPossibleTypes(type)
                : [type]),
        ], []);
        let typename;
        if (allPossibleTypes.length === 0) {
            typename = t.tsLiteralType(t.stringLiteral(''));
        }
        else if (allPossibleTypes.length > 1) {
            typename = t.tsUnionType(allPossibleTypes.map(tsTypenameForGraphQLType));
        }
        else {
            typename = tsTypenameForGraphQLType(allPossibleTypes[0]);
        }
        const typenameProperty = t.tsPropertySignature(t.identifier(field.responseName), optional
            ? t.tsTypeAnnotation(t.tsUnionType([typename, t.tsNullKeyword()]))
            : t.tsTypeAnnotation(typename));
        typenameProperty.optional = optional;
        return typenameProperty;
    }
    const property = t.tsPropertySignature(t.identifier(field.responseName), t.tsTypeAnnotation(tsTypeForGraphQLType(field.type, field, stack, context)));
    property.optional =
        context.options.partial ||
            field.isConditional ||
            !graphql_1.isNonNullType(field.type);
    return property;
}
function tsTypeForGraphQLType(graphQLType, field, stack, context) {
    let type;
    const forceNullable = context.options.partial ||
        (field.isConditional && graphQLType === field.type);
    const isNonNull = !forceNullable && graphql_1.isNonNullType(graphQLType);
    const unwrappedGraphQLType = graphql_1.isNonNullType(graphQLType)
        ? graphQLType.ofType
        : graphQLType;
    if (graphql_1.isScalarType(unwrappedGraphQLType)) {
        if (utilities_1.scalarTypeMap.hasOwnProperty(unwrappedGraphQLType.name)) {
            type = utilities_1.scalarTypeMap[unwrappedGraphQLType.name];
        }
        else {
            context.file.import(unwrappedGraphQLType.name);
            type = t.tsTypeReference(t.identifier(unwrappedGraphQLType.name));
        }
    }
    else if (graphql_1.isEnumType(unwrappedGraphQLType)) {
        context.file.import(unwrappedGraphQLType.name);
        type = t.tsTypeReference(t.identifier(unwrappedGraphQLType.name));
    }
    else if (graphql_1.isListType(unwrappedGraphQLType)) {
        const { ofType } = unwrappedGraphQLType;
        const arrayType = tsTypeForGraphQLType(ofType, field, stack, context);
        type = t.tsArrayType(t.isTSUnionType(arrayType) ? t.tsParenthesizedType(arrayType) : arrayType);
    }
    else if (graphql_1.isObjectType(unwrappedGraphQLType) ||
        graphql_1.isInterfaceType(unwrappedGraphQLType) ||
        graphql_1.isUnionType(unwrappedGraphQLType)) {
        type = tsTypeForObjectField(field, unwrappedGraphQLType, stack.nested(field, unwrappedGraphQLType), context);
    }
    else {
        type = t.tsAnyKeyword();
    }
    return isNonNull ? type : t.tsUnionType([type, t.tsNullKeyword()]);
}
function variablesInterface(variables, context) {
    return t.tsInterfaceDeclaration(t.identifier('Variables'), null, null, t.tsInterfaceBody(variables
        .filter(graphql_tool_utilities_1.isTypedVariable)
        .map((variable) => tsPropertyForVariable(variable, context))));
}
exports.variablesInterface = variablesInterface;
function tsPropertyForVariable({ name, type }, context) {
    const property = t.tsPropertySignature(t.identifier(name), t.tsTypeAnnotation(tsTypeForGraphQLInputType(type, context)));
    property.optional = !graphql_1.isNonNullType(type);
    return property;
}
function tsTypeForGraphQLInputType(graphQLType, context) {
    let type;
    const unwrappedGraphQLType = graphql_1.isNonNullType(graphQLType)
        ? graphQLType.ofType
        : graphQLType;
    if (graphql_1.isScalarType(unwrappedGraphQLType)) {
        if (utilities_1.scalarTypeMap.hasOwnProperty(unwrappedGraphQLType.name)) {
            type = utilities_1.scalarTypeMap[unwrappedGraphQLType.name];
        }
        else {
            context.file.import(unwrappedGraphQLType.name);
            type = t.tsTypeReference(t.identifier(unwrappedGraphQLType.name));
        }
    }
    else if (graphql_1.isEnumType(unwrappedGraphQLType) ||
        graphql_1.isInputObjectType(unwrappedGraphQLType)) {
        context.file.import(unwrappedGraphQLType.name);
        type = t.tsTypeReference(t.identifier(unwrappedGraphQLType.name));
    }
    else {
        const { ofType } = unwrappedGraphQLType;
        const arrayType = tsTypeForGraphQLInputType(ofType, context);
        type = t.tsArrayType(graphql_1.isNonNullType(ofType) ? arrayType : t.tsParenthesizedType(arrayType));
    }
    return graphql_1.isNonNullType(graphQLType)
        ? type
        : t.tsUnionType([type, t.tsNullKeyword()]);
}