@mikro-orm/core 7.0.0-dev.23 → 7.0.0-dev.231

package/utils/AbstractSchemaGenerator.js

@@ -15,7 +15,7 @@ export class AbstractSchemaGenerator {
         this.platform = this.driver.getPlatform();
         this.connection = this.driver.getConnection();
     }
-    async createSchema(options) {
+    async create(options) {
         this.notImplemented();
     }
     /**
@@ -24,7 +24,7 @@ export 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);
@@ -32,20 +32,22 @@ export class AbstractSchemaGenerator {
         }
         else {
             await this.ensureDatabase();
-            await this.dropSchema(options);
+            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);
+            await this.driver.nativeDelete(meta.class, {}, options);
+        }
+        if (options?.clearIdentityMap ?? true) {
+            this.clearIdentityMap();
         }
-        this.clearIdentityMap();
     }
     clearIdentityMap() {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!this.em) {
             return;
         }
@@ -57,13 +59,13 @@ export 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) {
@@ -88,21 +90,30 @@ export class AbstractSchemaGenerator {
         this.notImplemented();
     }
     getOrderedMetadata(schema) {
-        const metadata = Object.values(this.metadata.getAll()).filter(meta => {
-            const isRootEntity = meta.root.className === meta.className;
-            return isRootEntity && !meta.embeddable && !meta.virtual;
+        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 => calc.addNode(meta.root.className));
+        metadata.forEach(meta => {
+            const nodeId = meta.inheritanceType === 'tpt' && meta.tptParent ? meta._id : meta.root._id;
+            calc.addNode(nodeId);
+        });
         let meta = metadata.pop();
         while (meta) {
-            for (const prop of meta.props) {
-                calc.discoverProperty(prop, meta.root.className);
+            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.find(cls))
+            .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 !== '*';

package/utils/AsyncContext.d.ts

@@ -0,0 +1,6 @@
+export interface AsyncContext<T> {
+    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

@@ -0,0 +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();
+}
+/* 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;
+            }
+        },
+    };
+}
+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();
+}