@mikro-orm/core 7.0.0-rc.2 → 7.0.0

package/utils/Configuration.js

@@ -128,141 +128,159 @@ const DEFAULTS = {
     dynamicImportProvider: /* v8 ignore next */ (id) => import(id),
 };
 export class Configuration {
-    options;
-    logger;
-    driver;
-    platform;
-    cache = new Map();
-    extensions = new Map();
+    #options;
+    #logger;
+    #slowQueryLogger;
+    #driver;
+    #platform;
+    #cache = new Map();
+    #extensions = new Map();
     constructor(options, validate = true) {
         if (options.dynamicImportProvider) {
             globalThis.dynamicImportProvider = options.dynamicImportProvider;
         }
-        this.options = Utils.mergeConfig({}, DEFAULTS, options);
+        this.#options = Utils.mergeConfig({}, DEFAULTS, options);
         if (validate) {
             this.validateOptions();
         }
-        this.options.loggerFactory ??= DefaultLogger.create;
-        this.logger = this.options.loggerFactory({
-            debugMode: this.options.debug,
-            ignoreDeprecations: this.options.ignoreDeprecations,
-            usesReplicas: (this.options.replicas?.length ?? 0) > 0,
-            highlighter: this.options.highlighter,
-            writer: this.options.logger,
+        this.#options.loggerFactory ??= DefaultLogger.create;
+        this.#logger = this.#options.loggerFactory({
+            debugMode: this.#options.debug,
+            ignoreDeprecations: this.#options.ignoreDeprecations,
+            usesReplicas: (this.#options.replicas?.length ?? 0) > 0,
+            highlighter: this.#options.highlighter,
+            writer: this.#options.logger,
         });
-        const cf = this.options.compiledFunctions;
+        const cf = this.#options.compiledFunctions;
         if (cf && cf.__version !== Utils.getORMVersion()) {
-            this.logger.warn('discovery', `Compiled functions were generated with MikroORM v${cf.__version ?? 'unknown'}, but the current version is v${Utils.getORMVersion()}. Please regenerate with \`npx mikro-orm compile\`.`);
+            this.#logger.warn('discovery', `Compiled functions were generated with MikroORM v${cf.__version ?? 'unknown'}, but the current version is v${Utils.getORMVersion()}. Please regenerate with \`npx mikro-orm compile\`.`);
         }
-        if (this.options.driver) {
-            this.driver = new this.options.driver(this);
-            this.platform = this.driver.getPlatform();
-            this.platform.setConfig(this);
+        if (this.#options.driver) {
+            this.#driver = new this.#options.driver(this);
+            this.#platform = this.#driver.getPlatform();
+            this.#platform.setConfig(this);
             this.init(validate);
         }
     }
     getPlatform() {
-        return this.platform;
+        return this.#platform;
     }
     /**
      * Gets specific configuration option. Falls back to specified `defaultValue` if provided.
      */
     get(key, defaultValue) {
-        if (typeof this.options[key] !== 'undefined') {
-            return this.options[key];
+        if (typeof this.#options[key] !== 'undefined') {
+            return this.#options[key];
         }
         return defaultValue;
     }
     getAll() {
-        return this.options;
+        return this.#options;
     }
     /**
      * Overrides specified configuration value.
      */
     set(key, value) {
-        this.options[key] = value;
+        this.#options[key] = value;
         this.sync();
     }
     /**
      * Resets the configuration to its default value
      */
     reset(key) {
-        this.options[key] = DEFAULTS[key];
+        this.#options[key] = DEFAULTS[key];
     }
     /**
      * Gets Logger instance.
      */
     getLogger() {
-        return this.logger;
+        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;
+        if (typeof this.#options.dataloader === 'boolean') {
+            return this.#options.dataloader ? DataloaderType.ALL : DataloaderType.NONE;
         }
-        return this.options.dataloader;
+        return this.#options.dataloader;
     }
     getSchema(skipDefaultSchema = false) {
-        if (skipDefaultSchema && this.options.schema === this.platform.getDefaultSchemaName()) {
+        if (skipDefaultSchema && this.#options.schema === this.#platform.getDefaultSchemaName()) {
             return undefined;
         }
-        return this.options.schema;
+        return this.#options.schema;
     }
     /**
      * Gets current database driver instance.
      */
     getDriver() {
-        return this.driver;
+        return this.#driver;
     }
     registerExtension(name, cb) {
-        this.extensions.set(name, cb);
+        this.#extensions.set(name, cb);
     }
     getExtension(name) {
-        if (this.cache.has(name)) {
-            return this.cache.get(name);
+        if (this.#cache.has(name)) {
+            return this.#cache.get(name);
         }
-        const ext = this.extensions.get(name);
+        const ext = this.#extensions.get(name);
         /* v8 ignore next */
         if (!ext) {
             return undefined;
         }
-        this.cache.set(name, ext());
-        return this.cache.get(name);
+        this.#cache.set(name, ext());
+        return this.#cache.get(name);
     }
     /**
      * Gets instance of NamingStrategy. (cached)
      */
     getNamingStrategy() {
-        return this.getCachedService(this.options.namingStrategy || this.platform.getNamingStrategy());
+        return this.getCachedService(this.#options.namingStrategy || this.#platform.getNamingStrategy());
     }
     /**
      * Gets instance of Hydrator. (cached)
      */
     getHydrator(metadata) {
-        return this.getCachedService(this.options.hydrator, metadata, this.platform, this);
+        return this.getCachedService(this.#options.hydrator, metadata, this.#platform, this);
     }
     /**
      * Gets instance of Comparator. (cached)
      */
     getComparator(metadata) {
-        return this.getCachedService(EntityComparator, metadata, this.platform, this);
+        return this.getCachedService(EntityComparator, metadata, this.#platform, this);
     }
     /**
      * Gets instance of MetadataProvider. (cached)
      */
     getMetadataProvider() {
-        return this.getCachedService(this.options.metadataProvider, this);
+        return this.getCachedService(this.#options.metadataProvider, this);
     }
     /**
      * Gets instance of metadata CacheAdapter. (cached)
      */
     getMetadataCacheAdapter() {
-        return this.getCachedService(this.options.metadataCache.adapter, this.options.metadataCache.options, this.options.baseDir, this.options.metadataCache.pretty);
+        return this.getCachedService(this.#options.metadataCache.adapter, this.#options.metadataCache.options, this.#options.baseDir, this.#options.metadataCache.pretty);
     }
     /**
      * Gets instance of CacheAdapter for result cache. (cached)
      */
     getResultCacheAdapter() {
-        return this.getCachedService(this.options.resultCache.adapter, { expiration: this.options.resultCache.expiration, ...this.options.resultCache.options });
+        return this.getCachedService(this.#options.resultCache.adapter, {
+            expiration: this.#options.resultCache.expiration,
+            ...this.#options.resultCache.options,
+        });
     }
     /**
      * Gets EntityRepository class to be instantiated.
@@ -271,85 +289,87 @@ export class Configuration {
         if (repository) {
             return repository();
         }
-        if (this.options.entityRepository) {
-            return this.options.entityRepository;
+        if (this.#options.entityRepository) {
+            return this.#options.entityRepository;
         }
-        return this.platform.getRepositoryClass();
+        return this.#platform.getRepositoryClass();
     }
     /**
      * Creates instance of given service and caches it.
      */
     getCachedService(cls, ...args) {
-        if (!this.cache.has(cls.name)) {
-            this.cache.set(cls.name, new cls(...args));
+        if (!this.#cache.has(cls.name)) {
+            this.#cache.set(cls.name, new cls(...args));
         }
-        return this.cache.get(cls.name);
+        return this.#cache.get(cls.name);
     }
     resetServiceCache() {
-        this.cache.clear();
+        this.#cache.clear();
     }
     init(validate) {
         const useCache = this.getMetadataProvider().useCache();
-        const metadataCache = this.options.metadataCache;
+        const metadataCache = this.#options.metadataCache;
         if (!useCache) {
             metadataCache.adapter = NullCacheAdapter;
         }
         metadataCache.enabled ??= useCache;
-        this.options.clientUrl ??= this.platform.getDefaultClientUrl();
-        this.options.implicitTransactions ??= this.platform.usesImplicitTransactions();
+        this.#options.clientUrl ??= this.#platform.getDefaultClientUrl();
+        this.#options.implicitTransactions ??= this.#platform.usesImplicitTransactions();
         if (validate && metadataCache.enabled && !metadataCache.adapter) {
             throw new Error('No metadata cache adapter specified, please fill in `metadataCache.adapter` option or use the async MikroORM.init() method which can autoload it.');
         }
         try {
-            const url = new URL(this.options.clientUrl);
+            const url = new URL(this.#options.clientUrl);
             if (url.pathname) {
-                this.options.dbName = this.get('dbName', decodeURIComponent(url.pathname).substring(1));
+                this.#options.dbName = this.get('dbName', decodeURIComponent(url.pathname).substring(1));
             }
         }
         catch {
-            const url = this.options.clientUrl.match(/:\/\/.*\/([^?]+)/);
+            const url = /:\/\/.*\/([^?]+)/.exec(this.#options.clientUrl);
             if (url) {
-                this.options.dbName = this.get('dbName', decodeURIComponent(url[1]));
+                this.#options.dbName = this.get('dbName', decodeURIComponent(url[1]));
             }
         }
-        if (validate && !this.options.dbName && this.options.clientUrl) {
+        if (validate && !this.#options.dbName && this.#options.clientUrl) {
             throw new Error("No database specified, `clientUrl` option provided but it's missing the pathname.");
         }
-        this.options.schema ??= this.platform.getDefaultSchemaName();
-        this.options.charset ??= this.platform.getDefaultCharset();
-        Object.keys(this.options.filters).forEach(key => {
-            this.options.filters[key].default ??= true;
+        this.#options.schema ??= this.#platform.getDefaultSchemaName();
+        this.#options.charset ??= this.#platform.getDefaultCharset();
+        Object.keys(this.#options.filters).forEach(key => {
+            this.#options.filters[key].default ??= true;
         });
-        if (!this.options.filtersOnRelations) {
-            this.options.autoJoinRefsForFilters ??= false;
+        if (!this.#options.filtersOnRelations) {
+            this.#options.autoJoinRefsForFilters ??= false;
         }
-        this.options.subscribers = [...this.options.subscribers].map(subscriber => {
+        this.#options.subscribers = [...this.#options.subscribers].map(subscriber => {
             return subscriber.constructor.name === 'Function' ? new subscriber() : subscriber;
         });
         this.sync();
         if (!colors.enabled()) {
-            this.options.highlighter = new NullHighlighter();
+            this.#options.highlighter = new NullHighlighter();
         }
     }
     sync() {
-        setEnv('MIKRO_ORM_COLORS', this.options.colors);
-        this.logger.setDebugMode(this.options.debug);
+        setEnv('MIKRO_ORM_COLORS', this.#options.colors);
+        this.#logger.setDebugMode(this.#options.debug);
+        this.#slowQueryLogger = undefined;
     }
     validateOptions() {
         /* v8 ignore next */
-        if ('type' in this.options) {
-            throw new Error('The `type` option has been removed in v6, please fill in the `driver` option instead or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from \'@mikro-orm/mysql\'; export default defineConfig({ ... })`).');
+        if ('type' in this.#options) {
+            throw new Error("The `type` option has been removed in v6, please fill in the `driver` option instead or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from '@mikro-orm/mysql'; export default defineConfig({ ... })`).");
         }
-        if (!this.options.driver) {
-            throw new Error('No driver specified, please fill in the `driver` option or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from \'@mikro-orm/mysql\'; export defineConfig({ ... })`).');
+        if (!this.#options.driver) {
+            throw new Error("No driver specified, please fill in the `driver` option or use `defineConfig` helper (to define your ORM config) or `MikroORM` class (to call the `init` method) exported from the driver package (e.g. `import { defineConfig } from '@mikro-orm/mysql'; export defineConfig({ ... })`).");
         }
-        if (!this.options.dbName && !this.options.clientUrl) {
+        if (!this.#options.dbName && !this.#options.clientUrl) {
             throw new Error('No database specified, please fill in `dbName` or `clientUrl` option');
         }
-        if (this.options.entities.length === 0 && this.options.discovery.warnWhenNoEntities) {
+        if (this.#options.entities.length === 0 && this.#options.discovery.warnWhenNoEntities) {
             throw new Error('No entities found, please use `entities` option');
         }
-        if (typeof this.options.driverOptions === 'function' && this.options.driverOptions.constructor.name === 'AsyncFunction') {
+        if (typeof this.#options.driverOptions === 'function' &&
+            this.#options.driverOptions.constructor.name === 'AsyncFunction') {
             throw new Error('`driverOptions` callback cannot be async');
         }
     }

package/utils/Cursor.d.ts

@@ -1,4 +1,4 @@
-import type { EntityMetadata, FilterObject, Loaded } from '../typings.js';
+import type { EntityKey, EntityMetadata, FilterObject, Loaded } from '../typings.js';
 import type { FindByCursorOptions, OrderDefinition } from '../drivers/IDatabaseDriver.js';
 import { type QueryOrder } from '../enums.js';
 /**
@@ -49,11 +49,11 @@ import { type QueryOrder } from '../enums.js';
  * ```
  */
 export declare class Cursor<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true> {
+    #private;
     readonly items: Loaded<Entity, Hint, Fields, Excludes>[];
     readonly totalCount: IncludeCount extends true ? number : undefined;
     readonly hasPrevPage: boolean;
     readonly hasNextPage: boolean;
-    private readonly definition;
     constructor(items: Loaded<Entity, Hint, Fields, Excludes>[], totalCount: IncludeCount extends true ? number : undefined, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>, meta: EntityMetadata<Entity>);
     get startCursor(): string | null;
     get endCursor(): string | null;
@@ -69,5 +69,5 @@ export declare class Cursor<Entity extends object, Hint extends string = never,
     static for<Entity extends object>(meta: EntityMetadata<Entity>, entity: FilterObject<Entity>, orderBy: OrderDefinition<Entity>): string;
     static encode(value: unknown[]): string;
     static decode(value: string): unknown[];
-    static getDefinition<Entity extends object>(meta: EntityMetadata<Entity>, orderBy: OrderDefinition<Entity>): [never, QueryOrder][];
+    static getDefinition<Entity extends object>(meta: EntityMetadata<Entity>, orderBy: OrderDefinition<Entity>): [EntityKey, QueryOrder][];
 }

package/utils/Cursor.js

@@ -57,7 +57,7 @@ export class Cursor {
     totalCount;
     hasPrevPage;
     hasNextPage;
-    definition;
+    #definition;
     constructor(items, totalCount, options, meta) {
         this.items = items;
         this.totalCount = totalCount;
@@ -75,7 +75,7 @@ export class Cursor {
                 items.pop();
             }
         }
-        this.definition = Cursor.getDefinition(meta, orderBy);
+        this.#definition = Cursor.getDefinition(meta, orderBy);
     }
     get startCursor() {
         if (this.items.length === 0) {
@@ -118,11 +118,11 @@ export class Cursor {
                 value = value.unwrap();
             }
             if (object) {
-                return ({ [prop]: value });
+                return { [prop]: value };
             }
             return value;
         };
-        const value = this.definition.map(([key, direction]) => processEntity(entity, key, direction));
+        const value = this.#definition.map(([key, direction]) => processEntity(entity, key, direction));
         return Cursor.encode(value);
     }
     *[Symbol.iterator]() {
@@ -151,7 +151,7 @@ export class Cursor {
     }
     static decode(value) {
         return JSON.parse(Buffer.from(value, 'base64url').toString('utf8')).map((value) => {
-            if (typeof value === 'string' && value.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}/)) {
+            if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}/.exec(value)) {
                 return new Date(value);
             }
             return value;
@@ -167,7 +167,9 @@ export class Cursor {
                 }
                 const prop = meta.properties[key];
                 /* v8 ignore next */
-                if (!prop || !([ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
+                if (!prop ||
+                    !([ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE].includes(prop.kind) ||
+                        (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner))) {
                     continue;
                 }
                 ret.push([prop.name, order[prop.name]]);

package/utils/DataloaderUtils.js

@@ -101,26 +101,27 @@ export class DataloaderUtils {
             const uniqueName = key.substring(0, key.indexOf('|'));
             const opts = JSON.parse(key.substring(key.indexOf('|') + 1));
             const meta = em.getMetadata().getByUniqueName(uniqueName);
-            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0 ?
-                {
+            const res = await em.find(meta.class, opts?.where != null && Object.keys(opts.where).length > 0
+                ? {
                     $and: [
                         {
                             $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                                return ({ [prop]: Array.from(pks) });
+                                return { [prop]: Array.from(pks) };
                             }),
                         },
                         opts.where,
                     ],
-                } : {
-                // The entries of the filter Map will be used as the values of the $or operator
-                $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
-                    return ({ [prop]: Array.from(pks) });
-                }),
-            }, {
+                }
+                : {
+                    // The entries of the filter Map will be used as the values of the $or operator
+                    $or: Array.from(filterMap.entries()).map(([prop, pks]) => {
+                        return { [prop]: Array.from(pks) };
+                    }),
+                }, {
                 ...opts,
                 // We need to populate the inverse side of the relationship in order to be able to later retrieve the PK(s) from its item(s)
                 populate: [
-                    ...(opts.populate === false ? [] : opts.populate ?? []),
+                    ...(opts.populate === false ? [] : (opts.populate ?? [])),
                     ...Array.from(filterMap.keys()).filter(
                     // We need to do so only if the inverse side is a collection, because we can already retrieve the PK from a reference without having to load it
                     prop => meta.properties[prop]?.ref !== true),
@@ -207,7 +208,9 @@ export class DataloaderUtils {
                     options.refresh ??= c[1]?.refresh;
                 }
                 options.where = wrap({ $or });
-                const r = await em.getEntityLoader().findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
+                const r = await em
+                    .getEntityLoader()
+                    .findChildrenFromPivotTable(owners, prop, options, orderBy, populate, group[0][1]?.ref);
                 ret.push(...r);
             }
             return ret;
@@ -224,7 +227,7 @@ export class DataloaderUtils {
         }
         catch {
             /* v8 ignore next */
-            throw new Error('DataLoader is not found, make sure `dataloader` package is installed in your project\'s dependencies.');
+            throw new Error("DataLoader is not found, make sure `dataloader` package is installed in your project's dependencies.");
         }
     }
 }

package/utils/EntityComparator.d.ts

@@ -1,4 +1,4 @@
-import type { EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, IMetadataStorage } from '../typings.js';
+import type { EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { Configuration } from './Configuration.js';
 type Comparator<T> = (a: T, b: T, options?: {
@@ -6,19 +6,12 @@ type Comparator<T> = (a: T, b: T, options?: {
 }) => EntityData<T>;
 type ResultMapper<T> = (result: EntityData<T>) => EntityData<T> | null;
 type SnapshotGenerator<T> = (entity: T) => EntityData<T>;
+type PkGetter<T> = (entity: T) => Primary<T>;
+type PkSerializer<T> = (entity: T) => string;
 type CompositeKeyPart = string | CompositeKeyPart[];
 export declare class EntityComparator {
-    private readonly metadata;
-    private readonly platform;
-    private readonly config?;
-    private readonly comparators;
-    private readonly mappers;
-    private readonly snapshotGenerators;
-    private readonly pkGetters;
-    private readonly pkGettersConverted;
-    private readonly pkSerializers;
-    private tmpIndex;
-    constructor(metadata: IMetadataStorage, platform: Platform, config?: Configuration | undefined);
+    #private;
+    constructor(metadata: IMetadataStorage, platform: Platform, config?: Configuration);
     /**
      * Computes difference between two entities.
      */
@@ -38,15 +31,15 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getPkGetter<T>(meta: EntityMetadata<T>): any;
+    getPkGetter<T>(meta: EntityMetadata<T>): PkGetter<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getPkGetterConverted<T>(meta: EntityMetadata<T>): any;
+    getPkGetterConverted<T>(meta: EntityMetadata<T>): PkGetter<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getPkSerializer<T>(meta: EntityMetadata<T>): any;
+    getPkSerializer<T>(meta: EntityMetadata<T>): PkSerializer<T>;
     /**
      * @internal Highly performance-sensitive method.
      */