@axiosleo/orm-mysql 0.9.4 → 0.9.6

package/.vscode/extensions.json

@@ -0,0 +1,15 @@
+{
+  "recommendations": [
+    "vscode-icons-team.vscode-icons",
+    "formulahendry.docker-extension-pack",
+    "mikestead.dotenv",
+    "dbaeumer.vscode-eslint",
+    "codezombiech.gitignore",
+    "eamodio.gitlens",
+    "esbenp.prettier-vscode",
+    "wayou.vscode-todo-highlight",
+    "vue.vscode-typescript-vue-plugin",
+    "octref.vetur",
+    "pflannery.vscode-versionlens"
+  ]
+}

package/README.md

@@ -3,6 +3,7 @@
 
 [![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)
+[![node version](https://img.shields.io/badge/node.js-%3E=_16.0-green.svg?style=flat-square)](http://nodejs.org/download/)
 [![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?ref=badge_shield)
 

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.4',
+  version: '0.9.6',
   commands_dir: path.join(__dirname, '../commands'),
 });
 

package/index.d.ts

@@ -5,6 +5,7 @@ import {
   PoolOptions,
   QueryOptions,
   RowDataPacket,
+  ResultSetHeader,
   ConnectionOptions
 } from 'mysql2';
 
@@ -12,6 +13,8 @@ import {
   Connection as PromiseConnection,
 } from 'mysql2/promise';
 
+type MySQLQueryResult = OkPacket | ResultSetHeader;
+
 export type Clients = {
   [key: string]: Connection | Pool
 }
@@ -34,13 +37,15 @@ export interface OrderByOptions {
 }
 
 export type OperatorType = 'select' | 'find' | 'insert' | 'update' | 'delete' | 'count';
+export type CascadeType = 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'NO ACTION' | 'restrict' | 'cascade' | 'set null' | 'no action';
 
 export interface JoinOption {
   table: string | Query;
   table_alias?: string;
-  self_column: string;
-  foreign_column: string;
+  self_column?: string;
+  foreign_column?: string;
   join_type?: 'left' | 'right' | 'inner';
+  on?: string;
 }
 
 export interface TableOption {
@@ -54,7 +59,7 @@ export type QueryOperatorBaseOptions = {
 };
 
 export type AttrSubQuery = () => Query;
-export type Attr = string | AttrSubQuery;
+export type Attr = string | AttrSubQuery | Query;
 
 export type QueryOperatorOptions = QueryOperatorBaseOptions & {
   conditions: WhereOptions[];
@@ -110,7 +115,7 @@ export declare class Query {
   join(opt: JoinOption): this;
 }
 
-export type QueryResult = any | undefined | RowDataPacket[] | RowDataPacket | OkPacket;
+export type QueryResult = any | undefined | RowDataPacket[] | RowDataPacket | MySQLQueryResult;
 
 export declare class QueryOperator extends Query {
   conn: Connection | Pool;
@@ -126,9 +131,9 @@ export declare class QueryOperator extends Query {
 
   find<T>(): Promise<T>;
 
-  update(data?: any): Promise<OkPacket>;
+  update(data?: any): Promise<MySQLQueryResult>;
 
-  insert(data?: any): Promise<OkPacket>;
+  insert(data?: any): Promise<MySQLQueryResult>;
 
   count(): Promise<number>;
 
@@ -137,7 +142,7 @@ export declare class QueryOperator extends Query {
    * @param id 
    * @param index_field_name default is 'id'
    */
-  delete(id?: number, index_field_name?: string): Promise<OkPacket>;
+  delete(id?: number, index_field_name?: string): Promise<MySQLQueryResult>;
 }
 
 export declare class QueryHandler {
@@ -165,7 +170,7 @@ export declare class QueryHandler {
    * @param data 
    * @param condition 
    */
-  upsert(tableName: string, data: any, condition: Record<string, ConditionValueType>): Promise<OkPacket>;
+  upsert(tableName: string, data: any, condition: Record<string, ConditionValueType>): Promise<MySQLQueryResult>;
 
   /**
  * @param database default is options.database
@@ -211,7 +216,7 @@ export declare class TransactionHandler {
 
   rollback(): Promise<void>;
 
-  upsert(tableName: string, data: any, condition: Record<string, ConditionValueType>): Promise<OkPacket>;
+  upsert(tableName: string, data: any, condition: Record<string, ConditionValueType>): Promise<MySQLQueryResult>;
 }
 
 export function createClient(options: ConnectionOptions, name?: string | null | undefined): Connection;
@@ -319,12 +324,6 @@ interface CreateIndexOptions {
   spatial?: boolean
 }
 
-export type ManageBuilderOptions = {
-  operator: 'create' | 'drop' | 'alter';
-  columns: Record<string, ColumnItem>;
-  target: 'table' | 'column' | 'index' | 'foreign_key';
-}
-
 export declare class MigrationInterface {
 
   /**
@@ -348,7 +347,7 @@ export declare class MigrationInterface {
     unsigned?: boolean,
     allowNull?: boolean,
     default?: string | number | boolean | null | 'timestamp',
-    onUpdate?: string,
+    onUpdate?: boolean,
     comment?: string,
     autoIncrement?: boolean,
     primaryKey?: boolean,
@@ -370,8 +369,8 @@ export declare class MigrationInterface {
     reference: {
       tableName: string,
       columnName: string,
-      onDelete?: 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'NO ACTION' | 'restrict' | 'cascade' | 'set null' | 'no action',
-      onUpdate?: 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'NO ACTION' | 'restrict' | 'cascade' | 'set null' | 'no action',
+      onDelete?: CascadeType,
+      onUpdate?: CascadeType,
     }
   }): void;
 
@@ -383,6 +382,3 @@ export declare class MigrationInterface {
 
   dropForeignKey(foreign_key: string, tableName: string): void;
 }
-
-export declare function up(migration: MigrationInterface): Promise<void>;
-export declare function down(migration: MigrationInterface): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiosleo/orm-mysql",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "MySQL ORM tool",
   "keywords": [
     "mysql",
@@ -19,12 +19,15 @@
     "test-cov": "nyc -r=lcov -r=html -r=text -r=json mocha -t 10000 -R spec tests/*.tests.js",
     "test-one": "mocha --reporter spec --timeout 3000 ",
     "ci": "npm run lint && npm run test-cov",
-    "clear": "rm -rf ./nyc_output ./coverage"
+    "clear": "rm -rf ./nyc_output ./coverage && rm -rf ./node_modules && npm cache clean --force"
   },
   "license": "MIT",
+  "engines": {
+    "node": ">=16.0.0"
+  },
   "dependencies": {
-    "@axiosleo/cli-tool": "^1.6.0",
-    "mysql2": "^2.3.3",
+    "@axiosleo/cli-tool": "^1.6.1",
+    "mysql2": "^3.9.1",
     "validatorjs": "^3.22.1"
   },
   "repository": {
@@ -32,19 +35,18 @@
     "url": "https://github.com/AxiosLeo/node-orm-mysql"
   },
   "devDependencies": {
-    "@types/node": "^20.8.3",
-    "chai": "^4.2.0",
-    "chai-as-promised": "^7.1.1",
-    "eslint": "^7.0",
+    "@types/node": "^20.11.16",
+    "chai": "^5.0.3",
+    "eslint": "^8.56.0",
     "expect.js": "^0.3.1",
-    "has-flag": "^4.0.0",
-    "mm": "^3.2.0",
-    "mocha": "^9.1.3",
+    "has-flag": "^5.0.1",
+    "mm": "^3.4.0",
+    "mocha": "^10.2.0",
     "mocha-sinon": "^2.1.2",
     "nyc": "^15.1.0",
     "pre-commit": "^1.2.2",
-    "sinon": "^9.0.2",
-    "typescript": "^4.3.2"
+    "sinon": "^17.0.1",
+    "typescript": "^5.3.3"
   },
   "pre-commit": {
     "silent": false,

package/src/builder.js

@@ -17,6 +17,8 @@ const emit = (arr, res) => {
   }
 };
 
+const operations = ['find', 'select', 'insert', 'update', 'delete', 'count', 'manage'];
+
 class Builder {
   /**
    * @param {import('../index').QueryOperatorOptions} options 
@@ -35,12 +37,15 @@ class Builder {
         options.attrs = options.attrs || [];
         const attrs = options.attrs.map((attr) => {
           if (attr instanceof Function) {
-            const query = attr();
-            const builder = new Builder(query.options);
+            attr = attr();
+          }
+          if (attr instanceof Query) {
+            const builder = new Builder(attr.options);
+            this.values = this.values.concat(builder.values);
             let s = `(${builder.sql})`;
-            if (query.alias) {
-              return query.alias.indexOf(' ') > -1 ? s + ' ' + this._buildFieldKey(query.alias)
-                : s + ' AS ' + this._buildFieldKey(query.alias);
+            if (attr.alias) {
+              return attr.alias.indexOf(' ') > -1 ? s + ' ' + this._buildFieldKey(attr.alias)
+                : s + ' AS ' + this._buildFieldKey(attr.alias);
             }
             return s;
           }
@@ -48,9 +53,9 @@ class Builder {
         });
         emit(tmp, `SELECT ${attrs.length ? 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._buildCondition(options.conditions));
         emit(tmp, this._buildOrders(options.orders));
-        emit(tmp, this._buldPagenation(options.pageLimit, options.pageOffset));
+        emit(tmp, this._buildPagination(options.pageLimit, options.pageOffset));
         if (options.having && options.having.length && !options.groupField.length) {
           throw new Error('having is not allowed without "GROUP BY"');
         }
@@ -70,13 +75,16 @@ class Builder {
         break;
       }
       case 'update': {
+        if (is.invalid(options.data)) {
+          throw new Error('Data is required for update operation');
+        }
         const fields = this._buildValues(options.data);
         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');
         }
-        emit(tmp, this._buildContidion(options.conditions));
+        emit(tmp, this._buildCondition(options.conditions));
         sql = tmp.join(' ');
         break;
       }
@@ -85,16 +93,20 @@ class Builder {
         if (!options.conditions.length) {
           throw new Error('At least one where condition is required for delete operation');
         }
-        emit(tmp, this._buildContidion(options.conditions));
+        emit(tmp, this._buildCondition(options.conditions));
         sql = tmp.join(' ');
         break;
       }
       case 'count': {
-        emit(tmp, `SELECT COUNT(*) AS count FROM ${this._buildTables(options.tables)}`);
+        let fieldName = 'count';
+        if (!is.empty(options.attrs)) {
+          fieldName = this._buildFieldKey(options.attrs[0]);
+        }
+        emit(tmp, `SELECT COUNT(*) AS ${fieldName} FROM ${this._buildTables(options.tables)}`);
         emit(tmp, this._buildJoins(options.joins));
-        emit(tmp, this._buildContidion(options.conditions));
+        emit(tmp, this._buildCondition(options.conditions));
         if (options.having && options.having.length && !options.groupField.length) {
-          throw new Error('having is not allowed without "GROUP BY"');
+          throw new Error('"HAVING" is not allowed without "GROUP BY"');
         }
         emit(tmp, this._buildGroupField(options.groupField));
         emit(tmp, this._buildHaving(options.having));
@@ -122,7 +134,7 @@ class Builder {
     if (!having || !having.length) {
       return '';
     }
-    return this._buildContidion(having, 'HAVING ');
+    return this._buildCondition(having, 'HAVING ');
   }
 
   _buildJoins(joins = []) {
@@ -130,7 +142,7 @@ class Builder {
       let { table, alias, self_column, foreign_column, join_type } = j;
       if (table instanceof Query) {
         if (!alias) {
-          throw new Error('Alias is required for subquery');
+          throw new Error('Alias is required for subQuery');
         }
         const builder = new Builder(table.options);
         this.values = this.values.concat(builder.values);
@@ -153,7 +165,11 @@ class Builder {
           sql = 'INNER JOIN ';
           break;
       }
-      sql += `${table} ON ${this._buildFieldWithTableName(self_column)} = ${this._buildFieldWithTableName(foreign_column)}`;
+      if (j.on) {
+        sql += `${table} ON ${j.on}`;
+      } else {
+        sql += `${table} ON ${this._buildFieldWithTableName(self_column)} = ${this._buildFieldWithTableName(foreign_column)}`;
+      }
       return sql;
     }).join(' ');
   }
@@ -186,7 +202,7 @@ class Builder {
     }).join(' , ');
   }
 
-  _buldPagenation(limit, offset) {
+  _buildPagination(limit, offset) {
     let sql = '';
     if (limit) {
       sql += ` LIMIT ${limit}`;
@@ -227,7 +243,7 @@ class Builder {
     return null;
   }
 
-  _buildContidionIn(condition, isNot = false) {
+  _buildConditionIn(condition, isNot = false) {
     if (Array.isArray(condition.value) && !condition.value.length) {
       throw new Error('Value must not be empty for "IN" condition');
     } else if (!Array.isArray(condition.value) && !(condition.value instanceof Query)) {
@@ -244,7 +260,7 @@ class Builder {
     return res ? `${this._buildFieldKey(condition.key)} ${opt} (${res})` : `${this._buildFieldKey(condition.key)} ${opt} (?)`;
   }
 
-  _buildContidion(conditions, prefix) {
+  _buildCondition(conditions, prefix) {
     if (!conditions || !conditions.length) {
       return '';
     }
@@ -265,7 +281,7 @@ class Builder {
         }
         if (c.key && c.key.indexOf('->') !== -1) {
           const keys = c.key.split('->');
-          return this._buildContidion([
+          return this._buildCondition([
             {
               key: `JSON_EXTRACT(${this._buildFieldKey(keys[0])}, '${keys[1]}')`,
               opt: c.opt,
@@ -275,11 +291,11 @@ class Builder {
         }
         const opt = c.opt.toLowerCase();
         if (opt === 'in') {
-          return this._buildContidionIn(c);
+          return this._buildConditionIn(c);
         } else if (opt === 'not in') {
-          return this._buildContidionIn(c, true);
+          return this._buildConditionIn(c, true);
         } else if (opt === 'group' && Array.isArray(c.value)) {
-          return `(${this._buildContidion(c.value, '')})`;
+          return `(${this._buildCondition(c.value, '')})`;
         }
         let res = this._buildConditionValues(c.value);
         if (!is.empty(res)) {
@@ -325,21 +341,24 @@ class Builder {
 
 class ManageSQLBuilder extends Builder {
   /**
-   * @param {import('../index').ManageBuilderOptions} options 
+   * @param {import('./migration').ManageBuilderOptions} options 
    */
   constructor(options) {
-    super({ operator: 'manage' });
-    // const emitter = new Emitter();
-    const action = `${options.operator}_${options.target}`;
-    const method = _caml_case(action, false);
-    if (!this[method]) {
-      throw new Error(`'${options.target}' Unsupported '${options.operator}' operation.`);
-    }
-    try {
-      this.sql = this[method].call(this, options);
-    } catch (err) {
-      debug.dump(`${options.operator} ${options.target} error: ${err.message}`);
-      throw err;
+    if (operations.indexOf(options.operator) > -1) {
+      super(options);
+    } else {
+      super({ operator: 'manage' });
+      const action = `${options.operator}_${options.target}`;
+      const method = _caml_case(action, false);
+      if (!this[method]) {
+        throw new Error(`'${options.target}' Unsupported '${options.operator}' operation.`);
+      }
+      try {
+        this.sql = this[method].call(this, options);
+      } catch (err) {
+        debug.dump(`${options.operator} ${options.target} error: ${err.message}`);
+        throw err;
+      }
     }
   }
 

package/src/migration.d.ts

@@ -1,8 +1,19 @@
+import { ColumnItem } from '../index';
+
 type QueryItem = {
   sql: string,
   values: any[],
 };
 
+export type ManageBuilderOptions = {
+  operator: 'create' | 'drop' | 'alter';
+  columns: Record<string, ColumnItem>;
+  target: 'table' | 'column' | 'index' | 'foreign_key';
+  name?: string;
+  engine?: 'InnoDB' | 'MyISAM' | 'MEMORY',
+  charset?: string
+}
+
 export type Context = {
   action: 'up' | 'down',
   connection: {

package/src/query.js

@@ -180,6 +180,29 @@ class Query {
     this.options.joins.push({ table, alias: table_alias, self_column, foreign_column, join_type });
     return this;
   }
+
+  joinOn(table, alias, on, type = 'LEFT') {
+    if (!table) {
+      throw new Error('table is required');
+    }
+    if (!on) {
+      throw new Error('on is required');
+    }
+    this.options.joins.push({ table, alias, on, join_type: type });
+    return this;
+  }
+
+  leftJoin(table, alias, on) {
+    return this.joinOn(table, alias, on, 'LEFT');
+  }
+
+  rightJoin(table, alias, on) {
+    return this.joinOn(table, alias, on, 'RIGHT');
+  }
+
+  innerJoin(table, alias, on) {
+    return this.joinOn(table, alias, on, 'INNER');
+  }
 }
 
 module.exports = Query;