mediateur/dist/core/middlewares.js

A simple library allowing the implementation of the Mediator design pattern

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.middlewares = void 0;
const globalMiddlewares = new Set();
const messageMiddlewares = new Map();
const handlerMiddlewares = new Map();
const createChain = (messageType, handler) => {
    var _a, _b;
    const middlewares = [
        ...globalMiddlewares,
        ...((_a = messageMiddlewares.get(messageType)) !== null && _a !== void 0 ? _a : []),
        ...((_b = handlerMiddlewares.get(handler)) !== null && _b !== void 0 ? _b : []),
    ];
    const chain = () => {
        const middlewareToExecute = middlewares.shift();
        if (!middlewareToExecute) {
            return handler;
        }
        return (data) => __awaiter(void 0, void 0, void 0, function* () {
            return yield middlewareToExecute({
                type: messageType,
                data,
            }, () => __awaiter(void 0, void 0, void 0, function* () { return chain()(data); }));
        });
    };
    return chain();
};
const hasMiddlewares = (messageType, handler) => {
    const hasGlobalMiddlewares = !!globalMiddlewares.size;
    const hasMessageMiddlewares = !!(messageMiddlewares.get(messageType) || [])
        .length;
    const hasHandlerMiddlewares = !!(handlerMiddlewares.get(handler) || []).length;
    return hasGlobalMiddlewares || hasMessageMiddlewares || hasHandlerMiddlewares;
};
const isAddMessageMiddlewaresOptions = (value) => {
    return typeof value.messageType === 'string';
};
const isAddHandlerMiddlewaresOptions = (value) => {
    return typeof value.handler === 'function';
};
const add = (options) => {
    var _a, _b;
    if (isAddMessageMiddlewaresOptions(options)) {
        const messageTypes = Array.isArray(options.messageType)
            ? options.messageType
            : [options.messageType];
        for (const messageType of messageTypes) {
            const middlewares = (_a = messageMiddlewares.get(messageType)) !== null && _a !== void 0 ? _a : [];
            messageMiddlewares.set(messageType, [
                ...middlewares,
                ...options.middlewares,
            ]);
        }
    }
    else if (isAddHandlerMiddlewaresOptions(options)) {
        const middlewares = (_b = handlerMiddlewares.get(options.handler)) !== null && _b !== void 0 ? _b : [];
        handlerMiddlewares.set(options.handler, [
            ...middlewares,
            ...options.middlewares,
        ]);
    }
    else {
        for (const middleware of options.middlewares) {
            globalMiddlewares.add(middleware);
        }
    }
};
const apply = (messageType, handler) => {
    if (!hasMiddlewares(messageType, handler)) {
        return handler;
    }
    const handlerWithMiddlewareChain = createChain(messageType, handler);
    return handlerWithMiddlewareChain;
};
const clear = () => {
    globalMiddlewares.clear();
    messageMiddlewares.clear();
    handlerMiddlewares.clear();
};
exports.middlewares = {
    add,
    apply,
    clear,
};