@axiosleo/orm-mysql 0.6.3 → 0.8.0

package/README.md

@@ -195,6 +195,39 @@ try {
 }
 ```
 
+### Custom query driver
+
+```javascript
+const { 
+  createClient, 
+  QueryHandler, 
+  Query,
+  Builder 
+} = require("@axiosleo/orm-mysql");
+
+const conn = createClient({
+  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, {
+  driver: 'custom',
+  query_handler: (con, options) => {
+    const builder = new Builder(options);
+    return new Promise((resolve, reject) => {
+      if (options.operator === 'select') {
+        resolve([{ a: 1, b: 2 }]);
+      } else {
+        reject(new Error('some error'));
+      }
+    });
+  }
+});
+```
+
 ## License
 
 This project is open-sourced software licensed under the [MIT](LICENSE).

package/index.d.ts

@@ -48,7 +48,12 @@ export interface TableOption {
   alias: string | null;
 }
 
-export type QueryOperatorOptions = {
+export type QueryOperatorBaseOptions = {
+  driver?: string | 'mysql';
+  query_handler?: QueryHandler;
+};
+
+export type QueryOperatorOptions = QueryOperatorBaseOptions & {
   conditions: WhereOptions[];
   attrs?: string[] | null;
   orders: OrderByOptions[];
@@ -79,6 +84,8 @@ export declare class Query {
 
   whereConditions(...condition: WhereOptions[]): this;
 
+  groupWhere(...condition: WhereOptions[]): this;
+
   orWhere(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
 
   andWhere(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
@@ -104,7 +111,7 @@ export declare class QueryOperator extends Query {
   conn: Connection;
   options: QueryOperatorOptions
 
-  constructor(conn: Connection);
+  constructor(conn: Connection, opt?: QueryOperatorBaseOptions);
 
   buildSql(operator: OperatorType): { sql: string, values: any[] };
 
@@ -130,8 +137,9 @@ export declare class QueryOperator extends Query {
 
 export declare class QueryHandler {
   conn: Connection;
+  options: QueryOperatorBaseOptions;
 
-  constructor(conn: Connection);
+  constructor(conn: Connection, options?: QueryOperatorBaseOptions);
 
   /**
    * select table
@@ -239,3 +247,9 @@ export declare class Hook {
     ...args: any[]
   ) => void
 }
+
+export declare class Builder {
+  sql: string;
+  values: any[];
+  constructor(options: QueryOperatorOptions);
+}

package/index.js

@@ -19,9 +19,11 @@ const {
 } = require('./src/client');
 
 const Hook = require('./src/hook');
+const { Builder } = require('./src/builder');
 
 module.exports = {
   Hook,
+  Builder,
 
   Query,
   QueryHandler,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiosleo/orm-mysql",
-  "version": "0.6.3",
+  "version": "0.8.0",
   "description": "MySQL ORM tool",
   "keywords": [
     "mysql",
@@ -28,7 +28,7 @@
     "url": "https://github.com/AxiosLeo/node-orm-mysql"
   },
   "devDependencies": {
-    "@types/node": "^15.12.1",
+    "@types/node": "^20.8.3",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
     "eslint": "^7.0",

package/src/builder.js

@@ -216,6 +216,12 @@ class Builder {
     let sql = typeof prefix === 'undefined' ? 'WHERE ' : prefix;
     if (conditions.length) {
       sql += `${conditions.map((c) => {
+        if (typeof c.key === 'undefined') {
+          c.key = null;
+        }
+        if (typeof c.value === 'undefined') {
+          c.value = null;
+        }
         if (c.key === null && c.value === null) {
           return ` ${c.opt} `;
         }

package/src/operator.js

@@ -4,31 +4,59 @@ const { Builder } = require('./builder');
 const Query = require('./query');
 const Hook = require('./hook');
 
-const query = async (conn, options, transaction) => {
-  return new Promise((resolve, reject) => {
-    if (transaction) {
-      conn.execute(options)
-        .then((res) => resolve(res))
-        .catch((err) => reject(err));
-    } else {
-      conn.query(options, (err, result) => {
-        if (err) {
-          reject(err);
+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 {
-          resolve(result);
+          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;
+    }
+  }
 };
 
 class QueryOperator extends Query {
   /**
    * @param {*} conn 
    */
-  constructor(conn = null) {
+  constructor(conn = null, options = {}) {
     super(null);
     this.conn = conn;
+    this.options.driver = options.driver || 'mysql';
+    this.options.query_handler = options.query_handler || null;
+    if (this.options.driver !== 'mysql') {
+      if (!this.options.query_handler) {
+        throw new Error('query_handler is required');
+      }
+      if (!(this.options.query_handler instanceof Function)) {
+        throw new Error('query_handler must be a function');
+      }
+    }
   }
 
   buildSql(operator) {
@@ -43,28 +71,23 @@ class QueryOperator extends Query {
     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(',');
     Hook.listen({ label: 'pre', table: from, opt: this.options.operator }, this.options);
     let res;
     try {
       switch (this.options.operator) {
         case 'find': {
-          const tmp = await query(this.conn, options, this.options.transaction);
+          const tmp = await query(this.conn, this.options);
           res = tmp[0];
           break;
         }
         case 'count': {
-          const [tmp] = await query(this.conn, options, this.options.transaction);
+          const [tmp] = await query(this.conn, this.options);
           res = tmp.count;
           break;
         }
         default:
-          res = await query(this.conn, options, this.options.transaction);
+          res = await query(this.conn, this.options);
       }
       Hook.listen({ label: 'post', table: from, opt: this.options.operator }, this.options, res);
     } catch (err) {
@@ -115,24 +138,20 @@ class QueryOperator extends Query {
 }
 
 class QueryHandler {
-  constructor(conn) {
+  constructor(conn, options = {}) {
     this.conn = conn;
+    this.optinos = options;
   }
 
-  async query(options) {
-    return new Promise((resolve, reject) => {
-      this.conn.query(options, (err, result) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(result);
-        }
-      });
-    });
+  async query(opt) {
+    if (!opt) {
+      throw new Error('opt is required');
+    }
+    return await query(this.conn, this.options, opt);
   }
 
   table(table, alias = null) {
-    return (new QueryOperator(this.conn)).table(table, alias);
+    return (new QueryOperator(this.conn, this.optinos)).table(table, alias);
   }
 
   async upsert(tableName, data, condition = {}) {

package/src/query.js

@@ -3,6 +3,8 @@
 class Query {
   constructor(operator = 'select') {
     this.options = {
+      driver: 'mysql',
+      query_handler: null,
       conditions: [],
       orders: [],
       tables: [],
@@ -69,6 +71,18 @@ class Query {
     return this;
   }
 
+  groupWhere(...conditions) {
+    if (!conditions.length) {
+      return this;
+    }
+    const condition = { key: null, opt: 'group', value: [] };
+    conditions.forEach((c) => {
+      condition.value.push(c);
+    });
+    this.options.conditions.push(condition);
+    return this;
+  }
+
   orWhere(key, opt, value) {
     if (!this.options.conditions.length) {
       throw new Error('At least one where condition is required');
@@ -124,7 +138,6 @@ 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

@@ -15,9 +15,19 @@ class TransactionOperator extends QueryOperator {
   /**
    * @param {*} conn 
    */
-  constructor(conn) {
+  constructor(conn, options) {
     super(conn);
     this.options.transaction = true;
+    this.options.driver = options.driver || 'mysql';
+    this.options.query_handler = options.query_handler || null;
+    if (this.options.driver !== 'mysql') {
+      if (!this.options.query_handler) {
+        throw new Error('query_handler is required');
+      }
+      if (!(this.options.query_handler instanceof Function)) {
+        throw new Error('query_handler must be a function');
+      }
+    }
   }
 
   /**
@@ -42,6 +52,7 @@ class TransactionHandler {
     if (levels[this.level]) {
       this.level = levels[this.level];
     }
+    this.options = options;
     if (!Object.values(levels).includes(this.level)) {
       throw new Error('Invalid transaction level: ' + this.level);
     }
@@ -79,7 +90,7 @@ class TransactionHandler {
     if (!this.isbegin) {
       throw new Error('Transaction is not begin');
     }
-    return (new TransactionOperator(this.conn)).table(table, alias);
+    return (new TransactionOperator(this.conn, this.options)).table(table, alias);
   }
 
   async upsert(tableName, data, condition = {}) {