@axiosleo/orm-mysql 0.9.17 → 0.10.0-alpha

package/.vscode/extensions.json

@@ -8,7 +8,6 @@
     "eamodio.gitlens",
     "esbenp.prettier-vscode",
     "wayou.vscode-todo-highlight",
-    "vue.vscode-typescript-vue-plugin",
     "octref.vetur",
     "pflannery.vscode-versionlens"
   ]

package/bin/orm-mysql.js

@@ -9,7 +9,7 @@ const app = new App({
   name: 'MySQL ORM CLI',
   desc: 'migrate, model, seed, etc.',
   bin: 'orm-mysql',
-  version: '0.9.17',
+  version: '0.10.0-alpha',
   commands_dir: path.join(__dirname, '../commands'),
 });
 

package/index.d.ts

@@ -84,32 +84,65 @@ export type QueryOperatorOptions = QueryOperatorBaseOptions & {
   explain?: boolean;
 }
 
-export declare class Query {
-  options: QueryOperatorOptions;
+export declare class QueryCondition {
+  where(logicOpt: 'OR' | 'or' | 'AND' | 'and'): this;
 
-  constructor(operator?: OperatorType, alias?: string | null);
+  where(key: string, value: ConditionValueType | WhereOptions[]): this;
 
-  table(table: string, alias?: string | null): this;
+  where(key: string, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
 
-  tables(...tables: TableOption[]): this;
+  /**
+ * @deprecated will deprecated on v1.0+ version
+ */
+  where(key: string | null, value: ConditionValueType | WhereOptions[], opt?: OptType): this;
 
-  keys(...keys: string[]): this;
+  where(key: string, opt: OptType, value: ConditionValueType | WhereOptions[], isOr?: boolean): this;
 
-  limit(limit: number): this;
+  whereIn(key: string, value: string | string[] | number[] | Query): this;
 
-  offset(offset: number): this;
+  whereNotIn(key: string, value: string | string[] | number[] | Query): this;
 
-  where(key: string | null, value: ConditionValueType | WhereOptions[], opt?: OptType): this;
+  whereContain(key: string, value: string | number): this;
+
+  whereNotContain(key: string, value: string | number): this;
+
+  whereBetween(key: string, value: any[]): this;
+
+  whereNotBetween(key: string, value: any[]): this;
+
+  whereOverlaps(key: string, value: any[]): this;
+
+  whereNotOverlaps(key: string, value: any[]): this;
+
+  whereLike(key: string, value: string | string[]): this;
+
+  whereNotLike(key: string, value: string | string[]): this;
+
+  whereCondition(condition: QueryCondition): this;
 
   whereObject(obj: Record<string, ConditionValueType>): this;
+}
 
-  whereConditions(...condition: WhereItem[]): this;
+export type JoinOptions = {
+  alias?: string,
+  conditions: WhereItem[]
+};
 
-  groupWhere(...condition: WhereItem[]): this;
+export declare class Query extends QueryCondition {
 
-  orWhere(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
+  options: QueryOperatorOptions;
 
-  andWhere(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
+  constructor(operator?: OperatorType, alias?: string | null);
+
+  table(table: string, alias?: string | null): this;
+
+  tables(...tables: TableOption[]): this;
+
+  keys(...keys: string[]): this;
+
+  limit(limit: number): this;
+
+  offset(offset: number): this;
 
   attr(...attr: Attr[]): this;
 
@@ -125,11 +158,31 @@ export declare class Query {
 
   join(opt: JoinOption): this;
 
-  leftJoin(table: string, on: string, options?: { alias?: string }): this;
+  leftJoin(table: string | Query, on: string, options?: { alias?: string }): this;
+
+  rightJoin(table: string | Query, on: string, options?: { alias?: string }): this;
+
+  innerJoin(table: string | Query, on: string, options?: { alias?: string }): this;
+
+  /**
+   * @deprecated will deprecated on v1.0+ version
+   */
+  whereConditions(...condition: WhereItem[]): this;
 
-  rightJoin(table: string, on: string, options?: { alias?: string }): this;
+  /**
+   * @deprecated will deprecated on v1.0+ version
+   */
+  groupWhere(...condition: WhereItem[]): this;
 
-  innerJoin(table: string, on: string, options?: { alias?: string }): this;
+  /**
+   * @deprecated will deprecated on v1.0+ version
+   */
+  orWhere(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
+
+  /**
+   * @deprecated will deprecated on v1.0+ version
+   */
+  andWhere(key: string | null, opt: OptType, value: ConditionValueType | WhereOptions[]): this;
 }
 
 export type QueryResult = any | undefined | RowDataPacket[] | RowDataPacket | MySQLQueryResult;
@@ -183,7 +236,7 @@ export declare class QueryOperator extends Query {
 
   insertAll<T extends Object>(rows: T[]): Promise<MySQLQueryResult[]>;
 
-  upsertRow(row: any, ...conditions: WhereItem[]): Promise<MySQLQueryResult>;
+  upsertRow(row: any, condition: QueryCondition): Promise<MySQLQueryResult>;
 
   upsertRow<T extends Object>(row: T, ...conditions: WhereItem[]): Promise<MySQLQueryResult>;
 }

package/index.js

@@ -3,6 +3,7 @@
 const {
   QueryHandler,
   QueryOperator,
+  QueryCondition,
   Query
 } = require('./src/operator');
 
@@ -30,6 +31,7 @@ module.exports = {
   Query,
   QueryHandler,
   QueryOperator,
+  QueryCondition,
 
   TransactionOperator,
   TransactionHandler,

package/package.json

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

package/src/builder.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { debug } = require('@axiosleo/cli-tool');
-const Query = require('./query');
+const { Query } = require('./query');
 const is = require('@axiosleo/cli-tool/src/helper/is');
 const { _caml_case, _render } = require('@axiosleo/cli-tool/src/helper/str');
 const { _validate } = require('./utils');
@@ -144,7 +144,7 @@ class Builder {
   _buildJoins(joins = []) {
     return joins.map((j) => {
       let { table, alias, self_column, foreign_column, join_type } = j;
-      if (table instanceof Query) {
+      if (table instanceof Query || table.options) {
         if (!alias) {
           throw new Error('Alias is required for subQuery');
         }

package/src/client.js

@@ -5,7 +5,7 @@ const mysqlPromise = require('mysql2/promise');
 const { _validate } = require('./utils');
 const { _query } = require('./core');
 const { QueryHandler } = require('./operator');
-const Query = require('./query');
+const { Query } = require('./query');
 
 const clients = {};
 

package/src/operator.js

@@ -2,7 +2,7 @@
 
 const os = require('os');
 const { Builder } = require('./builder');
-const Query = require('./query');
+const { Query, QueryCondition } = require('./query');
 const Hook = require('./hook');
 const { _query } = require('./core');
 const { printer } = require('@axiosleo/cli-tool');
@@ -142,23 +142,22 @@ class QueryOperator extends Query {
     return await this.exec();
   }
 
-  async upsertRow(data, ...conditions) {
-    if (conditions.length === 0) {
-      throw new Error('conditions is required');
-    }
+  async upsertRow(data, condition) {
     if (!this.options.tables[0]) {
       throw new Error('table is required');
     }
     const query = new QueryOperator(this.conn, this.options);
     const table = this.options.tables[0].table;
     const alias = this.options.tables[0].alias;
-    const count = await query.table(table, alias)
-      .whereConditions(...conditions)
-      .count();
+    const q = query.table(table, alias);
+    if (condition instanceof QueryCondition) {
+      q.whereCondition(condition);
+    } else {
+      q.whereObject(condition);
+    }
+    const count = await q.count();
     if (count) {
-      return await query
-        .whereConditions(...conditions)
-        .update(data);
+      return await q.update(data);
     }
     return await query.insert(data);
   }
@@ -230,5 +229,6 @@ class QueryHandler {
 module.exports = {
   QueryOperator,
   QueryHandler,
+  QueryCondition,
   Query
 };

package/src/query.js

@@ -4,6 +4,11 @@ const { _assign } = require('@axiosleo/cli-tool/src/helper/obj');
 const { _validate } = require('./utils');
 const is = require('@axiosleo/cli-tool/src/helper/is');
 
+const optType = [
+  '=', '!=', '>', '<', '>=', '<=',
+  'LIKE', 'NOT LIKE', 'IN', 'NOT IN', 'BETWEEN', 'NOT BETWEEN', 'IS', 'IS NOT', 'REGEXP', 'NOT REGEXP', 'AND', 'OR', 'GROUP', 'CONTAIN', 'NOT CONTAIN', 'OVERLAPS', 'NOT OVERLAPS'
+];
+
 function joinOn(table, on, options = {}) {
   let o = _assign({ alias: null, join_type: 'INNER', table, on }, options);
   if (!table) {
@@ -16,8 +21,141 @@ function joinOn(table, on, options = {}) {
   return this;
 }
 
-class Query {
+class QueryCondition {
+  constructor() {
+    this.options = {
+      conditions: []
+    };
+  }
+
+  where(...args) {
+    if (this.options.conditions.length !== 0 && args.length > 1) {
+      const last = this.options.conditions[this.options.conditions.length - 1];
+      if (last.opt) {
+        const opt = last.opt.toUpperCase();
+        if (opt !== 'AND' && opt !== 'OR') {
+          this.options.conditions.push({ key: null, opt: args[3] === true ? 'OR' : 'AND', value: null });
+        }
+      }
+    }
+    switch (args.length) {
+      case 4:
+      case 3: {
+        const [key, opt, value] = args;
+        if (is.string(value) && optType.includes(value.toUpperCase()) >= -1) {
+          this.options.conditions.push({ key, opt: value, value: opt });
+          break;
+        }
+        this.options.conditions.push({ key, opt, value });
+        break;
+      }
+      case 2: {
+        const [key, value] = args;
+        this.options.conditions.push({ key, opt: '=', value });
+        break;
+      }
+      case 1: {
+        const [opt] = args;
+        this.options.conditions.push({ key: null, opt, value: null });
+        break;
+      }
+      default: {
+        throw new Error('Invalid arguments');
+      }
+    }
+    return this;
+  }
+
+  whereAnd() {
+    this.options.conditions.push({ key: null, opt: 'AND', value: null });
+    return this;
+  }
+
+  whereOr() {
+    this.options.conditions.push({ key: null, opt: 'OR', value: null });
+    return this;
+  }
+
+  whereIn(key, value) {
+    if (is.string(value)) {
+      value = value.split(',').map(v => v.trim());
+    }
+    this.options.conditions.push({ key, opt: 'IN', value });
+    return this;
+  }
+
+  whereNotIn(key, value) {
+    if (is.string(value)) {
+      value = value.split(',').map(v => v.trim());
+    }
+    this.options.conditions.push({ key, opt: 'NOT IN', value });
+    return this;
+  }
+
+  whereContain(key, value) {
+    this.options.conditions.push({ key, opt: 'CONTAIN', value });
+    return this;
+  }
+
+  whereNotContain(key, value) {
+    this.options.conditions.push({ key, opt: 'NOT CONTAIN', value });
+    return this;
+  }
+
+  whereBetween(key, value) {
+    this.options.conditions.push({ key, opt: 'BETWEEN', value });
+    return this;
+  }
+
+  whereNotBetween(key, value) {
+    this.options.conditions.push({ key, opt: 'NOT BETWEEN', value });
+    return this;
+  }
+
+  whereOverlaps(key, value) {
+    this.options.conditions.push({ key, opt: 'OVERLAPS', value });
+    return this;
+  }
+
+  whereNotOverlaps(key, value) {
+    this.options.conditions.push({ key, opt: 'NOT OVERLAPS', value });
+    return this;
+  }
+
+  whereLike(key, value) {
+    if (is.array(value)) {
+      value = value.join('');
+    }
+    this.options.conditions.push({ key, opt: 'LIKE', value });
+    return this;
+  }
+
+  whereNotLike(key, value) {
+    if (is.array(value)) {
+      value = value.join('');
+    }
+    this.options.conditions.push({ key, opt: 'NOT LIKE', value });
+    return this;
+  }
+
+  /**
+   * @param {QueryCondition} condition 
+   * @returns 
+   */
+  whereCondition(condition) {
+    this.options.conditions.push({ key: null, opt: 'GROUP', value: condition.options.conditions });
+    return this;
+  }
+
+  whereObject(object = {}) {
+    Object.keys(object).forEach((key) => this.where(key, object[key]));
+    return this;
+  }
+}
+
+class Query extends QueryCondition {
   constructor(operator = 'select', alias = null) {
+    super();
     this.options = {
       driver: 'mysql',
       queryHandler: null,
@@ -63,31 +201,93 @@ class Query {
     return this;
   }
 
+  attr(...attrs) {
+    if (!attrs.length) {
+      this.options.attrs = [];
+      return this;
+    }
+    this.options.attrs = attrs;
+    return this;
+  }
+
+  orderBy(sortField, sortOrder = 'asc') {
+    this.options.orders.push({ sortField, sortOrder });
+    return this;
+  }
+
+  groupBy(...groupField) {
+    this.options.groupField = groupField;
+    return this;
+  }
+
+  having(key, opt = '=', value = null) {
+    let optUpper = opt.toUpperCase();
+    if (optUpper === 'AND' || optUpper === 'OR') {
+      this.options.having.push({ key: null, opt: optUpper, value: null });
+      return this;
+    }
+    if (this.options.having.length) {
+      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 });
+      }
+    }
+    this.options.having.push({ key, opt, value });
+    return this;
+  }
+
+  page(limit, offset = 0) {
+    this.options.pageLimit = limit;
+    this.options.pageOffset = offset;
+    return this;
+  }
+
+  set(data) {
+    if (is.invalid(data)) {
+      throw new Error('data is required');
+    }
+    this.options.data = data;
+    return this;
+  }
+
   /**
-   * 
-   * @param {string} key 
-   * @param {any} value 
-   * @param {*} opt 
+   * @param {{table:string,table_alias?:string,self_column: string,foreign_column: string,join_type?: 'left' | 'right' | 'inner'}} opt 
    * @returns 
    */
-  where(key, value, opt = '=') {
-    if (!key) {
-      throw new Error('key is required');
-    }
-    if (this.options.conditions.length) {
-      this.options.conditions.push({ key: null, opt: 'AND', value: null });
+  join(opt = {}) {
+    let types = ['left', 'right', 'inner'];
+    opt.join_type = opt.join_type ? opt.join_type.toLowerCase() : 'inner';
+    if (types.indexOf(opt.join_type) === -1) {
+      throw new Error('Invalid join type : ' + opt.join_type + '; only supported ' + types.join(', '));
     }
-    this.options.conditions.push({
-      key, opt, value,
+    _validate(opt, {
+      table: 'required',
+      self_column: 'required',
+      foreign_column: 'required_if:on',
+      join_type: [{ in: types }]
     });
+    let { table, table_alias, self_column, foreign_column, join_type } = opt;
+    this.options.joins.push({ table, alias: table_alias, self_column, foreign_column, join_type });
     return this;
   }
 
-  whereObject(object = {}) {
-    Object.keys(object).forEach((key) => this.where(key, object[key]));
-    return this;
+  leftJoin(table, on, options = {}) {
+    return joinOn.call(this, table, on, { ...options, join_type: 'LEFT' });
+  }
+
+  rightJoin(table, on, options = {}) {
+    return joinOn.call(this, table, on, { ...options, join_type: 'RIGHT' });
   }
 
+  innerJoin(table, on, options = {}) {
+    return joinOn.call(this, table, on, { ...options, join_type: 'INNER' });
+  }
+
+  /**
+   * @deprecated
+   * @param  {...any} conditions 
+   * @returns 
+   */
   whereConditions(...conditions) {
     if (!conditions.length) {
       return this;
@@ -121,6 +321,11 @@ class Query {
     return this;
   }
 
+  /**
+   * @deprecated
+   * @param  {...any} conditions 
+   * @returns 
+   */
   groupWhere(...conditions) {
     if (!conditions.length) {
       return this;
@@ -153,6 +358,13 @@ class Query {
     return this;
   }
 
+  /**
+   * @deprecated
+   * @param {*} key 
+   * @param {*} opt 
+   * @param {*} value 
+   * @returns 
+   */
   orWhere(key, opt, value) {
     if (!this.options.conditions.length) {
       throw new Error('At least one where condition is required');
@@ -165,6 +377,13 @@ class Query {
     return this;
   }
 
+  /**
+   * @deprecated
+   * @param {*} key 
+   * @param {*} opt 
+   * @param {*} value 
+   * @returns 
+   */
   andWhere(key, opt, value) {
     if (!this.options.conditions.length) {
       throw new Error('At least one where condition is required');
@@ -176,88 +395,6 @@ class Query {
     }, { key, opt, value });
     return this;
   }
-
-  attr(...attrs) {
-    if (!attrs.length) {
-      this.options.attrs = [];
-      return this;
-    }
-    this.options.attrs = attrs;
-    return this;
-  }
-
-  orderBy(sortField, sortOrder = 'asc') {
-    this.options.orders.push({ sortField, sortOrder });
-    return this;
-  }
-
-  groupBy(...groupField) {
-    this.options.groupField = groupField;
-    return this;
-  }
-
-  having(key, opt = '=', value = null) {
-    let optUpper = opt.toUpperCase();
-    if (optUpper === 'AND' || optUpper === 'OR') {
-      this.options.having.push({ key: null, opt: optUpper, value: null });
-      return this;
-    }
-    if (this.options.having.length) {
-      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 });
-      }
-    }
-    this.options.having.push({ key, opt, value });
-    return this;
-  }
-
-  page(limit, offset = 0) {
-    this.options.pageLimit = limit;
-    this.options.pageOffset = offset;
-    return this;
-  }
-
-  set(data) {
-    if (is.invalid(data)) {
-      throw new Error('data is required');
-    }
-    this.options.data = data;
-    return this;
-  }
-
-  /**
-   * @param {{table:string,table_alias?:string,self_column: string,foreign_column: string,join_type?: 'left' | 'right' | 'inner'}} opt 
-   * @returns 
-   */
-  join(opt = {}) {
-    let types = ['left', 'right', 'inner'];
-    opt.join_type = opt.join_type ? opt.join_type.toLowerCase() : 'inner';
-    if (types.indexOf(opt.join_type) === -1) {
-      throw new Error('Invalid join type : ' + opt.join_type + '; only supported ' + types.join(', '));
-    }
-    _validate(opt, {
-      table: 'required',
-      self_column: 'required',
-      foreign_column: 'required_if:on',
-      join_type: [{ in: types }]
-    });
-    let { table, table_alias, self_column, foreign_column, join_type } = opt;
-    this.options.joins.push({ table, alias: table_alias, self_column, foreign_column, join_type });
-    return this;
-  }
-
-  leftJoin(table, on, options = {}) {
-    return joinOn.call(this, table, on, { ...options, join_type: 'LEFT' });
-  }
-
-  rightJoin(table, on, options = {}) {
-    return joinOn.call(this, table, on, { ...options, join_type: 'RIGHT' });
-  }
-
-  innerJoin(table, on, options = {}) {
-    return joinOn.call(this, table, on, { ...options, join_type: 'INNER' });
-  }
 }
 
-module.exports = Query;
+module.exports = { Query, QueryCondition };