@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/cache/FileCacheAdapter.js

@@ -1,18 +1,17 @@
-import { globSync } from 'tinyglobby';
 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;
-    hashAlgorithm;
-    VERSION = Utils.getORMVersion();
-    cache = {};
-    constructor(options, baseDir, pretty = false, hashAlgorithm = 'md5') {
-        this.options = options;
-        this.baseDir = baseDir;
-        this.pretty = pretty;
-        this.hashAlgorithm = hashAlgorithm;
+    #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';
     }
     /**
      * @inheritDoc
@@ -22,7 +21,7 @@ export class FileCacheAdapter {
         if (!existsSync(path)) {
             return null;
         }
-        const payload = Utils.readJSONSync(path);
+        const payload = fs.readJSONSync(path);
         const hash = this.getHash(payload.origin);
         if (!hash || payload.hash !== hash) {
             return null;
@@ -33,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
@@ -53,32 +52,38 @@ export class FileCacheAdapter {
      */
     clear() {
         const path = this.path('*');
-        const files = globSync(path);
-        files.forEach(file => unlinkSync(file));
-        this.cache = {};
+        const files = fs.glob(path);
+        for (const file of files) {
+            /* v8 ignore next */
+            try {
+                unlinkSync(file);
+            }
+            catch {
+                // ignore if file is already gone
+            }
+        }
+        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 = Utils.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) {
-        Utils.ensureDir(this.options.cacheDir);
-        return `${this.options.cacheDir}/${name}.json`;
+        fs.ensureDir(this.#options.cacheDir);
+        return `${this.#options.cacheDir}/${name}.json`;
     }
     getHash(origin) {
-        origin = Utils.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, undefined, this.hashAlgorithm);
+        return Utils.hash(contents.toString() + this.#VERSION);
     }
 }

package/cache/GeneratedCacheAdapter.d.ts

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

package/cache/GeneratedCacheAdapter.js

@@ -1,34 +1,32 @@
 export class GeneratedCacheAdapter {
-    options;
-    data = new Map();
+    #data;
     constructor(options) {
-        this.options = 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,5 +1,4 @@
-export * from './CacheAdapter.js';
+export type * from './CacheAdapter.js';
 export * from './NullCacheAdapter.js';
-export * from './FileCacheAdapter.js';
 export * from './MemoryCacheAdapter.js';
 export * from './GeneratedCacheAdapter.js';

package/cache/index.js

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

package/connections/Connection.d.ts

@@ -17,7 +17,9 @@ export declare abstract class Connection {
     /**
      * Establishes connection to database
      */
-    abstract connect(): void | Promise<void>;
+    abstract connect(options?: {
+        skipOnConnect?: boolean;
+    }): void | Promise<void>;
     /**
      * Are we connected to the database
      */
@@ -37,18 +39,24 @@ export declare abstract class Connection {
      */
     close(force?: boolean): Promise<void>;
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     ensureConnection(): Promise<void>;
+    /**
+     * Execute raw SQL queries, handy from running schema dump loaded from a file.
+     * This method doesn't support transactions, as opposed to `orm.schema.execute()`, which is used internally.
+     */
+    executeDump(dump: string): Promise<void>;
+    protected onConnect(): Promise<void>;
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
     }): Promise<T>;
     begin(options?: {
-        isolationLevel?: IsolationLevel;
+        isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
@@ -58,7 +66,6 @@ export declare abstract class Connection {
     rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
     abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
     getConnectionOptions(): ConnectionConfig;
-    getClientUrl(): string;
     setMetadata(metadata: MetadataStorage): void;
     setPlatform(platform: Platform): void;
     getPlatform(): Platform;

package/connections/Connection.js

@@ -1,4 +1,3 @@
-import { URL } from 'node:url';
 import { Utils } from '../utils/Utils.js';
 export class Connection {
     config;
@@ -17,7 +16,18 @@ export class Connection {
             this.options = Utils.copy(options);
         }
         else {
-            const props = ['dbName', 'clientUrl', 'host', 'port', 'user', 'password', 'multipleStatements', 'pool', 'schema', 'driverOptions'];
+            const props = [
+                'dbName',
+                'clientUrl',
+                'host',
+                'port',
+                'user',
+                'password',
+                'multipleStatements',
+                'pool',
+                'schema',
+                'driverOptions',
+            ];
             this.options = props.reduce((o, i) => {
                 o[i] = this.config.get(i);
                 return o;
@@ -33,13 +43,32 @@ export class Connection {
             .forEach(k => delete this.options[k]);
     }
     /**
-     * Ensure the connection exists, this is used to support lazy connect when using `MikroORM.initSync()`
+     * Ensure the connection exists, this is used to support lazy connect when using `new MikroORM()` instead of the async `init` method.
      */
     async ensureConnection() {
         if (!this.connected) {
             await this.connect();
         }
     }
+    /**
+     * Execute raw SQL queries, handy from running schema dump loaded from a file.
+     * This method doesn't support transactions, as opposed to `orm.schema.execute()`, which is used internally.
+     */
+    async executeDump(dump) {
+        throw new Error(`Executing SQL dumps is not supported by current driver`);
+    }
+    async onConnect() {
+        const schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
+        if (this.type === 'write' && schemaGenerator) {
+            if (this.config.get('ensureDatabase')) {
+                const options = this.config.get('ensureDatabase');
+                await schemaGenerator.ensureDatabase(typeof options === 'boolean' ? {} : { ...options, forceCheck: true });
+            }
+            if (this.config.get('ensureIndexes')) {
+                await schemaGenerator.ensureIndexes();
+            }
+        }
+    }
     async transactional(cb, options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
@@ -67,24 +96,17 @@ export class Connection {
             }
         }
         else {
-            const url = new URL(this.config.getClientUrl());
+            const url = new URL(this.config.get('clientUrl'));
             this.options.host = ret.host = this.options.host ?? this.config.get('host', decodeURIComponent(url.hostname));
             this.options.port = ret.port = this.options.port ?? this.config.get('port', +url.port);
             this.options.user = ret.user = this.options.user ?? this.config.get('user', decodeURIComponent(url.username));
-            this.options.password = ret.password = this.options.password ?? this.config.get('password', decodeURIComponent(url.password));
-            this.options.dbName = ret.database = this.options.dbName ?? this.config.get('dbName', decodeURIComponent(url.pathname).replace(/^\//, ''));
+            this.options.password = ret.password =
+                this.options.password ?? this.config.get('password', decodeURIComponent(url.password));
+            this.options.dbName = ret.database =
+                this.options.dbName ?? this.config.get('dbName', decodeURIComponent(url.pathname).replace(/^\//, ''));
         }
         return ret;
     }
-    getClientUrl() {
-        const options = this.getConnectionOptions();
-        const url = new URL(this.config.getClientUrl(true));
-        const password = options.password ? ':*****' : '';
-        const schema = options.schema && options.schema !== this.platform.getDefaultSchemaName()
-            ? `?schema=${options.schema}`
-            : '';
-        return `${url.protocol}//${options.user}${password}@${options.host}:${options.port}${schema}`;
-    }
     setMetadata(metadata) {
         this.metadata = metadata;
     }

package/drivers/DatabaseDriver.d.ts

@@ -1,5 +1,5 @@
-import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition } from './IDatabaseDriver.js';
-import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
+import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition, type StreamOptions } from './IDatabaseDriver.js';
+import type { ConnectionType, Constructor, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import { type Configuration, type ConnectionOptions } from '../utils/Configuration.js';
@@ -9,7 +9,7 @@ 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;
     protected readonly dependencies: string[];
@@ -17,33 +17,37 @@ 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[]);
-    abstract find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
-    abstract findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
-    abstract nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    abstract nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
-    abstract nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
-    abstract nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
-    abstract count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
+    abstract find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    abstract findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    abstract nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    abstract nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
+    abstract nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    abstract nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
+    abstract count<T extends object, P extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
-    countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
-    aggregate(entityName: string, pipeline: any[]): Promise<any[]>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    countVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
+    aggregate(entityName: EntityName, pipeline: any[]): Promise<any[]>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
     mapResult<T extends object>(result: EntityDictionary<T>, meta?: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
-    connect(): Promise<C>;
-    reconnect(): Promise<C>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     close(force?: boolean): Promise<void>;
     getPlatform(): Platform;
     setMetadata(metadata: MetadataStorage): void;
     getMetadata(): MetadataStorage;
     getDependencies(): string[];
+    protected isPopulated<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>, hint: PopulateOptions<T>, name?: string): boolean;
     protected processCursorOptions<T extends object, P extends string>(meta: EntityMetadata<T>, options: FindOptions<T, P, any, any>, orderBy: OrderDefinition<T>): {
         orderBy: OrderDefinition<T>[];
         where: FilterQuery<T>;
@@ -52,9 +56,10 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     /** @internal */
     mapDataToFieldNames(data: Dictionary, stringifyJsonArrays: boolean, properties?: Record<string, EntityProperty>, convertCustomTypes?: boolean, object?: boolean): Dictionary;
     protected inlineEmbeddables<T extends object>(meta: EntityMetadata<T>, data: T, where?: boolean): void;
-    protected getPrimaryKeyFields(entityName: string): string[];
+    protected getPrimaryKeyFields<T>(meta: EntityMetadata<T>): string[];
     protected createReplicas(cb: (c: ConnectionOptions) => C): C[];
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    abstract stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     /**
      * @inheritDoc
      */
@@ -71,4 +76,6 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
         schema?: string;
         parentSchema?: string;
     }): string | undefined;
+    /** @internal */
+    getORMClass(): Constructor<MikroORM>;
 }