@mikro-orm/core 7.0.0-dev.99 → 7.0.0-rc.1

package/utils/RawQueryFragment.d.ts

@@ -1,23 +1,25 @@
 import type { AnyString, Dictionary, EntityKey } from '../typings.js';
-export declare class RawQueryFragment {
+declare const rawFragmentSymbolBrand: unique symbol;
+export type RawQueryFragmentSymbol = symbol & {
+    readonly [rawFragmentSymbolBrand]: true;
+};
+export declare class RawQueryFragment<Alias extends string = string> {
     #private;
     readonly sql: string;
     readonly params: unknown[];
-    static cloneRegistry?: Set<string>;
+    /** @internal Type-level only - used to track the alias for type inference */
+    private readonly __alias?;
     constructor(sql: string, params?: unknown[]);
-    as(alias: string): RawQueryFragment;
-    valueOf(): string;
+    get key(): RawQueryFragmentSymbol;
+    as<A extends string>(alias: A): RawQueryFragment<A>;
+    [Symbol.toPrimitive](hint: 'string'): RawQueryFragmentSymbol;
+    get [Symbol.toStringTag](): string;
     toJSON(): string;
-    toString(): string;
-    clone(): RawQueryFragment;
-    static run<T>(cb: (...args: any[]) => Promise<T>): Promise<T>;
-    /**
-     * @internal allows testing we don't leak memory, as the raw fragments cache needs to be cleared automatically
-     */
-    static checkCacheSize(): number;
-    static isKnownFragment(key: string | RawQueryFragment): boolean;
-    static getKnownFragment(key: string | RawQueryFragment, cleanup?: boolean): RawQueryFragment | undefined;
-    static remove(key: string): void;
+    clone(): this;
+    static isKnownFragmentSymbol(key: unknown): key is RawQueryFragmentSymbol;
+    static hasObjectFragments(object: unknown): boolean;
+    static isKnownFragment(key: unknown): key is RawQueryFragment | symbol;
+    static getKnownFragment(key: unknown): RawQueryFragment<any> | undefined;
 }
 export { RawQueryFragment as Raw };
 export declare function isRaw(value: unknown): value is RawQueryFragment;
@@ -80,7 +82,7 @@ export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
  * 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>): NoInfer<R>;
+export declare function raw<R = RawQueryFragment & symbol, T extends object = any>(sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): R;
 /**
  * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.
  *
@@ -93,16 +95,19 @@ export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> |
  *
  * // 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 declare function sql(sql: readonly string[], ...values: unknown[]): any;
+export declare function sql<R = RawQueryFragment & symbol>(sql: readonly string[], ...values: unknown[]): R;
 export declare namespace sql {
-    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;
+    var ref: <T extends object = any>(...keys: string[]) => RawQueryFragment<string> & symbol;
+    var now: (length?: number) => RawQueryFragment<string> & symbol;
+    var lower: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
+    var upper: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
 }
-export declare function createSqlFunction<T extends object, R = string>(func: string, key: string | ((alias: string) => string)): R;
+export declare function createSqlFunction<R = RawQueryFragment & symbol, T extends object = any>(func: string, key: string | ((alias: string) => string)): R;
 /**
  * Tag function providing quoting of db identifiers (table name, columns names, index names, ...).
  *
@@ -111,11 +116,11 @@ export declare function createSqlFunction<T extends object, R = string>(func: st
  * ```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 { ... }
  * ```
  */
 export declare function quote(expParts: readonly string[], ...values: (string | {
     toString(): string;
-})[]): any;
+})[]): RawQueryFragment<string> & symbol;

package/utils/RawQueryFragment.js

@@ -1,81 +1,60 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { Utils } from './Utils.js';
 export class RawQueryFragment {
     sql;
     params;
-    static #rawQueryCache = new Map();
-    static #storage = new AsyncLocalStorage();
-    static #index = 0n;
-    static cloneRegistry;
-    #used = 0;
+    static #rawQueryReferences = new WeakMap();
     #key;
     constructor(sql, params = []) {
         this.sql = sql;
         this.params = params;
-        this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
+    }
+    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}'`);
     }
-    toJSON() {
-        return this.#key;
+    get [Symbol.toStringTag]() {
+        return this.toJSON();
     }
-    toString() {
-        RawQueryFragment.#rawQueryCache.set(this.#key, this);
-        this.#used++;
-        return this.#key;
+    toJSON() {
+        return `raw('${this.sql}')`;
     }
     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;
+        return this;
+    }
+    static isKnownFragmentSymbol(key) {
+        return typeof key === 'symbol' && this.#rawQueryReferences.has(key);
+    }
+    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);
     }
     /** @ignore */
     /* v8 ignore next */
@@ -190,14 +169,13 @@ 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') {
@@ -217,7 +195,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

@@ -161,7 +161,7 @@ export class TransactionManager {
             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 = wrapped.__data;

package/utils/Utils.d.ts

@@ -1,7 +1,8 @@
-import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, 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';
+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,7 +15,6 @@ export declare function parseJsonSafe<T = unknown>(value: unknown): T;
 export declare class Utils {
     #private;
     static readonly PK_SEPARATOR = "~~~";
-    static dynamicImportProvider: (id: string) => Promise<any>;
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -110,7 +110,7 @@ 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.
@@ -129,25 +129,6 @@ 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): string;
     static runIfNotEmpty(clause: () => any, data: any): void;
     static defaultValue<T extends Dictionary>(prop: T, option: keyof T, defaultValue: any): void;
@@ -158,12 +139,11 @@ export declare class Utils {
      * 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 hasNestedKey(object: unknown, key: string): boolean;
-    static dynamicImport<T = any>(id: string): Promise<T>;
     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;
     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;
@@ -176,4 +156,5 @@ export declare class Utils {
     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)[];
 }

package/utils/Utils.js

@@ -1,8 +1,7 @@
-import { isAbsolute, normalize, relative } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
 import { clone } from './clone.js';
 import { GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
 import { helper } from '../entity/wrap.js';
+import { Raw } from './RawQueryFragment.js';
 function compareConstructors(a, b) {
     if (a.constructor === b.constructor) {
         return true;
@@ -36,7 +35,6 @@ export function compareObjects(a, b) {
     }
     /* v8 ignore next */
     if ((typeof a === 'function' && typeof b === 'function') ||
-        (typeof a === 'object' && a.client && ['Ref', 'Raw'].includes(a.constructor.name) && typeof b === 'object' && b.client && ['Ref', 'Raw'].includes(b.constructor.name)) || // knex qb
         (a instanceof RegExp && b instanceof RegExp) ||
         (a instanceof String && b instanceof String) ||
         (a instanceof Number && b instanceof Number)) {
@@ -125,9 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.99';
-    /* v8 ignore next */
-    static dynamicImportProvider = (id) => import(id);
+    static #ORM_VERSION = '7.0.0-rc.1';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -538,13 +534,15 @@ export class Utils {
      */
     static detectTypeScriptSupport() {
         /* v8 ignore next */
-        return process.argv[0].endsWith('ts-node') // running via ts-node directly
-            || !!process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS // forced explicitly or enabled via `registerTypeScriptSupport()`
-            || !!process.env.TS_JEST // check if ts-jest is used (works only with v27.0.4+)
-            || !!process.env.VITEST // check if vitest is used
-            || !!process.versions.bun // check if bun is used
-            || process.argv.slice(1).some(arg => arg.match(/\.([mc]?ts|tsx)$/)) // executing `.ts` file
-            || process.execArgv.some(arg => {
+        const process = globalThis.process ?? {};
+        /* v8 ignore next */
+        return process.argv?.[0]?.endsWith('ts-node') // running via ts-node directly
+            || !!process.env?.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS // forced explicitly or enabled via `registerTypeScriptSupport()`
+            || !!process.env?.TS_JEST // check if ts-jest is used
+            || !!process.env?.VITEST // check if vitest is used
+            || !!process.versions?.bun // check if bun is used
+            || process.argv?.slice(1).some(arg => arg.match(/\.([mc]?ts|tsx)$/)) // executing `.ts` file
+            || process.execArgv?.some(arg => {
                 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
@@ -589,64 +587,6 @@ export class Utils {
     static isCollection(item) {
         return item?.__collection;
     }
-    static fileURLToPath(url) {
-        // expose `fileURLToPath` on Utils so that it can be properly mocked in tests
-        return fileURLToPath(url);
-    }
-    /**
-     * 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) {
-        let start = 0;
-        for (let i = 0; i < parts.length; i++) {
-            const part = parts[i];
-            if (isAbsolute(part)) {
-                start = i;
-            }
-            else if (part.startsWith('file:')) {
-                start = i;
-                parts[i] = Utils.fileURLToPath(part);
-            }
-        }
-        if (start > 0) {
-            parts = parts.slice(start);
-        }
-        let path = parts.join('/').replace(/\\/g, '/').replace(/\/$/, '');
-        path = normalize(path).replace(/\\/g, '/');
-        return (path.match(/^[/.]|[a-zA-Z]:/) || path.startsWith('!')) ? path : './' + path;
-    }
-    /**
-     * Determines the relative path between two paths. If either path is a `file:` URL,
-     * it is converted to a local path.
-     */
-    static relativePath(path, relativeTo) {
-        if (!path) {
-            return path;
-        }
-        path = Utils.normalizePath(path);
-        if (path.startsWith('.')) {
-            return path;
-        }
-        path = relative(Utils.normalizePath(relativeTo), path);
-        return Utils.normalizePath(path);
-    }
-    /**
-     * 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, baseDir = process.cwd()) {
-        if (!path) {
-            return Utils.normalizePath(baseDir);
-        }
-        if (!isAbsolute(path) && !path.startsWith('file://')) {
-            path = baseDir + '/' + path;
-        }
-        return Utils.normalizePath(path);
-    }
     // FNV-1a 64-bit
     static hash(data, length) {
         let h1 = 0xcbf29ce484222325n;
@@ -702,8 +642,8 @@ export class Utils {
         }
         return values;
     }
-    static flatten(arrays) {
-        return [].concat.apply([], arrays);
+    static flatten(arrays, deep) {
+        return arrays.flatMap(v => deep && Array.isArray(v) ? this.flatten(v, true) : v);
     }
     static isOperator(key, includeGroupOperators = true) {
         if (!includeGroupOperators) {
@@ -723,15 +663,13 @@ export class Utils {
         }
         return false;
     }
-    static async dynamicImport(id) {
-        /* v8 ignore next */
-        const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
-        return this.dynamicImportProvider(specifier);
-    }
     static getORMVersion() {
         return this.#ORM_VERSION;
     }
-    static createFunction(context, code) {
+    static createFunction(context, code, compiledFunctions, key) {
+        if (key && compiledFunctions?.[key]) {
+            return compiledFunctions[key](...context.values());
+        }
         try {
             return new Function(...context.keys(), `'use strict';\n` + code)(...context.values());
             /* v8 ignore next */
@@ -889,4 +827,12 @@ export class Utils {
             return o;
         }, {});
     }
+    static getObjectQueryKeys(obj) {
+        return Reflect.ownKeys(obj).filter(key => {
+            if (!Object.prototype.propertyIsEnumerable.call(obj, key)) {
+                return false;
+            }
+            return typeof key === 'string' || Raw.isKnownFragmentSymbol(key);
+        });
+    }
 }

package/utils/clone.js

@@ -3,7 +3,6 @@
  * clone `EventEmitter`s to get around https://github.com/mikro-orm/mikro-orm/issues/2748
  * @internal
  */
-import { RawQueryFragment } from './RawQueryFragment.js';
 /**
  * Get the property descriptor of a property on an object or its prototype chain.
  *
@@ -29,10 +28,6 @@ export function clone(parent, respectCustomCloneMethod = true) {
         if (parent === null) {
             return null;
         }
-        const raw = RawQueryFragment.getKnownFragment(parent, false);
-        if (raw && respectCustomCloneMethod) {
-            return raw.clone();
-        }
         if (typeof parent !== 'object') {
             return parent;
         }
@@ -113,25 +108,16 @@ export function clone(parent, respectCustomCloneMethod = true) {
             if (attrs && typeof attrs.get === 'function' && attrs.set == null) {
                 continue;
             }
-            const raw = RawQueryFragment.getKnownFragment(i, false);
-            if (raw && respectCustomCloneMethod) {
-                const i2 = raw.clone().toString();
-                child[i2] = _clone(parent[i]);
-                continue;
-            }
             child[i] = _clone(parent[i]);
         }
-        if (Object.getOwnPropertySymbols) {
-            const symbols = Object.getOwnPropertySymbols(parent);
-            for (let i = 0; i < symbols.length; i++) {
-                const symbol = symbols[i];
-                const descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
-                /* v8 ignore next */
-                if (descriptor && !descriptor.enumerable) {
-                    continue;
-                }
-                child[symbol] = _clone(parent[symbol]);
+        const symbols = Object.getOwnPropertySymbols(parent);
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            const descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
+            if (descriptor && !descriptor.enumerable) {
+                continue;
             }
+            child[symbol] = _clone(parent[symbol]);
         }
         return child;
     }

package/utils/env-vars.d.ts

@@ -1,3 +1,7 @@
 import { type Options } from './Configuration.js';
 /** @internal */
+export declare function setEnv(key: string, value: unknown): void;
+/** @internal */
+export declare function getEnv(key: string): string | undefined;
+/** @internal */
 export declare function loadEnvironmentVars(): Partial<Options>;

package/utils/env-vars.js

@@ -1,5 +1,15 @@
 import { Utils } from './Utils.js';
 /** @internal */
+export function setEnv(key, value) {
+    if (globalThis.process?.env) {
+        globalThis.process.env[key] = String(value);
+    }
+}
+/** @internal */
+export function getEnv(key) {
+    return globalThis.process?.env?.[key];
+}
+/** @internal */
 export function loadEnvironmentVars() {
     const ret = {};
     const getEnvKey = (key, envPrefix = 'MIKRO_ORM_') => {
@@ -13,8 +23,9 @@ export function loadEnvironmentVars() {
     const num = (v) => +v;
     const read = (o, envPrefix, key, mapper = v => v) => {
         const envKey = getEnvKey(key, envPrefix);
-        if (envKey in process.env) {
-            o[key] = mapper(process.env[envKey]);
+        /* v8 ignore next */
+        if (envKey in (globalThis.process?.env ?? {})) {
+            o[key] = mapper(getEnv(envKey));
         }
     };
     const cleanup = (o, k) => Utils.hasObjectKeys(o[k]) ? {} : delete o[k];
@@ -49,7 +60,6 @@ export function loadEnvironmentVars() {
     read1('warnWhenNoEntities', bool);
     read1('checkDuplicateTableNames', bool);
     read1('checkDuplicateFieldNames', bool);
-    read1('checkDuplicateEntities', bool);
     read1('checkNonPersistentCompositeProps', bool);
     read1('inferDefaultValues', bool);
     read1('tsConfigPath');

package/utils/fs-utils.d.ts

@@ -1,12 +1,33 @@
 import { type Dictionary } from '../typings.js';
 export declare const fs: {
+    init(): Promise<void>;
     pathExists(path: string): boolean;
     ensureDir(path: string): void;
     readJSONSync<T = Dictionary>(path: string): T;
     glob(input: string | string[], cwd?: string): string[];
+    resolveGlob(input: string | string[], cwd?: string): string[];
     getPackageConfig<T extends Dictionary>(basePath?: string): T;
     getORMPackages(): Set<string>;
     getORMPackageVersion(name: string): string | undefined;
     checkPackageVersion(): void;
+    /**
+     * 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 (`/`).
+     */
+    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.
+     */
+    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.
+     */
+    absolutePath(path: string, baseDir?: string): string;
+    dynamicImport<T = any>(id: string): Promise<T>;
 };
 export * from '../cache/FileCacheAdapter.js';