@n1k1t/mock-server/lib/src/server/index.js

Powerful util to setup mocks over HTTP APIs

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MockServer = void 0;
const relativeTime_1 = __importDefault(require("dayjs/plugin/relativeTime"));
const dayjs_1 = __importDefault(require("dayjs"));
const ioredis_1 = require("ioredis");
const ws_1 = require("ws");
const http_1 = require("http");
const socket_io_1 = require("socket.io");
const models_1 = require("./models");
const services_1 = require("./services");
const logger_1 = require("../logger");
const transports_1 = require("./transports");
const config_1 = __importDefault(require("../config"));
__exportStar(require("./transports"), exports);
__exportStar(require("./models"), exports);
__exportStar(require("./types"), exports);
dayjs_1.default.extend(relativeTime_1.default);
const logger = logger_1.Logger.build('Server');
class MockServer {
    constructor(configuration) {
        this.configuration = configuration;
        this.timestamp = Date.now();
        this.authority = `http://${this.configuration.host}:${this.configuration.port}`;
        this.databases = {
            redis: this.configuration.databases?.redis
                ? new ioredis_1.Redis({ keyPrefix: 'mock:', ...this.configuration.databases?.redis })
                : null,
        };
        this.exchanges = {
            io: (0, models_1.buildSocketIoExchange)({ emit: () => false }),
        };
        this.providers = models_1.ProvidersStorage.build(this);
        this.transports = models_1.TransportsStorage.build()
            .register('http', new transports_1.HttpTransport())
            .register('ws', new transports_1.WsTransport());
        this.router = models_1.Router.build(this);
        this.http = (0, http_1.createServer)((0, transports_1.buildHttpListener)(this.router));
        this.ws = new ws_1.WebSocketServer({ server: this.http }).on('connection', (0, transports_1.buildWsListener)(this.router));
        this.io = new socket_io_1.Server(this.http, {
            ...(process.env['NODE_ENV'] === 'development' && {
                cors: { origin: '*' },
            }),
        });
        this.services = {
            analytics: services_1.AnalyticsService.build(this),
            metrics: services_1.MetricsService.build(this),
        };
        this.internal = {
            transports: {
                http: new transports_1.InternalHttpTransport(this),
                io: new transports_1.InternalSocketIoTransport(this),
            },
        };
        this.databases.redis?.on('reconnecting', () => logger.info('Redis is reconnecting'));
        this.databases.redis?.on('connect', () => logger.info('Redis has connected'));
        this.databases.redis?.on('close', () => logger.info('Redis has closed'));
        this.databases.redis?.on('error', (error) => logger.info('Got redis error', error?.stack ?? error));
    }
    get client() {
        return this.providers.default.client;
    }
    unbindExpiredContainers() {
        this.providers.extract().forEach((provider) => provider.storages.containers.getExpired().forEach((container) => {
            container.unbind();
            logger.info(`Container [${container.key}] has unbinded by expiration of [${container.ttl}] seconds`);
        }));
        return this;
    }
    static async start(configuration) {
        const routes = config_1.default.get('routes');
        const server = new MockServer(configuration);
        await new Promise((resolve) => server.http.listen(configuration.port, configuration.host, () => {
            logger.info(`Server has started on [${server.authority}]`);
            logger.info(`GUI is available on [${server.authority}${routes.internal.root}${routes.internal.gui}/]`);
            resolve();
        }));
        Object
            .entries(configuration.transports ?? {})
            .forEach(([type, transport]) => server.transports.register(type, transport));
        server.router.register(`${routes.internal.root}/**`, {
            provider: server.providers.default,
            transports: {
                http: server.internal.transports.http,
            },
        });
        setInterval(() => server.unbindExpiredContainers(), (configuration.containers?.expiredCleaningInterval ?? 60 * 60) * 1000);
        setInterval(() => server.services.metrics.register('memory', { mbs: process.memoryUsage().heapUsed / 1024 / 1024 }), 5 * 1000);
        setInterval(() => server.services.metrics.register('containers', {
            count: server.providers.extract().reduce((acc, provider) => acc + provider.storages.containers.size, 0),
        }), 5 * 1000);
        if (server.databases.redis) {
            setInterval(async () => {
                const redis = await server.services.analytics.calculateRedisUsage();
                server.services.metrics.register('cache', {
                    redis_mbs: redis.bytes / 1024 / 1024,
                    redis_count: redis.count,
                });
            }, 10 * 60 * 1000);
        }
        return server;
    }
}
exports.MockServer = MockServer;
//# sourceMappingURL=index.js.map