mongo-milestone/dist/dispatcher.js

*A life-saving little tool to work around the lack of ACID Transactions in MongoDB*

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.registerMethods = exports.wrapMethod = exports.registeredMethods = exports.dispatch = exports.unregister = exports.register = exports.DISPATCHER_KEYS_MUST_BE_STRINGS = exports.DISPATCHER_PROPERTIES_MUST_BE_FUNCTIONS = exports.METHOD_NOT_FOUND = undefined;
var _arguments = arguments;

var _q = require('q');

var _q2 = _interopRequireDefault(_q);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const METHOD_NOT_FOUND = exports.METHOD_NOT_FOUND = method => `The invoked method "${ method }" wasn't found. Have you registered it yet?`;
const DISPATCHER_PROPERTIES_MUST_BE_FUNCTIONS = exports.DISPATCHER_PROPERTIES_MUST_BE_FUNCTIONS = `All properties in the Dispatcher object must be functions`;
const DISPATCHER_KEYS_MUST_BE_STRINGS = exports.DISPATCHER_KEYS_MUST_BE_STRINGS = `All properties is the Dispatcher object must be functions`;

const _dispatcher = {};

const register = exports.register = ({ name, fn, obj }) => {
    if (typeof name == 'string' && typeof fn == 'function') {
        return registerMethod(name, fn);
    } else if (typeof fn == 'function') {
        const result = fn();

        return registerMethods(result);
    } else {
        return registerMethods(obj);
    }
};

const unregister = exports.unregister = name => {
    if (typeof name === 'string') {
        return unregisterMethod(name);
    }

    if (name === false) {
        return unregisterAll();
    }
};

const dispatch = exports.dispatch = (name, parameters) => {
    if (typeof name !== 'string') {
        throw new Error(METHOD_NOT_FOUND(name));
    }

    if (name.indexOf('[') !== -1) {
        let parts = name.split('[');
        name = parts[0];

        parameters.index = parseInt(parts[1].split(']')[0]);
    }

    const method = _dispatcher[name];

    if (!method) {
        throw new Error(METHOD_NOT_FOUND(name));
    }

    let result;

    try {
        const result = method(parameters);

        if (!_q2.default.isPromiseAlike(result)) {
            return _q2.default.fcall(() => result);
        } else {
            return result;
        }
    } catch (e) {
        return _q2.default.fcall(() => e);
    }
};

const registeredMethods = exports.registeredMethods = () => {
    return Object.assign({}, _dispatcher);
};

const wrapMethod = exports.wrapMethod = (() => {
    const defaultTransformer = parameters => parameters;

    return (method, transformer = defaultTransformer, context = null) => {
        if (typeof transformer !== 'function') {
            transformer = defaultTransformer;
        }

        return function (parameters) {
            let params = transformer(parameters);

            return method.apply(context, Array.isArray(params) ? params : [params]);
        };
    };
})();

Function.prototype.wrap = function (transformer, context = null) {
    return wrapMethod(this, transformer, context);
};

const registerMethods = exports.registerMethods = registeredDispatcher => {
    var methodNames = Object.keys(registeredDispatcher);

    if (methodNames.find(name => !name || typeof name !== 'string')) {
        throw new Error(DISPATCHER_KEYS_MUST_BE_STRINGS);
    }

    if (methodNames.find(name => !registeredDispatcher[name] || typeof registeredDispatcher[name] !== 'function')) {
        throw new Error(DISPATCHER_PROPERTIES_MUST_BE_FUNCTIONS);
    }

    for (const methodName of methodNames) {
        _dispatcher[methodName] = registeredDispatcher[methodName];
    }

    return _dispatcher;
};

const registerMethod = (name, method) => {
    if (!name || typeof name !== 'string') {
        throw new Error(DISPATCHER_KEYS_MUST_BE_STRINGS);
    }

    if (!method || typeof method !== 'function') {
        throw new Error(DISPATCHER_PROPERTIES_MUST_BE_FUNCTIONS);
    }

    _dispatcher[name] = method;

    return _dispatcher;
};

const unregisterAll = () => {
    var methods = Object.keys(_dispatcher);

    for (const method of methods) {
        delete _dispatcher[method];
    }

    return _dispatcher;
};

const unregisterMethod = () => {
    for (const method of _arguments) {
        delete _dispatcher[method];
    }

    return _dispatcher;
};