@mikro-orm/core 7.0.0-dev.64 → 7.0.0-dev.66

package/EntityManager.js

@@ -627,7 +627,7 @@ export class EntityManager {
         where = await em.processWhere(entityName, where, options, 'read');
         em.validator.validateEmptyWhere(where);
         em.checkLockRequirements(options.lockMode, meta);
-        const isOptimisticLocking = !Utils.isDefined(options.lockMode) || options.lockMode === LockMode.OPTIMISTIC;
+        const isOptimisticLocking = options.lockMode == null || options.lockMode === LockMode.OPTIMISTIC;
         if (entity && !em.shouldRefresh(meta, entity, options) && isOptimisticLocking) {
             return em.lockAndPopulate(meta, entity, where, options);
         }
@@ -1711,7 +1711,7 @@ export class EntityManager {
                     options.flags.push(QueryFlag.INFER_POPULATE);
                     return [];
                 }
-                if (Utils.isString(field)) {
+                if (typeof field === 'string') {
                     return [{ field, strategy: options.strategy }];
                 }
                 return [field];
@@ -1818,7 +1818,7 @@ export class EntityManager {
         config ??= this.config.get('resultCache').global;
         if (config) {
             const em = this.getContext();
-            const expiration = Array.isArray(config) ? config[1] : (Utils.isNumber(config) ? config : undefined);
+            const expiration = Array.isArray(config) ? config[1] : (typeof config === 'number' ? config : undefined);
             await em.resultCache.set(key.key, data instanceof Function ? data() : data, '', expiration);
         }
     }

package/MikroORM.js

@@ -37,7 +37,7 @@ export class MikroORM {
      * - no support for folder based discovery
      */
     constructor(options) {
-        const env = ConfigurationLoader.loadEnvironmentVarsSync();
+        const env = ConfigurationLoader.loadEnvironmentVars();
         const coreVersion = ConfigurationLoader.checkPackageVersion();
         options = Utils.merge(options, env);
         this.config = new Configuration(options);

package/entity/Collection.js

@@ -63,7 +63,7 @@ export class Collection extends ArrayCollection {
     async loadCount(options = {}) {
         options = typeof options === 'boolean' ? { refresh: options } : options;
         const { refresh, where, ...countOptions } = options;
-        if (!refresh && !where && Utils.isDefined(this._count)) {
+        if (!refresh && !where && this._count != null) {
             return this._count;
         }
         const em = this.getEntityManager();

package/entity/EntityFactory.js

@@ -290,7 +290,7 @@ export class EntityFactory {
         if (!spk?.serializedPrimaryKey) {
             return;
         }
-        if (pk.type.toLowerCase() === 'objectid' && (data[pk.name] != null || data[spk.name] != null)) {
+        if (pk.type === 'ObjectId' && (data[pk.name] != null || data[spk.name] != null)) {
             data[pk.name] = this.platform.denormalizePrimaryKey((data[spk.name] || data[pk.name]));
             delete data[spk.name];
         }

package/entity/EntityValidator.js

@@ -43,7 +43,7 @@ export class EntityValidator {
                 !prop.embedded &&
                 ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
                 prop.name !== wrapped.__meta.root.discriminatorColumn &&
-                prop.type.toLowerCase() !== 'objectid' &&
+                prop.type !== 'ObjectId' &&
                 prop.persist !== false &&
                 entity[prop.name] == null) {
                 throw ValidationError.propertyRequired(entity, prop);
@@ -131,7 +131,7 @@ export class EntityValidator {
     }
     fixDateType(givenValue) {
         let date;
-        if (Utils.isString(givenValue) && givenValue.match(/^-?\d+(\.\d+)?$/)) {
+        if (typeof givenValue === 'string' && givenValue.match(/^-?\d+(\.\d+)?$/)) {
             date = new Date(+givenValue);
         }
         else {

package/metadata/EntitySchema.js

@@ -39,8 +39,8 @@ export class EntitySchema {
         if (type && Type.isMappedType(type.prototype)) {
             prop.type = type;
         }
-        if (Utils.isString(prop.formula)) {
-            const formula = prop.formula; // tmp var is needed here
+        if (typeof prop.formula === 'string') {
+            const formula = prop.formula;
             prop.formula = () => formula;
         }
         if (prop.formula) {
@@ -263,7 +263,7 @@ export class EntitySchema {
     }
     normalizeType(options, type) {
         if ('entity' in options) {
-            if (Utils.isString(options.entity)) {
+            if (typeof options.entity === 'string') {
                 type = options.type = options.entity;
             }
             else if (options.entity) {

package/metadata/MetadataDiscovery.d.ts

@@ -27,6 +27,7 @@ export declare class MetadataDiscovery {
     discoverReferences<T>(refs: Iterable<EntityClass<T> | EntitySchema<T>>, validate?: boolean): EntityMetadata<T>[];
     reset(className: string): void;
     private getSchema;
+    private getRootEntity;
     private discoverEntity;
     private saveToCache;
     private initNullability;

package/metadata/MetadataDiscovery.js

@@ -1,5 +1,5 @@
 import { extname } from 'node:path';
-import { EntityMetadata } from '../typings.js';
+import { EntityMetadata, } from '../typings.js';
 import { Utils } from '../utils/Utils.js';
 import { MetadataValidator } from './MetadataValidator.js';
 import { MetadataStorage } from './MetadataStorage.js';
@@ -270,11 +270,22 @@ export class MetadataDiscovery {
         schema.setClass(entity);
         return schema;
     }
+    getRootEntity(meta) {
+        const base = meta.extends && this.metadata.find(Utils.className(meta.extends));
+        if (!base || base === meta) { // make sure we do not fall into infinite loop
+            return meta;
+        }
+        const root = this.getRootEntity(base);
+        if (root.discriminatorColumn) {
+            return root;
+        }
+        return meta;
+    }
     discoverEntity(schema) {
         const meta = schema.meta;
         const path = meta.path;
         this.logger.log('discovery', `- processing entity ${colors.cyan(meta.className)}${colors.grey(path ? ` (${path})` : '')}`);
-        const root = Utils.getRootEntity(this.metadata, meta);
+        const root = this.getRootEntity(meta);
         schema.meta.path = Utils.relativePath(meta.path, this.config.get('baseDir'));
         const cache = this.metadataProvider.useCache() && meta.path && this.cache.get(meta.className + extname(meta.path));
         if (cache) {
@@ -971,7 +982,7 @@ export class MetadataDiscovery {
         }
         if (this.platform.usesEnumCheckConstraints() && !meta.embeddable) {
             for (const prop of meta.props) {
-                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => Utils.isString(item))) {
+                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
                     this.initFieldName(prop);
                     meta.checks.push({
                         name: this.namingStrategy.indexName(meta.tableName, prop.fieldNames, 'check'),
@@ -1277,7 +1288,7 @@ export class MetadataDiscovery {
             t = 'enum';
         }
         else if (prop.enum) {
-            t = prop.items?.every(item => Utils.isString(item)) ? 'enum' : 'tinyint';
+            t = prop.items?.every(item => typeof item === 'string') ? 'enum' : 'tinyint';
         }
         if (t === 'Date') {
             t = 'datetime';

package/metadata/MetadataStorage.d.ts

@@ -8,10 +8,6 @@ export declare class MetadataStorage {
     static getMetadata(): Dictionary<EntityMetadata>;
     static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
     static isKnownEntity(name: string): boolean;
-    static getMetadataFromDecorator<T = any>(target: T & Dictionary & {
-        [MetadataStorage.PATH_SYMBOL]?: string;
-    }): EntityMetadata<T>;
-    static init(): MetadataStorage;
     static clear(): void;
     getAll(): Dictionary<EntityMetadata>;
     getByDiscriminatorColumn<T>(meta: EntityMetadata<T>, data: EntityData<T>): EntityMetadata<T> | undefined;

package/metadata/MetadataStorage.js

@@ -2,9 +2,14 @@ import { EntityMetadata } from '../typings.js';
 import { Utils } from '../utils/Utils.js';
 import { MetadataError } from '../errors.js';
 import { EntityHelper } from '../entity/EntityHelper.js';
+function getGlobalStorage(namespace) {
+    const key = `mikro-orm-${namespace}`;
+    globalThis[key] = globalThis[key] || {};
+    return globalThis[key];
+}
 export class MetadataStorage {
     static PATH_SYMBOL = Symbol('MetadataStorage.PATH_SYMBOL');
-    static metadata = Utils.getGlobalStorage('metadata');
+    static metadata = getGlobalStorage('metadata');
     metadata;
     constructor(metadata = {}) {
         this.metadata = Utils.copy(metadata, false);
@@ -22,15 +27,6 @@ export class MetadataStorage {
     static isKnownEntity(name) {
         return !!Object.values(this.metadata).find(meta => meta.className === name);
     }
-    static getMetadataFromDecorator(target) {
-        if (!Object.hasOwn(target, MetadataStorage.PATH_SYMBOL)) {
-            Object.defineProperty(target, MetadataStorage.PATH_SYMBOL, { value: Utils.lookupPathFromDecorator(target.name), writable: true });
-        }
-        return MetadataStorage.getMetadata(target.name, target[MetadataStorage.PATH_SYMBOL]);
-    }
-    static init() {
-        return new MetadataStorage(MetadataStorage.metadata);
-    }
     static clear() {
         Object.keys(this.metadata).forEach(k => delete this.metadata[k]);
     }

package/metadata/MetadataValidator.d.ts

@@ -1,17 +1,10 @@
 import type { EntityMetadata } from '../typings.js';
 import { type MetadataDiscoveryOptions } from '../utils/Configuration.js';
-import { ReferenceKind } from '../enums.js';
 import type { MetadataStorage } from './MetadataStorage.js';
 /**
  * @internal
  */
 export declare class MetadataValidator {
-    /**
-     * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
-     * on the same property. One should use only `@ManyToOne()` in such case.
-     * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
-     */
-    static validateSingleDecorator(meta: EntityMetadata, propertyName: string, reference: ReferenceKind): void;
     validateEntityDefinition<T>(metadata: MetadataStorage, name: string, options: MetadataDiscoveryOptions): void;
     validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
     private validateReference;

package/metadata/MetadataValidator.js

@@ -5,16 +5,6 @@ import { ReferenceKind } from '../enums.js';
  * @internal
  */
 export class MetadataValidator {
-    /**
-     * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
-     * on the same property. One should use only `@ManyToOne()` in such case.
-     * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
-     */
-    static validateSingleDecorator(meta, propertyName, reference) {
-        if (meta.properties[propertyName] && meta.properties[propertyName].kind !== reference) {
-            throw MetadataError.multipleDecorators(meta.className, propertyName);
-        }
-    }
     validateEntityDefinition(metadata, name, options) {
         const meta = metadata.get(name);
         if (meta.virtual || meta.expression) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.64",
+  "version": "7.0.0-dev.66",
   "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",
@@ -52,7 +52,7 @@
     "access": "public"
   },
   "dependencies": {
-    "mikro-orm": "7.0.0-dev.64"
+    "mikro-orm": "7.0.0-dev.66"
   },
   "peerDependencies": {
     "dataloader": "2.2.3"

package/platforms/Platform.d.ts

@@ -1,7 +1,7 @@
 import { inspect } from 'node:util';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { type NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import type { Constructor, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, EntityMetadata, SimpleColumnMeta } from '../typings.js';
+import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta } from '../typings.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Configuration } from '../utils/Configuration.js';

package/platforms/Platform.js

@@ -3,7 +3,7 @@ import { clone } from '../utils/clone.js';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { UnderscoreNamingStrategy } from '../naming-strategy/UnderscoreNamingStrategy.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
-import { ArrayType, BigIntType, BlobType, Uint8ArrayType, BooleanType, CharacterType, DateType, DecimalType, DoubleType, JsonType, SmallIntType, TimeType, TinyIntType, Type, UuidType, StringType, IntegerType, FloatType, DateTimeType, TextType, EnumType, UnknownType, MediumIntType, IntervalType, } from '../types/index.js';
+import { ArrayType, BigIntType, BlobType, BooleanType, CharacterType, DateTimeType, DateType, DecimalType, DoubleType, EnumType, FloatType, IntegerType, IntervalType, JsonType, MediumIntType, SmallIntType, StringType, TextType, TimeType, TinyIntType, Type, Uint8ArrayType, UnknownType, UuidType, } from '../types/index.js';
 import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
 import { RawQueryFragment } from '../utils/RawQueryFragment.js';
@@ -160,7 +160,7 @@ export class Platform {
         return `text`;
     }
     getEnumTypeDeclarationSQL(column) {
-        if (column.items?.every(item => Utils.isString(item))) {
+        if (column.items?.every(item => typeof item === 'string')) {
             return `enum('${column.items.join("','")}')`;
         }
         return this.getTinyIntTypeDeclarationSQL(column);

package/types/ArrayType.d.ts

@@ -1,4 +1,4 @@
-import { Type, type TransformContext } from './Type.js';
+import { type TransformContext, Type } from './Type.js';
 import type { EntityProperty } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 export declare class ArrayType<T = string> extends Type<T[] | null, string | null> {

package/types/ArrayType.js

@@ -1,5 +1,4 @@
 import { Type } from './Type.js';
-import { Utils } from '../utils/Utils.js';
 import { ValidationError } from '../errors.js';
 export class ArrayType extends Type {
     toJsValue;
@@ -26,7 +25,7 @@ export class ArrayType extends Type {
         if (value == null) {
             return value;
         }
-        if (Utils.isString(value)) {
+        if (typeof value === 'string') {
             value = platform.unmarshallArray(value);
         }
         return value.map(i => this.toJsValue(i));

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Transaction } from './connections/Connection.js';
-import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind, type EmbeddedPrefixMode } from './enums.js';
+import { type Cascade, type DeferMode, type EmbeddedPrefixMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind } from './enums.js';
 import { type AssignOptions } from './entity/EntityAssigner.js';
 import { type EntityIdentifier } from './entity/EntityIdentifier.js';
 import { type EntityLoaderOptions } from './entity/EntityLoader.js';

package/typings.js

@@ -100,7 +100,7 @@ export class EntityMetadata {
         this.virtual = !!this.expression;
         if (config) {
             for (const prop of this.props) {
-                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => Utils.isString(item))) {
+                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
                     const name = config.getNamingStrategy().indexName(this.tableName, prop.fieldNames, 'check');
                     const exists = this.checks.findIndex(check => check.name === name);
                     if (exists !== -1) {

package/unit-of-work/UnitOfWork.js

@@ -724,7 +724,7 @@ export class UnitOfWork {
         if (!meta.versionProperty) {
             throw OptimisticLockError.notVersioned(meta);
         }
-        if (!Utils.isDefined(version)) {
+        if (typeof version === 'undefined') {
             return;
         }
         const wrapped = helper(entity);

package/utils/Configuration.js

@@ -144,7 +144,7 @@ export class Configuration {
     extensions = new Map();
     constructor(options, validate = true) {
         if (options.dynamicImportProvider) {
-            Utils.setDynamicImportProvider(options.dynamicImportProvider);
+            Utils.dynamicImportProvider = options.dynamicImportProvider;
         }
         this.options = Utils.mergeConfig({}, DEFAULTS, options);
         this.options.baseDir = Utils.absolutePath(this.options.baseDir);

package/utils/ConfigurationLoader.d.ts

@@ -1,40 +1,13 @@
-import type { EntityManager } from '../EntityManager.js';
-import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
+import type { IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
 import type { Dictionary } from '../typings.js';
-import { Configuration, type Options } from './Configuration.js';
+import { type Options } from './Configuration.js';
 /**
  * @internal
  */
 export declare class ConfigurationLoader {
-    /**
-     * Gets a named configuration
-     *
-     * @param contextName Load a config with the given `contextName` value. Used when config file exports array or factory function. Setting it to "default" matches also config objects without `contextName` set.
-     * @param paths Array of possible paths for a configuration file. Files will be checked in order, and the first existing one will be used. Defaults to the output of {@link ConfigurationLoader.getConfigPaths}.
-     * @param options Additional options to augment the final configuration with.
-     */
-    static getConfiguration<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>>(contextName?: string, paths?: string[], options?: Partial<Options>): Promise<Configuration<D, EM>>;
-    static getConfigFile(paths: string[]): Promise<[string, unknown] | []>;
+    static loadEnvironmentVars<D extends IDatabaseDriver>(): Partial<Options<D>>;
     static getPackageConfig(basePath?: string): Dictionary;
-    static getSettings(): Settings;
-    static getConfigPaths(): string[];
-    static isESM(): boolean;
-    /**
-     * Tries to register TS support in the following order: swc, tsx, jiti, tsimp
-     * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
-     * This method is used only in CLI context.
-     */
-    static registerTypeScriptSupport(configPath?: string, tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto'): Promise<boolean>;
-    static loadEnvironmentVars<D extends IDatabaseDriver>(): Promise<Partial<Options<D>>>;
-    static loadEnvironmentVarsSync<D extends IDatabaseDriver>(): Partial<Options<D>>;
     static getORMPackages(): Set<string>;
     static getORMPackageVersion(name: string): string | undefined;
     static checkPackageVersion(): string;
 }
-export interface Settings {
-    verbose?: boolean;
-    preferTs?: boolean;
-    tsLoader?: 'swc' | 'tsx' | 'jiti' | 'tsimp' | 'auto';
-    tsConfigPath?: string;
-    configPaths?: string[];
-}

package/utils/ConfigurationLoader.js

@@ -1,209 +1,11 @@
 import { realpathSync } from 'node:fs';
-import { colors } from '../logging/colors.js';
-import { Configuration } from './Configuration.js';
 import { Utils } from './Utils.js';
+import { colors } from '../logging/colors.js';
 /**
  * @internal
  */
 export class ConfigurationLoader {
-    /**
-     * Gets a named configuration
-     *
-     * @param contextName Load a config with the given `contextName` value. Used when config file exports array or factory function. Setting it to "default" matches also config objects without `contextName` set.
-     * @param paths Array of possible paths for a configuration file. Files will be checked in order, and the first existing one will be used. Defaults to the output of {@link ConfigurationLoader.getConfigPaths}.
-     * @param options Additional options to augment the final configuration with.
-     */
-    static async getConfiguration(contextName = 'default', paths = ConfigurationLoader.getConfigPaths(), options = {}) {
-        const env = await this.loadEnvironmentVars();
-        const configFinder = (cfg) => {
-            return typeof cfg === 'object' && cfg !== null && ('contextName' in cfg ? cfg.contextName === contextName : (contextName === 'default'));
-        };
-        const isValidConfigFactoryResult = (cfg) => {
-            return typeof cfg === 'object' && cfg !== null && (!('contextName' in cfg) || cfg.contextName === contextName);
-        };
-        const result = await this.getConfigFile(paths);
-        if (!result[0]) {
-            if (Utils.hasObjectKeys(env)) {
-                return new Configuration(Utils.mergeConfig({ contextName }, options, env));
-            }
-            throw new Error(`MikroORM config file not found in ['${paths.join(`', '`)}']`);
-        }
-        const path = result[0];
-        let tmp = result[1];
-        if (Array.isArray(tmp)) {
-            const tmpFirstIndex = tmp.findIndex(configFinder);
-            if (tmpFirstIndex === -1) {
-                // Static config not found. Try factory functions
-                let configCandidate;
-                for (let i = 0, l = tmp.length; i < l; ++i) {
-                    const f = tmp[i];
-                    if (typeof f !== 'function') {
-                        continue;
-                    }
-                    configCandidate = await f(contextName);
-                    if (!isValidConfigFactoryResult(configCandidate)) {
-                        continue;
-                    }
-                    tmp = configCandidate;
-                    break;
-                }
-                if (Array.isArray(tmp)) {
-                    throw new Error(`MikroORM config '${contextName}' was not found within the config file '${path}'. Either add a config with this name to the array, or add a function that when given this name will return a configuration object without a name, or with name set to this name.`);
-                }
-            }
-            else {
-                const tmpLastIndex = tmp.findLastIndex(configFinder);
-                if (tmpLastIndex !== tmpFirstIndex) {
-                    throw new Error(`MikroORM config '${contextName}' is not unique within the array exported by '${path}' (first occurrence index: ${tmpFirstIndex}; last occurrence index: ${tmpLastIndex})`);
-                }
-                tmp = tmp[tmpFirstIndex];
-            }
-        }
-        else {
-            if (tmp instanceof Function) {
-                tmp = await tmp(contextName);
-                if (!isValidConfigFactoryResult(tmp)) {
-                    throw new Error(`MikroORM config '${contextName}' was not what the function exported from '${path}' provided. Ensure it returns a config object with no name, or name matching the requested one.`);
-                }
-            }
-            else {
-                if (!configFinder(tmp)) {
-                    throw new Error(`MikroORM config '${contextName}' was not what the default export from '${path}' provided.`);
-                }
-            }
-        }
-        const esmConfigOptions = this.isESM() ? { entityGenerator: { esmImport: true } } : {};
-        return new Configuration(Utils.mergeConfig({}, esmConfigOptions, tmp, options, env));
-    }
-    static async getConfigFile(paths) {
-        for (let path of paths) {
-            path = Utils.absolutePath(path);
-            path = Utils.normalizePath(path);
-            if (Utils.pathExists(path)) {
-                const config = await Utils.dynamicImport(path);
-                /* v8 ignore next */
-                return [path, await (config.default ?? config)];
-            }
-        }
-        return [];
-    }
-    static getPackageConfig(basePath = process.cwd()) {
-        if (Utils.pathExists(`${basePath}/package.json`)) {
-            /* v8 ignore next 5 */
-            try {
-                return Utils.readJSONSync(`${basePath}/package.json`);
-            }
-            catch {
-                return {};
-            }
-        }
-        const parentFolder = realpathSync(`${basePath}/..`);
-        // we reached the root folder
-        if (basePath === parentFolder) {
-            return {};
-        }
-        return this.getPackageConfig(parentFolder);
-    }
-    static getSettings() {
-        const config = ConfigurationLoader.getPackageConfig();
-        const settings = { ...config['mikro-orm'] };
-        const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
-        settings.preferTs = process.env.MIKRO_ORM_CLI_PREFER_TS != null ? bool(process.env.MIKRO_ORM_CLI_PREFER_TS) : settings.preferTs;
-        settings.tsLoader = process.env.MIKRO_ORM_CLI_TS_LOADER ?? settings.tsLoader;
-        settings.tsConfigPath = process.env.MIKRO_ORM_CLI_TS_CONFIG_PATH ?? settings.tsConfigPath;
-        settings.verbose = process.env.MIKRO_ORM_CLI_VERBOSE != null ? bool(process.env.MIKRO_ORM_CLI_VERBOSE) : settings.verbose;
-        if (process.env.MIKRO_ORM_CLI_CONFIG?.endsWith('.ts')) {
-            settings.preferTs = true;
-        }
-        return settings;
-    }
-    static getConfigPaths() {
-        const settings = ConfigurationLoader.getSettings();
-        const typeScriptSupport = settings.preferTs ?? Utils.detectTypeScriptSupport();
-        const paths = [];
-        if (process.env.MIKRO_ORM_CLI_CONFIG) {
-            paths.push(process.env.MIKRO_ORM_CLI_CONFIG);
-        }
-        paths.push(...(settings.configPaths || []));
-        if (typeScriptSupport) {
-            paths.push('./src/mikro-orm.config.ts');
-            paths.push('./mikro-orm.config.ts');
-        }
-        const distDir = Utils.pathExists(process.cwd() + '/dist');
-        const buildDir = Utils.pathExists(process.cwd() + '/build');
-        /* v8 ignore next */
-        const path = distDir ? 'dist' : (buildDir ? 'build' : 'src');
-        paths.push(`./${path}/mikro-orm.config.js`);
-        paths.push('./mikro-orm.config.js');
-        /* v8 ignore next */
-        return Utils.unique(paths).filter(p => !p.match(/\.[mc]?ts$/) || typeScriptSupport);
-    }
-    static isESM() {
-        const config = ConfigurationLoader.getPackageConfig();
-        const type = config?.type ?? '';
-        return type === 'module';
-    }
-    /**
-     * Tries to register TS support in the following order: swc, tsx, jiti, tsimp
-     * Use `MIKRO_ORM_CLI_TS_LOADER` env var to set the loader explicitly.
-     * This method is used only in CLI context.
-     */
-    static async registerTypeScriptSupport(configPath = 'tsconfig.json', tsLoader) {
-        /* v8 ignore next 3 */
-        if (process.versions.bun) {
-            return true;
-        }
-        process.env.SWC_NODE_PROJECT ??= configPath;
-        process.env.TSIMP_PROJECT ??= configPath;
-        process.env.MIKRO_ORM_CLI_ALWAYS_ALLOW_TS ??= '1';
-        const isEsm = this.isESM();
-        /* v8 ignore next */
-        const importMethod = isEsm ? 'tryImport' : 'tryRequire';
-        const explicitLoader = tsLoader ?? process.env.MIKRO_ORM_CLI_TS_LOADER ?? 'auto';
-        const loaders = {
-            swc: { esm: '@swc-node/register/esm-register', cjs: '@swc-node/register' },
-            tsx: { esm: 'tsx/esm/api', cjs: 'tsx/cjs/api', cb: (tsx) => tsx.register({ tsconfig: configPath }) },
-            jiti: { esm: 'jiti/register', cjs: 'jiti/register', cb: () => Utils.setDynamicImportProvider(id => import(id).then(mod => mod?.default ?? mod)) },
-            tsimp: { esm: 'tsimp/import', cjs: 'tsimp/import' },
-        };
-        for (const loader of Utils.keys(loaders)) {
-            if (explicitLoader !== 'auto' && loader !== explicitLoader) {
-                continue;
-            }
-            const { esm, cjs, cb } = loaders[loader];
-            /* v8 ignore next */
-            const module = isEsm ? esm : cjs;
-            const mod = await Utils[importMethod]({ module });
-            if (mod) {
-                cb?.(mod);
-                process.env.MIKRO_ORM_CLI_TS_LOADER = loader;
-                return true;
-            }
-        }
-        // eslint-disable-next-line no-console
-        console.warn('Neither `swc`, `tsx`, `jiti` nor `tsimp` found in the project dependencies, support for working with TypeScript files might not work. To use `swc`, you need to install both `@swc-node/register` and `@swc/core`.');
-        return false;
-    }
-    static async loadEnvironmentVars() {
-        const ret = this.loadEnvironmentVarsSync();
-        // only to keep some sort of back compatibility with those using env vars only, to support `MIKRO_ORM_TYPE`
-        const PLATFORMS = {
-            mongo: { className: 'MongoDriver', module: '@mikro-orm/mongodb' },
-            mysql: { className: 'MySqlDriver', module: '@mikro-orm/mysql' },
-            mssql: { className: 'MsSqlDriver', module: '@mikro-orm/mssql' },
-            mariadb: { className: 'MariaDbDriver', module: '@mikro-orm/mariadb' },
-            postgresql: { className: 'PostgreSqlDriver', module: '@mikro-orm/postgresql' },
-            sqlite: { className: 'SqliteDriver', module: '@mikro-orm/sqlite' },
-            libsql: { className: 'LibSqlDriver', module: '@mikro-orm/libsql' },
-        };
-        if (process.env.MIKRO_ORM_TYPE) {
-            const val = process.env.MIKRO_ORM_TYPE;
-            const driver = await import(PLATFORMS[val].module);
-            ret.driver = driver[PLATFORMS[val].className];
-        }
-        return ret;
-    }
-    static loadEnvironmentVarsSync() {
+    static loadEnvironmentVars() {
         const ret = {};
         const array = (v) => v.split(',').map(vv => vv.trim());
         const bool = (v) => ['true', 't', '1'].includes(v.toLowerCase());
@@ -280,6 +82,23 @@ export class ConfigurationLoader {
         cleanup(ret, 'seeder');
         return ret;
     }
+    static getPackageConfig(basePath = process.cwd()) {
+        if (Utils.pathExists(`${basePath}/package.json`)) {
+            /* v8 ignore next 5 */
+            try {
+                return Utils.readJSONSync(`${basePath}/package.json`);
+            }
+            catch {
+                return {};
+            }
+        }
+        const parentFolder = realpathSync(`${basePath}/..`);
+        // we reached the root folder
+        if (basePath === parentFolder) {
+            return {};
+        }
+        return this.getPackageConfig(parentFolder);
+    }
     static getORMPackages() {
         const pkg = this.getPackageConfig();
         return new Set([

package/utils/EntityComparator.js

@@ -613,10 +613,10 @@ export class EntityComparator {
         if (['buffer', 'uint8array'].includes(type)) {
             return this.getGenericComparator(this.wrap(prop.name), `!compareBuffers(last${this.wrap(prop.name)}, current${this.wrap(prop.name)})`);
         }
-        if (['date'].includes(type)) {
+        if (type === 'date') {
             return this.getGenericComparator(this.wrap(prop.name), `last${this.wrap(prop.name)}.valueOf() !== current${this.wrap(prop.name)}.valueOf()`);
         }
-        if (['objectid'].includes(type)) {
+        if (type === 'objectid') {
             // We might be comparing PK to object, in case we compare with cached data of populated entity
             // in such case we just ignore the comparison and fallback to `equals()` (which will still mark
             // it as not equal as we compare PK to plain object).

package/utils/QueryHelper.js

@@ -1,9 +1,9 @@
 import { Reference } from '../entity/Reference.js';
 import { Utils } from './Utils.js';
-import { GroupOperator, ReferenceKind } from '../enums.js';
+import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, ReferenceKind } from '../enums.js';
 import { JsonType } from '../types/JsonType.js';
 import { helper } from '../entity/wrap.js';
-import { RawQueryFragment, isRaw } from './RawQueryFragment.js';
+import { isRaw, RawQueryFragment } from './RawQueryFragment.js';
 /** @internal */
 export class QueryHelper {
     static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
@@ -44,7 +44,7 @@ export class QueryHelper {
         }
         const keys = Object.keys(where);
         const groupOperator = keys.find(k => {
-            return Utils.isGroupOperator(k) && Array.isArray(where[k]) && where[k].every(cond => {
+            return k in GroupOperator && Array.isArray(where[k]) && where[k].every(cond => {
                 return Utils.isPlainObject(cond) && Object.keys(cond).every(k2 => {
                     if (Utils.isOperator(k2, false)) {
                         if (k2 === '$not') {
@@ -241,12 +241,12 @@ export class QueryHelper {
                 return o;
             }, {});
         }
-        if (key && Utils.isJsonKeyOperator(key)) {
+        if (key && JSON_KEY_OPERATORS.includes(key)) {
             return Array.isArray(cond)
                 ? platform.marshallArray(cond)
                 : cond;
         }
-        if (Array.isArray(cond) && !(key && Utils.isArrayOperator(key))) {
+        if (Array.isArray(cond) && !(key && ARRAY_OPERATORS.includes(key))) {
             return cond.map(v => QueryHelper.processCustomType(prop, v, platform, key, fromQuery));
         }
         if (isRaw(cond)) {

package/utils/Utils.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityData, EntityDictionary, EntityKey, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
+import type { 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';
@@ -14,32 +14,14 @@ export declare function parseJsonSafe<T = unknown>(value: unknown): T;
 export declare class Utils {
     static readonly PK_SEPARATOR = "~~~";
     static dynamicImportProvider: (id: string) => Promise<any>;
-    /**
-     * 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?: undefined | 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
@@ -50,14 +32,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.
      */
@@ -78,11 +52,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.
      */
@@ -133,12 +102,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).
      */
@@ -152,11 +115,6 @@ export declare class Utils {
      * 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.
      */
@@ -203,11 +161,7 @@ export declare class Utils {
     static extractEnumValues(target: Dictionary): (string | number)[];
     static flatten<T>(arrays: T[][]): 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
@@ -221,7 +175,6 @@ export declare class Utils {
      */
     static resolveModulePath(id: string, from?: string): string;
     static dynamicImport<T = any>(id: string): Promise<T>;
-    static setDynamicImportProvider(provider: (id: string) => Promise<unknown>): void;
     static ensureDir(path: string): void;
     static readJSONSync(path: string): Dictionary;
     static getORMVersion(): string;
@@ -239,7 +192,6 @@ export declare class Utils {
         module: string;
         warning?: string;
     }): Promise<T | undefined>;
-    static stripRelativePath(str: string): string;
     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][];

package/utils/Utils.js

@@ -4,7 +4,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, globSync, statSync, mkdirSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { clone } from './clone.js';
-import { ARRAY_OPERATORS, GroupOperator, JSON_KEY_OPERATORS, PlainObject, QueryOperator, ReferenceKind, } from '../enums.js';
+import { GroupOperator, PlainObject, QueryOperator, ReferenceKind } from '../enums.js';
 import { helper } from '../entity/wrap.js';
 function compareConstructors(a, b) {
     if (a.constructor === b.constructor) {
@@ -130,50 +130,12 @@ export class Utils {
     static PK_SEPARATOR = '~~~';
     /* v8 ignore next */
     static dynamicImportProvider = (id) => import(id);
-    /**
-     * Checks if the argument is not undefined
-     */
-    static isDefined(data) {
-        return typeof data !== 'undefined';
-    }
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
     static isObject(o) {
         return !!o && typeof o === 'object' && !Array.isArray(o);
     }
-    /**
-     * 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(params) {
-        const keys = Object.keys(params);
-        const values = Object.values(params);
-        if (!Utils.isPlainObject(values[0])) {
-            const lastKey = keys[keys.length - 1];
-            const last = params[lastKey];
-            delete params[lastKey];
-            return { ...last, ...params };
-        }
-        // validate only first parameter is used if its an option object
-        const empty = (v) => v == null || (Utils.isPlainObject(v) && !Utils.hasObjectKeys(v));
-        if (values.slice(1).some(v => !empty(v))) {
-            throw new Error('Mixing first decorator parameter as options object with other parameters is forbidden. ' +
-                'If you want to use the options parameter at first position, provide all options inside it.');
-        }
-        return values[0];
-    }
-    /**
-     * Checks if the argument is instance of `Object`, but not one of the blacklisted types. Returns false for arrays.
-     */
-    static isNotObject(o, not) {
-        return this.isObject(o) && !not.some(cls => o instanceof cls);
-    }
     /**
      * Removes `undefined` properties (recursively) so they are not saved as nulls
      */
@@ -221,18 +183,6 @@ export class Utils {
         }
         return false;
     }
-    /**
-     * Checks if the argument is string
-     */
-    static isString(s) {
-        return typeof s === 'string';
-    }
-    /**
-     * Checks if the argument is number
-     */
-    static isNumber(s) {
-        return typeof s === 'number';
-    }
     /**
      * Checks if arguments are deeply (but not strictly) equal.
      */
@@ -291,30 +241,6 @@ export class Utils {
         }
         return Utils._merge(target, sources, ignoreUndefined);
     }
-    static getRootEntity(metadata, meta) {
-        const base = meta.extends && metadata.find(Utils.className(meta.extends));
-        if (!base || base === meta) { // make sure we do not fall into infinite loop
-            return meta;
-        }
-        const root = Utils.getRootEntity(metadata, base);
-        if (root.discriminatorColumn) {
-            return root;
-        }
-        return meta;
-    }
-    /**
-     * Computes difference between two objects, ignoring items missing in `b`.
-     */
-    static diff(a, b) {
-        const ret = {};
-        for (const k of Object.keys(b)) {
-            if (Utils.equals(a[k], b[k])) {
-                continue;
-            }
-            ret[k] = b[k];
-        }
-        return ret;
-    }
     /**
      * Creates deep copy of given object.
      */
@@ -398,7 +324,7 @@ export class Utils {
             return true;
         }
         if (Utils.isObject(key)) {
-            if (key.constructor && key.constructor.name.toLowerCase() === 'objectid') {
+            if (key.constructor?.name === 'ObjectId') {
                 return true;
             }
             if (!Utils.isPlainObject(key) && !Utils.isEntity(key, true)) {
@@ -583,12 +509,6 @@ export class Utils {
     static isScalarReference(data, allowReference = false) {
         return typeof data === 'object' && data?.__scalarReference;
     }
-    /**
-     * Checks whether the argument is ObjectId instance
-     */
-    static isObjectID(key) {
-        return Utils.isObject(key) && key.constructor && key.constructor.name.toLowerCase() === 'objectid';
-    }
     /**
      * Checks whether the argument is empty (array without items, object without keys or falsy value).
      */
@@ -632,43 +552,6 @@ export class Utils {
                     || arg.includes('node_modules/tsx/'); // check for tsx loader
             });
     }
-    /**
-     * 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, stack) {
-        // use some dark magic to get source path to caller
-        stack = stack || new Error().stack.split('\n');
-        // In some situations (e.g. swc 1.3.4+), the presence of a source map can obscure the call to
-        // __decorate(), replacing it with the constructor name. To support these cases we look for
-        // Reflect.decorate() as well. Also when babel is used, we need to check
-        // the `_applyDecoratedDescriptor` method instead.
-        let line = stack.findIndex(line => line.match(/__decorate|Reflect\.decorate|_applyDecoratedDescriptor/));
-        // bun does not have those lines at all, only the DecorateProperty/DecorateConstructor,
-        // but those are also present in node, so we need to check this only if they weren't found.
-        if (line === -1) {
-            // here we handle bun which stack is different from nodejs so we search for reflect-metadata
-            // Different bun versions might have different stack traces. The "last index" works for both 1.2.6 and 1.2.7.
-            const reflectLine = stack.findLastIndex(line => Utils.normalizePath(line).includes('node_modules/reflect-metadata/Reflect.js'));
-            if (reflectLine === -1 || reflectLine + 2 >= stack.length || !stack[reflectLine + 1].includes('bun:wrap')) {
-                return name;
-            }
-            line = reflectLine + 2;
-        }
-        if (stack[line].includes('Reflect.decorate')) {
-            line++;
-        }
-        if (Utils.normalizePath(stack[line]).includes('node_modules/tslib/tslib')) {
-            line++;
-        }
-        try {
-            const re = stack[line].match(/\(.+\)/i) ? /\((.*):\d+:\d+\)/ : /at\s*(.*):\d+:\d+$/;
-            return Utils.normalizePath(stack[line].match(re)[1]);
-        }
-        catch {
-            return name;
-        }
-    }
     /**
      * Gets the type of the argument.
      */
@@ -852,15 +735,6 @@ export class Utils {
         }
         return key in GroupOperator || key in QueryOperator;
     }
-    static isGroupOperator(key) {
-        return key in GroupOperator;
-    }
-    static isArrayOperator(key) {
-        return ARRAY_OPERATORS.includes(key);
-    }
-    static isJsonKeyOperator(key) {
-        return JSON_KEY_OPERATORS.includes(key);
-    }
     static hasNestedKey(object, key) {
         if (!object) {
             return false;
@@ -873,11 +747,6 @@ export class Utils {
         }
         return false;
     }
-    static getGlobalStorage(namespace) {
-        const key = `mikro-orm-${namespace}`;
-        globalThis[key] = globalThis[key] || {};
-        return globalThis[key];
-    }
     /**
      * Require a module from a specific location
      * @param id The module to require
@@ -909,10 +778,6 @@ export class Utils {
         const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
         return this.dynamicImportProvider(specifier);
     }
-    /* v8 ignore next 3 */
-    static setDynamicImportProvider(provider) {
-        this.dynamicImportProvider = provider;
-    }
     static ensureDir(path) {
         if (!existsSync(path)) {
             mkdirSync(path, { recursive: true });
@@ -1086,9 +951,6 @@ export class Utils {
             throw err;
         }
     }
-    static stripRelativePath(str) {
-        return str.replace(/^(?:\.\.\/|\.\/)+/, '/');
-    }
     static xor(a, b) {
         return (a || b) && !(a && b);
     }