@mikro-orm/core 7.0.0-dev.5 → 7.0.0-dev.50

package/utils/QueryHelper.js

@@ -4,6 +4,7 @@ import { GroupOperator, ReferenceKind } from '../enums.js';
 import { JsonType } from '../types/JsonType.js';
 import { helper } from '../entity/wrap.js';
 import { RawQueryFragment, isRaw } from './RawQueryFragment.js';
+/** @internal */
 export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
     static processParams(params) {
@@ -33,11 +34,52 @@ export class QueryHelper {
         });
         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 Utils.isGroupOperator(k) && 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.getPrimaryKeyValues(item, meta.primaryKeys, false);
+                    where[i] = Utils.getPrimaryKeyValues(item, meta, false);
                 }
             });
         }
@@ -45,9 +87,9 @@ export class QueryHelper {
             return false;
         }
         if (meta.primaryKeys.every(pk => pk in where) && Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
-            return !!key && !GroupOperator[key] && Object.keys(where).every(k => !Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
+            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 false;
+                    return true;
                 }
                 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);
@@ -58,7 +100,7 @@ export 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.getPrimaryKeyValues(where[k], meta2.primaryKeys, true);
+                where[k] = Utils.getPrimaryKeyValues(where[k], meta2, true);
             }
         });
         return false;
@@ -69,6 +111,7 @@ export 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') {
@@ -118,7 +161,7 @@ export class QueryHelper {
                 value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
             }
             const isJsonProperty = prop?.customType instanceof JsonType && Utils.isPlainObject(value) && !isRaw(value) && Object.keys(value)[0] !== '$eq';
-            if (isJsonProperty) {
+            if (isJsonProperty && prop?.kind !== ReferenceKind.EMBEDDED) {
                 return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
             }
             if (Array.isArray(value) && !Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
@@ -159,6 +202,24 @@ export 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;

package/utils/RawQueryFragment.d.ts

@@ -10,8 +10,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>;
     /**
@@ -72,8 +70,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 +106,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

@@ -8,7 +8,6 @@ export class RawQueryFragment {
     static #storage = new AsyncLocalStorage();
     static #index = 0n;
     static cloneRegistry;
-    #assigned = false;
     #used = 0;
     #key;
     constructor(sql, params = []) {
@@ -17,11 +16,6 @@ export class RawQueryFragment {
         this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
     }
     as(alias) {
-        // TODO: to be removed in v7
-        /* istanbul ignore next */
-        if (alias.startsWith('`') || alias.startsWith('"')) {
-            return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
-        }
         return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
     valueOf() {
@@ -35,13 +29,6 @@ export 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);
@@ -147,6 +134,24 @@ export 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 function raw(sql, params) {
     if (sql instanceof RawQueryFragment) {
@@ -205,3 +210,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/TransactionManager.d.ts

@@ -0,0 +1,65 @@
+import type { EntityManager } from '../EntityManager.js';
+import { type TransactionOptions } from '../enums.js';
+/**
+ * Manages transaction lifecycle and propagation for EntityManager.
+ */
+export declare class TransactionManager {
+    private readonly em;
+    constructor(em: EntityManager);
+    /**
+     * Main entry point for handling transactional operations with propagation support.
+     */
+    handle<T>(cb: (em: EntityManager) => T | Promise<T>, options?: TransactionOptions): Promise<T>;
+    /**
+     * Executes the callback with the specified propagation type.
+     */
+    private executeWithPropagation;
+    /**
+     * Suspends the current transaction and returns the suspended resources.
+     */
+    private suspendTransaction;
+    /**
+     * Resumes a previously suspended transaction.
+     */
+    private resumeTransaction;
+    /**
+     * Executes operation without transaction context.
+     */
+    private executeWithoutTransaction;
+    /**
+     * Creates new independent transaction, suspending any existing one.
+     */
+    private executeWithNewTransaction;
+    /**
+     * Creates new transaction context.
+     */
+    private createNewTransaction;
+    /**
+     * Executes nested transaction with savepoint.
+     */
+    private executeNestedTransaction;
+    /**
+     * Creates a fork of the EntityManager with the given options.
+     */
+    private createFork;
+    /**
+     * Determines if changes should be propagated to the upper context.
+     */
+    private shouldPropagateToUpperContext;
+    /**
+     * Merges entities from fork to parent EntityManager.
+     */
+    private mergeEntitiesToParent;
+    /**
+     * Registers a deletion handler to unset entity identities after flush.
+     */
+    private registerDeletionHandler;
+    /**
+     * Processes transaction execution.
+     */
+    private processTransaction;
+    /**
+     * Executes transaction workflow with entity synchronization.
+     */
+    private executeTransactionFlow;
+}

package/utils/TransactionManager.js

@@ -0,0 +1,223 @@
+import { ReferenceKind, TransactionPropagation } from '../enums.js';
+import { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster.js';
+import { TransactionContext } from '../utils/TransactionContext.js';
+import { ChangeSetType } from '../unit-of-work/ChangeSet.js';
+import { TransactionStateError } from '../errors.js';
+import { helper } from '../entity/wrap.js';
+/**
+ * Manages transaction lifecycle and propagation for EntityManager.
+ */
+export class TransactionManager {
+    em;
+    constructor(em) {
+        this.em = em;
+    }
+    /**
+     * Main entry point for handling transactional operations with propagation support.
+     */
+    async handle(cb, options = {}) {
+        const em = this.em.getContext(false);
+        options.propagation ??= TransactionPropagation.NESTED;
+        options.ctx ??= em.getTransactionContext();
+        const hasExistingTransaction = !!em.getTransactionContext();
+        return this.executeWithPropagation(options.propagation, em, cb, options, hasExistingTransaction);
+    }
+    /**
+     * Executes the callback with the specified propagation type.
+     */
+    async executeWithPropagation(propagation, em, cb, options, hasExistingTransaction) {
+        switch (propagation) {
+            case TransactionPropagation.NOT_SUPPORTED:
+                return this.executeWithoutTransaction(em, cb, options);
+            case TransactionPropagation.REQUIRES_NEW:
+                return this.executeWithNewTransaction(em, cb, options, hasExistingTransaction);
+            case TransactionPropagation.REQUIRED:
+                if (hasExistingTransaction) {
+                    return cb(em);
+                }
+                return this.createNewTransaction(em, cb, options);
+            case TransactionPropagation.NESTED:
+                if (hasExistingTransaction) {
+                    return this.executeNestedTransaction(em, cb, options);
+                }
+                return this.createNewTransaction(em, cb, options);
+            case TransactionPropagation.SUPPORTS:
+                if (hasExistingTransaction) {
+                    return cb(em);
+                }
+                return this.executeWithoutTransaction(em, cb, options);
+            case TransactionPropagation.MANDATORY:
+                if (!hasExistingTransaction) {
+                    throw TransactionStateError.requiredTransactionNotFound(propagation);
+                }
+                return cb(em);
+            case TransactionPropagation.NEVER:
+                if (hasExistingTransaction) {
+                    throw TransactionStateError.transactionNotAllowed(propagation);
+                }
+                return this.executeWithoutTransaction(em, cb, options);
+            default:
+                throw TransactionStateError.invalidPropagation(propagation);
+        }
+    }
+    /**
+     * Suspends the current transaction and returns the suspended resources.
+     */
+    suspendTransaction(em) {
+        const suspended = em.getTransactionContext();
+        em.resetTransactionContext();
+        return suspended;
+    }
+    /**
+     * Resumes a previously suspended transaction.
+     */
+    resumeTransaction(em, suspended) {
+        if (suspended != null) {
+            em.setTransactionContext(suspended);
+        }
+    }
+    /**
+     * Executes operation without transaction context.
+     */
+    async executeWithoutTransaction(em, cb, options) {
+        const suspended = this.suspendTransaction(em);
+        const fork = this.createFork(em, { ...options, disableTransactions: true });
+        const propagateToUpperContext = this.shouldPropagateToUpperContext(em);
+        try {
+            return await this.executeTransactionFlow(fork, cb, propagateToUpperContext, em);
+        }
+        finally {
+            this.resumeTransaction(em, suspended);
+        }
+    }
+    /**
+     * Creates new independent transaction, suspending any existing one.
+     */
+    async executeWithNewTransaction(em, cb, options, hasExistingTransaction) {
+        const fork = this.createFork(em, options);
+        let suspended = null;
+        // Suspend existing transaction if present
+        if (hasExistingTransaction) {
+            suspended = this.suspendTransaction(em);
+        }
+        const newOptions = { ...options, ctx: undefined };
+        try {
+            return await this.processTransaction(em, fork, cb, newOptions);
+        }
+        finally {
+            if (suspended != null) {
+                this.resumeTransaction(em, suspended);
+            }
+        }
+    }
+    /**
+     * Creates new transaction context.
+     */
+    async createNewTransaction(em, cb, options) {
+        const fork = this.createFork(em, options);
+        return this.processTransaction(em, fork, cb, options);
+    }
+    /**
+     * Executes nested transaction with savepoint.
+     */
+    async executeNestedTransaction(em, cb, options) {
+        const fork = this.createFork(em, options);
+        // Pass existing context to create savepoint
+        const nestedOptions = { ...options, ctx: em.getTransactionContext() };
+        return this.processTransaction(em, fork, cb, nestedOptions);
+    }
+    /**
+     * Creates a fork of the EntityManager with the given options.
+     */
+    createFork(em, options) {
+        return em.fork({
+            clear: options.clear ?? false,
+            flushMode: options.flushMode,
+            cloneEventManager: true,
+            disableTransactions: options.ignoreNestedTransactions,
+            loggerContext: options.loggerContext,
+        });
+    }
+    /**
+     * Determines if changes should be propagated to the upper context.
+     */
+    shouldPropagateToUpperContext(em) {
+        return !em.global || this.em.config.get('allowGlobalContext');
+    }
+    /**
+     * Merges entities from fork to parent EntityManager.
+     */
+    mergeEntitiesToParent(fork, parent) {
+        const parentUoW = parent.getUnitOfWork(false);
+        // perf: if parent is empty, we can just move all entities from the fork to skip the `em.merge` overhead
+        if (parentUoW.getIdentityMap().keys().length === 0) {
+            for (const entity of fork.getUnitOfWork(false).getIdentityMap()) {
+                parentUoW.getIdentityMap().store(entity);
+                helper(entity).__em = parent;
+            }
+            return;
+        }
+        for (const entity of fork.getUnitOfWork(false).getIdentityMap()) {
+            const wrapped = helper(entity);
+            const meta = wrapped.__meta;
+            // eslint-disable-next-line dot-notation
+            const parentEntity = parentUoW.getById(meta.className, wrapped.getPrimaryKey(), parent['_schema'], true);
+            if (parentEntity && parentEntity !== entity) {
+                const parentWrapped = helper(parentEntity);
+                parentWrapped.__data = wrapped.__data;
+                parentWrapped.__originalEntityData = wrapped.__originalEntityData;
+                for (const prop of meta.hydrateProps) {
+                    if (prop.kind === ReferenceKind.SCALAR) {
+                        parentEntity[prop.name] = entity[prop.name];
+                    }
+                }
+            }
+            else {
+                parentUoW.merge(entity, new Set([entity]));
+            }
+        }
+    }
+    /**
+     * Registers a deletion handler to unset entity identities after flush.
+     */
+    registerDeletionHandler(fork, parent) {
+        fork.getEventManager().registerSubscriber({
+            afterFlush: (args) => {
+                const deletionChangeSets = args.uow.getChangeSets()
+                    .filter(cs => cs.type === ChangeSetType.DELETE || cs.type === ChangeSetType.DELETE_EARLY);
+                for (const cs of deletionChangeSets) {
+                    parent.getUnitOfWork(false).unsetIdentity(cs.entity);
+                }
+            },
+        });
+    }
+    /**
+     * Processes transaction execution.
+     */
+    async processTransaction(em, fork, cb, options) {
+        const propagateToUpperContext = this.shouldPropagateToUpperContext(em);
+        const eventBroadcaster = new TransactionEventBroadcaster(fork, undefined);
+        return TransactionContext.create(fork, () => fork.getConnection().transactional(async (trx) => {
+            fork.setTransactionContext(trx);
+            return this.executeTransactionFlow(fork, cb, propagateToUpperContext, em);
+        }, { ...options, eventBroadcaster }));
+    }
+    /**
+     * Executes transaction workflow with entity synchronization.
+     */
+    async executeTransactionFlow(fork, cb, propagateToUpperContext, parentEm) {
+        if (!propagateToUpperContext) {
+            const ret = await cb(fork);
+            await fork.flush();
+            return ret;
+        }
+        // Setup: Register deletion handler before execution
+        this.registerDeletionHandler(fork, parentEm);
+        // Execute callback and flush
+        const ret = await cb(fork);
+        await fork.flush();
+        // Synchronization: Merge entities back to the parent
+        this.mergeEntitiesToParent(fork, parentEm);
+        return ret;
+    }
+}

package/utils/Utils.d.ts

@@ -1,4 +1,4 @@
-import { type GlobbyOptions } from 'globby';
+import { type GlobOptions } from 'tinyglobby';
 import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
 import type { Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -134,14 +134,14 @@ export declare class Utils {
     static getCompositeKeyHash<T>(data: EntityData<T>, meta: EntityMetadata<T>, convertCustomTypes?: boolean, platform?: Platform, flat?: boolean): string;
     static getPrimaryKeyHash(pks: (string | Buffer | Date)[]): string;
     static splitPrimaryKeys<T extends object>(key: string): EntityKey<T>[];
-    static getPrimaryKeyValues<T>(entity: T, primaryKeys: string[], allowScalar?: boolean, convertCustomTypes?: boolean): any;
+    static getPrimaryKeyValues<T>(entity: T, primaryKeys: string[] | EntityMetadata<T>, allowScalar?: boolean, convertCustomTypes?: boolean): any;
     static getPrimaryKeyCond<T>(entity: T, primaryKeys: EntityKey<T>[]): Record<string, Primary<T>> | null;
     /**
      * Maps nested FKs from `[1, 2, 3]` to `[1, [2, 3]]`.
      */
     static mapFlatCompositePrimaryKey(fk: Primary<any>[], prop: EntityProperty, fieldNames?: string[], idx?: number): Primary<any> | Primary<any>[];
     static getPrimaryKeyCondFromArray<T extends object>(pks: Primary<T>[], meta: EntityMetadata<T>): Record<string, Primary<T>>;
-    static getOrderedPrimaryKeys<T>(id: Primary<T> | Record<string, Primary<T>>, meta: EntityMetadata<T>, platform?: Platform, convertCustomTypes?: boolean): Primary<T>[];
+    static getOrderedPrimaryKeys<T>(id: Primary<T> | Record<string, Primary<T>>, meta: EntityMetadata<T>, platform?: Platform, convertCustomTypes?: boolean, allowScalar?: boolean): Primary<T>[];
     /**
      * Checks whether given object is an entity instance.
      */
@@ -206,13 +206,13 @@ export declare class Utils {
      * If either `path` or `baseDir` are `file:` URLs, they are converted to local paths.
      */
     static absolutePath(path: string, baseDir?: string): string;
-    static hash(data: string, length?: number): string;
+    static hash(data: string, length?: number, algorithm?: 'md5' | 'sha256'): string;
     static runIfNotEmpty(clause: () => any, data: any): void;
     static defaultValue<T extends Dictionary>(prop: T, option: keyof T, defaultValue: any): void;
     static findDuplicates<T>(items: T[]): T[];
     static removeDuplicates<T>(items: T[]): T[];
     static randomInt(min: number, max: number): number;
-    static pathExists(path: string, options?: GlobbyOptions): Promise<boolean>;
+    static pathExists(path: string, options?: GlobOptions): Promise<boolean>;
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
@@ -230,6 +230,12 @@ export declare class Utils {
      * @param [from] Location to start the node resolution
      */
     static requireFrom<T extends Dictionary>(id: string, from?: string): T;
+    /**
+     * Resolve path to a module.
+     * @param id The module to require
+     * @param [from] Location to start the node resolution
+     */
+    static resolveModulePath(id: string, from?: string): string;
     static dynamicImport<T = any>(id: string): Promise<T>;
     static setDynamicImportProvider(provider: (id: string) => Promise<unknown>): void;
     static ensureDir(path: string): void;
@@ -246,19 +252,15 @@ export declare class Utils {
     static setPayloadProperty<T>(entity: EntityDictionary<T>, meta: EntityMetadata<T>, prop: EntityProperty<T>, value: unknown, idx: number[]): void;
     static tryRequire<T extends Dictionary = any>({ module, from, allowError, warning }: {
         module: string;
-        warning: string;
+        warning?: string;
         from?: string;
         allowError?: string;
     }): T | undefined;
     static tryImport<T extends Dictionary = any>({ module, warning }: {
         module: string;
-        warning: string;
+        warning?: string;
     }): Promise<T | undefined>;
     static stripRelativePath(str: string): string;
-    /**
-     * simple process.argv parser, supports only properties with long names, prefixed with `--`
-     */
-    static parseArgs<T extends Dictionary = Dictionary>(): T;
     static xor(a: boolean, b: boolean): boolean;
     static keys<T extends object>(obj: T): (keyof T)[];
     static values<T extends object>(obj: T): T[keyof T][];