@mikro-orm/core 7.0.2 → 7.0.3-dev.1

package/MikroORM.d.ts

@@ -3,16 +3,7 @@ import { type EntitySchema } from './metadata/EntitySchema.js';
 import { MetadataStorage } from './metadata/MetadataStorage.js';
 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';
+import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
 /** @internal */
 export declare function loadOptionalDependencies(options: Partial<Options>): Promise<void>;
 /**
@@ -43,101 +34,81 @@ export declare function loadOptionalDependencies(options: Partial<Options>): Pro
  * await em.flush();
  * ```
  */
-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;
-  };
-  /** The database driver instance used by this ORM. */
-  readonly driver: Driver;
-  /** The ORM configuration instance. */
-  readonly config: Configuration<Driver>;
-  /**
-   * 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: 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: Partial<Options<Driver, EM, Entities>>);
-  /**
-   * Connects to the database.
-   */
-  connect(): Promise<Driver>;
-  /**
-   * Reconnects, possibly to a different database.
-   */
-  reconnect(options?: Partial<Options<Driver, EM, Entities>>): Promise<void>;
-  /**
-   * Checks whether the database connection is active.
-   */
-  isConnected(): Promise<boolean>;
-  /**
-   * Checks whether the database connection is active, returns the reason if not.
-   */
-  checkConnection(): Promise<
-    | {
+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;
+    };
+    /** The database driver instance used by this ORM. */
+    readonly driver: Driver;
+    /** The ORM configuration instance. */
+    readonly config: Configuration<Driver>;
+    /**
+     * 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: 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: Partial<Options<Driver, EM, Entities>>);
+    /**
+     * Connects to the database.
+     */
+    connect(): Promise<Driver>;
+    /**
+     * Reconnects, possibly to a different database.
+     */
+    reconnect(options?: Partial<Options<Driver, EM, Entities>>): Promise<void>;
+    /**
+     * Checks whether the database connection is active.
+     */
+    isConnected(): Promise<boolean>;
+    /**
+     * Checks whether the database connection is active, returns the reason if not.
+     */
+    checkConnection(): Promise<{
         ok: true;
-      }
-    | {
+    } | {
         ok: false;
         reason: string;
         error?: Error;
-      }
-  >;
-  /**
-   * Closes the database connection.
-   */
-  close(force?: boolean): Promise<void>;
-  /**
-   * Gets the `MetadataStorage`.
-   */
-  getMetadata(): MetadataStorage;
-  /**
-   * Gets the `EntityMetadata` instance when provided with the `entityName` parameter.
-   */
-  getMetadata<Entity extends object>(entityName: EntityName<Entity>): EntityMetadata<Entity>;
-  private createEntityManager;
-  /**
-   * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
-   */
-  discoverEntity<T extends Constructor | EntitySchema>(entities: T | T[], reset?: EntityName | EntityName[]): void;
-  /**
-   * Gets the SchemaGenerator.
-   */
-  get schema(): ReturnType<ReturnType<Driver['getPlatform']>['getSchemaGenerator']>;
-  /**
-   * Gets the SeedManager
-   */
-  get seeder(): ISeedManager;
-  /**
-   * Gets the Migrator.
-   */
-  get migrator(): IMigrator;
-  /**
-   * Gets the EntityGenerator.
-   */
-  get entityGenerator(): IEntityGenerator;
+    }>;
+    /**
+     * Closes the database connection.
+     */
+    close(force?: boolean): Promise<void>;
+    /**
+     * Gets the `MetadataStorage`.
+     */
+    getMetadata(): MetadataStorage;
+    /**
+     * Gets the `EntityMetadata` instance when provided with the `entityName` parameter.
+     */
+    getMetadata<Entity extends object>(entityName: EntityName<Entity>): EntityMetadata<Entity>;
+    private createEntityManager;
+    /**
+     * Allows dynamically discovering new entity by reference, handy for testing schema diffing.
+     */
+    discoverEntity<T extends Constructor | EntitySchema>(entities: T | T[], reset?: EntityName | EntityName[]): void;
+    /**
+     * Gets the SchemaGenerator.
+     */
+    get schema(): ReturnType<ReturnType<Driver['getPlatform']>['getSchemaGenerator']>;
+    /**
+     * Gets the SeedManager
+     */
+    get seeder(): ISeedManager;
+    /**
+     * Gets the Migrator.
+     */
+    get migrator(): IMigrator;
+    /**
+     * Gets the EntityGenerator.
+     */
+    get entityGenerator(): IEntityGenerator;
 }

package/MikroORM.js

@@ -5,40 +5,41 @@ import { loadEnvironmentVars } from './utils/env-vars.js';
 import { Utils } from './utils/Utils.js';
 import { colors } from './logging/colors.js';
 async function tryRegisterExtension(name, pkg, extensions) {
-  try {
-    const url = import.meta.resolve(pkg);
-    const mod = await import(url);
-    if (mod[name]) {
-      extensions.push(mod[name]);
-    }
-  } catch {
-    // not installed
-  }
+    try {
+        const url = import.meta.resolve(pkg);
+        const mod = await import(url);
+        if (mod[name]) {
+            extensions.push(mod[name]);
+        }
+    }
+    catch {
+        // not installed
+    }
 }
 /** @internal */
 export async function loadOptionalDependencies(options) {
-  await import('@mikro-orm/core/fs-utils').then(m => m.fs.init()).catch(() => null);
-  const extensions = options.extensions ?? [];
-  const exists = name => extensions.some(ext => ext.name === name);
-  if (!exists('SeedManager')) {
-    await tryRegisterExtension('SeedManager', '@mikro-orm/seeder', extensions);
-  }
-  if (!exists('Migrator')) {
-    await tryRegisterExtension('Migrator', '@mikro-orm/migrations', extensions);
-  }
-  /* v8 ignore if */
-  if (!exists('Migrator')) {
-    await tryRegisterExtension('Migrator', '@mikro-orm/migrations-mongodb', extensions);
-  }
-  if (!exists('EntityGenerator')) {
-    await tryRegisterExtension('EntityGenerator', '@mikro-orm/entity-generator', extensions);
-  }
-  options.extensions = extensions;
-  const metadataCacheEnabled = options.metadataCache?.enabled || options.metadataProvider?.useCache?.();
-  if (metadataCacheEnabled) {
-    options.metadataCache ??= {};
-    options.metadataCache.adapter ??= await import('@mikro-orm/core/fs-utils').then(m => m.FileCacheAdapter);
-  }
+    await import('@mikro-orm/core/fs-utils').then(m => m.fs.init()).catch(() => null);
+    const extensions = options.extensions ?? [];
+    const exists = (name) => extensions.some(ext => ext.name === name);
+    if (!exists('SeedManager')) {
+        await tryRegisterExtension('SeedManager', '@mikro-orm/seeder', extensions);
+    }
+    if (!exists('Migrator')) {
+        await tryRegisterExtension('Migrator', '@mikro-orm/migrations', extensions);
+    }
+    /* v8 ignore if */
+    if (!exists('Migrator')) {
+        await tryRegisterExtension('Migrator', '@mikro-orm/migrations-mongodb', extensions);
+    }
+    if (!exists('EntityGenerator')) {
+        await tryRegisterExtension('EntityGenerator', '@mikro-orm/entity-generator', extensions);
+    }
+    options.extensions = extensions;
+    const metadataCacheEnabled = options.metadataCache?.enabled || options.metadataProvider?.useCache?.();
+    if (metadataCacheEnabled) {
+        options.metadataCache ??= {};
+        options.metadataCache.adapter ??= await import('@mikro-orm/core/fs-utils').then(m => m.FileCacheAdapter);
+    }
 }
 /**
  * The main class used to configure and bootstrap the ORM.
@@ -69,151 +70,151 @@ export async function loadOptionalDependencies(options) {
  * ```
  */
 export class MikroORM {
-  /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
-  em;
-  /** The database driver instance used by this ORM. */
-  driver;
-  /** The ORM configuration instance. */
-  config;
-  #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.
-   */
-  static async init(options) {
-    /* v8 ignore next */
-    if (!options) {
-      throw new Error(`options parameter is required`);
-    }
-    options = { ...options };
-    options.discovery ??= {};
-    options.discovery.skipSyncDiscovery ??= true;
-    await loadOptionalDependencies(options);
-    const orm = new this(options);
-    const preferTs = orm.config.get('preferTs', Utils.detectTypeScriptSupport());
-    orm.#metadata = await orm.#discovery.discover(preferTs);
-    orm.createEntityManager();
-    return orm;
-  }
-  /**
-   * 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) {
-    const env = loadEnvironmentVars();
-    options = options.preferEnvVars ? Utils.merge(options, env) : Utils.merge(env, options);
-    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.driver.getPlatform().init(this);
-    for (const extension of this.config.get('extensions')) {
-      extension.register(this);
-    }
-    if (!discovery.skipSyncDiscovery) {
-      this.#metadata = this.#discovery.discoverSync();
-      this.createEntityManager();
-    }
-  }
-  /**
-   * Connects to the database.
-   */
-  async connect() {
-    await this.driver.connect();
-    return this.driver;
-  }
-  /**
-   * Reconnects, possibly to a different database.
-   */
-  async reconnect(options = {}) {
-    /* v8 ignore next */
-    for (const key of Utils.keys(options)) {
-      this.config.set(key, options[key]);
-    }
-    await this.driver.reconnect();
-  }
-  /**
-   * Checks whether the database connection is active.
-   */
-  async isConnected() {
-    return this.driver.getConnection().isConnected();
-  }
-  /**
-   * Checks whether the database connection is active, returns the reason if not.
-   */
-  async checkConnection() {
-    return this.driver.getConnection().checkConnection();
-  }
-  /**
-   * Closes the database connection.
-   */
-  async close(force = false) {
-    await this.driver.close(force);
-    await this.config.getMetadataCacheAdapter()?.close?.();
-    await this.config.getResultCacheAdapter()?.close?.();
-  }
-  /**
-   * Gets the `MetadataStorage` (without parameters) or `EntityMetadata` instance when provided with the `entityName` parameter.
-   */
-  getMetadata(entityName) {
-    if (entityName) {
-      return this.#metadata.get(entityName);
-    }
-    return this.#metadata;
-  }
-  createEntityManager() {
-    this.driver.setMetadata(this.#metadata);
-    this.em = this.driver.createEntityManager();
-    this.em.global = true;
-    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);
-    }
-    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.decorate(this.em);
-  }
-  /**
-   * Gets the SchemaGenerator.
-   */
-  get schema() {
-    return this.config.getExtension('@mikro-orm/schema-generator');
-  }
-  /**
-   * Gets the SeedManager
-   */
-  get seeder() {
-    return this.driver.getPlatform().getExtension('SeedManager', '@mikro-orm/seeder', '@mikro-orm/seeder', this.em);
-  }
-  /**
-   * Gets the Migrator.
-   */
-  get migrator() {
-    return this.driver.getPlatform().getExtension('Migrator', '@mikro-orm/migrator', '@mikro-orm/migrations', this.em);
-  }
-  /**
-   * Gets the EntityGenerator.
-   */
-  get entityGenerator() {
-    return this.driver
-      .getPlatform()
-      .getExtension('EntityGenerator', '@mikro-orm/entity-generator', '@mikro-orm/entity-generator', this.em);
-  }
+    /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
+    em;
+    /** The database driver instance used by this ORM. */
+    driver;
+    /** The ORM configuration instance. */
+    config;
+    #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.
+     */
+    static async init(options) {
+        /* v8 ignore next */
+        if (!options) {
+            throw new Error(`options parameter is required`);
+        }
+        options = { ...options };
+        options.discovery ??= {};
+        options.discovery.skipSyncDiscovery ??= true;
+        await loadOptionalDependencies(options);
+        const orm = new this(options);
+        const preferTs = orm.config.get('preferTs', Utils.detectTypeScriptSupport());
+        orm.#metadata = await orm.#discovery.discover(preferTs);
+        orm.createEntityManager();
+        return orm;
+    }
+    /**
+     * 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) {
+        const env = loadEnvironmentVars();
+        options = options.preferEnvVars ? Utils.merge(options, env) : Utils.merge(env, options);
+        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.driver.getPlatform().init(this);
+        for (const extension of this.config.get('extensions')) {
+            extension.register(this);
+        }
+        if (!discovery.skipSyncDiscovery) {
+            this.#metadata = this.#discovery.discoverSync();
+            this.createEntityManager();
+        }
+    }
+    /**
+     * Connects to the database.
+     */
+    async connect() {
+        await this.driver.connect();
+        return this.driver;
+    }
+    /**
+     * Reconnects, possibly to a different database.
+     */
+    async reconnect(options = {}) {
+        /* v8 ignore next */
+        for (const key of Utils.keys(options)) {
+            this.config.set(key, options[key]);
+        }
+        await this.driver.reconnect();
+    }
+    /**
+     * Checks whether the database connection is active.
+     */
+    async isConnected() {
+        return this.driver.getConnection().isConnected();
+    }
+    /**
+     * Checks whether the database connection is active, returns the reason if not.
+     */
+    async checkConnection() {
+        return this.driver.getConnection().checkConnection();
+    }
+    /**
+     * Closes the database connection.
+     */
+    async close(force = false) {
+        await this.driver.close(force);
+        await this.config.getMetadataCacheAdapter()?.close?.();
+        await this.config.getResultCacheAdapter()?.close?.();
+    }
+    /**
+     * Gets the `MetadataStorage` (without parameters) or `EntityMetadata` instance when provided with the `entityName` parameter.
+     */
+    getMetadata(entityName) {
+        if (entityName) {
+            return this.#metadata.get(entityName);
+        }
+        return this.#metadata;
+    }
+    createEntityManager() {
+        this.driver.setMetadata(this.#metadata);
+        this.em = this.driver.createEntityManager();
+        this.em.global = true;
+        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);
+        }
+        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.decorate(this.em);
+    }
+    /**
+     * Gets the SchemaGenerator.
+     */
+    get schema() {
+        return this.config.getExtension('@mikro-orm/schema-generator');
+    }
+    /**
+     * Gets the SeedManager
+     */
+    get seeder() {
+        return this.driver.getPlatform().getExtension('SeedManager', '@mikro-orm/seeder', '@mikro-orm/seeder', this.em);
+    }
+    /**
+     * Gets the Migrator.
+     */
+    get migrator() {
+        return this.driver.getPlatform().getExtension('Migrator', '@mikro-orm/migrator', '@mikro-orm/migrations', this.em);
+    }
+    /**
+     * Gets the EntityGenerator.
+     */
+    get entityGenerator() {
+        return this.driver
+            .getPlatform()
+            .getExtension('EntityGenerator', '@mikro-orm/entity-generator', '@mikro-orm/entity-generator', this.em);
+    }
 }

package/cache/CacheAdapter.d.ts

@@ -1,42 +1,42 @@
 /** Interface for async-capable cache storage used by result cache and metadata cache. */
 export interface CacheAdapter {
-  /**
-   * Gets the items under `name` key from the cache.
-   */
-  get<T = any>(name: string): T | Promise<T | undefined> | undefined;
-  /**
-   * Sets the item to the cache. `origin` is used for cache invalidation and should reflect the change in data.
-   */
-  set(name: string, data: any, origin: string, expiration?: number): void | Promise<void>;
-  /**
-   * Removes the item from cache.
-   */
-  remove(name: string): void | Promise<void>;
-  /**
-   * Clears all items stored in the cache.
-   */
-  clear(): void | Promise<void>;
-  /**
-   * Called inside `MikroORM.close()` Allows graceful shutdowns (e.g. for redis).
-   */
-  close?(): void | Promise<void>;
+    /**
+     * Gets the items under `name` key from the cache.
+     */
+    get<T = any>(name: string): T | Promise<T | undefined> | undefined;
+    /**
+     * Sets the item to the cache. `origin` is used for cache invalidation and should reflect the change in data.
+     */
+    set(name: string, data: any, origin: string, expiration?: number): void | Promise<void>;
+    /**
+     * Removes the item from cache.
+     */
+    remove(name: string): void | Promise<void>;
+    /**
+     * Clears all items stored in the cache.
+     */
+    clear(): void | Promise<void>;
+    /**
+     * Called inside `MikroORM.close()` Allows graceful shutdowns (e.g. for redis).
+     */
+    close?(): void | Promise<void>;
 }
 /** Synchronous variant of CacheAdapter, used for metadata cache where async access is not needed. */
 export interface SyncCacheAdapter extends CacheAdapter {
-  /**
-   * Gets the items under `name` key from the cache.
-   */
-  get<T = any>(name: string): T | undefined;
-  /**
-   * Sets the item to the cache. `origin` is used for cache invalidation and should reflect the change in data.
-   */
-  set(name: string, data: any, origin: string, expiration?: number): void;
-  /**
-   * Removes the item from cache.
-   */
-  remove(name: string): void;
-  /**
-   * Generates a combined cache from all existing entries.
-   */
-  combine?(): string | void;
+    /**
+     * Gets the items under `name` key from the cache.
+     */
+    get<T = any>(name: string): T | undefined;
+    /**
+     * Sets the item to the cache. `origin` is used for cache invalidation and should reflect the change in data.
+     */
+    set(name: string, data: any, origin: string, expiration?: number): void;
+    /**
+     * Removes the item from cache.
+     */
+    remove(name: string): void;
+    /**
+     * Generates a combined cache from all existing entries.
+     */
+    combine?(): string | void;
 }