@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/utils/RawQueryFragment.js

@@ -1,99 +1,65 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { inspect } from 'node:util';
 import { Utils } from './Utils.js';
 export class RawQueryFragment {
     sql;
     params;
-    static #rawQueryCache = new Map();
-    static #storage = new AsyncLocalStorage();
-    static #index = 0n;
-    static cloneRegistry;
-    #assigned = false;
-    #used = 0;
+    static #rawQueryReferences = new WeakMap();
     #key;
     constructor(sql, params = []) {
         this.sql = sql;
         this.params = params;
-        this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
     }
-    as(alias) {
-        // TODO: to be removed in v7
-        /* v8 ignore next 3 */
-        if (alias.startsWith('`') || alias.startsWith('"')) {
-            return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
+    get key() {
+        if (!this.#key) {
+            this.#key = Symbol(this.toJSON());
+            RawQueryFragment.#rawQueryReferences.set(this.#key, this);
         }
+        return this.#key;
+    }
+    as(alias) {
         return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
-    valueOf() {
+    [Symbol.toPrimitive](hint) {
+        // if a fragment is converted to string (used as an object key), return a unique symbol
+        // and save a weak reference to map so we can retrieve it when compiling the query
+        if (hint === 'string') {
+            return this.key;
+        }
         throw new Error(`Trying to modify raw SQL fragment: '${this.sql}'`);
     }
+    get [Symbol.toStringTag]() {
+        return this.toJSON();
+    }
     toJSON() {
-        return this.#key;
+        return `raw('${this.sql}')`;
     }
-    toString() {
-        RawQueryFragment.#rawQueryCache.set(this.#key, this);
-        this.#used++;
-        return this.#key;
+    clone() {
+        return this;
     }
-    /** @internal */
-    assign() {
-        if (this.#assigned) {
-            throw new Error(`Cannot reassign already used RawQueryFragment: '${this.sql}'`);
-        }
-        this.#assigned = true;
+    static isKnownFragmentSymbol(key) {
+        return typeof key === 'symbol' && this.#rawQueryReferences.has(key);
     }
-    clone() {
-        RawQueryFragment.cloneRegistry?.add(this.#key);
-        return new RawQueryFragment(this.sql, this.params);
-    }
-    static async run(cb) {
-        const removeStack = new Set();
-        const res = await this.#storage.run(removeStack, cb);
-        removeStack.forEach(key => RawQueryFragment.remove(key));
-        removeStack.clear();
-        return res;
-    }
-    /**
-     * @internal allows testing we don't leak memory, as the raw fragments cache needs to be cleared automatically
-     */
-    static checkCacheSize() {
-        return this.#rawQueryCache.size;
+    static hasObjectFragments(object) {
+        return (Utils.isPlainObject(object) &&
+            Object.getOwnPropertySymbols(object).some(symbol => this.isKnownFragmentSymbol(symbol)));
     }
     static isKnownFragment(key) {
         if (key instanceof RawQueryFragment) {
             return true;
         }
-        return this.#rawQueryCache.has(key);
+        return this.isKnownFragmentSymbol(key);
     }
-    static getKnownFragment(key, cleanup = true) {
+    static getKnownFragment(key) {
         if (key instanceof RawQueryFragment) {
             return key;
         }
-        const raw = this.#rawQueryCache.get(key);
-        if (raw && cleanup) {
-            this.remove(key);
-        }
-        return raw;
-    }
-    static remove(key) {
-        const raw = this.#rawQueryCache.get(key);
-        if (!raw) {
+        if (typeof key !== 'symbol') {
             return;
         }
-        raw.#used--;
-        if (raw.#used <= 0) {
-            const removeStack = this.#storage.getStore();
-            if (removeStack) {
-                removeStack.add(key);
-            }
-            else {
-                this.#rawQueryCache.delete(key);
-            }
-        }
+        return this.#rawQueryReferences.get(key);
     }
-    /* v8 ignore next 8 */
     /** @ignore */
-    [inspect.custom]() {
+    /* v8 ignore next */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
         if (this.params) {
             return { sql: this.sql, params: this.params };
         }
@@ -204,20 +170,19 @@ export function raw(sql, params) {
  *
  * // value can be empty array
  * await em.find(User, { [sql`(select 1 = 1)`]: [] });
+ *
+ * // with type parameter for assignment without casting
+ * entity.date = sql<Date>`now()`;
  * ```
  */
 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);
+    return raw(sql.join('?'), values);
 }
 export function createSqlFunction(func, key) {
     if (typeof key === 'string') {
         return raw(`${func}(${key})`);
     }
-    return raw(a => `${func}(${(key(a))})`);
+    return raw(a => `${func}(${key(a)})`);
 }
 sql.ref = (...keys) => raw('??', [keys.join('.')]);
 sql.now = (length) => raw('current_timestamp' + (length == null ? '' : `(${length})`));
@@ -231,7 +196,7 @@ sql.upper = (key) => createSqlFunction('upper', key);
  * ```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})` })
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns, indexName) => quote`create index ${indexName} on ${table} (${columns.name})` })
  * @Entity({ schema: 'library' })
  * export class Author { ... }
  * ```

package/utils/RequestContext.js

@@ -1,10 +1,10 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { createAsyncContext } from './AsyncContext.js';
 /**
  * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
  */
 export class RequestContext {
     map;
-    static storage = new AsyncLocalStorage();
+    static storage = createAsyncContext();
     static counter = 1;
     id = RequestContext.counter++;
     constructor(map) {

package/utils/TransactionContext.js

@@ -1,7 +1,7 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
+import { createAsyncContext } from './AsyncContext.js';
 export class TransactionContext {
     em;
-    static storage = new AsyncLocalStorage();
+    static storage = createAsyncContext();
     id;
     constructor(em) {
         this.em = em;

package/utils/TransactionManager.js

@@ -1,4 +1,4 @@
-import { TransactionPropagation } from '../enums.js';
+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';
@@ -17,9 +17,7 @@ export class TransactionManager {
      */
     async handle(cb, options = {}) {
         const em = this.em.getContext(false);
-        // Set NESTED as the default propagation type
         options.propagation ??= TransactionPropagation.NESTED;
-        // Set the context to the current transaction context if not already set
         options.ctx ??= em.getTransactionContext();
         const hasExistingTransaction = !!em.getTransactionContext();
         return this.executeWithPropagation(options.propagation, em, cb, options, hasExistingTransaction);
@@ -162,12 +160,16 @@ export class TransactionManager {
         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);
+            const parentEntity = parentUoW.getById(meta.class, wrapped.getPrimaryKey(), parent.schema, true);
             if (parentEntity && parentEntity !== entity) {
                 const parentWrapped = helper(parentEntity);
-                parentWrapped.__data = helper(entity).__data;
-                parentWrapped.__originalEntityData = helper(entity).__originalEntityData;
+                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]));
@@ -180,7 +182,8 @@ export class TransactionManager {
     registerDeletionHandler(fork, parent) {
         fork.getEventManager().registerSubscriber({
             afterFlush: (args) => {
-                const deletionChangeSets = args.uow.getChangeSets()
+                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);

package/utils/Utils.d.ts

@@ -1,9 +1,8 @@
-import { type GlobOptions } from 'tinyglobby';
-import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
+import type { CompiledFunctions, Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, Primary } from '../typings.js';
 import type { Collection } from '../entity/Collection.js';
 import type { Platform } from '../platforms/Platform.js';
-import type { ScalarReference } from '../entity/Reference.js';
-export declare const ObjectBindingPattern: unique symbol;
+import { type ScalarReference } from '../entity/Reference.js';
+import { type RawQueryFragmentSymbol } from './RawQueryFragment.js';
 export declare function compareObjects(a: any, b: any): boolean;
 export declare function compareArrays(a: any[] | string, b: any[] | string): boolean;
 export declare function compareBooleans(a: unknown, b: unknown): boolean;
@@ -14,33 +13,16 @@ export declare function compareBuffers(a: Uint8Array, b: Uint8Array): boolean;
 export declare function equals(a: any, b: any): boolean;
 export declare function parseJsonSafe<T = unknown>(value: unknown): T;
 export declare class Utils {
+    #private;
     static readonly PK_SEPARATOR = "~~~";
-    /**
-     * Checks if the argument is not undefined
-     */
-    static isDefined<T = Record<string, unknown>>(data: any): data is T;
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
     static isObject<T = Dictionary>(o: any): o is T;
-    /**
-     * Relation decorators allow using two signatures
-     * - using first parameter as options object
-     * - using all parameters
-     *
-     * This function validates those two ways are not mixed and returns the final options object.
-     * If the second way is used, we always consider the last parameter as options object.
-     * @internal
-     */
-    static processDecoratorParameters<T>(params: Dictionary): T;
-    /**
-     * Checks if the argument is instance of `Object`, but not one of the blacklisted types. Returns false for arrays.
-     */
-    static isNotObject<T = Dictionary>(o: any, not: any[]): o is T;
     /**
      * Removes `undefined` properties (recursively) so they are not saved as nulls
      */
-    static dropUndefinedProperties<T = Dictionary | unknown[]>(o: any, value?: undefined | null, visited?: Set<unknown>): void;
+    static dropUndefinedProperties(o: any, value?: null, visited?: Set<unknown>): void;
     /**
      * Returns the number of properties on `obj`. This is 20x faster than Object.keys(obj).length.
      * @see https://github.com/deepkit/deepkit-framework/blob/master/packages/core/src/core.ts
@@ -51,14 +33,6 @@ export declare class Utils {
      * @see https://github.com/deepkit/deepkit-framework/blob/master/packages/core/src/core.ts
      */
     static hasObjectKeys(object: Dictionary): boolean;
-    /**
-     * Checks if the argument is string
-     */
-    static isString(s: any): s is string;
-    /**
-     * Checks if the argument is number
-     */
-    static isNumber<T = number>(s: any): s is T;
     /**
      * Checks if arguments are deeply (but not strictly) equal.
      */
@@ -79,11 +53,6 @@ export declare class Utils {
      * Merges all sources into the target recursively.
      */
     private static _merge;
-    static getRootEntity(metadata: IMetadataStorage, meta: EntityMetadata): EntityMetadata;
-    /**
-     * Computes difference between two objects, ignoring items missing in `b`.
-     */
-    static diff(a: Dictionary, b: Dictionary): Record<keyof (typeof a & typeof b), any>;
     /**
      * Creates deep copy of given object.
      */
@@ -101,26 +70,11 @@ export declare class Utils {
      */
     static renameKey<T>(payload: T, from: string | keyof T, to: string): void;
     /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
-     */
-    static tokenize(func: {
-        toString(): string;
-    } | string | {
-        type: string;
-        value: string;
-    }[]): {
-        type: string;
-        value: string;
-    }[];
-    /**
-     * Returns array of functions argument names. Uses `esprima` for source code analysis.
+     * Returns array of functions argument names. Uses basic regex for source code analysis, might not work with advanced syntax.
      */
-    static getParamNames(func: {
+    static getConstructorParams(func: {
         toString(): string;
-    } | string | {
-        type: string;
-        value: string;
-    }[], methodName?: string): string[];
+    }): string[] | undefined;
     /**
      * Checks whether the argument looks like primary key (string, number or ObjectId).
      */
@@ -133,7 +87,7 @@ 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[] | EntityMetadata<T>, allowScalar?: boolean, convertCustomTypes?: boolean): any;
+    static getPrimaryKeyValues<T>(entity: T, meta: 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]]`.
@@ -149,12 +103,6 @@ export declare class Utils {
      * Checks whether given object is a scalar reference.
      */
     static isScalarReference<T = unknown>(data: any, allowReference?: boolean): data is ScalarReference<any> & {};
-    /**
-     * Checks whether the argument is ObjectId instance
-     */
-    static isObjectID(key: any): key is {
-        toHexString: () => string;
-    };
     /**
      * Checks whether the argument is empty (array without items, object without keys or falsy value).
      */
@@ -162,17 +110,12 @@ export declare class Utils {
     /**
      * Gets string name of given class.
      */
-    static className<T>(classOrName: EntityName<T>): string;
+    static className<T>(classOrName: string | EntityName<T>): string;
     static extractChildElements(items: string[], prefix: string, allSymbol?: string): string[];
     /**
      * Tries to detect TypeScript support.
      */
     static detectTypeScriptSupport(): boolean;
-    /**
-     * Uses some dark magic to get source path to caller where decorator is used.
-     * Analyses stack trace of error created inside the function call.
-     */
-    static lookupPathFromDecorator(name: string, stack?: string[]): string;
     /**
      * Gets the type of the argument.
      */
@@ -186,86 +129,32 @@ export declare class Utils {
      */
     static runSerial<T = any, U = any>(items: Iterable<U>, cb: (item: U) => Promise<T>): Promise<T[]>;
     static isCollection<T extends object, O extends object = object>(item: any): item is Collection<T, O>;
-    static fileURLToPath(url: string | URL): string;
-    /**
-     * Resolves and normalizes a series of path parts relative to each preceding part.
-     * If any part is a `file:` URL, it is converted to a local path. If any part is an
-     * absolute path, it replaces preceding paths (similar to `path.resolve` in NodeJS).
-     * Trailing directory separators are removed, and all directory separators are converted
-     * to POSIX-style separators (`/`).
-     */
-    static normalizePath(...parts: string[]): string;
-    /**
-     * Determines the relative path between two paths. If either path is a `file:` URL,
-     * it is converted to a local path.
-     */
-    static relativePath(path: string, relativeTo: string): string;
-    /**
-     * Computes the absolute path to for the given path relative to the provided base directory.
-     * 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, algorithm?: 'md5' | 'sha256'): string;
+    static hash(data: string, length?: number): 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?: GlobOptions): Promise<boolean>;
     /**
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
     static extractEnumValues(target: Dictionary): (string | number)[];
-    static flatten<T>(arrays: T[][]): T[];
+    static flatten<T>(arrays: T[][], deep?: boolean): T[];
     static isOperator(key: PropertyKey, includeGroupOperators?: boolean): boolean;
-    static isGroupOperator(key: PropertyKey): boolean;
-    static isArrayOperator(key: PropertyKey): boolean;
-    static isJsonKeyOperator(key: PropertyKey): boolean;
     static hasNestedKey(object: unknown, key: string): boolean;
-    static getGlobalStorage(namespace: string): Dictionary;
-    /**
-     * Require a module from a specific location
-     * @param id The module to require
-     * @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 ensureDir(path: string): void;
-    static pathExistsSync(path: string): boolean;
-    static readJSONSync(path: string): Dictionary;
     static getORMVersion(): string;
-    static createFunction(context: Map<string, any>, code: string): any;
+    static createFunction(context: Map<string, any>, code: string, compiledFunctions?: CompiledFunctions, key?: string): any;
     static callCompiledFunction<T extends unknown[], R>(fn: (...args: T) => R, ...args: T): R;
-    /**
-     * @see https://github.com/mikro-orm/mikro-orm/issues/840
-     */
-    static propertyDecoratorReturnValue(): any;
     static unwrapProperty<T>(entity: T, meta: EntityMetadata<T>, prop: EntityProperty<T>, payload?: boolean): [unknown, number[]][];
     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;
-        from?: string;
-        allowError?: string;
-    }): T | undefined;
-    static tryImport<T extends Dictionary = any>({ module, warning }: {
+    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][];
     static entries<T extends object>(obj: T): [keyof T, T[keyof T]][];
     static primaryKeyToObject<T>(meta: EntityMetadata<T>, primaryKey: Primary<T> | T, visible?: (keyof T)[]): T;
+    static getObjectQueryKeys<T extends Dictionary, K extends string = Extract<keyof T, string>>(obj: T): (K | RawQueryFragmentSymbol)[];
 }