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

package/MikroORM.d.ts

@@ -82,6 +82,10 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * Closes the database connection.
      */
     close(force?: boolean): Promise<void>;
+    /**
+     * Closes the database connection, allows using the ORM instance with `await using`.
+     */
+    [Symbol.asyncDispose](): Promise<void>;
     /**
      * Gets the `MetadataStorage`.
      */

package/MikroORM.js

@@ -2,6 +2,7 @@ import { MetadataDiscovery } from './metadata/MetadataDiscovery.js';
 import { MetadataStorage } from './metadata/MetadataStorage.js';
 import { Configuration } from './utils/Configuration.js';
 import { loadEnvironmentVars } from './utils/env-vars.js';
+import { clearRlsFilterDefsCache } from './utils/rls-utils.js';
 import { Utils } from './utils/Utils.js';
 import { colors } from './logging/colors.js';
 async function tryRegisterExtension(name, pkg, extensions) {
@@ -159,6 +160,12 @@ export class MikroORM {
         await this.config.getMetadataCacheAdapter()?.close?.();
         await this.config.getResultCacheAdapter()?.close?.();
     }
+    /**
+     * Closes the database connection, allows using the ORM instance with `await using`.
+     */
+    async [Symbol.asyncDispose]() {
+        await this.close();
+    }
     /**
      * Gets the `MetadataStorage` (without parameters) or `EntityMetadata` instance when provided with the `entityName` parameter.
      */
@@ -189,6 +196,8 @@ export class MikroORM {
             meta.root = this.#metadata.get(meta.root.class);
         }
         this.#metadata.decorate(this.em);
+        // the newly discovered entities may declare `rls` filters the cached lookup was built without
+        clearRlsFilterDefsCache(this.#metadata);
     }
     /**
      * Gets the SchemaGenerator.

package/cache/CacheAdapter.d.ts

@@ -1,9 +1,10 @@
 /** Interface for async-capable cache storage used by result cache and metadata cache. */
 export interface CacheAdapter {
     /**
-     * Gets the items under `name` key from the cache.
+     * Gets the items under `name` key from the cache. When `origin` is provided, adapters that
+     * track the entry origin should ignore entries cached from a different source file.
      */
-    get<T = any>(name: string): T | Promise<T | undefined> | undefined;
+    get<T = any>(name: string, origin?: string): T | Promise<T | undefined> | undefined;
     /**
      * Sets the item to the cache. `origin` is used for cache invalidation and should reflect the change in data.
      */
@@ -24,9 +25,10 @@ export interface CacheAdapter {
 /** Synchronous variant of CacheAdapter, used for metadata cache where async access is not needed. */
 export interface SyncCacheAdapter extends CacheAdapter {
     /**
-     * Gets the items under `name` key from the cache.
+     * Gets the items under `name` key from the cache. When `origin` is provided, adapters that
+     * track the entry origin should ignore entries cached from a different source file.
      */
-    get<T = any>(name: string): T | undefined;
+    get<T = any>(name: string, origin?: string): T | undefined;
     /**
      * Sets the item to the cache. `origin` is used for cache invalidation and should reflect the change in data.
      */

package/cache/FileCacheAdapter.d.ts

@@ -8,7 +8,7 @@ export declare class FileCacheAdapter implements SyncCacheAdapter {
     /**
      * @inheritDoc
      */
-    get(name: string): any;
+    get(name: string, origin?: string): any;
     /**
      * @inheritDoc
      */

package/cache/FileCacheAdapter.js

@@ -16,12 +16,17 @@ export class FileCacheAdapter {
     /**
      * @inheritDoc
      */
-    get(name) {
+    get(name, origin) {
         const path = this.path(name);
         if (!existsSync(path)) {
             return null;
         }
         const payload = fs.readJSONSync(path);
+        // Two classes with the same name share the cache key, ignore entries cached
+        // from a different source file.
+        if (origin && fs.absolutePath(payload.origin, this.#baseDir) !== fs.absolutePath(origin, this.#baseDir)) {
+            return null;
+        }
         const hash = this.getHash(payload.origin);
         if (!hash || payload.hash !== hash) {
             return null;
@@ -71,7 +76,7 @@ export class FileCacheAdapter {
         let path = typeof this.#options.combined === 'string' ? this.#options.combined : './metadata.json';
         path = fs.normalizePath(this.#options.cacheDir, path);
         this.#options.combined = path; // override in the options, so we can log it from the CLI in `cache:generate` command
-        writeFileSync(path, JSON.stringify(this.#cache, null, this.#pretty ? 2 : undefined));
+        writeFileSync(path, JSON.stringify(this.#cache, null, this.#pretty ? 2 : undefined), { flush: true });
         return path;
     }
     path(name) {

package/connections/Connection.d.ts

@@ -1,7 +1,7 @@
 import { type Configuration, type ConnectionOptions } from '../utils/Configuration.js';
 import type { LogContext, Logger } from '../logging/Logger.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
-import type { ConnectionType, Dictionary, MaybePromise, Primary, RoutineProperty } from '../typings.js';
+import type { ConnectionType, Dictionary, MaybePromise, Primary, RoutineProperty, SessionContext } from '../typings.js';
 import type { Routine } from '../metadata/Routine.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { Type } from '../types/Type.js';
@@ -51,6 +51,13 @@ export declare abstract class Connection {
      * This method doesn't support transactions, as opposed to `orm.schema.execute()`, which is used internally.
      */
     executeDump(dump: string): Promise<void>;
+    /**
+     * Returns the underlying database client the connection drives — e.g. the `pg` pool, the
+     * `better-sqlite3` database, or the `PGlite` instance — for vendor APIs MikroORM does not wrap.
+     * Each driver narrows the return type to its own client. Its lifecycle belongs to the ORM, so
+     * leave closing it to `orm.close()` unless you supplied the client yourself via `driverOptions`.
+     */
+    getNativeClient(): Promise<unknown>;
     protected onConnect(): Promise<void>;
     /** Executes a callback inside a transaction, committing on success and rolling back on failure. */
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
@@ -59,6 +66,7 @@ export declare abstract class Connection {
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
+        sessionContext?: SessionContext;
     }): Promise<T>;
     /** Begins a new database transaction and returns the transaction context. */
     begin(options?: {
@@ -67,6 +75,7 @@ export declare abstract class Connection {
         ctx?: Transaction;
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
+        sessionContext?: SessionContext;
     }): Promise<Transaction>;
     /** Commits the given transaction. */
     commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;

package/connections/Connection.js

@@ -65,6 +65,15 @@ export class Connection {
     async executeDump(dump) {
         throw new Error(`Executing SQL dumps is not supported by current driver`);
     }
+    /**
+     * Returns the underlying database client the connection drives — e.g. the `pg` pool, the
+     * `better-sqlite3` database, or the `PGlite` instance — for vendor APIs MikroORM does not wrap.
+     * Each driver narrows the return type to its own client. Its lifecycle belongs to the ORM, so
+     * leave closing it to `orm.close()` unless you supplied the client yourself via `driverOptions`.
+     */
+    async getNativeClient() {
+        throw new Error(`Accessing the native client is not supported by current driver`);
+    }
     async onConnect() {
         const schemaGenerator = this.config.getExtension('@mikro-orm/schema-generator');
         if (this.type === 'write' && schemaGenerator) {

package/drivers/DatabaseDriver.d.ts

@@ -64,7 +64,23 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
         orderBy: OrderDefinition<T>[];
         where: FilterQuery<T>;
     };
-    protected createCursorCondition<T extends object>(definition: (readonly [keyof T & string, QueryOrder])[], offsets: Dictionary[], inverse: boolean, meta: EntityMetadata<T>): FilterQuery<T>;
+    /**
+     * Resolves a leaf `orderBy` direction into the two flags the rewritten `orderBy` and the cursor
+     * condition have to agree on, or pagination skips rows at the null boundary. A placement the caller
+     * asked for wins where the platform can honor it, anything else follows the platform's own default,
+     * which is what the untouched `orderBy` will get.
+     */
+    private parseCursorDirection;
+    /**
+     * Restores the JS value of a single cursor offset. String-cursor values (`fromJson`) are decoded
+     * JSON: types implementing `fromJSON` own the round trip, other custom types restore via
+     * `convertToJSValue`, with `Date` healing for date-like columns based on the property type (never
+     * based on the string shape alone). POJO values are already JS values and only date-like strings
+     * are healed. Values compared against a JSON document keep their serialized form instead, unless
+     * the platform preserves native date types inside JSON documents (mongo).
+     */
+    private mapCursorOffset;
+    protected createCursorCondition<T extends object>(definition: (readonly [keyof T & string, QueryOrder])[], offsets: Dictionary[], inverse: boolean, meta: EntityMetadata<T>, fromJson?: boolean): FilterQuery<T>;
     /** @internal */
     mapDataToFieldNames(data: Dictionary, stringifyJsonArrays: boolean, properties?: Record<string, EntityProperty>, convertCustomTypes?: boolean, object?: boolean): Dictionary;
     protected inlineEmbeddables<T extends object>(meta: EntityMetadata<T>, data: T, where?: boolean): void;

package/drivers/DatabaseDriver.js

@@ -7,8 +7,10 @@ import { EntityManager } from '../EntityManager.js';
 import { CursorError, ValidationError } from '../errors.js';
 import { DriverException } from '../exceptions.js';
 import { helper } from '../entity/wrap.js';
+import { Reference } from '../entity/Reference.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { JsonType } from '../types/JsonType.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
 import { MikroORM } from '../MikroORM.js';
 /** Abstract base class for all database drivers, implementing common driver logic. */
 export class DatabaseDriver {
@@ -141,14 +143,32 @@ export class DatabaseDriver {
             return !!val && typeof val === 'object' && key in val;
         };
         const createCursor = (val, key, inverse = false) => {
-            let def = isCursor(val, key) ? val[key] : val;
-            if (Utils.isPlainObject(def)) {
-                def = Cursor.for(meta, def, orderBy);
+            const def = Reference.unwrapReference((isCursor(val, key) ? val[key] : val));
+            let offsets;
+            let fromJson = false;
+            // entity (and reference) instances are supported as cursors too, their properties are read the same way
+            if (Utils.isPlainObject(def) || Utils.isEntity(def)) {
+                // POJO values are already JS values, extract them ordered per the definition,
+                // without the JSON round trip `Cursor.for` + `Cursor.decode` would impose
+                offsets = definition.map(([key]) => {
+                    if (def[key] === undefined) {
+                        throw CursorError.missingValue(meta.className, key);
+                    }
+                    return def[key];
+                });
             }
-            /* v8 ignore next */
-            const offsets = def ? Cursor.decode(def) : [];
-            if (definition.length === offsets.length) {
-                return this.createCursorCondition(definition, offsets, inverse, meta);
+            else {
+                try {
+                    /* v8 ignore next */
+                    offsets = def ? Cursor.decode(def) : [];
+                }
+                catch (error) {
+                    throw CursorError.invalidCursor(meta.className, error);
+                }
+                fromJson = true;
+            }
+            if (definition.length > 0 && definition.length === offsets.length) {
+                return this.createCursorCondition(definition, offsets, inverse, meta, fromJson);
             }
             /* v8 ignore next */
             return {};
@@ -162,62 +182,194 @@ export class DatabaseDriver {
         if (limit != null) {
             options.limit = limit + (overfetch ? 1 : 0);
         }
-        const createOrderBy = (prop, direction) => {
+        const createOrderBy = (prop, direction, properties = meta.properties) => {
+            const propMeta = properties[prop];
             if (Utils.isPlainObject(direction)) {
+                const childProps = propMeta?.kind === ReferenceKind.EMBEDDED ? propMeta.embeddedProps : propMeta?.targetMeta?.properties;
                 const value = Utils.getObjectQueryKeys(direction).reduce((o, key) => {
-                    Object.assign(o, createOrderBy(key, direction[key]));
+                    Object.assign(o, createOrderBy(key, direction[key], childProps ?? {}));
                     return o;
                 }, {});
                 return { [prop]: value };
             }
-            const desc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
+            const { desc, nullsFirst, explicit } = this.parseCursorDirection(direction);
             const dir = Utils.xor(desc, isLast) ? 'desc' : 'asc';
+            // only a requested placement is spelled out, an unqualified direction already lands where the
+            // condition expects it; backward pagination reverses the ordering, so the placement flips too
+            if (explicit) {
+                const nulls = Utils.xor(nullsFirst, isLast) ? 'first' : 'last';
+                return { [prop]: `${dir} nulls ${nulls}` };
+            }
             return { [prop]: dir };
         };
+        // the cursor condition is created at the driver level, after the EM already converted custom types
+        // in the user `where`, so we need to run the same conversion over it explicitly
+        const where = QueryHelper.processWhere({
+            where: ($and.length > 1 ? { $and } : { ...$and[0] }),
+            entityName: meta.class,
+            metadata: this.metadata,
+            platform: this.platform,
+            convertCustomTypes: options.convertCustomTypes,
+        });
         return {
             orderBy: definition.map(([prop, direction]) => createOrderBy(prop, direction)),
-            where: ($and.length > 1 ? { $and } : { ...$and[0] }),
+            where,
         };
     }
-    createCursorCondition(definition, offsets, inverse, meta) {
-        const createCondition = (prop, direction, offset, eq = false, path = prop) => {
-            if (Utils.isPlainObject(direction)) {
-                if (offset === undefined) {
-                    throw CursorError.missingValue(meta.className, path);
+    /**
+     * Resolves a leaf `orderBy` direction into the two flags the rewritten `orderBy` and the cursor
+     * condition have to agree on, or pagination skips rows at the null boundary. A placement the caller
+     * asked for wins where the platform can honor it, anything else follows the platform's own default,
+     * which is what the untouched `orderBy` will get.
+     */
+    parseCursorDirection(direction) {
+        const dir = ('' + direction).toLowerCase();
+        const desc = direction === QueryOrderNumeric.DESC || dir.startsWith('desc');
+        const nullsFirst = dir.includes('nulls first');
+        const explicit = (nullsFirst || dir.includes('nulls last')) && this.platform.supportsNullsOrdering();
+        if (!explicit) {
+            return { desc, nullsFirst: this.platform.sortsNullsLowest() ? !desc : desc, explicit };
+        }
+        return { desc, nullsFirst, explicit };
+    }
+    /**
+     * Restores the JS value of a single cursor offset. String-cursor values (`fromJson`) are decoded
+     * JSON: types implementing `fromJSON` own the round trip, other custom types restore via
+     * `convertToJSValue`, with `Date` healing for date-like columns based on the property type (never
+     * based on the string shape alone). POJO values are already JS values and only date-like strings
+     * are healed. Values compared against a JSON document keep their serialized form instead, unless
+     * the platform preserves native date types inside JSON documents (mongo).
+     */
+    mapCursorOffset(prop, value, insideJson, fromJson) {
+        if (Utils.isScalarReference(value)) {
+            value = value.unwrap();
+        }
+        // scalar direction on a relation orders by its primary key
+        if (Utils.isEntity(value, true)) {
+            value = helper(value).getPrimaryKey();
+        }
+        if (value == null) {
+            return value;
+        }
+        // mongo preserves native date types inside JSON documents, restored JS values compare directly
+        if (insideJson && !this.platform.preservesDatesInsideJson()) {
+            // compared against the JSON document, which holds the JSON form of the database value
+            if (value instanceof Date) {
+                return value.toISOString();
+            }
+            if (prop?.customType && fromJson) {
+                const restored = prop.customType.fromJSON
+                    ? prop.customType.fromJSON(value, this.platform)
+                    : prop.customType.convertToJSValue(value, this.platform);
+                // a restored `Date` compares against its ISO string in the document, everything else
+                // keeps the JS value and gets its single `convertToDatabaseValue` in `processWhere`
+                if (restored instanceof Date) {
+                    const converted = prop.customType.convertToDatabaseValue(restored, this.platform, {
+                        fromQuery: true,
+                        key: prop.name,
+                        mode: 'query',
+                    });
+                    if (converted instanceof Date) {
+                        return converted.toISOString();
+                    }
                 }
-                const value = Utils.keys(direction).reduce((o, key) => {
-                    Object.assign(o, createCondition(key, direction[key], offset?.[key], eq, `${path}.${key}`));
-                    return o;
-                }, {});
-                return { [prop]: value };
+                return restored;
             }
-            const isDesc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
-            const dirStr = direction.toString().toLowerCase();
-            let nullsFirst;
-            if (dirStr.includes('nulls first')) {
-                nullsFirst = true;
+            return value;
+        }
+        if (prop?.customType) {
+            if (fromJson && prop.customType.fromJSON) {
+                // the type owns its JSON round trip
+                return prop.customType.fromJSON(value, this.platform);
             }
-            else if (dirStr.includes('nulls last')) {
-                nullsFirst = false;
+            // A string is either a serialized form (string cursor) or a hand-written one (POJO).
+            // Types whose JS value is a `Date` must receive one. The rest get the string first,
+            // so any sub-millisecond precision survives.
+            if (typeof value === 'string' &&
+                (prop.runtimeType === 'Date' || this.platform.getMappedType(prop.columnTypes?.[0] ?? '').runtimeType === 'Date')) {
+                if (prop.runtimeType !== 'Date') {
+                    try {
+                        return prop.customType.convertToJSValue(value, this.platform);
+                    }
+                    catch {
+                        // the type cannot read the serialized string, fall back to the `Date` form
+                    }
+                }
+                return prop.customType.convertToJSValue(new Date(value), this.platform);
             }
-            else {
-                // Default: NULLS LAST for ASC, NULLS FIRST for DESC (matches most databases)
-                nullsFirst = isDesc;
+            // serialized non-string values still need restoring; POJO values are already JS values
+            return fromJson ? prop.customType.convertToJSValue(value, this.platform) : value;
+        }
+        if (typeof value === 'string' && prop?.runtimeType === 'Date') {
+            return new Date(value);
+        }
+        return value;
+    }
+    createCursorCondition(definition, offsets, inverse, meta, fromJson = false) {
+        const createCondition = (prop, direction, offset, eq = false, path = prop, properties = meta.properties, insideJson = false, nullable = false) => {
+            const propMeta = properties[prop];
+            // nullable relations and embeddables null out their joined columns, and a formula can yield null unannounced
+            nullable ||= !!propMeta?.nullable || !!propMeta?.formula;
+            if (Utils.isPlainObject(direction)) {
+                if (offset === undefined) {
+                    throw CursorError.missingValue(meta.className, path);
+                }
+                // POJO cursors can carry entity, reference or embeddable class instances, read their properties directly
+                offset = Reference.unwrapReference(offset);
+                const childProps = propMeta?.kind === ReferenceKind.EMBEDDED ? propMeta.embeddedProps : propMeta?.targetMeta?.properties;
+                insideJson ||=
+                    (propMeta?.kind === ReferenceKind.EMBEDDED && !!propMeta.object) || propMeta?.customType instanceof JsonType;
+                const keys = Utils.keys(direction);
+                const child = (key, childEq) => createCondition(key, direction[key], 
+                // a null relation offset means the whole sort key is null, propagate it to the leaves
+                offset === null ? null : offset[key], childEq, `${path}.${key}`, childProps ?? {}, insideJson, nullable);
+                // the group's own keys are a keyset in their own right, so they decompose the same way the
+                // top level does; merging them into one object would compare every key independently instead
+                const lex = (index) => {
+                    const key = keys[index];
+                    if (index === keys.length - 1) {
+                        return child(key, eq);
+                    }
+                    const atOrPast = child(key, true);
+                    const tail = lex(index + 1);
+                    // an unconstrained tail matches anything, leaving only the `at or past` prefix to constrain
+                    const past = Utils.hasObjectKeys(tail) ? { $or: [child(key, false), tail] } : {};
+                    if (!Utils.hasObjectKeys(past)) {
+                        return atOrPast;
+                    }
+                    return Utils.hasObjectKeys(atOrPast) ? { $and: [atOrPast, past] } : past;
+                };
+                const value = keys.length > 0 ? lex(0) : {};
+                // an unconstrained group condition must not degrade to `{ [prop]: {} }`
+                return Utils.hasObjectKeys(value) ? { [prop]: value } : {};
             }
+            const { desc: isDesc, nullsFirst } = this.parseCursorDirection(direction);
             const operator = Utils.xor(isDesc, inverse) ? '$lt' : '$gt';
             // For leaf-level properties, undefined means missing value
             if (offset === undefined) {
                 throw CursorError.missingValue(meta.className, path);
             }
+            // string-cursor values are client supplied, so a value the type cannot restore is an
+            // invalid cursor, letting callers map `CursorError` to a client error response
+            try {
+                offset = this.mapCursorOffset(propMeta, offset, insideJson, fromJson);
+            }
+            catch (error) {
+                if (!fromJson || error instanceof CursorError) {
+                    throw error;
+                }
+                throw CursorError.invalidCursor(meta.className, error);
+            }
             // Handle null offset (intentional null cursor value)
             if (offset === null) {
+                // hasItemsAfterNull: forward + nullsFirst, or backward + nullsLast
+                const hasItemsAfterNull = Utils.xor(nullsFirst, inverse);
                 if (eq) {
-                    // Equal to null
-                    return { [prop]: null };
+                    // at-or-after a null sort key means every row when non-null rows follow the null block,
+                    // so the tie-breaker in the `$or` sibling can reach past it
+                    return hasItemsAfterNull ? {} : { [prop]: null };
                 }
                 // Strict comparison with null cursor value
-                // hasItemsAfterNull: forward + nullsFirst, or backward + nullsLast
-                const hasItemsAfterNull = Utils.xor(nullsFirst, inverse);
                 if (hasItemsAfterNull) {
                     return { [prop]: { $ne: null } };
                 }
@@ -225,7 +377,12 @@ export class DatabaseDriver {
                 return { [prop]: [] };
             }
             // Non-null offset
-            return { [prop]: { [operator + (eq ? 'e' : '')]: offset } };
+            const condition = { [prop]: { [operator + (eq ? 'e' : '')]: offset } };
+            // null sort keys lie past the offset here, and no comparison ever matches them
+            if (nullable && !Utils.xor(nullsFirst, inverse)) {
+                return { $or: [condition, { [prop]: null }] };
+            }
+            return condition;
         };
         const [order, ...otherOrders] = definition;
         const [offset, ...otherOffsets] = offsets;
@@ -233,13 +390,18 @@ export class DatabaseDriver {
         if (!otherOrders.length) {
             return createCondition(prop, direction, offset);
         }
-        return {
-            ...createCondition(prop, direction, offset, true),
+        const atOrPast = createCondition(prop, direction, offset, true);
+        const past = {
             $or: [
                 createCondition(prop, direction, offset),
-                this.createCursorCondition(otherOrders, otherOffsets, inverse, meta),
+                this.createCursorCondition(otherOrders, otherOffsets, inverse, meta, fromJson),
             ],
         };
+        // the `at or past` prefix is itself a group condition when it compares against nulls
+        if ('$or' in atOrPast) {
+            return { $and: [atOrPast, past] };
+        }
+        return { ...atOrPast, ...past };
     }
     /** @internal */
     mapDataToFieldNames(data, stringifyJsonArrays, properties, convertCustomTypes, object) {
@@ -359,8 +521,8 @@ export class DatabaseDriver {
                 const props = prop.embeddedProps;
                 let unknownProp = false;
                 Object.keys(data[prop.name]).forEach(kk => {
-                    // explicitly allow `$exists`, `$eq`, `$ne` and `$elemMatch` operators here as they can't be misused this way
-                    const operator = Object.keys(data[prop.name]).some(f => Utils.isOperator(f) && !['$exists', '$ne', '$eq', '$elemMatch'].includes(f));
+                    // explicitly allow `$exists`, `$eq`, `$ne`, `$elemMatch` and `$all` operators here as they can't be misused this way
+                    const operator = Object.keys(data[prop.name]).some(f => Utils.isOperator(f) && !['$exists', '$ne', '$eq', '$elemMatch', '$all'].includes(f));
                     if (operator) {
                         throw ValidationError.cannotUseOperatorsInsideEmbeddables(meta.class, prop.name, data);
                     }

package/drivers/IDatabaseDriver.d.ts

@@ -345,6 +345,7 @@ export interface CountByOptions<T extends object> {
     filters?: FilterOptions;
     having?: FilterQuery<T>;
     schema?: string;
+    connectionType?: ConnectionType;
     flushMode?: FlushMode | `${FlushMode}`;
     loggerContext?: LogContext;
     logging?: LoggingOptions;

package/entity/Collection.js

@@ -117,9 +117,11 @@ export class Collection {
             opts.orderBy = QueryHelper.mergeOrderBy(opts.orderBy, this.property.orderBy, this.property.targetMeta?.orderBy);
             options.populate = (await em.preparePopulate(this.property.targetMeta.class, options));
             const cond = (await em.applyFilters(this.property.targetMeta.class, where, options.filters ?? {}, 'read'));
-            const map = await em
+            // fall back to the ambient transaction context, or `withSessionContext` would wrap the pivot load in a
+            // second concurrent transaction (a deadlock with a single-connection pool) instead of joining the open one
+            const map = await em.withSessionContext(ctx ?? em.getTransactionContext(), trx => em
                 .getDriver()
-                .loadFromPivotTable(this.property, [helper(this.owner).__primaryKeys], cond, opts.orderBy, ctx, options);
+                .loadFromPivotTable(this.property, [helper(this.owner).__primaryKeys], cond, opts.orderBy, trx, options));
             items = map[helper(this.owner).getSerializedPrimaryKey()].map((item) => em.merge(this.property.targetMeta.class, item, { convertCustomTypes: true }));
             await em.populate(items, options.populate, options);
         }

package/entity/EntityFactory.js

@@ -77,6 +77,12 @@ export class EntityFactory {
             }
         }
         data = { ...data };
+        if (options.newEntity && meta2.root.inheritanceType === 'sti' && meta2.discriminatorValue != null) {
+            const prop = meta2.properties[meta2.root.discriminatorColumn];
+            if (prop && prop.userDefined !== false) {
+                data[prop.name] ??= meta2.discriminatorValue;
+            }
+        }
         const entity = exists ?? this.createEntity(data, meta2, options);
         wrapped = helper(entity);
         wrapped.__processing = true;

package/entity/EntityLoader.d.ts

@@ -1,4 +1,4 @@
-import type { AnyEntity, AutoPath, ConnectionType, EntityName, EntityProperty, FilterQuery, PopulateHintOptions, PopulateOptions } from '../typings.js';
+import type { AnyEntity, AutoPath, ConnectionType, EntityName, EntityProperty, FilterQuery, ObjectQuery, PopulateHintOptions, PopulateOptions } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
 import type { InflightQueryAbortStrategy } from '../connections/Connection.js';
@@ -14,6 +14,8 @@ export interface EntityLoaderOptions<Entity, Fields extends string = never, Excl
     where?: FilterQuery<Entity>;
     /** Controls how `where` conditions are applied to populated relations. */
     populateWhere?: PopulateHint | `${PopulateHint}`;
+    /** @see FindOptions.populateFilter */
+    populateFilter?: ObjectQuery<Entity>;
     /** Ordering for populated relations. */
     orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     /** Whether to reload already loaded entities. */
@@ -77,6 +79,10 @@ export declare class EntityLoader {
     /** @internal */
     findChildrenFromPivotTable<Entity extends object>(filtered: Entity[], prop: EntityProperty<Entity>, options: Required<EntityLoaderOptions<Entity>>, orderBy?: QueryOrderMap<Entity>[], populate?: PopulateOptions<Entity>, pivotJoin?: boolean): Promise<AnyEntity[][]>;
     private extractChildCondition;
+    /** Extracts the part of `options.populateFilter` that applies to the given relation. */
+    private extractChildPopulateFilter;
+    /** Splits an extracted populate filter into the conditions on the populated entity and those on its own relations. */
+    private splitPopulateFilter;
     private buildFields;
     private getChildReferences;
     private filterCollections;