@axiosleo/orm-mysql 0.13.2 → 0.14.1

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

package/index.d.ts

@@ -640,9 +640,20 @@ export declare class MigrationInterface {
   createForeignKey(table: string, options: {
     foreignKey?: string,
     columnName: string,
-    reference: {
-      tableName: string,
-      columnName: string,
+    references?: {
+      table: string,
+      column: string,
+      onDelete?: CascadeType,
+      onUpdate?: CascadeType,
+    },
+    /** @deprecated Use `references` instead */
+    reference?: {
+      table?: string,
+      column?: string,
+      /** @deprecated Use `table` instead */
+      tableName?: string,
+      /** @deprecated Use `column` instead */
+      columnName?: string,
       onDelete?: CascadeType,
       onUpdate?: CascadeType,
     }

package/package.json

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

package/src/builder.js

@@ -582,8 +582,17 @@ class ManageSQLBuilder extends Builder {
     });
   }
 
-  createForeignKey(options) {
+  createForeignKey(options, onCreateTable = false) {
+    if (options.reference && !options.references) {
+      options.references = options.reference;
+    }
     if (options.references) {
+      if (options.references.tableName && !options.references.table) {
+        options.references.table = options.references.tableName;
+      }
+      if (options.references.columnName && !options.references.column) {
+        options.references.column = options.references.columnName;
+      }
       options.references.onDelete = options.references.onDelete ? options.references.onDelete.toUpperCase() : 'NO ACTION';
       options.references.onUpdate = options.references.onUpdate ? options.references.onUpdate.toUpperCase() : 'NO ACTION';
     }
@@ -591,17 +600,27 @@ class ManageSQLBuilder extends Builder {
       name: 'required|string',
       table: 'required|string',
       column: 'required|string',
-      'references.tableName': 'required|string',
-      'references.columnName': 'required|string',
+      'references.table': 'required|string',
+      'references.column': 'required|string',
       'references.onUpdate': [{ in: ['RESTRICT', 'CASCADE', 'SET NULL', 'NO ACTION'] }],
       'references.onDelete': [{ in: ['RESTRICT', 'CASCADE', 'SET NULL', 'NO ACTION'] }]
     });
+    if (onCreateTable === true) {
+      return _render('CONSTRAINT `${name}` FOREIGN KEY (`${column_name}`) REFERENCES `${foreign_table}` (`${foreign_column}`) ON DELETE ${on_delete} ON UPDATE ${on_update}', {
+        name: options.name,
+        column_name: options.column,
+        foreign_table: options.references.table,
+        foreign_column: options.references.column,
+        on_delete: options.references.onDelete || 'NO ACTION',
+        on_update: options.references.onUpdate || 'NO ACTION',
+      });
+    }
     return _render('ALTER TABLE `${table_name}` ADD CONSTRAINT `${name}` FOREIGN KEY (`${column_name}`) REFERENCES `${foreign_table}` (`${foreign_column}`) ON DELETE ${on_delete} ON UPDATE ${on_update}', {
-      table_name: options.tableName,
+      table_name: options.table,
       name: options.name,
-      column_name: options.columnName,
-      foreign_table: options.references.tableName,
-      foreign_column: options.references.columnName,
+      column_name: options.column,
+      foreign_table: options.references.table,
+      foreign_column: options.references.column,
       on_delete: options.references.onDelete || 'NO ACTION',
       on_update: options.references.onUpdate || 'NO ACTION',
     });
@@ -663,6 +682,12 @@ class ManageSQLBuilder extends Builder {
         column.references = column.reference;
       }
       if (column.references) {
+        if (column.references.tableName && !column.references.table) {
+          column.references.table = column.references.tableName;
+        }
+        if (column.references.columnName && !column.references.column) {
+          column.references.column = column.references.columnName;
+        }
         column.references.onDelete = column.references.onDelete ? column.references.onDelete.toUpperCase() : 'NO ACTION';
         column.references.onUpdate = column.references.onUpdate ? column.references.onUpdate.toUpperCase() : 'NO ACTION';
 
@@ -677,8 +702,8 @@ class ManageSQLBuilder extends Builder {
           table,
           column: column.name,
           references: {
-            tableName: column.references.table,
-            columnName: column.references.column,
+            table: column.references.table,
+            column: column.references.column,
             onDelete: column.references.onDelete,
             onUpdate: column.references.onUpdate
           }
@@ -697,7 +722,7 @@ class ManageSQLBuilder extends Builder {
     }
     if (referenceColumns.length) {
       referenceColumns.forEach((r) => {
-        strs.push(this.createForeignKey(r));
+        strs.push(this.createForeignKey(r, true));
       });
     }
     return strs.join(', ');

package/src/migration.js

@@ -227,13 +227,22 @@ function _initMigration(file, queries = {}) {
 
   Object.defineProperty(migration, 'createForeignKey', {
     value: function (table, options = {}) {
+      const refs = options.references || options.reference;
+      if (refs) {
+        if (refs.tableName && !refs.table) {
+          refs.table = refs.tableName;
+        }
+        if (refs.columnName && !refs.column) {
+          refs.column = refs.columnName;
+        }
+      }
       _assign(options, {
         operator: 'create',
         target: 'foreignKey',
         name: options.foreignKey ? options.foreignKey : 'fk_' + table + '_' + options.columnName,
         table: table,
         column: options.columnName,
-        references: options.references || options.reference  // 兼容性处理
+        references: refs
       });
       const builder = new ManageSQLBuilder(options);
       queries[file].push({ sql: builder.sql, values: builder.values });

package/.vscode/extensions.json

@@ -1,14 +0,0 @@
-{
-  "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",
-    "octref.vetur",
-    "pflannery.vscode-versionlens"
-  ]
-}

package/.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-  "cSpell.words": [
-    "fulltext"
-  ]
-}

package/examples/base_column.js

@@ -1,28 +0,0 @@
-'use strict';
-
-/**
- * @returns {Record<string, import('@axiosleo/orm-mysql').ColumnItem>}
- */
-module.exports = {
-  id: {
-    type: 'int',
-    allowNull: false,
-    primaryKey: true,
-    autoIncrement: true
-  },
-  created_at: {
-    type: 'TIMESTAMP',
-    allowNull: false,
-    default: 'CURRENT_TIMESTAMP'
-  },
-  updated_at: {
-    type: 'TIMESTAMP',
-    allowNull: false,
-    default: 'CURRENT_TIMESTAMP',
-    onUpdate: 'CURRENT_TIMESTAMP'
-  },
-  disabled_at: {
-    type: 'TIMESTAMP',
-    allowNull: true
-  }
-};

package/examples/migration/.connect.js

@@ -1,16 +0,0 @@
-'use strict';
-
-const path = require('path');
-
-const dotenv = require('dotenv');
-dotenv.config({
-  path: path.join(__dirname, '../../../.env')
-});
-
-module.exports = {
-  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
-};

package/examples/migration/1706764048.init.js

@@ -1,108 +0,0 @@
-'use strict';
-
-const baseColumn = require('../base_column');
-
-/**
- * @param {import('@axiosleo/orm-mysql').MigrationInterface} migration
- */
-function up(migration) {
-  migration.createTable('orgs', {
-    ...baseColumn,
-    code: {
-      type: 'varchar',
-      length: 64,
-      allowNull: false,
-      uniqIndex: true
-    },
-    name: {
-      type: 'VARCHAR',
-      allowNull: false
-    },
-    type: {
-      type: 'VARCHAR',
-      comment: '集团 group;公司 company;',
-      allowNull: false
-    },
-  });
-
-  migration.createTable('account', {
-    ...baseColumn,
-    uuid: {
-      type: 'VARCHAR',
-      length: 36,
-      allowNull: false,
-      uniqIndex: true,
-      comment: 'uuid'
-    },
-    username: {
-      type: 'varchar',
-      length: 64,
-      allowNull: false,
-    },
-    name: {
-      type: 'VARCHAR',
-      length: 100,
-      allowNull: false,
-      comment: '姓名',
-    },
-    avatar: {
-      type: 'VARCHAR',
-      allowNull: true,
-      comment: '头像文件索引'
-    },
-    password: {
-      type: 'varchar',
-      length: 64,
-      allowNull: false
-    },
-    last_token: {
-      type: 'VARCHAR',
-      length: 36,
-      allowNull: true,
-      comment: '最后一次登录的token'
-    }
-  });
-  migration.createIndex('account', ['username asc']);
-
-  migration.createTable('account_orgs', {
-    id: baseColumn.id,
-    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',
-      length: 32,
-      allowNull: false,
-      comment: '组织创建者creator;组织管理员admin;组织用户user;',
-      default: 'user'
-    }
-  });
-  migration.createColumn('created_at', 'TIMESTAMP', 'account_orgs');
-}
-
-/**
- * @param {import('@axiosleo/orm-mysql').MigrationInterface} migration
- */
-function down(migration) {
-  migration.dropTable('account_orgs');
-  migration.dropTable('account');
-  migration.dropTable('orgs');
-}
-
-module.exports = {
-  up,
-  down
-};

package/examples/transaction_example.js

@@ -1,228 +0,0 @@
-/* eslint-disable no-console */
-'use strict';
-
-/**
- * 事务使用示例
- * 
- * 这个示例展示了如何正确使用事务，避免连接阻塞问题
- */
-
-const mysql = require('mysql2/promise');
-const { QueryHandler } = require('../src/operator');
-
-/**
- * 示例 1: 使用连接池（推荐）
- * 优点：自动从池中获取新连接，不会阻塞其他操作
- */
-async function exampleWithPool() {
-  const pool = mysql.createPool({
-    host: 'localhost',
-    port: 3306,
-    user: 'root',
-    password: 'password',
-    database: 'test_db',
-    connectionLimit: 10
-  });
-
-  const queryHandler = new QueryHandler(pool);
-
-  try {
-    // 方式 1: 使用 QueryHandler.beginTransaction()（推荐）
-    // 这会自动从连接池获取一个新连接用于事务
-    const transaction = await queryHandler.beginTransaction({ level: 'RC' });
-    
-    try {
-      // 执行事务操作
-      await transaction.table('users').insert({ name: 'John', age: 30 });
-      await transaction.table('orders').insert({ user_id: 1, total: 100 });
-      
-      // 提交事务（会自动释放连接回池）
-      await transaction.commit();
-      console.log('Transaction committed successfully');
-    } catch (err) {
-      // 回滚事务（会自动释放连接回池）
-      await transaction.rollback();
-      console.error('Transaction rolled back:', err.message);
-      throw err;
-    }
-
-    // 同时，其他操作不会被阻塞
-    const users = await queryHandler.table('users').select();
-    console.log('Users:', users);
-
-  } finally {
-    await pool.end();
-  }
-}
-
-/**
- * 示例 2: 使用单一连接（不推荐用于生产环境）
- * 注意：事务执行期间会阻塞该连接的其他操作
- */
-async function exampleWithSingleConnection() {
-  const connection = await mysql.createConnection({
-    host: 'localhost',
-    port: 3306,
-    user: 'root',
-    password: 'password',
-    database: 'test_db'
-  });
-
-  const queryHandler = new QueryHandler(connection);
-
-  try {
-    // 使用单一连接创建事务
-    const transaction = await queryHandler.beginTransaction({ level: 'RR' });
-    
-    try {
-      await transaction.table('users').insert({ name: 'Jane', age: 25 });
-      await transaction.commit();
-      console.log('Transaction committed');
-    } catch (err) {
-      await transaction.rollback();
-      console.error('Transaction rolled back:', err);
-      throw err;
-    }
-
-  } finally {
-    await connection.end();
-  }
-}
-
-/**
- * 示例 3: 直接使用 TransactionHandler
- * 适用于需要更多控制的场景
- */
-async function exampleWithTransactionHandler() {
-  const { TransactionHandler } = require('../src/transaction');
-  
-  const connection = await mysql.createConnection({
-    host: 'localhost',
-    port: 3306,
-    user: 'root',
-    password: 'password',
-    database: 'test_db'
-  });
-
-  const transaction = new TransactionHandler(connection, { level: 'SERIALIZABLE' });
-  
-  try {
-    await transaction.begin();
-    
-    // 执行多个操作
-    await transaction.table('users').insert({ name: 'Bob', age: 35 });
-    await transaction.table('user_profiles').insert({ user_id: 1, bio: 'Developer' });
-    
-    // 使用锁
-    const lockedRows = await transaction.table('products')
-      .where('id', [1, 2, 3], 'IN')
-      .append('FOR UPDATE')
-      .select();
-    
-    console.log('Locked rows:', lockedRows);
-    
-    await transaction.commit();
-    console.log('Transaction completed');
-  } catch (err) {
-    await transaction.rollback();
-    console.error('Error:', err);
-    throw err;
-  } finally {
-    await connection.end();
-  }
-}
-
-/**
- * 示例 4: 并发事务（使用连接池）
- * 展示多个事务可以同时执行而不相互阻塞
- */
-async function exampleConcurrentTransactions() {
-  const pool = mysql.createPool({
-    host: 'localhost',
-    port: 3306,
-    user: 'root',
-    password: 'password',
-    database: 'test_db',
-    connectionLimit: 10
-  });
-
-  const queryHandler = new QueryHandler(pool);
-
-  try {
-    // 并发执行多个事务
-    const results = await Promise.all([
-      // 事务 1
-      (async () => {
-        const tx = await queryHandler.beginTransaction();
-        try {
-          await tx.table('users').insert({ name: 'User1', age: 20 });
-          await tx.commit();
-          return 'Transaction 1 completed';
-        } catch (err) {
-          await tx.rollback();
-          throw err;
-        }
-      })(),
-      
-      // 事务 2
-      (async () => {
-        const tx = await queryHandler.beginTransaction();
-        try {
-          await tx.table('users').insert({ name: 'User2', age: 21 });
-          await tx.commit();
-          return 'Transaction 2 completed';
-        } catch (err) {
-          await tx.rollback();
-          throw err;
-        }
-      })(),
-      
-      // 事务 3
-      (async () => {
-        const tx = await queryHandler.beginTransaction();
-        try {
-          await tx.table('users').insert({ name: 'User3', age: 22 });
-          await tx.commit();
-          return 'Transaction 3 completed';
-        } catch (err) {
-          await tx.rollback();
-          throw err;
-        }
-      })()
-    ]);
-
-    console.log('All transactions completed:', results);
-  } finally {
-    await pool.end();
-  }
-}
-
-/**
- * 最佳实践总结：
- * 
- * 1. 生产环境推荐使用连接池（Pool）
- * 2. 使用 QueryHandler.beginTransaction() 自动管理连接
- * 3. 始终在 try-catch-finally 中使用事务
- * 4. 确保调用 commit() 或 rollback()
- * 5. 连接池会自动释放连接，无需手动管理
- * 6. 避免在事务中执行长时间运行的操作
- * 7. 根据需要选择合适的隔离级别：
- *    - 'RU' / 'READ UNCOMMITTED': 最低隔离级别，性能最好，可能读到脏数据
- *    - 'RC' / 'READ COMMITTED': 避免脏读
- *    - 'RR' / 'REPEATABLE READ': MySQL 默认级别，避免不可重复读
- *    - 'S' / 'SERIALIZABLE': 最高隔离级别，完全串行化，性能最差
- */
-
-// 运行示例（取消注释以运行）
-// exampleWithPool().catch(console.error);
-// exampleWithSingleConnection().catch(console.error);
-// exampleWithTransactionHandler().catch(console.error);
-// exampleConcurrentTransactions().catch(console.error);
-
-module.exports = {
-  exampleWithPool,
-  exampleWithSingleConnection,
-  exampleWithTransactionHandler,
-  exampleConcurrentTransactions
-};
-