@mikro-orm/core 7.0.0-dev.107 → 7.0.0-dev.109

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/entity/EntityHelper.js

@@ -6,6 +6,7 @@ import { WrappedEntity } from './WrappedEntity.js';
 import { ReferenceKind } from '../enums.js';
 import { helper } from './wrap.js';
 import { inspect } from '../logging/inspect.js';
+import { getEnv } from '../utils/env-vars.js';
 /**
  * @internal
  */
@@ -130,7 +131,7 @@ export class EntityHelper {
                 .forEach(prop => delete object[prop.name]);
             const ret = inspect(object, { depth });
             let name = this.constructor.name;
-            const showEM = ['true', 't', '1'].includes(process.env.MIKRO_ORM_LOG_EM_ID?.toString().toLowerCase() ?? '');
+            const showEM = ['true', 't', '1'].includes(getEnv('MIKRO_ORM_LOG_EM_ID')?.toLowerCase() ?? '');
             if (showEM) {
                 if (helper(this).__em) {
                     name += ` [managed by ${helper(this).__em.id}]`;

package/logging/colors.d.ts

@@ -5,5 +5,5 @@ export declare const colors: {
     yellow: (text: string) => string;
     grey: (text: string) => string;
     cyan: (text: string) => string;
-    enabled: () => boolean | "" | undefined;
+    enabled: () => boolean;
 };

package/logging/colors.js

@@ -1,9 +1,10 @@
-const bool = (v) => v && ['true', 't', '1'].includes(v.toLowerCase());
-const boolIfDefined = (v) => v != null ? bool(v) : true;
-const enabled = () => !bool(process.env.NO_COLOR)
-    && !bool(process.env.MIKRO_ORM_NO_COLOR)
-    && boolIfDefined(process.env.FORCE_COLOR)
-    && boolIfDefined(process.env.MIKRO_ORM_COLORS);
+import { getEnv } from '../utils/env-vars.js';
+const bool = (k) => ['true', 't', '1'].includes(getEnv(k)?.toLowerCase() ?? '');
+const boolIfDefined = (k) => getEnv(k) != null ? bool(k) : true;
+const enabled = () => !bool('NO_COLOR')
+    && !bool('MIKRO_ORM_NO_COLOR')
+    && boolIfDefined('FORCE_COLOR')
+    && boolIfDefined('MIKRO_ORM_COLORS');
 const wrap = (fn) => (text) => enabled() ? fn(text) : text;
 /** @internal */
 export const colors = {

package/logging/inspect.js

@@ -1,12 +1,7 @@
 let nodeInspect;
 /** @internal */
 export function inspect(value, options) {
-    if (nodeInspect === undefined) {
-        /* v8 ignore else */
-        if (globalThis.process?.getBuiltinModule) {
-            nodeInspect = globalThis.process.getBuiltinModule('node:util').inspect;
-        }
-    }
+    nodeInspect ??= globalThis.process?.getBuiltinModule?.('node:util').inspect;
     /* v8 ignore else */
     if (nodeInspect) {
         return nodeInspect(value, options);

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.107",
+  "version": "7.0.0-dev.109",
   "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/utils/Configuration.js

@@ -10,6 +10,7 @@ import { RequestContext } from './RequestContext.js';
 import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums.js';
 import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter.js';
 import { EntityComparator } from './EntityComparator.js';
+import { setEnv } from './env-vars.js';
 const DEFAULTS = {
     pool: {},
     entities: [],
@@ -34,7 +35,7 @@ const DEFAULTS = {
     colors: true,
     findOneOrFailHandler: (entityName, where) => NotFoundError.findOneFailed(entityName, where),
     findExactlyOneOrFailHandler: (entityName, where) => NotFoundError.findExactlyOneFailed(entityName, where),
-    baseDir: process.cwd(),
+    baseDir: globalThis.process?.cwd?.(),
     hydrator: ObjectHydrator,
     flushMode: FlushMode.AUTO,
     loadStrategy: LoadStrategy.BALANCED,
@@ -135,10 +136,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();
         }
@@ -328,7 +328,7 @@ export class Configuration {
         }
     }
     sync() {
-        process.env.MIKRO_ORM_COLORS = '' + this.options.colors;
+        setEnv('MIKRO_ORM_COLORS', this.options.colors);
         this.logger.setDebugMode(this.options.debug);
     }
     validateOptions() {

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.107';
-    /* v8 ignore next */
-    static dynamicImportProvider = (id) => import(id);
+    static #ORM_VERSION = '7.0.0-dev.109';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -537,14 +533,16 @@ export class Utils {
      * Tries to detect TypeScript support.
      */
     static detectTypeScriptSupport() {
+        /* v8 ignore next */
+        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 (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 => {
+            || !!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;
@@ -723,11 +663,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/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];

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';