@mikro-orm/core 7.2.0-dev.9 → 7.2.0

package/types/TextType.d.ts

@@ -1,9 +1,7 @@
-import { Type } from './Type.js';
+import { BaseStringType } from './StringType.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
 /** Maps a database TEXT column (unbounded length) to a JS `string`. */
-export declare class TextType extends Type<string | null | undefined, string | null | undefined> {
+export declare class TextType extends BaseStringType {
     getColumnType(prop: EntityProperty, platform: Platform): string;
-    compareAsType(): string;
-    ensureComparable(): boolean;
 }

package/types/TextType.js

@@ -1,13 +1,7 @@
-import { Type } from './Type.js';
+import { BaseStringType } from './StringType.js';
 /** Maps a database TEXT column (unbounded length) to a JS `string`. */
-export class TextType extends Type {
+export class TextType extends BaseStringType {
     getColumnType(prop, platform) {
         return platform.getTextTypeDeclarationSQL(prop);
     }
-    compareAsType() {
-        return 'string';
-    }
-    ensureComparable() {
-        return false;
-    }
 }

package/types/Type.d.ts

@@ -59,6 +59,17 @@ export declare abstract class Type<JSType = string, DBType = JSType> {
      * By default uses the runtime value.
      */
     toJSON(value: JSType, platform: Platform): JSType | DBType;
+    /**
+     * Converts a value from its serialized JSON form back to its JS representation. Used when
+     * decoding cursor values. The input is what `toJSON` produced, after a `JSON.parse` round
+     * trip, and never an already restored JS value. Cursors are client supplied, so the value
+     * can be any JSON shape: validate it and throw for values the type cannot restore, and
+     * `findByCursor` surfaces the failure as a `CursorError`.
+     * Implementing this method also makes cursor encoding use `toJSON`. Without it, cursors
+     * carry the raw JS value, and decoding falls back to `convertToJSValue`, with type-based
+     * `Date` restoration for date-like columns.
+     */
+    fromJSON?(value: unknown, platform: Platform): JSType;
     /**
      * Gets the SQL declaration snippet for a field of this type.
      */

package/types/Type.js

@@ -55,11 +55,11 @@ export class Type {
         return prop.columnTypes?.[0] ?? platform.getTextTypeDeclarationSQL(prop);
     }
     static getType(cls) {
-        const key = cls.name;
-        if (!Type.types.has(key)) {
-            Type.types.set(key, new cls());
+        // keyed by class reference, as minifiers can mangle two classes to the same name
+        if (!Type.types.has(cls)) {
+            Type.types.set(cls, new cls());
         }
-        return Type.types.get(key);
+        return Type.types.get(cls);
     }
     /**
      * Checks whether the argument is instance of `Type`.

package/types/index.d.ts

@@ -15,7 +15,7 @@ import { IntervalType } from './IntervalType.js';
 import { JsonType } from './JsonType.js';
 import { MediumIntType } from './MediumIntType.js';
 import { SmallIntType } from './SmallIntType.js';
-import { StringType } from './StringType.js';
+import { type StringTypeOptions, StringType } from './StringType.js';
 import { TextType } from './TextType.js';
 import { TimeType } from './TimeType.js';
 import { TinyIntType } from './TinyIntType.js';
@@ -23,7 +23,7 @@ import { type IType, type TransformContext, Type } from './Type.js';
 import { Uint8ArrayType } from './Uint8ArrayType.js';
 import { UnknownType } from './UnknownType.js';
 import { UuidType } from './UuidType.js';
-export type { TransformContext, IType };
+export type { TransformContext, IType, StringTypeOptions };
 export { Type, DateType, TimeType, DateTimeType, BigIntType, BlobType, Uint8ArrayType, ArrayType, EnumArrayType, EnumType, JsonType, IntegerType, SmallIntType, TinyIntType, MediumIntType, FloatType, DoubleType, BooleanType, DecimalType, StringType, UuidType, TextType, UnknownType, IntervalType, CharacterType, };
 /** Registry of all built-in type constructors, keyed by their short name (e.g., `types.integer`, `types.uuid`). */
 export declare const types: {

package/typings.d.ts

@@ -314,6 +314,7 @@ export type OperatorMap<T> = {
     $ne?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
     $in?: readonly ExpandScalar<T>[] | readonly Primary<T>[] | Raw | Subquery;
     $nin?: readonly ExpandScalar<T>[] | readonly Primary<T>[] | Raw | Subquery;
+    $all?: readonly ExpandQuery<T>[];
     $not?: ExpandQuery<T>;
     $none?: ExpandQuery<T>;
     $some?: ExpandQuery<T>;
@@ -478,12 +479,12 @@ type NonArrayObject = object & {
 export type EntityDataProp<T, C extends boolean> = T extends Date ? string | Date : T extends Scalar ? T : T extends ScalarReference<infer U> ? EntityDataProp<U, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? EntityDataNested<U, C> : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
+} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? EntityDataNested<U, C> : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? [U] extends [NonArrayObject] ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
 /** Like `EntityDataProp` but used in `RequiredEntityData` context with required/optional key distinction. */
 export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : Exclude<T, null> extends RequiredNullable.Brand ? T | null : T extends Scalar ? T : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? RequiredEntityDataNested<U, O, C> : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
+} ? C extends true ? Raw : Runtime : T extends LazyRef.Brand<infer U> ? RequiredEntityDataNested<U, O, C> : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? [U] extends [NonArrayObject] ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
 /** Nested entity data shape for embedded or related entities within `EntityData`. */
 export type EntityDataNested<T, C extends boolean = false> = T extends undefined ? never : T extends any[] ? Readonly<T> : EntityData<T, C> | ExpandEntityProp<T, C>;
 type UnwrapScalarRef<T> = T extends ScalarReference<infer U> ? U : T;
@@ -653,6 +654,16 @@ export type SerializeDTO<T, H extends string = never, E extends string = never,
 };
 type TargetKeys<T> = T extends EntityClass<infer P> ? keyof P : keyof T;
 type PropertyName<T> = IsUnknown<T> extends false ? TargetKeys<T> : string;
+/** Resolved `through` option of a virtual to-one relation, populated during discovery. */
+export interface ThroughRelation {
+    entity: EntityClass;
+    where?: FilterQuery<any>;
+    orderBy?: QueryOrderMap<any>[];
+    /** M:1 property on the `through` entity pointing back to the owner. */
+    ownerProperty: string;
+    /** M:1 property on the `through` entity pointing to the target, undefined when the target is selected directly. */
+    targetProperty?: string;
+}
 /** Table reference object passed to formula callbacks, including alias and schema information. */
 export type FormulaTable = {
     alias: string;
@@ -710,6 +721,8 @@ export type IndexCallback<T> = (columns: Record<PropertyName<T>, string>, table:
 export type FormulaCallback<T> = (columns: FormulaColumns<T>, table: FormulaTable) => string | Raw;
 /** Callback for CHECK constraint expressions. Receives column mappings and table info. */
 export type CheckCallback<T> = (columns: SchemaColumns<T>, table: SchemaTable) => string | Raw;
+/** Callback for row level security policy expressions. Receives column mappings and table info. */
+export type PolicyCallback<T> = (columns: SchemaColumns<T>, table: SchemaTable) => string | Raw;
 /** Callback for trigger body expressions. Receives column mappings and table info. */
 export type TriggerCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
 /**
@@ -724,6 +737,28 @@ export interface CheckConstraint<T = any> {
     property?: string;
     expression: string | Raw | CheckCallback<T>;
 }
+/** Definition of a PostgreSQL row level security policy on a table. */
+export interface PolicyDef<T = any> {
+    /** Policy name. Auto-generated if omitted. */
+    name?: string;
+    /** DML command the policy applies to. Defaults to `'all'`. */
+    command?: 'select' | 'insert' | 'update' | 'delete' | 'all';
+    /** Whether the policy is permissive (OR-combined) or restrictive (AND-combined). Defaults to `'permissive'`. */
+    type?: 'permissive' | 'restrictive';
+    /** Database roles the policy applies to. Defaults to `PUBLIC`. */
+    roles?: string[];
+    /** `USING` expression filtering visible rows. Can be a string, Raw query, or callback receiving column name mappings. */
+    using?: string | Raw | PolicyCallback<T>;
+    /** `WITH CHECK` expression validating written rows. Can be a string, Raw query, or callback receiving column name mappings. */
+    check?: string | Raw | PolicyCallback<T>;
+}
+/** Per-context database session state applied for row level security (session variables and role). */
+export interface SessionContext {
+    /** Session variables set via `set_config`, typically referenced by RLS policies through `current_setting()`. `Date` values are serialized to ISO 8601. */
+    variables?: Dictionary<string | number | boolean | Date>;
+    /** Database role to switch to for the duration of the context (`set local role` / `set role`). */
+    role?: string;
+}
 /** Definition of a database trigger on a table. */
 export interface TriggerDef<T = any> {
     /** Trigger name. Auto-generated if omitted. */
@@ -1019,6 +1054,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     fixedOrderColumn?: string;
     pivotTable: string;
     pivotEntity: EntityClass<Target>;
+    through?: ThroughRelation;
     joinColumns: string[];
     ownColumns: string[];
     inverseJoinColumns: string[];
@@ -1050,6 +1086,12 @@ export declare class EntityMetadata<Entity = any, Class extends EntityCtor<Entit
     constructor(meta?: Partial<EntityMetadata>);
     addProperty(prop: Partial<EntityProperty<Entity>>): void;
     removeProperty(name: string, sync?: boolean): void;
+    /** For TPT entities, the version column exists only on the table of the entity that declares it. */
+    ownsVersionProperty(): boolean;
+    /** For TPT entities, concurrency check columns exist only on the table of the entity that declares them. */
+    getOwnConcurrencyCheckKeys(): EntityKey<Entity>[];
+    /** Whether updates of this table are guarded by a version property or concurrency check columns it owns. */
+    hasOptimisticLock(): boolean;
     getPrimaryProps(flatten?: boolean): EntityProperty<Entity>[];
     getPrimaryProp(): EntityProperty<Entity>;
     /**
@@ -1165,6 +1207,9 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     }[];
     checks: CheckConstraint<Entity>[];
     triggers: TriggerDef<Entity>[];
+    policies: PolicyDef<Entity>[];
+    /** Enables row level security on the table. `'force'` also enables it for the table owner. Implied by non-empty `policies`, unless set to `false`, which keeps the policies staged but RLS disabled. */
+    rowLevelSecurity?: boolean | 'force';
     repositoryClass?: string;
     repository: () => EntityClass<EntityRepository<any>>;
     hooks: {
@@ -1492,6 +1537,15 @@ type FilterDefResolved<T extends object = any> = {
     entity?: EntityName<T> | EntityName<T>[];
     args?: boolean;
     strict?: boolean;
+    /**
+     * Also materializes this filter as a PostgreSQL row level security policy on the entity's table, and stages the
+     * matching session variables when its params are enabled via `em.setFilterParams()`. The `cond` must be compilable
+     * to a static expression (no access to `em`/`type`/`options`, not async). Each referenced argument maps to a session
+     * variable named `mikro.<filterName>.<argName>`; pass `{ setting }` to override that name for a single-argument filter.
+     */
+    rls?: boolean | {
+        setting?: string;
+    };
 };
 /** Definition of a query filter that can be registered globally or per-entity via `@Filter()`. */
 export type FilterDef<T extends EntityName | readonly EntityName[] = any> = FilterDefResolved<EntityFromInput<T>> & {

package/typings.js

@@ -49,6 +49,7 @@ export class EntityMetadata {
         this.uniques = [];
         this.checks = [];
         this.triggers = [];
+        this.policies = [];
         this.referencingProperties = [];
         this.concurrencyCheckKeys = new Set();
         Object.assign(this, meta);
@@ -79,6 +80,25 @@ export class EntityMetadata {
             this.sync();
         }
     }
+    /** For TPT entities, the version column exists only on the table of the entity that declares it. */
+    ownsVersionProperty() {
+        if (!this.versionProperty) {
+            return false;
+        }
+        return this.inheritanceType !== 'tpt' || !this.ownProps || this.ownProps.some(p => p.name === this.versionProperty);
+    }
+    /** For TPT entities, concurrency check columns exist only on the table of the entity that declares them. */
+    getOwnConcurrencyCheckKeys() {
+        const keys = [...this.concurrencyCheckKeys];
+        if (this.inheritanceType !== 'tpt' || !this.ownProps) {
+            return keys;
+        }
+        return keys.filter(key => this.ownProps.some(p => p.name === key));
+    }
+    /** Whether updates of this table are guarded by a version property or concurrency check columns it owns. */
+    hasOptimisticLock() {
+        return this.ownsVersionProperty() || this.getOwnConcurrencyCheckKeys().length > 0;
+    }
     getPrimaryProps(flatten = false) {
         const pks = this.primaryKeys.map(pk => this.properties[pk]);
         if (flatten) {
@@ -216,7 +236,10 @@ export class EntityMetadata {
         if (config) {
             const platform = config.getPlatform();
             for (const prop of this.props) {
-                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
+                if (prop.enum &&
+                    !prop.nativeEnumName &&
+                    prop.items?.every(item => typeof item === 'string') &&
+                    !['json', 'jsonb'].includes(prop.columnTypes?.[0])) {
                     const name = platform.getIndexName(this.tableName, prop.fieldNames, 'check');
                     const exists = this.checks.findIndex(check => check.name === name);
                     if (exists !== -1) {

package/unit-of-work/ChangeSetPersister.js

@@ -204,13 +204,14 @@ export class ChangeSetPersister {
     }
     checkConcurrencyKeys(meta, changeSet, cond) {
         const tmp = [];
-        for (const key of meta.concurrencyCheckKeys) {
+        const keys = meta.getOwnConcurrencyCheckKeys();
+        for (const key of keys) {
             cond[key] = changeSet.originalEntity[key];
             if (changeSet.payload[key]) {
                 tmp.push(key);
             }
         }
-        if (tmp.length === 0 && meta.concurrencyCheckKeys.size > 0) {
+        if (tmp.length === 0 && keys.length > 0) {
             throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
@@ -303,32 +304,33 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
-        if (meta.concurrencyCheckKeys.size === 0 &&
-            (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
+        if (meta.getOwnConcurrencyCheckKeys().length === 0 &&
+            (!meta.ownsVersionProperty() || changeSet.entity[meta.versionProperty] == null)) {
             return this.#driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
         }
-        if (meta.versionProperty) {
+        if (meta.ownsVersionProperty()) {
             cond[meta.versionProperty] = this.#platform.convertVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
         }
         this.checkConcurrencyKeys(meta, changeSet, cond);
         return this.#driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
     }
     async checkOptimisticLocks(meta, changeSets, options) {
-        if (meta.concurrencyCheckKeys.size === 0 &&
-            (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
+        const concurrencyCheckKeys = meta.getOwnConcurrencyCheckKeys();
+        if (concurrencyCheckKeys.length === 0 &&
+            (!meta.ownsVersionProperty() || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
             return;
         }
         // skip entity references as they don't have version values loaded
         changeSets = changeSets.filter(cs => helper(cs.entity).__initialized);
+        const primaryKeys = meta.primaryKeys.concat(...concurrencyCheckKeys);
         const $or = changeSets.map(cs => {
-            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
-            if (meta.versionProperty) {
+            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, primaryKeys);
+            if (meta.ownsVersionProperty()) {
                 // @ts-ignore
                 cond[meta.versionProperty] = this.#platform.convertVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
             }
             return cond;
         });
-        const primaryKeys = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
         options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
             orderBy: meta.primaryKeys.reduce((o, pk) => {
@@ -336,7 +338,9 @@ export class ChangeSetPersister {
                 return o;
             }, {}),
         });
-        const res = await this.#driver.find(meta.root.class, { $or }, options);
+        // TPT tables query their own metadata, as the version column might not live on the root table
+        const target = meta.inheritanceType === 'tpt' ? meta : meta.root;
+        const res = await this.#driver.find(target.class, { $or }, options);
         if (res.length !== changeSets.length) {
             // a FK pointing to a composite PK is an array, so the values need to be compared deeply
             const compare = (a, b, keys) => keys.every(k => equals(a[k], b[k]));
@@ -347,7 +351,7 @@ export class ChangeSetPersister {
         }
     }
     checkOptimisticLock(meta, changeSet, res) {
-        if ((meta.versionProperty || meta.concurrencyCheckKeys.size > 0) && res && !res.affectedRows) {
+        if ((meta.ownsVersionProperty() || meta.getOwnConcurrencyCheckKeys().length > 0) && res && !res.affectedRows) {
             throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
@@ -356,7 +360,7 @@ export class ChangeSetPersister {
      * so we use a single query in case of both versioning and default values is used.
      */
     async reloadVersionValues(meta, changeSets, options) {
-        const reloadProps = meta.versionProperty && !this.#usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
+        const reloadProps = meta.ownsVersionProperty() && !this.#usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
         if (changeSets[0].type === ChangeSetType.CREATE) {
             for (const prop of meta.props) {
                 if (prop.persist === false) {

package/unit-of-work/UnitOfWork.js

@@ -124,7 +124,6 @@ export class UnitOfWork {
         if (options?.newEntity) {
             return entity;
         }
-        const forceUndefined = this.#em.config.get('forceUndefined');
         const wrapped = helper(entity);
         if (options?.loaded && wrapped.__initialized && !wrapped.__onLoadFired) {
             this.#loadedEntities.add(entity);
@@ -332,6 +331,7 @@ export class UnitOfWork {
                     let parentCs = changeSet.tptChangeSets.find(pc => pc.meta === current);
                     if (!parentCs) {
                         parentCs = new ChangeSet(entity, changeSet.type, {}, current);
+                        parentCs.originalEntity = changeSet.originalEntity;
                         changeSet.tptChangeSets.splice(idx, 0, parentCs);
                     }
                     idx++;
@@ -472,6 +472,7 @@ export class UnitOfWork {
                 const loggerContext = Utils.merge({ id: this.#em._id }, this.#em.getLoggerContext({ disableContextResolution: true }));
                 await this.#em.getConnection('write').transactional(trx => this.persistToDatabase(groups, trx), {
                     ctx: oldTx,
+                    sessionContext: this.#em.getTransactionSessionContext(),
                     eventBroadcaster: new TransactionEventBroadcaster(this.#em),
                     loggerContext,
                 });
@@ -527,6 +528,10 @@ export class UnitOfWork {
                     if (prop.formula) {
                         delete referrer[prop.name];
                     }
+                    else if (prop.primary) {
+                        // the referrer's primary key contains the removed entity, so its identity cannot survive the removal
+                        this.unsetIdentity(referrer);
+                    }
                     else {
                         delete helper(referrer).__data[prop.name];
                     }
@@ -702,13 +707,14 @@ export class UnitOfWork {
                     payload[pk] = identifiers[i] ?? originalChangeSet.payload[pk];
                 }
             }
-            if (!isCreate && Object.keys(payload).length === 0) {
+            // the table declaring the version property or a concurrency check still needs its bump and lock check
+            if (!isCreate && Object.keys(payload).length === 0 && !current.hasOptimisticLock()) {
                 current = current.tptParent;
                 continue;
             }
             const cs = new ChangeSet(entity, originalChangeSet.type, payload, current);
+            cs.originalEntity = originalChangeSet.originalEntity;
             if (current === meta) {
-                cs.originalEntity = originalChangeSet.originalEntity;
                 leafCs = cs;
             }
             else {
@@ -1205,7 +1211,8 @@ export class UnitOfWork {
         const addToGroup = (cs) => {
             // Skip stub TPT changesets with empty payload (e.g. leaf with no own-property changes on UPDATE)
             if ((cs.type === ChangeSetType.UPDATE || cs.type === ChangeSetType.UPDATE_EARLY) &&
-                !Utils.hasObjectKeys(cs.payload)) {
+                !Utils.hasObjectKeys(cs.payload) &&
+                !cs.meta.hasOptimisticLock()) {
                 return;
             }
             const group = groups[cs.type];

package/utils/Configuration.d.ts

@@ -439,7 +439,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      */
     filters: Dictionary<{
         name?: string;
-    } & Omit<FilterDef, 'name'>>;
+    } & Omit<FilterDef, 'name' | 'rls'>>;
     /**
      * Metadata discovery configuration options.
      * Controls how entities are discovered and validated.
@@ -480,6 +480,12 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @default false
      */
     disableTransactions?: boolean;
+    /**
+     * How `em.setSessionContext()` session variables/role are applied for row level security.
+     * `'transaction'` (default) emits `set_config(..., true)` inside each transaction; `'connection'` applies them on every pooled connection acquire (PostgreSQL only).
+     * @default 'transaction'
+     */
+    sessionContext?: 'transaction' | 'connection';
     /**
      * Enable verbose logging of internal operations.
      * @default false
@@ -840,6 +846,14 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
          * @default false
          */
         ignoreRoutines?: boolean;
+        /**
+         * Leave row level security policies unmanaged. Declared policies are still created and RLS is still enabled or
+         * forced based on the entity metadata, but existing policies are never dropped or altered and RLS is never
+         * disabled or unforced — use this to protect hand-written policies from being removed when they are not
+         * mirrored in the entity definitions.
+         * @default false
+         */
+        ignorePolicies?: boolean;
         /**
          * Table names or patterns to skip during schema generation.
          * @default []

package/utils/Configuration.js

@@ -7,7 +7,7 @@ import { Utils } from '../utils/Utils.js';
 import { Routine } from '../metadata/Routine.js';
 import { MetadataValidator } from '../metadata/MetadataValidator.js';
 import { MetadataProvider } from '../metadata/MetadataProvider.js';
-import { NotFoundError } from '../errors.js';
+import { MetadataError, NotFoundError, ValidationError } from '../errors.js';
 import { RequestContext } from './RequestContext.js';
 import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums.js';
 import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter.js';
@@ -71,6 +71,7 @@ const DEFAULTS = {
     ensureDatabase: true,
     ensureIndexes: false,
     batchSize: 300,
+    sessionContext: 'transaction',
     debug: false,
     ignoreDeprecations: false,
     verbose: false,
@@ -94,6 +95,7 @@ const DEFAULTS = {
         ignoreSchema: [],
         ignoreTriggers: false,
         ignoreRoutines: false,
+        ignorePolicies: false,
         skipTables: [],
         skipViews: [],
         skipColumns: {},
@@ -393,7 +395,15 @@ export class Configuration {
         }
         this.#options.schema ??= this.#platform.getDefaultSchemaName();
         this.#options.charset ??= this.#platform.getDefaultCharset();
+        // fail closed instead of silently applying no session state on drivers without the reserve hook (e.g. pglite)
+        if (this.#options.sessionContext === 'connection' && !this.#platform.supportsConnectionSessionContext()) {
+            throw ValidationError.connectionSessionContextNotSupported();
+        }
         Object.keys(this.#options.filters).forEach(key => {
+            // global filters have no entity to attach a policy to, so `rls` is only valid on entity-scoped filters
+            if (this.#options.filters[key].rls) {
+                throw MetadataError.rlsFilterMustBeEntityScoped(key);
+            }
             this.#options.filters[key].default ??= true;
         });
         if (!this.#options.filtersOnRelations) {

package/utils/Cursor.d.ts

@@ -61,6 +61,8 @@ export declare class Cursor<Entity extends object, Hint extends string = never,
      * Computes the cursor value for a given entity.
      */
     from(entity: Entity | Loaded<Entity, Hint, Fields, Excludes>): string;
+    /** Serializes a single cursor value, walking nested directions and reading the owner's properties. */
+    private static serialize;
     [Symbol.iterator](): IterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
     get length(): number;
     /**

package/utils/Cursor.js

@@ -58,6 +58,7 @@ export class Cursor {
     hasPrevPage;
     hasNextPage;
     #definition;
+    #meta;
     constructor(items, totalCount, options, meta) {
         this.items = items;
         this.totalCount = totalCount;
@@ -76,6 +77,7 @@ export class Cursor {
             }
         }
         this.#definition = Cursor.getDefinition(meta, orderBy);
+        this.#meta = meta;
     }
     get startCursor() {
         if (this.items.length === 0) {
@@ -93,37 +95,46 @@ export class Cursor {
      * Computes the cursor value for a given entity.
      */
     from(entity) {
-        const processEntity = (entity, prop, direction, object = false) => {
-            if (Utils.isPlainObject(direction)) {
-                const unwrapped = Reference.unwrapReference(entity[prop]);
-                // Check if the relation is loaded - for nested properties, undefined means not populated
-                if (Utils.isEntity(unwrapped) && !helper(unwrapped).isInitialized()) {
-                    throw CursorError.entityNotPopulated(entity, prop);
-                }
-                return Utils.keys(direction).reduce((o, key) => {
-                    Object.assign(o, processEntity(unwrapped, key, direction[key], true));
-                    return o;
-                }, {});
-            }
-            let value = entity[prop];
-            // Allow null/undefined values in cursor - they will be handled in createCursorCondition
-            // undefined can occur with forceUndefined config option which converts null to undefined
-            if (value == null) {
-                return object ? { [prop]: null } : null;
-            }
-            if (Utils.isEntity(value, true)) {
-                value = helper(value).getPrimaryKey();
-            }
-            if (Utils.isScalarReference(value)) {
-                value = value.unwrap();
+        const value = this.#definition.map(([key, direction]) => Cursor.serialize(this.#meta.properties, entity, key, direction));
+        return Cursor.encode(value);
+    }
+    /** Serializes a single cursor value, walking nested directions and reading the owner's properties. */
+    static serialize(properties, owner, key, direction) {
+        const prop = properties[key];
+        let value = owner[key];
+        if (Utils.isPlainObject(direction)) {
+            const unwrapped = Reference.unwrapReference(value);
+            // for nested properties, an uninitialized relation means not populated
+            if (Utils.isEntity(unwrapped) && !helper(unwrapped).isInitialized()) {
+                throw CursorError.entityNotPopulated(owner, key);
             }
-            if (object) {
-                return { [prop]: value };
+            if (unwrapped == null || typeof unwrapped !== 'object') {
+                return unwrapped;
             }
-            return value;
-        };
-        const value = this.#definition.map(([key, direction]) => processEntity(entity, key, direction));
-        return Cursor.encode(value);
+            const childProps = prop?.kind === ReferenceKind.EMBEDDED ? prop.embeddedProps : prop?.targetMeta?.properties;
+            return Utils.keys(direction).reduce((o, childKey) => {
+                o[childKey] = Cursor.serialize(childProps ?? {}, unwrapped, childKey, direction[childKey]);
+                return o;
+            }, {});
+        }
+        // allow null/undefined values in cursor - they will be handled in createCursorCondition
+        // undefined can occur with forceUndefined config option which converts null to undefined
+        if (value == null) {
+            return null;
+        }
+        if (Utils.isEntity(value, true)) {
+            value = helper(value).getPrimaryKey();
+        }
+        if (Utils.isScalarReference(value)) {
+            value = value.unwrap();
+        }
+        // only types implementing `fromJSON` own their wire format, others keep the raw JS value,
+        // so their cursors stay decodable by the `convertToJSValue` fallback
+        if (prop?.customType?.fromJSON) {
+            // the platform is assigned to the type instance during discovery
+            return prop.customType.toJSON(value, prop.customType.platform);
+        }
+        return value;
     }
     *[Symbol.iterator]() {
         for (const item of this.items) {
@@ -138,12 +149,11 @@ export class Cursor {
      */
     static for(meta, entity, orderBy) {
         const definition = this.getDefinition(meta, orderBy);
-        return Cursor.encode(definition.map(([key]) => {
-            const value = entity[key];
-            if (value === undefined) {
+        return Cursor.encode(definition.map(([key, direction]) => {
+            if (entity[key] === undefined) {
                 throw CursorError.missingValue(meta.className, key);
             }
-            return value;
+            return this.serialize(meta.properties, entity, key, direction);
         }));
     }
     static encode(value) {

package/utils/DataloaderUtils.js

@@ -197,7 +197,8 @@ export class DataloaderUtils {
                 const prop = group[0][0].property;
                 const options = {};
                 const wrap = (cond) => ({ [prop.name]: cond });
-                const orderBy = Utils.asArray(group[0][1]?.orderBy).map(o => wrap(o));
+                // `findChildrenFromPivotTable` expects the `orderBy` relative to the target entity, so no wrapping here
+                const orderBy = Utils.asArray(group[0][1]?.orderBy);
                 const populate = wrap(group[0][1]?.populate);
                 const owners = group.map(c => c[0].owner);
                 const $or = [];

package/utils/EntityComparator.d.ts

@@ -80,6 +80,8 @@ export declare class EntityComparator {
     private getGenericComparator;
     private getPropertyComparator;
     private wrap;
+    /** Renders a key as a single-quoted JS string literal, safe to embed in generated code. */
+    private quote;
     private safeKey;
     /**
      * Sets the toArray helper in the context if not already set.