@methodus/server/dist/server.js

Server components for @methodus workflow

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Server = void 0;
const tslib_1 = require("tslib");
require("reflect-metadata");
const servers_1 = require("./servers");
const commons_1 = tslib_1.__importDefault(require("@methodus/framework-decorators/commons"));
const method_handler_1 = require("./method/handlers/method.handler");
const pipe_handler_1 = require("./method/handlers/pipe.handler");
const plugins_1 = require("./plugins");
const injection_1 = tslib_1.__importDefault(require("@methodus/framework-decorators/injection"));
const uuid_1 = require("uuid");
class Server {
    constructor(port, app, httpServer) {
        this._app = {};
        this.port = 0;
        this.ipAddress = '0.0.0.0';
        this._plugins = [];
        this.methodHandler = new method_handler_1.MethodHandler();
        this.methodPipeHandler = new pipe_handler_1.MethodPipeHandler();
        if (port) {
            this.port = +port || 0;
        }
        this.app = app;
        this.httpServer = httpServer;
        this.serverKey = this.makeid();
        this.instanceId = servers_1.Servers.addServer(this);
        try {
            this.methodHandler = injection_1.default.Injector.resolve('MethodHandler');
            this.methodPipeHandler = injection_1.default.Injector.resolve('MethodPipeHandler');
        }
        catch (error) {
            throw new Error('missing MethodHandler are you using a platform package?');
        }
    }
    makeid() {
        return uuid_1.v1();
    }
    plugins(plugins) {
        this._plugins = plugins;
        return this;
    }
    configure(config) {
        this.config = config;
        return this;
    }
    useClient(_class) {
        if (_class.classType) {
            const methodusClass = _class.classType;
            let configName = methodusClass.name;
            if (!configName && methodusClass.constructor) {
                configName = methodusClass.constructor.name;
            }
            const metaObject = injection_1.default.ClassContainer.get(configName);
            _class.transportType = new injection_1.default.ClientContainer(_class.transportType);
            servers_1.Servers.clients[configName] = _class;
            if (metaObject) {
                metaObject.methodType = _class.transportType.name;
                injection_1.default.ClassContainer.set(configName, metaObject);
                commons_1.default.logger.info(`using client class ${_class.classType.name} in ${_class.transportType.name} mode`);
            }
            else {
                commons_1.default.logger.error('could not load metadata for ' + configName);
            }
        }
    }
    start() {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            this.port = 0;
            console.log(`> Methodus.`);
            if (this.config && this._plugins && this._plugins.length > 0) {
                const loader = new plugins_1.PluginLoader();
                yield loader.config(this.config, this._plugins);
            }
            const onStart = [];
            if (this.httpServer) {
                servers_1.Servers.set(this.instanceId, 'http', this.httpServer);
            }
            if (this.httpsServer) {
                servers_1.Servers.set(this.instanceId, 'https', this.httpsServer);
            }
            if (this.app) {
                servers_1.Servers.set(this.instanceId, 'express', this.app);
            }
            if (this.config && this.config.servers) {
                this.config.servers.forEach((server) => {
                    if (server.options && server.options.port) {
                        this.port = server.options.port;
                    }
                    if (server.onStart) {
                        onStart.push(server.onStart);
                    }
                    const aServerInstance = servers_1.Servers.get(this.instanceId, server.type.name);
                    if (!aServerInstance) {
                        server.instanceId = this.instanceId;
                        return new injection_1.default.ServerContainer(server, this);
                    }
                    else {
                        return aServerInstance;
                    }
                });
                onStart.forEach((startEvent) => {
                    const instance = servers_1.Servers.get(this.instanceId, 'express');
                    if (instance && instance._app) {
                        startEvent(instance._app);
                    }
                });
                this.httpServer = servers_1.Servers.get(this.instanceId, 'http');
                if (this.httpServer && this.port) {
                    this.httpServer.listen(this.port, this.ipAddress);
                }
                this.httpsServer = servers_1.Servers.get(this.instanceId, 'https');
                if (this.httpsServer && this.port) {
                    this.httpsServer.listen(this.port, this.ipAddress);
                }
            }
            if (this.config) {
                const classes = this.config.classes.entries();
                for (let i = 0; i < this.config.classes.size; i++) {
                    const element = classes.next();
                    this.useClass(element.value[1]);
                }
                const clients = this.config.clients.entries();
                for (let i = 0; i < this.config.clients.size; i++) {
                    const element = clients.next();
                    this.useClient(element.value[1]);
                }
            }
            return this;
        });
    }
    useClass(_class) {
        const serverInstance = this;
        Object.keys(servers_1.Servers.instances).forEach((serverId) => {
            const server = servers_1.Servers.instances[serverId];
            if (_class.classType) {
                const methodusClass = _class.classType;
                let configName = methodusClass.name;
                if (!configName && methodusClass.constructor) {
                    configName = methodusClass.constructor.name;
                }
                const metaObject = injection_1.default.ClassContainer.get(configName);
                const serverTypeName = _class.serverType.name || _class.serverType;
                if (server[serverTypeName]) {
                    servers_1.Servers.classes[configName] = _class;
                    if (metaObject) {
                        metaObject.methodType = _class.methodType;
                        metaObject.serverType = _class.serverType;
                        metaObject.instanceId = serverInstance.instanceId;
                        injection_1.default.ClassContainer.set(configName, metaObject);
                        commons_1.default.logger.info(`using server class ${configName} in ${_class.methodType} mode`);
                        const activeServers = servers_1.Servers.get(serverInstance.instanceId, serverTypeName);
                        if (activeServers) {
                            activeServers.useClass(_class.classType, metaObject.methodType);
                        }
                    }
                    else {
                        commons_1.default.logger.error('could not load metadata for ' + configName);
                    }
                }
            }
        });
    }
    kill() {
        servers_1.Servers.serversArray.forEach((server) => {
            if (server && server.close) {
                server.close();
            }
        });
        servers_1.Servers.reset();
    }
}
exports.Server = Server;
//# sourceMappingURL=server.js.map