@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/unit-of-work/index.d.ts

@@ -1,6 +1,6 @@
-export * from './ChangeSet';
-export * from './ChangeSetComputer';
-export * from './ChangeSetPersister';
-export * from './CommitOrderCalculator';
-export * from './UnitOfWork';
-export * from './IdentityMap';
+export * from './ChangeSet.js';
+export * from './ChangeSetComputer.js';
+export * from './ChangeSetPersister.js';
+export * from './CommitOrderCalculator.js';
+export * from './UnitOfWork.js';
+export * from './IdentityMap.js';

package/unit-of-work/index.js

@@ -1,22 +1,6 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ChangeSet"), exports);
-__exportStar(require("./ChangeSetComputer"), exports);
-__exportStar(require("./ChangeSetPersister"), exports);
-__exportStar(require("./CommitOrderCalculator"), exports);
-__exportStar(require("./UnitOfWork"), exports);
-__exportStar(require("./IdentityMap"), exports);
+export * from './ChangeSet.js';
+export * from './ChangeSetComputer.js';
+export * from './ChangeSetPersister.js';
+export * from './CommitOrderCalculator.js';
+export * from './UnitOfWork.js';
+export * from './IdentityMap.js';

package/utils/AbstractSchemaGenerator.d.ts

@@ -1,27 +1,27 @@
-import type { ClearDatabaseOptions, DropSchemaOptions, EntityMetadata, ISchemaGenerator, UpdateSchemaOptions, CreateSchemaOptions, RefreshDatabaseOptions, EnsureDatabaseOptions } from '../typings';
-import type { IDatabaseDriver } from '../drivers/IDatabaseDriver';
-import type { MetadataStorage } from '../metadata/MetadataStorage';
-import type { Configuration } from './Configuration';
+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?: ReturnType<D['createEntityManager']>;
+    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 | ReturnType<D['createEntityManager']>);
-    createSchema(options?: CreateSchemaOptions): Promise<void>;
+    constructor(em: D | D[typeof EntityManagerType]);
+    create(options?: CreateSchemaOptions): Promise<void>;
     /**
      * Returns true if the database was created.
      */
     ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
-    refreshDatabase(options?: RefreshDatabaseOptions): Promise<void>;
-    clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
+    refresh(options?: RefreshDatabaseOptions): Promise<void>;
+    clear(options?: ClearDatabaseOptions): Promise<void>;
     protected clearIdentityMap(): void;
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
-    dropSchema(options?: DropSchemaOptions): Promise<void>;
+    drop(options?: DropSchemaOptions): Promise<void>;
     getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
-    updateSchema(options?: UpdateSchemaOptions): Promise<void>;
+    update(options?: UpdateSchemaOptions): Promise<void>;
     getUpdateSchemaSQL(options?: UpdateSchemaOptions): Promise<string>;
     getUpdateSchemaMigrationSQL(options?: UpdateSchemaOptions): Promise<{
         up: string;

package/utils/AbstractSchemaGenerator.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSchemaGenerator = void 0;
-const CommitOrderCalculator_1 = require("../unit-of-work/CommitOrderCalculator");
-const EntityManager_1 = require("../EntityManager");
-class AbstractSchemaGenerator {
+import { CommitOrderCalculator } from '../unit-of-work/CommitOrderCalculator.js';
+import { EntityManager } from '../EntityManager.js';
+export class AbstractSchemaGenerator {
     em;
     driver;
     config;
@@ -11,14 +8,14 @@ class AbstractSchemaGenerator {
     platform;
     connection;
     constructor(em) {
-        this.em = em instanceof EntityManager_1.EntityManager ? em : undefined;
-        this.driver = em instanceof EntityManager_1.EntityManager ? em.getDriver() : 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 createSchema(options) {
+    async create(options) {
         this.notImplemented();
     }
     /**
@@ -27,7 +24,7 @@ class AbstractSchemaGenerator {
     async ensureDatabase(options) {
         this.notImplemented();
     }
-    async refreshDatabase(options) {
+    async refresh(options) {
         if (options?.dropDb) {
             const name = this.config.get('dbName');
             await this.dropDatabase(name);
@@ -35,20 +32,22 @@ class AbstractSchemaGenerator {
         }
         else {
             await this.ensureDatabase();
-            await this.dropSchema();
+            await this.drop(options);
         }
         if (options?.createSchema !== false) {
-            await this.createSchema(options);
+            await this.create(options);
         }
     }
-    async clearDatabase(options) {
+    async clear(options) {
         for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
             await this.driver.nativeDelete(meta.className, {}, options);
         }
-        this.clearIdentityMap();
+        if (options?.clearIdentityMap ?? true) {
+            this.clearIdentityMap();
+        }
     }
     clearIdentityMap() {
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (!this.em) {
             return;
         }
@@ -60,13 +59,13 @@ class AbstractSchemaGenerator {
     async getCreateSchemaSQL(options) {
         this.notImplemented();
     }
-    async dropSchema(options) {
+    async drop(options) {
         this.notImplemented();
     }
     async getDropSchemaSQL(options) {
         this.notImplemented();
     }
-    async updateSchema(options) {
+    async update(options) {
         this.notImplemented();
     }
     async getUpdateSchemaSQL(options) {
@@ -95,7 +94,7 @@ class AbstractSchemaGenerator {
             const isRootEntity = meta.root.className === meta.className;
             return isRootEntity && !meta.embeddable && !meta.virtual;
         });
-        const calc = new CommitOrderCalculator_1.CommitOrderCalculator();
+        const calc = new CommitOrderCalculator();
         metadata.forEach(meta => calc.addNode(meta.root.className));
         let meta = metadata.pop();
         while (meta) {
@@ -106,10 +105,12 @@ class AbstractSchemaGenerator {
         }
         return calc.sort()
             .map(cls => this.metadata.find(cls))
-            .filter(meta => schema ? [schema, '*'].includes(meta.schema) : meta.schema !== '*');
+            .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`);
     }
 }
-exports.AbstractSchemaGenerator = AbstractSchemaGenerator;