@mikro-orm/core 7.1.0-dev.5 → 7.1.0-dev.50

package/utils/Configuration.d.ts

@@ -6,6 +6,7 @@ import { type Logger, type LoggerNamespace, type LoggerOptions } from '../loggin
 import type { EntityManager } from '../EntityManager.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntitySchema } from '../metadata/EntitySchema.js';
+import { Routine } from '../metadata/Routine.js';
 import { MetadataProvider } from '../metadata/MetadataProvider.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { EventSubscriber } from '../events/EventSubscriber.js';
@@ -27,6 +28,10 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
     get<T extends keyof Options<D, EM>, U extends Options<D, EM>[T]>(key: T, defaultValue?: U): U;
     /** Returns all configuration options. */
     getAll(): Options<D, EM>;
+    /** Validates the `routines` config option on first access and throws on duplicate `(schema, name)` pairs or non-Routine entries. */
+    getRoutines(): readonly Routine[];
+    hasRoutine(routine: Routine): boolean;
+    private normaliseRoutines;
     /**
      * Overrides specified configuration value.
      */
@@ -238,6 +243,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.
@@ -390,6 +413,13 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Can be class references or instances.
      */
     subscribers: Iterable<EventSubscriber | Constructor<EventSubscriber>>;
+    /**
+     * Stored procedures and functions, declared as {@link Routine} instances.
+     *
+     * @example
+     * routines: [HashUser, AddRecord]
+     */
+    routines: Iterable<Routine>;
     /**
      * Global entity filters to apply.
      * Filters are applied by default unless explicitly disabled.

package/utils/Configuration.js

@@ -4,6 +4,8 @@ import { NullHighlighter } from '../utils/NullHighlighter.js';
 import { DefaultLogger } from '../logging/DefaultLogger.js';
 import { colors } from '../logging/colors.js';
 import { Utils } from '../utils/Utils.js';
+import { Routine } from '../metadata/Routine.js';
+import { MetadataValidator } from '../metadata/MetadataValidator.js';
 import { MetadataProvider } from '../metadata/MetadataProvider.js';
 import { NotFoundError } from '../errors.js';
 import { RequestContext } from './RequestContext.js';
@@ -17,6 +19,7 @@ const DEFAULTS = {
     entitiesTs: [],
     extensions: [],
     subscribers: [],
+    routines: [],
     filters: {},
     discovery: {
         warnWhenNoEntities: true,
@@ -137,6 +140,8 @@ export class Configuration {
     #platform;
     #cache = new Map();
     #extensions = new Map();
+    #routines = [];
+    #routinesNormalised = false;
     constructor(options, validate = true) {
         if (options.dynamicImportProvider) {
             globalThis.dynamicImportProvider = options.dynamicImportProvider;
@@ -181,6 +186,42 @@ export class Configuration {
     getAll() {
         return this.#options;
     }
+    /** Validates the `routines` config option on first access and throws on duplicate `(schema, name)` pairs or non-Routine entries. */
+    getRoutines() {
+        this.normaliseRoutines();
+        return this.#routines;
+    }
+    hasRoutine(routine) {
+        this.normaliseRoutines();
+        return this.#routines.includes(routine);
+    }
+    normaliseRoutines() {
+        if (this.#routinesNormalised) {
+            return;
+        }
+        const validator = new MetadataValidator();
+        const seenKeys = new Set();
+        // Stage in a local array so a mid-loop throw doesn't leave `#routines` partially populated;
+        // a retry after the user fixes the offending entry would otherwise duplicate earlier ones.
+        const collected = [];
+        for (const item of this.#options.routines ?? []) {
+            if (!Routine.is(item)) {
+                throw new Error(`'routines' entry is not a stored routine declaration. Use a Routine class instance.`);
+            }
+            validator.validateRoutineDefinition(item);
+            // Case-fold to match `SchemaComparator.compareRoutines`, which lower-cases the key so
+            // dialect-specific folding (Oracle uppercases, PG lowercases) round-trips; otherwise a
+            // user could register `'Foo'` and `'foo'` here and have the comparator silently collapse them.
+            const key = ((item.schema ? `${item.schema}.` : '') + item.name).toLowerCase();
+            if (seenKeys.has(key)) {
+                throw new Error(`Duplicate routine '${key}' declared more than once in the 'routines' config. Routine names must be unique within a schema.`);
+            }
+            seenKeys.add(key);
+            collected.push(item);
+        }
+        this.#routines.push(...collected);
+        this.#routinesNormalised = true;
+    }
     /**
      * Overrides specified configuration value.
      */
@@ -324,6 +365,10 @@ export class Configuration {
         metadataCache.enabled ??= useCache;
         this.#options.clientUrl ??= this.#platform.getDefaultClientUrl();
         this.#options.implicitTransactions ??= this.#platform.usesImplicitTransactions();
+        // Eagerly trigger routine validation so errors surface at init time, not on first call.
+        if (validate) {
+            this.getRoutines();
+        }
         if (validate && metadataCache.enabled && !metadataCache.adapter) {
             throw new Error('No metadata cache adapter specified, please fill in `metadataCache.adapter` option or use the async MikroORM.init() method which can autoload it.');
         }

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/TransactionManager.js

@@ -136,6 +136,8 @@ export class TransactionManager {
             cloneEventManager: true,
             disableTransactions: options.ignoreNestedTransactions,
             loggerContext: options.loggerContext,
+            signal: options.signal,
+            inflightQueryAbortStrategy: options.inflightQueryAbortStrategy,
         });
     }
     /**

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

package/utils/upsert-utils.d.ts

@@ -10,3 +10,5 @@ export declare function getWhereCondition<T extends object>(meta: EntityMetadata
     where: FilterQuery<T>;
     propIndex: number | false;
 };
+/** @internal */
+export declare function resetUntouchedCollections<Entity extends object>(meta: EntityMetadata<Entity>, entity: Entity): void;

package/utils/upsert-utils.js

@@ -1,5 +1,8 @@
 import { isRaw } from '../utils/RawQueryFragment.js';
 import { Utils } from './Utils.js';
+import { ReferenceKind } from '../enums.js';
+import { Collection } from '../entity/Collection.js';
+import { helper } from '../entity/wrap.js';
 function expandEmbeddedProperties(prop, key) {
     if (prop.object) {
         return [prop.name];
@@ -52,7 +55,9 @@ export function getOnConflictFields(meta, data, uniqueFields, options) {
         });
     }
     const keys = Object.keys(data).flatMap(f => {
-        if (!(Array.isArray(uniqueFields) && !uniqueFields.includes(f))) {
+        // skip explicitly listed unique fields; for raw onConflictFields we can't introspect the
+        // fragment, so merge all data keys (the user is responsible for not corrupting them).
+        if (Array.isArray(uniqueFields) && uniqueFields.includes(f)) {
             return [];
         }
         const prop = meta?.properties[f];
@@ -142,3 +147,23 @@ export function getWhereCondition(meta, onConflictFields, data, where) {
     }
     return { where, propIndex };
 }
+/** @internal */
+export function resetUntouchedCollections(meta, entity) {
+    // for entities passed in via `em.create()` and then upserted, collection-kind relations
+    // were initialized as empty-but-initialized by the hydrator (newEntity=true). once the
+    // upsert resolves the entity to a possibly existing row, that state is stale and would
+    // cause `em.populate()` to skip those collections. replace them with a fresh
+    // uninitialized collection so populate can load them.
+    if (helper(entity).__originalEntityData) {
+        return;
+    }
+    for (const prop of meta.relations) {
+        if (prop.kind !== ReferenceKind.MANY_TO_MANY && prop.kind !== ReferenceKind.ONE_TO_MANY) {
+            continue;
+        }
+        const collection = entity[prop.name];
+        if (Utils.isCollection(collection) && collection.isInitialized() && !collection.isDirty()) {
+            Collection.create(entity, prop.name, undefined, false);
+        }
+    }
+}