@mikro-orm/core 7.0.0-dev.336 → 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/drivers/DatabaseDriver.js

@@ -346,8 +346,8 @@ export class DatabaseDriver {
                 const props = prop.embeddedProps;
                 let unknownProp = false;
                 Object.keys(data[prop.name]).forEach(kk => {
-                    // explicitly allow `$exists`, `$eq` and `$ne` operators here as they can't be misused this way
-                    const operator = Object.keys(data[prop.name]).some(f => Utils.isOperator(f) && !['$exists', '$ne', '$eq'].includes(f));
+                    // explicitly allow `$exists`, `$eq`, `$ne` and `$elemMatch` operators here as they can't be misused this way
+                    const operator = Object.keys(data[prop.name]).some(f => Utils.isOperator(f) && !['$exists', '$ne', '$eq', '$elemMatch'].includes(f));
                     if (operator) {
                         throw ValidationError.cannotUseOperatorsInsideEmbeddables(meta.class, prop.name, data);
                     }

package/enums.d.ts

@@ -45,7 +45,8 @@ export declare enum QueryOperator {
     $size = "size",// collection operators, sql only
     $hasKey = "?",// postgres only, json
     $hasKeys = "?&",// postgres only, json
-    $hasSomeKeys = "?|"
+    $hasSomeKeys = "?|",// postgres only, json
+    $elemMatch = "elemMatch"
 }
 export declare const ARRAY_OPERATORS: string[];
 export declare const JSON_KEY_OPERATORS: string[];

package/enums.js

@@ -48,6 +48,7 @@ export var QueryOperator;
     QueryOperator["$hasKey"] = "?";
     QueryOperator["$hasKeys"] = "?&";
     QueryOperator["$hasSomeKeys"] = "?|";
+    QueryOperator["$elemMatch"] = "elemMatch";
 })(QueryOperator || (QueryOperator = {}));
 export const ARRAY_OPERATORS = ['$eq', '$gt', '$gte', '$lt', '$lte', '$ne', '$overlap', '$contains', '$contained'];
 export const JSON_KEY_OPERATORS = ['$hasKey', '$hasKeys', '$hasSomeKeys'];

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.336",
+  "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/typings.d.ts

@@ -234,8 +234,18 @@ export type FilterItemValue<T> = T | ExpandScalar<T> | Primary<T> | Raw;
 export type FilterValue<T> = OperatorMap<FilterItemValue<T>> | FilterItemValue<T> | FilterItemValue<T>[] | null;
 type FilterObjectProp<T, K extends PropertyKey> = K extends keyof MergeUnion<T> ? MergeUnion<T>[K] : K extends keyof T ? T[K] : never;
 type ExpandQueryMerged<T> = [T] extends [object] ? [T] extends [Scalar] ? never : FilterQuery<MergeUnion<T>> : FilterValue<T>;
+type ElemMatchCondition<T extends Record<string, any>> = {
+    [K in keyof T]?: T[K] | OperatorMap<T[K]>;
+} & {
+    $or?: ElemMatchCondition<T>[];
+    $and?: ElemMatchCondition<T>[];
+    $not?: ElemMatchCondition<T>;
+};
+type ElemMatchFilter<T> = T extends readonly (infer E)[] ? E extends Record<string, any> ? {
+    $elemMatch: ElemMatchCondition<E>;
+} : never : never;
 export type FilterObject<T> = {
-    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | null;
+    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | ElemMatchFilter<FilterObjectProp<T, K>> | null;
 };
 export type ExpandQuery<T> = T extends object ? (T extends Scalar ? never : FilterQuery<T>) : FilterValue<T>;
 export type EntityProps<T> = {

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

@@ -186,7 +186,7 @@ export class QueryHelper {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
             // oxfmt-ignore
-            const isJsonProperty = prop?.customType instanceof JsonType && !isRaw(value) && (Utils.isPlainObject(value) ? Object.keys(value)[0] !== '$eq' : !Array.isArray(value));
+            const isJsonProperty = prop?.customType instanceof JsonType && !isRaw(value) && (Utils.isPlainObject(value) ? !['$eq', '$elemMatch'].includes(Object.keys(value)[0]) : !Array.isArray(value));
             if (isJsonProperty && prop?.kind !== ReferenceKind.EMBEDDED) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }

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.336';
+    static #ORM_VERSION = '7.0.0-dev.338';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */