@l-v-yonsama/multi-platform-database-drivers 0.1.1

package/src/db/drivers/BaseDriver.ts

@@ -0,0 +1,256 @@
+import DBError from '../DBError';
+import {
+  DbConnection,
+  DbResource,
+  ColumnResolver,
+  DbColumn,
+  SchemaAndTableHints,
+  TableRows,
+  Proposal,
+} from '../resource/DbResource';
+import ResultSetDataHolder from '../resource/ResultSetDataHolder';
+import * as tunnel from 'tunnel-ssh';
+import getPort, { portNumbers } from 'get-port';
+import ResourceUtil from '../resource/ResourceUtil';
+import { ResourceType } from '../resource/types/ResourceType';
+import { DBType } from '../resource/types/DBType';
+import * as fs from 'fs';
+
+export default abstract class BaseDriver {
+  public isConnected: boolean;
+  protected conRes: DbConnection;
+  protected sshServer: any;
+  protected sshLocalPort?: number;
+
+  constructor(conRes: DbConnection) {
+    this.conRes = conRes;
+    this.isConnected = false;
+    // log.info(this.getName(), '★CREATED', this.conRes.id);
+  }
+  getName(): string {
+    return this.constructor.name;
+  }
+  getConnectionRes(): DbConnection {
+    return this.conRes;
+  }
+
+  initBaseStatus(): void {
+    this.isConnected = false;
+  }
+
+  isNeedsSsh(): boolean {
+    return this.conRes.hasSshSetting();
+  }
+  isQuery(sql: string): boolean {
+    sql = sql.toLocaleLowerCase();
+    sql = sql.replace(/-- .+/, '');
+    sql = sql.replace(/(\r\n|\r|\n|\t| )+/g, ' ').trim();
+    // console.log('final sql =[' + sql + ']');
+    if (sql.match(/select[ ]+[^ ]+[ ]+from/)) {
+      return true;
+    }
+    return false;
+  }
+
+  createColumnResolver(sql?: string): ColumnResolver {
+    if (sql) {
+      const hints = this.parseSchemaAndTableHints(sql);
+      return { hints };
+    }
+    return { hints: { list: [] } };
+  }
+  parseSchemaAndTableHints(sql: string): SchemaAndTableHints {
+    const ret: SchemaAndTableHints = { list: [] };
+    const myRegexp = /(FROM|UPDATE)[\s]+(([^\s()]+)\.)?([^\s()]+)/gim;
+    let match = myRegexp.exec(sql);
+    while (match != null) {
+      // sql=SELECT * FROM SSS.TTT
+      // [1]=SSS.TTT
+      // [2]=SSS.
+      // [3]=SSS
+      // [4]=TTT
+      ret.list.push({ schema: match[3], table: match[4] });
+      match = myRegexp.exec(sql);
+    }
+    return ret;
+  }
+
+  getProposals(): Proposal[] {
+    if (this.conRes && DBType.isRDB(this.conRes.db_type)) {
+      const retList: Proposal[] = [];
+      this.conRes.getChildren().forEach((db) => {
+        db.getChildren().forEach((schema) => {
+          schema.getChildren().forEach((table) => {
+            let table_comment = table.comment;
+            if (!table_comment) {
+              table_comment = table.name;
+            }
+            retList.push({
+              s: schema.name,
+              name: table.name,
+              comment: table.comment,
+              type: table.getResouceType(),
+            });
+            table.getChildren().forEach((column) => {
+              if (column.comment) {
+                retList.push({
+                  s: schema.name,
+                  t: table.name,
+                  name: column.name,
+                  comment: `${table_comment}.${column.comment}`,
+                  type: column.getResouceType(),
+                });
+              } else {
+                retList.push({
+                  s: schema.name,
+                  t: table.name,
+                  name: column.name,
+                  comment: `${table_comment}.${column.name}`,
+                  type: column.getResouceType(),
+                });
+              }
+            });
+          });
+        });
+      });
+      return retList;
+    }
+    return [];
+  }
+
+  resolveColumn(
+    column: string,
+    resolver?: ColumnResolver,
+  ): DbColumn | undefined {
+    if (resolver === undefined) {
+      return undefined;
+    }
+    if (this.conRes) {
+      for (let i = 0; i < resolver.hints.list.length; i++) {
+        const hints = resolver.hints.list[i];
+        const t = ResourceUtil.findResource(
+          this.conRes,
+          ResourceType.Table,
+          hints.table,
+        );
+        if (t) {
+          // log.info(LOG_PREFIX, "#resolveColumn found table", hints.table);
+          return <DbColumn>t.getChildByName(column, { quote_ident: true });
+        } else {
+          // log.warn(LOG_PREFIX, "#resolveColumn not found table", hints.table);
+        }
+      }
+    } else {
+      // log.warn(LOG_PREFIX, '#resolveColumn no connection res.')
+    }
+    return undefined;
+  }
+
+  resolveColumnComment(column: string, resolver?: ColumnResolver): string {
+    const c = this.resolveColumn(column, resolver);
+    if (c && c.comment) {
+      return c.comment;
+    }
+    return '';
+  }
+
+  async asyncConnectToSshServer(): Promise<string> {
+    this.sshLocalPort = await getPort({ port: portNumbers(13000, 15100) });
+    // log.info(LOG_PREFIX, 'SSH Local host port is ', this.sshLocalPort)
+    return new Promise<string>((resolve, reject) => {
+      const setting = Object.assign({}, this.conRes.ssh, {
+        localHost: '127.0.0.1',
+        localPort: this.sshLocalPort,
+      });
+      if (setting.auth_method === 'private_key') {
+        setting.privateKey = fs.readFileSync(setting.privateKeyPath, 'utf8');
+      }
+
+      this.sshServer = tunnel(setting, function (err: Error) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve('');
+        }
+      });
+      // Use a listener to handle errors outside the callback
+      this.sshServer.on('error', function (err: Error) {
+        console.error('Something bad happened:', err);
+      });
+    });
+  }
+
+  async asyncConnect(): Promise<string> {
+    let errorReason = '';
+    try {
+      this.initBaseStatus();
+      if (this.conRes) {
+        if (this.isNeedsSsh()) {
+          await this.asyncConnectToSshServer();
+        }
+        errorReason = await this.connectSub();
+      } else {
+        errorReason = 'Connection property is nothing';
+      }
+    } catch (e) {
+      errorReason = e.message;
+    }
+    this.isConnected = errorReason === '';
+    return errorReason;
+  }
+  async asyncClose(): Promise<string> {
+    let errorReason = '';
+    try {
+      if (this.conRes) {
+        if (this.isConnected) {
+          errorReason = await this.closeSub();
+        } else {
+          // log.info('not connected, skip close.')
+        }
+      } else {
+        errorReason = 'Connection property is nothing';
+      }
+    } catch (e) {
+      errorReason = e.message;
+    } finally {
+      if (this.sshServer) {
+        this.sshServer.close();
+        this.sshServer = undefined;
+      }
+      this.initBaseStatus();
+    }
+    return errorReason;
+  }
+  abstract connectSub(): Promise<string>;
+  abstract closeSub(): Promise<string>;
+  abstract getResouces(options: {
+    progress_callback?: Function | undefined;
+    params?: any;
+  }): Promise<Array<DbResource>>;
+  abstract test(with_connect: boolean): Promise<string>;
+  abstract countTables(
+    tables: SchemaAndTableHints,
+    options: any,
+  ): Promise<TableRows[]>;
+  abstract requestSql(
+    sql: string,
+    options?: RequestSqlOptions,
+  ): Promise<ResultSetDataHolder>;
+  createDBError(message: string, sourceError: any): DBError {
+    return new DBError(
+      message,
+      sourceError.code,
+      sourceError.errno,
+      sourceError.sqlMessage,
+      sourceError.sqlState,
+    );
+  }
+}
+
+export interface RequestSqlOptions {
+  binds?: string[];
+  needs_column_resolve?: boolean;
+  progress_callback?: Function;
+  max_rows?: number;
+  auto_connection?: boolean;
+}

package/src/db/drivers/MongoDriver.js

@@ -0,0 +1,110 @@
+import * as DbRes from '../resource/DbResource';
+
+export default class MongoDriver {
+  constructor() {
+    this.client = require('mongodb').MongoClient;
+    this.isConnected = false;
+    this.dbMap = {};
+  }
+  getName() {
+    return 'MongoDriver';
+  }
+  setProperties(prop) {
+    this.name = prop.name;
+    this.url = prop.url;
+  }
+  connect() {
+    const self = this;
+    this.isConnected = false;
+    return new Promise((resolve, reject) => {
+      console.log('connect to ', this.url);
+      this.client.connect(this.url, function (err, db) {
+        if (err) {
+          console.error('Connection failure.', err, db);
+          reject(new Error('[Connection failure]:' + err.message));
+        } else {
+          console.info('Connection success.');
+          self.isConnected = true;
+          self.db = db;
+          var adminDb = self.db.admin();
+          adminDb.listDatabases(function (err, dbs) {
+            console.log('listed..');
+            if (err) {
+              console.log('has error..', err);
+              reject(new Error(err.message));
+            } else {
+              dbs.databases.forEach((database) => {
+                self.dbMap[database.name] = database;
+              });
+              resolve({ ok: true });
+            }
+          });
+        }
+      });
+    });
+  }
+  requestSql(sql) {
+    return new Promise((resolve, reject) => {
+      const self = this;
+      console.log('sql=', sql);
+      const db = self.db.db('yon_test');
+      var collection = db.collection('content_rs');
+      collection
+        .find({})
+        .toArray()
+        .then((docs) => {
+          console.log('done', docs);
+          resolve(docs);
+        });
+    });
+  }
+  getResouces() {
+    const self = this;
+    console.log('driver.js 43 create promsie');
+    return new Promise((resolve, reject) => {
+      let dbResources = [];
+      console.log('start refreshResouces ');
+      let promiseList = [];
+      Object.values(self.dbMap).forEach((database) => {
+        let schema = new DbRes.DbSchema();
+        schema.name = database.name;
+        schema.comment = 'sizeOnDisk: ' + database.sizeOnDisk;
+        dbResources.push(schema);
+        const db1 = self.db.db(database.name);
+        console.log('db1=', db1);
+        promiseList.push(
+          new Promise((resolve, reject) => {
+            db1.listCollections({}).toArray(function (err, items) {
+              if (!err) {
+                items.forEach((t) => {
+                  let table = new DbRes.DbTable();
+                  table.name = t.name;
+                  table.comment = 'Index: ' + t.idIndex;
+                  schema.children.push(table);
+                });
+              }
+              resolve(items);
+            });
+          }),
+        );
+      });
+      console.log('loopend...');
+      Promise.all(promiseList)
+        .then((results) => {
+          console.log('okkkkkkk', results);
+          resolve(dbResources);
+        })
+        .catch((e) => {
+          console.log('sippai', e);
+          resolve(dbResources);
+        });
+    });
+  }
+  close() {
+    this.isConnected = false;
+    if (this.db) {
+      console.log('closed...');
+      this.db.close();
+    }
+  }
+}

package/src/db/drivers/MySQLDriver.ts

@@ -0,0 +1,318 @@
+import BaseDriver, { RequestSqlOptions } from './BaseDriver';
+import * as mysql from 'mysql2/promise';
+import ResultSetDataHolder, { RdhKey } from '../resource/ResultSetDataHolder';
+import {
+  DbConnection,
+  DbResource,
+  DbDatabase,
+  DbSchema,
+  DbTable,
+  DbColumn,
+  ColumnResolver,
+  TableRows,
+  SchemaAndTableHints,
+} from '../resource/DbResource';
+import { MySQLColumnType } from '../resource/types/MySQLColumnType';
+import { EnumValues } from 'enum-values';
+import { GeneralColumnType } from '../resource/types/GeneralColumnType';
+import { ResultSetHeader } from 'mysql2/promise';
+
+export default class MySQLDriver extends BaseDriver {
+  private client: mysql.Pool | undefined;
+
+  constructor(conRes: DbConnection) {
+    super(conRes);
+  }
+
+  fieldInfo2Key(fieldInfo, resolver?: ColumnResolver): RdhKey {
+    if (resolver) {
+      resolver.hints.list.push({ table: fieldInfo.orgTable });
+    }
+    const name = EnumValues.getNameFromValue(
+      MySQLColumnType,
+      MySQLColumnType.parseByFieldInfo(fieldInfo),
+    );
+    const key = new RdhKey(
+      fieldInfo.name,
+      GeneralColumnType.parse(name),
+      super.resolveColumnComment(fieldInfo.orgName, resolver),
+    );
+    if (key.type === GeneralColumnType.UNKNOWN) {
+      // log.error(LOG_PREFIX, 'Unknownt=', fieldInfo)
+    }
+    // console.log('key=', key, EnumValues.getNameFromValue(GeneralColumnType, key.type));
+    return key;
+  }
+
+  async connectSub(): Promise<string> {
+    let errorMessage = '';
+    const options = {
+      connectionLimit: 4,
+      multipleStatements: true,
+      port: this.conRes.port,
+      host: this.conRes.host,
+      user: this.conRes.user,
+      password: this.conRes.password,
+      database: this.conRes.database,
+    };
+    this.client = mysql.createPool(options);
+    try {
+      errorMessage = await this.test();
+    } catch (e) {
+      errorMessage = e.message;
+    }
+    return errorMessage;
+  }
+
+  async test(with_connect = false): Promise<string> {
+    let errorReason = '';
+    if (with_connect) {
+      errorReason = await this.asyncConnect();
+    }
+    if (!errorReason) {
+      const rdh = await this.requestSql('SELECT 1 from DUAL');
+      if (rdh && rdh.errorMessage) {
+        return rdh.errorMessage;
+      }
+      if (with_connect) {
+        await this.asyncClose();
+      }
+    }
+    return errorReason;
+  }
+
+  // public
+  async requestSql(
+    sql: string,
+    options?: RequestSqlOptions,
+  ): Promise<ResultSetDataHolder> {
+    // console.log('requestSql', sql);
+    let rdh = new ResultSetDataHolder([]);
+
+    if (this.client) {
+      let binds: string[] = [];
+      if (options && options.binds) {
+        binds = options.binds;
+      }
+      let resolver: ColumnResolver;
+      if (options && options.needs_column_resolve === true) {
+        resolver = this.createColumnResolver(sql);
+      }
+
+      const [rows, fields] = await this.client.execute(sql, binds);
+      try {
+        if (fields === undefined) {
+          // execute...
+          // Ok Packet {
+          //   fieldCount: 0,
+          //   affectedRows: 1,
+          //   insertId: 0,
+          //   serverStatus: 2,
+          //   warningCount: 0,
+          //   message: '',
+          //   protocol41: true,
+          //   changedRows: 0 }
+          const results = rows as ResultSetHeader;
+
+          rdh = new ResultSetDataHolder([
+            'fieldCount',
+            'affectedRows',
+            'insertId',
+            'serverStatus',
+            'warningStatus',
+            'changedRows',
+          ]);
+          rdh.addRow({
+            fieldCount: results.fieldCount,
+            affectedRows: results.affectedRows,
+            insertId: results.insertId,
+            serverStatus: results.serverStatus,
+            warningStatus: results.warningStatus,
+            changedRows: results.changedRows,
+          });
+        } else {
+          rdh = new ResultSetDataHolder(
+            fields === undefined
+              ? []
+              : fields.map((f) => this.fieldInfo2Key(f, resolver)),
+          );
+          (rows as any).forEach((result: any) => {
+            rdh.addRow(result);
+          });
+        }
+      } catch (err) {
+        rdh = ResultSetDataHolder.create(err);
+      }
+    } else {
+      new Error('No connection');
+    }
+
+    return rdh;
+  }
+
+  async countTables(
+    tables: SchemaAndTableHints,
+    options: any,
+  ): Promise<TableRows[]> {
+    const list = new Array<TableRows>();
+    let counter = 1;
+    for (const st of tables.list) {
+      let prefix = '';
+      if (st.schema) {
+        prefix = st.schema + '.';
+      }
+      if (options && options.progress_callback) {
+        if (counter % 5 === 0) {
+          options.progress_callback(`Count ${prefix}${st.table}`, 70);
+        }
+      }
+      const sql = `SELECT COUNT(*) as count FROM ${prefix}${st.table}`;
+      try {
+        const [results] = await this.client.query(sql, []);
+        if (results && (results as any).length > 0) {
+          const row = results[0];
+          const obj: TableRows = Object.assign({ count: row.count }, st);
+          list.push(obj);
+        }
+      } catch (e) {
+        console.error(e);
+      }
+      counter++;
+    }
+    return list;
+  }
+
+  async getResouces(options: {
+    progress_callback?: Function | undefined;
+    params?: any;
+  }): Promise<Array<DbResource>> {
+    if (!this.conRes) {
+      return [];
+    }
+    const dbResources = new Array<DbResource>();
+    const dbDatabase = new DbDatabase(this.conRes.database);
+    dbResources.push(dbDatabase);
+    let progress = 10;
+    if (options.progress_callback) {
+      options.progress_callback(
+        `${dbResources.length} Databases found.`,
+        progress,
+      );
+    }
+
+    const dbSchemas = await this.getSchemas(dbDatabase);
+    dbSchemas.forEach((res) => {
+      dbDatabase.addChild(res);
+    });
+    progress = 30;
+    if (options.progress_callback) {
+      options.progress_callback(`${dbSchemas.length} Schemas found.`, progress);
+    }
+
+    // const parallels = [];
+    const incrPerSchema = Math.round(20 / dbSchemas.length);
+    for (const dbSchema of dbSchemas) {
+      const dbTables = await this.getTables(dbSchema);
+      dbTables.forEach((res) => dbSchema.addChild(res));
+      if (options.progress_callback) {
+        progress += incrPerSchema;
+        options.progress_callback(
+          `${dbTables.length} Tables found in Schema[${dbSchema.getName()}].`,
+          progress,
+        );
+      }
+    }
+    for (const dbSchema of dbSchemas) {
+      if (options.progress_callback) {
+        progress += incrPerSchema;
+        options.progress_callback(
+          `Commnets finding now... in Schema[${dbSchema.getName()}].`,
+          progress,
+        );
+      }
+      for (const dbTable of dbSchema.getChildren()) {
+        const dbColumns = await this.getColumns(<DbTable>dbTable);
+        dbColumns.forEach((res: DbColumn) => dbTable.addChild(res));
+      }
+    }
+    return dbResources;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async getSchemas(dbDatabase: DbDatabase): Promise<Array<DbSchema>> {
+    const rdh = await this.requestSql(`SELECT SCHEMA_NAME AS name
+      FROM INFORMATION_SCHEMA.SCHEMATA
+      WHERE LOWER(SCHEMA_NAME) NOT IN ('information_schema', 'sys', 'performance_schema')
+      ORDER BY name`);
+    return rdh.rows.map((r) => {
+      const res = new DbSchema(r.values.name);
+      return res;
+    });
+  }
+
+  async getTables(dbSchema: DbSchema): Promise<Array<DbTable>> {
+    const rdh = await this
+      .requestSql(`SELECT TABLE_NAME as name, CASE TABLE_TYPE
+          WHEN 'BASE TABLE' THEN 'TABLE'
+          WHEN 'SYSTEM VIEW' THEN 'VIEW'
+          ELSE 'TABLE' END  AS table_type,
+          TABLE_COMMENT as comment
+          FROM INFORMATION_SCHEMA.TABLES
+          WHERE TABLE_SCHEMA = '${dbSchema.getName()}' `);
+
+    return rdh.rows.map((r) => {
+      const res = new DbTable(
+        r.values.name,
+        r.values.table_type,
+        r.values.comment,
+      );
+      return res;
+    });
+  }
+
+  async getColumns(dbTable: DbTable): Promise<Array<DbColumn>> {
+    const binds = [dbTable.getParent().getName(), dbTable.getName()];
+    const rdh = await this.requestSql(
+      `SELECT COLUMN_NAME as name,
+            DATA_TYPE as col_type,
+            CASE WHEN IS_NULLABLE = 'YES' THEN 1 ELSE 0 END as nullable,
+            COLUMN_KEY as col_key,
+            COLUMN_DEFAULT as col_default,
+            EXTRA as col_extra,
+            COLUMN_COMMENT as comment
+            FROM INFORMATION_SCHEMA.COLUMNS
+            WHERE TABLE_SCHEMA = ? AND  TABLE_NAME = ?`,
+      { binds },
+    );
+
+    return rdh.rows.map((r) => {
+      const type_name = EnumValues.getNameFromValue(
+        MySQLColumnType,
+        MySQLColumnType.parse(r.values.col_type),
+      );
+      const res = new DbColumn(
+        r.values.name,
+        GeneralColumnType.parse(type_name),
+        {
+          nullable: r.values.nullable === 1,
+          key: r.values.col_key,
+          default: r.values.col_default,
+          extra: r.values.col_extra,
+        },
+        r.values.comment,
+      );
+      return res;
+    });
+  }
+
+  async closeSub(): Promise<string> {
+    try {
+      if (this.client) {
+        await this.client.end();
+      }
+      return '';
+    } catch (e) {
+      return e.message;
+    }
+  }
+}