@mikro-orm/core 7.1.0-dev.3 → 7.1.0-dev.31

package/utils/AbstractMigrator.js

@@ -38,18 +38,32 @@ export class AbstractMigrator {
     /**
      * @inheritDoc
      */
-    async getExecuted() {
+    async getExecuted(options) {
         await this.init();
-        return this.storage.getExecutedMigrations();
+        const schema = options?.schema ?? this.options.schema;
+        this.storage.setRunSchema?.(schema);
+        try {
+            return await this.storage.getExecutedMigrations();
+        }
+        finally {
+            this.storage.unsetRunSchema?.();
+        }
     }
     /**
      * @inheritDoc
      */
-    async getPending() {
+    async getPending(options) {
         await this.init();
-        const all = await this.discoverMigrations();
-        const executed = new Set(await this.storage.executed());
-        return all.filter(m => !executed.has(m.name)).map(m => ({ name: m.name, path: m.path }));
+        const schema = options?.schema ?? this.options.schema;
+        this.storage.setRunSchema?.(schema);
+        try {
+            const all = await this.discoverMigrations();
+            const executed = new Set(await this.storage.executed());
+            return all.filter(m => !executed.has(m.name)).map(m => ({ name: m.name, path: m.path }));
+        }
+        finally {
+            this.storage.unsetRunSchema?.();
+        }
     }
     /**
      * @inheritDoc
@@ -63,6 +77,209 @@ export class AbstractMigrator {
     async down(options) {
         return this.runMigrations('down', options);
     }
+    /**
+     * @inheritDoc
+     */
+    async rollup(migrations) {
+        await this.init();
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        const all = await this.discoverMigrations();
+        const executedSet = new Set(await this.storage.executed());
+        let toRollup;
+        if (migrations && migrations.length > 0) {
+            const requested = new Set(migrations.map(m => this.getMigrationFilename(m)));
+            toRollup = all.filter(m => requested.has(m.name));
+            const found = new Set(toRollup.map(m => m.name));
+            const notFound = [...requested].filter(name => !found.has(name));
+            if (notFound.length > 0) {
+                throw new Error(`Migrations not found: ${notFound.join(', ')}`);
+            }
+            const notExecuted = toRollup.filter(m => !executedSet.has(m.name));
+            if (notExecuted.length > 0) {
+                throw new Error(`Cannot roll up migrations that have not been executed: ${notExecuted.map(m => m.name).join(', ')}`);
+            }
+        }
+        else {
+            toRollup = all.filter(m => executedSet.has(m.name));
+        }
+        if (toRollup.length < 2) {
+            throw new Error('At least 2 executed migrations are required for rollup');
+        }
+        const withoutPath = toRollup.filter(m => !m.path);
+        if (withoutPath.length > 0) {
+            throw new Error(`Cannot roll up migrations without file paths (class-based migrations): ${withoutPath.map(m => m.name).join(', ')}`);
+        }
+        const upBodies = [];
+        const downBodies = [];
+        const placeholder = `__mikro_orm_rollup_${Date.now()}__`;
+        for (const migration of toRollup) {
+            const source = await fs.readFile(migration.path);
+            const upBody = this.extractMethodBody(source, 'up');
+            const downBody = this.extractMethodBody(source, 'down');
+            if (upBody) {
+                upBodies.push(`    // --- merged from ${migration.name} ---\n${upBody}`);
+            }
+            if (downBody) {
+                downBodies.unshift(`    // --- merged from ${migration.name} ---\n${downBody}`);
+            }
+        }
+        const diff = {
+            up: [placeholder],
+            down: downBodies.length > 0 ? [placeholder] : [],
+        };
+        const [templateCode, fileName] = await this.generator.generate(diff);
+        const placeholderRe = new RegExp(`^.*${placeholder}.*$`, 'm');
+        let code = templateCode.replace(placeholderRe, upBodies.join('\n'));
+        if (downBodies.length > 0) {
+            code = code.replace(placeholderRe, downBodies.join('\n'));
+        }
+        await fs.writeFile(fs.normalizePath(this.absolutePath, fileName), code, { flush: true });
+        const updateStorage = async () => {
+            for (const migration of toRollup) {
+                await this.storage.unlogMigration({ name: migration.name });
+            }
+            await this.storage.logMigration({ name: fileName.replace(/\.[jt]s$/, '') });
+        };
+        if (this.options.transactional) {
+            await this.driver.getConnection().transactional(async (trx) => {
+                this.storage.setMasterMigration(trx);
+                try {
+                    await updateStorage();
+                }
+                finally {
+                    this.storage.unsetMasterMigration();
+                }
+            });
+        }
+        else {
+            await updateStorage();
+        }
+        await Promise.all(toRollup.map(migration => fs.unlink(migration.path)));
+        return { fileName, code, diff: { up: [], down: [] } };
+    }
+    /**
+     * Extracts the body of a method from migration source code using brace counting.
+     * Returns the raw lines between the opening and closing braces, or empty string if not found.
+     * @internal
+     */
+    extractMethodBody(source, methodName) {
+        const lines = source.split('\n');
+        // match method declarations, not occurrences in comments/strings — require preceding whitespace or keyword
+        const methodPattern = new RegExp(`^\\s+(?:override\\s+|async\\s+)*${methodName}\\s*\\(`);
+        let methodLine = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (methodPattern.test(lines[i])) {
+                methodLine = i;
+                break;
+            }
+        }
+        if (methodLine === -1) {
+            return '';
+        }
+        let braceCount = 0;
+        let bodyStart = -1;
+        let bodyEnd = -1;
+        let bodyStartCol = -1;
+        let bodyEndCol = -1;
+        let inBacktick = false;
+        let inBlockComment = false;
+        // stack tracks brace depth at which each template expression `${...}` was entered
+        const templateExprStack = [];
+        for (let i = methodLine; i < lines.length; i++) {
+            const line = lines[i];
+            for (let j = 0; j < line.length; j++) {
+                // handle multi-line block comments
+                if (inBlockComment) {
+                    if (line[j] === '*' && j + 1 < line.length && line[j + 1] === '/') {
+                        inBlockComment = false;
+                        j++;
+                    }
+                    continue;
+                }
+                // handle multi-line template literals
+                if (inBacktick) {
+                    if (line[j] === '\\') {
+                        j++;
+                    }
+                    else if (line[j] === '`') {
+                        inBacktick = false;
+                    }
+                    else if (line[j] === '$' && j + 1 < line.length && line[j + 1] === '{') {
+                        // entering template expression — resume brace counting
+                        templateExprStack.push(braceCount);
+                        inBacktick = false;
+                        j++; // skip the {
+                        braceCount++;
+                    }
+                    continue;
+                }
+                const ch = line[j];
+                // single/double quoted strings (single-line only)
+                if (ch === "'" || ch === '"') {
+                    const quote = ch;
+                    j++;
+                    while (j < line.length) {
+                        if (line[j] === '\\') {
+                            j++;
+                        }
+                        else if (line[j] === quote) {
+                            break;
+                        }
+                        j++;
+                    }
+                    continue;
+                }
+                // template literal start
+                if (ch === '`') {
+                    inBacktick = true;
+                    continue;
+                }
+                // single-line comment
+                if (ch === '/' && j + 1 < line.length && line[j + 1] === '/') {
+                    break;
+                }
+                // block comment start
+                if (ch === '/' && j + 1 < line.length && line[j + 1] === '*') {
+                    inBlockComment = true;
+                    j++;
+                    continue;
+                }
+                if (ch === '{') {
+                    if (braceCount === 0) {
+                        bodyStart = i;
+                        bodyStartCol = j + 1;
+                    }
+                    braceCount++;
+                }
+                else if (ch === '}') {
+                    braceCount--;
+                    // closing a template expression — re-enter backtick mode
+                    if (templateExprStack.length > 0 && braceCount === templateExprStack[templateExprStack.length - 1]) {
+                        templateExprStack.pop();
+                        inBacktick = true;
+                        continue;
+                    }
+                    if (braceCount === 0) {
+                        bodyEnd = i;
+                        bodyEndCol = j;
+                        break;
+                    }
+                }
+            }
+            if (bodyEnd !== -1) {
+                break;
+            }
+        }
+        if (bodyStart === -1 || bodyEnd === -1) {
+            return '';
+        }
+        // single-line method body: extract content between braces on the same line
+        if (bodyStart === bodyEnd) {
+            const content = lines[bodyStart].slice(bodyStartCol, bodyEndCol).trim();
+            return content ? `    ${content}` : '';
+        }
+        return lines.slice(bodyStart + 1, bodyEnd).join('\n');
+    }
     /**
      * @inheritDoc
      */
@@ -114,26 +331,26 @@ export class AbstractMigrator {
         }
     }
     resolve(params) {
-        const createMigrationHandler = async (method) => {
+        const createMigrationHandler = async (method, afterRun) => {
             const { fs } = await import('@mikro-orm/core/fs-utils');
             const migration = await fs.dynamicImport(params.path);
             const MigrationClass = Object.values(migration).find(cls => typeof cls === 'function' && typeof cls.constructor === 'function');
             const instance = new MigrationClass(this.driver, this.config);
-            await this.runner.run(instance, method);
+            await this.runner.run(instance, method, afterRun);
         };
         return {
             name: this.storage.getMigrationName(params.name),
             path: params.path,
-            up: () => createMigrationHandler('up'),
-            down: () => createMigrationHandler('down'),
+            up: afterRun => createMigrationHandler('up', afterRun),
+            down: afterRun => createMigrationHandler('down', afterRun),
         };
     }
     initialize(MigrationClass, name) {
         const instance = new MigrationClass(this.driver, this.config);
         return {
             name: this.storage.getMigrationName(name),
-            up: () => this.runner.run(instance, 'up'),
-            down: () => this.runner.run(instance, 'down'),
+            up: afterRun => this.runner.run(instance, 'up', afterRun),
+            down: afterRun => this.runner.run(instance, 'down', afterRun),
         };
     }
     /**
@@ -212,13 +429,15 @@ export class AbstractMigrator {
         for (const migration of toRun) {
             const event = { name: migration.name, path: migration.path };
             await this.emit(eventBefore, event);
-            await migration[method]();
-            if (method === 'up') {
-                await this.storage.logMigration({ name: migration.name });
-            }
-            else {
-                await this.storage.unlogMigration({ name: migration.name });
-            }
+            // log inside the runner's tx (if any) so a logMigration failure rolls the migration back
+            await migration[method](async (tx) => {
+                if (method === 'up') {
+                    await this.storage.logMigration({ name: migration.name }, tx);
+                }
+                else {
+                    await this.storage.unlogMigration({ name: migration.name }, tx);
+                }
+            });
             await this.emit(eventAfter, event);
             result.push(event);
         }
@@ -284,13 +503,17 @@ export class AbstractMigrator {
         return /^\d{14}$/.exec(name) ? this.options.fileName(name) : name;
     }
     prefix(options) {
+        const base = {};
+        if (this.options.schema) {
+            base.schema = this.options.schema;
+        }
         if (typeof options === 'string' || Array.isArray(options)) {
-            return { migrations: Utils.asArray(options).map(name => this.getMigrationFilename(name)) };
+            return { ...base, migrations: Utils.asArray(options).map(name => this.getMigrationFilename(name)) };
         }
         if (!options) {
-            return {};
+            return base;
         }
-        const result = {};
+        const result = base;
         if (options.migrations) {
             result.migrations = options.migrations.map(name => this.getMigrationFilename(name));
         }
@@ -303,23 +526,35 @@ export class AbstractMigrator {
         else if (options.to === 0) {
             result.to = 0;
         }
+        if (options.schema !== undefined) {
+            result.schema = options.schema;
+        }
         return result;
     }
     async runMigrations(method, options) {
         await this.init();
-        if (!this.options.transactional || !this.options.allOrNothing) {
-            return this.executeMigrations(method, this.prefix(options));
+        const normalized = this.prefix(options);
+        this.runner.setRunSchema?.(normalized.schema);
+        this.storage.setRunSchema?.(normalized.schema);
+        try {
+            if (!this.options.transactional || !this.options.allOrNothing) {
+                return await this.executeMigrations(method, normalized);
+            }
+            if (Utils.isObject(options) && options.transaction) {
+                return await this.runInTransaction(options.transaction, method, normalized);
+            }
+            return await this.driver.getConnection().transactional(trx => this.runInTransaction(trx, method, normalized));
         }
-        if (Utils.isObject(options) && options.transaction) {
-            return this.runInTransaction(options.transaction, method, options);
+        finally {
+            this.runner.unsetRunSchema?.();
+            this.storage.unsetRunSchema?.();
         }
-        return this.driver.getConnection().transactional(trx => this.runInTransaction(trx, method, options));
     }
     async runInTransaction(trx, method, options) {
         this.runner.setMasterMigration(trx);
         this.storage.setMasterMigration(trx);
         try {
-            return await this.executeMigrations(method, this.prefix(options));
+            return await this.executeMigrations(method, options);
         }
         finally {
             this.runner.unsetMasterMigration();

package/utils/AbstractSchemaGenerator.d.ts

@@ -34,6 +34,6 @@ export declare abstract class AbstractSchemaGenerator<D extends IDatabaseDriver>
     dropDatabase(name?: string): Promise<void>;
     execute(query: string): Promise<void>;
     ensureIndexes(): Promise<void>;
-    protected getOrderedMetadata(schema?: string): EntityMetadata[];
+    protected getOrderedMetadata(schema?: string, includeWildcardSchema?: boolean): EntityMetadata[];
     protected notImplemented(): never;
 }

package/utils/AbstractSchemaGenerator.js

@@ -89,7 +89,7 @@ export class AbstractSchemaGenerator {
     async ensureIndexes() {
         this.notImplemented();
     }
-    getOrderedMetadata(schema) {
+    getOrderedMetadata(schema, includeWildcardSchema = false) {
         const metadata = [...this.metadata.getAll().values()].filter(meta => {
             const isRootEntity = meta.root.class === meta.class;
             const isTPTChild = meta.inheritanceType === 'tpt' && meta.tptParent;
@@ -116,6 +116,9 @@ export class AbstractSchemaGenerator {
             .sort()
             .map(cls => this.metadata.getById(cls))
             .filter(meta => {
+            if (includeWildcardSchema && meta.schema === '*') {
+                return true;
+            }
             const targetSchema = meta.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
             return schema ? [schema, '*'].includes(targetSchema) : meta.schema !== '*';
         });

package/utils/Configuration.d.ts

@@ -238,6 +238,24 @@ export type MigrationsOptions = {
     fileName?: (timestamp: string, name?: string) => string;
     /** List of migration classes or objects to use instead of file-based discovery. */
     migrationsList?: (MigrationObject | Constructor<Migration>)[];
+    /**
+     * Target schema used when running migrations. When set, the driver's "set current schema" statement
+     * (e.g. `SET search_path` on PostgreSQL) is issued before each migration, and the migration tracking
+     * table lives in this schema. Can be overridden per call via `migrator.up({ schema })`.
+     *
+     * Intended for per-deployment-one-schema setups (e.g. PR previews) and for applying a single
+     * unqualified migration to multiple schemas (see `includeWildcardSchema`). Not supported on MSSQL.
+     */
+    schema?: string;
+    /**
+     * When set, entities with a wildcard schema (`schema: '*'`) are included in generated migrations.
+     * The emitted SQL is unqualified — and therefore safe to apply against any schema at runtime via
+     * `migrator.up({ schema })` — only when neither `options.schema` nor the ORM's `config.schema`
+     * is set. If `config.schema` is set, wildcard tables are qualified with it (useful for local
+     * dev runs); in that case, generate migrations from an environment where `config.schema` is unset.
+     * @default false
+     */
+    includeWildcardSchema?: boolean;
 };
 /**
  * Configuration options for database seeders.
@@ -529,6 +547,13 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @default false
      */
     forceUndefined: boolean;
+    /**
+     * Initialize nullable properties to `null` (or `undefined` when `forceUndefined` is set)
+     * during `em.create()` when they are not provided in the data. Without this option,
+     * nullable properties remain `undefined` until the entity is loaded from the database.
+     * @default false
+     */
+    initNullableProperties: boolean;
     /**
      * Property `onCreate` hooks are normally executed during `flush` operation.
      * With this option, they will be processed early inside `em.create()` method.

package/utils/Configuration.js

@@ -62,6 +62,7 @@ const DEFAULTS = {
     upsertManaged: true,
     forceEntityConstructor: false,
     forceUndefined: false,
+    initNullableProperties: false,
     forceUtcTimezone: true,
     processOnCreateHooksEarly: true,
     ensureDatabase: true,

package/utils/DataloaderUtils.d.ts

@@ -1,5 +1,5 @@
 import type { Constructor, Primary, Ref } from '../typings.js';
-import { Collection, type InitCollectionOptions } from '../entity/Collection.js';
+import { Collection, type InitCollectionOptions, type LoadCountOptions } from '../entity/Collection.js';
 import { type EntityManager } from '../EntityManager.js';
 import { type LoadReferenceOptions } from '../entity/Reference.js';
 type BatchLoadFn<K, V> = (keys: readonly K[]) => PromiseLike<ArrayLike<V | Error>>;
@@ -44,6 +44,15 @@ export declare class DataloaderUtils {
      * makes one query per entity and maps each input collection to the corresponding result.
      */
     static getManyToManyColBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<InitCollectionOptions<any, any>, 'dataloader'>?], any>;
+    /**
+     * Returns the count dataloader batchLoadFn, which aggregates `Collection.loadCount()` calls
+     * by entity and relation, issues a single grouped count query per entity+options combination
+     * via `em.countBy()`, and maps each input collection to the corresponding count.
+     *
+     * For 1:M relations, groups by the FK property on the target entity.
+     * For M:N relations, groups by the owner FK on the pivot entity.
+     */
+    static getCountBatchLoadFn(em: EntityManager): BatchLoadFn<[Collection<any>, Omit<LoadCountOptions<any>, 'dataloader' | 'refresh'>?], number>;
     static getDataLoader(): Promise<Constructor<{
         load: (...args: unknown[]) => Promise<unknown>;
     }>>;

package/utils/DataloaderUtils.js

@@ -1,6 +1,7 @@
 import { Collection } from '../entity/Collection.js';
 import { helper } from '../entity/wrap.js';
 import { Reference } from '../entity/Reference.js';
+import { ReferenceKind } from '../enums.js';
 import { Utils } from './Utils.js';
 export class DataloaderUtils {
     static DataLoader;
@@ -216,6 +217,83 @@ export class DataloaderUtils {
             return ret;
         };
     }
+    /**
+     * Returns the count dataloader batchLoadFn, which aggregates `Collection.loadCount()` calls
+     * by entity and relation, issues a single grouped count query per entity+options combination
+     * via `em.countBy()`, and maps each input collection to the corresponding count.
+     *
+     * For 1:M relations, groups by the FK property on the target entity.
+     * For M:N relations, groups by the owner FK on the pivot entity.
+     */
+    static getCountBatchLoadFn(em) {
+        return async (collsWithOpts) => {
+            const groups = new Map();
+            const keys = [];
+            for (const [col, opts] of collsWithOpts) {
+                const prop = col.property;
+                let fkProp;
+                let countByClass;
+                let targetFilterProp;
+                if (prop.kind === ReferenceKind.ONE_TO_MANY) {
+                    fkProp = prop.mappedBy;
+                    countByClass = prop.targetMeta.class;
+                }
+                else {
+                    // M:N: group by the owner FK on the pivot entity
+                    const pivotMeta = em.getMetadata().get(prop.pivotEntity);
+                    const ownerPivotProp = pivotMeta.relations[prop.owner ? 0 : 1];
+                    const targetPivotProp = pivotMeta.relations[prop.owner ? 1 : 0];
+                    fkProp = ownerPivotProp.name;
+                    countByClass = pivotMeta.class;
+                    targetFilterProp = targetPivotProp.name;
+                }
+                // Include the owner-side uniqueName in the key so that two distinct owner entity types
+                // sharing a relation with the same property name (e.g. `Author.books` and `Publisher.books`)
+                // don't collide into a single batch that would use one owner's FK mapping for the other.
+                const ownerUniqueName = helper(col.owner).__meta.uniqueName;
+                const key = `${ownerUniqueName}.${prop.name}|${JSON.stringify(opts ?? {})}`;
+                keys.push(key);
+                let group = groups.get(key);
+                if (!group) {
+                    group = { fkProp, countByClass, targetFilterProp, ownerPKs: new Map(), opts: opts ?? {} };
+                    groups.set(key, group);
+                }
+                const pk = helper(col.owner).getPrimaryKey();
+                group.ownerPKs.set(JSON.stringify(pk), pk);
+            }
+            const promises = Array.from(groups.entries()).map(async ([key, group]) => {
+                const allPKs = Array.from(group.ownerPKs.values());
+                const { where, ...countOpts } = group.opts;
+                const conditions = [{ [group.fkProp]: { $in: allPKs } }];
+                if (where) {
+                    conditions.push(where);
+                }
+                // For M:N, apply the target entity's filters through the pivot's target relation
+                if (group.targetFilterProp) {
+                    const targetMeta = em.getMetadata().find(group.countByClass);
+                    const targetRelMeta = targetMeta.properties[group.targetFilterProp]?.targetMeta;
+                    if (targetRelMeta) {
+                        const filterCond = await em.applyFilters(targetRelMeta.class, {}, countOpts.filters, 'read');
+                        if (filterCond && Object.keys(filterCond).length > 0) {
+                            conditions.push({ [group.targetFilterProp]: filterCond });
+                        }
+                    }
+                }
+                const fkWhere = conditions.length === 1 ? conditions[0] : { $and: conditions };
+                const counts = await em.countBy(group.countByClass, group.fkProp, {
+                    where: fkWhere,
+                    ...countOpts,
+                });
+                return [key, counts];
+            });
+            const resultsMap = new Map(await Promise.all(promises));
+            return collsWithOpts.map(([col], i) => {
+                const pk = helper(col.owner).getPrimaryKey();
+                const counts = resultsMap.get(keys[i]);
+                return counts?.[String(pk)] ?? 0;
+            });
+        };
+    }
     static async getDataLoader() {
         if (this.DataLoader) {
             return this.DataLoader;

package/utils/EntityComparator.js

@@ -536,7 +536,7 @@ export class EntityComparator {
             ret += ` && entity${path.map(k => this.wrap(k)).join('')}?.isInitialized()`;
         }
         ret += `) {\n`;
-        if (['number', 'string', 'boolean'].includes(prop.type.toLowerCase())) {
+        if (!prop.array && ['number', 'string', 'boolean'].includes(prop.type.toLowerCase())) {
             return ret + `    ret${dataKey} = entity${entityKey}${unwrap};\n  }\n`;
         }
         if (prop.kind === ReferenceKind.EMBEDDED) {

package/utils/QueryHelper.d.ts

@@ -6,6 +6,22 @@ import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 /** @internal */
 export declare class QueryHelper {
     static readonly SUPPORTED_OPERATORS: string[];
+    /**
+     * True when the property has multiple polymorph target types. Covers two structurally-equivalent
+     * shapes routed through the same loading path:
+     *   1. Union-target owner side — `Post.attachments: Collection<Image | Video>` (one owner, many
+     *      target types, shared pivot with target-side discriminator).
+     *   2. Merged inverse of Rails-style polymorphic M:N — `Tag.owners: Collection<Post | Video>`
+     *      (many owner types pointing at one target, viewed from the target where "owners" looks
+     *      like a union of multiple types).
+     *
+     * Both cases are loaded via `loadFromUnionTargetPolymorphicPivotTable`, which buckets pivot rows
+     * by discriminator and hydrates each target class separately.
+     */
+    static isUnionTargetPolymorphic(prop: {
+        polymorphic?: boolean;
+        polymorphTargets?: readonly unknown[];
+    }): boolean;
     /**
      * 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.

package/utils/QueryHelper.js

@@ -7,6 +7,21 @@ import { isRaw, Raw } from './RawQueryFragment.js';
 /** @internal */
 export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
+    /**
+     * True when the property has multiple polymorph target types. Covers two structurally-equivalent
+     * shapes routed through the same loading path:
+     *   1. Union-target owner side — `Post.attachments: Collection<Image | Video>` (one owner, many
+     *      target types, shared pivot with target-side discriminator).
+     *   2. Merged inverse of Rails-style polymorphic M:N — `Tag.owners: Collection<Post | Video>`
+     *      (many owner types pointing at one target, viewed from the target where "owners" looks
+     *      like a union of multiple types).
+     *
+     * Both cases are loaded via `loadFromUnionTargetPolymorphicPivotTable`, which buckets pivot rows
+     * by discriminator and hydrates each target class separately.
+     */
+    static isUnionTargetPolymorphic(prop) {
+        return !!prop.polymorphic && (prop.polymorphTargets?.length ?? 0) > 1;
+    }
     /**
      * 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.

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

package/utils/fs-utils.d.ts

@@ -13,7 +13,9 @@ export interface FsUtils {
     normalizePath(...parts: string[]): string;
     relativePath(path: string, relativeTo: string): string;
     absolutePath(path: string, baseDir?: string): string;
+    readFile(path: string): Promise<string>;
     writeFile(path: string, data: string, options?: Record<string, any>): Promise<void>;
+    unlink(path: string): Promise<void>;
     dynamicImport<T = any>(id: string): Promise<T>;
 }
 export declare const fs: FsUtils;

package/utils/fs-utils.js

@@ -1,5 +1,5 @@
 import { existsSync, globSync as nodeGlobSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
-import { writeFile as nodeWriteFile } from 'node:fs/promises';
+import { readFile as nodeReadFile, unlink as nodeUnlink, writeFile as nodeWriteFile } from 'node:fs/promises';
 import { isAbsolute, join, normalize, relative } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Utils } from './Utils.js';
@@ -181,9 +181,15 @@ export const fs = {
         }
         return this.normalizePath(path);
     },
+    async readFile(path) {
+        return nodeReadFile(path, 'utf-8');
+    },
     async writeFile(path, data, options) {
         await nodeWriteFile(path, data, options);
     },
+    async unlink(path) {
+        await nodeUnlink(path);
+    },
     async dynamicImport(id) {
         /* v8 ignore next */
         const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;

package/utils/index.d.ts

@@ -10,3 +10,4 @@ export * from './EntityComparator.js';
 export * from './RawQueryFragment.js';
 export * from './env-vars.js';
 export * from './upsert-utils.js';
+export * from './partition-utils.js';