@mikro-orm/core 7.1.16-dev.10 → 7.1.16-dev.12

package/drivers/DatabaseDriver.d.ts

@@ -65,13 +65,22 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
         where: FilterQuery<T>;
     };
     /**
-     * Restores the JS value of a single cursor offset: ISO strings become `Date` instances based on the
-     * property type (never based on the string shape alone), and custom types are restored via
-     * `convertToJSValue`. Values compared against a JSON document keep their serialized form instead,
-     * unless the platform preserves native date types inside JSON documents (mongo).
+     * 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>): FilterQuery<T>;
+    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

@@ -10,7 +10,6 @@ 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 { DateTimeType } from '../types/DateTimeType.js';
 import { QueryHelper } from '../utils/QueryHelper.js';
 import { MikroORM } from '../MikroORM.js';
 /** Abstract base class for all database drivers, implementing common driver logic. */
@@ -146,6 +145,7 @@ export class DatabaseDriver {
         const createCursor = (val, key, inverse = false) => {
             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,
@@ -158,11 +158,17 @@ export class DatabaseDriver {
                 });
             }
             else {
-                /* v8 ignore next */
-                offsets = def ? Cursor.decode(def) : [];
+                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);
+                return this.createCursorCondition(definition, offsets, inverse, meta, fromJson);
             }
             /* v8 ignore next */
             return {};
@@ -176,21 +182,23 @@ 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 dirStr = direction.toString().toLowerCase();
-            const desc = direction === QueryOrderNumeric.DESC || dirStr.startsWith('desc');
-            let dir = Utils.xor(desc, isLast) ? 'desc' : 'asc';
-            const nullsFirst = dirStr.includes('nulls first');
-            // backward pagination reverses the whole ordering, so the nulls placement flips with the direction
-            if (nullsFirst || dirStr.includes('nulls last')) {
-                dir += Utils.xor(nullsFirst, isLast) ? ' nulls first' : ' nulls last';
+            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 };
         };
@@ -209,12 +217,30 @@ export class DatabaseDriver {
         };
     }
     /**
-     * Restores the JS value of a single cursor offset: ISO strings become `Date` instances based on the
-     * property type (never based on the string shape alone), and custom types are restored via
-     * `convertToJSValue`. Values compared against a JSON document keep their serialized form instead,
-     * unless the platform preserves native date types inside JSON documents (mongo).
+     * 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.
      */
-    mapCursorOffset(prop, value, insideJson) {
+    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();
         }
@@ -225,25 +251,65 @@ export class DatabaseDriver {
         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 serialized form
+            // compared against the JSON document, which holds the JSON form of the database value
             if (value instanceof Date) {
                 return value.toISOString();
             }
-            // restore the JS value from the serialized form, `processWhere` then converts it to
-            // the database form, which is what the JSON document holds for custom typed props
-            return prop?.customType ? prop.customType.convertToJSValue(value, this.platform) : value;
+            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();
+                    }
+                }
+                return restored;
+            }
+            return value;
         }
-        if (typeof value === 'string' &&
-            (prop?.runtimeType === 'Date' ||
-                (prop?.customType && this.platform.getMappedType(prop.columnTypes?.[0] ?? '') instanceof DateTimeType))) {
-            value = new Date(value);
+        if (prop?.customType) {
+            if (fromJson && prop.customType.fromJSON) {
+                // the type owns its JSON round trip
+                return prop.customType.fromJSON(value, this.platform);
+            }
+            // 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);
+            }
+            // 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 prop?.customType ? prop.customType.convertToJSValue(value, this.platform) : value;
+        return value;
     }
-    createCursorCondition(definition, offsets, inverse, meta) {
-        const createCondition = (prop, direction, offset, eq = false, path = prop, properties = meta.properties, insideJson = false) => {
+    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);
@@ -253,40 +319,54 @@ export class DatabaseDriver {
                 const childProps = propMeta?.kind === ReferenceKind.EMBEDDED ? propMeta.embeddedProps : propMeta?.targetMeta?.properties;
                 insideJson ||=
                     (propMeta?.kind === ReferenceKind.EMBEDDED && !!propMeta.object) || propMeta?.customType instanceof JsonType;
-                const value = Utils.keys(direction).reduce((o, key) => {
-                    Object.assign(o, createCondition(key, direction[key], offset?.[key], eq, `${path}.${key}`, childProps ?? {}, insideJson));
-                    return o;
-                }, {});
-                // an unconstrained group must stay unconstrained, an empty object condition would instead
-                // match only rows where every child value is null (e.g. object embeddables)
+                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 dirStr = direction.toString().toLowerCase();
-            const isDesc = direction === QueryOrderNumeric.DESC || dirStr.startsWith('desc');
-            let nullsFirst;
-            if (dirStr.includes('nulls first')) {
-                nullsFirst = true;
-            }
-            else if (dirStr.includes('nulls last')) {
-                nullsFirst = false;
-            }
-            else {
-                // Default: NULLS LAST for ASC, NULLS FIRST for DESC (matches most databases)
-                nullsFirst = isDesc;
-            }
+            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);
             }
-            offset = this.mapCursorOffset(propMeta, offset, insideJson);
+            // 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) {
-                    // the `>=` half of the keyset condition: every row when the nulls come first in this
-                    // direction, only the null ones when they come last
+                    // 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
@@ -297,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;
@@ -305,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) {

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

@@ -635,7 +635,7 @@ export class EntityLoader {
         if (!Utils.isEmpty(prop.where)) {
             where = { $and: [where, prop.where] };
         }
-        const map = await this.#driver.loadFromPivotTable(prop, ids, where, orderBy, this.#em.getTransactionContext(), options2, pivotJoin);
+        const map = await this.#em.withSessionContext(this.#em.getTransactionContext(), ctx => this.#driver.loadFromPivotTable(prop, ids, where, orderBy, ctx, options2, pivotJoin));
         const children = [];
         const isUnionTargetMN = QueryHelper.isUnionTargetPolymorphic(prop);
         for (let i = 0; i < filtered.length; i++) {

package/entity/EntityRepository.d.ts

@@ -1,5 +1,5 @@
 import type { PopulatePath } from '../enums.js';
-import type { CreateOptions, EntityManager, MergeOptions } from '../EntityManager.js';
+import type { CreateOptions, EntityManager, MapOptions, MergeOptions } from '../EntityManager.js';
 import type { AssignOptions } from './EntityAssigner.js';
 import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityName, FilterQuery, Loaded, Primary, AutoPath, RequiredEntityData, Ref, EntityType, EntityDTO, MergeSelected, FromEntityType, IsSubset, MergeLoaded, ArrayElement, IndexFilterQuery, WithUsingOptions } from '../typings.js';
 import type { CountByOptions, CountOptions, DeleteOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from '../drivers/IDatabaseDriver.js';
@@ -115,11 +115,10 @@ export declare class EntityRepository<Entity extends object> {
      */
     nativeDelete(where: FilterQuery<Entity>, options?: DeleteOptions<Entity>): Promise<number>;
     /**
-     * Maps raw database result to an entity and merges it to this EntityManager.
+     * Maps raw database result to an entity and merges it to this EntityManager by default.
+     * Use `disableIdentityMap` to return an isolated entity without affecting the current context.
      */
-    map(result: EntityDictionary<Entity>, options?: {
-        schema?: string;
-    }): Entity;
+    map(result: EntityDictionary<Entity>, options?: Omit<MapOptions, 'mapped'>): Entity;
     /**
      * Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
      * The key option specifies which property to use for identity map lookup instead of the primary key.

package/entity/EntityRepository.js

@@ -131,7 +131,8 @@ export class EntityRepository {
         return this.getEntityManager().nativeDelete(this.entityName, where, options);
     }
     /**
-     * Maps raw database result to an entity and merges it to this EntityManager.
+     * Maps raw database result to an entity and merges it to this EntityManager by default.
+     * Use `disableIdentityMap` to return an isolated entity without affecting the current context.
      */
     map(result, options) {
         return this.getEntityManager().map(this.entityName, result, options);

package/entity/defineEntity.d.ts

@@ -148,6 +148,8 @@ export interface PropertyChain<in out Value, in out Options> {
     orphanRemoval(orphanRemoval?: boolean): HasKind<Options, '1:m' | '1:1'> extends true ? PropertyChain<Value, Options> : never;
     discriminator(discriminator: string): HasKind<Options, 'm:1' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     discriminatorMap(discriminatorMap: Dictionary<string>): HasKind<Options, 'm:1' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    /** Resolve this read-only to-one relation via a subquery on another entity (see {@doclink relationships#to-one-relations-through-another-entity | To-one relations through another entity}). */
+    through(through: () => EntityName): HasKind<Options, 'm:1' | '1:1'> extends true ? PropertyChain<Value, Options> : never;
     pivotTable(pivotTable: string): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     pivotEntity(pivotEntity: () => EntityName): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
     fixedOrder(fixedOrder?: boolean): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
@@ -528,6 +530,8 @@ export declare class UniversalPropertyOptionsBuilder<in out Value, in out Option
     fixedOrderColumn(fixedOrderColumn: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
     pivotTable(pivotTable: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    /** Resolve this read-only to-one relation via a subquery on another entity (see {@doclink relationships#to-one-relations-through-another-entity | To-one relations through another entity}). */
+    through(through: () => EntityName): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
     pivotEntity(pivotEntity: () => EntityName): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
@@ -570,6 +574,13 @@ export declare class UniversalPropertyOptionsBuilder<in out Value, in out Option
 export interface EmptyOptions extends Partial<Record<UniversalPropertyKeys, unknown>> {
 }
 /** @internal */
+export declare class StringPropertyOptionsBuilder<Value, Options> extends UniversalPropertyOptionsBuilder<Value, Options, IncludeKeysForProperty> {
+    trim(): StringPropertyOptionsBuilder<Value, Options>;
+    lowercase(): StringPropertyOptionsBuilder<Value, Options>;
+    uppercase(): StringPropertyOptionsBuilder<Value, Options>;
+    private withOptions;
+}
+/** @internal */
 export declare class OneToManyOptionsBuilderOnlyMappedBy<Value extends object> extends UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
     kind: '1:m';
 }, IncludeKeysForOneToManyOptions> {
@@ -582,7 +593,7 @@ type EntityTarget = {
     '~entity': any;
 } | EntityClass;
 declare const propertyBuilders: PropertyBuilders;
-type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'datetime' | 'time' | 'enum';
+type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'string' | 'text' | 'datetime' | 'time' | 'enum';
 /** Map of factory functions for creating type-safe property builders (scalars, enums, embeddables, and relations). */
 export type PropertyBuilders = {
     [K in Exclude<keyof typeof types, PropertyBuildersOverrideKeys>]: () => UniversalPropertyOptionsBuilder<InferPropertyValueType<(typeof types)[K]>, EmptyOptions, IncludeKeysForProperty>;
@@ -591,6 +602,8 @@ export type PropertyBuilders = {
     array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.array<T>>, EmptyOptions, IncludeKeysForProperty>;
     decimal: <Mode extends 'number' | 'string' = 'string'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.decimal<Mode>>, EmptyOptions, IncludeKeysForProperty>;
     json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
+    string: () => StringPropertyOptionsBuilder<InferPropertyValueType<typeof types.string>, EmptyOptions>;
+    text: () => StringPropertyOptionsBuilder<InferPropertyValueType<typeof types.text>, EmptyOptions>;
     formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
     datetime: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.datetime>, EmptyOptions, IncludeKeysForProperty>;
     time: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.time>, EmptyOptions, IncludeKeysForProperty>;
@@ -638,6 +651,9 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         entity?: EntityName<any> | EntityName<any>[];
         args?: boolean;
         strict?: boolean;
+        rls?: boolean | {
+            setting?: string;
+        };
     }>;
     forceObject?: TForceObject;
     embeddable?: TEmbeddable;

package/entity/defineEntity.js

@@ -403,6 +403,10 @@ export class UniversalPropertyOptionsBuilder {
     pivotTable(pivotTable) {
         return this.assignOptions({ pivotTable });
     }
+    /** Resolve this read-only to-one relation via a subquery on another entity (see {@doclink relationships#to-one-relations-through-another-entity | To-one relations through another entity}). */
+    through(through) {
+        return this.assignOptions({ through });
+    }
     /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
     pivotEntity(pivotEntity) {
         return this.assignOptions({ pivotEntity });
@@ -472,6 +476,27 @@ export class UniversalPropertyOptionsBuilder {
     }
 }
 /** @internal */
+export class StringPropertyOptionsBuilder extends UniversalPropertyOptionsBuilder {
+    trim() {
+        return this.withOptions({ trim: true });
+    }
+    lowercase() {
+        return this.withOptions({ case: 'lower' });
+    }
+    uppercase() {
+        return this.withOptions({ case: 'upper' });
+    }
+    withOptions(options) {
+        const type = this['~options'].type;
+        const TypeClass = typeof type === 'function' ? type : type.constructor;
+        const currentOptions = typeof type === 'function' ? {} : type.options;
+        return new StringPropertyOptionsBuilder({
+            ...this['~options'],
+            type: new TypeClass({ ...currentOptions, ...options }),
+        });
+    }
+}
+/** @internal */
 export class OneToManyOptionsBuilderOnlyMappedBy extends UniversalPropertyOptionsBuilder {
     /** Point to the owning side property name. */
     mappedBy(mappedBy) {
@@ -487,6 +512,12 @@ const propertyBuilders = {
     array: (toJsValue = i => i, toDbValue = i => i) => new UniversalPropertyOptionsBuilder({ type: new types.array(toJsValue, toDbValue) }),
     decimal: (mode) => new UniversalPropertyOptionsBuilder({ type: new types.decimal(mode) }),
     json: () => new UniversalPropertyOptionsBuilder({ type: types.json }),
+    string: () => new StringPropertyOptionsBuilder({
+        type: types.string,
+    }),
+    text: () => new StringPropertyOptionsBuilder({
+        type: types.text,
+    }),
     formula: (formula) => new UniversalPropertyOptionsBuilder({ formula }),
     datetime: (length) => new UniversalPropertyOptionsBuilder({ type: types.datetime, length }),
     time: (length) => new UniversalPropertyOptionsBuilder({ type: types.time, length }),

package/enums.d.ts

@@ -1,4 +1,4 @@
-import type { EntityKey, ExpandProperty } from './typings.js';
+import type { EntityKey, ExpandProperty, SessionContext } from './typings.js';
 import type { InflightQueryAbortStrategy, Transaction } from './connections/Connection.js';
 import type { LogContext } from './logging/Logger.js';
 /** Controls when the `EntityManager` flushes pending changes to the database. */
@@ -309,6 +309,8 @@ export interface TransactionOptions {
     flushMode?: FlushMode | `${FlushMode}`;
     ignoreNestedTransactions?: boolean;
     loggerContext?: LogContext;
+    /** @internal database session context applied on `begin()` (set via `em.setSessionContext()`). */
+    sessionContext?: SessionContext;
     /**
      * `AbortSignal` cancelling every query within the transaction (including the implicit flush).
      * Cancelling mid-transaction triggers a rollback once the in-flight query settles.

package/errors.d.ts

@@ -25,6 +25,13 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static invalidCompositeIdentifier(meta: EntityMetadata): ValidationError;
     static cannotCommit(): ValidationError;
     static cannotUseGlobalContext(): ValidationError;
+    static sessionContextNotSupported(): ValidationError;
+    static sessionContextRequiresImplicitTransactions(): ValidationError;
+    static sessionContextWithDisabledTransactions(): ValidationError;
+    static sessionContextInsideTransaction(action?: 'set' | 'clear'): ValidationError;
+    static cannotStageNonScalarSessionVariable(filterName: string, argName: string): ValidationError;
+    static sessionContextStreamRequiresTransaction(): ValidationError;
+    static connectionSessionContextNotSupported(): ValidationError;
     static cannotUseOperatorsInsideEmbeddables(entityName: EntityName, propName: string, payload: unknown): ValidationError;
     static cannotUseGroupOperatorsInsideScalars(entityName: EntityName, propName: string, payload: unknown): ValidationError;
     static invalidEmbeddableQuery(entityName: EntityName, propName: string, embeddableType: string): ValidationError;
@@ -34,6 +41,7 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
 export declare class CursorError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
     static entityNotPopulated(entity: AnyEntity, prop: string): ValidationError;
     static missingValue(entityName: string, prop: string): ValidationError;
+    static invalidCursor(entityName: string, cause: Error): CursorError;
 }
 /** Error thrown when an optimistic lock conflict is detected during entity persistence. */
 export declare class OptimisticLockError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
@@ -66,6 +74,9 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError;
     static nonPersistentCompositeProp(meta: EntityMetadata, prop: EntityProperty): MetadataError;
     static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError;
+    static throughRelationMissingProperty(meta: EntityMetadata, prop: EntityProperty, through: EntityMetadata, side: 'owner' | 'target'): MetadataError;
+    static throughRelationCompositeTarget(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static throughRelationInvalidKind(meta: EntityMetadata, prop: EntityProperty): MetadataError;
     static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError;
     static targetKeyOnManyToMany(meta: EntityMetadata, prop: EntityProperty): MetadataError;
     static targetKeyNotUnique(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError;
@@ -77,6 +88,30 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static tptNotSupportedByDriver(meta: EntityMetadata): MetadataError;
     /** Thrown when database triggers are defined on an entity using a driver that does not support them. */
     static triggersNotSupportedByDriver(meta: EntityMetadata): MetadataError;
+    /** Thrown when row level security is declared on an entity using a driver that does not support it. */
+    static rowLevelSecurityNotSupportedByDriver(meta: EntityMetadata): MetadataError;
+    /** Thrown when row level security is declared on a non-root entity of an STI hierarchy. */
+    static rowLevelSecurityOnNonRootStiEntity(meta: EntityMetadata): MetadataError;
+    /** Thrown when two policies on the same entity are given the same explicit name. */
+    static duplicatePolicyName(meta: EntityMetadata, name: string): MetadataError;
+    /** Thrown when a filter flagged with `rls` is declared on a driver that does not support row level security. */
+    static rlsFilterNotSupportedByDriver(meta: EntityMetadata, filterName: string): MetadataError;
+    /** Thrown when a filter flagged with `rls` is declared on a non-root entity of an STI hierarchy. */
+    static rlsFilterOnNonRootStiEntity(meta: EntityMetadata, filterName: string): MetadataError;
+    /** Thrown when a global (config or EM registered) filter is flagged with `rls`; RLS filters must be entity scoped. */
+    static rlsFilterMustBeEntityScoped(filterName: string): MetadataError;
+    /** Thrown when an entity-scoped `rls` filter is registered at runtime via `em.addFilter()` instead of in metadata. */
+    static rlsFilterCannotBeRegisteredAtRuntime(filterName: string): MetadataError;
+    /** Thrown when a filter's custom `setting` is used with more than one argument. */
+    static rlsFilterMultiArgSetting(filterName: string, args: string[]): MetadataError;
+    /** Thrown when an `rls` filter's condition depends on runtime state and cannot be compiled to a static policy. */
+    static rlsFilterDependsOnRuntimeState(filterName: string): MetadataError;
+    /** Thrown when an `rls` filter compares against a column whose type has no automatic session-variable cast. */
+    static rlsFilterUncastableType(filterName: string, columnType: string): MetadataError;
+    /** Thrown when an `rls` filter references an argument outside of a direct comparison, which cannot be compiled. */
+    static rlsFilterUnsupportedCond(filterName: string): MetadataError;
+    /** Thrown when an `rls` filter compares against a column the schema generator does not manage. */
+    static rlsFilterUnmanagedColumn(filterName: string, column: string): MetadataError;
     private static fromMessage;
 }
 /** Error thrown when an entity lookup fails to find the expected result. */