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

package/utils/QueryHelper.js

@@ -4,6 +4,7 @@ import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, ReferenceKind } fro
 import { JsonType } from '../types/JsonType.js';
 import { helper } from '../entity/wrap.js';
 import { isRaw, Raw } from './RawQueryFragment.js';
+import { MetadataError } from '../errors.js';
 /** @internal */
 export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
@@ -286,6 +287,68 @@ export class QueryHelper {
             return filters[f];
         });
     }
+    /** @internal Sentinel wrapping for arguments accessed while statically resolving an `rls` filter condition. */
+    static RLS_SENTINEL_PREFIX = '__mikro_rls_arg__';
+    /** @internal */
+    static 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, accessed, entityName) {
+        if (!(filter.cond instanceof Function)) {
+            return filter.cond;
+        }
+        const args = new Proxy({}, {
+            get: (_target, prop) => {
+                if (typeof prop === 'symbol') {
+                    // e.g. coercing `args` itself in a template literal triggers a `Symbol.toPrimitive` lookup
+                    throw MetadataError.rlsFilterUnsupportedCond(filter.name);
+                }
+                accessed.add(prop);
+                return `${this.RLS_SENTINEL_PREFIX}${prop}${this.RLS_SENTINEL_SUFFIX}`;
+            },
+        });
+        const poison = new Proxy({}, {
+            get: () => {
+                throw MetadataError.rlsFilterDependsOnRuntimeState(filter.name);
+            },
+        });
+        // property access on the poison proxies throws, but equality/truthiness checks (`type === 'read'`,
+        // `entityName === 'X'`, `options ? a : b`) cannot be trapped — vary all three across the evaluations and require
+        // identical results, so a command-, entity-, or options-dependent condition cannot silently compile one branch.
+        // `entityName` uses the real class name (plus two derived-distinct variants) so an `=== '<name>'` check diverges;
+        // `options` alternates the poison proxy and `undefined` so a truthiness check flips. `em` stays poison throughout.
+        const name = entityName ?? `${this.RLS_SENTINEL_PREFIX}entity${this.RLS_SENTINEL_SUFFIX}`;
+        const evaluate = (type, entity, options) => {
+            let result;
+            try {
+                result = filter.cond(args, type, poison, options, entity);
+            }
+            catch (e) {
+                // a raw TypeError from touching the `undefined` options/em must fail closed like the poison proxy does,
+                // but the descriptive MetadataErrors thrown above are already correct — let them surface unchanged
+                if (e instanceof MetadataError) {
+                    throw e;
+                }
+                throw MetadataError.rlsFilterDependsOnRuntimeState(filter.name);
+            }
+            if (result instanceof Promise) {
+                throw MetadataError.rlsFilterDependsOnRuntimeState(filter.name);
+            }
+            return result;
+        };
+        const read = evaluate('read', name, poison);
+        const update = evaluate('update', `${name}\0a`, undefined);
+        const del = evaluate('delete', `${name}\0b`, poison);
+        if (JSON.stringify(read) !== JSON.stringify(update) || JSON.stringify(read) !== JSON.stringify(del)) {
+            throw MetadataError.rlsFilterDependsOnRuntimeState(filter.name);
+        }
+        return read;
+    }
     static mergePropertyFilters(propFilters, options) {
         if (!options || !propFilters || options === true || propFilters === true) {
             return options ?? propFilters;

package/utils/RawQueryFragment.d.ts

@@ -61,6 +61,12 @@ export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
  * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
  * ```
  *
+ * Named parameters are supported via an object of parameters, use `:name` for values and `:name:` for identifiers:
+ *
+ * ```ts
+ * raw('select :col: from geo where city = :city or region = :city', { col: 'city', city: 'Brno' });
+ * ```
+ *
  * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
  *
  * ```ts

package/utils/RawQueryFragment.js

@@ -146,6 +146,12 @@ export const ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
  * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
  * ```
  *
+ * Named parameters are supported via an object of parameters, use `:name` for values and `:name:` for identifiers:
+ *
+ * ```ts
+ * raw('select :col: from geo where city = :city or region = :city', { col: 'city', city: 'Brno' });
+ * ```
+ *
  * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
  *
  * ```ts
@@ -191,13 +197,16 @@ export function raw(sql, params) {
         return Utils.getPrimaryKeyHash(sql);
     }
     if (typeof params === 'object' && !Array.isArray(params)) {
-        const pairs = Object.entries(params);
+        const dict = params;
         const objectParams = [];
-        for (const [key, value] of pairs) {
-            sql = sql.replace(`:${key}:`, '??');
-            sql = sql.replace(`:${key}`, '?');
-            objectParams.push(value);
-        }
+        // single left-to-right scan keeps values in SQL-placeholder order while `::` casts and unknown tokens stay untouched
+        sql = sql.replace(/(?<!:):([$\w]+)(:(?!:))?/g, (match, key, identifier) => {
+            if (!Object.hasOwn(dict, key)) {
+                return match;
+            }
+            objectParams.push(dict[key]);
+            return identifier ? '??' : '?';
+        });
         return new RawQueryFragment(sql, objectParams);
     }
     return new RawQueryFragment(sql, params);

package/utils/RequestContext.d.ts

@@ -17,13 +17,13 @@ export declare class RequestContext {
      * If the handler is async, the return value needs to be awaited.
      * Uses `AsyncLocalStorage.run()`, suitable for regular express style middlewares with a `next` callback.
      */
-    static create<T>(em: EntityManager | EntityManager[], next: (...args: any[]) => T, options?: CreateContextOptions): T;
+    static create<T>(em: EntityManager | EntityManager[], next: (...args: any[]) => T, options?: ((name: string) => CreateContextOptions) | CreateContextOptions): T;
     /**
      * Creates new RequestContext instance and runs the code inside its domain.
      * If the handler is async, the return value needs to be awaited.
      * Uses `AsyncLocalStorage.enterWith()`, suitable for elysia style middlewares without a `next` callback.
      */
-    static enter(em: EntityManager | EntityManager[], options?: CreateContextOptions): void;
+    static enter(em: EntityManager | EntityManager[], options?: ((name: string) => CreateContextOptions) | CreateContextOptions): void;
     /**
      * Returns current RequestContext (if available).
      */

package/utils/RequestContext.js

@@ -50,10 +50,19 @@ export class RequestContext {
     static createContext(em, options = {}) {
         const forks = new Map();
         if (Array.isArray(em)) {
-            em.forEach(em => forks.set(em.name, em.fork({ useContext: true, ...options })));
+            if (typeof options === 'function') {
+                for (const emInstance of em) {
+                    forks.set(emInstance.name, emInstance.fork({ useContext: true, ...options(emInstance.name) }));
+                }
+            }
+            else {
+                for (const emInstance of em) {
+                    forks.set(emInstance.name, emInstance.fork({ useContext: true, ...options }));
+                }
+            }
         }
         else {
-            forks.set(em.name, em.fork({ useContext: true, ...options }));
+            forks.set(em.name, em.fork({ useContext: true, ...(typeof options === 'function' ? options(em.name) : options) }));
         }
         return new RequestContext(forks);
     }

package/utils/TransactionManager.js

@@ -239,7 +239,7 @@ export class TransactionManager {
         return TransactionContext.create(fork, () => fork.getConnection().transactional(async (trx) => {
             fork.setTransactionContext(trx);
             return this.executeTransactionFlow(fork, cb, propagateToUpperContext, em);
-        }, { ...options, eventBroadcaster }));
+        }, { sessionContext: fork.getTransactionSessionContext(), ...options, eventBroadcaster }));
     }
     /**
      * Executes transaction workflow with entity synchronization.

package/utils/Utils.d.ts

@@ -33,6 +33,8 @@ export declare function parseJsonSafe<T = unknown>(value: unknown): T;
 export declare class Utils {
     #private;
     static readonly PK_SEPARATOR = "~~~";
+    /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
+    static getRlsSettingName(filterName: string, argName: string): string;
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

package/utils/Utils.js

@@ -153,7 +153,11 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.1.16-dev.1';
+    static #ORM_VERSION = '7.1.16-dev.11';
+    /** Default session variable name backing an RLS filter argument (`current_setting('mikro.<filter>.<arg>')`). */
+    static getRlsSettingName(filterName, argName) {
+        return `mikro.${filterName}.${argName}`;
+    }
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -602,7 +606,8 @@ export class Utils {
                 return (arg.includes('ts-node') || // check for ts-node loader
                     arg.includes('@swc-node/register') || // check for swc-node/register loader
                     arg.includes('node_modules/tsx/') || // check for tsx loader
-                    arg.includes('@oxc-node/core') // check for oxc-node loader
+                    arg.includes('@oxc-node/core') || // check for oxc-node loader
+                    arg.includes('@nubjs/loader') // check for Nub loader
                 );
             }));
     }
@@ -854,7 +859,11 @@ export class Utils {
             return await import(module);
         }
         catch (err) {
-            if (warning && err.code === 'ERR_MODULE_NOT_FOUND') {
+            // only a missing module is expected here, anything else is a real failure inside the module
+            if (!['ERR_MODULE_NOT_FOUND', 'MODULE_NOT_FOUND'].includes(err.code)) {
+                throw err;
+            }
+            if (warning) {
                 // eslint-disable-next-line no-console
                 console.warn(warning);
             }

package/utils/env-vars.js

@@ -79,6 +79,7 @@ export function loadEnvironmentVars() {
     read2('silent', bool);
     read2('emit');
     read2('snapshot', bool);
+    read2('snapshotOnMigrate', bool);
     read2('snapshotName');
     cleanup(ret, 'migrations');
     ret.schemaGenerator = {};
@@ -87,6 +88,7 @@ export function loadEnvironmentVars() {
     read3('createForeignKeyConstraints', bool);
     read3('ignoreTriggers', bool);
     read3('ignoreRoutines', bool);
+    read3('ignorePolicies', bool);
     cleanup(ret, 'schemaGenerator');
     ret.seeder = {};
     const read4 = read.bind(null, ret.seeder, 'MIKRO_ORM_SEEDER_');

package/utils/index.d.ts

@@ -10,4 +10,5 @@ export * from './EntityComparator.js';
 export * from './RawQueryFragment.js';
 export * from './env-vars.js';
 export * from './upsert-utils.js';
+export * from './rls-utils.js';
 export * from './partition-utils.js';

package/utils/index.js

@@ -10,4 +10,5 @@ export * from './EntityComparator.js';
 export * from './RawQueryFragment.js';
 export * from './env-vars.js';
 export * from './upsert-utils.js';
+export * from './rls-utils.js';
 export * from './partition-utils.js';

package/utils/rls-utils.d.ts

@@ -0,0 +1,35 @@
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+import type { Dictionary, FilterDef } from '../typings.js';
+/** An `rls`-flagged filter definition together with the entity it is declared on. @internal */
+export interface RlsFilterEntry {
+    filter: FilterDef;
+    entityName: string;
+}
+/**
+ * Collects all `rls`-flagged filter definitions with the given name (only entity-scoped filters can be `rls`).
+ * The full name -> defs lookup is built once and cached on the shared (immutable) MetadataStorage, so repeated
+ * `setFilterParams` calls and forks reuse it instead of walking every entity each time.
+ * @internal
+ */
+export declare function findRlsFilterDefs(metadata: MetadataStorage, name: string): RlsFilterEntry[];
+/**
+ * Drops the cached `rls` filter lookup — `MikroORM.discoverEntity()` mutates the shared MetadataStorage,
+ * so a lookup built before the call would miss the newly discovered filters.
+ *
+ * @internal
+ */
+export declare function clearRlsFilterDefsCache(metadata: MetadataStorage): void;
+/**
+ * Computes the `rls` session variables a set of same-named filter defs stages for the given args, mirroring the
+ * policy compilation (`current_setting` names and custom `setting` binding). Shared by staging and `fork({ session })`.
+ * @internal
+ */
+export declare function computeRlsFilterVariables(filters: RlsFilterEntry[], args: Dictionary): Dictionary<string | number | boolean | Date>;
+/**
+ * Computes which staged session variables a `setFilterParams` call may prune: the variables the OLD args staged for
+ * this filter that the new args no longer set, minus any variable another filter's current params still stage
+ * (a custom `setting` name can be shared by differently named filters). Recomputing from the old args rather than
+ * matching by prefix keeps a filter named `tenant` from also pruning a `tenant.x` filter's `mikro.tenant.x.*` variables.
+ * @internal
+ */
+export declare function computeRemovedRlsVariables(metadata: MetadataStorage, name: string, filters: RlsFilterEntry[], previousArgs: Dictionary, nextVariables: Dictionary, allFilterParams: Dictionary<Dictionary>): string[];

package/utils/rls-utils.js

@@ -0,0 +1,97 @@
+import { MetadataError, ValidationError } from '../errors.js';
+import { QueryHelper } from './QueryHelper.js';
+import { Utils } from './Utils.js';
+/** Lazily-built `rls` filter lookup keyed by the shared (immutable) MetadataStorage, so all forks reuse it. */
+const rlsFilterDefs = new WeakMap();
+/**
+ * Collects all `rls`-flagged filter definitions with the given name (only entity-scoped filters can be `rls`).
+ * The full name -> defs lookup is built once and cached on the shared (immutable) MetadataStorage, so repeated
+ * `setFilterParams` calls and forks reuse it instead of walking every entity each time.
+ * @internal
+ */
+export function findRlsFilterDefs(metadata, name) {
+    let cache = rlsFilterDefs.get(metadata);
+    if (!cache) {
+        cache = new Map();
+        for (const meta of metadata) {
+            for (const filterName of Object.keys(meta.filters)) {
+                const filter = meta.filters[filterName];
+                if (!filter.rls) {
+                    continue;
+                }
+                const defs = cache.get(filterName) ?? [];
+                // inheritance shares the same filter object across base and child metadata — keep a single entry
+                if (!defs.some(d => d.filter === filter)) {
+                    defs.push({ filter, entityName: meta.className });
+                }
+                cache.set(filterName, defs);
+            }
+        }
+        rlsFilterDefs.set(metadata, cache);
+    }
+    return cache.get(name) ?? [];
+}
+/**
+ * Drops the cached `rls` filter lookup — `MikroORM.discoverEntity()` mutates the shared MetadataStorage,
+ * so a lookup built before the call would miss the newly discovered filters.
+ *
+ * @internal
+ */
+export function clearRlsFilterDefsCache(metadata) {
+    rlsFilterDefs.delete(metadata);
+}
+/**
+ * Computes the `rls` session variables a set of same-named filter defs stages for the given args, mirroring the
+ * policy compilation (`current_setting` names and custom `setting` binding). Shared by staging and `fork({ session })`.
+ * @internal
+ */
+export function computeRlsFilterVariables(filters, args) {
+    const variables = {};
+    for (const { filter, entityName } of filters) {
+        const setting = typeof filter.rls === 'object' ? filter.rls.setting : undefined;
+        let settingArg;
+        if (setting) {
+            // mirror the policy compilation — a custom `setting` binds the single argument the condition accesses
+            const accessed = new Set();
+            QueryHelper.resolveRlsFilterCond(filter, accessed, entityName);
+            if (accessed.size > 1) {
+                throw MetadataError.rlsFilterMultiArgSetting(filter.name, [...accessed]);
+            }
+            settingArg = [...accessed][0];
+        }
+        for (const key of Object.keys(args)) {
+            const value = args[key];
+            // treat `undefined` like an omitted arg — staging it would serialize as the literal string 'undefined'
+            if (value === undefined) {
+                continue;
+            }
+            // a non-scalar arg has no equivalent in the compiled `= current_setting(...)` comparison — the app-level
+            // filter would apply `$in`/`is null` semantics while the policy compares against `String(value)`
+            if (value === null || (typeof value === 'object' && !(value instanceof Date))) {
+                throw ValidationError.cannotStageNonScalarSessionVariable(filter.name, key);
+            }
+            const settingName = key === settingArg ? setting : Utils.getRlsSettingName(filter.name, key);
+            variables[settingName] = value;
+        }
+    }
+    return variables;
+}
+/**
+ * Computes which staged session variables a `setFilterParams` call may prune: the variables the OLD args staged for
+ * this filter that the new args no longer set, minus any variable another filter's current params still stage
+ * (a custom `setting` name can be shared by differently named filters). Recomputing from the old args rather than
+ * matching by prefix keeps a filter named `tenant` from also pruning a `tenant.x` filter's `mikro.tenant.x.*` variables.
+ * @internal
+ */
+export function computeRemovedRlsVariables(metadata, name, filters, previousArgs, nextVariables, allFilterParams) {
+    const removed = Object.keys(computeRlsFilterVariables(filters, previousArgs)).filter(key => !(key in nextVariables));
+    const keptByOthers = new Set();
+    for (const otherName of removed.length > 0 ? Object.keys(allFilterParams) : []) {
+        if (otherName !== name) {
+            for (const key of Object.keys(computeRlsFilterVariables(findRlsFilterDefs(metadata, otherName), allFilterParams[otherName]))) {
+                keptByOthers.add(key);
+            }
+        }
+    }
+    return removed.filter(key => !keptByOthers.has(key));
+}