shyft/lib/engine/mutation/Mutation.js

Model driven GraphQL API framework

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.processEntityMutations = exports.isMutation = exports.Mutation = exports.defaultEntityMutations = exports.mutationTypes = exports.MUTATION_TYPE_DELETE = exports.MUTATION_TYPE_UPDATE = exports.MUTATION_TYPE_CREATE = void 0;
var lodash_1 = require("lodash");
var util_1 = require("../util");
exports.MUTATION_TYPE_CREATE = 'create';
exports.MUTATION_TYPE_UPDATE = 'update';
exports.MUTATION_TYPE_DELETE = 'delete';
exports.mutationTypes = [
    exports.MUTATION_TYPE_CREATE,
    exports.MUTATION_TYPE_UPDATE,
    exports.MUTATION_TYPE_DELETE,
];
exports.defaultEntityMutations = [
    {
        name: 'create',
        type: exports.MUTATION_TYPE_CREATE,
        description: function (typeName) { return "Create a new **`" + typeName + "`**"; },
        hasAttributes: true,
    },
    {
        name: 'update',
        type: exports.MUTATION_TYPE_UPDATE,
        description: function (typeName) {
            return "Update a single **`" + typeName + "`** using its node ID and a data patch";
        },
        hasAttributes: true,
    },
    {
        name: 'delete',
        description: function (typeName) {
            return "Delete a single **`" + typeName + "`** using its node ID";
        },
        type: exports.MUTATION_TYPE_DELETE,
    },
];
var Mutation = /** @class */ (function () {
    function Mutation(setup) {
        var _this = this;
        if (setup === void 0) { setup = {}; }
        var name = setup.name, type = setup.type, description = setup.description, attributes = setup.attributes, preProcessor = setup.preProcessor, postProcessor = setup.postProcessor, fromState = setup.fromState, toState = setup.toState;
        util_1.passOrThrow(name, function () { return 'Missing mutation name'; });
        util_1.passOrThrow(type, function () { return "Missing type for mutation '" + name + "'"; });
        util_1.passOrThrow(exports.mutationTypes.indexOf(type) >= 0, function () {
            return "Unknown mutation type '" + type + "' used, try one of these: '" + exports.mutationTypes.join(', ') + "'";
        });
        util_1.passOrThrow(description, function () { return "Missing description for mutation '" + name + "'"; });
        this.name = name;
        this.type = type;
        this.description = description;
        if (this.type === exports.MUTATION_TYPE_CREATE ||
            this.type === exports.MUTATION_TYPE_UPDATE) {
            this.attributes = attributes;
        }
        if (this.type === exports.MUTATION_TYPE_CREATE) {
            this.isTypeCreate = true;
        }
        if (this.type === exports.MUTATION_TYPE_UPDATE) {
            this.needsInstance = true;
            this.ignoreRequired = true;
            this.isTypeUpdate = true;
        }
        if (this.type === exports.MUTATION_TYPE_DELETE) {
            this.needsInstance = true;
            this.isTypeDelete = true;
        }
        if (preProcessor) {
            util_1.passOrThrow(util_1.isFunction(preProcessor), function () { return "preProcessor of mutation '" + name + "' needs to be a valid function"; });
            this.preProcessor = preProcessor;
        }
        if (postProcessor) {
            util_1.passOrThrow(util_1.isFunction(postProcessor), function () {
                return "postProcessor of mutation '" + name + "' needs to be a valid function";
            });
            this.postProcessor = postProcessor;
        }
        if (fromState) {
            util_1.passOrThrow(this.type !== exports.MUTATION_TYPE_CREATE, function () {
                return "Mutation '" + _this.name + "' cannot define fromState as it is a 'create' type mutation";
            });
            util_1.passOrThrow(typeof fromState === 'string' || util_1.isArray(fromState), function () {
                return "fromState in mutation '" + name + "' needs to be the name of a state or a list of state names as a precondition to the mutation";
            });
            if (this.type !== exports.MUTATION_TYPE_DELETE) {
                util_1.passOrThrow(toState, function () {
                    return "Mutation '" + _this.name + "' has a fromState defined but misses a toState definition";
                });
            }
            this.fromState = fromState;
        }
        if (toState) {
            util_1.passOrThrow(this.type !== exports.MUTATION_TYPE_DELETE, function () {
                return "Mutation '" + _this.name + "' cannot define toState as it is a 'delete' type mutation";
            });
            util_1.passOrThrow(typeof toState === 'string' || util_1.isArray(toState), function () {
                return "toState in mutation '" + _this.name + "' needs to be the name of a state or a list of state names the mutation can transition to";
            });
            if (this.type !== exports.MUTATION_TYPE_CREATE) {
                util_1.passOrThrow(fromState, function () {
                    return "Mutation '" + _this.name + "' has a toState defined but misses a fromState definition";
                });
            }
            this.toState = toState;
        }
    }
    Mutation.prototype.toString = function () {
        return this.name;
    };
    return Mutation;
}());
exports.Mutation = Mutation;
var isMutation = function (obj) {
    return obj instanceof Mutation;
};
exports.isMutation = isMutation;
var processEntityMutations = function (entity, mutations) {
    util_1.passOrThrow(util_1.isArray(mutations), function () {
        return "Entity '" + entity.name + "' mutations definition needs to be an array of mutations";
    });
    mutations.map(function (mutation, idx) {
        util_1.passOrThrow(exports.isMutation(mutation), function () {
            return "Invalid mutation definition for entity '" + entity.name + "' at position '" + idx + "'";
        });
    });
    var entityAttributes = entity.getAttributes();
    var entityStates = entity.getStates();
    var requiredAttributeNames = [];
    util_1.mapOverProperties(entityAttributes, function (attribute, attributeName) {
        if (!attribute.isSystemAttribute) {
            if (attribute.required && !attribute.defaultValue) {
                requiredAttributeNames.push(attributeName);
            }
        }
    });
    var mutationNames = [];
    mutations.map(function (mutation) {
        util_1.passOrThrow(!mutationNames.includes(mutation.name), function () {
            return "Duplicate mutation name '" + mutation.name + "' found in '" + entity.name + "'";
        });
        mutationNames.push(mutation.name);
        if (mutation.attributes) {
            util_1.passOrThrow((util_1.isArray(mutation.attributes, true) &&
                mutation.type === exports.MUTATION_TYPE_CREATE) ||
                util_1.isArray(mutation.attributes, false), function () {
                return "Mutation '" + entity.name + "." + mutation.name + "' needs to have a list of attributes";
            });
            mutation.attributes.map(function (attribute) {
                util_1.passOrThrow(typeof attribute === 'string', function () {
                    return "Mutation '" + entity.name + "." + mutation.name + "' needs to have a list of attribute names";
                });
            });
            util_1.passOrThrow(mutation.attributes.length === lodash_1.uniq(mutation.attributes).length, function () {
                return "Mutation '" + entity.name + "." + mutation.name + "' needs to have a list of unique attribute names";
            });
            mutation.attributes.map(function (attributeName) {
                util_1.passOrThrow(entityAttributes[attributeName], function () {
                    return "Cannot use attribute '" + entity.name + "." + attributeName + "' in mutation '" + entity.name + "." + mutation.name + "' as it does not exist";
                });
            });
            if (mutation.type === exports.MUTATION_TYPE_CREATE) {
                var missingAttributeNames_1 = requiredAttributeNames.filter(function (requiredAttributeName) {
                    return !mutation.attributes.includes(requiredAttributeName);
                });
                util_1.passOrThrow(missingAttributeNames_1.length === 0, function () {
                    return "Missing required attributes in mutation '" + entity.name + "." + mutation.name + "' need to have a defaultValue() function: [ " + missingAttributeNames_1.join(', ') + " ]";
                });
            }
        }
        else if (mutation.type === exports.MUTATION_TYPE_CREATE ||
            mutation.type === exports.MUTATION_TYPE_UPDATE) {
            var nonSystemAttributeNames_1 = [];
            util_1.mapOverProperties(entityAttributes, function (attribute, attributeName) {
                if (!attribute.isSystemAttribute) {
                    nonSystemAttributeNames_1.push(attributeName);
                }
            });
            mutation.attributes = nonSystemAttributeNames_1;
        }
        var checkMutationStates = function (stateStringOrArray) {
            var stateNames = util_1.isArray(stateStringOrArray)
                ? stateStringOrArray
                : [stateStringOrArray];
            stateNames.map(function (stateName) {
                util_1.passOrThrow(entityStates[stateName], function () {
                    return "Unknown state '" + stateName + "' used in mutation '" + entity.name + "." + mutation.name + "'";
                });
            });
        };
        if (mutation.fromState) {
            util_1.passOrThrow(entity.hasStates(), function () {
                return "Mutation '" + entity.name + "." + mutation.name + "' cannot define fromState as the entity is stateless";
            });
            checkMutationStates(mutation.fromState);
        }
        if (mutation.toState) {
            util_1.passOrThrow(entity.hasStates(), function () {
                return "Mutation '" + entity.name + "." + mutation.name + "' cannot define toState as the entity is stateless";
            });
            checkMutationStates(mutation.toState);
        }
    });
    return mutations;
};
exports.processEntityMutations = processEntityMutations;