@mikro-orm/core 7.0.11-dev.9 → 7.0.12-dev.0

package/drivers/IDatabaseDriver.d.ts

@@ -248,6 +248,7 @@ export interface NativeInsertUpdateOptions<T> {
     /** `nativeUpdate()` only option */
     upsert?: boolean;
     loggerContext?: LogContext;
+    logging?: LoggingOptions;
     /** sql only */
     unionWhere?: ObjectQuery<T>[];
     /** sql only */
@@ -310,6 +311,8 @@ export interface UpdateOptions<T> {
     filters?: FilterOptions;
     schema?: string;
     ctx?: Transaction;
+    loggerContext?: LogContext;
+    logging?: LoggingOptions;
     /** sql only */
     unionWhere?: ObjectQuery<T>[];
     /** sql only */
@@ -347,6 +350,7 @@ export interface DriverMethodOptions {
     ctx?: Transaction;
     schema?: string;
     loggerContext?: LogContext;
+    logging?: LoggingOptions;
 }
 /** MongoDB-style collation options for locale-aware string comparison. */
 export interface CollationOptions {

package/entity/EntityLoader.js

@@ -555,7 +555,12 @@ export class EntityLoader {
         };
         if (prop.polymorphic && prop.polymorphTargets) {
             await Promise.all(prop.polymorphTargets.map(async (targetMeta) => {
-                const targetChildren = unique.filter(child => helper(child).__meta.className === targetMeta.className);
+                const targetChildren = unique.filter(child => {
+                    const childMeta = helper(child).__meta;
+                    // Use root.className for TPT entities: a Dog (root: Animal) should match
+                    // targetMeta Animal. For non-TPT entities, root === self.
+                    return childMeta.root.className === targetMeta.root.className;
+                });
                 if (targetChildren.length > 0) {
                     await populateChildren(targetMeta, targetChildren);
                 }

package/metadata/MetadataDiscovery.js

@@ -1592,7 +1592,10 @@ export class MetadataDiscovery {
             prop.defaultRaw = this.#platform.formatQuery(raw.sql, raw.params);
             return;
         }
-        if (Array.isArray(prop.default) && prop.customType) {
+        // TODO(v8): always convert the default via the custom type — the `compareAsType() !== 'any'`
+        // guard preserves the legacy convention where JSON defaults are passed pre-stringified.
+        // Array defaults are converted unconditionally (e.g. `default: []` on a JSON-backed embedded array).
+        if (prop.customType && (Array.isArray(prop.default) || prop.customType.compareAsType() !== 'any')) {
             val = prop.customType.convertToDatabaseValue(prop.default, this.#platform);
         }
         prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;

package/metadata/MetadataValidator.js

@@ -283,8 +283,10 @@ export class MetadataValidator {
     validateIndexes(meta, indexes, type) {
         for (const index of indexes) {
             for (const propName of Utils.asArray(index.properties)) {
-                const prop = meta.root.properties[propName];
-                if (!prop && !Object.values(meta.root.properties).some(p => propName.startsWith(p.name + '.'))) {
+                const prop = meta.properties[propName] ?? meta.root.properties[propName];
+                if (!prop &&
+                    !Object.values(meta.properties).some(p => propName.startsWith(p.name + '.')) &&
+                    !Object.values(meta.root.properties).some(p => propName.startsWith(p.name + '.'))) {
                     throw MetadataError.unknownIndexProperty(meta, propName, type);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.11-dev.9",
+  "version": "7.0.12-dev.0",
   "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/utils/AbstractMigrator.d.ts

@@ -72,6 +72,7 @@ export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implem
     down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
     abstract getStorage(): IMigratorStorage;
     protected init(): Promise<void>;
+    protected initPaths(): Promise<void>;
     protected initServices(): void;
     protected resolve(params: {
         name: string;
@@ -89,7 +90,7 @@ export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implem
     private detectSourceFolder;
     private registerDefaultListeners;
     private emit;
-    private discoverMigrations;
+    protected discoverMigrations(): Promise<RunnableMigration[]>;
     private executeMigrations;
     private filterUp;
     private filterDown;

package/utils/AbstractMigrator.js

@@ -68,14 +68,24 @@ export class AbstractMigrator {
             return;
         }
         this.initialized = true;
-        if (!this.options.migrationsList) {
-            const { fs } = await import('@mikro-orm/core/fs-utils');
-            this.detectSourceFolder(fs);
-            /* v8 ignore next */
-            const key = this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs ? 'pathTs' : 'path';
-            this.absolutePath = fs.absolutePath(this.options[key], this.config.get('baseDir'));
+        await this.initPaths();
+    }
+    async initPaths() {
+        if (this.absolutePath || this.options.migrationsList) {
+            return;
+        }
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        this.detectSourceFolder(fs);
+        /* v8 ignore next */
+        const key = this.config.get('preferTs', Utils.detectTypeScriptSupport()) && this.options.pathTs ? 'pathTs' : 'path';
+        this.absolutePath = fs.absolutePath(this.options[key], this.config.get('baseDir'));
+        try {
             fs.ensureDir(this.absolutePath);
         }
+        catch {
+            // read-only filesystem — read-only operations (e.g. `getPending` with a
+            // snapshot) may still succeed; write operations will fail on their own
+        }
     }
     initServices() {
         this.runner = this.createRunner();

package/utils/EntityComparator.js

@@ -569,7 +569,14 @@ export class EntityComparator {
                 ret += `      ret${dataKey} = null;\n`;
                 ret += `    } else if (typeof entity${entityKey} !== 'undefined') {\n`;
                 ret += `      const val${level} = entity${entityKey}${unwrap};\n`;
-                ret += `      const discriminator = ${discriminatorMapKey}.get(val${level}?.constructor);\n`;
+                // walk up the prototype chain so TPT subclasses resolve to their root's discriminator
+                ret += `      let __cls${level} = val${level}?.constructor;\n`;
+                ret += `      let discriminator;\n`;
+                ret += `      while (__cls${level} != null) {\n`;
+                ret += `        discriminator = ${discriminatorMapKey}.get(__cls${level});\n`;
+                ret += `        if (discriminator !== undefined) break;\n`;
+                ret += `        __cls${level} = Object.getPrototypeOf(__cls${level});\n`;
+                ret += `      }\n`;
                 ret += `      const pk = val${level}?.__helper?.__identifier && !val${level}?.__helper?.hasPrimaryKey()\n`;
                 ret += `        ? val${level}.__helper.__identifier\n`;
                 ret += `        : toArray(val${level}?.__helper?.getPrimaryKey(true));\n`;

package/utils/QueryHelper.d.ts

@@ -8,6 +8,7 @@ export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
     /**
      * Finds the discriminator value (key) for a given entity class in a discriminator map.
+     * Walks up the prototype chain so TPT subclasses resolve to their root's key.
      */
     static findDiscriminatorValue<T>(discriminatorMap: Dictionary<T>, targetClass: T): string | undefined;
     static processParams(params: unknown): any;

package/utils/QueryHelper.js

@@ -9,9 +9,19 @@ export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
     /**
      * Finds the discriminator value (key) for a given entity class in a discriminator map.
+     * Walks up the prototype chain so TPT subclasses resolve to their root's key.
      */
     static findDiscriminatorValue(discriminatorMap, targetClass) {
-        return Object.entries(discriminatorMap).find(([, cls]) => cls === targetClass)?.[0];
+        const entries = Object.entries(discriminatorMap);
+        let current = targetClass;
+        while (current != null) {
+            const hit = entries.find(([, cls]) => cls === current)?.[0];
+            if (hit) {
+                return hit;
+            }
+            current = Object.getPrototypeOf(current);
+        }
+        return undefined;
     }
     static processParams(params) {
         if (Reference.isReference(params)) {

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.0.11-dev.9';
+    static #ORM_VERSION = '7.0.12-dev.0';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */