@axiosleo/orm-mysql 0.3.1 → 0.4.0

package/README.md

@@ -1,5 +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)
+
 ## Installation
 
 ```bash
@@ -46,7 +51,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 +134,22 @@ 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' });
+```
+
 ## License
 
 This project is open-sourced software licensed under the [MIT](LICENSE).

package/index.d.ts

@@ -30,7 +30,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;
@@ -90,6 +90,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 +100,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[]>;
 
@@ -128,3 +130,15 @@ export declare class QueryHandler {
 export function createClient(options: ConnectionOptions, name?: string | null | undefined): Connection;
 
 export function getClient(name: string): Connection;
+
+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

@@ -8,7 +8,11 @@ const {
 
 const { createClient, getClient } = require('./src/client');
 
+const { Hook } = require('./src/hook');
+
 module.exports = {
+  Hook,
+
   Query,
   QueryHandler,
   QueryOperator,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiosleo/orm-mysql",
-  "version": "0.3.1",
+  "version": "0.4.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,3 +1,4 @@
+/* eslint-disable no-console */
 'use strict';
 
 const dotenv = require('dotenv');
@@ -9,6 +10,7 @@ const {
   QueryHandler,
   // Query
 } = require('../src/operator');
+const { Hook } = require('../index');
 
 const conn = mysql.createConnection({
   host: process.env.MYSQL_HOST,
@@ -19,27 +21,29 @@ const conn = mysql.createConnection({
 });
 const hanlder = new QueryHandler(conn);
 
+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 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);
+  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);
 };
 
 test();
-

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,56 @@ 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(' ');
         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 +84,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 +117,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 +132,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 +190,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/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,6 +2,7 @@
 
 const { Builder } = require('./builder');
 const Query = require('./query');
+const { handleEvent } = require('./hook');
 
 const query = async (conn, options) => {
   return new Promise((resolve, reject) => {
@@ -38,18 +39,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);
+          res = tmp[0];
+          break;
+        }
+        case 'count': {
+          const [tmp] = await query(this.conn, options);
+          res = tmp.count;
+          break;
+        }
+        default:
+          res = await query(this.conn, options);
       }
-      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() {

package/src/query.js

@@ -119,6 +119,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 });