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

package/EntityManager.js

@@ -136,6 +136,7 @@ export class EntityManager {
             await em.#entityLoader.populate(entityName, cached.data, populate, {
                 ...options,
                 ...em.getPopulateWhere(where, options),
+                orderBy: options.populateOrderBy ?? options.orderBy,
                 ignoreLazyScalarProperties: true,
                 lookup: false,
             });
@@ -166,6 +167,7 @@ export class EntityManager {
         await em.#entityLoader.populate(entityName, unique, populate, {
             ...options,
             ...em.getPopulateWhere(where, options),
+            orderBy: options.populateOrderBy ?? options.orderBy,
             ignoreLazyScalarProperties: true,
             lookup: false,
         });

package/metadata/MetadataDiscovery.js

@@ -1394,7 +1394,10 @@ export class MetadataDiscovery {
             // The primary key column is shared by every subtype, so it stays NOT NULL —
             // only subtype-specific columns become nullable for the rows of other subtypes.
             newProp.nullable = !newProp.primary;
-            newProp.inherited = !rootProp;
+            // A subtype-specific property is `inherited` on the root so it is not pushed down to
+            // sibling subtypes that don't declare it. When a second child redeclares the same
+            // property, the root prop was already marked inherited by the first child, so keep it.
+            newProp.inherited = !rootProp || !!rootProp.inherited;
             // For narrowed relation overrides, keep the root's declaration intact so
             // the full target union (e.g. `Food`) is preserved for populates from the
             // abstract root — otherwise the last child processed would win.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.1.5-dev.8",
+  "version": "7.1.5",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/unit-of-work/UnitOfWork.js

@@ -993,21 +993,21 @@ export class UnitOfWork {
         const commitOrderReversed = [...commitOrder].reverse();
         // early delete - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
         for (const meta of commitOrderReversed) {
-            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE_EARLY].get(meta) ?? [], ctx);
+            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE_EARLY].get(meta._id) ?? [], ctx);
         }
         // early update - when we recreate entity in the same UoW, we need to issue those delete queries before inserts
         for (const meta of commitOrder) {
-            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE_EARLY].get(meta) ?? [], ctx);
+            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE_EARLY].get(meta._id) ?? [], ctx);
         }
         // extra updates
         await this.commitExtraUpdates(ChangeSetType.UPDATE_EARLY, ctx);
         // create
         for (const meta of commitOrder) {
-            await this.commitCreateChangeSets(groups[ChangeSetType.CREATE].get(meta) ?? [], ctx);
+            await this.commitCreateChangeSets(groups[ChangeSetType.CREATE].get(meta._id) ?? [], ctx);
         }
         // update
         for (const meta of commitOrder) {
-            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE].get(meta) ?? [], ctx);
+            await this.commitUpdateChangeSets(groups[ChangeSetType.UPDATE].get(meta._id) ?? [], ctx);
         }
         // extra updates
         await this.commitExtraUpdates(ChangeSetType.UPDATE, ctx);
@@ -1015,7 +1015,7 @@ export class UnitOfWork {
         await this.commitCollectionUpdates(ctx);
         // delete - entity deletions need to be in reverse commit order
         for (const meta of commitOrderReversed) {
-            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE].get(meta) ?? [], ctx);
+            await this.commitDeleteChangeSets(groups[ChangeSetType.DELETE].get(meta._id) ?? [], ctx);
         }
         // take snapshots of all persisted collections
         const visited = new Set();
@@ -1209,7 +1209,10 @@ export class UnitOfWork {
                 return;
             }
             const group = groups[cs.type];
-            const groupKey = cs.meta.inheritanceType === 'tpt' ? cs.meta : cs.rootMeta;
+            // keyed by `_id` so the groups share keys with `getCommitOrder()`, which dedupes by `_id`;
+            // two `EntityMetadata` instances with the same `_id` (shared metadata cache) must not split
+            // a group between them, or the lookup in `persistToDatabase()` misses and drops it (GH #7903)
+            const groupKey = cs.meta.inheritanceType === 'tpt' ? cs.meta._id : cs.rootMeta._id;
             const classGroup = group.get(groupKey) ?? [];
             classGroup.push(cs);
             if (!group.has(groupKey)) {

package/utils/AbstractSchemaGenerator.d.ts

@@ -35,5 +35,7 @@ export declare abstract class AbstractSchemaGenerator<D extends IDatabaseDriver>
     execute(query: string): Promise<void>;
     ensureIndexes(): Promise<void>;
     protected getOrderedMetadata(schema?: string, includeWildcardSchema?: boolean): EntityMetadata[];
+    /** View entities are not backed by real tables, so they must be skipped when truncating/deleting during `clear()`. */
+    protected getOrderedMetadataForClear(schema?: string): EntityMetadata[];
     protected notImplemented(): never;
 }

package/utils/AbstractSchemaGenerator.js

@@ -39,7 +39,7 @@ export class AbstractSchemaGenerator {
         }
     }
     async clear(options) {
-        for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
+        for (const meta of this.getOrderedMetadataForClear(options?.schema).reverse()) {
             await this.driver.nativeDelete(meta.class, {}, options);
         }
         if (options?.clearIdentityMap ?? true) {
@@ -123,6 +123,10 @@ export class AbstractSchemaGenerator {
             return schema ? [schema, '*'].includes(targetSchema) : meta.schema !== '*';
         });
     }
+    /** View entities are not backed by real tables, so they must be skipped when truncating/deleting during `clear()`. */
+    getOrderedMetadataForClear(schema) {
+        return this.getOrderedMetadata(schema).filter(meta => !meta.view);
+    }
     notImplemented() {
         throw new Error(`This method is not supported by ${this.driver.constructor.name} driver`);
     }

package/utils/EntityComparator.js

@@ -549,7 +549,13 @@ export class EntityComparator {
     }
     getPropertySnapshot(meta, prop, context, dataKey, entityKey, path, level = 1, object) {
         const unwrap = prop.ref ? '?.unwrap()' : '';
-        let ret = `  if (${this.getPropertyCondition(path)}`;
+        let condition = this.getPropertyCondition(path);
+        // a getter may dereference state that only exists once hydrated, so when snapshotting an
+        // unhydrated reference we short-circuit the read behind the initialized check
+        if (prop.getter && !prop.setter && path.length === 1) {
+            condition = `entity.__helper.__initialized && ${condition}`;
+        }
+        let ret = `  if (${condition}`;
         if (prop.lazy && prop.ref) {
             ret += ` && entity${path.map(k => this.wrap(k)).join('')}?.isInitialized()`;
         }

package/utils/RequestContext.d.ts

@@ -1,5 +1,4 @@
-import type { EntityManager } from '../EntityManager.js';
-import { type LoggingOptions } from '../logging/Logger.js';
+import type { EntityManager, ForkOptions } from '../EntityManager.js';
 /**
  * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
  */
@@ -35,8 +34,6 @@ export declare class RequestContext {
     static getEntityManager(name?: string): EntityManager | undefined;
     private static createContext;
 }
-/** Options for creating a new RequestContext, allowing schema and logger overrides. */
-export interface CreateContextOptions {
-    schema?: string;
-    loggerContext?: LoggingOptions;
+/** Options for creating a new RequestContext, allowing global overrides. */
+export interface CreateContextOptions extends Omit<ForkOptions, 'useContext' | 'disableContextResolution' | 'keepTransactionContext' | 'clear'> {
 }

package/utils/Utils.js

@@ -141,7 +141,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.1.5-dev.8';
+    static #ORM_VERSION = '7.1.5';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

package/utils/clone.js

@@ -33,6 +33,12 @@ export function clone(parent, respectCustomCloneMethod = true) {
             return parent;
         }
         if (respectCustomCloneMethod && 'clone' in parent && typeof parent.clone === 'function') {
+            // an async `clone()` signals a live stateful resource (e.g. a PGlite instance
+            // in `driverOptions`, whose `clone()` boots a second WASM database) — this sync
+            // function cannot await it, so keep the instance by reference instead
+            if (parent.clone.constructor.name === 'AsyncFunction') {
+                return parent;
+            }
             return parent.clone();
         }
         let child;