@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/utils/QueryHelper.js

@@ -1,23 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryHelper = void 0;
-const Reference_1 = require("../entity/Reference");
-const Utils_1 = require("./Utils");
-const enums_1 = require("../enums");
-const JsonType_1 = require("../types/JsonType");
-const wrap_1 = require("../entity/wrap");
-const RawQueryFragment_1 = require("./RawQueryFragment");
-class QueryHelper {
+import { Reference } from '../entity/Reference.js';
+import { Utils } from './Utils.js';
+import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, ReferenceKind } from '../enums.js';
+import { JsonType } from '../types/JsonType.js';
+import { helper } from '../entity/wrap.js';
+import { isRaw, RawQueryFragment } from './RawQueryFragment.js';
+/** @internal */
+export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
     static processParams(params) {
-        if (Reference_1.Reference.isReference(params)) {
+        if (Reference.isReference(params)) {
             params = params.unwrap();
         }
-        if (Utils_1.Utils.isEntity(params)) {
-            if ((0, wrap_1.helper)(params).__meta.compositePK) {
-                return (0, wrap_1.helper)(params).__primaryKeys;
+        if (Utils.isEntity(params)) {
+            if (helper(params).__meta.compositePK) {
+                return helper(params).__primaryKeys;
             }
-            return (0, wrap_1.helper)(params).getPrimaryKey();
+            return helper(params).getPrimaryKey();
         }
         if (params === undefined) {
             return null;
@@ -25,34 +23,75 @@ class QueryHelper {
         if (Array.isArray(params)) {
             return params.map(item => QueryHelper.processParams(item));
         }
-        if (Utils_1.Utils.isPlainObject(params)) {
+        if (Utils.isPlainObject(params)) {
             QueryHelper.processObjectParams(params);
         }
         return params;
     }
     static processObjectParams(params = {}) {
-        Utils_1.Utils.keys(params).forEach(k => {
+        Utils.keys(params).forEach(k => {
             params[k] = QueryHelper.processParams(params[k]);
         });
         return params;
     }
+    /**
+     * converts `{ account: { $or: [ [Object], [Object] ] } }`
+     * to `{ $or: [ { account: [Object] }, { account: [Object] } ] }`
+     */
+    static liftGroupOperators(where, meta, metadata, key) {
+        if (!Utils.isPlainObject(where)) {
+            return undefined;
+        }
+        const keys = Object.keys(where);
+        const groupOperator = keys.find(k => {
+            return k in GroupOperator && Array.isArray(where[k]) && where[k].every(cond => {
+                return Utils.isPlainObject(cond) && Object.keys(cond).every(k2 => {
+                    if (Utils.isOperator(k2, false)) {
+                        if (k2 === '$not') {
+                            return Object.keys(cond[k2]).every(k3 => meta.primaryKeys.includes(k3));
+                        }
+                        return true;
+                    }
+                    return meta.primaryKeys.includes(k2);
+                });
+            });
+        });
+        if (groupOperator) {
+            return groupOperator;
+        }
+        for (const k of keys) {
+            const value = where[k];
+            const prop = meta.properties[k];
+            if (!prop || ![ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                continue;
+            }
+            const op = this.liftGroupOperators(value, prop.targetMeta, metadata, k);
+            if (op) {
+                delete where[k];
+                where[op] = value[op].map((v) => {
+                    return { [k]: v };
+                });
+            }
+        }
+        return undefined;
+    }
     static inlinePrimaryKeyObjects(where, meta, metadata, key) {
         if (Array.isArray(where)) {
             where.forEach((item, i) => {
                 if (this.inlinePrimaryKeyObjects(item, meta, metadata, key)) {
-                    where[i] = Utils_1.Utils.getPrimaryKeyValues(item, meta.primaryKeys, false);
+                    where[i] = Utils.getPrimaryKeyValues(item, meta, false);
                 }
             });
         }
-        if (!Utils_1.Utils.isPlainObject(where) || (key && meta.properties[key]?.customType instanceof JsonType_1.JsonType)) {
+        if (!Utils.isPlainObject(where) || (key && meta.properties[key]?.customType instanceof JsonType)) {
             return false;
         }
-        if (meta.primaryKeys.every(pk => pk in where) && Utils_1.Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
-            return !!key && !enums_1.GroupOperator[key] && Object.keys(where).every(k => !Utils_1.Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
-                if (Utils_1.Utils.isOperator(v, false)) {
-                    return false;
+        if (meta.primaryKeys.every(pk => pk in where) && Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
+            return !!key && !GroupOperator[key] && key !== '$not' && Object.keys(where).every(k => !Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
+                if (Utils.isOperator(v, false)) {
+                    return true;
                 }
-                if (meta.properties[k].primary && [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
+                if (meta.properties[k].primary && [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
                     return this.inlinePrimaryKeyObjects(where[k], meta.properties[k].targetMeta, metadata, v);
                 }
                 return true;
@@ -61,7 +100,7 @@ class QueryHelper {
         Object.keys(where).forEach(k => {
             const meta2 = metadata.find(meta.properties[k]?.type) || meta;
             if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
-                where[k] = Utils_1.Utils.getPrimaryKeyValues(where[k], meta2.primaryKeys, true);
+                where[k] = Utils.getPrimaryKeyValues(where[k], meta2, true);
             }
         });
         return false;
@@ -72,30 +111,31 @@ class QueryHelper {
         const meta = metadata.find(entityName);
         // inline PK-only objects in M:N queries, so we don't join the target entity when not needed
         if (meta && root) {
+            QueryHelper.liftGroupOperators(where, meta, metadata);
             QueryHelper.inlinePrimaryKeyObjects(where, meta, metadata);
         }
         if (platform.getConfig().get('ignoreUndefinedInQuery') && where && typeof where === 'object') {
-            Utils_1.Utils.dropUndefinedProperties(where);
+            Utils.dropUndefinedProperties(where);
         }
         where = QueryHelper.processParams(where) ?? {};
-        /* istanbul ignore next */
-        if (!root && Utils_1.Utils.isPrimaryKey(where)) {
+        /* v8 ignore next */
+        if (!root && Utils.isPrimaryKey(where)) {
             return where;
         }
-        if (meta && Utils_1.Utils.isPrimaryKey(where, meta.compositePK)) {
-            where = { [Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
+        if (meta && Utils.isPrimaryKey(where, meta.compositePK)) {
+            where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
         }
         if (Array.isArray(where) && root) {
-            const rootPrimaryKey = meta ? Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys) : entityName;
+            const rootPrimaryKey = meta ? Utils.getPrimaryKeyHash(meta.primaryKeys) : entityName;
             let cond = { [rootPrimaryKey]: { $in: where } };
             // @ts-ignore
             // detect tuple comparison, use `$or` in case the number of constituents don't match
-            if (meta && !where.every(c => Utils_1.Utils.isPrimaryKey(c) || (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils_1.Utils.isPrimaryKey(i))))) {
+            if (meta && !where.every(c => Utils.isPrimaryKey(c) || (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils.isPrimaryKey(i))))) {
                 cond = { $or: where };
             }
             return QueryHelper.processWhere({ ...options, where: cond, root: false });
         }
-        if (!Utils_1.Utils.isPlainObject(where)) {
+        if (!Utils.isPlainObject(where)) {
             return where;
         }
         return Object.keys(where).reduce((o, key) => {
@@ -103,34 +143,34 @@ class QueryHelper {
             const prop = this.findProperty(key, options);
             const keys = prop?.joinColumns?.length ?? 0;
             const composite = keys > 1;
-            if (Array.isArray(value) && value.length === 0 && RawQueryFragment_1.RawQueryFragment.isKnownFragment(key)) {
+            if (Array.isArray(value) && value.length === 0 && RawQueryFragment.isKnownFragment(key)) {
                 o[key] = value;
                 return o;
             }
-            if (key in enums_1.GroupOperator) {
+            if (key in GroupOperator) {
                 o[key] = value.map((sub) => QueryHelper.processWhere({ ...options, where: sub, root }));
                 return o;
             }
             // wrap top level operators (except platform allowed operators) with PK
-            if (Utils_1.Utils.isOperator(key) && root && meta && !platform.isAllowedTopLevelOperator(key)) {
-                const rootPrimaryKey = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+            if (Utils.isOperator(key) && root && meta && !platform.isAllowedTopLevelOperator(key)) {
+                const rootPrimaryKey = Utils.getPrimaryKeyHash(meta.primaryKeys);
                 o[rootPrimaryKey] = { [key]: QueryHelper.processWhere({ ...options, where: value, root: false }) };
                 return o;
             }
-            if (prop?.customType && convertCustomTypes && !(0, RawQueryFragment_1.isRaw)(value)) {
+            if (prop?.customType && convertCustomTypes && !isRaw(value)) {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
-            const isJsonProperty = prop?.customType instanceof JsonType_1.JsonType && Utils_1.Utils.isPlainObject(value) && !(0, RawQueryFragment_1.isRaw)(value) && Object.keys(value)[0] !== '$eq';
-            if (isJsonProperty) {
+            const isJsonProperty = prop?.customType instanceof JsonType && Utils.isPlainObject(value) && !isRaw(value) && Object.keys(value)[0] !== '$eq';
+            if (isJsonProperty && prop?.kind !== ReferenceKind.EMBEDDED) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
-            if (Array.isArray(value) && !Utils_1.Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
+            if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
                 // comparing single composite key - use $eq instead of $in
                 const op = composite && !value.every(v => Array.isArray(v)) ? '$eq' : '$in';
                 o[key] = { [op]: value };
                 return o;
             }
-            if (Utils_1.Utils.isPlainObject(value)) {
+            if (Utils.isPlainObject(value)) {
                 o[key] = QueryHelper.processWhere({
                     ...options,
                     where: value,
@@ -152,7 +192,7 @@ class QueryHelper {
         if (Array.isArray(options)) {
             options.forEach(filter => opts[filter] = true);
         }
-        else if (Utils_1.Utils.isPlainObject(options)) {
+        else if (Utils.isPlainObject(options)) {
             Object.keys(options).forEach(filter => opts[filter] = options[filter]);
         }
         return Object.keys(filters)
@@ -162,6 +202,24 @@ class QueryHelper {
             return filters[f];
         });
     }
+    static mergePropertyFilters(propFilters, options) {
+        if (!options || !propFilters || options === true || propFilters === true) {
+            return options ?? propFilters;
+        }
+        if (Array.isArray(propFilters)) {
+            propFilters = propFilters.reduce((o, item) => {
+                o[item] = true;
+                return o;
+            }, {});
+        }
+        if (Array.isArray(options)) {
+            options = options.reduce((o, item) => {
+                o[item] = true;
+                return o;
+            }, {});
+        }
+        return Utils.mergeConfig({}, propFilters, options);
+    }
     static isFilterActive(entityName, filterName, filter, options) {
         if (filter.entity && !filter.entity.includes(entityName)) {
             return false;
@@ -172,9 +230,9 @@ class QueryHelper {
         return filter.default || filterName in options;
     }
     static processCustomType(prop, cond, platform, key, fromQuery) {
-        if (Utils_1.Utils.isPlainObject(cond)) {
-            return Utils_1.Utils.keys(cond).reduce((o, k) => {
-                if (Utils_1.Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
+        if (Utils.isPlainObject(cond)) {
+            return Utils.keys(cond).reduce((o, k) => {
+                if (Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
                     o[k] = QueryHelper.processCustomType(prop, cond[k], platform, k, fromQuery);
                 }
                 else {
@@ -183,15 +241,15 @@ class QueryHelper {
                 return o;
             }, {});
         }
-        if (key && Utils_1.Utils.isJsonKeyOperator(key)) {
+        if (key && JSON_KEY_OPERATORS.includes(key)) {
             return Array.isArray(cond)
                 ? platform.marshallArray(cond)
                 : cond;
         }
-        if (Array.isArray(cond) && !(key && Utils_1.Utils.isArrayOperator(key))) {
+        if (Array.isArray(cond) && !(key && ARRAY_OPERATORS.includes(key))) {
             return cond.map(v => QueryHelper.processCustomType(prop, v, platform, key, fromQuery));
         }
-        if ((0, RawQueryFragment_1.isRaw)(cond)) {
+        if (isRaw(cond)) {
             return cond;
         }
         return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });
@@ -200,8 +258,8 @@ class QueryHelper {
         return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key === op);
     }
     static processJsonCondition(o, value, path, platform, alias) {
-        if (Utils_1.Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils_1.Utils.isOperator(k))) {
-            Utils_1.Utils.keys(value).forEach(k => {
+        if (Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils.isOperator(k))) {
+            Utils.keys(value).forEach(k => {
                 this.processJsonCondition(o, value[k], [...path, k], platform, alias);
             });
             return o;
@@ -219,7 +277,7 @@ class QueryHelper {
         if (Array.isArray(value)) {
             return typeof value[0];
         }
-        if (Utils_1.Utils.isPlainObject(value) && Object.keys(value).every(k => Utils_1.Utils.isOperator(k))) {
+        if (Utils.isPlainObject(value) && Object.keys(value).every(k => Utils.isOperator(k))) {
             return this.getValueType(Object.values(value)[0]);
         }
         return typeof value;
@@ -233,4 +291,3 @@ class QueryHelper {
         return meta?.properties[propName];
     }
 }
-exports.QueryHelper = QueryHelper;

package/utils/RawQueryFragment.d.ts

@@ -1,5 +1,4 @@
-import { inspect } from 'node:util';
-import type { AnyString, Dictionary, EntityKey } from '../typings';
+import type { AnyString, Dictionary, EntityKey } from '../typings.js';
 export declare class RawQueryFragment {
     #private;
     readonly sql: string;
@@ -10,8 +9,6 @@ export declare class RawQueryFragment {
     valueOf(): string;
     toJSON(): string;
     toString(): string;
-    /** @internal */
-    assign(): void;
     clone(): RawQueryFragment;
     static run<T>(cb: (...args: any[]) => Promise<T>): Promise<T>;
     /**
@@ -21,14 +18,6 @@ export declare class RawQueryFragment {
     static isKnownFragment(key: string | RawQueryFragment): boolean;
     static getKnownFragment(key: string | RawQueryFragment, cleanup?: boolean): RawQueryFragment | undefined;
     static remove(key: string): void;
-    /** @ignore */
-    [inspect.custom](): {
-        sql: string;
-        params: unknown[];
-    } | {
-        sql: string;
-        params?: undefined;
-    };
 }
 export { RawQueryFragment as Raw };
 export declare function isRaw(value: unknown): value is RawQueryFragment;
@@ -72,8 +61,26 @@ export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
  * ```ts
  * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
  * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
  */
-export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
+export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R>;
 /**
  * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.
  *
@@ -90,9 +97,25 @@ export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> |
  */
 export declare function sql(sql: readonly string[], ...values: unknown[]): any;
 export declare namespace sql {
-    var ref: <T extends object>(...keys: string[]) => RawQueryFragment;
+    var ref: <T extends object>(...keys: string[]) => NoInfer<RawQueryFragment>;
     var now: (length?: number) => string;
     var lower: <T extends object>(key: string | ((alias: string) => string)) => string;
     var upper: <T extends object>(key: string | ((alias: string) => string)) => string;
 }
 export declare function createSqlFunction<T extends object, R = string>(func: string, key: string | ((alias: string) => string)): R;
+/**
+ * Tag function providing quoting of db identifiers (table name, columns names, index names, ...).
+ *
+ * Within the template literal on which the tag function is applied, all placeholders are considered to be database identifiers, and will thus be quoted as so according to the database in use.
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("name")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`name`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export declare function quote(expParts: readonly string[], ...values: (string | {
+    toString(): string;
+})[]): any;

package/utils/RawQueryFragment.js

@@ -1,21 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALIAS_REPLACEMENT_RE = exports.ALIAS_REPLACEMENT = exports.Raw = exports.RawQueryFragment = void 0;
-exports.isRaw = isRaw;
-exports.raw = raw;
-exports.sql = sql;
-exports.createSqlFunction = createSqlFunction;
-const node_async_hooks_1 = require("node:async_hooks");
-const node_util_1 = require("node:util");
-const Utils_1 = require("./Utils");
-class RawQueryFragment {
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { Utils } from './Utils.js';
+export class RawQueryFragment {
     sql;
     params;
     static #rawQueryCache = new Map();
-    static #storage = new node_async_hooks_1.AsyncLocalStorage();
+    static #storage = new AsyncLocalStorage();
     static #index = 0n;
     static cloneRegistry;
-    #assigned = false;
     #used = 0;
     #key;
     constructor(sql, params = []) {
@@ -24,7 +15,7 @@ class RawQueryFragment {
         this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
     }
     as(alias) {
-        return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
+        return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
     valueOf() {
         throw new Error(`Trying to modify raw SQL fragment: '${this.sql}'`);
@@ -37,13 +28,6 @@ class RawQueryFragment {
         this.#used++;
         return this.#key;
     }
-    /** @internal */
-    assign() {
-        if (this.#assigned) {
-            throw new Error(`Cannot reassign already used RawQueryFragment: '${this.sql}'`);
-        }
-        this.#assigned = true;
-    }
     clone() {
         RawQueryFragment.cloneRegistry?.add(this.#key);
         return new RawQueryFragment(this.sql, this.params);
@@ -93,27 +77,26 @@ class RawQueryFragment {
             }
         }
     }
-    /* istanbul ignore next */
     /** @ignore */
-    [node_util_1.inspect.custom]() {
+    /* v8 ignore next */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
         if (this.params) {
             return { sql: this.sql, params: this.params };
         }
         return { sql: this.sql };
     }
 }
-exports.RawQueryFragment = RawQueryFragment;
-exports.Raw = RawQueryFragment;
+export { RawQueryFragment as Raw };
 Object.defineProperties(RawQueryFragment.prototype, {
     __raw: { value: true, enumerable: false },
 });
-function isRaw(value) {
+export function isRaw(value) {
     return typeof value === 'object' && value !== null && '__raw' in value;
 }
 /** @internal */
-exports.ALIAS_REPLACEMENT = '[::alias::]';
+export const ALIAS_REPLACEMENT = '[::alias::]';
 /** @internal */
-exports.ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
+export const ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
 /**
  * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
  * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
@@ -150,20 +133,38 @@ exports.ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
  * ```ts
  * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
  * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
  */
-function raw(sql, params) {
+export function raw(sql, params) {
     if (sql instanceof RawQueryFragment) {
         return sql;
     }
     if (sql instanceof Function) {
-        sql = sql(exports.ALIAS_REPLACEMENT);
+        sql = sql(ALIAS_REPLACEMENT);
     }
     if (sql === '??' && Array.isArray(params)) {
         return new RawQueryFragment(sql, params);
     }
     if (Array.isArray(sql)) {
         // for composite FK we return just a simple string
-        return Utils_1.Utils.getPrimaryKeyHash(sql);
+        return Utils.getPrimaryKeyHash(sql);
     }
     if (typeof params === 'object' && !Array.isArray(params)) {
         const pairs = Object.entries(params);
@@ -191,14 +192,14 @@ function raw(sql, params) {
  * await em.find(User, { [sql`(select 1 = 1)`]: [] });
  * ```
  */
-function sql(sql, ...values) {
+export function sql(sql, ...values) {
     return raw(sql.reduce((query, queryPart, i) => {
         const valueExists = i < values.length;
         const text = query + queryPart;
         return valueExists ? text + '?' : text;
     }, ''), values);
 }
-function createSqlFunction(func, key) {
+export function createSqlFunction(func, key) {
     if (typeof key === 'string') {
         return raw(`${func}(${key})`);
     }
@@ -208,3 +209,19 @@ sql.ref = (...keys) => raw('??', [keys.join('.')]);
 sql.now = (length) => raw('current_timestamp' + (length == null ? '' : `(${length})`));
 sql.lower = (key) => createSqlFunction('lower', key);
 sql.upper = (key) => createSqlFunction('upper', key);
+/**
+ * Tag function providing quoting of db identifiers (table name, columns names, index names, ...).
+ *
+ * Within the template literal on which the tag function is applied, all placeholders are considered to be database identifiers, and will thus be quoted as so according to the database in use.
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("name")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`name`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export function quote(expParts, ...values) {
+    return raw(expParts.join('??'), values);
+}

package/utils/RequestContext.d.ts

@@ -1,5 +1,5 @@
-import type { EntityManager } from '../EntityManager';
-import { type LoggingOptions } from '../logging/Logger';
+import type { EntityManager } from '../EntityManager.js';
+import { type LoggingOptions } from '../logging/Logger.js';
 /**
  * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
  */

package/utils/RequestContext.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestContext = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
+import { AsyncLocalStorage } from 'node:async_hooks';
 /**
  * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
  */
-class RequestContext {
+export class RequestContext {
     map;
-    static storage = new node_async_hooks_1.AsyncLocalStorage();
+    static storage = new AsyncLocalStorage();
     static counter = 1;
     id = RequestContext.counter++;
     constructor(map) {
@@ -61,4 +58,3 @@ class RequestContext {
         return new RequestContext(forks);
     }
 }
-exports.RequestContext = RequestContext;

package/utils/TransactionContext.d.ts

@@ -1,4 +1,4 @@
-import type { EntityManager } from '../EntityManager';
+import type { EntityManager } from '../EntityManager.js';
 export declare class TransactionContext {
     readonly em: EntityManager;
     private static storage;

package/utils/TransactionContext.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionContext = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
-class TransactionContext {
+import { AsyncLocalStorage } from 'node:async_hooks';
+export class TransactionContext {
     em;
-    static storage = new node_async_hooks_1.AsyncLocalStorage();
+    static storage = new AsyncLocalStorage();
     id;
     constructor(em) {
         this.em = em;
@@ -26,9 +23,8 @@ class TransactionContext {
     /**
      * Returns current EntityManager (if available).
      */
-    static getEntityManager(name = /* istanbul ignore next */ 'default') {
+    static getEntityManager(name = 'default') {
         const context = TransactionContext.currentTransactionContext();
         return context?.em.name === name ? context.em : undefined;
     }
 }
-exports.TransactionContext = TransactionContext;