exodus-framework 2.0.699 → 2.0.701

package/lib/services/security.js

@@ -0,0 +1,224 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var crypto = _interopRequireWildcard(require("crypto"));
+var fs = _interopRequireWildcard(require("fs"));
+var _nodeJose = require("node-jose");
+var _path = _interopRequireDefault(require("path"));
+var _app = require("../app");
+var _error = require("./error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+class SecurityService extends _app.Service {
+  privateKey;
+  publicKey;
+  servicePublicKey;
+  async init() {
+    this.checkPaths();
+    await this.loadPrivateKey();
+    await this.loadPublicKey();
+  }
+  checkPaths() {
+    !fs.existsSync(_app.Core.settings.getAuthentication().certPath) && fs.mkdirSync(_app.Core.settings.getAuthentication().certPath, {
+      recursive: true
+    });
+  }
+
+  /* Key Pair */
+  async loadPrivateKey() {
+    const privateKeyPath = _path.default.join(_app.Core.settings.getAuthentication().certPath, 'private_key.pem');
+    if (fs.existsSync(privateKeyPath)) {
+      const pem = fs.readFileSync(privateKeyPath, 'utf8');
+      this.privateKey = await _nodeJose.JWK.asKey(pem, 'pem');
+    } else {
+      const {
+        privateKey
+      } = await this.createKeyPairs();
+      this.privateKey = await _nodeJose.JWK.asKey(privateKey, 'pem');
+    }
+  }
+  async loadPublicKey() {
+    const publicKeyPath = _path.default.join(_app.Core.settings.getAuthentication().certPath, 'public_key.pem');
+    const pem = this.privateKey.toPEM(false);
+    this.publicKey == (await _nodeJose.JWK.asKey(pem, 'pem'));
+    fs.writeFileSync(publicKeyPath, pem, 'utf8');
+  }
+  async createKeyPairs() {
+    const keyPair = await _nodeJose.JWK.createKey('RSA', 2048, {
+      alg: 'RS256',
+      use: 'sig',
+      iss: _app.Core.settings.getAuthentication().issuer
+    });
+    return {
+      publicKey: keyPair.toPEM(false),
+      privateKey: keyPair.toPEM(true)
+    };
+  }
+  async loadServicePublicKey() {
+    if (fs.existsSync(_app.Core.settings.getAuthentication().servicePublicKeyPath)) {
+      const pem = fs.readFileSync(_app.Core.settings.getAuthentication().servicePublicKeyPath, 'utf8');
+      this.servicePublicKey = await _nodeJose.JWK.asKey(pem, 'pem');
+    } else {
+      throw new _error.ApplicationException('Não foi possível localizar o certificado de serviço. Verifique o caminho nas configurações');
+    }
+  }
+
+  /**
+   * Chave privada emitida por este serviço
+   *
+   * @memberof SecurityService
+   */
+  getPrivateKey() {
+    return this.privateKey;
+  }
+  /**
+   * Chave publica emitida por este serviço
+   *
+   * @memberof SecurityService
+   */
+  getPublicKey() {
+    return this.publicKey;
+  }
+  /**
+   * Chave publica emitida pelo serviço do hub se sessões
+   *
+   * @memberof SecurityService
+   */
+  getServicePublicKey() {
+    return this.servicePublicKey;
+  }
+  /**
+   * Criptografía utilizando chave publica
+   *
+   * @param {TSignData} data
+   * @memberof SecurityService
+   */
+  async encrypt(data, publicKey) {
+    const currentTime = Math.floor(Date.now() / 1000);
+    const defaults = {
+      iat: currentTime,
+      exp: currentTime + _app.Core.settings.getAuthentication().signExpirationSecs,
+      iss: _app.Core.settings.getAuthentication().issuer
+    };
+    const payload = JSON.stringify({
+      ...defaults,
+      ...data
+    });
+    try {
+      const encrypted = await _nodeJose.JWE.createEncrypt({
+        format: 'compact'
+      }, publicKey).update(payload).final();
+      return encrypted;
+    } catch (error) {
+      new _error.ApplicationException('Não foi possível criptografar os dados', error);
+      return false;
+    }
+  }
+  /**
+   * Descriptografia utilizando chave privada
+   *
+   * @param {string} encryptedData
+   * @memberof SecurityService
+   */
+  async decrypt(encryptedData, privateKey) {
+    try {
+      const decrypted = await _nodeJose.JWE.createDecrypt(privateKey).decrypt(encryptedData);
+      const result = decrypted.plaintext.toString();
+      const parserd = JSON.parse(result);
+      // Tenta parsear como JSON se for objeto
+      return parserd.payload;
+    } catch (error) {
+      new _error.ApplicationException('Não foi possível descriptografar os dados', error);
+      return false;
+    }
+  }
+  /**
+   * Realiza uma assinatura usando chave privada
+   *
+   * @param {TSignData} data
+   * @memberof SecurityService
+   */
+  async sign(data, privateKey) {
+    const currentTime = Math.floor(Date.now() / 1000);
+    const defaults = {
+      iat: currentTime,
+      exp: currentTime + _app.Core.settings.getAuthentication().signExpirationSecs,
+      iss: _app.Core.settings.getAuthentication().issuer
+    };
+    try {
+      const payload = JSON.stringify({
+        ...defaults,
+        ...data
+      });
+      const signature = await _nodeJose.JWS.createSign({
+        compact: true,
+        fields: {
+          typ: 'jwt'
+        }
+      }, privateKey).update(payload, 'utf8').final();
+      return signature;
+    } catch (error) {
+      throw new _error.ApplicationException('Erro ao assinar os dados', error);
+    }
+  }
+
+  /**
+   * Verifica assinatura utilizando chave publica
+   *
+   * @param {string} signature
+   * @memberof SecurityService
+   */
+  async verifySignature(signature, publicKey) {
+    try {
+      const result = await _nodeJose.JWS.createVerify(publicKey).verify(signature);
+      const payload = result.payload.toString();
+      return JSON.parse(payload);
+    } catch (error) {
+      new _error.ApplicationException('Assinatura inválida ou erro durante a verificação', error);
+    }
+  }
+
+  /**
+   * Criptografía de dados utilizando um buffer automático ao invés de chaves
+   *
+   * @param {(string | object)} data
+   * @memberof SecurityService
+   */
+  simpleEncrypt(data) {
+    if (process.versions.openssl <= '1.0.1f') {
+      throw new Error('OpenSSL Version too old, vulnerability to Heartbleed');
+    }
+    const key = crypto.randomBytes(32);
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key), iv);
+    let encrypted = cipher.update(data);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return [iv.toString('hex') + ':' + encrypted.toString('hex'), key];
+  }
+  /**
+   * Utiliza um buffer para descriptografar dados criptografados através de simpleEncrypt()
+   *
+   * @param {string} data
+   * @param {Buffer} key
+   * @memberof SecurityService
+   */
+  simpleDecrypt(data, key) {
+    try {
+      const textParts = data.split(':');
+      const iv = Buffer.from(textParts.shift(), 'hex');
+      const encryptedText = Buffer.from(textParts.join(':'), 'hex');
+      const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(key), iv);
+      let decrypted = decipher.update(encryptedText);
+      decrypted = Buffer.concat([decrypted, decipher.final()]);
+      return decrypted;
+    } catch (error) {
+      new _error.ApplicationException('Erro durante a descriptografia de dados', error);
+      return false;
+    }
+  }
+}
+var _default = exports.default = SecurityService;

package/lib/services/sequelize.d.ts

@@ -1,12 +1,14 @@
 import { Model, ModelStatic, Sequelize } from 'sequelize';
 import Service from '../app/service';
 import { IService } from '../contracts/service';
+import { EnvConnection } from '../models';
 declare class SequelizeService extends Service implements IService {
     serviceDB: Sequelize;
     masterDB: Sequelize;
     models: ModelStatic<any>[];
     connections: Map<string, Sequelize>;
     initializedModels: Map<string, typeof Model<any, any>>;
+    relations: Map<string, EnvConnection>;
     constructor();
     init(): Promise<void>;
     connectMainDatabase(): Promise<unknown>;

package/lib/services/sequelize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequelize.d.ts","sourceRoot":"","sources":["../../src/services/sequelize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE1D,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAchD,cAAM,gBAAiB,SAAQ,OAAQ,YAAW,QAAQ;IACxD,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;IAC3B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACpC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;;IAMjD,IAAI;IAOJ,mBAAmB;IAgCzB,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,QAAQ,SAAI;IAerC,mBAAmB;IAGb,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IA6C9C,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAwC9C,KAAK,CAAC,QAAQ,EAAE,MAAM;IAatB,MAAM,CAAC,QAAQ,EAAE,MAAM;IA4C7B,cAAc,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE;IAInC,QAAQ,CAAC,CAAC,SAAS,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAC7C,KAAK,EAAE,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG;QAAE,UAAU,EAAE,CAAC,UAAU,EAAE,SAAS,KAAK,CAAC,CAAA;KAAE,EAC5E,QAAQ,EAAE,MAAM;IAwBlB,uBAAuB,CAAC,MAAM,EAAE,MAAM;;;;CAMvC;AAED,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"sequelize.d.ts","sourceRoot":"","sources":["../../src/services/sequelize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE1D,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAKhD,OAAO,EAAE,aAAa,EAAgB,MAAM,WAAW,CAAC;AASxD,cAAM,gBAAiB,SAAQ,OAAQ,YAAW,QAAQ;IACxD,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC;IAC3B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACpC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACvD,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;;IAMhC,IAAI;IAOJ,mBAAmB;IAgCzB,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,QAAQ,SAAI;IAerC,mBAAmB;IAGb,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IA6C9C,QAAQ,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAwC9C,KAAK,CAAC,QAAQ,EAAE,MAAM;IAwCtB,MAAM,CAAC,QAAQ,EAAE,MAAM;IA4C7B,cAAc,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE;IAInC,QAAQ,CAAC,CAAC,SAAS,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,EAC7C,KAAK,EAAE,OAAO,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG;QAAE,UAAU,EAAE,CAAC,UAAU,EAAE,SAAS,KAAK,CAAC,CAAA;KAAE,EAC5E,QAAQ,EAAE,MAAM;IAwBlB,uBAAuB,CAAC,MAAM,EAAE,MAAM;;;;CAMvC;AAED,eAAe,gBAAgB,CAAC"}

package/lib/services/sequelize.js

@@ -0,0 +1,265 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _sequelize = require("sequelize");
+var _app = require("../app");
+var _service = _interopRequireDefault(require("../app/service"));
+var _Connection = require("../models/Connection");
+var _database = require("../utils/database");
+var _logger = _interopRequireDefault(require("../utils/logger"));
+var _error = require("./error");
+var _models = require("../models");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de gerênciamento do banco de dados
+ *
+ * @class SequelizeService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class SequelizeService extends _service.default {
+  serviceDB;
+  masterDB;
+  models;
+  connections;
+  initializedModels;
+  relations;
+
+  //# Initialization
+  constructor() {
+    super();
+  }
+  async init() {
+    this.serviceDB = _database.serviceDB;
+    this.masterDB = _database.masterDB;
+    this.connections = new Map();
+    this.initializedModels = new Map();
+    await this.connectMainDatabase();
+  }
+  async connectMainDatabase() {
+    if (!this.models) throw new _error.ApplicationException('Models are requireds! Call registerModels(modelsArray)');
+
+    // #Include native models
+    this.models = [...this.models, ..._models.NativeModels];
+    return new Promise(resolve => {
+      this.masterDB.sync({
+        force: false
+      }).then(() => {
+        this.log('✅ Connected master database sucessfully', 'success');
+        this.serviceDB.sync({
+          force: false
+        }).then(() => {
+          this.log('✅ Connected service database sucessfully', 'success');
+          resolve(true);
+        }).catch(reason => {
+          new _error.ApplicationException('Não foi possível inicializar a conexão com o ServiceDB', reason);
+        });
+      }).catch(reason => {
+        new _error.ApplicationException('Não foi possível inicializar a conexão com MasterDB', reason);
+      });
+    });
+  }
+
+  //# Common
+  reconnect(db, attempts = 2) {
+    db.sync().then(() => {
+      this.log('Database pronto', 'success');
+    }).catch(reason => {
+      this.log('Attemping to connect master database', 'warning');
+      (0, _logger.default)().warn('Erro ao inicializar o banco de dados, tentando novamente...', reason);
+      if (attempts > 0) {
+        setTimeout(() => this.reconnect(db, attempts - 1), 5000);
+      } else {
+        new _error.ApplicationException('Error on connecting master database', reason);
+      }
+    });
+  }
+  getMasterConnection() {
+    return this.masterDB;
+  }
+  async createDB(connection_uuid, name) {
+    const connData = await _Connection.Connection.findByPk(connection_uuid);
+    if (!connData) {
+      this.log('Connection data not found: ' + connection_uuid);
+      return false;
+    }
+    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const sequelize = new _sequelize.Sequelize({
+      dialect: connData.dialect,
+      username: connData.username,
+      password: connData.password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging(sql, timing) {
+        (0, _logger.default)().trace('DATABASE', sql, timing);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      sequelize.authenticate().then(async () => {
+        const [results] = await sequelize.query(`SHOW DATABASES LIKE '${dbQueryName}';`);
+        if (results.length === 0) {
+          // Se o banco de dados não existir, cria-o
+          await sequelize.query(`CREATE DATABASE ${dbQueryName};`);
+          this.log(`Database "${dbQueryName}" has been created.`);
+          resolve(true);
+        } else {
+          this.log(`Database "${dbQueryName}" already exists.`);
+          resolve(false);
+        }
+      }).catch(reason => {
+        new _error.ApplicationException('Error while checking/creating database:', reason);
+        reject(reason);
+      }).finally(() => {
+        sequelize.close();
+      });
+    });
+  }
+  async deleteDB(connection_uuid, name) {
+    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const connData = await _Connection.Connection.findByPk(connection_uuid);
+    if (!connData) {
+      this.log('Connection data not found: ' + connection_uuid);
+      return false;
+    }
+    const sequelize = new _sequelize.Sequelize({
+      dialect: connData.dialect,
+      username: connData.username,
+      password: connData.password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging(sql, timing) {
+        (0, _logger.default)().trace('DATABASE', sql, timing);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      sequelize.authenticate().then(async () => {
+        // Se o banco de dados não existir, cria-o
+        await sequelize.query(`DROP DATABASE IF EXISTS ${dbQueryName};`);
+        this.log(`Database "${dbQueryName}" has been deleted.`);
+        resolve(true);
+      }).catch(reason => {
+        new _error.ApplicationException('Error while checking/deleting database:', reason);
+        reject(reason);
+      }).finally(() => {
+        sequelize.close();
+      });
+    });
+  }
+  async getDB(tenantId) {
+    let relation;
+    if (tenantId == _app.Core.settings.getDatabase().service.database) {
+      return _database.serviceDB;
+    } else if (tenantId == _app.Core.settings.getDatabase().master.database) {
+      return _database.masterDB;
+    }
+    if (this.relations.get(tenantId)) {
+      relation = this.relations.get(tenantId);
+    } else {
+      relation = await _models.EnvConnection.findOne({
+        where: {
+          envUuid: tenantId
+        }
+      });
+      if (!relation) {
+        new _error.ApplicationException('Não foi possível encontrar a relação env-db: tenantId=' + tenantId);
+        return false;
+      }
+      this.relations.set(tenantId, relation);
+    }
+    const dbName = `${_app.Core.settings.getDatabase().service.database}_${relation.envToken}`; //nomeclatura padrão do banco de dados do serviço
+    const queryId = `${relation.connUuid}@${dbName}`;
+    return this.connections.get(queryId) || (await this.initDB(tenantId));
+  }
+  /* async getDB2(tenantId: string) {
+    const { con_uuid, envToken } = this.parseDataInfoByTenantId(tenantId);
+      if (con_uuid == Core.settings.getDatabase().service.database) {
+      return serviceDB;
+    } else if (con_uuid == Core.settings.getDatabase().master.database) {
+      return masterDB;
+    }
+    const dbName = `${Core.settings.getDatabase().service.database}_${envToken}`; //nomeclatura padrão do banco de dados do serviço
+    const queryId = `${con_uuid}@${dbName}`;
+      return this.connections.get(queryId) || (await this.initDB(tenantId));
+  } */
+  async initDB(tenantId) {
+    const {
+      con_uuid,
+      envToken
+    } = this.parseDataInfoByTenantId(tenantId);
+    const dbName = `${_app.Core.settings.getDatabase().service.database}_${envToken}`; //nomeclatura padrão do banco de dados do serviço
+    const queryId = `${con_uuid}@${dbName}`;
+    if (this.connections.get(queryId)) {
+      return this.connections.get(queryId);
+    }
+    const connData = await _Connection.Connection.findByPk(con_uuid);
+    if (!connData) {
+      this.log('Error on init connection, data not found! uuid: ' + con_uuid, 'danger');
+      return false;
+    }
+    const conn = new _sequelize.Sequelize({
+      database: dbName,
+      dialect: connData.dialect,
+      username: connData.username,
+      password: connData.password,
+      define: {
+        timestamps: true
+      },
+      timezone: '-03:00',
+      logging(sql, timing) {
+        (0, _logger.default)().trace('DATABASE', sql, timing);
+      }
+    });
+    return new Promise((resolve, reject) => {
+      conn.sync({
+        force: false
+      }).then(() => {
+        this.log(`✅ Connected ${dbName} database sucessfully`, 'success');
+        this.connections.set(queryId, conn);
+        resolve(conn);
+      }).catch(reason => {
+        this.log(`error trying to connect: ${dbName}, UUID: ${con_uuid}`);
+        reject(reason);
+        new _error.ApplicationException(`error trying to connect: ${dbName}, UUID: ${con_uuid}`, reason);
+      });
+    });
+  }
+  registerModels(models) {
+    this.models = models;
+  }
+  async getModel(model, tenantId) {
+    const {
+      con_uuid,
+      envToken
+    } = this.parseDataInfoByTenantId(tenantId);
+    const modelInitID = `${envToken}@${con_uuid}#${model.name}`;
+    const cache = this.initializedModels.get(modelInitID);
+    if (cache) {
+      return cache;
+    }
+    const connection = await this.getDB(tenantId);
+    if (!connection) {
+      throw new _error.ApplicationException('Não foi possível obter o model espeficificado: Conexão não encontrada');
+    }
+    const m = model.initialize(connection);
+    await m.sync();
+    this.initializedModels.set(modelInitID, m);
+    return m;
+  }
+  parseDataInfoByTenantId(tenant) {
+    const e = tenant.split('@');
+    const envToken = e[0];
+    const con_uuid = e[1];
+    return {
+      envToken,
+      con_uuid
+    };
+  }
+}
+var _default = exports.default = SequelizeService;

package/lib/services/socket.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _controller = require("../app/controller");
+var _service = _interopRequireDefault(require("../app/service"));
+var _socket = require("socket.io");
+var _express = _interopRequireDefault(require("./express"));
+var _error = require("./error");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Serviço de gerênciamento de comunicação WS/WSS Socket
+ *
+ * @class SocketIOService
+ * @extends {Service}
+ * @implements {IService}
+ */
+class SocketIOService extends _service.default {
+  server;
+  mainRouter;
+  constructor() {
+    super();
+  }
+  async init() {
+    if (!this.mainRouter) throw new _error.ApplicationException('Need router'); //!sem router
+    const server = _express.default.singleton().getHttpServer();
+    this.createSocket(server);
+    this.server.on('connection', this.onConnection.bind(this));
+    this.log('Socket server created');
+  }
+  onConnection(socket) {
+    this.log(`${socket.id} conectado`);
+    socket.on('disconnect', () => this.log(`${socket.id} desconectado`));
+    this.bindEvents(socket);
+  }
+  bindEvents(socket) {
+    Object.entries(this.mainRouter).forEach(([key, handle]) => {
+      socket.on(key, (...args) => {
+        handle(new _controller.SocketRequest(socket, key), ...args);
+      });
+    });
+  }
+  createSocket(app, cors = {
+    origin: '*'
+  }) {
+    this.server = new _socket.Server(app, {
+      cors
+    });
+  }
+  registerRouter(router) {
+    this.mainRouter = router;
+  }
+}
+var _default = exports.default = SocketIOService;