@axiosleo/orm-mysql 0.5.5 → 0.6.0

package/README.md

@@ -126,7 +126,7 @@ async function deleteExample() {
 }
 
 async function subqueryExample() {
-  const query = hanlder.table("users", "u");
+  const query = handler.table("users", "u");
   const subQuery = new Query("select");
   subQuery.table("users").having("COUNT(*)", ">", 1);
 

package/index.d.ts

@@ -48,7 +48,7 @@ export interface TableOption {
   alias: string | null;
 }
 
-export interface QueryOperatorOptions {
+export type QueryOperatorOptions = {
   conditions: WhereOptions[];
   attrs?: string[] | null;
   orders: OrderByOptions[];
@@ -133,14 +133,33 @@ export declare class QueryHandler {
 
   constructor(conn: Connection);
 
+  /**
+   * select table
+   * @param table 
+   * @param alias 
+   */
   table(table: string, alias?: string | null): QueryOperator;
 
+  /**
+   * execute sql
+   * @param options 
+   */
   query(options: QueryOptions): Promise<any>;
 
+  /**
+   * insert or update
+   * @param tableName 
+   * @param data 
+   * @param condition 
+   */
   upsert(tableName: string, data: any, condition: Record<string, ConditionValueType>): Promise<OkPacket>;
 }
 
 export declare class TransactionOperator extends QueryOperator {
+  /**
+   * @example LOCK IN SHARE MODE
+   * @example FOR UPDATE
+   */
   append(suffix: string): this;
 }
 
@@ -180,13 +199,44 @@ export function createPool(options: PoolOptions, name?: string | null | undefine
 export function createPromiseClient(options: ConnectionOptions, name?: string | null | undefined): PromiseConnection;
 
 export declare class Hook {
+  /**
+   * pre hook for query operator
+   */
   static pre: (
     callback: (options: QueryOperatorOptions) => void,
     option: { table?: string, opt?: OperatorType }
   ) => string;
 
+  /**
+   * post hook for query operator
+   */
   static post: (
     callback: (options: QueryOperatorOptions, result: QueryResult | Error) => void,
     option: { table?: string, opt?: OperatorType }
   ) => string;
+
+  /**
+   * register hook
+   */
+  static register: (
+    callback: (options: QueryOperatorOptions) => void,
+    ...paths: string[]
+  ) => void;
+
+  /**
+   * listen event
+   */
+  static listen: (
+    options?: QueryOperatorOptions & { label?: string },
+    ...args: any[]
+  ) => void;
+
+  /**
+   * trigger event
+   */
+  static trigger: (
+    label: string,
+    options?: QueryOperatorOptions,
+    ...args: any[]
+  ) => void
 }

package/index.js

@@ -18,7 +18,7 @@ const {
   createPromiseClient
 } = require('./src/client');
 
-const { Hook } = require('./src/hook');
+const Hook = require('./src/hook');
 
 module.exports = {
   Hook,

package/package.json

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

package/src/hook.js

@@ -2,25 +2,35 @@
 
 const EventEmitter = require('events');
 
-const events = {}; // event tree
+const events = new Map(); // 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;
+const push = (callback, trace = []) => {
+  let step = 0;
+  let curr = events;
+  let event_name_items = [];
+  while (step < trace.length) {
+    let curr_key = trace[step] || '*';
+    if (curr_key === '__proto__' || curr_key === 'constructor' || curr_key === 'prototype') {
+      curr_key = '*';
+    }
+    event_name_items.push(curr_key);
+    if (!curr.has(curr_key)) {
+      curr.set(curr_key, new Map());
+    }
+    curr = curr.get(curr_key);
+    step++;
   }
-  events[label][table][opt]++;
-  hook.on(`${label}::${table}::${opt}`, callback);
-  return { label, table, opt, callback };
+  let event_name = event_name_items.join('::');
+  hook.on(event_name, callback);
+  return event_name;
+};
+
+const pushEvent = (options = {}) => {
+  const { label, table, opt, callback } = options;
+  const trace = [label, table, opt];
+  const event_name = push(callback, trace);
+  return { event_name, label, table, opt, callback };
 };
 
 const eventRecur = (curr, trace, step, paths, args) => {
@@ -40,28 +50,36 @@ const eventRecur = (curr, trace, step, 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 }) {
+  static pre(callback, options = {}) {
+    const { table, opt } = options;
     return pushEvent({
       label: 'pre', table, opt, callback
     });
   }
 
-  static post(callback, { table, opt }) {
+  static post(callback, options = {}) {
+    const { table, opt } = options;
     return pushEvent({
       label: 'post', table, opt, callback
     });
   }
+
+  static listen(options = {}, ...args) {
+    const { label, table, opt } = options;
+    Hook.trigger([label, table, opt], ...args);
+  }
+
+  static register(callback, ...paths) {
+    push(callback, paths);
+  }
+
+  static trigger(paths = [], ...args) {
+    let curr = events;
+    let step = 0;
+    let trace = paths;
+    eventRecur(curr, trace, step, [], args);
+  }
 }
 
-module.exports = {
-  Hook,
-  handleEvent
-};
+module.exports = Hook;

package/src/operator.js

@@ -2,7 +2,7 @@
 
 const { Builder } = require('./builder');
 const Query = require('./query');
-const { handleEvent } = require('./hook');
+const Hook = require('./hook');
 
 const query = async (conn, options, transaction) => {
   return new Promise((resolve, reject) => {
@@ -26,7 +26,7 @@ class QueryOperator extends Query {
   /**
    * @param {*} conn 
    */
-  constructor(conn) {
+  constructor(conn = null) {
     super(null);
     this.conn = conn;
   }
@@ -40,13 +40,16 @@ class QueryOperator extends Query {
     if (!this.options.operator) {
       throw new Error('Invalid operator: ' + this.options.operator);
     }
+    if (this.conn === null) {
+      throw new Error('Connection is null');
+    }
     const builder = this.buildSql(this.options.operator);
     const { sql, values } = builder;
     const options = {
       sql, values
     };
     const from = this.options.tables.map(t => t.tableName).join(',');
-    handleEvent('pre', from, this.options.operator, this.options);
+    Hook.listen({ label: 'pre', table: from, opt: this.options.operator }, this.options);
     let res;
     try {
       switch (this.options.operator) {
@@ -63,9 +66,9 @@ class QueryOperator extends Query {
         default:
           res = await query(this.conn, options, this.options.transaction);
       }
-      handleEvent('post', from, this.options.operator, this.options, res);
+      Hook.listen({ label: 'post', table: from, opt: this.options.operator }, this.options, res);
     } catch (err) {
-      handleEvent('post', from, this.options.operator, this.options, err);
+      Hook.listen({ label: 'post', table: from, opt: this.options.operator }, this.options, err);
       throw err;
     }
     return res;