@mikro-orm/core 7.0.4 → 7.0.5-dev.1

package/utils/AbstractSchemaGenerator.d.ts

@@ -1,48 +1,39 @@
-import type {
-  ClearDatabaseOptions,
-  DropSchemaOptions,
-  EntityMetadata,
-  ISchemaGenerator,
-  UpdateSchemaOptions,
-  CreateSchemaOptions,
-  RefreshDatabaseOptions,
-  EnsureDatabaseOptions,
-} from '../typings.js';
+import type { ClearDatabaseOptions, DropSchemaOptions, EntityMetadata, ISchemaGenerator, UpdateSchemaOptions, CreateSchemaOptions, RefreshDatabaseOptions, EnsureDatabaseOptions } from '../typings.js';
 import { type EntityManagerType, type IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { Configuration } from './Configuration.js';
 export declare abstract class AbstractSchemaGenerator<D extends IDatabaseDriver> implements ISchemaGenerator {
-  protected readonly em?: D[typeof EntityManagerType];
-  protected readonly driver: D;
-  protected readonly config: Configuration;
-  protected readonly metadata: MetadataStorage;
-  protected readonly platform: ReturnType<D['getPlatform']>;
-  protected readonly connection: ReturnType<D['getConnection']>;
-  constructor(em: D | D[typeof EntityManagerType]);
-  create(options?: CreateSchemaOptions): Promise<void>;
-  /**
-   * Returns true if the database was created.
-   */
-  ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
-  refresh(options?: RefreshDatabaseOptions): Promise<void>;
-  clear(options?: ClearDatabaseOptions): Promise<void>;
-  protected clearIdentityMap(): void;
-  getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
-  drop(options?: DropSchemaOptions): Promise<void>;
-  getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
-  update(options?: UpdateSchemaOptions): Promise<void>;
-  getUpdateSchemaSQL(options?: UpdateSchemaOptions): Promise<string>;
-  getUpdateSchemaMigrationSQL(options?: UpdateSchemaOptions): Promise<{
-    up: string;
-    down: string;
-  }>;
-  /**
-   * creates new database and connects to it
-   */
-  createDatabase(name?: string): Promise<void>;
-  dropDatabase(name?: string): Promise<void>;
-  execute(query: string): Promise<void>;
-  ensureIndexes(): Promise<void>;
-  protected getOrderedMetadata(schema?: string): EntityMetadata[];
-  protected notImplemented(): never;
+    protected readonly em?: D[typeof EntityManagerType];
+    protected readonly driver: D;
+    protected readonly config: Configuration;
+    protected readonly metadata: MetadataStorage;
+    protected readonly platform: ReturnType<D['getPlatform']>;
+    protected readonly connection: ReturnType<D['getConnection']>;
+    constructor(em: D | D[typeof EntityManagerType]);
+    create(options?: CreateSchemaOptions): Promise<void>;
+    /**
+     * Returns true if the database was created.
+     */
+    ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
+    refresh(options?: RefreshDatabaseOptions): Promise<void>;
+    clear(options?: ClearDatabaseOptions): Promise<void>;
+    protected clearIdentityMap(): void;
+    getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
+    drop(options?: DropSchemaOptions): Promise<void>;
+    getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
+    update(options?: UpdateSchemaOptions): Promise<void>;
+    getUpdateSchemaSQL(options?: UpdateSchemaOptions): Promise<string>;
+    getUpdateSchemaMigrationSQL(options?: UpdateSchemaOptions): Promise<{
+        up: string;
+        down: string;
+    }>;
+    /**
+     * creates new database and connects to it
+     */
+    createDatabase(name?: string): Promise<void>;
+    dropDatabase(name?: string): Promise<void>;
+    execute(query: string): Promise<void>;
+    ensureIndexes(): Promise<void>;
+    protected getOrderedMetadata(schema?: string): EntityMetadata[];
+    protected notImplemented(): never;
 }

package/utils/AbstractSchemaGenerator.js

@@ -1,125 +1,126 @@
 import { CommitOrderCalculator } from '../unit-of-work/CommitOrderCalculator.js';
 import { EntityManager } from '../EntityManager.js';
 export class AbstractSchemaGenerator {
-  em;
-  driver;
-  config;
-  metadata;
-  platform;
-  connection;
-  constructor(em) {
-    this.em = em instanceof EntityManager ? em : undefined;
-    this.driver = em instanceof EntityManager ? em.getDriver() : em;
-    this.config = this.driver.config;
-    this.metadata = this.driver.getMetadata();
-    this.platform = this.driver.getPlatform();
-    this.connection = this.driver.getConnection();
-  }
-  async create(options) {
-    this.notImplemented();
-  }
-  /**
-   * Returns true if the database was created.
-   */
-  async ensureDatabase(options) {
-    this.notImplemented();
-  }
-  async refresh(options) {
-    if (options?.dropDb) {
-      const name = this.config.get('dbName');
-      await this.dropDatabase(name);
-      await this.createDatabase(name);
-    } else {
-      await this.ensureDatabase();
-      await this.drop(options);
-    }
-    if (options?.createSchema !== false) {
-      await this.create(options);
-    }
-  }
-  async clear(options) {
-    for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
-      await this.driver.nativeDelete(meta.class, {}, options);
-    }
-    if (options?.clearIdentityMap ?? true) {
-      this.clearIdentityMap();
-    }
-  }
-  clearIdentityMap() {
-    /* v8 ignore next */
-    if (!this.em) {
-      return;
-    }
-    const allowGlobalContext = this.config.get('allowGlobalContext');
-    this.config.set('allowGlobalContext', true);
-    this.em.clear();
-    this.config.set('allowGlobalContext', allowGlobalContext);
-  }
-  async getCreateSchemaSQL(options) {
-    this.notImplemented();
-  }
-  async drop(options) {
-    this.notImplemented();
-  }
-  async getDropSchemaSQL(options) {
-    this.notImplemented();
-  }
-  async update(options) {
-    this.notImplemented();
-  }
-  async getUpdateSchemaSQL(options) {
-    this.notImplemented();
-  }
-  async getUpdateSchemaMigrationSQL(options) {
-    this.notImplemented();
-  }
-  /**
-   * creates new database and connects to it
-   */
-  async createDatabase(name) {
-    this.notImplemented();
-  }
-  async dropDatabase(name) {
-    this.notImplemented();
-  }
-  async execute(query) {
-    this.notImplemented();
-  }
-  async ensureIndexes() {
-    this.notImplemented();
-  }
-  getOrderedMetadata(schema) {
-    const metadata = [...this.metadata.getAll().values()].filter(meta => {
-      const isRootEntity = meta.root.class === meta.class;
-      const isTPTChild = meta.inheritanceType === 'tpt' && meta.tptParent;
-      return (isRootEntity || isTPTChild) && !meta.embeddable && !meta.virtual;
-    });
-    const calc = new CommitOrderCalculator();
-    metadata.forEach(meta => {
-      const nodeId = meta.inheritanceType === 'tpt' && meta.tptParent ? meta._id : meta.root._id;
-      calc.addNode(nodeId);
-    });
-    let meta = metadata.pop();
-    while (meta) {
-      const nodeId = meta.inheritanceType === 'tpt' && meta.tptParent ? meta._id : meta.root._id;
-      for (const prop of meta.relations) {
-        calc.discoverProperty(prop, nodeId);
-      }
-      if (meta.inheritanceType === 'tpt' && meta.tptParent) {
-        const parentId = meta.tptParent._id;
-        calc.addDependency(parentId, nodeId, 1);
-      }
-      meta = metadata.pop();
-    }
-    return calc
-      .sort()
-      .map(cls => this.metadata.getById(cls))
-      .filter(meta => {
-        const targetSchema = meta.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
-        return schema ? [schema, '*'].includes(targetSchema) : meta.schema !== '*';
-      });
-  }
-  notImplemented() {
-    throw new Error(`This method is not supported by ${this.driver.constructor.name} driver`);
-  }
+    em;
+    driver;
+    config;
+    metadata;
+    platform;
+    connection;
+    constructor(em) {
+        this.em = em instanceof EntityManager ? em : undefined;
+        this.driver = em instanceof EntityManager ? em.getDriver() : em;
+        this.config = this.driver.config;
+        this.metadata = this.driver.getMetadata();
+        this.platform = this.driver.getPlatform();
+        this.connection = this.driver.getConnection();
+    }
+    async create(options) {
+        this.notImplemented();
+    }
+    /**
+     * Returns true if the database was created.
+     */
+    async ensureDatabase(options) {
+        this.notImplemented();
+    }
+    async refresh(options) {
+        if (options?.dropDb) {
+            const name = this.config.get('dbName');
+            await this.dropDatabase(name);
+            await this.createDatabase(name);
+        }
+        else {
+            await this.ensureDatabase();
+            await this.drop(options);
+        }
+        if (options?.createSchema !== false) {
+            await this.create(options);
+        }
+    }
+    async clear(options) {
+        for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
+            await this.driver.nativeDelete(meta.class, {}, options);
+        }
+        if (options?.clearIdentityMap ?? true) {
+            this.clearIdentityMap();
+        }
+    }
+    clearIdentityMap() {
+        /* v8 ignore next */
+        if (!this.em) {
+            return;
+        }
+        const allowGlobalContext = this.config.get('allowGlobalContext');
+        this.config.set('allowGlobalContext', true);
+        this.em.clear();
+        this.config.set('allowGlobalContext', allowGlobalContext);
+    }
+    async getCreateSchemaSQL(options) {
+        this.notImplemented();
+    }
+    async drop(options) {
+        this.notImplemented();
+    }
+    async getDropSchemaSQL(options) {
+        this.notImplemented();
+    }
+    async update(options) {
+        this.notImplemented();
+    }
+    async getUpdateSchemaSQL(options) {
+        this.notImplemented();
+    }
+    async getUpdateSchemaMigrationSQL(options) {
+        this.notImplemented();
+    }
+    /**
+     * creates new database and connects to it
+     */
+    async createDatabase(name) {
+        this.notImplemented();
+    }
+    async dropDatabase(name) {
+        this.notImplemented();
+    }
+    async execute(query) {
+        this.notImplemented();
+    }
+    async ensureIndexes() {
+        this.notImplemented();
+    }
+    getOrderedMetadata(schema) {
+        const metadata = [...this.metadata.getAll().values()].filter(meta => {
+            const isRootEntity = meta.root.class === meta.class;
+            const isTPTChild = meta.inheritanceType === 'tpt' && meta.tptParent;
+            return (isRootEntity || isTPTChild) && !meta.embeddable && !meta.virtual;
+        });
+        const calc = new CommitOrderCalculator();
+        metadata.forEach(meta => {
+            const nodeId = meta.inheritanceType === 'tpt' && meta.tptParent ? meta._id : meta.root._id;
+            calc.addNode(nodeId);
+        });
+        let meta = metadata.pop();
+        while (meta) {
+            const nodeId = meta.inheritanceType === 'tpt' && meta.tptParent ? meta._id : meta.root._id;
+            for (const prop of meta.relations) {
+                calc.discoverProperty(prop, nodeId);
+            }
+            if (meta.inheritanceType === 'tpt' && meta.tptParent) {
+                const parentId = meta.tptParent._id;
+                calc.addDependency(parentId, nodeId, 1);
+            }
+            meta = metadata.pop();
+        }
+        return calc
+            .sort()
+            .map(cls => this.metadata.getById(cls))
+            .filter(meta => {
+            const targetSchema = meta.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
+            return schema ? [schema, '*'].includes(targetSchema) : meta.schema !== '*';
+        });
+    }
+    notImplemented() {
+        throw new Error(`This method is not supported by ${this.driver.constructor.name} driver`);
+    }
 }

package/utils/AsyncContext.d.ts

@@ -1,6 +1,6 @@
 export interface AsyncContext<T> {
-  getStore(): T | undefined;
-  run<R>(store: T, callback: () => R): R;
-  enterWith(store: T): void;
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith(store: T): void;
 }
 export declare function createAsyncContext<T>(): AsyncContext<T>;

package/utils/AsyncContext.js

@@ -1,41 +1,42 @@
 function getNodeAsyncContext() {
-  const mod = globalThis.process?.getBuiltinModule?.('node:async_hooks');
-  /* v8 ignore next */
-  if (!mod?.AsyncLocalStorage) {
-    throw new Error('AsyncLocalStorage not available');
-  }
-  return new mod.AsyncLocalStorage();
+    const mod = globalThis.process?.getBuiltinModule?.('node:async_hooks');
+    /* v8 ignore next */
+    if (!mod?.AsyncLocalStorage) {
+        throw new Error('AsyncLocalStorage not available');
+    }
+    return new mod.AsyncLocalStorage();
 }
 /* v8 ignore next */
 function createFallbackAsyncContext() {
-  let store;
-  // eslint-disable-next-line no-console
-  console.warn('AsyncLocalStorage not available');
-  return {
-    getStore: () => store,
-    enterWith: value => (store = value),
-    run: (value, cb) => {
-      const prev = store;
-      store = value;
-      try {
-        return cb();
-      } finally {
-        store = prev;
-      }
-    },
-  };
+    let store;
+    // eslint-disable-next-line no-console
+    console.warn('AsyncLocalStorage not available');
+    return {
+        getStore: () => store,
+        enterWith: value => (store = value),
+        run: (value, cb) => {
+            const prev = store;
+            store = value;
+            try {
+                return cb();
+            }
+            finally {
+                store = prev;
+            }
+        },
+    };
 }
 export function createAsyncContext() {
-  /* v8 ignore next */
-  const ALS = globalThis.AsyncLocalStorage;
-  /* v8 ignore next */
-  if (typeof ALS === 'function' && ALS.prototype?.run) {
-    return new ALS();
-  }
-  /* v8 ignore else */
-  if (globalThis.process?.versions?.node) {
-    return getNodeAsyncContext();
-  }
-  /* v8 ignore next */
-  return createFallbackAsyncContext();
+    /* v8 ignore next */
+    const ALS = globalThis.AsyncLocalStorage;
+    /* v8 ignore next */
+    if (typeof ALS === 'function' && ALS.prototype?.run) {
+        return new ALS();
+    }
+    /* v8 ignore else */
+    if (globalThis.process?.versions?.node) {
+        return getNodeAsyncContext();
+    }
+    /* v8 ignore next */
+    return createFallbackAsyncContext();
 }