@mikro-orm/core 7.1.16-dev.1 → 7.1.16-dev.11

package/platforms/Platform.js

@@ -471,6 +471,14 @@ export class Platform {
     preservesDatesInsideJson() {
         return false;
     }
+    /** Whether `nulls first`/`nulls last` can be requested in an `orderBy`. */
+    supportsNullsOrdering() {
+        return true;
+    }
+    /** Where nulls land when an `orderBy` requests no explicit placement: lowest (`asc` puts them first) or highest. */
+    sortsNullsLowest() {
+        return false;
+    }
     /** Converts a JS value to its JSON database representation (typically JSON.stringify). */
     convertJsonToDatabaseValue(value, context) {
         return JSON.stringify(value);
@@ -616,6 +624,14 @@ export class Platform {
         Object.defineProperty(copy, JsonProperty, { enumerable: false, value: true });
         return copy;
     }
+    /**
+     * Builds the correlated subquery used as the formula of a virtual to-one relation defined via `through`.
+     * @internal
+     */
+    /* v8 ignore next 3 */
+    getThroughRelationFormula(prop, columns) {
+        throw new Error(`${this.constructor.name} does not support the 'through' option of ${prop.name}`);
+    }
     /** Initializes the platform with the ORM configuration. */
     setConfig(config) {
         this.config = config;
@@ -722,11 +738,51 @@ export class Platform {
     supportsDeferredUniqueConstraints() {
         return true;
     }
+    /** Whether the platform supports row level security (PostgreSQL). */
+    supportsRowLevelSecurity() {
+        return false;
+    }
+    /** Whether the driver can apply the session context on every pooled connection acquire (`sessionContext: 'connection'`). */
+    supportsConnectionSessionContext() {
+        return false;
+    }
+    /**
+     * SQL cast suffix (e.g. `'::uuid'`, or `''` when none is needed) applied when an RLS filter reads a session
+     * variable via `current_setting()` as the given column type, or `null` if the type has no automatic cast.
+     */
+    getCurrentSettingCast(mappedType) {
+        return null;
+    }
     /** Platform-specific validation of entity metadata. */
     validateMetadata(meta) {
         if (meta.partitionBy && !this.supportsPartitionedTables()) {
             throw new MetadataError(`Entity ${meta.className} uses partitionBy, but ${this.constructor.name} does not support partitioned tables`);
         }
+        const declaresRls = meta.policies.length > 0 || !!meta.rowLevelSecurity;
+        if (declaresRls && !this.supportsRowLevelSecurity()) {
+            throw MetadataError.rowLevelSecurityNotSupportedByDriver(meta);
+        }
+        // STI hierarchies share a single table, so only the root may declare policies; `root` is optional-chained
+        // as `validateMetadata` is public API and tolerates partially populated metadata
+        if (declaresRls && meta.root?.inheritanceType === 'sti' && meta.root !== meta) {
+            throw MetadataError.rowLevelSecurityOnNonRootStiEntity(meta);
+        }
+        if (meta.root?.inheritanceType === 'sti' && meta.root !== meta) {
+            for (const filter of Object.values(meta.filters)) {
+                // inherited root filters share the def object; only defs declared on the child itself are a problem,
+                // as non-root STI metas never reach the schema generator and the policy would silently not exist
+                if (filter.rls && meta.root.filters[filter.name] !== filter) {
+                    throw MetadataError.rlsFilterOnNonRootStiEntity(meta, filter.name);
+                }
+            }
+        }
+        if (!this.supportsRowLevelSecurity()) {
+            for (const filter of Object.values(meta.filters)) {
+                if (filter.rls) {
+                    throw MetadataError.rlsFilterNotSupportedByDriver(meta, filter.name);
+                }
+            }
+        }
     }
     /**
      * Generates a custom order by statement given a set of in order values, eg.

package/types/BigIntType.d.ts

@@ -11,6 +11,7 @@ export declare class BigIntType<Mode extends 'bigint' | 'number' | 'string' = 'b
     convertToDatabaseValue(value: JSTypeByMode<Mode> | null | undefined): string | null | undefined;
     convertToJSValue(value: string | bigint | null | undefined): JSTypeByMode<Mode> | null | undefined;
     toJSON(value: JSTypeByMode<Mode> | null | undefined): JSTypeByMode<Mode> | null | undefined;
+    fromJSON(value: unknown): JSTypeByMode<Mode> | null | undefined;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
     compareValues(a: string, b: string): boolean;

package/types/BigIntType.js

@@ -1,4 +1,5 @@
 import { Type } from './Type.js';
+import { ValidationError } from '../errors.js';
 /**
  * This type will automatically convert string values returned from the database to native JS bigints (default)
  * or numbers (safe only for values up to `Number.MAX_SAFE_INTEGER`), or strings, depending on the `mode`.
@@ -36,6 +37,28 @@ export class BigIntType extends Type {
         }
         return this.convertToDatabaseValue(value);
     }
+    fromJSON(value) {
+        // the serialized form is a decimal string, or a plain number in `number` mode
+        const valid = (typeof value === 'string' && /^-?\d+$/.test(value)) || (typeof value === 'number' && Number.isInteger(value));
+        if (!valid) {
+            throw ValidationError.invalidType(BigIntType, value, 'JSON');
+        }
+        switch (this.mode) {
+            case 'number': {
+                // `Number` silently rounds past `MAX_SAFE_INTEGER`, tampered cursors must fail loudly
+                const num = Number(value);
+                if (!Number.isSafeInteger(num)) {
+                    throw ValidationError.invalidType(BigIntType, value, 'JSON');
+                }
+                return num;
+            }
+            case 'string':
+                return String(value);
+            case 'bigint':
+            default:
+                return BigInt(value);
+        }
+    }
     getColumnType(prop, platform) {
         return platform.getBigIntTypeDeclarationSQL(prop);
     }

package/types/DateTimeType.d.ts

@@ -5,6 +5,7 @@ import type { EntityProperty } from '../typings.js';
 export declare class DateTimeType extends Type<Date, string> {
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
+    fromJSON(value: unknown): Date;
     get runtimeType(): string;
     ensureComparable(): boolean;
     getDefaultLength(platform: Platform): number;

package/types/DateTimeType.js

@@ -1,4 +1,5 @@
 import { Type } from './Type.js';
+import { ValidationError } from '../errors.js';
 /** Maps a database DATETIME/TIMESTAMP column to a JS `Date` object. */
 export class DateTimeType extends Type {
     getColumnType(prop, platform) {
@@ -7,6 +8,13 @@ export class DateTimeType extends Type {
     compareAsType() {
         return 'Date';
     }
+    fromJSON(value) {
+        const date = new Date(value);
+        if (typeof value !== 'string' || Number.isNaN(date.getTime())) {
+            throw ValidationError.invalidType(DateTimeType, value, 'JSON');
+        }
+        return date;
+    }
     get runtimeType() {
         return 'Date';
     }

package/types/StringType.d.ts

@@ -1,10 +1,21 @@
 import { Type } from './Type.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntityProperty } from '../typings.js';
-/** Maps a database VARCHAR column to a JS `string`. */
-export declare class StringType extends Type<string | null | undefined, string | null | undefined> {
-    getColumnType(prop: EntityProperty, platform: Platform): string;
+export interface StringTypeOptions {
+    trim?: boolean;
+    case?: 'upper' | 'lower';
+}
+/** @internal */
+export declare abstract class BaseStringType extends Type<string | null | undefined, string | null | undefined> {
+    readonly options: StringTypeOptions;
+    constructor(options?: StringTypeOptions);
+    convertToDatabaseValue(value: string | null | undefined): string | null | undefined;
     compareAsType(): string;
     ensureComparable(): boolean;
+    private normalize;
+}
+/** Maps a database VARCHAR column to a JS `string`. */
+export declare class StringType extends BaseStringType {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
     getDefaultLength(platform: Platform): number;
 }

package/types/StringType.js

@@ -1,8 +1,17 @@
 import { Type } from './Type.js';
-/** Maps a database VARCHAR column to a JS `string`. */
-export class StringType extends Type {
-    getColumnType(prop, platform) {
-        return platform.getVarcharTypeDeclarationSQL(prop);
+/** @internal */
+export class BaseStringType extends Type {
+    options;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        // a defined `compareValues` replaces the inline `!==` comparator, so only provide it when normalization is configured
+        if (options.trim || options.case) {
+            this.compareValues = (a, b) => this.normalize(a) === this.normalize(b);
+        }
+    }
+    convertToDatabaseValue(value) {
+        return this.normalize(value);
     }
     compareAsType() {
         return 'string';
@@ -10,6 +19,27 @@ export class StringType extends Type {
     ensureComparable() {
         return false;
     }
+    normalize(value) {
+        if (value == null) {
+            return value;
+        }
+        if (this.options.trim) {
+            value = value.trim();
+        }
+        if (this.options.case === 'upper') {
+            return value.toUpperCase();
+        }
+        if (this.options.case === 'lower') {
+            return value.toLowerCase();
+        }
+        return value;
+    }
+}
+/** Maps a database VARCHAR column to a JS `string`. */
+export class StringType extends BaseStringType {
+    getColumnType(prop, platform) {
+        return platform.getVarcharTypeDeclarationSQL(prop);
+    }
     getDefaultLength(platform) {
         return platform.getDefaultVarcharLength();
     }

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/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>;
@@ -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[];
@@ -1171,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: {
@@ -1498,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);

package/unit-of-work/UnitOfWork.js

@@ -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,
                 });

package/utils/Configuration.d.ts

@@ -233,6 +233,12 @@ export type MigrationsOptions = {
      * @default true
      */
     snapshot?: boolean;
+    /**
+     * Update the snapshot from the database schema when running migrations up or down.
+     * Disable to keep the snapshot managed solely by `migration:create`.
+     * @default true
+     */
+    snapshotOnMigrate?: boolean;
     /** Custom name for the snapshot file. */
     snapshotName?: string;
     /**
@@ -433,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.
@@ -474,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
@@ -834,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,
@@ -84,6 +85,7 @@ const DEFAULTS = {
         dropTables: true,
         safe: false,
         snapshot: true,
+        snapshotOnMigrate: true,
         emit: 'ts',
         // mirrors `NamingStrategy.classToMigrationName`, so the file name matches the class it declares
         fileName: (timestamp, name) => `Migration${timestamp}${name ? '_' + name.replace(/[^$\p{ID_Continue}]+/gu, '_') : ''}`,
@@ -93,6 +95,7 @@ const DEFAULTS = {
         ignoreSchema: [],
         ignoreTriggers: false,
         ignoreRoutines: false,
+        ignorePolicies: false,
         skipTables: [],
         skipViews: [],
         skipColumns: {},
@@ -392,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/QueryHelper.d.ts

@@ -37,6 +37,18 @@ export declare class QueryHelper {
     static inlinePrimaryKeyObjects<T extends object>(where: Dictionary, meta: EntityMetadata<T>, metadata: MetadataStorage, key?: string): boolean;
     static processWhere<T extends object>(options: ProcessWhereOptions<T>): FilterQuery<T>;
     static getActiveFilters<T>(meta: EntityMetadata<T>, options: FilterOptions | undefined, filters: Dictionary<FilterDef>): FilterDef[];
+    /** @internal Sentinel wrapping for arguments accessed while statically resolving an `rls` filter condition. */
+    static readonly RLS_SENTINEL_PREFIX = "__mikro_rls_arg__";
+    /** @internal */
+    static readonly RLS_SENTINEL_SUFFIX = "__";
+    /**
+     * Resolves an `rls` filter's condition to a static `FilterQuery`. Function conditions are called with a proxy `args`
+     * that yields a unique sentinel per accessed argument, real `type`/`entityName` strings (validated to not affect the
+     * result), and a poison proxy or `undefined` for the remaining runtime-only parameters.
+     *
+     * @internal
+     */
+    static resolveRlsFilterCond(filter: FilterDef, accessed: Set<string>, entityName?: string): Dictionary;
     static mergePropertyFilters(propFilters: FilterOptions | undefined, options: FilterOptions | undefined): FilterOptions | undefined;
     static isFilterActive<T>(meta: EntityMetadata<T>, filterName: string, filter: FilterDef, options: Dictionary<boolean | Dictionary>): boolean;
     static processCustomType<T extends object>(prop: EntityProperty<T>, cond: FilterQuery<T>, platform: Platform, key?: string, fromQuery?: boolean): FilterQuery<T>;