@axiosleo/orm-mysql 0.3.1 → 0.5.0

package/.env

@@ -3,4 +3,4 @@ MYSQL_HOST = "rm-bp1a906h4019pldm6io.mysql.rds.aliyuncs.com"
 MYSQL_USER = "kms"
 MYSQL_PASS = "bmPWuq_vJgupdL9"
 MYSQL_PORT = 3306
-MYSQL_DB = "business_5b5ecd9941d6cc1bbc065fc6"
+MYSQL_DB = "kms-test"

package/README.md

@@ -1,5 +1,11 @@
 # @axiosleo/orm-mysql
 
+
+[![NPM version](https://img.shields.io/npm/v/@axiosleo/orm-mysql.svg?style=flat-square)](https://npmjs.org/package/@axiosleo/orm-mysql)
+[![npm download](https://img.shields.io/npm/dm/@axiosleo/orm-mysql.svg?style=flat-square)](https://npmjs.org/package/@axiosleo/orm-mysql)
+[![License](https://img.shields.io/github/license/AxiosLeo/node-orm-mysql?color=%234bc524)](LICENSE)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FAxiosLeo%2Fnode-orm-mysql.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2FAxiosLeo%2Fnode-orm-mysql?ref=badge_shield)
+
 ## Installation
 
 ```bash
@@ -46,7 +52,7 @@ query.offset(0);                 // set offset
 let rows = await query.select(); // select
 ```
 
-### Some Examples
+### Some Query Examples
 
 ```javascript
 const { createClient, QueryHandler, Query } = require("@axiosleo/orm-mysql");
@@ -129,6 +135,59 @@ async function subqueryExample() {
 }
 ```
 
+### Hook
+
+```javascript
+const { Hook } = require("@axiosleo/orm-mysql");
+
+// opt: 'select' | 'find' | 'insert' | 'update' | 'delete' | 'count'
+
+Hook.pre(async (options) => {
+  debug.log('options', options);
+}, { table: 'table_name', opt: 'insert'});
+
+Hook.post(async (options, result) => {
+  throw new Error('some error');
+}, { table: 'table_name', opt: 'insert' });
+```
+
+### Transaction
+
+```javascript
+const { TransactionHandler, createPromiseClient } = require("@axiosleo/orm-mysql");
+
+const conn = createPromiseClient({
+  host: process.env.MYSQL_HOST,
+  port: process.env.MYSQL_PORT,
+  user: process.env.MYSQL_USER,
+  password: process.env.MYSQL_PASS,
+  database: process.env.MYSQL_DB,
+});
+
+const transaction = new TransactionHandler(connection);
+
+try {
+  // insert user info
+  let row = await transaction.table("users").insert({
+    name: "Joe",
+    age: 18,
+  });
+  const lastInsertId = row[0].insertId;
+
+  // insert student info
+  await transaction.table("students").insert({
+    user_id: lastInsertId,
+  });
+  await transaction.commit();
+} catch (e) {
+  await transaction.rollback();
+  throw e;
+}
+```
+
 ## License
 
 This project is open-sourced software licensed under the [MIT](LICENSE).
+
+
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FAxiosLeo%2Fnode-orm-mysql.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2FAxiosLeo%2Fnode-orm-mysql?ref=badge_large)

package/index.d.ts

@@ -1,11 +1,17 @@
 import {
+  Pool,
   OkPacket,
   Connection,
+  PoolOptions,
   QueryOptions,
   RowDataPacket,
   ConnectionOptions
 } from 'mysql2';
 
+import {
+  Connection as PromiseConnection,
+} from 'mysql2/promise';
+
 export type Clients = {
   [key: string]: Connection
 }
@@ -30,7 +36,7 @@ export interface OrderByOptions {
 export type OperatorType = 'select' | 'find' | 'insert' | 'update' | 'delete' | 'count';
 
 export interface JoinOption {
-  table: string;
+  table: string | Query;
   table_alias?: string;
   self_column: string;
   foreign_column: string;
@@ -54,6 +60,8 @@ export interface QueryOperatorOptions {
   groupField: string[];
   joins: JoinOption[];
   having: WhereOptions[];
+  suffix?: string | null;
+  transaction: boolean;
 }
 
 export declare class Query {
@@ -90,6 +98,8 @@ export declare class Query {
   join(opt: JoinOption): this;
 }
 
+export type QueryResult = any | undefined | RowDataPacket[] | RowDataPacket | OkPacket;
+
 export declare class QueryOperator extends Query {
   conn: Connection;
   options: QueryOperatorOptions
@@ -98,7 +108,7 @@ export declare class QueryOperator extends Query {
 
   buildSql(operator: OperatorType): { sql: string, values: any[] };
 
-  exec(): Promise<any | undefined | RowDataPacket[] | RowDataPacket | OkPacket>;
+  exec(): Promise<QueryResult>;
 
   select<T>(): Promise<T[]>;
 
@@ -110,7 +120,12 @@ export declare class QueryOperator extends Query {
 
   count(): Promise<number>;
 
-  delete(id?: number): Promise<OkPacket>;
+  /**
+   * delete data
+   * @param id 
+   * @param index_field_name default is 'id'
+   */
+  delete(id?: number, index_field_name?: string): Promise<OkPacket>;
 }
 
 export declare class QueryHandler {
@@ -125,6 +140,51 @@ export declare class QueryHandler {
   upsert(tableName: string, data: any, condition: Record<string, ConditionValueType>): Promise<OkPacket>;
 }
 
+export declare class TransactionOperator extends QueryOperator {
+  append(suffix: string): this;
+}
+
+export declare class TransactionHandler {
+  constructor(conn: PromiseConnection, options?: {
+    level: 'READ UNCOMMITTED' | 'RU'
+    | 'READ COMMITTED' | 'RC'
+    | 'REPEATABLE READ' | 'RR'
+    | 'SERIALIZABLE' | 'S'
+  });
+
+  query(options: QueryOptions): Promise<any>;
+
+  execute(sql: string, values: any[]): Promise<any>;
+
+  lastInsertId(alias?: string): Promise<number>;
+
+  table(table: string, alias?: string | null): TransactionOperator;
+
+  begin(): Promise<void>;
+
+  commit(): Promise<void>;
+
+  rollback(): Promise<void>;
+
+  upsert(tableName: string, data: any, condition: Record<string, ConditionValueType>): Promise<OkPacket>;
+}
+
 export function createClient(options: ConnectionOptions, name?: string | null | undefined): Connection;
 
 export function getClient(name: string): Connection;
+
+export function createPool(options: PoolOptions, name?: string | null | undefined): Pool;
+
+export function createPromiseClient(options: ConnectionOptions, name?: string | null | undefined): PromiseConnection;
+
+export declare class Hook {
+  static pre: (
+    callback: (options: QueryOperatorOptions) => void,
+    option: { table?: string, opt?: OperatorType }
+  ) => string;
+
+  static post: (
+    callback: (options: QueryOperatorOptions, result: QueryResult | Error) => void,
+    option: { table?: string, opt?: OperatorType }
+  ) => string;
+}

package/index.js

@@ -6,13 +6,32 @@ const {
   Query
 } = require('./src/operator');
 
-const { createClient, getClient } = require('./src/client');
+const {
+  TransactionOperator,
+  TransactionHandler
+} = require('./src/transaction');
+
+const {
+  getClient,
+  createPool,
+  createClient,
+  createPromiseClient
+} = require('./src/client');
+
+const { Hook } = require('./src/hook');
 
 module.exports = {
+  Hook,
+
   Query,
   QueryHandler,
   QueryOperator,
 
+  TransactionOperator,
+  TransactionHandler,
+
   getClient,
-  createClient
+  createPool,
+  createClient,
+  createPromiseClient
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiosleo/orm-mysql",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "MySQL ORM tool",
   "keywords": [
     "mysql",

package/runtimes/hook.js

@@ -0,0 +1,104 @@
+/* eslint-disable no-console */
+'use strict';
+
+const EventEmitter = require('events');
+const { debug } = require('@axiosleo/cli-tool');
+const events = {}; // event tree
+const hook = new EventEmitter();
+
+const pushEvent = ({ label, table, opt, callback }) => {
+  label = label || '*';
+  if (!events[label]) {
+    events[label] = {};
+  }
+  table = table || '*';
+  if (!events[label][table]) {
+    events[label][table] = {};
+  }
+  opt = opt || '*';
+  if (!events[label][table][opt]) {
+    events[label][table][opt] = 0;
+  }
+  events[label][table][opt]++;
+  hook.on(`${label}::${table}::${opt}`, callback);
+  return { label, table, opt, callback };
+};
+
+const eventRecur = (curr, trace, step, paths, args) => {
+  if (step === trace.length) {
+    hook.emit(paths.join('::'), ...args);
+    return;
+  }
+  const t = trace[step];
+  if (curr['*']) {
+    paths[step] = '*';
+    eventRecur(curr[t], trace, step + 1, paths, args);
+  }
+  if (curr[t]) {
+    paths[step] = t;
+    eventRecur(curr[t], trace, step + 1, paths, args);
+  }
+  return;
+};
+
+const handleEvent = (label, table, opt, ...args) => {
+  let curr = events;
+  let step = 0;
+  let trace = [label, table, opt];
+  eventRecur(curr, trace, step, [], args);
+};
+
+pushEvent({
+  label: 'before',
+  table: 'table1',
+  opt: 'insert',
+  callback: (...args) => {
+    debug.log(args);
+  }
+});
+pushEvent({
+  table: 'table1',
+  opt: 'insert',
+  callback: (...args) => {
+    debug.log(args);
+  }
+});
+pushEvent({
+  label: 'before',
+  table: 'table1',
+  callback: (...args) => {
+    debug.log(args);
+  }
+});
+pushEvent({
+  label: 'before',
+  opt: 'insert',
+  callback: (...args) => {
+    debug.log(args);
+  }
+});
+pushEvent({
+  label: 'before',
+  callback: (...args) => {
+    debug.log(args);
+  }
+});
+pushEvent({
+  table: 'table1',
+  callback: (...args) => {
+    debug.log(args);
+  }
+});
+pushEvent({
+  opt: 'insert',
+  callback: (...args) => {
+    debug.log(args);
+  }
+});
+pushEvent({
+  callback: (...args) => {
+    debug.log(args);
+  }
+});
+debug.log(JSON.stringify(events, null, 2));
+handleEvent('before', 'table1', 'insert', 1, 2, 3);

package/runtimes/test.js

@@ -1,45 +1,73 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable no-console */
 'use strict';
 
+const path = require('path');
 const dotenv = require('dotenv');
-dotenv.config();
+dotenv.config({
+  path: path.join(__dirname, '../.env')
+});
 const { debug } = require('@axiosleo/cli-tool');
 
-const mysql = require('mysql2');
-const {
-  QueryHandler,
-  // Query
-} = require('../src/operator');
-
-const conn = mysql.createConnection({
-  host: process.env.MYSQL_HOST,
-  port: process.env.MYSQL_PORT,
-  user: process.env.MYSQL_USER,
-  password: process.env.MYSQL_PASS,
-  database: process.env.MYSQL_DB,
-});
-const hanlder = new QueryHandler(conn);
+const mysql = require('mysql2/promise');
 
-const test = async () => {
-  const query = hanlder.table('meta_items_relationship', 'mir')
-    .attr('mi_p.meta as p_meta', 'mi_c.meta as c_meta', 'mir.item_parent as item_parent_id', 'mir.item_child as item_child_id');
-  const res = query
-    .where('mi_p.id', 601)
-    .join({
-      table: 'meta_items',
-      table_alias: 'mi_p',
-      self_column: 'mir.item_parent',
-      foreign_column: 'mi_p.id',
-      // join_type: 'left'
-    })
-    .join({
-      table: 'meta_items',
-      table_alias: 'mi_c',
-      self_column: 'mir.item_child',
-      foreign_column: 'mi_c.id',
-    }).buildSql('select');
-  const result = await query.select();
-  debug.halt(res, result);
-};
+const { TransactionHandler } = require('../src/transaction');
 
-test();
+async function main() {
+  const items = ['RI0002', 'CB0004'];
+  const config = {
+    user: process.env.MYSQL_USER,
+    password: process.env.MYSQL_PASS,
+    host: process.env.MYSQL_HOST,
+    port: process.env.MYSQL_PORT,
+    database: process.env.MYSQL_DB,
+  };
+  const connection = await mysql.createConnection(config);
+  const transaction = new TransactionHandler(connection);
+  await transaction.begin();
+  console.log('Finished setting the isolation level to read committed');
+  try {
+    await transaction.table('product').attr('id', 'name').where('sku', items, 'IN').append('FOR UPDATE').select();
+    console.log(`Locked rows for skus ${items.join()}`);
+    const [itemsToOrder] = await transaction.table('product').attr('name', 'quantity', 'price').where('sku', items, 'IN').orderBy('id').select();
+    console.log('Selected quantities for items');
+    let orderTotal = 0;
+    let orderItems = [];
+    for (let itemToOrder of itemsToOrder) {
+      if (itemToOrder.quantity < 1) {
+        throw new Error(`One of the items is out of stock ${itemToOrder.name}`);
+      }
+      console.log(`Quantity for ${itemToOrder.name} is ${itemToOrder.quantity}`);
+      orderTotal += itemToOrder.price;
+      orderItems.push(itemToOrder.name);
+    }
+    const res = await transaction.table('sales_order').insert({
+      items: orderItems.join(),
+      total: orderTotal,
+    });
+    // const lastInsertId = res[0].insertId;
+    debug.log('result', res);
+    await debug.pause('pause', {
+      items: orderItems.join(),
+      total: orderTotal,
+    });
+    console.log('Order created');
+    await transaction.execute(
+      'UPDATE product SET quantity=quantity - 1 WHERE sku IN (?, ?)',
+      items
+    );
+    console.log(`Deducted quantities by 1 for ${items.join()}`);
+    await transaction.commit();
+    const lastInsertId = await transaction.lastInsertId('order_id');
+    debug.log(`order created with id ${lastInsertId}`);
+    return `order created with id ${lastInsertId}`;
+  } catch (err) {
+    console.error(`Error occurred while creating order: ${err.message}`, err);
+    transaction.rollback();
+    console.info('Rollback successful');
+    debug.log('error creating order');
+    return 'error creating order';
+  }
+}
 
+main();

package/src/builder.js

@@ -3,10 +3,21 @@
 const Query = require('./query');
 const is = require('@axiosleo/cli-tool/src/helper/is');
 
+/**
+ * @param {array} arr 
+ * @param {string} res 
+ */
+const emit = (arr, res) => {
+  if (res) {
+    arr.push(res);
+  }
+};
+
 class Builder {
   constructor(options) {
     let sql = '';
     this.values = [];
+    let tmp = [];
     switch (options.operator) {
       case 'find': {
         options.pageLimit = 1;
@@ -14,51 +25,59 @@ class Builder {
       }
       // eslint-disable-next-line no-fallthrough
       case 'select': {
-        sql = `SELECT ${options.attrs ? options.attrs.map((a) => this._buildFieldKey(a)).join(',') : '*'} FROM ${this._buildTables(options.tables)}`;
-        sql += this._buildJoins(options.joins);
-        sql += this._buildContidion(options.conditions);
-        sql += options.orders.length > 0 ? this._buildOrders(options.orders) : '';
-        sql += this._buldPagenation(options.pageLimit, options.pageOffset);
-        if (options.groupField.length) {
-          sql += ` GROUP BY ${options.groupField.map(f => this._buildFieldKey(f)).join(',')}`;
-          sql += this._buildHaving(options.having);
-        } else if (options.having && options.having.length) {
+        emit(tmp, `SELECT ${options.attrs ? options.attrs.map((a) => this._buildFieldKey(a)).join(',') : '*'} FROM ${this._buildTables(options.tables)}`);
+        emit(tmp, this._buildJoins(options.joins));
+        emit(tmp, this._buildContidion(options.conditions));
+        emit(tmp, this._buildOrders(options.orders));
+        emit(tmp, this._buldPagenation(options.pageLimit, options.pageOffset));
+        if (options.having && options.having.length && !options.groupField.length) {
           throw new Error('having is not allowed without "GROUP BY"');
         }
+        emit(tmp, this._buildGroupField(options.groupField));
+        emit(tmp, this._buildHaving(options.having));
+        sql = tmp.join(' ');
+        if (options.suffix) {
+          sql += ' ' + options.suffix;
+        }
         break;
       }
       case 'insert': {
         const fields = this._buildValues(options.data);
-        sql = `INSERT INTO ${this._buildTables(options.tables)}(${fields.map((f) => this._buildFieldKey(f))}) VALUES (${fields.map(() => '?').join(',')})`;
+        emit(tmp, `INSERT INTO ${this._buildTables(options.tables)}(${fields.map((f) => `\`${f}\``).join(',')})`);
+        emit(tmp, `VALUES (${fields.map((f) => '?').join(',')})`);
+        sql = tmp.join(' ');
         break;
       }
       case 'update': {
         const fields = this._buildValues(options.data);
-        sql = `UPDATE ${this._buildTables(options.tables)} SET ${fields.map(f => `${this._buildFieldKey(f)} = ?`).join(',')}`;
+        emit(tmp, `UPDATE ${this._buildTables(options.tables)}`);
+        emit(tmp, `SET ${fields.map((f) => `\`${f}\` = ?`).join(',')}`);
         if (!options.conditions.length) {
           throw new Error('At least one condition is required for update operation');
         }
-        sql += this._buildContidion(options.conditions);
+        emit(tmp, this._buildContidion(options.conditions));
+        sql = tmp.join(' ');
         break;
       }
       case 'delete': {
-        sql = `DELETE FROM ${this._buildTables(options.tables)}`;
+        emit(tmp, `DELETE FROM ${this._buildTables(options.tables)}`);
         if (!options.conditions.length) {
           throw new Error('At least one where condition is required for delete operation');
         }
-        sql += this._buildContidion(options.conditions);
+        emit(tmp, this._buildContidion(options.conditions));
+        sql = tmp.join(' ');
         break;
       }
       case 'count': {
-        sql = `SELECT COUNT(*) AS count FROM ${this._buildTables(options.tables)}`;
-        sql += this._buildJoins(options.joins);
-        sql += this._buildContidion(options.conditions);
-        if (options.groupField.length) {
-          sql += ` GROUP BY ${options.groupField.map(f => this._buildFieldKey(f)).join(',')}`;
-          sql += this._buildHaving(options.having);
-        } else if (options.having && options.having.length) {
+        emit(tmp, `SELECT COUNT(*) AS count FROM ${this._buildTables(options.tables)}`);
+        emit(tmp, this._buildJoins(options.joins));
+        emit(tmp, this._buildContidion(options.conditions));
+        if (options.having && options.having.length && !options.groupField.length) {
           throw new Error('having is not allowed without "GROUP BY"');
         }
+        emit(tmp, this._buildGroupField(options.groupField));
+        emit(tmp, this._buildHaving(options.having));
+        sql = tmp.join(' ');
         break;
       }
       default:
@@ -68,16 +87,31 @@ class Builder {
     this.sql = sql;
   }
 
+  _buildGroupField(groupFields = []) {
+    if (!groupFields || !groupFields.length) {
+      return '';
+    }
+    return `GROUP BY ${groupFields.map(f => this._buildFieldKey(f)).join(',')}`;
+  }
+
   _buildHaving(having) {
-    if (!having.length) {
+    if (!having || !having.length) {
       return '';
     }
-    return this._buildContidion(having, ' HAVING ');
+    return this._buildContidion(having, 'HAVING ');
   }
 
   _buildJoins(joins = []) {
     return joins.map((j) => {
       let { table, alias, self_column, foreign_column, join_type } = j;
+      if (table instanceof Query) {
+        if (!alias) {
+          throw new Error('Alias is required for subquery');
+        }
+        const builder = new Builder(table.options);
+        this.values = this.values.concat(builder.values);
+        table = `(${builder.sql})`;
+      }
       if (alias) {
         table = `\`${table}\` AS \`${alias}\``;
       } else {
@@ -86,13 +120,13 @@ class Builder {
       let sql = '';
       switch (join_type) {
         case 'left':
-          sql = ' LEFT JOIN ';
+          sql = 'LEFT JOIN ';
           break;
         case 'right':
-          sql = ' RIGHT JOIN ';
+          sql = 'RIGHT JOIN ';
           break;
         default:
-          sql = ' INNER JOIN ';
+          sql = 'INNER JOIN ';
           break;
       }
       sql += `${table} ON ${this._buildFieldWithTableName(self_column)} = ${this._buildFieldWithTableName(foreign_column)}`;
@@ -101,14 +135,17 @@ class Builder {
   }
 
   _buildOrders(orders = []) {
-    const sql = ' ORDER BY ' + orders.map((o) => {
+    if (!orders || !orders.length) {
+      return '';
+    }
+    const sql = 'ORDER BY ' + orders.map((o) => {
       return `${this._buildFieldKey(o.sortField)} ${o.sortOrder}`;
     }).join(',');
     return sql;
   }
 
   _buildTables(tables) {
-    if (!tables.length) {
+    if (!tables || !tables.length) {
       throw new Error('At least one table is required');
     }
     return tables.map((t) => {
@@ -156,10 +193,10 @@ class Builder {
   }
 
   _buildContidion(conditions, prefix) {
-    if (!conditions.length) {
+    if (!conditions || !conditions.length) {
       return '';
     }
-    let sql = typeof prefix === 'undefined' ? ' WHERE ' : prefix;
+    let sql = typeof prefix === 'undefined' ? 'WHERE ' : prefix;
     if (conditions.length) {
       sql += `${conditions.map((c) => {
         if (c.key === null && c.value === null) {

package/src/client.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const mysql = require('mysql2');
+const mysqlPromise = require('mysql2/promise');
 const { validate } = require('./utils');
 
 const clients = {};
@@ -28,6 +29,51 @@ const createClient = (options, name = null) => {
   return clients[key];
 };
 
+/**
+ * @param {mysql.ConnectionOptions} options 
+ * @param {string|null} name 
+ * @returns {mysqlPromise.Connection}
+ */
+const createPromiseClient = async (options, name = null) => {
+  validate(options, {
+    host: 'required|string',
+    user: 'required|string',
+    password: 'required|string',
+    port: 'required|integer',
+    database: 'required|string',
+  });
+  const key = name ? name :
+    `${options.host}:${options.port}:${options.user}:${options.password}:${options.database}`;
+  if (clients[key]) {
+    return clients[key];
+  }
+  clients[key] = await mysqlPromise.createConnection(options);
+  return clients[key];
+};
+
+/**
+ * create pool
+ * @param {mysql.PoolOptions} options
+ * @returns {mysql.Pool}
+ */
+const createPool = (options, name = null) => {
+  validate(options, {
+    host: 'required|string',
+    user: 'required|string',
+    password: 'required|string',
+    port: 'required|integer',
+    database: 'required|string',
+  });
+  const key = name ? name :
+    `${options.host}:${options.port}:${options.user}:${options.password}:${options.database}`;
+  if (clients[key]) {
+    return clients[key];
+  }
+  const pool = mysql.createPool(options);
+  clients[key] = pool;
+  return pool;
+};
+
 /**
  * get client
  * @param {*} name 
@@ -45,5 +91,7 @@ const getClient = (name) => {
 
 module.exports = {
   getClient,
-  createClient
+  createPool,
+  createClient,
+  createPromiseClient
 };

package/src/hook.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const EventEmitter = require('events');
+
+const events = {}; // event tree
+const hook = new EventEmitter();
+
+const pushEvent = ({ label, table, opt, callback }) => {
+  label = label || '*';
+  if (!events[label]) {
+    events[label] = {};
+  }
+  table = table || '*';
+  if (!events[label][table]) {
+    events[label][table] = {};
+  }
+  opt = opt || '*';
+  if (!events[label][table][opt]) {
+    events[label][table][opt] = 0;
+  }
+  events[label][table][opt]++;
+  hook.on(`${label}::${table}::${opt}`, callback);
+  return { label, table, opt, callback };
+};
+
+const eventRecur = (curr, trace, step, paths, args) => {
+  if (step === trace.length) {
+    hook.emit(paths.join('::'), ...args);
+    return;
+  }
+  const t = trace[step];
+  if (curr['*']) {
+    paths[step] = '*';
+    eventRecur(curr[t], trace, step + 1, paths, args);
+  }
+  if (curr[t]) {
+    paths[step] = t;
+    eventRecur(curr[t], trace, step + 1, paths, args);
+  }
+  return;
+};
+
+const handleEvent = (label, table, opt, ...args) => {
+  let curr = events;
+  let step = 0;
+  let trace = [label, table, opt];
+  eventRecur(curr, trace, step, [], args);
+};
+
+class Hook {
+  static pre(callback, { table, opt }) {
+    return pushEvent({
+      label: 'pre', table, opt, callback
+    });
+  }
+
+  static post(callback, { table, opt }) {
+    return pushEvent({
+      label: 'post', table, opt, callback
+    });
+  }
+}
+
+module.exports = {
+  Hook,
+  handleEvent
+};

package/src/operator.js

@@ -2,16 +2,23 @@
 
 const { Builder } = require('./builder');
 const Query = require('./query');
+const { handleEvent } = require('./hook');
 
-const query = async (conn, options) => {
+const query = async (conn, options, transaction) => {
   return new Promise((resolve, reject) => {
-    conn.query(options, (err, result) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(result);
-      }
-    });
+    if (transaction) {
+      conn.execute(options)
+        .then((res) => resolve(res))
+        .catch((err) => reject(err));
+    } else {
+      conn.query(options, (err, result) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(result);
+        }
+      });
+    }
   });
 };
 
@@ -38,18 +45,30 @@ class QueryOperator extends Query {
     const options = {
       sql, values
     };
-    switch (this.options.operator) {
-      case 'find': {
-        const res = await query(this.conn, options);
-        return res[0];
-      }
-      case 'count': {
-        const [res] = await query(this.conn, options);
-        return res.count;
+    const from = this.options.tables.map(t => t.tableName).join(',');
+    handleEvent('pre', from, this.options.operator, this.options);
+    let res;
+    try {
+      switch (this.options.operator) {
+        case 'find': {
+          const tmp = await query(this.conn, options, this.options.transaction);
+          res = tmp[0];
+          break;
+        }
+        case 'count': {
+          const [tmp] = await query(this.conn, options, this.options.transaction);
+          res = tmp.count;
+          break;
+        }
+        default:
+          res = await query(this.conn, options, this.options.transaction);
       }
-      default:
-        return query(this.conn, options);
+      handleEvent('post', from, this.options.operator, this.options, res);
+    } catch (err) {
+      handleEvent('post', from, this.options.operator, this.options, err);
+      throw err;
     }
+    return res;
   }
 
   async select() {
@@ -83,9 +102,9 @@ class QueryOperator extends Query {
     return await this.exec();
   }
 
-  async delete(id) {
+  async delete(id, index_field_name = 'id') {
     if (id) {
-      this.where('id', id);
+      this.where(index_field_name, id);
     }
     this.options.operator = 'delete';
     return await this.exec();

package/src/query.js

@@ -10,7 +10,9 @@ class Query {
       data: null,
       groupField: [],
       having: [],
-      joins: []
+      joins: [],
+      suffix: null,
+      transaction: false
     };
   }
 
@@ -119,6 +121,7 @@ class Query {
       let lastOpt = this.options.having[this.options.having.length - 1].opt.toUpperCase();
       if (lastOpt !== 'AND' && lastOpt !== 'OR') {
         this.options.having.push({ key: null, opt: 'AND', value: null });
+        return this;
       }
     }
     this.options.having.push({ key, opt, value });

package/src/transaction.js

@@ -0,0 +1,111 @@
+'use strict';
+
+// eslint-disable-next-line no-unused-vars
+const mysql = require('mysql2/promise');
+const { QueryOperator } = require('./operator');
+
+const levels = {
+  RU: 'READ UNCOMMITTED',
+  RC: 'READ COMMITTED',
+  RR: 'REPEATABLE READ',
+  S: 'SERIALIZABLE'
+};
+
+class TransactionOperator extends QueryOperator {
+  /**
+   * @param {*} conn 
+   */
+  constructor(conn) {
+    super(conn);
+    this.options.transaction = true;
+  }
+
+  /**
+   * @example LOCK IN SHARE MODE
+   * @example FOR UPDATE
+   */
+  append(suffix) {
+    this.options.suffix = suffix || null;
+    return this;
+  }
+}
+
+class TransactionHandler {
+  /**
+   * @param {mysql.Connection} conn 
+   * @param {mysql.ConnectionOptions} options
+   */
+  constructor(conn, options = {}) {
+    this.isbegin = false;
+    this.conn = conn;
+    this.level = options.level || 'SERIALIZABLE';
+    if (levels[this.level]) {
+      this.level = levels[this.level];
+    }
+    if (!Object.values(levels).includes(this.level)) {
+      throw new Error('Invalid transaction level: ' + this.level);
+    }
+  }
+
+  async query(options) {
+    return new Promise((resolve, reject) => {
+      this.conn.query(options, (err, result) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(result);
+        }
+      });
+    });
+  }
+
+  async execute(sql, values = []) {
+    return this.conn.execute(sql, values);
+  }
+
+  async lastInsertId(alias = 'insert_id') {
+    let sql = `SELECT LAST_INSERT_ID() as ${alias}`;
+    const [row] = await this.execute(sql);
+    return row && row[0] ? row[0][alias] : 0;
+  }
+
+  async begin() {
+    this.isbegin = true;
+    await this.execute(`SET TRANSACTION ISOLATION LEVEL ${this.level}`);
+    await this.conn.beginTransaction();
+  }
+
+  table(table, alias = null) {
+    if (!this.isbegin) {
+      throw new Error('Transaction is not begin');
+    }
+    return (new TransactionOperator(this.conn)).table(table, alias);
+  }
+
+  async upsert(tableName, data, condition = {}) {
+    const count = await this.table(tableName).whereObject(condition).count();
+    if (count) {
+      return await this.table(tableName).whereObject(condition).update(data);
+    }
+    return await this.table(tableName).insert(data);
+  }
+
+  async commit() {
+    if (!this.isbegin) {
+      throw new Error('Transaction is not begin');
+    }
+    await this.conn.commit();
+  }
+
+  async rollback() {
+    if (!this.isbegin) {
+      throw new Error('Transaction is not begin');
+    }
+    await this.conn.rollback();
+  }
+}
+
+module.exports = {
+  TransactionOperator,
+  TransactionHandler
+};