@axiosleo/orm-mysql 0.4.0 → 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,9 +1,10 @@
 # @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/refs/branch/master)
+[![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
 
@@ -150,6 +151,43 @@ Hook.post(async (options, result) => {
 }, { 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
 }
@@ -54,6 +60,8 @@ export interface QueryOperatorOptions {
   groupField: string[];
   joins: JoinOption[];
   having: WhereOptions[];
+  suffix?: string | null;
+  transaction: boolean;
 }
 
 export declare class Query {
@@ -112,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 {
@@ -127,10 +140,43 @@ 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,
@@ -141,4 +187,4 @@ export declare class Hook {
     callback: (options: QueryOperatorOptions, result: QueryResult | Error) => void,
     option: { table?: string, opt?: OperatorType }
   ) => string;
-}
+}

package/index.js

@@ -6,7 +6,17 @@ 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');
 
@@ -17,6 +27,11 @@ module.exports = {
   QueryHandler,
   QueryOperator,
 
+  TransactionOperator,
+  TransactionHandler,
+
   getClient,
-  createClient
+  createPool,
+  createClient,
+  createPromiseClient
 };

package/package.json

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

package/runtimes/test.js

@@ -1,49 +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 { Hook } = require('../index');
-
-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');
 
-Hook.pre(async (options) => {
-  debug.log('options', options);
-}, {
-  table: 'test',
-  opt: 'insert'
-});
-Hook.postInsert(async (options, result) => {
-  throw new Error('some error');
-}, { table: 'test', opt: 'insert' });
+const { TransactionHandler } = require('../src/transaction');
 
-const test = async () => {
-  console.time('query');
-  const query = hanlder.table('test');
-  const result = await query.insert({
-    name: 'test',
-    item_code: '178eb48aa207a59ef8e3cb6944b5ed35'
-  });
-  await hanlder.table('test')
-    .where('name', 'test')
-    .where('item_code', '178eb48aa207a59ef8e3cb6944b5ed35')
-    .delete();
-  console.timeEnd('query');
-  debug.halt(result);
-};
+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';
+  }
+}
 
-test();
+main();

package/src/builder.js

@@ -36,6 +36,9 @@ class Builder {
         emit(tmp, this._buildGroupField(options.groupField));
         emit(tmp, this._buildHaving(options.having));
         sql = tmp.join(' ');
+        if (options.suffix) {
+          sql += ' ' + options.suffix;
+        }
         break;
       }
       case 'insert': {

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/operator.js

@@ -4,15 +4,21 @@ 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);
+        }
+      });
+    }
   });
 };
 
@@ -45,17 +51,17 @@ class QueryOperator extends Query {
     try {
       switch (this.options.operator) {
         case 'find': {
-          const tmp = await query(this.conn, options);
+          const tmp = await query(this.conn, options, this.options.transaction);
           res = tmp[0];
           break;
         }
         case 'count': {
-          const [tmp] = await query(this.conn, options);
+          const [tmp] = await query(this.conn, options, this.options.transaction);
           res = tmp.count;
           break;
         }
         default:
-          res = await query(this.conn, options);
+          res = await query(this.conn, options, this.options.transaction);
       }
       handleEvent('post', from, this.options.operator, this.options, res);
     } catch (err) {
@@ -96,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
     };
   }
 

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
+};