@mikro-orm/core 7.0.0-rc.3 → 7.0.1-dev.0

package/MikroORM.d.ts

@@ -5,7 +5,7 @@ import { Configuration, type Options } from './utils/Configuration.js';
 import type { EntityManager } from './EntityManager.js';
 import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
 /** @internal */
-export declare function loadOptionalDependencies(options: Options): Promise<void>;
+export declare function loadOptionalDependencies(options: Partial<Options>): Promise<void>;
 /**
  * The main class used to configure and bootstrap the ORM.
  *
@@ -35,27 +35,25 @@ export declare function loadOptionalDependencies(options: Options): Promise<void
  * ```
  */
 export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends Driver[typeof EntityManagerType] & EntityManager<Driver> = Driver[typeof EntityManagerType] & EntityManager<Driver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> {
+    #private;
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
     em: EM & {
         '~entities'?: Entities;
     };
     readonly driver: Driver;
     readonly config: Configuration<Driver>;
-    private metadata;
-    private readonly logger;
-    private readonly discovery;
     /**
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.
      */
-    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * Synchronous variant of the `init` method with some limitations:
      * - folder-based discovery not supported
      * - ORM extensions are not autoloaded
      * - when metadata cache is enabled, `FileCacheAdapter` needs to be explicitly set in the config
      */
-    constructor(options: Options<Driver, EM, Entities>);
+    constructor(options: Partial<Options<Driver, EM, Entities>>);
     /**
      * Connects to the database.
      */

package/MikroORM.js

@@ -74,9 +74,9 @@ export class MikroORM {
     em;
     driver;
     config;
-    metadata;
-    logger;
-    discovery;
+    #metadata;
+    #logger;
+    #discovery;
     /**
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.
@@ -92,7 +92,7 @@ export class MikroORM {
         await loadOptionalDependencies(options);
         const orm = new this(options);
         const preferTs = orm.config.get('preferTs', Utils.detectTypeScriptSupport());
-        orm.metadata = await orm.discovery.discover(preferTs);
+        orm.#metadata = await orm.#discovery.discover(preferTs);
         orm.createEntityManager();
         return orm;
     }
@@ -108,15 +108,15 @@ export class MikroORM {
         this.config = new Configuration(options);
         const discovery = this.config.get('discovery');
         this.driver = this.config.getDriver();
-        this.logger = this.config.getLogger();
-        this.logger.log('info', `MikroORM version: ${colors.green(Utils.getORMVersion())}`);
-        this.discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
+        this.#logger = this.config.getLogger();
+        this.#logger.log('info', `MikroORM version: ${colors.green(Utils.getORMVersion())}`);
+        this.#discovery = new MetadataDiscovery(new MetadataStorage(), this.driver.getPlatform(), this.config);
         this.driver.getPlatform().init(this);
         for (const extension of this.config.get('extensions')) {
             extension.register(this);
         }
         if (!discovery.skipSyncDiscovery) {
-            this.metadata = this.discovery.discoverSync();
+            this.#metadata = this.#discovery.discoverSync();
             this.createEntityManager();
         }
     }
@@ -162,32 +162,32 @@ export class MikroORM {
      */
     getMetadata(entityName) {
         if (entityName) {
-            return this.metadata.get(entityName);
+            return this.#metadata.get(entityName);
         }
-        return this.metadata;
+        return this.#metadata;
     }
     createEntityManager() {
-        this.driver.setMetadata(this.metadata);
+        this.driver.setMetadata(this.#metadata);
         this.em = this.driver.createEntityManager();
         this.em.global = true;
-        this.metadata.decorate(this.em);
-        this.driver.setMetadata(this.metadata);
+        this.#metadata.decorate(this.em);
+        this.driver.setMetadata(this.#metadata);
     }
     /**
      * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
      */
     discoverEntity(entities, reset) {
         for (const className of Utils.asArray(reset)) {
-            this.metadata.reset(className);
-            this.discovery.reset(className);
+            this.#metadata.reset(className);
+            this.#discovery.reset(className);
         }
-        const tmp = this.discovery.discoverReferences(Utils.asArray(entities));
-        const metadata = this.discovery.processDiscoveredEntities(tmp);
+        const tmp = this.#discovery.discoverReferences(Utils.asArray(entities));
+        const metadata = this.#discovery.processDiscoveredEntities(tmp);
         for (const meta of metadata) {
-            this.metadata.set(meta.class, meta);
-            meta.root = this.metadata.get(meta.root.class);
+            this.#metadata.set(meta.class, meta);
+            meta.root = this.#metadata.get(meta.root.class);
         }
-        this.metadata.decorate(this.em);
+        this.#metadata.decorate(this.em);
     }
     /**
      * Gets the SchemaGenerator.

package/README.md

@@ -2,14 +2,14 @@
   <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 and SQLite (including libSQL) 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, SQLite (including libSQL), MSSQL and Oracle databases. 
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
-[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
-[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![NPM version](https://img.shields.io/npm/v/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
+[![NPM dev version](https://img.shields.io/npm/v/@mikro-orm/core/next.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
-[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
+[![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://npmx.dev/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
@@ -181,6 +181,7 @@ yarn add @mikro-orm/core @mikro-orm/mysql         # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/mariadb       # for mysql/mariadb
 yarn add @mikro-orm/core @mikro-orm/postgresql    # for postgresql
 yarn add @mikro-orm/core @mikro-orm/mssql         # for mssql
+yarn add @mikro-orm/core @mikro-orm/oracledb      # for oracle
 yarn add @mikro-orm/core @mikro-orm/sqlite        # for sqlite
 yarn add @mikro-orm/core @mikro-orm/libsql        # for libsql
 ```

package/cache/FileCacheAdapter.d.ts

@@ -1,10 +1,6 @@
 import type { SyncCacheAdapter } from './CacheAdapter.js';
 export declare class FileCacheAdapter implements SyncCacheAdapter {
-    private readonly options;
-    private readonly baseDir;
-    private readonly pretty;
-    private readonly VERSION;
-    private cache;
+    #private;
     constructor(options: {
         cacheDir: string;
         combined?: boolean | string;

package/cache/FileCacheAdapter.js

@@ -2,16 +2,16 @@ import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
 import { fs } from '../utils/fs-utils.js';
 import { Utils } from '../utils/Utils.js';
 export class FileCacheAdapter {
-    options;
-    baseDir;
-    pretty;
-    VERSION = Utils.getORMVersion();
-    cache = {};
+    #VERSION = Utils.getORMVersion();
+    #cache = {};
+    #options;
+    #baseDir;
+    #pretty;
     constructor(options = {}, baseDir, pretty = false) {
-        this.options = options;
-        this.baseDir = baseDir;
-        this.pretty = pretty;
-        this.options.cacheDir ??= process.cwd() + '/temp';
+        this.#options = options;
+        this.#baseDir = baseDir;
+        this.#pretty = pretty;
+        this.#options.cacheDir ??= process.cwd() + '/temp';
     }
     /**
      * @inheritDoc
@@ -32,13 +32,13 @@ export class FileCacheAdapter {
      * @inheritDoc
      */
     set(name, data, origin) {
-        if (this.options.combined) {
-            this.cache[name.replace(/\.[jt]s$/, '')] = data;
+        if (this.#options.combined) {
+            this.#cache[name.replace(/\.[jt]s$/, '')] = data;
             return;
         }
         const path = this.path(name);
         const hash = this.getHash(origin);
-        writeFileSync(path, JSON.stringify({ data, origin, hash, version: this.VERSION }, null, this.pretty ? 2 : undefined));
+        writeFileSync(path, JSON.stringify({ data, origin, hash, version: this.#VERSION }, null, this.#pretty ? 2 : undefined));
     }
     /**
      * @inheritDoc
@@ -62,28 +62,28 @@ export class FileCacheAdapter {
                 // ignore if file is already gone
             }
         }
-        this.cache = {};
+        this.#cache = {};
     }
     combine() {
-        if (!this.options.combined) {
+        if (!this.#options.combined) {
             return;
         }
-        let path = typeof this.options.combined === 'string' ? this.options.combined : './metadata.json';
-        path = fs.normalizePath(this.options.cacheDir, path);
-        this.options.combined = path; // override in the options, so we can log it from the CLI in `cache:generate` command
-        writeFileSync(path, JSON.stringify(this.cache, null, this.pretty ? 2 : undefined));
+        let path = typeof this.#options.combined === 'string' ? this.#options.combined : './metadata.json';
+        path = fs.normalizePath(this.#options.cacheDir, path);
+        this.#options.combined = path; // override in the options, so we can log it from the CLI in `cache:generate` command
+        writeFileSync(path, JSON.stringify(this.#cache, null, this.#pretty ? 2 : undefined));
         return path;
     }
     path(name) {
-        fs.ensureDir(this.options.cacheDir);
-        return `${this.options.cacheDir}/${name}.json`;
+        fs.ensureDir(this.#options.cacheDir);
+        return `${this.#options.cacheDir}/${name}.json`;
     }
     getHash(origin) {
-        origin = fs.absolutePath(origin, this.baseDir);
+        origin = fs.absolutePath(origin, this.#baseDir);
         if (!existsSync(origin)) {
             return null;
         }
         const contents = readFileSync(origin);
-        return Utils.hash(contents.toString() + this.VERSION);
+        return Utils.hash(contents.toString() + this.#VERSION);
     }
 }

package/cache/GeneratedCacheAdapter.d.ts

@@ -1,7 +1,7 @@
 import type { CacheAdapter } from './CacheAdapter.js';
 import type { Dictionary } from '../typings.js';
 export declare class GeneratedCacheAdapter implements CacheAdapter {
-    private readonly data;
+    #private;
     constructor(options: {
         data: Dictionary;
     });

package/cache/GeneratedCacheAdapter.js

@@ -1,32 +1,32 @@
 export class GeneratedCacheAdapter {
-    data = new Map();
+    #data;
     constructor(options) {
-        this.data = new Map(Object.entries(options.data));
+        this.#data = new Map(Object.entries(options.data));
     }
     /**
      * @inheritDoc
      */
     get(name) {
         const key = name.replace(/\.[jt]s$/, '');
-        const data = this.data.get(key);
+        const data = this.#data.get(key);
         return data;
     }
     /**
      * @inheritDoc
      */
     set(name, data, origin) {
-        this.data.set(name, { data });
+        this.#data.set(name, { data });
     }
     /**
      * @inheritDoc
      */
     remove(name) {
-        this.data.delete(name);
+        this.#data.delete(name);
     }
     /**
      * @inheritDoc
      */
     clear() {
-        this.data.clear();
+        this.#data.clear();
     }
 }

package/cache/MemoryCacheAdapter.d.ts

@@ -1,7 +1,6 @@
 import type { CacheAdapter } from './CacheAdapter.js';
 export declare class MemoryCacheAdapter implements CacheAdapter {
-    private readonly options;
-    private readonly data;
+    #private;
     constructor(options: {
         expiration: number;
     });

package/cache/MemoryCacheAdapter.js

@@ -1,17 +1,17 @@
 export class MemoryCacheAdapter {
-    options;
-    data = new Map();
+    #data = new Map();
+    #options;
     constructor(options) {
-        this.options = options;
+        this.#options = options;
     }
     /**
      * @inheritDoc
      */
     get(name) {
-        const data = this.data.get(name);
+        const data = this.#data.get(name);
         if (data) {
             if (data.expiration < Date.now()) {
-                this.data.delete(name);
+                this.#data.delete(name);
             }
             else {
                 return data.data;
@@ -23,18 +23,18 @@ export class MemoryCacheAdapter {
      * @inheritDoc
      */
     set(name, data, origin, expiration) {
-        this.data.set(name, { data, expiration: Date.now() + (expiration ?? this.options.expiration) });
+        this.#data.set(name, { data, expiration: Date.now() + (expiration ?? this.#options.expiration) });
     }
     /**
      * @inheritDoc
      */
     remove(name) {
-        this.data.delete(name);
+        this.#data.delete(name);
     }
     /**
      * @inheritDoc
      */
     clear() {
-        this.data.clear();
+        this.#data.clear();
     }
 }

package/cache/index.d.ts

@@ -1,4 +1,4 @@
-export * from './CacheAdapter.js';
+export type * from './CacheAdapter.js';
 export * from './NullCacheAdapter.js';
 export * from './MemoryCacheAdapter.js';
 export * from './GeneratedCacheAdapter.js';

package/cache/index.js

@@ -1,4 +1,3 @@
-export * from './CacheAdapter.js';
 export * from './NullCacheAdapter.js';
 export * from './MemoryCacheAdapter.js';
 export * from './GeneratedCacheAdapter.js';

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.d.ts

@@ -9,7 +9,6 @@ import type { Platform } from '../platforms/Platform.js';
 import type { Collection } from '../entity/Collection.js';
 import { EntityManager } from '../EntityManager.js';
 import { DriverException } from '../exceptions.js';
-import type { Logger } from '../logging/Logger.js';
 import { MikroORM } from '../MikroORM.js';
 export declare abstract class DatabaseDriver<C extends Connection> implements IDatabaseDriver<C> {
     readonly config: Configuration;
@@ -18,7 +17,6 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     protected readonly connection: C;
     protected readonly replicas: C[];
     protected readonly platform: Platform;
-    protected readonly logger: Logger;
     protected comparator: EntityComparator;
     protected metadata: MetadataStorage;
     protected constructor(config: Configuration, dependencies: string[]);

package/drivers/DatabaseDriver.js

@@ -18,13 +18,11 @@ export class DatabaseDriver {
     connection;
     replicas = [];
     platform;
-    logger;
     comparator;
     metadata;
     constructor(config, dependencies) {
         this.config = config;
         this.dependencies = dependencies;
-        this.logger = this.config.getLogger();
     }
     async nativeUpdateMany(entityName, where, data, options) {
         throw new Error(`Batch updates are not supported by ${this.constructor.name} driver`);
@@ -348,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/entity/Collection.d.ts

@@ -9,17 +9,9 @@ export interface MatchingOptions<T extends object, P extends string = never> ext
     ctx?: Transaction;
 }
 export declare class Collection<T extends object, O extends object = object> {
+    #private;
     readonly owner: O;
     [k: number]: T;
-    protected readonly items: Set<T>;
-    protected initialized: boolean;
-    protected dirty: boolean;
-    protected partial: boolean;
-    protected snapshot: T[] | undefined;
-    private readonly?;
-    protected _count?: number;
-    private _property?;
-    private _populated?;
     constructor(owner: O, items?: T[], initialized?: boolean);
     /**
      * Creates new Collection instance, assigns it to the owning entity and sets the items to it (propagating them to their inverse sides)