@mikro-orm/mysql 7.1.0-dev.8 → 7.1.0

package/MySqlConnection.d.ts

@@ -1,9 +1,11 @@
 import { type ControlledTransaction, MysqlDialect } from 'kysely';
 import { type PoolOptions } from 'mysql2';
+import { type Routine, type Transaction } from '@mikro-orm/core';
 import { AbstractSqlConnection, type TransactionEventBroadcaster } from '@mikro-orm/sql';
 /** MySQL database connection using the `mysql2` driver. */
 export declare class MySqlConnection extends AbstractSqlConnection {
     createKyselyDialect(overrides: PoolOptions): Promise<MysqlDialect>;
     mapOptions(overrides: PoolOptions): PoolOptions;
+    callRoutine<T>(routine: Routine, args?: Record<string, unknown>, ctx?: Transaction): Promise<T>;
     commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
 }

package/MySqlConnection.js

@@ -11,12 +11,18 @@ export class MySqlConnection extends AbstractSqlConnection {
             const innerPool = createPool({ ...options, password: initialPassword });
             // mysql2 reads pool.config.connectionConfig.password when creating new physical
             // connections, so updating it before getConnection() ensures fresh tokens are used.
-            // Existing idle connections are already authenticated and unaffected.
+            // Existing idle connections are already authenticated and unaffected, so we skip
+            // the callback when the pool has a free connection to reuse.
             const pool = {
                 getConnection(cb) {
+                    const inner = innerPool;
+                    if ((inner._freeConnections?.length ?? 0) > 0) {
+                        innerPool.getConnection(cb);
+                        return;
+                    }
                     Promise.resolve(password())
                         .then(pw => {
-                        innerPool.config.connectionConfig.password = pw;
+                        inner.config.connectionConfig.password = pw;
                         innerPool.getConnection(cb);
                     })
                         .catch(err => cb(err, undefined));
@@ -40,6 +46,17 @@ export class MySqlConnection extends AbstractSqlConnection {
         const pool = this.config.get('pool');
         ret.connectionLimit = pool?.max;
         ret.idleTimeout = pool?.idleTimeoutMillis;
+        // mysql2 only runs idle cleanup when `maxIdle < connectionLimit`; its default has
+        // them equal, so `idleTimeout` alone is a no-op. When the user opts into idle
+        // cleanup via `pool.idleTimeoutMillis`, default `maxIdle` to `pool.min ?? 0` so
+        // idle connections actually drain. A misconfigured `pool.min > pool.max` is
+        // clamped below `pool.max` so cleanup still runs. Explicit `driverOptions.maxIdle`
+        // still wins because `overrides` is merged in last.
+        if (pool?.idleTimeoutMillis != null) {
+            const min = pool.min ?? 0;
+            const max = pool.max;
+            ret.maxIdle = max != null && min > max ? Math.max(0, max - 1) : min;
+        }
         if (this.config.get('multipleStatements')) {
             ret.multipleStatements = this.config.get('multipleStatements');
         }
@@ -53,6 +70,52 @@ export class MySqlConnection extends AbstractSqlConnection {
         ret.dateStrings = true;
         return Utils.mergeConfig(ret, overrides);
     }
+    async callRoutine(routine, args = {}, ctx) {
+        if (routine.type === 'function') {
+            return this.callRoutineFunction(routine, args, ctx);
+        }
+        const name = this.platform.quoteIdentifier(routine.name);
+        const callPlaceholders = [];
+        const callValues = [];
+        const outVarParams = [];
+        routine.params.forEach((p, i) => {
+            if (p.direction === 'in') {
+                callPlaceholders.push('?');
+                callValues.push(this.convertRoutineInbound(args[p.name], p));
+                return;
+            }
+            const varName = `@_mikro_orm_routine_${i}`;
+            outVarParams.push({ name: p.name, varName, param: p });
+            callPlaceholders.push(varName);
+        });
+        // MySQL `@var`s are connection-scoped, so SET + CALL + SELECT must share one physical
+        // connection — wrap in an implicit transaction when the caller didn't supply one.
+        const needsConnectionAffinity = outVarParams.length > 0 && !ctx;
+        const runSteps = async (sharedCtx) => {
+            for (let i = 0; i < routine.params.length; i++) {
+                const p = routine.params[i];
+                if (p.direction === 'inout') {
+                    const varName = `@_mikro_orm_routine_${i}`;
+                    await this.execute(`set ${varName} := ?`, [this.convertRoutineInbound(args[p.name], p)], 'run', sharedCtx);
+                }
+            }
+            // mysql2 trails the result sets with an OK packet (non-array); filter to row arrays.
+            const callResult = (await this.execute(`call ${name}(${callPlaceholders.join(', ')})`, callValues, 'all', sharedCtx));
+            const resultSets = callResult.filter(Array.isArray);
+            if (outVarParams.length > 0) {
+                const selectClause = outVarParams
+                    .map(o => `${o.varName} as ${this.platform.quoteIdentifier(o.name)}`)
+                    .join(', ');
+                const rows = (await this.execute(`select ${selectClause}`, [], 'all', sharedCtx));
+                this.applyRoutineOutParams(rows[0] ?? {}, outVarParams.map(o => o.param), args);
+            }
+            return (resultSets.length > 0 ? resultSets : undefined);
+        };
+        if (needsConnectionAffinity) {
+            return this.transactional(trx => runSteps(trx));
+        }
+        return runSteps(ctx);
+    }
     async commit(ctx, eventBroadcaster) {
         if (!ctx.isRolledBack && 'savepointName' in ctx) {
             try {

package/MySqlMikroORM.d.ts

@@ -1,5 +1,5 @@
-import { type AnyEntity, type EntityClass, type EntitySchema, MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
-import type { SqlEntityManager } from '@mikro-orm/sql';
+import { type AnyEntity, type EntityClass, type EntitySchema, type MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import { SqlMikroORM, type SqlEntityManager } from '@mikro-orm/sql';
 import { MySqlDriver } from './MySqlDriver.js';
 /** Configuration options for the MySQL driver. */
 export type MySqlOptions<EM extends SqlEntityManager<MySqlDriver> = SqlEntityManager<MySqlDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Partial<Options<MySqlDriver, EM, Entities>>;
@@ -8,7 +8,7 @@ export declare function defineMySqlConfig<EM extends SqlEntityManager<MySqlDrive
 /**
  * @inheritDoc
  */
-export declare class MySqlMikroORM<EM extends SqlEntityManager<MySqlDriver> = SqlEntityManager<MySqlDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<MySqlDriver, EM, Entities> {
+export declare class MySqlMikroORM<EM extends SqlEntityManager<MySqlDriver> = SqlEntityManager<MySqlDriver>, Entities extends readonly (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends SqlMikroORM<MySqlDriver, EM, Entities> {
     /**
      * @inheritDoc
      */

package/MySqlMikroORM.js

@@ -1,4 +1,5 @@
-import { defineConfig, MikroORM, } from '@mikro-orm/core';
+import { defineConfig, } from '@mikro-orm/core';
+import { SqlMikroORM } from '@mikro-orm/sql';
 import { MySqlDriver } from './MySqlDriver.js';
 /** Creates a type-safe configuration object for the MySQL driver. */
 export function defineMySqlConfig(options) {
@@ -7,7 +8,7 @@ export function defineMySqlConfig(options) {
 /**
  * @inheritDoc
  */
-export class MySqlMikroORM extends MikroORM {
+export class MySqlMikroORM extends SqlMikroORM {
     /**
      * @inheritDoc
      */

package/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases.
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -19,6 +19,7 @@ Install a driver package for your database:
 
 ```sh
 npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
 npm install @mikro-orm/mysql        # MySQL
 npm install @mikro-orm/mariadb      # MariaDB
 npm install @mikro-orm/sqlite       # SQLite

package/index.d.ts

@@ -3,3 +3,7 @@ export * from './MySqlDriver.js';
 export * from './MySqlPlatform.js';
 export * from './MySqlConnection.js';
 export { MySqlMikroORM as MikroORM, type MySqlOptions as Options, defineMySqlConfig as defineConfig, } from './MySqlMikroORM.js';
+import { type AbstractSqlDriver, SqlEntityManager } from '@mikro-orm/sql';
+import type { MySqlDriver } from './MySqlDriver.js';
+export type EntityManager<Driver extends AbstractSqlDriver = MySqlDriver> = SqlEntityManager<Driver>;
+export declare const EntityManager: typeof SqlEntityManager;

package/index.js

@@ -3,3 +3,5 @@ export * from './MySqlDriver.js';
 export * from './MySqlPlatform.js';
 export * from './MySqlConnection.js';
 export { MySqlMikroORM as MikroORM, defineMySqlConfig as defineConfig, } from './MySqlMikroORM.js';
+import { SqlEntityManager } from '@mikro-orm/sql';
+export const EntityManager = SqlEntityManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mysql",
-  "version": "7.1.0-dev.8",
+  "version": "7.1.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",
@@ -47,16 +47,16 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.1.0-dev.8",
-    "kysely": "0.28.16",
-    "mysql2": "3.22.1",
+    "@mikro-orm/sql": "7.1.0",
+    "kysely": "0.29.2",
+    "mysql2": "3.22.3",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.1.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.8"
+    "@mikro-orm/core": "7.1.0"
   },
   "engines": {
     "node": ">= 22.17.0"