@sendoutcards/apollo-codegen-typescript/lib/typePredicates.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const types_1 = require("@babel/types");
const types_2 = require("@babel/types");
const intermediates_1 = require("./intermediates");
const types_3 = require("@babel/types");
const types_4 = require("@babel/types");
const types_5 = require("@babel/types");
const types_6 = require("@babel/types");
const types_7 = require("@babel/types");
const types_8 = require("@babel/types");
const constructors_1 = require("./constructors");
const compact_1 = require("./compact");
const types_9 = require("./types");
const possiblyParenthesizedExpression = (expression, parentOperator) => types_4.isLogicalExpression(expression) && expression.operator != parentOperator
    ? types_5.parenthesizedExpression(expression)
    : expression;
const logicallyCombine = (operator, expressions) => expressions.length < 1
    ? types_1.booleanLiteral(operator == "&&")
    : expressions
        .slice(1)
        .reduce((expression, nextExpression) => types_3.logicalExpression(operator, expression, possiblyParenthesizedExpression(nextExpression, operator)), possiblyParenthesizedExpression(expressions[0], operator));
const and = (...expressions) => logicallyCombine("&&", expressions);
const or = (...expressions) => logicallyCombine("||", expressions);
const nullPredicate = (expression) => types_1.binaryExpression("==", expression, types_1.nullLiteral());
const scalarType = (scalar) => {
    switch (scalar.name) {
        case "Int":
        case "Float":
            return "number";
        case "Boolean":
            return "boolean";
        default:
            return "string";
    }
};
const isFragmentReference = expression => fragmentReference => types_1.TSAsExpression(types_6.callExpression(types_2.identifier(`is${fragmentReference.name}`), [expression]), types_1.TSBooleanKeyword());
const accumIdentifier = constructors_1.typedIdentifier("accum", types_1.TSAnyKeyword());
const nextIdentifier = constructors_1.typedIdentifier("next", types_1.TSAnyKeyword());
const listPredicate = (expression, ofType) => and(types_6.callExpression(types_1.memberExpression(types_2.identifier("Array"), types_2.identifier("isArray")), [expression]), types_6.callExpression(types_1.memberExpression(types_6.callExpression(types_1.memberExpression(expression, types_2.identifier("slice")), [
    types_7.numericLiteral(0),
    types_7.numericLiteral(5)
]), types_2.identifier("reduce")), [
    types_1.arrowFunctionExpression([accumIdentifier, nextIdentifier], and(accumIdentifier, typePredicate(nextIdentifier, ofType))),
    types_1.booleanLiteral(true)
]));
const typePredicate = (expression, type, validated) => {
    switch (type.kind) {
        case "Maybe":
            return or(nullPredicate(expression), typePredicate(expression, type.ofType));
        case "List":
            return listPredicate(expression, type.ofType);
        case "FragmentReference":
            return isFragmentReference(expression)(type);
        case "InlineSelection":
            return inlineSelectionPredicate(type, expression, validated);
        case "Enum":
            return or(...type.values.map(value => types_1.binaryExpression("==", expression, types_1.stringLiteral(value))));
        case "Scalar":
            return types_1.binaryExpression("==", types_8.unaryExpression("typeof", expression), types_1.stringLiteral(scalarType(type)));
        case "Typename":
            return or(...type.possibleTypes
                .toArray()
                .map(type => types_1.binaryExpression("==", expression, types_1.stringLiteral(type))));
    }
};
const typenamePredicate = (object, type) => types_1.binaryExpression("==", types_1.memberExpression(object, types_2.identifier("__typename")), types_1.stringLiteral(type));
const typeConditionsPredicate = (inlineSelection, object) => {
    const remainingTypes = types_9.remainingPossibleTypes(inlineSelection.typeConditions, inlineSelection.possibleTypes);
    return (inlineSelection.typeConditions.length > 0 &&
        or(...inlineSelection.typeConditions.map(condition => and(or(...condition.possibleTypes
            .toArray()
            .map(type => typenamePredicate(object, type))), typePredicate(object, condition, true))), ...remainingTypes.toArray().map(type => typenamePredicate(object, type))));
};
const inlineSelectionPredicate = (inlineSelection, object, validated) => and(...compact_1.default(...inlineSelection.intersections.map(isFragmentReference(object)), inlineSelection.intersections.length == 0 && !validated && object, ...inlineSelection.fields.map(field => typePredicate(types_1.memberExpression(object, types_2.identifier(field.name)), field.type)), typeConditionsPredicate(inlineSelection, object)));
const fragmentIdentifier = types_2.identifier("fragment");
exports.isFragmentDeclaration = (fragment) => types_1.variableDeclaration("const", [
    types_1.variableDeclarator(types_2.identifier(`is${fragment.fragmentName}`), Object.assign({}, types_1.arrowFunctionExpression([constructors_1.typedIdentifier(fragmentIdentifier.name, types_1.TSAnyKeyword())], inlineSelectionPredicate(intermediates_1.InlineSelection(fragment.selectionSet), fragmentIdentifier)), { returnType: types_1.TSTypeAnnotation(types_1.TSTypePredicate(fragmentIdentifier, types_1.TSTypeAnnotation(types_1.TSTypeReference(types_2.identifier(fragment.fragmentName))))) }))
]);
//# sourceMappingURL=typePredicates.js.map