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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const intermediates_1 = require("./intermediates");
const extendedIntermediates_1 = require("./extendedIntermediates");
const immutable_1 = require("immutable");
const normalizableSelectionsFromExtendedFieldType = (type) => {
    switch (type.kind) {
        case "InlineSelection":
            return NormalizableSelections(type);
        case "Maybe":
            return normalizableSelectionsFromExtendedFieldType(type.ofType);
        case "List":
            return normalizableSelectionsFromExtendedFieldType(type.ofType);
        default:
            return immutable_1.Map();
    }
};
const selectTypename = (__typename) => (field) => field.type.kind == "Typename"
    ? { type: intermediates_1.Typename(immutable_1.Set([__typename])), optional: field.optional }
    : field;
const NormalizableSelections = (selection) => selection.fields.reduce((normalizedSelections, fields, __typename) => fields.reduce((normalizedSelections, field) => normalizedSelections.mergeDeep(normalizableSelectionsFromExtendedFieldType(field.type)), isNormalizable(fields)
    ? normalizedSelections.mergeDeep(immutable_1.Map({
        [__typename]: immutable_1.List([fields.map(selectTypename(__typename))])
    }))
    : normalizedSelections), immutable_1.Map());
const normalizeFieldType = (type) => {
    switch (type.kind) {
        case "InlineSelection":
            return normalizeSelection(type);
        case "Maybe":
            return intermediates_1.Maybe(normalizeFieldType(type.ofType));
        case "List":
            return intermediates_1.List(normalizeFieldType(type.ofType));
        default:
            return type;
    }
};
const normalizeField = ({ type, optional }) => ({
    type: normalizeFieldType(type),
    optional
});
const normalizeSelection = (selection) => ({
    kind: "InlineSelection",
    fields: selection.fields.map(fields => isNormalizable(fields)
        ? fields.filter((_, fieldName) => fieldName == "__typename" || fieldName == "id")
        : fields.map(normalizeField))
});
const returnIfEqual = (__typename, fieldName, lhs, rhs) => {
    const differentKindsError = Error(`${lhs.kind} is not the same as ${rhs.kind}`);
    switch (lhs.kind) {
        case "Typename":
            if (rhs.kind != "Typename") {
                throw differentKindsError;
            }
            if (!lhs.possibleTypes.equals(rhs.possibleTypes)) {
                throw Error(`${lhs.possibleTypes} are not the same as ${rhs.possibleTypes}`);
            }
            return rhs;
        case "Enum":
            if (rhs.kind != "Enum") {
                throw differentKindsError;
            }
            if (lhs.name != rhs.name) {
                throw Error(`${lhs.name} is different than ${rhs.name}`);
            }
            if (lhs.values != rhs.values) {
                throw Error(`Possible values ${lhs.values} are not the same as ${rhs.values}`);
            }
            return rhs;
        case "Scalar":
            if (rhs.kind != "Scalar") {
                throw differentKindsError;
            }
            if (lhs.name != rhs.name) {
                throw Error(`Types ${lhs.name} and ${rhs.name} are not the same`);
            }
            return rhs;
        case "InlineSelection":
            if (rhs.kind != "InlineSelection") {
                throw differentKindsError;
            }
            if (!extendedIntermediates_1.extendedSelectionsAreEqual(lhs, rhs)) {
                throw Error(`${__typename} can't be normalized because it has conflicting definitions for "${fieldName}" that could lead to runtime bugs. Either alias the field name or make the selections the same.`);
            }
            return rhs;
        case "List":
            if (rhs.kind != "List") {
                throw differentKindsError;
            }
            return intermediates_1.List(returnIfEqual(__typename, fieldName, lhs.ofType, rhs.ofType));
        case "Maybe":
            if (rhs.kind != "Maybe") {
                throw differentKindsError;
            }
            return intermediates_1.Maybe(returnIfEqual(__typename, fieldName, lhs.ofType, rhs.ofType));
    }
};
const mergeExtendedSelections = (lhs, rhs) => {
    return {
        kind: "InlineSelection",
        fields: lhs.fields.mergeWith((lhs, rhs, __typename) => mergeFields(__typename)(lhs, rhs), rhs.fields)
    };
};
const isNormalizable = (fields) => fields.has("__typename") && fields.has("id");
const mergeField = (__typename) => (lhs, rhs, fieldName) => ({
    type: lhs.type.kind == "InlineSelection" &&
        rhs.type.kind == "InlineSelection" &&
        !lhs.type.fields.some(isNormalizable) &&
        !rhs.type.fields.some(isNormalizable)
        ? mergeExtendedSelections(lhs.type, rhs.type)
        : returnIfEqual(__typename, fieldName, lhs.type, rhs.type),
    optional: lhs.optional || rhs.optional
});
const mergeFields = (__typename) => (lhs, rhs) => {
    const intersection = immutable_1.Set(lhs.keySeq()).intersect(immutable_1.Set(rhs.keySeq()));
    return lhs
        .mergeWith(mergeField(__typename), rhs)
        .map((field, fieldName) => !intersection.contains(fieldName)
        ? { type: field.type, optional: true }
        : field);
};
exports.normalizedTypes = (context) => {
    const fragments = Object.values(context.fragments).reduce((fragments, fragment) => (Object.assign({}, fragments, { [fragment.fragmentName]: intermediates_1.InlineSelection(fragment.selectionSet) })), {});
    const extendedSelections = Object.values(context.operations).map(operation => extendedIntermediates_1.ExtendedSelection(intermediates_1.InlineSelection(operation.selectionSet), fragments));
    const normalizableSelections = extendedSelections.reduce((normalizedSelections, extendedSelection) => normalizedSelections.mergeDeep(NormalizableSelections(extendedSelection)), immutable_1.Map());
    return normalizableSelections.map((fields, __typename) => fields.reduce(mergeFields(__typename)).map(normalizeField));
};
//# sourceMappingURL=normalization.js.map