@n1k1t/mock-server/lib/src/server/models/router.js

The ultimate toolkit to intercept, transform, and simulate HTTP/WS traffic with type-safe expectations

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Router = void 0;
const minimatch_1 = __importDefault(require("minimatch"));
const lodash_1 = __importDefault(require("lodash"));
const logger_1 = require("../../logger");
const logger = logger_1.Logger.build('Router');
class Router extends Map {
    constructor(server) {
        super();
        this.server = server;
    }
    default(transport) {
        return {
            provider: this.server.providers.default,
            transport: this.server.transports.get(transport),
        };
    }
    register(pattern, configuration) {
        const existent = this.get(pattern);
        const routes = existent ?? new Set();
        const provided = Array.isArray(configuration.transports)
            ? configuration.transports
            : configuration.transports
                ? Object.keys(configuration.transports)
                : [...this.server.transports.keys()];
        const transports = provided.reduce((acc, type) => lodash_1.default.set(acc, type, Array.isArray(configuration.transports)
            ? this.server.transports.get(type)
            : configuration.transports?.[type] ?? this.server.transports.get(type)), {});
        for (const route of existent?.values() ?? []) {
            if (route.provider === configuration.provider) {
                logger.warn(`Route [${pattern}] is already registered with the same [${configuration.provider.group}] provider`);
                return this;
            }
            if (route.provider.group === configuration.provider.group) {
                logger.warn([
                    `Route [${pattern}] is already registered with similar [${configuration.provider.group}] provider`,
                    'Extending...',
                ].join('. '));
                route.provider.extend(configuration.provider);
                configuration.provider.assign({
                    storages: route.provider.storages,
                    client: route.provider.client,
                    server: route.provider.server,
                });
                return this;
            }
        }
        this.server.providers.register(configuration.provider);
        routes.add({ transports, provider: configuration.provider });
        return this.set(pattern, routes);
    }
    /** Deletes each route that is using provider */
    unregister(provider) {
        for (const [pattern, routes] of this.entries()) {
            for (const route of routes) {
                if (route.provider.group === provider.group) {
                    routes.delete(route);
                }
            }
            if (!routes.size) {
                this.delete(pattern);
            }
        }
        return this;
    }
    *match(transport, path) {
        for (const [pattern, routes] of this.entries()) {
            if ((0, minimatch_1.default)(path, pattern)) {
                for (const route of routes) {
                    if (!route.transports[transport]) {
                        continue;
                    }
                    yield {
                        provider: route.provider,
                        transport: route.transports[transport],
                    };
                }
            }
        }
        yield this.default(transport);
    }
    static build(server) {
        return new Router(server);
    }
}
exports.Router = Router;
//# sourceMappingURL=router.js.map