@axiosleo/orm-mysql 0.8.6 → 0.9.0

package/README.md

@@ -195,6 +195,31 @@ try {
 }
 ```
 
+### Migration
+
+```javascript
+'use strict';
+
+/**
+ * @param {import('@axiosleo/orm-mysql').MigrationInterface} migration
+ */
+function up(migration) {
+  migration.createDatabase({ database_name: 'demo' });
+}
+
+/**
+ * @param {import('@axiosleo/orm-mysql').MigrationInterface} migration
+ */
+function down(migration) {
+  migration.dropDatabase({ database_name: 'demo' });
+}
+
+module.exports = {
+  up,
+  down
+};
+```
+
 ### Custom query driver
 
 ```javascript
@@ -215,7 +240,7 @@ const conn = createClient({
 
 const hanlder = new QueryHandler(conn, {
   driver: 'custom',
-  query_handler: (con, options) => {
+  queryHandler: (con, options) => {
     const builder = new Builder(options);
     return new Promise((resolve, reject) => {
       if (options.operator === 'select') {

package/bin/orm-mysql.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const path = require('path');
+const { App } = require('@axiosleo/cli-tool');
+
+const app = new App({
+  name: 'MySQL ORM CLI',
+  desc: 'migrate, model, seed, etc.',
+  bin: 'orm-mysql',
+  version: '0.9.0',
+  commands_dir: path.join(__dirname, '../commands'),
+});
+
+app.start();

package/commands/generate.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const path = require('path');
+const { Command, printer } = require('@axiosleo/cli-tool');
+const { _exists, _write } = require('@axiosleo/cli-tool/src/helper/fs');
+const { _snake_case } = require('@axiosleo/cli-tool/src/helper/str');
+
+class GenerateCommand extends Command {
+  constructor() {
+    super({
+      name: 'generate',
+      desc: ''
+    });
+    this.addArgument('name', 'Migration name', 'required', '');
+    this.addArgument('dir', 'Migration scripts directory', 'optional', process.cwd());
+  }
+
+  /**
+   * @param {*} args 
+   * @param {*} options 
+   * @param {string[]} argList 
+   * @param {import('@axiosleo/cli-tool').App} app 
+   */
+  async exec(args, options) {
+    const { name, dir } = args;
+    const fileName = parseInt((new Date()).valueOf() / 1000) + '.' + _snake_case(name) + '.js';
+    const filePath = path.join(dir, fileName);
+    if (await _exists(filePath)) {
+      printer.error('Migration script file already exists: ' + fileName);
+      return;
+    }
+    const template = `
+'use strict';
+
+/**
+ * @param {import('@axiosleo/orm-mysql').MigrationInterface} migration
+ */
+function up(migration) {
+}
+
+/**
+ * @param {import('@axiosleo/orm-mysql').MigrationInterface} migration
+ */
+function down(migration) {
+}
+
+module.exports = {
+  up,
+  down
+};
+`;
+    await _write(filePath, template);
+    printer.info('Migration file created: ' + filePath);
+  }
+}
+
+module.exports = GenerateCommand;

package/commands/migrate.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const { Command, debug, Workflow } = require('@axiosleo/cli-tool');
+const is = require('@axiosleo/cli-tool/src/helper/is');
+const migration = require('../src/migration');
+
+class MigrateCommand extends Command {
+  constructor() {
+    super({
+      name: 'migrate',
+      desc: 'Migrate database',
+    });
+    this.addArgument('action', 'up or down', 'required');
+    this.addArgument('dir', 'migration directory', 'optional', process.cwd());
+
+    this.addOption('debug', 'd', '[false] debug mode', 'optional', false);
+    this.addOption('host', null, '[localhost] mysql host', 'optional', 'localhost');
+    this.addOption('user', null, '[root] username for connect to the database', 'optional', 'root');
+    this.addOption('pass', null, 'password to connect to the database', 'optional', '');
+    this.addOption('port', null, '[3306] port number to connect to the database', 'optional', 3306);
+    this.addOption('db', null, 'database name', 'optional', '');
+  }
+
+  /**
+   * @param {*} args 
+   * @param {*} options 
+   */
+  async exec(args, options) {
+    const workflow = new Workflow(migration);
+    try {
+      await workflow.start({
+        action: args.action,
+        config: {
+          dir: args.dir
+        },
+        connection: {
+          host: options.host,
+          port: is.number(options.port) ?
+            options.port : parseInt(options.port),
+          user: options.user,
+          password: options.pass,
+          database: options.db
+        },
+        debug: options.debug
+      });
+      process.exit(0);
+    } catch (e) {
+      if (e.curr && e.curr.error) {
+        debug.error(e.curr.error);
+      } else {
+        debug.log(e);
+      }
+      process.exit(1);
+    }
+  }
+}
+
+module.exports = MigrateCommand;

package/examples/migration/.connect.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports = {
+  host: 'localhost',
+  port: 13306,
+  user: 'root',
+  password: '3AQqZTfmww=Ftj',
+  database: 'cms'
+};

package/examples/migration/20240101.create.table.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/**
+ * @param {import('../../').MigrationInterface} migration
+ */
+function up(migration) {
+  migration.createTable({
+    table_name: 'organization',
+    columns: [{
+      column_name: 'id',
+      type: 'int(11)',
+      not_null: true,
+      is_primary_key: true,
+    }]
+  });
+}
+
+/**
+ * @param {import('../../').MigrationInterface} migration
+ */
+function down(migration) {
+  migration.dropTable({ table_name: 'table1' });
+}
+
+module.exports = {
+  up,
+  down
+};

package/examples/migration/20240102.1.create.column.js

@@ -0,0 +1,14 @@
+'use strict';
+
+async function up(migration) {
+
+}
+
+async function down(migration) {
+
+}
+
+module.exports = {
+  up,
+  down
+};

package/examples/migration/20240102.2.create.index.js

@@ -0,0 +1 @@
+'use strict';

package/index.d.ts

@@ -50,7 +50,7 @@ export interface TableOption {
 
 export type QueryOperatorBaseOptions = {
   driver?: string | 'mysql';
-  query_handler?: QueryHandler;
+  queryHandler?: QueryHandler;
 };
 
 export type QueryOperatorOptions = QueryOperatorBaseOptions & {
@@ -161,6 +161,17 @@ export declare class QueryHandler {
    * @param condition 
    */
   upsert(tableName: string, data: any, condition: Record<string, ConditionValueType>): Promise<OkPacket>;
+
+  /**
+ * @param database default is options.database
+ */
+  existDatabase(database?: string): Promise<boolean>;
+
+  /**
+   * @param table
+   * @param database default is options.database
+   */
+  existTable(table: string, database?: string): Promise<boolean>;
 }
 
 export declare class TransactionOperator extends QueryOperator {
@@ -256,26 +267,117 @@ export declare class Builder {
 
 export declare class MySQLClient extends QueryHandler {
 
-  constructor(options?: ConnectionOptions, name?: string | null | undefined);
-
-  /**
-   * @param database default is options.database
-   */
-  existDatabase(database?: string): Promise<boolean>;
-
-  /**
-   * @param table
-   * @param database default is options.database
-   */
-  existTable(table: string, database?: string): Promise<boolean>;
+  constructor(options?: ConnectionOptions, name?: string | null | undefined, type?: 'default' | 'promise' | 'pool');
 
   /**
-   * 
    * @param query 
    * @param operator default is 'select'
    */
   execQuery(query: Query, operator?: OperatorType): Promise<QueryResult>;
 
   close(): Promise<void>;
+}
+
+type FieldType =
+  'TINYINT' | 'SMALLINT' | 'MEDIUMINT' | 'INT' | 'BIGINT' | 'FLOAT' | 'DOUBLE' | 'DECIMAL' |
+  'DATE' | 'TIME' | 'YEAR' | 'DATETIME' | 'TIMESTAMP' |
+  'CHAR' | 'VARCHAR' | 'TINYBLOB' | 'TINYTEXT' | 'BLOB' | 'TEXT' | 'MEDIUMBLOB' | 'MEDIUMTEXT' |
+  'LONGBLOB' | 'LONGTEXT' | 'ENUM' | 'SET' | 'JSON';
+
+interface ColumnItem {
+  type: FieldType,
+  length?: number,
+  unsigned?: boolean,
+  allowNull?: boolean,
+  default?: string | number | boolean | null | 'timestamp',
+  onUpdate?: boolean,
+  comment?: string,
+  autoIncrement?: boolean,
+  primaryKey?: boolean,
+  uniqIndex?: boolean
+}
+
+interface CreateColumnOptions {
+  length?: number,
+  unsigned?: boolean,
+  allowNull?: boolean,
+  default?: string | number | boolean | null | 'timestamp',
+  comment?: string,
+  autoIncrement?: boolean,
+  primaryKey?: boolean,
+  uniqIndex?: boolean
+}
+
+interface CreateIndexOptions {
+  unique?: boolean,
+  fulltext?: boolean,
+  spatial?: boolean
+}
 
+export type ManageBuilderOptions = {
+  operator: 'create' | 'drop' | 'alter';
+  columns: Record<string, ColumnItem>;
+  target: 'table' | 'column' | 'index' | 'foreign_key';
 }
+
+export declare class MigrationInterface {
+
+  /**
+   * @param tableName 
+   * @param columns 
+   * @param options default engine is InnoDB; default charset is utf8mb4
+   */
+  createTable(tableName: string, columns: Record<string, ColumnItem>, options?: {
+    engine?: 'InnoDB' | 'MyISAM' | 'MEMORY',
+    charset?: string
+  }): void;
+
+  /**
+   * @param columnName 
+   * @param columnType 
+   * @param tableName 
+   * @param options allowNull default is true
+   */
+  createColumn(columnName: string, columnType: FieldType, tableName: string, options?: {
+    length?: number,
+    unsigned?: boolean,
+    allowNull?: boolean,
+    default?: string | number | boolean | null | 'timestamp',
+    onUpdate?: string,
+    comment?: string,
+    autoIncrement?: boolean,
+    primaryKey?: boolean,
+    uniqIndex?: boolean,
+    after?: string
+  }): void;
+
+  createIndex(tableName: string, columns: string[], options?: {
+    indexName?: string,
+    unique?: boolean,
+    fulltext?: boolean,
+    spatial?: boolean
+  }): void;
+
+  createForeignKey(options: {
+    foreignKey?: string,
+    tableName: string,
+    columnName: string,
+    reference: {
+      tableName: string,
+      columnName: string,
+      onDelete?: 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'NO ACTION' | 'restrict' | 'cascade' | 'set null' | 'no action',
+      onUpdate?: 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'NO ACTION' | 'restrict' | 'cascade' | 'set null' | 'no action',
+    }
+  }): void;
+
+  dropTable(tableName: string): void;
+
+  dropColumn(columnName: string, tableName: string): void;
+
+  dropIndex(indexName: string): void;
+
+  dropForeignKey(foreign_key: string, tableName: string): void;
+}
+
+export declare function up(migration: MigrationInterface): Promise<void>;
+export declare function down(migration: MigrationInterface): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiosleo/orm-mysql",
-  "version": "0.8.6",
+  "version": "0.9.0",
   "description": "MySQL ORM tool",
   "keywords": [
     "mysql",
@@ -10,16 +10,20 @@
   "directories": {
     "lib": "src"
   },
+  "bin": {
+    "orm-mysql": "./bin/orm-mysql.js"
+  },
   "scripts": {
     "lint": "tsc ./index.d.ts && eslint --fix src/",
     "test": "mocha --reporter spec --timeout 3000 tests/*.tests.js",
     "test-cov": "nyc -r=lcov -r=html -r=text -r=json mocha -t 10000 -R spec tests/*.tests.js",
+    "test-one": "mocha --reporter spec --timeout 3000 ",
     "ci": "npm run lint && npm run test-cov",
     "clear": "rm -rf ./nyc_output ./coverage"
   },
   "license": "MIT",
   "dependencies": {
-    "@axiosleo/cli-tool": "^1.4.11",
+    "@axiosleo/cli-tool": "^1.6.0",
     "mysql2": "^2.3.3",
     "validatorjs": "^3.22.1"
   },

package/src/builder.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { debug } = require('@axiosleo/cli-tool');
 const Query = require('./query');
 const is = require('@axiosleo/cli-tool/src/helper/is');
+const { _caml_case, _render } = require('@axiosleo/cli-tool/src/helper/str');
+const { _validate } = require('./utils');
+const { _assign } = require('@axiosleo/cli-tool/src/helper/obj');
 
 /**
  * @param {array} arr 
@@ -14,6 +18,9 @@ const emit = (arr, res) => {
 };
 
 class Builder {
+  /**
+   * @param {import('../index').QueryOperatorOptions} options 
+   */
   constructor(options) {
     let sql = '';
     this.values = [];
@@ -80,6 +87,9 @@ class Builder {
         sql = tmp.join(' ');
         break;
       }
+      case 'manage': {
+        break;
+      }
       default:
         throw new Error('Invalid operator: ' + options.operator);
     }
@@ -285,6 +295,235 @@ class Builder {
   }
 }
 
+class ManageSQLBuilder extends Builder {
+  /**
+   * @param {import('../index').ManageBuilderOptions} options 
+   */
+  constructor(options) {
+    super({ operator: 'manage' });
+    // const emitter = new Emitter();
+    const action = `${options.operator}_${options.target}`;
+    const method = _caml_case(action, false);
+    if (!this[method]) {
+      throw new Error(`'${options.target}' Unsupported '${options.operator}' operation.`);
+    }
+    try {
+      this.sql = this[method].call(this, options);
+    } catch (err) {
+      debug.dump(`${options.operator} ${options.target} error: ${err.message}`);
+      throw err;
+    }
+  }
+
+  /**
+   * @param {import('../index').ManageBuilderOptions} options 
+   */
+  createTable(options) {
+    _validate(options, {
+      name: 'required|string',
+      engine: [{ in: ['InnoDB', 'MyISAM', 'MEMORY'] }],
+      charset: 'string'
+    });
+    if (is.empty(options.columns)) {
+      throw new Error('At least one column is required');
+    }
+    if (!Object.values(options.columns).find(c => c.primaryKey === true)) {
+      throw new Error('At least one primary key column is required');
+    }
+    let columns = Object.keys(options.columns).map(name => {
+      return { name, ...options.columns[name] };
+    });
+    options = _assign({
+      engine: 'InnoDB',
+      charset: 'utf8mb4'
+    }, options, {
+      columns: this.createColumns(columns)
+    });
+    return _render('CREATE TABLE `${name}` ( ${columns} ) ENGINE=${engine} DEFAULT CHARSET=${charset}', options);
+  }
+
+  createColumn(options) {
+    _validate(options, {
+      table: 'required|string',
+      name: 'required|string',
+      type: 'required|string',
+      length: 'number',
+      unsigned: 'boolean',
+      allowNull: 'boolean',
+      default: 'string',
+      comment: 'string',
+      autoIncrement: 'boolean',
+      primaryKey: 'boolean',
+      uniqIndex: 'boolean',
+      after: 'string'
+    });
+    return `ALTER TABLE \`${options.table}\` ADD COLUMN ` + this.renderSingleColumn(options);
+  }
+
+  createIndex(options) {
+    _validate(options, {
+      name: 'required|string',
+      table: 'required|string',
+      columns: 'required|array',
+      unique: 'boolean',
+      fulltext: 'boolean',
+      spatial: 'boolean',
+      order: [{ in: ['asc', 'desc'] }],
+      visible: 'boolean'
+    });
+
+    return _render('CREATE INDEX `${index_name}` ON `${table_name}` (${column_names}) ${visible}', {
+      index_name: options.name,
+      table_name: options.table,
+      visible: options.visible === false ? 'INVISIBLE' : 'VISIBLE',
+      column_names: options.columns.map(c => {
+        if (c.indexOf(' ') !== -1) {
+          let t = c.split(' ', 2);
+          return `\`${t[0]}\` ${t[1].toUpperCase()}`;
+        }
+        return `\`${c}\``;
+      }).join(', ')
+    });
+  }
+
+  createForeignKey(options) {
+    _validate(options, {
+      name: 'required|string',
+      table: 'required|string',
+      column: 'required|string',
+      'reference.tableName': 'required|string',
+      'reference.columnName': 'required|string',
+      'reference.onUpdate': [{ in: ['RESTRICT', 'CASCADE', 'SET NULL', 'NO ACTION'] }],
+      'reference.onDelete': [{ in: ['RESTRICT', 'CASCADE', 'SET NULL', 'NO ACTION'] }]
+    });
+    return _render('ALTER TABLE `${table_name}` ADD CONSTRAINT `${name}` FOREIGN KEY (`${column_name}`) REFERENCES `${foreign_table}` (`${foreign_column}`) ON DELETE ${on_delete} ON UPDATE ${on_update}', {
+      table_name: options.tableName,
+      name: options.name,
+      column_name: options.columnName,
+      foreign_table: options.reference.tableName,
+      foreign_column: options.reference.columnName,
+      on_delete: options.reference.onDelete || 'NO ACTION',
+      on_update: options.reference.onUpdate || 'NO ACTION',
+    });
+  }
+
+  dropTable(options) {
+    _validate(options, {
+      name: 'required|string',
+    });
+    return _render('DROP TABLE `${name}`', options);
+  }
+
+  dropColumn(options) {
+    _validate(options, {
+      table: 'required|string',
+      name: 'required|string',
+    });
+    return _render('ALTER TABLE `${table}` DROP COLUMN `${name}`', options);
+
+  }
+
+  dropIndex(options) {
+    _validate(options, {
+      name: 'required|string',
+      table: 'required|string',
+    });
+    return _render('DROP INDEX `${name}` ON `${table}`', options);
+  }
+
+  dropForeignKey(options) {
+    _validate(options, {
+      name: 'required|string',
+      table: 'required|string',
+    });
+    return _render('ALTER TABLE `${table}` DROP FOREIGN KEY `${name}`', options);
+  }
+
+  createColumns(columns) {
+    let primaryColumn = null;
+    let indexColumns = [];
+    let strs = columns.map(column => {
+      let str = this.renderSingleColumn(column);
+      if (column.primaryKey === true) {
+        primaryColumn = column;
+      } else if (column.uniqIndex === true) {
+        indexColumns.push(column);
+      }
+      return str;
+    });
+    if (primaryColumn) {
+      strs.push(`PRIMARY KEY (\`${primaryColumn.name}\`)`);
+      strs.push(`UNIQUE INDEX \`${primaryColumn.name}\` (\`${primaryColumn.name}\` ASC) VISIBLE`);
+    }
+    if (indexColumns.length > 0) {
+      indexColumns.forEach((i) => {
+        strs.push(`UNIQUE INDEX \`${i.name}\` (\`${i.name}\` ASC) VISIBLE`);
+      });
+    }
+    return strs.join(', ');
+  }
+
+  renderSingleColumn(options) {
+    _validate(options, {
+      name: 'required|string',
+      type: 'required|string',
+      default: 'string',
+      onUpdate: 'string',
+      length: 'integer',
+      comment: 'string',
+      allowNull: 'boolean',
+      autoIncrement: 'boolean',
+      collate: 'string',
+      primaryKey: 'boolean',
+      uniqIndex: 'boolean'
+    });
+    let type = options.type.toUpperCase();
+    if (type === 'STRING') {
+      type = 'VARCHAR';
+    }
+    let str = `\`${options.name}\` ${type}`;
+    if (typeof options.length !== 'undefined') {
+      str += `(${options.length})`;
+    } else if (type === 'INT') {
+      str += '(11)';
+    } else if (type === 'VARCHAR') {
+      str += '(255)';
+    }
+    if (options.allowNull === false) {
+      str += ' NOT NULL';
+    }
+    if (options.unsigned === true) {
+      str += ' UNSIGNED';
+    }
+    if (typeof options.default !== 'undefined') {
+      if (options.primaryKey === true) {
+        throw new Error('Primary key can not have default value.');
+      }
+      if (options.default === null) {
+        str += ' DEFAULT NULL';
+      } else if (options.default === 'timestamp') {
+        str += ' DEFAULT CURRENT_TIMESTAMP';
+      } else if (is.string(options.default)) {
+        str += ` DEFAULT ${options.default}`;
+      }
+    }
+    if (options.onUpdate) {
+      str += ` ON UPDATE ${options.onUpdate}`;
+    }
+    if (is.string(options.comment) && is.empty(options.comment) === false) {
+      str += ` COMMENT '${options.comment}'`;
+    }
+    if (options.autoIncrement === true) {
+      str += ' AUTO_INCREMENT';
+    }
+    if (options.after) {
+      str += ' AFTER `' + options.after + '`';
+    }
+    return str;
+  }
+}
+
 module.exports = {
-  Builder
+  Builder,
+  ManageSQLBuilder
 };

package/src/client.js

@@ -3,8 +3,9 @@
 const mysql = require('mysql2');
 const mysqlPromise = require('mysql2/promise');
 const { _validate } = require('./utils');
-const { QueryHandler, Query } = require('./operator');
-const { _query } = require('./utils');
+const { _query } = require('./core');
+const { QueryHandler } = require('./operator');
+const Query = require('./query');
 
 const clients = {};
 
@@ -16,9 +17,9 @@ const clients = {};
 const createClient = (options, name = null) => {
   _validate(options, {
     host: 'required|string',
+    port: 'required|integer',
     user: 'required|string',
     password: 'required|string',
-    port: 'required|integer',
     database: 'required|string',
   });
   const key = name ? name :
@@ -39,9 +40,9 @@ const createClient = (options, name = null) => {
 const createPromiseClient = async (options, name = null) => {
   _validate(options, {
     host: 'required|string',
+    port: 'required|integer',
     user: 'required|string',
     password: 'required|string',
-    port: 'required|integer',
     database: 'required|string',
   });
   const key = name ? name :
@@ -96,31 +97,24 @@ class MySQLClient extends QueryHandler {
   /**
    * @param {mysql.ConnectionOptions} options 
    * @param {*} name 
+   * @param {'default'|'promise'|'pool'} type
    */
-  constructor(options, name = 'default') {
-    const conn = createClient(options, name);
+  constructor(options, name = 'default', type = 'default') {
+    let conn;
+    switch (type) {
+      case 'default':
+        conn = createClient(options, name);
+        break;
+      case 'pool':
+        conn = createPool(options, name);
+        break;
+      default:
+        throw new Error(`client type ${type} not found`);
+    }
     super(conn);
     this.database = options.database;
   }
 
-  async existTable(table, database = null) {
-    if (!table) {
-      throw new Error('table name is required');
-    }
-    const c = await this.table('information_schema.TABLES')
-      .where('TABLE_SCHEMA', database || this.database)
-      .where('TABLE_NAME', table)
-      .count();
-    return !!c;
-  }
-
-  async existDatabase(database) {
-    const c = await this.table('information_schema.SCHEMATA')
-      .where('SCHEMA_NAME', database)
-      .count();
-    return !!c;
-  }
-
   /**
    * @param {import('./operator').Query} query 
    */

package/src/core.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const { Builder } = require('./builder');
+
+/**
+ * 
+ * @param {import('mysql2/promise').Connection} conn 
+ * @param {*} options 
+ * @param {*} opt 
+ * @returns 
+ */
+const _query = (conn, options, opt = null) => {
+  switch (options.driver) {
+    case 'mysql': {
+      if (opt === null) {
+        const builder = new Builder(options);
+        opt = {
+          sql: builder.sql,
+          values: builder.values || [],
+        };
+      }
+      return new Promise((resolve, reject) => {
+        if (options.transaction) {
+          conn.execute(opt.sql, opt.values || []).then((res) => {
+            resolve(res[0]);
+          }).catch((err) => reject(err));
+          return;
+        }
+        conn.query(opt, (err, result) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(result);
+          }
+        });
+
+      });
+    }
+    default: {
+      if (typeof options.queryHandler === 'function') {
+        const promise = options.queryHandler(conn, options, opt);
+        if (promise instanceof Promise) {
+          return promise;
+        }
+      }
+      throw new Error('queryHandler must return a promise');
+    }
+  }
+};
+
+const _execSQL = (conn, sql, values = []) => {
+  let opt = { sql, values };
+  return new Promise((resolve, reject) => {
+    if (conn.query instanceof Function) {
+      conn.query(opt, (err, result) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(result);
+        }
+      });
+    } else {
+      conn.execute(opt)
+        .then((res) => resolve(res))
+        .catch((err) => reject(err));
+    }
+  });
+};
+
+module.exports = {
+  _query,
+  _execSQL
+};

package/src/migration.d.ts

@@ -0,0 +1,25 @@
+type QueryItem = {
+  sql: string,
+  values: any[],
+};
+
+export type Context = {
+  action: 'up' | 'down',
+  connection: {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+  },
+  items: string[],
+  task_key: string,
+  config: {
+    dir: string,
+  },
+  files: [],
+  runtime?: {
+    script: string,
+    queries: QueryItem[],
+  },
+};

package/src/migration.js

@@ -0,0 +1,319 @@
+'use strict';
+
+const path = require('path');
+const { _list, _exists } = require('@axiosleo/cli-tool/src/helper/fs');
+const { createClient, createPool, createPromiseClient } = require('./client');
+const { QueryHandler } = require('./operator');
+const { printer, debug } = require('@axiosleo/cli-tool');
+const { _execSQL } = require('./core');
+const { _render } = require('@axiosleo/cli-tool/src/helper/str');
+const { _foreach } = require('@axiosleo/cli-tool/src/helper/cmd');
+const { _assign } = require('@axiosleo/cli-tool/src/helper/obj');
+const { TransactionHandler } = require('..');
+const { ManageSQLBuilder } = require('./builder');
+
+const migrationColumns = [
+  {
+    name: 'id',
+    type: 'int',
+    length: 11,
+    allowNull: false,
+    autoIncrement: true,
+    primaryKey: true,
+  },
+  {
+    name: 'migration_key',
+    type: 'varchar',
+    length: 255,
+    allowNull: false,
+  },
+  {
+    name: 'filename',
+    type: 'varchar',
+    length: 255,
+    allowNull: false,
+    uniqIndex: true,
+  },
+  {
+    name: 'created_at',
+    type: 'datetime',
+    allowNull: false,
+    default: 'timestamp',
+  }
+];
+
+/**
+ * initialize migration
+ * @param {import('./migration').Context} context 
+ */
+async function init(context) {
+  let files = await _list(context.config.dir, false, '.js');
+  if (context.action === 'down') {
+    files = files.reverse();
+  }
+  context.files = files.filter(f => f !== '.connect.js');
+
+  const connectPath = path.join(context.config.dir, '.connect.js');
+  if (await _exists(connectPath)) {
+    const connect = require(connectPath);
+    _assign(context.connection, connect);
+  }
+  context.task_key = 'migrate_' + context.connection.database;
+  let globalConn = createClient({
+    ...context.connection,
+    database: 'mysql'
+  });
+  let handler = new QueryHandler(globalConn);
+
+  const database = context.connection.database;
+  if (!await handler.existDatabase(database)) {
+    printer.yellow('will create database ' + database).println().println();
+    await _execSQL(globalConn, _render('CREATE DATABASE `${database_name}` CHARACTER SET ${charset} COLLATE ${collate}', {
+      database_name: database,
+      charset: 'utf8mb4',
+      collate: 'utf8mb4_unicode_ci'
+    }));
+  }
+  globalConn.end();
+  const conn = createPool(context.connection, context.task_key);
+  context.pool = conn;
+
+  handler = new QueryHandler(conn);
+  if (await handler.existTable(context.task_key, database)) {
+    conn.end();
+    return;
+  }
+
+  // migration table not exists
+  printer.yellow('will create table ' + context.task_key).println();
+  let builder = new ManageSQLBuilder({
+    operator: 'create',
+    target: 'table',
+    name: context.task_key,
+    columns: migrationColumns
+  });
+  let res = await _execSQL(conn, builder.sql);
+  conn.end();
+  if (res.serverStatus !== 2) {
+    printer.error('create migration table failed.');
+    process.exit(1);
+  }
+}
+
+/**
+ * initialize migration
+ * @param {import('./migration').Context} context 
+ */
+async function _exec(context, queries) {
+  const conn = await createPromiseClient(context.connection, context.task_key + '_transaction');
+  const transaction = new TransactionHandler(conn);
+  await transaction.begin();
+
+  try {
+    const files = Object.keys(queries);
+    await _foreach(files, async (file) => {
+      const hasMigarated = await transaction.table(context.task_key)
+        .where('migration_key', context.task_key)
+        .where('filename', file)
+        .count();
+      if (context.action === 'up' && hasMigarated) {
+        if (hasMigarated) {
+          printer.yellow(`Migration file "${file}" has been migrated.`).println();
+          return;
+        }
+      } else if (context.action === 'down' && !hasMigarated) {
+        return;
+      }
+
+      const sqls = queries[file];
+      await _foreach(sqls, async (query) => {
+        if (context.debug) {
+          debug.log(query.sql);
+        }
+        await transaction.query(query);
+      });
+
+      if (context.action === 'up') {
+        await transaction.table(context.task_key).insert({
+          migration_key: context.task_key,
+          filename: file,
+          created_at: new Date()
+        });
+        printer.green('Success migrate up: ').yellow(file).println(' ');
+      } else {
+        const item = await transaction.table(context.task_key)
+          .where('migration_key', context.task_key)
+          .where('filename', file).find();
+        if (item) {
+          await transaction.table(context.task_key).where('id', item.id).delete();
+        }
+        printer.green('Success migrate down: ').yellow(file).println(' ');
+      }
+    });
+    await transaction.commit();
+  } catch (e) {
+    await transaction.rollback();
+    debug.log(e);
+  }
+}
+
+function _initMigration(file, queries = {}) {
+  const migration = {};
+  let baseAttr = {
+    writable: true,
+    enumerable: true,
+    configurable: true
+  };
+  Object.defineProperty(migration, 'createTable', {
+    value: function (table, columns, options = {}) {
+      _assign(options, {
+        operator: 'create',
+        target: 'table',
+        name: table,
+        columns
+      });
+      const builder = new ManageSQLBuilder(options);
+      queries[file].push({ sql: builder.sql, values: builder.values });
+    }, ...baseAttr
+  });
+  Object.defineProperty(migration, 'createColumn', {
+    value: function (name, type, table, options = {}) {
+      _assign(options, {
+        operator: 'create',
+        target: 'column',
+        table,
+        name,
+        type
+      });
+      const builder = new ManageSQLBuilder(options);
+      queries[file].push({ sql: builder.sql, values: builder.values });
+    }, ...baseAttr
+  });
+
+  Object.defineProperty(migration, 'createIndex', {
+    value: function (table, columns, options = {}) {
+      _assign(options, {
+        operator: 'create',
+        target: 'index',
+        name: options.indexName ? options.indexName : 'idx_' + table + '_' + columns.join('_'),
+        table,
+        columns
+      });
+      const builder = new ManageSQLBuilder(options);
+      queries[file].push({ sql: builder.sql, values: builder.values });
+    }, ...baseAttr
+  });
+
+  Object.defineProperty(migration, 'createForeignKey', {
+    value: function (options = {}) {
+      _assign(options, {
+        operator: 'create',
+        target: 'foreignKey',
+        name: options.foreignKey ? options.foreignKey : 'fk_' + options.tableName + '_' + options.columnName,
+        table: options.tableName,
+        column: options.columnName,
+        reference: options.reference
+      });
+      const builder = new ManageSQLBuilder(options);
+      queries[file].push({ sql: builder.sql, values: builder.values });
+    }, ...baseAttr
+  });
+
+  Object.defineProperty(migration, 'dropTable', {
+    value: function (table) {
+      const builder = new ManageSQLBuilder({
+        operator: 'drop',
+        target: 'table',
+        name: table
+      });
+      queries[file].push({ sql: builder.sql, values: builder.values });
+    }, ...baseAttr
+  });
+
+  Object.defineProperty(migration, 'dropColumn', {
+    value: function (name, table) {
+      const builder = new ManageSQLBuilder({
+        operator: 'drop',
+        target: 'column',
+        name,
+        table
+      });
+      queries[file].push({ sql: builder.sql, values: builder.values });
+    }, ...baseAttr
+  });
+
+  Object.defineProperty(migration, 'dropIndex', {
+    value: function (name, table) {
+      const builder = new ManageSQLBuilder({
+        operator: 'drop',
+        target: 'index',
+        name,
+        table
+      });
+      queries[file].push({ sql: builder.sql, values: builder.values });
+    }, ...baseAttr
+  });
+
+  Object.defineProperty(migration, 'dropForeignKey', {
+    value: function (name, table) {
+      const builder = new ManageSQLBuilder({
+        operator: 'drop',
+        target: 'foreignKey',
+        name,
+        table
+      });
+      queries[file].push({ sql: builder.sql, values: builder.values });
+    }, ...baseAttr
+  });
+
+  return migration;
+}
+
+/**
+ * initialize migration
+ * @param {import('./migration').Context} context 
+ */
+async function run(context) {
+  const { files } = context;
+  const queries = {};
+  await _foreach(files, async (file) => {
+    const scriptPath = path.join(context.config.dir, file);
+    const script = require(scriptPath);
+    queries[file] = [];
+
+    const migration = _initMigration(file, queries);
+
+    switch (context.action) {
+      case 'up': {
+        if (typeof script.up !== 'function') {
+          printer.error(`Migration file "${file}" must have a function named up.`);
+          process.exit(1);
+        }
+        await script.up(migration);
+        break;
+      }
+      case 'down': {
+        if (typeof script.down !== 'function') {
+          printer.error(`Migration file "${file}" must have a function named down.`);
+          process.exit(1);
+        }
+        await script.down(migration);
+        break;
+      }
+      default: {
+        throw new Error(`Unknown migration action ${context.action}.`);
+      }
+    }
+  });
+  await _exec(context, queries);
+}
+
+async function end(context) {
+  printer.yellow('Done').println(' ');
+}
+
+module.exports = {
+  init,
+  run,
+  end
+};

package/src/operator.js

@@ -3,7 +3,7 @@
 const { Builder } = require('./builder');
 const Query = require('./query');
 const Hook = require('./hook');
-const { _query } = require('./utils');
+const { _query } = require('./core');
 
 class QueryOperator extends Query {
   /**
@@ -13,13 +13,13 @@ class QueryOperator extends Query {
     super(null);
     this.conn = conn;
     this.options.driver = options.driver || 'mysql';
-    this.options.query_handler = options.query_handler || null;
+    this.options.queryHandler = options.queryHandler || null;
     if (this.options.driver !== 'mysql') {
-      if (!this.options.query_handler) {
-        throw new Error('query_handler is required');
+      if (!this.options.queryHandler) {
+        throw new Error('queryHandler is required');
       }
-      if (!(this.options.query_handler instanceof Function)) {
-        throw new Error('query_handler must be a function');
+      if (!(this.options.queryHandler instanceof Function)) {
+        throw new Error('queryHandler must be a function');
       }
     }
   }
@@ -131,6 +131,26 @@ class QueryHandler {
     }
     return await this.table(tableName).insert(data);
   }
+
+  async existTable(table, database = null) {
+    if (!table) {
+      throw new Error('table name is required');
+    }
+    const query = new QueryOperator(this.conn, this.options);
+    const c = await query.table('information_schema.TABLES')
+      .where('TABLE_SCHEMA', database || this.database)
+      .where('TABLE_NAME', table)
+      .count();
+    return !!c;
+  }
+
+  async existDatabase(database) {
+    const query = new QueryOperator(this.conn, this.options);
+    const c = await query.table('information_schema.SCHEMATA')
+      .where('SCHEMA_NAME', database)
+      .count();
+    return !!c;
+  }
 }
 
 module.exports = {

package/src/query.js

@@ -4,7 +4,7 @@ class Query {
   constructor(operator = 'select') {
     this.options = {
       driver: 'mysql',
-      query_handler: null,
+      queryHandler: null,
       conditions: [],
       orders: [],
       tables: [],

package/src/transaction.js

@@ -3,6 +3,7 @@
 // eslint-disable-next-line no-unused-vars
 const mysql = require('mysql2/promise');
 const { QueryOperator } = require('./operator');
+const { _query } = require('./core');
 
 const levels = {
   RU: 'READ UNCOMMITTED',
@@ -19,13 +20,13 @@ class TransactionOperator extends QueryOperator {
     super(conn);
     this.options.transaction = true;
     this.options.driver = options.driver || 'mysql';
-    this.options.query_handler = options.query_handler || null;
+    this.options.queryHandler = options.queryHandler || null;
     if (this.options.driver !== 'mysql') {
-      if (!this.options.query_handler) {
-        throw new Error('query_handler is required');
+      if (!this.options.queryHandler) {
+        throw new Error('queryHandler is required');
       }
-      if (!(this.options.query_handler instanceof Function)) {
-        throw new Error('query_handler must be a function');
+      if (!(this.options.queryHandler instanceof Function)) {
+        throw new Error('queryHandler must be a function');
       }
     }
   }
@@ -60,13 +61,9 @@ class TransactionHandler {
 
   async query(options) {
     return new Promise((resolve, reject) => {
-      this.conn.query(options, (err, result) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(result);
-        }
-      });
+      _query(this.conn, { transaction: true, driver: 'mysql' }, options)
+        .catch((res) => reject(res))
+        .then((res) => resolve(res));
     });
   }
 

package/src/utils.js

@@ -1,55 +1,21 @@
 'use strict';
 
 const Validator = require('validatorjs');
-const { Builder } = require('./builder');
 
-const _validate = (obj, rules) => {
+const _validate = (obj, rules, throwError = true) => {
   let validation = new Validator(obj, rules);
   validation.check();
   if (validation.fails()) {
     const errors = validation.errors.all();
     const keys = Object.keys(errors);
-    throw new Error(`${keys[0]}: ${errors[keys[0]]}`);
-  }
-};
-
-const _query = async (conn, options, opt = null) => {
-  switch (options.driver) {
-    case 'mysql': {
-      if (opt === null) {
-        const builder = new Builder(options);
-        opt = {
-          sql: builder.sql,
-          values: builder.values || [],
-        };
-      }
-      return new Promise((resolve, reject) => {
-        if (options.transaction) {
-          conn.execute(opt)
-            .then((res) => resolve(res))
-            .catch((err) => reject(err));
-        } else {
-          conn.query(opt, (err, result) => {
-            if (err) {
-              reject(err);
-            } else {
-              resolve(result);
-            }
-          });
-        }
-      });
-    }
-    default: {
-      const promise = options.query_handler(conn, options, opt);
-      if (!(promise instanceof Promise)) {
-        throw new Error('query_handler must return a promise');
-      }
-      return promise;
+    if (throwError) {
+      throw new Error(`${keys[0]}: ${errors[keys[0]]}`);
     }
+    return errors;
   }
+  return null;
 };
 
 module.exports = {
   _validate,
-  _query
 };