@axiosleo/orm-mysql 0.9.5 → 0.9.7

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

package/examples/migration/1706764048.init.js

@@ -69,10 +69,18 @@ function up(migration) {
     account_id: {
       type: 'int',
       allowNull: false,
+      references: {
+        table: 'account',
+        column: 'id'
+      }
     },
     org_id: {
       type: 'int',
       allowNull: false,
+      references: {
+        table: 'orgs',
+        column: 'id'
+      }
     },
     type: {
       type: 'varchar',
@@ -83,24 +91,6 @@ function up(migration) {
     }
   });
   migration.createColumn('created_at', 'TIMESTAMP', 'account_orgs');
-  migration.createForeignKey({
-    tableName: 'account_orgs',
-    columnName: 'account_id',
-    reference: {
-      tableName: 'account',
-      columnName: 'id',
-      onDelete: 'CASCADE'
-    }
-  });
-  migration.createForeignKey({
-    tableName: 'account_orgs',
-    columnName: 'org_id',
-    reference: {
-      tableName: 'orgs',
-      columnName: 'id',
-      onDelete: 'CASCADE'
-    }
-  });
 }
 
 /**

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,16 @@ 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 type JoinType = 'left' | 'right' | 'inner' | 'LEFT' | 'RIGHT' | 'INNER';
 
 export interface JoinOption {
   table: string | Query;
   table_alias?: string;
-  self_column: string;
-  foreign_column: string;
-  join_type?: 'left' | 'right' | 'inner';
+  self_column?: string;
+  foreign_column?: string;
+  join_type?: JoinType;
+  on?: string;
 }
 
 export interface TableOption {
@@ -54,7 +60,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[];
@@ -108,9 +114,15 @@ export declare class Query {
   set(data: any): this;
 
   join(opt: JoinOption): this;
+
+  leftJoin(table: string, on: string, options?: { alias?: string }): this;
+
+  rightJoin(table: string, on: string, options?: { alias?: string }): this;
+
+  innerJoin(table: string, on: string, options?: { alias?: string }): 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 +138,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 +149,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 +177,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 +223,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;
@@ -299,7 +311,13 @@ interface ColumnItem {
   comment?: string,
   autoIncrement?: boolean,
   primaryKey?: boolean,
-  uniqIndex?: boolean
+  uniqIndex?: boolean,
+  references?: {
+    table: string,
+    column: string,
+    onDelete?: CascadeType,
+    onUpdate?: CascadeType
+  }
 }
 
 interface CreateColumnOptions {
@@ -319,12 +337,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 +360,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 +382,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 +395,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.5",
+  "version": "0.9.7",
   "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,13 +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;
           }
@@ -71,6 +75,9 @@ 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(',')}`);
@@ -95,7 +102,7 @@ class Builder {
         emit(tmp, this._buildJoins(options.joins));
         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));
@@ -154,7 +161,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(' ');
   }
@@ -326,21 +337,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;
+      }
     }
   }
 
@@ -366,7 +380,7 @@ class ManageSQLBuilder extends Builder {
       engine: 'InnoDB',
       charset: 'utf8mb4'
     }, options, {
-      columns: this.createColumns(columns)
+      columns: this.createColumns(columns, options.name)
     });
     return _render('CREATE TABLE `${name}` ( ${columns} ) ENGINE=${engine} DEFAULT CHARSET=${charset}', options);
   }
@@ -468,9 +482,10 @@ class ManageSQLBuilder extends Builder {
     return _render('ALTER TABLE `${table}` DROP FOREIGN KEY `${name}`', options);
   }
 
-  createColumns(columns) {
+  createColumns(columns, table) {
     let primaryColumn = null;
     let indexColumns = [];
+    let referenceColumns = [];
     let strs = columns.map(column => {
       let str = this.renderSingleColumn(column);
       if (column.primaryKey === true) {
@@ -478,6 +493,28 @@ class ManageSQLBuilder extends Builder {
       } else if (column.uniqIndex === true) {
         indexColumns.push(column);
       }
+      if (column.reference) {
+        column.reference.onDelete = column.reference.onDelete ? column.reference.onDelete.toUpperCase() : 'NO ACTION';
+        column.reference.onUpdate = column.reference.onUpdate ? column.reference.onUpdate.toUpperCase() : 'NO ACTION';
+
+        _validate(column.reference, {
+          table: 'required|string',
+          column: 'required|string',
+          onDelete: [{ in: ['RESTRICT', 'CASCADE', 'SET NULL', 'NO ACTION'] }],
+          onUpdate: [{ in: ['RESTRICT', 'CASCADE', 'SET NULL', 'NO ACTION'] }]
+        });
+        referenceColumns.push({
+          name: 'fk_' + table + '_' + column.name,
+          table,
+          column: column.name,
+          reference: {
+            tableName: column.reference.table,
+            columnName: column.reference.column,
+            onDelete: column.reference.onDelete,
+            onUpdate: column.reference.onUpdate
+          }
+        });
+      }
       return str;
     });
     if (primaryColumn) {
@@ -489,6 +526,11 @@ class ManageSQLBuilder extends Builder {
         strs.push(`UNIQUE INDEX \`${i.name}\` (\`${i.name}\` ASC) VISIBLE`);
       });
     }
+    if (referenceColumns.length) {
+      referenceColumns.forEach((r) => {
+        strs.push(this.createForeignKey(r));
+      });
+    }
     return strs.join(', ');
   }
 

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/migration.js

@@ -114,16 +114,16 @@ async function _exec(context, queries) {
   try {
     const files = Object.keys(queries);
     await _foreach(files, async (file) => {
-      const hasMigarated = await transaction.table(context.task_key)
+      const hasMigrated = await transaction.table(context.task_key)
         .where('migration_key', context.task_key)
         .where('filename', file)
         .count();
-      if (context.action === 'up' && hasMigarated) {
-        if (hasMigarated) {
+      if (context.action === 'up' && hasMigrated) {
+        if (hasMigrated) {
           printer.yellow(`Migration file "${file}" has been migrated.`).println();
           return;
         }
-      } else if (context.action === 'down' && !hasMigarated) {
+      } else if (context.action === 'down' && !hasMigrated) {
         return;
       }
 

package/src/query.js

@@ -1,5 +1,21 @@
 'use strict';
 
+const { _assign } = require('@axiosleo/cli-tool/src/helper/obj');
+const { _validate } = require('./utils');
+const is = require('@axiosleo/cli-tool/src/helper/is');
+
+function joinOn(table, on, options = {}) {
+  let o = _assign({ alias: null, join_type: 'INNER', table, on }, options);
+  if (!table) {
+    throw new Error('table is required');
+  }
+  if (!on) {
+    throw new Error('on is required');
+  }
+  this.options.joins.push(o);
+  return this;
+}
+
 class Query {
   constructor(operator = 'select', alias = null) {
     this.options = {
@@ -109,6 +125,10 @@ class Query {
   }
 
   attr(...attr) {
+    if (attr.length === 1 && is.array(attr)) {
+      this.options.attrs = attr;
+      return this;
+    }
     if (!attr.length) {
       return this;
     }
@@ -164,22 +184,33 @@ class Query {
    * @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;
-    if (!table) {
-      throw new Error('table is required');
-    }
-    if (!self_column) {
-      throw new Error('self_column is required');
-    }
-    if (!foreign_column) {
-      throw new Error('foreign_column is required');
-    }
-    if (join_type && ['left', 'right', 'inner'].indexOf(join_type) === -1) {
-      throw new Error('Invalid join type : ' + join_type + '; only supported left, right, inner');
-    }
     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;