@mikro-orm/core 7.0.0-dev.63 → 7.0.0-dev.65

package/metadata/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

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

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 } from './enums.js';
+import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind, type EmbeddedPrefixMode } from './enums.js';
 import { type AssignOptions } from './entity/EntityAssigner.js';
 import { type EntityIdentifier } from './entity/EntityIdentifier.js';
 import { type EntityLoaderOptions } from './entity/EntityLoader.js';
@@ -7,7 +7,6 @@ import { type Collection } from './entity/Collection.js';
 import { type EntityFactory } from './entity/EntityFactory.js';
 import { type EntityRepository } from './entity/EntityRepository.js';
 import { Reference, type ScalarReference } from './entity/Reference.js';
-import type { MikroORM } from './MikroORM.js';
 import type { SerializationContext } from './serialization/SerializationContext.js';
 import type { SerializeOptions } from './serialization/EntitySerializer.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
@@ -17,7 +16,6 @@ import type { Platform } from './platforms/Platform.js';
 import type { Configuration } from './utils/Configuration.js';
 import type { RawQueryFragment } from './utils/RawQueryFragment.js';
 import type { EntityManager } from './EntityManager.js';
-import type { EmbeddedPrefixMode } from './decorators/Embedded.js';
 import type { EventSubscriber } from './events/EventSubscriber.js';
 import type { FilterOptions, FindOneOptions, FindOptions, LoadHint } from './drivers/IDatabaseDriver.js';
 export type Constructor<T = unknown> = new (...args: any[]) => T;
@@ -150,7 +148,6 @@ export type FilterValue<T> = OperatorMap<FilterItemValue<T>> | FilterItemValue<T
 export type FilterObject<T> = {
     -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<T[K]>> | FilterValue<ExpandProperty<T[K]>> | null;
 };
-export type ExpandObject<T> = T extends object ? T extends Scalar ? never : FilterObject<T> : never;
 export type ExpandQuery<T> = T extends object ? T extends Scalar ? never : FilterQuery<T> : FilterValue<T>;
 export type EntityProps<T> = {
     -readonly [K in EntityKey<T>]?: T[K];
@@ -583,6 +580,7 @@ export interface GenerateOptions {
     bidirectionalRelations?: boolean;
     identifiedReferences?: boolean;
     entityDefinition?: 'decorators' | 'defineEntity' | 'entitySchema';
+    decorators?: 'es' | 'legacy';
     inferEntityType?: boolean;
     enumMode?: 'ts-enum' | 'union-type' | 'dictionary';
     esmImport?: boolean;
@@ -847,12 +845,6 @@ export interface Seeder<T extends Dictionary = Dictionary> {
 }
 export type ConnectionType = 'read' | 'write';
 export type MetadataProcessor = (metadata: EntityMetadata[], platform: Platform) => MaybePromise<void>;
-/**
- * The type of context that the user intends to inject.
- */
-export type ContextProvider<T> = MaybePromise<MikroORM> | ((type: T) => MaybePromise<MikroORM | EntityManager | EntityRepository<any> | {
-    getEntityManager(): EntityManager;
-}>);
 export type MaybeReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
 export interface EntitySchemaWithMeta<TName extends string = string, TTableName extends string = string, TEntity = any, TBase = never, TProperties extends Record<string, any> = Record<string, any>> extends EntitySchema<TEntity, TBase> {
     readonly name: TName;

package/utils/Configuration.d.ts

@@ -9,15 +9,13 @@ import { type Logger, type LoggerNamespace, type LoggerOptions } from '../loggin
 import type { EntityManager } from '../EntityManager.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { EntitySchema } from '../metadata/EntitySchema.js';
-import type { MetadataProvider } from '../metadata/MetadataProvider.js';
+import { MetadataProvider } from '../metadata/MetadataProvider.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { ReflectMetadataProvider } from '../metadata/ReflectMetadataProvider.js';
-import type { EmbeddedPrefixMode } from '../decorators/Embedded.js';
 import type { EventSubscriber } from '../events/EventSubscriber.js';
 import type { AssignOptions } from '../entity/EntityAssigner.js';
 import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
 import { NotFoundError } from '../errors.js';
-import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums.js';
+import { DataloaderType, FlushMode, LoadStrategy, PopulateHint, type EmbeddedPrefixMode } from '../enums.js';
 import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter.js';
 import { EntityComparator } from './EntityComparator.js';
 import type { Type } from '../types/Type.js';
@@ -31,13 +29,10 @@ declare const DEFAULTS: {
     readonly filters: {};
     readonly discovery: {
         readonly warnWhenNoEntities: true;
-        readonly requireEntitiesArray: false;
         readonly checkDuplicateTableNames: true;
         readonly checkDuplicateFieldNames: true;
         readonly checkDuplicateEntities: true;
         readonly checkNonPersistentCompositeProps: true;
-        readonly alwaysAnalyseProperties: true;
-        readonly disableDynamicFileAccess: false;
         readonly inferDefaultValues: true;
     };
     readonly strict: false;
@@ -118,6 +113,7 @@ declare const DEFAULTS: {
         readonly identifiedReferences: true;
         readonly scalarPropertiesForRelations: "never";
         readonly entityDefinition: "defineEntity";
+        readonly decorators: "legacy";
         readonly enumMode: "dictionary";
         readonly fileName: (className: string) => string;
         readonly onlyPurePivotTables: false;
@@ -137,7 +133,7 @@ declare const DEFAULTS: {
         readonly expiration: 1000;
         readonly options: {};
     };
-    readonly metadataProvider: typeof ReflectMetadataProvider;
+    readonly metadataProvider: typeof MetadataProvider;
     readonly highlighter: NullHighlighter;
     readonly seeder: {
         readonly path: "./seeders";
@@ -284,18 +280,16 @@ export interface PoolConfig {
 }
 export interface MetadataDiscoveryOptions {
     warnWhenNoEntities?: boolean;
-    requireEntitiesArray?: boolean;
     checkDuplicateTableNames?: boolean;
     checkDuplicateFieldNames?: boolean;
     checkDuplicateEntities?: boolean;
     checkNonPersistentCompositeProps?: boolean;
-    alwaysAnalyseProperties?: boolean;
-    disableDynamicFileAccess?: boolean;
     inferDefaultValues?: boolean;
     getMappedType?: (type: string, platform: Platform) => Type<unknown> | undefined;
     onMetadata?: (meta: EntityMetadata, platform: Platform) => MaybePromise<void>;
     afterDiscovered?: (storage: MetadataStorage, platform: Platform) => MaybePromise<void>;
     tsConfigPath?: string;
+    /** @internal */
     skipSyncDiscovery?: boolean;
 }
 export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<Driver> & Driver[typeof EntityManagerType] = EntityManager<Driver> & Driver[typeof EntityManagerType], Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends ConnectionOptions {

package/utils/Configuration.js

@@ -5,7 +5,7 @@ import { NullHighlighter } from '../utils/NullHighlighter.js';
 import { DefaultLogger } from '../logging/DefaultLogger.js';
 import { colors } from '../logging/colors.js';
 import { Utils } from '../utils/Utils.js';
-import { ReflectMetadataProvider } from '../metadata/ReflectMetadataProvider.js';
+import { MetadataProvider } from '../metadata/MetadataProvider.js';
 import { NotFoundError } from '../errors.js';
 import { RequestContext } from './RequestContext.js';
 import { DataloaderType, FlushMode, LoadStrategy, PopulateHint } from '../enums.js';
@@ -20,13 +20,10 @@ const DEFAULTS = {
     filters: {},
     discovery: {
         warnWhenNoEntities: true,
-        requireEntitiesArray: false,
         checkDuplicateTableNames: true,
         checkDuplicateFieldNames: true,
         checkDuplicateEntities: true,
         checkNonPersistentCompositeProps: true,
-        alwaysAnalyseProperties: true,
-        disableDynamicFileAccess: false,
         inferDefaultValues: true,
     },
     strict: false,
@@ -108,6 +105,7 @@ const DEFAULTS = {
         identifiedReferences: true,
         scalarPropertiesForRelations: 'never',
         entityDefinition: 'defineEntity',
+        decorators: 'legacy',
         enumMode: 'dictionary',
         fileName: (className) => className,
         onlyPurePivotTables: false,
@@ -125,7 +123,7 @@ const DEFAULTS = {
         expiration: 1000, // 1s
         options: {},
     },
-    metadataProvider: ReflectMetadataProvider,
+    metadataProvider: MetadataProvider,
     highlighter: new NullHighlighter(),
     seeder: {
         path: './seeders',

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());
@@ -245,9 +47,12 @@ export class ConfigurationLoader {
         read(ret, 'MIKRO_ORM_COLORS', 'colors', bool);
         ret.discovery = {};
         read(ret.discovery, 'MIKRO_ORM_DISCOVERY_WARN_WHEN_NO_ENTITIES', 'warnWhenNoEntities', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_REQUIRE_ENTITIES_ARRAY', 'requireEntitiesArray', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_ALWAYS_ANALYSE_PROPERTIES', 'alwaysAnalyseProperties', bool);
-        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_DISABLE_DYNAMIC_FILE_ACCESS', 'disableDynamicFileAccess', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_DUPLICATE_TABLE_NAMES', 'checkDuplicateTableNames', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_DUPLICATE_FIELD_NAMES', 'checkDuplicateFieldNames', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_DUPLICATE_ENTITIES', 'checkDuplicateEntities', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_CHECK_NON_PERSISTENT_COMPOSITE_PROPS', 'checkNonPersistentCompositeProps', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_INFER_DEFAULT_VALUES', 'inferDefaultValues', bool);
+        read(ret.discovery, 'MIKRO_ORM_DISCOVERY_TS_CONFIG_PATH', 'tsConfigPath');
         cleanup(ret, 'discovery');
         ret.migrations = {};
         read(ret.migrations, 'MIKRO_ORM_MIGRATIONS_TABLE_NAME', 'tableName');
@@ -277,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/Utils.d.ts

@@ -227,10 +227,6 @@ export declare class Utils {
     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;
-    /**
-     * @see https://github.com/mikro-orm/mikro-orm/issues/840
-     */
-    static propertyDecoratorReturnValue(): any;
     static unwrapProperty<T>(entity: T, meta: EntityMetadata<T>, prop: EntityProperty<T>, payload?: boolean): [unknown, number[]][];
     static setPayloadProperty<T>(entity: EntityDictionary<T>, meta: EntityMetadata<T>, prop: EntityProperty<T>, value: unknown, idx: number[]): void;
     static tryRequire<T extends Dictionary = any>({ module, from, allowError, warning }: {

package/utils/Utils.js

@@ -975,14 +975,6 @@ export class Utils {
             throw e;
         }
     }
-    /**
-     * @see https://github.com/mikro-orm/mikro-orm/issues/840
-     */
-    static propertyDecoratorReturnValue() {
-        if (process.env.BABEL_DECORATORS_COMPAT) {
-            return {};
-        }
-    }
     static unwrapProperty(entity, meta, prop, payload = false) {
         let p = prop;
         const path = [];

package/decorators/Check.d.ts

@@ -1,3 +0,0 @@
-import type { CheckConstraint, EntityClass } from '../typings.js';
-export declare function Check<T>(options: CheckOptions<T>): (target: T, propertyName?: T extends EntityClass<unknown> ? undefined : keyof T) => any;
-export type CheckOptions<T = any> = CheckConstraint<T>;

package/decorators/Check.js

@@ -1,13 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { Utils } from '../utils/Utils.js';
-export function Check(options) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator((propertyName ? target.constructor : target));
-        options.property ??= propertyName;
-        meta.checks.push(options);
-        if (!propertyName) {
-            return target;
-        }
-        return Utils.propertyDecoratorReturnValue();
-    };
-}

package/decorators/CreateRequestContext.d.ts

@@ -1,3 +0,0 @@
-import type { ContextProvider } from '../typings.js';
-export declare function CreateRequestContext<T extends object>(context?: ContextProvider<T>, respectExistingContext?: boolean): MethodDecorator;
-export declare function EnsureRequestContext<T extends object>(context?: ContextProvider<T>): MethodDecorator;

package/decorators/CreateRequestContext.js

@@ -1,32 +0,0 @@
-import { RequestContext } from '../utils/RequestContext.js';
-import { resolveContextProvider } from '../utils/resolveContextProvider.js';
-import { TransactionContext } from '../utils/TransactionContext.js';
-export function CreateRequestContext(context, respectExistingContext = false) {
-    return function (target, propertyKey, descriptor) {
-        const originalMethod = descriptor.value;
-        const name = respectExistingContext ? 'EnsureRequestContext' : 'CreateRequestContext';
-        if (originalMethod.constructor.name !== 'AsyncFunction') {
-            throw new Error(`@${name}() should be use with async functions`);
-        }
-        descriptor.value = async function (...args) {
-            const em = await resolveContextProvider(this, context);
-            if (!em) {
-                throw new Error(`@${name}() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@${name}(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
-            }
-            // reuse existing context if available for given respect `contextName`
-            if (respectExistingContext && RequestContext.getEntityManager(em.name)) {
-                return originalMethod.apply(this, args);
-            }
-            // Otherwise, the outer tx context would be preferred.
-            const txContext = TransactionContext.currentTransactionContext();
-            const provider = txContext ? TransactionContext : RequestContext;
-            return txContext
-                ? provider.create(em.fork({ useContext: true }), () => originalMethod.apply(this, args))
-                : provider.create(em, () => originalMethod.apply(this, args));
-        };
-        return descriptor;
-    };
-}
-export function EnsureRequestContext(context) {
-    return CreateRequestContext(context, true);
-}

package/decorators/Embeddable.d.ts

@@ -1,10 +0,0 @@
-import type { AnyString, Dictionary, EntityClass } from '../typings.js';
-export declare function Embeddable<T>(options?: EmbeddableOptions<T>): (target: T) => T;
-export interface EmbeddableOptions<T> {
-    /** Specify constructor parameters to be used in `em.create` or when `forceConstructor` is enabled. Those should be names of declared entity properties in the same order as your constructor uses them. The ORM tries to infer those automatically, use this option in case the inference fails. */
-    constructorParams?: (T extends EntityClass<infer P> ? keyof P : string)[];
-    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
-    discriminatorMap?: Dictionary<string>;
-    discriminatorValue?: number | string;
-    abstract?: boolean;
-}

package/decorators/Embeddable.js

@@ -1,11 +0,0 @@
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-export function Embeddable(options = {}) {
-    return function (target) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target);
-        meta.class = target;
-        meta.name = meta.class.name;
-        meta.embeddable = true;
-        Object.assign(meta, options);
-        return target;
-    };
-}

package/decorators/Embedded.d.ts

@@ -1,12 +0,0 @@
-import type { AnyEntity, EntityName } from '../typings.js';
-import type { PropertyOptions } from './Property.js';
-export declare function Embedded<Owner extends object, Target>(type?: EmbeddedOptions<Owner, Target> | (() => EntityName<Target> | EntityName<Target>[]), options?: EmbeddedOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => any;
-/** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
-export type EmbeddedPrefixMode = 'absolute' | 'relative';
-export interface EmbeddedOptions<Owner, Target> extends PropertyOptions<Owner> {
-    entity?: string | (() => EntityName<Target> | EntityName<Target>[]);
-    prefix?: string | boolean;
-    prefixMode?: EmbeddedPrefixMode;
-    object?: boolean;
-    array?: boolean;
-}

package/decorators/Embedded.js

@@ -1,18 +0,0 @@
-import { MetadataValidator } from '../metadata/MetadataValidator.js';
-import { MetadataStorage } from '../metadata/MetadataStorage.js';
-import { Utils } from '../utils/Utils.js';
-import { ReferenceKind } from '../enums.js';
-export function Embedded(type = {}, options = {}) {
-    return function (target, propertyName) {
-        const meta = MetadataStorage.getMetadataFromDecorator(target.constructor);
-        MetadataValidator.validateSingleDecorator(meta, propertyName, ReferenceKind.EMBEDDED);
-        options = type instanceof Function ? { entity: type, ...options } : { ...type, ...options };
-        Utils.defaultValue(options, 'prefix', true);
-        meta.properties[propertyName] = {
-            name: propertyName,
-            kind: ReferenceKind.EMBEDDED,
-            ...options,
-        };
-        return Utils.propertyDecoratorReturnValue();
-    };
-}