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

package/utils/AbstractSchemaGenerator.d.ts

@@ -1,39 +1,48 @@
-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,126 +1,125 @@
 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,42 +1,41 @@
 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();
 }