@micro.ts/core/brokers/socketio/SocketIOBroker.js

Microservice framework with Typescript

"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.SocketIOBroker = void 0;
const AbstractBroker_1 = require("../AbstractBroker");
const socket_io_1 = require("socket.io");
class SocketIOBroker extends AbstractBroker_1.AbstractBroker {
    constructor() {
        super(...arguments);
        this.name = 'SocketIoBroker';
        this.routeMapper = (def) => {
            let basePart = def.base;
            if (basePart.indexOf('/') !== 0) {
                basePart = `/${basePart}`;
            }
            let controllerPart = def.controller;
            if (controllerPart.indexOf('/') !== 0) {
                controllerPart = `/${controllerPart}`;
            }
            let handlerPart = def.handler;
            if (handlerPart.indexOf('/') !== 0 && handlerPart.length > 0) {
                handlerPart = `/${handlerPart}`;
            }
            return `${basePart}${controllerPart}${handlerPart}`.replace('//', '/');
        };
        this.requestMapper = (clientId, query, headers, body, path, socket) => __awaiter(this, void 0, void 0, function* () {
            const act = {
                request: {
                    params: {},
                    path,
                    headers: Object.assign(Object.assign({}, headers), { socket_id: clientId }),
                    method: 'post',
                    body,
                    qs: query,
                    raw: { clientId, query, body, headers, path },
                },
                connection: socket,
            };
            return act;
        });
    }
    construct() {
        this.server = new socket_io_1.Server(this.config);
    }
    getConnection() {
        return this.server;
    }
    onDisconnected(cb) { }
    /**
     * Start listening
     */
    start() {
        return __awaiter(this, void 0, void 0, function* () {
            this.construct();
            this.server.on('close', (e) => this.handleConnectionError(e));
            this.server.on('error', (e) => this.handleConnectionError(e));
            this.server.on('connection', (socket) => {
                const clientId = socket.id;
                const query = socket.handshake.query;
                const headers = socket.handshake.headers;
                this.registeredRoutes.forEach((defs, key) => {
                    socket.on(key, (body) => __awaiter(this, void 0, void 0, function* () {
                        const action = yield this.requestMapper(clientId, query, headers, body, key, socket);
                        const handler = this.actionToRouteMapper(key, action, defs);
                        const response = yield handler(action);
                        socket.emit(key, response.response);
                    }));
                });
            });
        });
    }
}
exports.SocketIOBroker = SocketIOBroker;