@methodus/server
Version:
Server components for @methodus workflow
189 lines • 8.92 kB
JavaScript
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
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());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Server = void 0;
require("reflect-metadata");
const servers_1 = require("./servers");
const framework_commons_1 = __importDefault(require("@methodus/framework-commons"));
const plugins_1 = require("./plugins");
const framework_injection_1 = __importDefault(require("@methodus/framework-injection"));
const uuid_1 = require("uuid");
let Server = class Server {
constructor(port, app, httpServer) {
this._app = {};
this.port = 0;
this._plugins = [];
if (port) {
this.port = +port || 0;
}
this.app = app;
this.httpServer = httpServer;
this.serverKey = this.makeid();
this.instanceId = servers_1.Servers.addServer(this);
this.methodHandler = framework_injection_1.default.Injector.get('MethodHandler');
this.methodPipeHandler = framework_injection_1.default.Injector.get('MethodPipeHandler');
}
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 = framework_injection_1.default.ClassContainer.get(configName);
_class.transportType = new framework_injection_1.default.ClientContainer(_class.transportType);
servers_1.Servers.clients[configName] = _class;
if (metaObject) {
metaObject.methodType = _class.transportType.name;
framework_injection_1.default.ClassContainer.set(configName, metaObject);
framework_commons_1.default.logger
.info(`using client class ${_class.classType.name} in ${_class.transportType.name} mode`);
}
else {
framework_commons_1.default.logger.error('could not load metadata for ' + configName);
}
}
}
start() {
return __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 framework_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.httpServer.listen(this.port);
}
this.httpsServer = servers_1.Servers.get(this.instanceId, 'https');
if (this.httpsServer) {
this.httpsServer.listen(this.port);
}
}
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 = framework_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;
framework_injection_1.default.ClassContainer.set(configName, metaObject);
framework_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 {
framework_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();
}
};
Server = __decorate([
framework_injection_1.default.Singleton('MethodusServer'),
__metadata("design:paramtypes", [Object, Object, Object])
], Server);
exports.Server = Server;
//# sourceMappingURL=server.js.map