@mikro-orm/core 7.0.0-dev.337 → 7.0.0-dev.338

package/connections/Connection.d.ts

@@ -6,6 +6,7 @@ import type { Platform } from '../platforms/Platform.js';
 import type { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster.js';
 import type { IsolationLevel } from '../enums.js';
 export declare abstract class Connection {
+    #private;
     protected readonly config: Configuration;
     protected readonly type: ConnectionType;
     protected metadata: MetadataStorage;

package/connections/Connection.js

@@ -7,6 +7,12 @@ export class Connection {
     options;
     logger;
     connected = false;
+    get #connectionLabel() {
+        return {
+            type: this.type,
+            name: this.options.name || this.config.get('name') || this.options.host || this.options.dbName,
+        };
+    }
     constructor(config, options, type = 'write') {
         this.config = config;
         this.type = type;
@@ -120,28 +126,38 @@ export class Connection {
         const now = Date.now();
         try {
             const res = await cb();
-            this.logQuery(query, {
-                ...context,
-                took: Date.now() - now,
-                results: Array.isArray(res) ? res.length : undefined,
-                affected: Utils.isPlainObject(res) ? res.affectedRows : undefined,
-            });
+            const took = Date.now() - now;
+            const results = Array.isArray(res) ? res.length : undefined;
+            const affected = Utils.isPlainObject(res) ? res.affectedRows : undefined;
+            this.logQuery(query, { ...context, took, results, affected });
             return res;
         }
         catch (e) {
-            this.logQuery(query, { ...context, took: Date.now() - now, level: 'error' });
+            const took = Date.now() - now;
+            this.logQuery(query, { ...context, took, level: 'error' });
             throw e;
         }
     }
     logQuery(query, context = {}) {
+        const connection = this.#connectionLabel;
         this.logger.logQuery({
             level: 'info',
-            connection: {
-                type: this.type,
-                name: this.options.name || this.config.get('name') || this.options.host,
-            },
+            connection,
             ...context,
             query,
         });
+        const threshold = this.config.get('slowQueryThreshold');
+        if (threshold != null && (context.took ?? 0) >= threshold) {
+            this.config.getSlowQueryLogger().logQuery({
+                ...context,
+                // `enabled: true` bypasses the debug-mode check in isEnabled(),
+                // ensuring slow query logs are always emitted regardless of the `debug` setting.
+                enabled: true,
+                level: context.level ?? 'warning',
+                namespace: 'slow-query',
+                connection,
+                query,
+            });
+        }
     }
 }

package/logging/DefaultLogger.js

@@ -68,7 +68,8 @@ export class DefaultLogger {
      * @inheritDoc
      */
     logQuery(context) {
-        if (!this.isEnabled('query', context)) {
+        const namespace = context.namespace ?? 'query';
+        if (!this.isEnabled(namespace, context)) {
             return;
         }
         /* v8 ignore next */
@@ -86,7 +87,7 @@ export class DefaultLogger {
         if (this.usesReplicas && context.connection) {
             msg += colors.cyan(` (via ${context.connection.type} connection '${context.connection.name}')`);
         }
-        return this.log('query', msg, context);
+        return this.log(namespace, msg, context);
     }
     static create(options) {
         return new DefaultLogger(options);

package/logging/Logger.d.ts

@@ -22,10 +22,11 @@ export interface Logger {
     setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
     isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
 }
-export type LoggerNamespace = 'query' | 'query-params' | 'schema' | 'discovery' | 'info' | 'deprecated';
+export type LoggerNamespace = 'query' | 'query-params' | 'schema' | 'discovery' | 'info' | 'deprecated' | 'slow-query';
 export interface LogContext extends Dictionary {
     query?: string;
     label?: string;
+    namespace?: LoggerNamespace;
     params?: readonly unknown[];
     took?: number;
     results?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.0-dev.337",
+  "version": "7.0.0-dev.338",
   "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",

package/utils/Configuration.d.ts

@@ -36,6 +36,11 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
      * Gets Logger instance.
      */
     getLogger(): Logger;
+    /**
+     * Gets the logger instance for slow queries.
+     * Falls back to the main logger if no custom slow query logger factory is configured.
+     */
+    getSlowQueryLogger(): Logger;
     getDataloaderType(): DataloaderType;
     getSchema(skipDefaultSchema?: boolean): string | undefined;
     /**
@@ -671,6 +676,24 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @default DefaultLogger.create
      */
     loggerFactory?: (options: LoggerOptions) => Logger;
+    /**
+     * Threshold in milliseconds for logging slow queries.
+     * Queries taking at least this long will be logged via the 'slow-query' namespace at warning level.
+     * Slow query logs are always emitted when the threshold is met, regardless of the `debug` setting.
+     * Set to `0` to log every query as slow.
+     * @default undefined (slow query logging disabled)
+     */
+    slowQueryThreshold?: number;
+    /**
+     * Factory function to create a custom logger instance for slow queries.
+     * Has the same shape as `loggerFactory`. When not provided, the main logger instance is used.
+     *
+     * Note: slow query log entries are emitted with `context.enabled = true` to bypass the
+     * debug-mode check. Custom logger implementations must respect `context.enabled` in their
+     * `isEnabled()` method (as `DefaultLogger` does) to ensure slow query logs are always emitted.
+     * @default undefined (falls back to main logger)
+     */
+    slowQueryLoggerFactory?: (options: LoggerOptions) => Logger;
     /**
      * Custom error handler for `em.findOneOrFail()` when no entity is found.
      * @param entityName - Name of the entity being queried

package/utils/Configuration.js

@@ -130,6 +130,7 @@ const DEFAULTS = {
 export class Configuration {
     #options;
     #logger;
+    #slowQueryLogger;
     #driver;
     #platform;
     #cache = new Map();
@@ -195,6 +196,20 @@ export class Configuration {
     getLogger() {
         return this.#logger;
     }
+    /**
+     * Gets the logger instance for slow queries.
+     * Falls back to the main logger if no custom slow query logger factory is configured.
+     */
+    getSlowQueryLogger() {
+        this.#slowQueryLogger ??=
+            this.#options.slowQueryLoggerFactory?.({
+                debugMode: this.#options.debug,
+                writer: this.#options.logger,
+                highlighter: this.#options.highlighter,
+                usesReplicas: (this.#options.replicas?.length ?? 0) > 0,
+            }) ?? this.#logger;
+        return this.#slowQueryLogger;
+    }
     getDataloaderType() {
         if (typeof this.#options.dataloader === 'boolean') {
             return this.#options.dataloader ? DataloaderType.ALL : DataloaderType.NONE;
@@ -337,6 +352,7 @@ export class Configuration {
     sync() {
         setEnv('MIKRO_ORM_COLORS', this.#options.colors);
         this.#logger.setDebugMode(this.#options.debug);
+        this.#slowQueryLogger = undefined;
     }
     validateOptions() {
         /* v8 ignore next */

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.337';
+    static #ORM_VERSION = '7.0.0-dev.338';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */