@mikro-orm/core 7.1.0-dev.2 → 7.1.0-dev.20

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/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.2';
+    static #ORM_VERSION = '7.1.0-dev.20';
     /**
      * 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';

package/utils/index.js

@@ -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';

package/utils/partition-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Normalize a partition name for collision detection. Mirrors PostgreSQL identifier
+ * resolution: unquoted segments fold to lower case, quoted segments preserve case and
+ * un-escape embedded `""`. Returns a canonical `schema.name` form so both schema-qualified
+ * and bare names compare consistently (`.name` vs `schema.name` stay distinguishable).
+ *
+ * `Part_1`, `part_1`, and `"part_1"` all normalize to the same value, catching collisions
+ * that would otherwise only surface as runtime PG "relation already exists" errors.
+ */
+export declare function normalizePartitionNameForComparison(name: string): string;
+/**
+ * Split a comma-list of identifiers, respecting double-quoted identifiers (which may contain
+ * commas and use `""` to escape embedded quotes). Returns `null` when the input is not a clean
+ * comma-list of identifiers (e.g. contains function calls or literals), so callers treat it
+ * as an opaque expression.
+ */
+export declare function splitCommaSeparatedIdentifiers(value: string): string[] | null;

package/utils/partition-utils.js

@@ -0,0 +1,79 @@
+function normalizeIdentifierSegment(segment) {
+    const trimmed = segment.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).replaceAll('""', '"');
+    }
+    return trimmed.toLowerCase();
+}
+/**
+ * Normalize a partition name for collision detection. Mirrors PostgreSQL identifier
+ * resolution: unquoted segments fold to lower case, quoted segments preserve case and
+ * un-escape embedded `""`. Returns a canonical `schema.name` form so both schema-qualified
+ * and bare names compare consistently (`.name` vs `schema.name` stay distinguishable).
+ *
+ * `Part_1`, `part_1`, and `"part_1"` all normalize to the same value, catching collisions
+ * that would otherwise only surface as runtime PG "relation already exists" errors.
+ */
+export function normalizePartitionNameForComparison(name) {
+    const trimmed = name.trim();
+    let depth = 0;
+    for (let i = 0; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (ch === '"') {
+            if (trimmed[i + 1] === '"') {
+                i++;
+                continue;
+            }
+            depth = depth === 0 ? 1 : 0;
+            continue;
+        }
+        if (ch === '.' && depth === 0) {
+            return `${normalizeIdentifierSegment(trimmed.slice(0, i))}.${normalizeIdentifierSegment(trimmed.slice(i + 1))}`;
+        }
+    }
+    return `.${normalizeIdentifierSegment(trimmed)}`;
+}
+/**
+ * Split a comma-list of identifiers, respecting double-quoted identifiers (which may contain
+ * commas and use `""` to escape embedded quotes). Returns `null` when the input is not a clean
+ * comma-list of identifiers (e.g. contains function calls or literals), so callers treat it
+ * as an opaque expression.
+ */
+export function splitCommaSeparatedIdentifiers(value) {
+    const segments = [];
+    let buffer = '';
+    let inQuote = false;
+    for (let i = 0; i < value.length; i++) {
+        const ch = value[i];
+        if (ch === '"') {
+            if (inQuote && value[i + 1] === '"') {
+                buffer += '""';
+                i++;
+                continue;
+            }
+            inQuote = !inQuote;
+            buffer += ch;
+            continue;
+        }
+        if (!inQuote) {
+            if (ch === ',') {
+                segments.push(buffer);
+                buffer = '';
+                continue;
+            }
+            if (!/[\w.\s]/.test(ch)) {
+                return null;
+            }
+        }
+        buffer += ch;
+    }
+    if (inQuote) {
+        return null;
+    }
+    segments.push(buffer);
+    const trimmed = segments.map(s => s.trim());
+    if (trimmed.some(s => s === '')) {
+        return null;
+    }
+    return trimmed;
+}