@mikro-orm/core 7.2.0-dev.2 → 7.2.0-dev.21

package/metadata/MetadataDiscovery.js

@@ -165,10 +165,14 @@ export class MetadataDiscovery {
         filtered.forEach(meta => this.initAutoincrement(meta)); // once again after we init custom types
         filtered.forEach(meta => this.initCheckConstraints(meta));
         filtered.forEach(meta => this.initTriggers(meta));
-        forEachProp((_m, p) => {
+        // filter names are load-bearing for RLS (policy and session variable names), backfill from the dictionary key
+        filtered.forEach(meta => Object.entries(meta.filters).forEach(([key, filter]) => (filter.name ??= key)));
+        filtered.forEach(meta => this.initPolicies(meta));
+        forEachProp((m, p) => {
             this.initDefaultValue(p);
             this.inferTypeFromDefault(p);
             this.initRelation(p);
+            this.initThroughRelation(m, p);
             this.initColumnType(p);
         });
         forEachProp((m, p) => this.initIndexes(m, p));
@@ -212,14 +216,18 @@ export class MetadataDiscovery {
             .replace(/Array<(.*)>/, '$1') // unwrap array
             .replace(/\[]$/, '') // remove array suffix
             .replace(/\((.*)\)/, '$1'); // unwrap union types
+        // Names can be ambiguous when a minifier mangles two classes to the same name,
+        // so class references also need to be checked by identity.
+        const discoveredByIdentity = (target) => {
+            const cls = EntitySchema.is(target) ? target.meta.class : target;
+            return typeof cls !== 'function' || this.#discovered.some(m => m.class === cls);
+        };
         const missing = [];
         this.#discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
-            if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.pivotEntity) {
-                const pivotEntity = prop.pivotEntity;
-                const target = typeof pivotEntity === 'function' && !pivotEntity.prototype
-                    ? pivotEntity()
-                    : pivotEntity;
-                if (!this.#discovered.find(m => m.className === Utils.className(target))) {
+            const indirect = (prop.kind === ReferenceKind.MANY_TO_MANY ? prop.pivotEntity : prop.through);
+            if (indirect) {
+                const target = typeof indirect === 'function' && !indirect.prototype ? indirect() : indirect;
+                if (!this.#discovered.find(m => m.className === Utils.className(target)) || !discoveredByIdentity(target)) {
                     missing.push(target);
                 }
             }
@@ -227,7 +235,8 @@ export class MetadataDiscovery {
                 const target = typeof prop.entity === 'function' && !prop.entity.prototype ? prop.entity() : prop.type;
                 if (!unwrap(prop.type)
                     .split(/ ?\| ?/)
-                    .every(type => this.#discovered.find(m => m.className === type))) {
+                    .every(type => this.#discovered.find(m => m.className === type)) ||
+                    !Utils.asArray(target).every(discoveredByIdentity)) {
                     missing.push(...Utils.asArray(target));
                 }
             }
@@ -275,9 +284,11 @@ export class MetadataDiscovery {
                 continue;
             }
             parent = Object.getPrototypeOf(meta.class);
-            // Skip if parent is the auto-generated base class for the same entity (from setClass usage)
+            // Skip if parent is the auto-generated base class for the same entity (from setClass usage).
+            // A parent carrying its own decorator metadata is a real base class even when a minifier
+            // mangles it to the same name as the child.
             if (parent.name !== '' &&
-                parent.name !== meta.className &&
+                (parent.name !== meta.className || Object.hasOwn(parent, MetadataStorage.META_SYMBOL)) &&
                 !this.#metadata.has(parent) &&
                 parent !== BaseEntity) {
                 this.discoverReferences([parent], false);
@@ -311,7 +322,12 @@ export class MetadataDiscovery {
         const cls = entity;
         const path = cls[MetadataStorage.PATH_SYMBOL];
         if (path) {
-            const meta = Utils.copy(MetadataStorage.getMetadata(cls.name, path), false);
+            // Prefer the metadata stored on the class reference, the `className-path` key can
+            // collide when a minifier mangles two classes to the same name.
+            const stored = Object.hasOwn(cls, MetadataStorage.META_SYMBOL)
+                ? cls[MetadataStorage.META_SYMBOL]
+                : MetadataStorage.getMetadata(cls.name, path);
+            const meta = Utils.copy(stored, false);
             meta.path = path;
             this.#metadata.set(cls, meta);
         }
@@ -427,7 +443,18 @@ export class MetadataDiscovery {
         if (prop.kind === ReferenceKind.SCALAR || prop.kind === ReferenceKind.EMBEDDED) {
             prop.fieldNames = [this.#namingStrategy.propertyToColumnName(prop.name, object)];
         }
-        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.polymorphic) {
+        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.polymorphic) {
+            if (prop.targetMeta) {
+                // same layout as `initManyToOneFields` builds later: `[discriminatorColumn, ...fkIdColumns]`
+                const pkFields = prop.targetMeta.getPrimaryProps().flatMap(pk => {
+                    this.initFieldName(pk);
+                    return pk.fieldNames;
+                });
+                const idColumns = pkFields.map(fieldName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, fieldName, pkFields.length > 1));
+                prop.fieldNames = [prop.discriminatorColumn, ...idColumns];
+            }
+        }
+        else if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             prop.fieldNames = this.initManyToOneFieldName(prop, prop.name);
         }
         else if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
@@ -437,10 +464,13 @@ export class MetadataDiscovery {
     initManyToOneFieldName(prop, name) {
         const meta2 = prop.targetMeta;
         const ret = [];
-        for (const primaryKey of meta2.primaryKeys) {
-            this.initFieldName(meta2.properties[primaryKey]);
-            for (const fieldName of meta2.properties[primaryKey].fieldNames) {
-                ret.push(this.#namingStrategy.joinKeyColumnName(name, fieldName, meta2.compositePK));
+        // with `targetKey` on a composite PK target, derive the FK field name from that property
+        // instead of the PKs (simple PK targets keep the PK based naming for backwards compatibility)
+        const referencedKeys = prop.targetKey && meta2.compositePK ? [prop.targetKey] : meta2.primaryKeys;
+        for (const referencedKey of referencedKeys) {
+            this.initFieldName(meta2.properties[referencedKey]);
+            for (const fieldName of meta2.properties[referencedKey].fieldNames) {
+                ret.push(this.#namingStrategy.joinKeyColumnName(name, fieldName, !prop.targetKey && meta2.compositePK));
             }
         }
         return ret;
@@ -834,7 +864,7 @@ export class MetadataDiscovery {
             pivotMeta.properties[primaryProp.name] = primaryProp;
             pivotMeta.compositePK = false;
         }
-        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: !isCompositePK, nullable: false });
+        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: !prop.fixedOrder, nullable: false });
         this.initFieldName(discriminatorProp);
         pivotMeta.properties[discriminatorColumn] = discriminatorProp;
         const columnTypes = this.getPrimaryKeyColumnTypes(meta);
@@ -849,7 +879,7 @@ export class MetadataDiscovery {
             pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, persist: false });
         }
         else {
-            pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, primary: true, nullable: false });
+            pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, columnTypes, [...prop.joinColumns], { type: meta.className, primary: !prop.fixedOrder, nullable: false });
         }
         pivotMeta.properties[targetMeta.className + '_inverse'] = this.definePivotProperty(prop, targetMeta.className + '_inverse', targetMeta.class, prop.discriminator, false, false);
         // Create virtual M:1 relation to the polymorphic owner for single-query join loading
@@ -871,11 +901,11 @@ export class MetadataDiscovery {
         const discriminatorColumn = prop.discriminatorColumn;
         const targets = prop.polymorphTargets;
         pivotMeta.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.class, prop.discriminator, true, false);
-        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: true, nullable: false });
+        const discriminatorProp = this.createPivotScalarProperty(discriminatorColumn, [this.#platform.getVarcharTypeDeclarationSQL(prop)], [discriminatorColumn], { type: 'string', primary: !prop.fixedOrder, nullable: false });
         this.initFieldName(discriminatorProp);
         pivotMeta.properties[discriminatorColumn] = discriminatorProp;
         const firstTargetColumnTypes = this.getPrimaryKeyColumnTypes(targets[0]);
-        pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, firstTargetColumnTypes, [...prop.inverseJoinColumns], { type: targets[0].className, primary: true, nullable: false });
+        pivotMeta.properties[prop.discriminator] = this.createPivotScalarProperty(prop.discriminator, firstTargetColumnTypes, [...prop.inverseJoinColumns], { type: targets[0].className, primary: !prop.fixedOrder, nullable: false });
         pivotMeta.polymorphicDiscriminatorMap ??= {};
         for (const targetMeta of targets) {
             const relationName = `${prop.discriminator}_${targetMeta.tableName}`;
@@ -942,6 +972,11 @@ export class MetadataDiscovery {
         return primaryProp;
     }
     definePivotProperty(prop, name, type, inverse, owner, selfReferencing) {
+        let index = prop.index ?? this.#platform.indexForeignKeys();
+        if (owner && prop.index) {
+            // owner join columns are the leading prefix of the composite PK, so an explicit `index` only applies to them with `fixedOrder`; a custom index name always belongs to the inverse side
+            index = prop.fixedOrder ? true : this.#platform.indexForeignKeys();
+        }
         const ret = {
             name,
             type: Utils.className(type),
@@ -950,7 +985,7 @@ export class MetadataDiscovery {
             cascade: [Cascade.ALL],
             fixedOrder: prop.fixedOrder,
             fixedOrderColumn: prop.fixedOrderColumn,
-            index: this.#platform.indexForeignKeys(),
+            index,
             primary: !prop.fixedOrder,
             autoincrement: false,
             updateRule: prop.updateRule,
@@ -1036,11 +1071,18 @@ export class MetadataDiscovery {
         }
         // TPT children have their own tables that don't contain the parent's columns,
         // so propagating parent indexes/uniques/checks/triggers would target missing columns.
+        // deep equality, as the subclass items might be copies of the base class ones (e.g. with TC39 decorators)
         if (meta.inheritanceType !== 'tpt' || !meta.tptParent) {
-            meta.indexes = Utils.unique([...base.indexes, ...meta.indexes]);
-            meta.uniques = Utils.unique([...base.uniques, ...meta.uniques]);
-            meta.checks = Utils.unique([...base.checks, ...meta.checks]);
-            meta.triggers = Utils.unique([...base.triggers, ...meta.triggers]);
+            meta.indexes = Utils.unique([...base.indexes, ...meta.indexes], Utils.equals);
+            meta.uniques = Utils.unique([...base.uniques, ...meta.uniques], Utils.equals);
+            meta.checks = Utils.unique([...base.checks, ...meta.checks], Utils.equals);
+            meta.triggers = Utils.unique([...base.triggers, ...meta.triggers], Utils.equals);
+        }
+        // Policies pass down only from inlined abstract bases; STI children share the root table
+        // and TPT children own their tables, so both declare policies directly on the root/child.
+        if (base.abstract && base.inheritanceType !== 'sti' && (meta.inheritanceType !== 'tpt' || !meta.tptParent)) {
+            meta.policies = Utils.unique([...base.policies, ...meta.policies]);
+            meta.rowLevelSecurity ??= base.rowLevelSecurity;
         }
         const pks = Object.values(meta.properties)
             .filter(p => p.primary)
@@ -1184,7 +1226,11 @@ export class MetadataDiscovery {
             return;
         }
         visited.add(embeddedProp);
-        const embeddable = this.#discovered.find(m => m.name === embeddedProp.type);
+        // Prefer resolution via the class reference, the name can be ambiguous when a minifier
+        // mangles two classes to the same name. Only named metadata counts, an auto-discovered
+        // class without the `@Embeddable()` decorator should still fail as unknown below.
+        const embeddable = this.#discovered.find(m => m.name && m.class === embeddedProp.target) ??
+            this.#discovered.find(m => m.name === embeddedProp.type);
         if (!embeddable) {
             throw MetadataError.fromUnknownEntity(embeddedProp.type, `${meta.className}.${embeddedProp.name}`);
         }
@@ -1224,8 +1270,17 @@ export class MetadataDiscovery {
             if (embeddedProp.nullable || refInArray) {
                 meta.properties[name].nullable = true;
             }
+            // polymorphic relations derive their column names from the discriminator, so prefix it too
+            if (meta.properties[name].polymorphic && !object) {
+                meta.properties[name].discriminator = prefix + meta.properties[name].discriminator;
+                meta.properties[name].discriminatorColumn = prefix + meta.properties[name].discriminatorColumn;
+            }
             if (meta.properties[name].fieldNames) {
-                meta.properties[name].fieldNames[0] = prefix + meta.properties[name].fieldNames[0];
+                const { fieldNames, polymorphic } = meta.properties[name];
+                // polymorphic `fieldNames` hold `[discriminatorColumn, ...fkIdColumns]`, so prefix all of them
+                for (let i = 0; i < (polymorphic ? fieldNames.length : 1); i++) {
+                    fieldNames[i] = prefix + fieldNames[i];
+                }
             }
             else {
                 const name2 = meta.properties[name].name;
@@ -1654,6 +1709,9 @@ export class MetadataDiscovery {
                 if (prop.persist === false || prop.nativeEnumName || !prop.items?.every(item => typeof item === 'string')) {
                     continue;
                 }
+                if (prop.customType instanceof t.json || ['json', 'jsonb'].includes(prop.columnTypes?.[0])) {
+                    continue;
+                }
                 this.initFieldName(prop);
                 let expression = null;
                 if (prop.enum) {
@@ -1693,6 +1751,28 @@ export class MetadataDiscovery {
         }
         meta.hasTriggers = true;
     }
+    initPolicies(meta) {
+        if (meta.policies.length === 0) {
+            return;
+        }
+        const columns = meta.createSchemaColumnMappingObject();
+        const table = this.createSchemaTable(meta);
+        // resolve callbacks into a copy — the defs can be shared with siblings via an inlined abstract base,
+        // and resolving in place would bake the first child's table into every other child's policy
+        meta.policies = meta.policies.map(policy => {
+            if (!(policy.using instanceof Function) && !(policy.check instanceof Function)) {
+                return policy;
+            }
+            const resolved = { ...policy };
+            if (resolved.using instanceof Function) {
+                resolved.using = resolved.using(columns, table);
+            }
+            if (resolved.check instanceof Function) {
+                resolved.check = resolved.check(columns, table);
+            }
+            return resolved;
+        });
+    }
     initGeneratedColumn(meta, prop) {
         if (!prop.generated && prop.columnTypes) {
             const match = /(.*) generated always as (.*)/i.exec(prop.columnTypes[0]);
@@ -1997,6 +2077,58 @@ export class MetadataDiscovery {
             }
         }
     }
+    /** Resolves the `through` option of a virtual to-one relation into a read-only formula property. */
+    initThroughRelation(meta, prop) {
+        // already resolved, or not a through relation at all
+        if (prop.through?.ownerProperty || !prop.through) {
+            return;
+        }
+        if (![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+            throw MetadataError.throughRelationInvalidKind(meta, prop);
+        }
+        const targetMeta = prop.targetMeta;
+        // the subquery selects a single column
+        if (targetMeta.compositePK) {
+            throw MetadataError.throughRelationCompositeTarget(meta, prop);
+        }
+        const through = prop.through;
+        const throughMeta = this.#metadata.get(!through.prototype ? through() : through);
+        // a property is considered to point at an entity when it targets it or one of its parents
+        const pointsTo = (p, m) => {
+            const candidate = this.#metadata.find(p.target);
+            /* v8 ignore next 3 */
+            if (!candidate) {
+                return false;
+            }
+            return candidate.class === m.class || m.class.prototype instanceof candidate.class;
+        };
+        const fks = Object.values(throughMeta.properties).filter(p => p.kind === ReferenceKind.MANY_TO_ONE);
+        const ownerProp = fks.find(p => pointsTo(p, meta));
+        if (!ownerProp) {
+            throw MetadataError.throughRelationMissingProperty(meta, prop, throughMeta, 'owner');
+        }
+        let targetProperty;
+        const selectsTarget = throughMeta.class === targetMeta.class || throughMeta.class.prototype instanceof targetMeta.class;
+        if (!selectsTarget) {
+            const targetProp = fks.find(p => p !== ownerProp && pointsTo(p, targetMeta));
+            if (!targetProp) {
+                throw MetadataError.throughRelationMissingProperty(meta, prop, throughMeta, 'target');
+            }
+            targetProperty = targetProp.name;
+        }
+        prop.through = {
+            entity: throughMeta.class,
+            where: prop.where,
+            orderBy: prop.orderBy ? Utils.asArray(prop.orderBy) : undefined,
+            ownerProperty: ownerProp.name,
+            targetProperty,
+        };
+        // the condition and ordering apply to the `through` entity, not to the target, so they must not leak into the target joins
+        delete prop.where;
+        delete prop.orderBy;
+        prop.persist = false;
+        prop.formula = columns => this.#platform.getThroughRelationFormula(prop, columns);
+    }
     initColumnType(prop) {
         this.initUnsigned(prop);
         // Get the target properties for FK relations - use targetKey property if specified, otherwise PKs
@@ -2057,6 +2189,7 @@ export class MetadataDiscovery {
             prop.columnTypes.push(...columnTypes);
             if (!targetMeta.compositePK || prop.targetKey) {
                 prop.customType = referencedProp.customType;
+                prop.collation ??= referencedProp.collation;
             }
         }
     }
@@ -2112,7 +2245,7 @@ export class MetadataDiscovery {
     shouldForceConstructorUsage(meta) {
         const forceConstructor = this.#config.get('forceEntityConstructor');
         if (Array.isArray(forceConstructor)) {
-            return forceConstructor.some(cls => Utils.className(cls) === meta.className);
+            return forceConstructor.some(cls => Utils.matchesEntity(cls, meta));
         }
         return forceConstructor;
     }

package/metadata/MetadataProvider.js

@@ -92,7 +92,7 @@ export class MetadataProvider {
         if (!this.useCache()) {
             return undefined;
         }
-        const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta));
+        const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta), meta.path);
         if (cache) {
             this.loadFromCache(meta, cache);
             meta.root = root;

package/metadata/MetadataStorage.d.ts

@@ -1,13 +1,14 @@
-import { type Dictionary, EntityMetadata, type EntityName } from '../typings.js';
+import { type Dictionary, type EntityCtor, EntityMetadata, type EntityName } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 /** Registry that stores and provides access to entity metadata by class, name, or id. */
 export declare class MetadataStorage {
     #private;
     static readonly PATH_SYMBOL: unique symbol;
+    static readonly META_SYMBOL: unique symbol;
     constructor(metadata?: Dictionary<EntityMetadata>);
-    /** Returns the global metadata dictionary, or a specific entry by entity name and path. */
+    /** Returns the global metadata dictionary, or a specific entry by entity name and path (keyed by the class reference when `target` is provided). */
     static getMetadata(): Dictionary<EntityMetadata>;
-    static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
+    static getMetadata<T = any>(entity: string, path: string, target?: EntityCtor): EntityMetadata<T>;
     /** Checks whether an entity with the given class name exists in the global metadata. */
     static isKnownEntity(name: string): boolean;
     /** Clears all entries from the global metadata registry. */

package/metadata/MetadataStorage.js

@@ -11,11 +11,13 @@ function getGlobalStorage(namespace) {
 /** Registry that stores and provides access to entity metadata by class, name, or id. */
 export class MetadataStorage {
     static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
+    static META_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.META_SYMBOL');
     static #metadata = getGlobalStorage('metadata');
     #metadataMap = new Map();
     #idMap;
     #classNameMap;
     #uniqueNameMap;
+    #ambiguousNames = new Set();
     constructor(metadata = {}) {
         this.#idMap = {};
         this.#uniqueNameMap = {};
@@ -26,8 +28,21 @@ export class MetadataStorage {
             this.#metadataMap.set(meta.class, meta);
         }
     }
-    static getMetadata(entity, path) {
+    static getMetadata(entity, path, target) {
         const key = entity && path ? entity + '-' + Utils.hash(path) : null;
+        // Key the registry by the class reference when available, so two classes minified
+        // to the same mangled name don't collide on the `className-path` key.
+        if (key && target) {
+            if (!Object.hasOwn(target, MetadataStorage.META_SYMBOL)) {
+                Object.defineProperty(target, MetadataStorage.META_SYMBOL, {
+                    value: new EntityMetadata({ className: entity, path }),
+                    writable: true,
+                });
+            }
+            // Keep the name-keyed entry in sync, the class-keyed metadata survives `MetadataStorage.clear()`.
+            MetadataStorage.#metadata[key] = target[MetadataStorage.META_SYMBOL];
+            return target[MetadataStorage.META_SYMBOL];
+        }
         if (key && !MetadataStorage.#metadata[key]) {
             MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
         }
@@ -50,6 +65,10 @@ export class MetadataStorage {
     }
     /** Returns metadata for the given entity, optionally initializing it if not found. */
     get(entityName, init = false) {
+        // string lookups cannot be resolved when several classes were minified to the same name
+        if (typeof entityName === 'string' && this.#ambiguousNames.has(entityName)) {
+            throw MetadataError.ambiguousEntityName(entityName);
+        }
         const exists = this.find(entityName);
         if (exists) {
             return exists;
@@ -85,7 +104,13 @@ export class MetadataStorage {
         this.#metadataMap.set(entityName, meta);
         this.#idMap[meta._id] = meta;
         this.#uniqueNameMap[meta.uniqueName] = meta;
-        this.#classNameMap[Utils.className(entityName)] = meta;
+        const className = Utils.className(entityName);
+        const existing = this.#classNameMap[className];
+        // track name collisions caused by minifiers mangling two classes to the same name
+        if (existing && existing !== meta && existing.class !== meta.class) {
+            this.#ambiguousNames.add(className);
+        }
+        this.#classNameMap[className] = meta;
         return meta;
     }
     /** Removes metadata for the given entity from all internal maps. */
@@ -96,6 +121,11 @@ export class MetadataStorage {
             delete this.#idMap[meta._id];
             delete this.#uniqueNameMap[meta.uniqueName];
             delete this.#classNameMap[meta.className];
+            // the name may still be ambiguous among the remaining metas
+            const remaining = new Set([...this.#metadataMap.values()].filter(m => m.className === meta.className).map(m => m.class));
+            if (remaining.size <= 1) {
+                this.#ambiguousNames.delete(meta.className);
+            }
         }
     }
     /** Decorates all entity prototypes with helper methods (e.g. init, toJSON). */

package/metadata/Routine.js

@@ -135,6 +135,9 @@ export class Routine {
         return new Routine(config);
     }
     static is(item) {
-        return item instanceof Routine;
+        if (item instanceof Routine) {
+            return true;
+        }
+        return item != null && typeof item === 'object' && item.constructor?.name === 'Routine' && 'type' in item;
     }
 }

package/metadata/types.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FormulaCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery, Raw, SchemaColumns, TriggerDef } from '../typings.js';
+import type { AnyEntity, Constructor, EntityName, AnyString, CheckCallback, GeneratedColumnCallback, FormulaCallback, FilterQuery, Dictionary, AutoPath, EntityClass, IndexCallback, ObjectQuery, Raw, SchemaColumns, TriggerDef, PolicyDef } from '../typings.js';
 import type { Cascade, LoadStrategy, DeferMode, QueryOrderMap, EmbeddedPrefixMode } from '../enums.js';
 import type { Type, types } from '../types/index.js';
 import type { EntityManager } from '../EntityManager.js';
@@ -104,6 +104,10 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     hasTriggers?: boolean;
     /** Database triggers to create for this entity's table. (SQL drivers only) */
     triggers?: TriggerDef<E>[];
+    /** PostgreSQL row level security policies for this entity's table. Declaring policies implicitly enables RLS. */
+    policies?: PolicyDef<E>[];
+    /** Enables PostgreSQL row level security on this entity's table. `'force'` also enforces it for the table owner. Set to `false` to keep declared policies staged while leaving RLS disabled. */
+    rowLevelSecurity?: boolean | 'force';
     /**
      * PostgreSQL partitioning definition for this table.
      *
@@ -427,9 +431,15 @@ interface PolymorphicOptions {
      */
     discriminatorMap?: Dictionary<string>;
 }
-export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target>, PolymorphicOptions {
+export interface ManyToOneOptions<Owner, Target, Through = Target> extends ReferenceOptions<Owner, Target>, PolymorphicOptions {
     /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);
+    /** Resolve this read-only relation via a subquery on another entity: a pivot entity with FKs to both sides, or the target itself to pick a single item out of a to-many relation (see {@doclink relationships#to-one-relations-through-another-entity | To-one relations through another entity}). */
+    through?: () => EntityName<Through>;
+    /** Condition applied on the `through` entity. */
+    where?: FilterQuery<Through>;
+    /** Ordering applied on the `through` entity, the first matching row is used. */
+    orderBy?: QueryOrderMap<Through> | QueryOrderMap<Through>[];
     /** Wrap the entity in {@apilink Reference} wrapper. */
     ref?: boolean;
     /** Use this relation as a primary key. */
@@ -481,9 +491,15 @@ export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner,
     /** Point to the owning side property name. */
     mappedBy: (string & keyof Target) | ((e: Target) => any);
 }
-export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>>, PolymorphicOptions {
+export interface OneToOneOptions<Owner, Target, Through = Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy' | 'where'>>, PolymorphicOptions {
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;
+    /** Resolve this read-only relation via a subquery on another entity: a pivot entity with FKs to both sides, or the target itself to pick a single item out of a to-many relation (see {@doclink relationships#to-one-relations-through-another-entity | To-one relations through another entity}). */
+    through?: () => EntityName<Through>;
+    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}, or the condition applied on the `through` entity. */
+    where?: FilterQuery<Through>;
+    /** Ordering applied on the `through` entity, the first matching row is used. */
+    orderBy?: QueryOrderMap<Through> | QueryOrderMap<Through>[];
     /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);
     /** Wrap the entity in {@apilink Reference} wrapper. */

package/naming-strategy/AbstractNamingStrategy.js

@@ -10,7 +10,8 @@ export class AbstractNamingStrategy {
     classToMigrationName(timestamp, customMigrationName) {
         let migrationName = `Migration${timestamp}`;
         if (customMigrationName) {
-            migrationName += `_${customMigrationName}`;
+            // the name becomes part of a class identifier
+            migrationName += `_${customMigrationName.replace(/[^$\p{ID_Continue}]+/gu, '_')}`;
         }
         return migrationName;
     }

package/naming-strategy/NamingStrategy.d.ts

@@ -9,7 +9,8 @@ export interface NamingStrategy {
      */
     classToTableName(entityName: string, tableName?: string): string;
     /**
-     * Return a migration name. This name should allow ordering.
+     * Return a migration name. This name should allow ordering, and has to be a valid class identifier,
+     * as it is used as the class name in the generated migration file.
      */
     classToMigrationName(timestamp: string, customMigrationName?: string): string;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.2.0-dev.2",
+  "version": "7.2.0-dev.21",
   "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/platforms/Platform.d.ts

@@ -1,6 +1,6 @@
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { type NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta, FilterQuery, EntityValue, EntityKey } from '../typings.js';
+import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta, FilterQuery, EntityValue, EntityKey, FormulaColumns } from '../typings.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Configuration } from '../utils/Configuration.js';
@@ -211,8 +211,9 @@ export declare abstract class Platform {
     getBlobDeclarationSQL(): string;
     getJsonDeclarationSQL(): string;
     getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | Raw;
-    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | Raw;
-    processJsonCondition<T extends object>(o: FilterQuery<T>, value: EntityValue<T>, path: EntityKey<T>[], alias: boolean): FilterQuery<T>;
+    /** When `aliased` is a string, it holds an explicit alias the key was prefixed with. */
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean | string, value?: unknown): string | Raw;
+    processJsonCondition<T extends object>(o: FilterQuery<T>, value: EntityValue<T>, path: EntityKey<T>[], alias: boolean | string): FilterQuery<T>;
     protected getJsonValueType(value: unknown): string;
     getJsonIndexDefinition(index: {
         columnNames: string[];
@@ -227,6 +228,12 @@ export declare abstract class Platform {
     formatIndexHint(indexNames: string[]): string | undefined;
     /** Whether the driver automatically parses JSON columns into JS objects. */
     convertsJsonAutomatically(): boolean;
+    /** Whether date values inside JSON documents keep their native type (e.g. BSON dates), instead of being serialized to ISO strings. */
+    preservesDatesInsideJson(): boolean;
+    /** Whether `nulls first`/`nulls last` can be requested in an `orderBy`. */
+    supportsNullsOrdering(): boolean;
+    /** Where nulls land when an `orderBy` requests no explicit placement: lowest (`asc` puts them first) or highest. */
+    sortsNullsLowest(): boolean;
     /** Converts a JS value to its JSON database representation (typically JSON.stringify). */
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
     /** Converts a database JSON value to its JS representation. */
@@ -272,6 +279,11 @@ export declare abstract class Platform {
     formatQuery(sql: string, params: readonly any[]): string;
     /** Deep-clones embeddable data and tags it for JSON serialization. */
     cloneEmbeddable<T>(data: T): T;
+    /**
+     * Builds the correlated subquery used as the formula of a virtual to-one relation defined via `through`.
+     * @internal
+     */
+    getThroughRelationFormula(prop: EntityProperty, columns: FormulaColumns<any>): string;
     /** Initializes the platform with the ORM configuration. */
     setConfig(config: Configuration): void;
     /** Returns the current ORM configuration. */
@@ -313,6 +325,15 @@ export declare abstract class Platform {
     supportsDownMigrations(): boolean;
     /** Whether the platform supports deferred unique constraints. */
     supportsDeferredUniqueConstraints(): boolean;
+    /** Whether the platform supports row level security (PostgreSQL). */
+    supportsRowLevelSecurity(): boolean;
+    /** Whether the driver can apply the session context on every pooled connection acquire (`sessionContext: 'connection'`). */
+    supportsConnectionSessionContext(): boolean;
+    /**
+     * SQL cast suffix (e.g. `'::uuid'`, or `''` when none is needed) applied when an RLS filter reads a session
+     * variable via `current_setting()` as the given column type, or `null` if the type has no automatic cast.
+     */
+    getCurrentSettingCast(mappedType: Type<unknown>): string | null;
     /** Platform-specific validation of entity metadata. */
     validateMetadata(meta: EntityMetadata): void;
     /**