@mikro-orm/core 7.0.2-dev.8 → 7.0.2

package/MikroORM.d.ts

@@ -3,7 +3,16 @@ 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>;
 /**
@@ -34,79 +43,101 @@ 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;
-    };
-    readonly driver: Driver;
-    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,41 +5,40 @@ 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.
@@ -70,149 +69,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;
-    driver;
-    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);
+  }
 }