exodus-framework 2.0.723 → 2.0.724

package/lib/services/sequelize.d.ts

@@ -11,23 +11,20 @@ declare class SequelizeService extends Service implements IService {
     relations: Map<string, EnvDBHost>;
     constructor();
     init(): Promise<void>;
-    connectMainDatabase(): Promise<unknown>;
-    reconnect(db: Sequelize, attempts?: number): void;
-    getMasterConnection(): Sequelize;
+    connectDatabases(): Promise<unknown>;
+    getDB(tenantId: string): Promise<false | Sequelize>;
     createDB(hostUuid: string, name: string): Promise<boolean>;
     deleteDB(hostUuid: string, name: string): Promise<boolean>;
-    getDatabaseConnection(tenantId: string): Promise<false | Sequelize>;
-    testHostConnections(host: string, port: number, username: string, password: string): Promise<boolean>;
-    initDatabase(tenantId: string): Promise<false | Sequelize>;
-    registerModels(models: ModelStatic<any>[]): void;
+    initDB(tenantId: string): Promise<false | Sequelize>;
+    getDBName(envToken: string): string;
+    reconnect(db: Sequelize, attempts?: number): void;
+    createConnection(hostUuid: string, database?: string): Promise<false | Sequelize>;
+    testConnection(host: string, port: number, username: string, password: string): Promise<boolean>;
+    getRelation(tenantId: string): Promise<false | EnvDBHost>;
     getModel<M extends typeof Model<any, any>>(model: typeof Model<any, any> & {
         initialize: (connection: Sequelize) => M;
-    }, tenantId: string): Promise<M>;
-    parseDataInfoByTenantId(tenant: string): {
-        envToken: string;
-        con_uuid: string;
-    };
-    getDatabaseNamePattern(envToken: string): string;
+    }, tenantId: string): Promise<false | M>;
+    registerModels(models: ModelStatic<any>[]): void;
 }
 export default SequelizeService;
 //# sourceMappingURL=sequelize.d.ts.map

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,OAAO,EAAE,SAAS,EAAgB,MAAM,WAAW,CAAC;AAcpD,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,SAAS,CAAC,CAAC;;IAM5B,IAAI;IAOJ,mBAAmB;IAgCzB,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,QAAQ,SAAI;IAerC,mBAAmB;IAGb,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IA6CvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IA0CvC,qBAAqB,CAAC,QAAQ,EAAE,MAAM;IA4BtC,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IA0BlF,YAAY,CAAC,QAAQ,EAAE,MAAM;IAsDnC,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;;;;IAOtC,sBAAsB,CAAC,QAAQ,EAAE,MAAM;CAGxC;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;AAChD,OAAO,EAAE,SAAS,EAAgB,MAAM,WAAW,CAAC;AAcpD,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,SAAS,CAAC,CAAC;;IAM5B,IAAI;IAOJ,gBAAgB;IAgChB,KAAK,CAAC,QAAQ,EAAE,MAAM;IActB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IA6BvC,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAiBvC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAiB7B,SAAS,CAAC,QAAQ,EAAE,MAAM;IAK1B,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,QAAQ,SAAI;IAe/B,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IA6CpD,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;IA4B7E,WAAW,CAAC,QAAQ,EAAE,MAAM;IAmB5B,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;IAsBlB,cAAc,CAAC,MAAM,EAAE,WAAW,CAAC,GAAG,CAAC,EAAE;CAG1C;AAED,eAAe,gBAAgB,CAAC"}

package/lib/services/sequelize.js

@@ -38,9 +38,9 @@ class SequelizeService extends _service.default {
     this.masterDB = _database.masterDB;
     this.connections = new Map();
     this.initializedModels = new Map();
-    await this.connectMainDatabase();
+    await this.connectDatabases();
   }
-  async connectMainDatabase() {
+  async connectDatabases() {
     if (!this.models) throw new _error.ApplicationException('Models are requireds! Call registerModels(modelsArray)');
 
     // #Include native models
@@ -64,7 +64,81 @@ class SequelizeService extends _service.default {
     });
   }
 
-  //# Common
+  // #Database
+  async getDB(tenantId) {
+    /* master or service */
+    if (tenantId == _app.Core.settings.getDatabase().service.database) {
+      return _database.serviceDB;
+    } else if (tenantId == _app.Core.settings.getDatabase().master.database) {
+      return _database.masterDB;
+    }
+    const relation = await this.getRelation(tenantId);
+    if (!relation) return false;
+    const key = `${relation.hostUuid}@${this.getDBName(relation.envToken)}`;
+    return this.connections.get(key) || (await this.initDB(tenantId));
+  }
+  async createDB(hostUuid, name) {
+    const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
+    if (!host) {
+      this.log('Database host information not found: ' + hostUuid);
+      return false;
+    }
+    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const connection = await this.createConnection(hostUuid);
+    if (connection) {
+      try {
+        const [results] = await connection.query(`SHOW DATABASES LIKE '${dbQueryName}';`);
+        if (results.length === 0) {
+          // Se o banco de dados não existir, cria-o
+          await connection.query(`CREATE DATABASE ${dbQueryName};`);
+          this.log(`Database "${dbQueryName}" has been created.`);
+          return true;
+        } else {
+          this.log(`Database "${dbQueryName}" already exists.`);
+          return false;
+        }
+      } catch (error) {
+        new _error.ApplicationException('Erro on creating database', error);
+      } finally {
+        connection.close();
+      }
+    }
+    return false;
+  }
+  async deleteDB(hostUuid, name) {
+    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const connection = await this.createConnection(hostUuid);
+    if (connection) {
+      try {
+        await connection.query(`DROP DATABASE IF EXISTS ${dbQueryName};`);
+        this.log(`Database "${dbQueryName}" has been deleted.`);
+        return true;
+      } catch (error) {
+        return false;
+      } finally {
+        connection.close();
+      }
+    }
+    return false;
+  }
+  async initDB(tenantId) {
+    const relation = await this.getRelation(tenantId);
+    if (!relation) return false;
+    const dbName = this.getDBName(relation.envToken);
+    const key = `${relation.hostUuid}@${this.getDBName(relation.envToken)}`;
+    if (this.connections.has(key)) return this.connections.get(key);
+    const connection = await this.createConnection(relation.hostUuid, dbName);
+    if (connection) {
+      this.log(`✅ Connected ${dbName} database sucessfully`, 'success');
+      this.connections.set(key, connection);
+      return connection;
+    }
+  }
+  getDBName(envToken) {
+    return `${_app.Core.settings.getDatabase().service.database}_${envToken}`;
+  }
+
+  //#Connection
   reconnect(db, attempts = 2) {
     db.sync().then(() => {
       this.log('Database pronto', 'success');
@@ -78,20 +152,27 @@ class SequelizeService extends _service.default {
       }
     });
   }
-  getMasterConnection() {
-    return this.masterDB;
-  }
-  async createDB(hostUuid, name) {
+  async createConnection(hostUuid, database) {
     const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
     if (!host) {
-      this.log('Database host information not found: ' + hostUuid);
+      this.log('createConnection:: Database host information not found: ' + hostUuid);
       return false;
     }
-    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
+    const key = await _security.default.singleton().loadKeyByStr(host.credential);
+    const data = await _security.default.singleton().verifySignature(host.password, key);
+    if (!data) {
+      this.log('createConnection::Error on decript password by credential: ' + hostUuid, 'danger');
+      return false;
+    }
+    const password = data.payload;
+    const queryHost = host.host.split(':');
     const sequelize = new _sequelize.Sequelize({
+      host: queryHost[0],
+      port: Number(queryHost[1]),
       dialect: host.dialect,
+      database,
       username: host.username,
-      password: host.password,
+      password: password,
       define: {
         timestamps: true
       },
@@ -102,70 +183,38 @@ class SequelizeService extends _service.default {
     });
     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);
-        }
+        resolve(sequelize);
       }).catch(reason => {
-        new _error.ApplicationException('Error while checking/creating database:', reason);
         reject(reason);
-      }).finally(() => {
-        sequelize.close();
       });
     });
   }
-  async deleteDB(hostUuid, name) {
-    const dbQueryName = `${_app.Core.settings.getDatabase().service.database}_${name}`;
-    const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
-    if (!host) {
-      this.log('Database host information not found: ' + hostUuid);
-      return false;
-    }
-    const queryHost = host.host.split(':');
+  async testConnection(host, port, username, password) {
     const sequelize = new _sequelize.Sequelize({
-      host: queryHost[0],
-      port: Number(queryHost[1]),
-      dialect: host.dialect,
-      username: host.username,
-      password: host.password,
-      define: {
-        timestamps: true
-      },
+      host,
+      port,
+      username,
+      password,
       timezone: '-03:00',
       logging(sql, timing) {
         (0, _logger.default)().trace('DATABASE', sql, timing);
       }
     });
-    return new Promise((resolve, reject) => {
+    return new Promise(resolve => {
       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);
+        new _error.ApplicationException('teste de conexão falhou', reason);
+        resolve(false);
       }).finally(() => {
         sequelize.close();
       });
     });
   }
-  async getDatabaseConnection(tenantId) {
-    let relation;
-
-    /* master or service */
-    if (tenantId == _app.Core.settings.getDatabase().service.database) {
-      return _database.serviceDB;
-    } else if (tenantId == _app.Core.settings.getDatabase().master.database) {
-      return _database.masterDB;
-    }
 
+  //# Common
+  async getRelation(tenantId) {
+    let relation;
     /* fetch relation */
     if (this.relations.get(tenantId)) {
       relation = this.relations.get(tenantId);
@@ -181,113 +230,26 @@ class SequelizeService extends _service.default {
       }
       this.relations.set(tenantId, relation);
     }
-    const queryId = `${relation.hostUuid}@${this.getDatabaseNamePattern(relation.envToken)}`;
-    return this.connections.get(queryId) || (await this.initDatabase(tenantId));
-  }
-  async testHostConnections(host, port, username, password) {
-    const sequelize = new _sequelize.Sequelize({
-      host,
-      port,
-      username,
-      password,
-      timezone: '-03:00',
-      logging(sql, timing) {
-        (0, _logger.default)().trace('DATABASE', sql, timing);
-      }
-    });
-    return new Promise(resolve => {
-      sequelize.authenticate().then(async () => {
-        resolve(true);
-      }).catch(reason => {
-        resolve(false);
-      }).finally(() => {
-        sequelize.close();
-      });
-    });
-  }
-  async initDatabase(tenantId) {
-    const {
-      con_uuid: hostUuid,
-      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 = `${dbName}@${hostUuid}`;
-    if (this.connections.get(queryId)) {
-      return this.connections.get(queryId);
-    }
-    const host = await _DatabaseHost.DatabaseHost.findByPk(hostUuid);
-    if (!host) {
-      this.log('Error on init connection, data not found! uuid: ' + hostUuid, 'danger');
-      return false;
-    }
-    const key = await _security.default.singleton().loadKeyByStr(host.credential);
-    const data = await _security.default.singleton().verifySignature(host.password, key);
-    if (!data) {
-      this.log('Error on decript password by credential: ' + hostUuid, 'danger');
-      return false;
-    }
-    const password = data.payload;
-    const conn = new _sequelize.Sequelize({
-      host: host.host,
-      database: dbName,
-      dialect: host.dialect,
-      username: host.username,
-      password: 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: ${hostUuid}`);
-        reject(reason);
-        new _error.ApplicationException(`error trying to connect: ${dbName}, UUID: ${hostUuid}`, reason);
-      });
-    });
-  }
-  registerModels(models) {
-    this.models = models;
+    return relation;
   }
+
+  // #Entity
   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.getDatabaseConnection(tenantId);
+    const relation = await this.getRelation(tenantId);
+    if (!relation) return false;
+    const modelKey = `${relation.envToken}@${relation.hostUuid}#${model.name}`;
+    if (this.initializedModels.has(modelKey)) return this.initializedModels.get(modelKey);
+    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);
+    this.initializedModels.set(modelKey, m);
     return m;
   }
-  parseDataInfoByTenantId(tenant) {
-    const e = tenant.split('@');
-    const envToken = e[0];
-    const con_uuid = e[1];
-    return {
-      envToken,
-      con_uuid
-    };
-  }
-  getDatabaseNamePattern(envToken) {
-    return `${_app.Core.settings.getDatabase().service.database}_${envToken}`;
+  registerModels(models) {
+    this.models = models;
   }
 }
 var _default = exports.default = SequelizeService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exodus-framework",
-  "version": "2.0.723",
+  "version": "2.0.724",
   "description": "Exodus Framework",
   "author": "jhownpaixao",
   "license": "ISC",