@mikro-orm/core 7.0.0-dev.106 → 7.0.0-dev.108

package/cache/FileCacheAdapter.js

@@ -63,7 +63,7 @@ export class FileCacheAdapter {
         let path = typeof this.options.combined === 'string'
             ? this.options.combined
             : './metadata.json';
-        path = Utils.normalizePath(this.options.cacheDir, path);
+        path = fs.normalizePath(this.options.cacheDir, path);
         this.options.combined = path; // override in the options, so we can log it from the CLI in `cache:generate` command
         writeFileSync(path, JSON.stringify(this.cache, null, this.pretty ? 2 : undefined));
         return path;
@@ -73,7 +73,7 @@ export class FileCacheAdapter {
         return `${this.options.cacheDir}/${name}.json`;
     }
     getHash(origin) {
-        origin = Utils.absolutePath(origin, this.baseDir);
+        origin = fs.absolutePath(origin, this.baseDir);
         if (!existsSync(origin)) {
             return null;
         }

package/metadata/MetadataDiscovery.js

@@ -153,15 +153,19 @@ export class MetadataDiscovery {
         const { entities, entitiesTs, baseDir } = this.config.getAll();
         const targets = (preferTs && entitiesTs.length > 0) ? entitiesTs : entities;
         const processed = [];
+        const paths = [];
         for (const entity of targets) {
             if (typeof entity === 'string') {
-                const { discoverEntities } = await import('@mikro-orm/core/file-discovery');
-                processed.push(...await discoverEntities(entity, { baseDir }));
+                paths.push(entity);
             }
             else {
                 processed.push(entity);
             }
         }
+        if (paths.length > 0) {
+            const { discoverEntities } = await import('@mikro-orm/core/file-discovery');
+            processed.push(...await discoverEntities(paths, { baseDir }));
+        }
         return this.discoverReferences(processed);
     }
     discoverMissingTargets() {
@@ -253,7 +257,7 @@ export class MetadataDiscovery {
         const path = entity[MetadataStorage.PATH_SYMBOL];
         if (path) {
             const meta = Utils.copy(MetadataStorage.getMetadata(entity.name, path), false);
-            meta.path = Utils.relativePath(path, this.config.get('baseDir'));
+            meta.path = path;
             this.metadata.set(entity.name, meta);
         }
         const exists = this.metadata.has(entity.name);
@@ -279,7 +283,7 @@ export class MetadataDiscovery {
         const path = meta.path;
         this.logger.log('discovery', `- processing entity ${colors.cyan(meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
         const root = this.getRootEntity(meta);
-        schema.meta.path = Utils.relativePath(meta.path, this.config.get('baseDir'));
+        schema.meta.path = meta.path;
         const cache = this.metadataProvider.getCachedMetadata(meta, root);
         if (cache) {
             this.logger.log('discovery', `- using cached metadata for entity ${colors.cyan(meta.className)}`);

package/metadata/discover-entities.js

@@ -4,8 +4,8 @@ import { Utils } from '../utils/Utils.js';
 import { MetadataStorage } from './MetadataStorage.js';
 import { EntitySchema } from './EntitySchema.js';
 async function getEntityClassOrSchema(filepath, allTargets, baseDir) {
-    const path = Utils.normalizePath(baseDir, filepath);
-    const exports = await Utils.dynamicImport(path);
+    const path = fs.normalizePath(baseDir, filepath);
+    const exports = await fs.dynamicImport(path);
     const targets = Object.values(exports);
     // ignore class implementations that are linked from an EntitySchema
     for (const item of targets) {
@@ -25,9 +25,9 @@ async function getEntityClassOrSchema(filepath, allTargets, baseDir) {
     }
 }
 export async function discoverEntities(paths, options) {
-    paths = Utils.asArray(paths).map(path => Utils.normalizePath(path));
-    const baseDir = options?.baseDir ?? process.cwd();
-    const files = fs.glob(paths, Utils.normalizePath(baseDir));
+    paths = Utils.asArray(paths).map(path => fs.normalizePath(path));
+    const baseDir = fs.absolutePath(options?.baseDir ?? process.cwd());
+    const files = fs.glob(paths, fs.normalizePath(baseDir));
     const found = new Map();
     for (const filepath of files) {
         const filename = basename(filepath);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.106",
+  "version": "7.0.0-dev.108",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "exports": {
     "./package.json": "./package.json",

package/unit-of-work/UnitOfWork.js

@@ -1,4 +1,3 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { Collection } from '../entity/Collection.js';
 import { EntityHelper } from '../entity/EntityHelper.js';
 import { helper } from '../entity/wrap.js';
@@ -13,8 +12,9 @@ import { Cascade, DeferMode, EventType, LockMode, ReferenceKind } from '../enums
 import { OptimisticLockError, ValidationError } from '../errors.js';
 import { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster.js';
 import { IdentityMap } from './IdentityMap.js';
+import { createAsyncContext } from '../utils/AsyncContext.js';
 // to deal with validation for flush inside flush hooks and `Promise.all`
-const insideFlush = new AsyncLocalStorage();
+const insideFlush = createAsyncContext();
 export class UnitOfWork {
     em;
     /** map of references to managed entities */

package/utils/AsyncContext.d.ts

@@ -0,0 +1,6 @@
+export interface AsyncContext<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith(store: T): void;
+}
+export declare function createAsyncContext<T>(): AsyncContext<T>;

package/utils/AsyncContext.js

@@ -0,0 +1,42 @@
+function getNodeAsyncContext() {
+    const mod = globalThis.process?.getBuiltinModule?.('node:async_hooks');
+    /* v8 ignore next */
+    if (!mod?.AsyncLocalStorage) {
+        throw new Error('AsyncLocalStorage not available');
+    }
+    return new mod.AsyncLocalStorage();
+}
+/* v8 ignore next */
+function createFallbackAsyncContext() {
+    let store;
+    // eslint-disable-next-line no-console
+    console.warn('AsyncLocalStorage not available');
+    return {
+        getStore: () => store,
+        enterWith: value => store = value,
+        run: (value, cb) => {
+            const prev = store;
+            store = value;
+            try {
+                return cb();
+            }
+            finally {
+                store = prev;
+            }
+        },
+    };
+}
+export function createAsyncContext() {
+    /* v8 ignore next */
+    const ALS = globalThis.AsyncLocalStorage;
+    /* v8 ignore next */
+    if (typeof ALS === 'function' && ALS.prototype?.run) {
+        return new ALS();
+    }
+    /* v8 ignore else */
+    if (globalThis.process?.versions?.node) {
+        return getNodeAsyncContext();
+    }
+    /* v8 ignore next */
+    return createFallbackAsyncContext();
+}

package/utils/Configuration.js

@@ -135,10 +135,9 @@ export class Configuration {
     extensions = new Map();
     constructor(options, validate = true) {
         if (options.dynamicImportProvider) {
-            Utils.dynamicImportProvider = options.dynamicImportProvider;
+            globalThis.dynamicImportProvider = options.dynamicImportProvider;
         }
         this.options = Utils.mergeConfig({}, DEFAULTS, options);
-        this.options.baseDir = Utils.absolutePath(this.options.baseDir);
         if (validate) {
             this.validateOptions();
         }

package/utils/RawQueryFragment.js

@@ -1,10 +1,10 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { Utils } from './Utils.js';
+import { createAsyncContext } from './AsyncContext.js';
 export class RawQueryFragment {
     sql;
     params;
     static #rawQueryCache = new Map();
-    static #storage = new AsyncLocalStorage();
+    static #storage = createAsyncContext();
     static #index = 0n;
     static cloneRegistry;
     #used = 0;

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/Utils.d.ts

@@ -14,7 +14,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.
      */
@@ -129,25 +128,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;
@@ -161,7 +141,6 @@ export declare class Utils {
     static flatten<T>(arrays: T[][]): 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 callCompiledFunction<T extends unknown[], R>(fn: (...args: T) => R, ...args: T): R;

package/utils/Utils.js

@@ -1,5 +1,3 @@
-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';
@@ -125,9 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.106';
-    /* v8 ignore next */
-    static dynamicImportProvider = (id) => import(id);
+    static #ORM_VERSION = '7.0.0-dev.108';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -589,64 +585,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;
@@ -723,11 +661,6 @@ 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;
     }

package/utils/fs-utils.d.ts

@@ -4,9 +4,29 @@ export declare const fs: {
     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';

package/utils/fs-utils.js

@@ -1,6 +1,6 @@
 import { existsSync, globSync, mkdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { isAbsolute, join, normalize, relative } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { Utils } from './Utils.js';
 import { colors } from '../logging/colors.js';
 export const fs = {
@@ -20,13 +20,34 @@ export const fs = {
         return JSON.parse(file.toString());
     },
     glob(input, cwd) {
+        const patterns = Array.isArray(input) ? input : [input];
+        const positive = [];
+        const negative = [];
+        for (const p of patterns) {
+            if (p.startsWith('!')) {
+                negative.push(p.slice(1));
+            }
+            else {
+                positive.push(p);
+            }
+        }
+        const included = new Set(this.resolveGlob(positive, cwd));
+        if (included.size > 0 && negative.length > 0) {
+            const excluded = this.resolveGlob(negative, cwd);
+            for (const file of excluded) {
+                included.delete(file);
+            }
+        }
+        return [...included];
+    },
+    resolveGlob(input, cwd) {
         if (Array.isArray(input)) {
-            return input.flatMap(paths => this.glob(paths, cwd));
+            return input.flatMap(paths => this.resolveGlob(paths, cwd));
         }
         const hasGlobChars = /[*?[\]]/.test(input);
         if (!hasGlobChars) {
             try {
-                const s = statSync(cwd ? Utils.normalizePath(cwd, input) : input);
+                const s = statSync(cwd ? this.normalizePath(cwd, input) : input);
                 if (s.isDirectory()) {
                     const files = globSync(join(input, '**'), { cwd, withFileTypes: true });
                     return files.filter(f => f.isFile()).map(f => join(f.parentPath, f.name));
@@ -93,5 +114,65 @@ export const fs = {
             }
         }
     },
+    /**
+     * 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) {
+        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] = 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.
+     */
+    relativePath(path, relativeTo) {
+        if (!path) {
+            return path;
+        }
+        path = this.normalizePath(path);
+        if (path.startsWith('.')) {
+            return path;
+        }
+        path = relative(this.normalizePath(relativeTo), path);
+        return this.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.
+     */
+    absolutePath(path, baseDir = process.cwd()) {
+        if (!path) {
+            return this.normalizePath(baseDir);
+        }
+        if (!isAbsolute(path) && !path.startsWith('file://')) {
+            path = baseDir + '/' + path;
+        }
+        return this.normalizePath(path);
+    },
+    async dynamicImport(id) {
+        /* v8 ignore next */
+        const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
+        const dynamicImportProvider = globalThis.dynamicImportProvider ?? ((id) => import(id));
+        return dynamicImportProvider(specifier);
+    },
 };
 export * from '../cache/FileCacheAdapter.js';