@axiosleo/orm-mysql 0.9.6 → 0.9.8

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.6',
+  version: '0.9.8',
   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

@@ -38,13 +38,14 @@ 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';
+  join_type?: JoinType;
   on?: string;
 }
 
@@ -113,6 +114,12 @@ 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 | MySQLQueryResult;
@@ -304,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 {
@@ -352,7 +365,7 @@ export declare class MigrationInterface {
     autoIncrement?: boolean,
     primaryKey?: boolean,
     uniqIndex?: boolean,
-    after?: string
+    after?: string,
   }): void;
 
   createIndex(tableName: string, columns: string[], options?: {

package/package.json

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

package/src/builder.js

@@ -98,11 +98,7 @@ class Builder {
         break;
       }
       case 'count': {
-        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, `SELECT COUNT(*) AS count FROM ${this._buildTables(options.tables)}`);
         emit(tmp, this._buildJoins(options.joins));
         emit(tmp, this._buildCondition(options.conditions));
         if (options.having && options.having.length && !options.groupField.length) {
@@ -154,6 +150,7 @@ class Builder {
         table = `\`${table}\``;
       }
       let sql = '';
+      join_type = join_type.toLowerCase();
       switch (join_type) {
         case 'left':
           sql = 'LEFT JOIN ';
@@ -384,26 +381,15 @@ 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);
   }
 
   createColumn(options) {
-    _validate(options, {
-      table: 'required|string',
-      name: 'required|string',
-      type: 'required|string',
-      length: 'integer',
-      unsigned: 'boolean',
-      allowNull: 'boolean',
-      default: 'string',
-      comment: 'string',
-      autoIncrement: 'boolean',
-      primaryKey: 'boolean',
-      uniqIndex: 'boolean',
-      after: 'string'
-    });
+    if (!options.table) {
+      throw new Error('Table name is required');
+    }
     return `ALTER TABLE \`${options.table}\` ADD COLUMN ` + this.renderSingleColumn(options);
   }
 
@@ -434,6 +420,8 @@ class ManageSQLBuilder extends Builder {
   }
 
   createForeignKey(options) {
+    options.reference.onDelete = options.reference.onDelete ? options.reference.onDelete.toUpperCase() : 'NO ACTION';
+    options.reference.onUpdate = options.reference.onUpdate ? options.reference.onUpdate.toUpperCase() : 'NO ACTION';
     _validate(options, {
       name: 'required|string',
       table: 'required|string',
@@ -486,9 +474,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) {
@@ -496,6 +485,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) {
@@ -507,6 +518,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.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,44 +184,32 @@ 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;
   }
 
-  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');
+  leftJoin(table, on, options = {}) {
+    return joinOn.call(this, table, on, { ...options, join_type: 'LEFT' });
   }
 
-  rightJoin(table, alias, on) {
-    return this.joinOn(table, alias, on, 'RIGHT');
+  rightJoin(table, on, options = {}) {
+    return joinOn.call(this, table, on, { ...options, join_type: 'RIGHT' });
   }
 
-  innerJoin(table, alias, on) {
-    return this.joinOn(table, alias, on, 'INNER');
+  innerJoin(table, on, options = {}) {
+    return joinOn.call(this, table, on, { ...options, join_type: 'INNER' });
   }
 }