@mikro-orm/core 7.0.0-dev.27 → 7.0.0-dev.29

package/EntityManager.d.ts

@@ -270,6 +270,29 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     upsertMany<Entity extends object, Fields extends string = any>(entityNameOrEntity: EntityName<Entity> | Entity[], data?: (EntityData<Entity> | NoInfer<Entity>)[], options?: UpsertManyOptions<Entity, Fields>): Promise<Entity[]>;
     /**
      * Runs your callback wrapped inside a database transaction.
+     *
+     * If a transaction is already active, a new savepoint (nested transaction) will be created by default. This behavior
+     * can be controlled via the `propagation` option. Use the provided EntityManager instance for all operations that
+     * should be part of the transaction. You can safely use a global EntityManager instance from a DI container, as this
+     * method automatically creates an async context for the transaction.
+     *
+     * **Concurrency note:** When running multiple transactions concurrently (e.g. in parallel requests or jobs), use the
+     * `clear: true` option. This ensures the callback runs in a clear fork of the EntityManager, providing full isolation
+     * between concurrent transactional handlers. Using `clear: true` is an alternative to forking explicitly and calling
+     * the method on the new fork – it already provides the necessary isolation for safe concurrent usage.
+     *
+     * **Propagation note:** Changes made within a transaction (whether top-level or nested) are always propagated to the
+     * parent context, unless the parent context is a global one. If you want to avoid that, fork the EntityManager first
+     * and then call this method on the fork.
+     *
+     * **Example:**
+     * ```ts
+     * await em.transactional(async (em) => {
+     *   const author = new Author('Jon');
+     *   em.persist(author);
+     *   // flush is called automatically at the end of the callback
+     * });
+     * ```
      */
     transactional<T>(cb: (em: this) => T | Promise<T>, options?: TransactionOptions): Promise<T>;
     /**
@@ -562,6 +585,8 @@ export interface MergeOptions {
     schema?: string;
     disableContextResolution?: boolean;
     keepIdentity?: boolean;
+    validate?: boolean;
+    cascade?: boolean; /** @default true */
 }
 export interface ForkOptions {
     /** do we want a clear identity map? defaults to true */

package/EntityManager.js

@@ -506,18 +506,24 @@ export class EntityManager {
             flushMode: FlushMode.COMMIT,
         });
         const em = this.getContext();
-        if (reloaded) {
-            for (const e of fork.unitOfWork.getIdentityMap()) {
-                const ref = em.getReference(e.constructor.name, helper(e).getPrimaryKey());
-                const data = this.comparator.prepareEntity(e);
-                em.config.getHydrator(this.metadata).hydrate(ref, helper(ref).__meta, helper(e).serialize({ ignoreSerializers: true, includeHidden: true }), em.entityFactory, 'full', false, true);
-                helper(ref).__originalEntityData = data;
-            }
-        }
-        else {
+        if (!reloaded) {
             em.unitOfWork.unsetIdentity(entity);
+            return null;
         }
-        return reloaded ? entity : reloaded;
+        let found = false;
+        for (const e of fork.unitOfWork.getIdentityMap()) {
+            const ref = em.getReference(e.constructor.name, helper(e).getPrimaryKey());
+            const data = helper(e).serialize({ ignoreSerializers: true, includeHidden: true });
+            em.config.getHydrator(this.metadata).hydrate(ref, helper(ref).__meta, data, em.entityFactory, 'full', false, true);
+            helper(ref).__originalEntityData = this.comparator.prepareEntity(e);
+            found ||= ref === entity;
+        }
+        if (!found) {
+            const data = helper(reloaded).serialize({ ignoreSerializers: true, includeHidden: true });
+            em.config.getHydrator(this.metadata).hydrate(entity, helper(entity).__meta, data, em.entityFactory, 'full', false, true);
+            helper(entity).__originalEntityData = this.comparator.prepareEntity(reloaded);
+        }
+        return entity;
     }
     /**
      * Finds first entity matching your `where` query.
@@ -979,6 +985,29 @@ export class EntityManager {
     }
     /**
      * Runs your callback wrapped inside a database transaction.
+     *
+     * If a transaction is already active, a new savepoint (nested transaction) will be created by default. This behavior
+     * can be controlled via the `propagation` option. Use the provided EntityManager instance for all operations that
+     * should be part of the transaction. You can safely use a global EntityManager instance from a DI container, as this
+     * method automatically creates an async context for the transaction.
+     *
+     * **Concurrency note:** When running multiple transactions concurrently (e.g. in parallel requests or jobs), use the
+     * `clear: true` option. This ensures the callback runs in a clear fork of the EntityManager, providing full isolation
+     * between concurrent transactional handlers. Using `clear: true` is an alternative to forking explicitly and calling
+     * the method on the new fork – it already provides the necessary isolation for safe concurrent usage.
+     *
+     * **Propagation note:** Changes made within a transaction (whether top-level or nested) are always propagated to the
+     * parent context, unless the parent context is a global one. If you want to avoid that, fork the EntityManager first
+     * and then call this method on the fork.
+     *
+     * **Example:**
+     * ```ts
+     * await em.transactional(async (em) => {
+     *   const author = new Author('Jon');
+     *   em.persist(author);
+     *   // flush is called automatically at the end of the callback
+     * });
+     * ```
      */
     async transactional(cb, options = {}) {
         const em = this.getContext(false);
@@ -1171,8 +1200,12 @@ export class EntityManager {
         }
         const em = options.disableContextResolution ? this : this.getContext();
         options.schema ??= em._schema;
+        options.validate ??= true;
+        options.cascade ??= true;
         entityName = Utils.className(entityName);
-        em.validator.validatePrimaryKey(data, em.metadata.get(entityName));
+        if (options.validate) {
+            em.validator.validatePrimaryKey(data, em.metadata.get(entityName));
+        }
         let entity = em.unitOfWork.tryGetById(entityName, data, options.schema, false);
         if (entity && helper(entity).__managed && helper(entity).__initialized && !options.refresh) {
             return entity;
@@ -1181,12 +1214,16 @@ export class EntityManager {
         const childMeta = em.metadata.getByDiscriminatorColumn(meta, data);
         const dataIsEntity = Utils.isEntity(data);
         if (options.keepIdentity && entity && dataIsEntity && entity !== data) {
-            em.entityFactory.mergeData(meta, entity, helper(data).__originalEntityData, { initialized: true, merge: true, ...options });
+            helper(entity).__data = helper(data).__data;
+            helper(entity).__originalEntityData = helper(data).__originalEntityData;
             return entity;
         }
         entity = dataIsEntity ? data : em.entityFactory.create(entityName, data, { merge: true, ...options });
-        em.validator.validate(entity, data, childMeta ?? meta);
-        em.unitOfWork.merge(entity);
+        if (options.validate) {
+            em.validator.validate(entity, data, childMeta ?? meta);
+        }
+        const visited = options.cascade ? undefined : new Set([entity]);
+        em.unitOfWork.merge(entity, visited);
         return entity;
     }
     /**

package/MikroORM.js

@@ -35,7 +35,6 @@ export class MikroORM {
             }
         }
         options = Utils.mergeConfig(options, env);
-        ConfigurationLoader.commonJSCompat(options);
         if ('DRIVER' in this && !options.driver) {
             options.driver = this.DRIVER;
         }

package/cache/FileCacheAdapter.d.ts

@@ -3,12 +3,13 @@ export declare class FileCacheAdapter implements SyncCacheAdapter {
     private readonly options;
     private readonly baseDir;
     private readonly pretty;
+    private readonly hashAlgorithm;
     private readonly VERSION;
     private cache;
     constructor(options: {
         cacheDir: string;
         combined?: boolean | string;
-    }, baseDir: string, pretty?: boolean);
+    }, baseDir: string, pretty?: boolean, hashAlgorithm?: 'md5' | 'sha256');
     /**
      * @inheritDoc
      */

package/cache/FileCacheAdapter.js

@@ -5,12 +5,14 @@ export class FileCacheAdapter {
     options;
     baseDir;
     pretty;
+    hashAlgorithm;
     VERSION = Utils.getORMVersion();
     cache = {};
-    constructor(options, baseDir, pretty = false) {
+    constructor(options, baseDir, pretty = false, hashAlgorithm = 'md5') {
         this.options = options;
         this.baseDir = baseDir;
         this.pretty = pretty;
+        this.hashAlgorithm = hashAlgorithm;
     }
     /**
      * @inheritDoc
@@ -77,6 +79,6 @@ export class FileCacheAdapter {
             return null;
         }
         const contents = readFileSync(origin);
-        return Utils.hash(contents.toString() + this.VERSION);
+        return Utils.hash(contents.toString() + this.VERSION, undefined, this.hashAlgorithm);
     }
 }

package/entity/EntityLoader.js

@@ -466,23 +466,20 @@ export class EntityLoader {
     }
     getChildReferences(entities, prop, options, ref) {
         const filtered = this.filterCollections(entities, prop.name, options, ref);
-        const children = [];
         if (prop.kind === ReferenceKind.ONE_TO_MANY) {
-            children.push(...filtered.map(e => e[prop.name].owner));
+            return filtered.map(e => e[prop.name].owner);
         }
-        else if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
-            children.push(...filtered.reduce((a, b) => {
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner) {
+            return filtered.reduce((a, b) => {
                 a.push(...b[prop.name].getItems());
                 return a;
-            }, []));
-        }
-        else if (prop.kind === ReferenceKind.MANY_TO_MANY) { // inverse side
-            children.push(...filtered);
+            }, []);
         }
-        else { // MANY_TO_ONE or ONE_TO_ONE
-            children.push(...this.filterReferences(entities, prop.name, options, ref));
+        if (prop.kind === ReferenceKind.MANY_TO_MANY) { // inverse side
+            return filtered;
         }
-        return children;
+        // MANY_TO_ONE or ONE_TO_ONE
+        return this.filterReferences(entities, prop.name, options, ref);
     }
     filterCollections(entities, field, options, ref) {
         if (options.refresh) {

package/entity/EntityValidator.js

@@ -11,7 +11,7 @@ export class EntityValidator {
     }
     validate(entity, payload, meta) {
         meta.props.forEach(prop => {
-            if (prop.inherited) {
+            if (prop.inherited || (prop.persist === false && prop.userDefined !== false)) {
                 return;
             }
             if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {

package/entity/defineEntity.d.ts

@@ -73,7 +73,7 @@ export declare class PropertyOptionsBuilder<Value> {
     /**
      * Explicitly specify the auto increment of the primary key.
      */
-    autoincrement(autoincrement?: boolean): PropertyOptionsBuilder<Value>;
+    autoincrement<T extends boolean = true>(autoincrement?: T): PropertyOptionsBuilder<T extends true ? Opt<Value> : Value>;
     /**
      * Add the property to the `returning` statement.
      */
@@ -443,6 +443,9 @@ export declare class OneToOneOptionsBuilder<TargetValue extends object> extends
     deferMode(deferMode: DeferMode | `${DeferMode}`): OneToOneOptionsBuilder<TargetValue>;
 }
 declare const propertyBuilders: {
+    bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => PropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}>;
+    array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => PropertyOptionsBuilder<T[]>;
+    decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => PropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>>;
     json: <T>() => PropertyOptionsBuilder<T>;
     formula: <T>(formula: string | ((alias: string) => string)) => PropertyOptionsBuilder<T>;
     type: <T extends PropertyValueType>(type: T) => PropertyOptionsBuilder<InferPropertyValueType<T>>;
@@ -455,10 +458,8 @@ declare const propertyBuilders: {
     date: () => PropertyOptionsBuilder<string>;
     time: () => PropertyOptionsBuilder<any>;
     datetime: () => PropertyOptionsBuilder<Date>;
-    bigint: () => PropertyOptionsBuilder<NonNullable<string | number | bigint | null | undefined>>;
     blob: () => PropertyOptionsBuilder<NonNullable<Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike> | null>>;
     uint8array: () => PropertyOptionsBuilder<Uint8Array<ArrayBufferLike>>;
-    array: () => PropertyOptionsBuilder<unknown[]>;
     enumArray: () => PropertyOptionsBuilder<(string | number)[]>;
     integer: () => PropertyOptionsBuilder<number>;
     smallint: () => PropertyOptionsBuilder<number>;
@@ -467,7 +468,6 @@ declare const propertyBuilders: {
     float: () => PropertyOptionsBuilder<number>;
     double: () => PropertyOptionsBuilder<NonNullable<string | number>>;
     boolean: () => PropertyOptionsBuilder<NonNullable<boolean | null | undefined>>;
-    decimal: () => PropertyOptionsBuilder<NonNullable<string | number>>;
     character: () => PropertyOptionsBuilder<string>;
     string: () => PropertyOptionsBuilder<string>;
     uuid: () => PropertyOptionsBuilder<string>;
@@ -481,6 +481,9 @@ export declare function defineEntity<Properties extends Record<string, any>>(met
 }): EntitySchema<InferEntityFromProperties<Properties>, never>;
 export declare namespace defineEntity {
     var properties: {
+        bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => PropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}>;
+        array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => PropertyOptionsBuilder<T[]>;
+        decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => PropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>>;
         json: <T>() => PropertyOptionsBuilder<T>;
         formula: <T>(formula: string | ((alias: string) => string)) => PropertyOptionsBuilder<T>;
         type: <T extends PropertyValueType>(type: T) => PropertyOptionsBuilder<InferPropertyValueType<T>>;
@@ -493,10 +496,8 @@ export declare namespace defineEntity {
         date: () => PropertyOptionsBuilder<string>;
         time: () => PropertyOptionsBuilder<any>;
         datetime: () => PropertyOptionsBuilder<Date>;
-        bigint: () => PropertyOptionsBuilder<NonNullable<string | number | bigint | null | undefined>>;
         blob: () => PropertyOptionsBuilder<NonNullable<Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike> | null>>;
         uint8array: () => PropertyOptionsBuilder<Uint8Array<ArrayBufferLike>>;
-        array: () => PropertyOptionsBuilder<unknown[]>;
         enumArray: () => PropertyOptionsBuilder<(string | number)[]>;
         integer: () => PropertyOptionsBuilder<number>;
         smallint: () => PropertyOptionsBuilder<number>;
@@ -505,7 +506,6 @@ export declare namespace defineEntity {
         float: () => PropertyOptionsBuilder<number>;
         double: () => PropertyOptionsBuilder<NonNullable<string | number>>;
         boolean: () => PropertyOptionsBuilder<NonNullable<boolean | null | undefined>>;
-        decimal: () => PropertyOptionsBuilder<NonNullable<string | number>>;
         character: () => PropertyOptionsBuilder<string>;
         string: () => PropertyOptionsBuilder<string>;
         uuid: () => PropertyOptionsBuilder<string>;

package/entity/defineEntity.js

@@ -622,6 +622,9 @@ function createPropertyBuilders(options) {
 }
 const propertyBuilders = {
     ...createPropertyBuilders(types),
+    bigint: (mode) => new PropertyOptionsBuilder({ type: new types.bigint(mode) }),
+    array: (toJsValue = i => i, toDbValue = i => i) => new PropertyOptionsBuilder({ type: new types.array(toJsValue, toDbValue) }),
+    decimal: (mode) => new PropertyOptionsBuilder({ type: new types.decimal(mode) }),
     json: () => new PropertyOptionsBuilder({ type: types.json }),
     formula: (formula) => new PropertyOptionsBuilder({ formula }),
     type: (type) => new PropertyOptionsBuilder({ type }),

package/hydration/ObjectHydrator.js

@@ -71,7 +71,14 @@ export class ObjectHydrator extends Hydrator {
                 ret.push(`  const oldValue_${idx} = entity${entityKey};`);
             }
             ret.push(`  if (data${dataKey} === null) {`);
-            ret.push(`    entity${entityKey} = ${nullVal};`);
+            if (prop.ref) {
+                ret.push(`    entity${entityKey} = new ScalarReference();`);
+                ret.push(`    entity${entityKey}.bind(entity, '${prop.name}');`);
+                ret.push(`    entity${entityKey}.set(${nullVal});`);
+            }
+            else {
+                ret.push(`    entity${entityKey} = ${nullVal};`);
+            }
             ret.push(`  } else if (typeof data${dataKey} !== 'undefined') {`);
             if (prop.customType) {
                 registerCustomType(prop, convertorKey, 'convertToJSValue', context);

package/index.js

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { PrimaryKeyProp, EntityMetadata, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Config, } from './typings.js';
+export { PrimaryKeyProp, EntityMetadata, EntityRepositoryType, OptionalProps, EagerProps, HiddenProps, Opt, Hidden, Config, DefineConfig, RequiredNullable, } from './typings.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/MetadataDiscovery.js

@@ -1152,7 +1152,7 @@ export class MetadataDiscovery {
         if (prop.fieldNames?.length === 1 && !prop.customType) {
             [BigIntType, DoubleType, DecimalType, IntervalType, DateType]
                 .filter(type => mappedType instanceof type)
-                .forEach(type => prop.customType = new type());
+                .forEach((type) => prop.customType = new type());
         }
         if (prop.customType && !prop.columnTypes) {
             const mappedType = this.getMappedType({ columnTypes: [prop.customType.getColumnType(prop, this.platform)] });

package/metadata/MetadataStorage.js

@@ -10,7 +10,7 @@ export class MetadataStorage {
         this.metadata = Utils.copy(metadata, false);
     }
     static getMetadata(entity, path) {
-        const key = entity && path ? entity + '-' + Utils.hash(path) : null;
+        const key = entity && path ? entity + '-' + Utils.hash(path, undefined, 'sha256') : null;
         if (key && !MetadataStorage.metadata[key]) {
             MetadataStorage.metadata[key] = new EntityMetadata({ className: entity, path });
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.27",
+  "version": "7.0.0-dev.29",
   "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,9 +52,9 @@
   },
   "dependencies": {
     "dataloader": "2.2.3",
-    "dotenv": "17.2.2",
+    "dotenv": "17.2.3",
     "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.27",
+    "mikro-orm": "7.0.0-dev.29",
     "reflect-metadata": "0.2.2",
     "tinyglobby": "0.2.13"
   }

package/types/BigIntType.d.ts

@@ -5,13 +5,15 @@ import type { EntityProperty } from '../typings.js';
  * This type will automatically convert string values returned from the database to native JS bigints (default)
  * or numbers (safe only for values up to `Number.MAX_SAFE_INTEGER`), or strings, depending on the `mode`.
  */
-export declare class BigIntType extends Type<string | bigint | number | null | undefined, string | null | undefined> {
-    mode?: "bigint" | "number" | "string" | undefined;
-    constructor(mode?: "bigint" | "number" | "string" | undefined);
-    convertToDatabaseValue(value: string | bigint | null | undefined): string | null | undefined;
-    convertToJSValue(value: string | bigint | null | undefined): bigint | number | string | null | undefined;
-    toJSON(value: string | bigint | null | undefined): string | bigint | null | undefined;
+export declare class BigIntType<Mode extends 'bigint' | 'number' | 'string' = 'bigint'> extends Type<JSTypeByMode<Mode> | null | undefined, string | null | undefined> {
+    mode?: Mode | undefined;
+    constructor(mode?: Mode | undefined);
+    convertToDatabaseValue(value: JSTypeByMode<Mode> | null | undefined): string | null | undefined;
+    convertToJSValue(value: string | bigint | null | undefined): JSTypeByMode<Mode> | null | undefined;
+    toJSON(value: JSTypeByMode<Mode> | null | undefined): JSTypeByMode<Mode> | null | undefined;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
     compareValues(a: string, b: string): boolean;
 }
+type JSTypeByMode<Mode extends 'bigint' | 'number' | 'string'> = Mode extends 'bigint' ? bigint : Mode extends 'number' ? number : string;
+export {};

package/types/DecimalType.d.ts

@@ -4,12 +4,14 @@ import type { EntityProperty } from '../typings.js';
 /**
  * Type that maps an SQL DECIMAL to a JS string or number.
  */
-export declare class DecimalType extends Type<string | number, string> {
-    mode?: "number" | "string" | undefined;
-    constructor(mode?: "number" | "string" | undefined);
-    convertToJSValue(value: string): number | string;
+export declare class DecimalType<Mode extends 'number' | 'string' = 'string'> extends Type<JSTypeByMode<Mode>, string> {
+    mode?: Mode | undefined;
+    constructor(mode?: Mode | undefined);
+    convertToJSValue(value: string): JSTypeByMode<Mode>;
     compareValues(a: string, b: string): boolean;
     private format;
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
 }
+type JSTypeByMode<Mode extends 'number' | 'string'> = Mode extends 'number' ? number : string;
+export {};

package/typings.d.ts

@@ -52,22 +52,34 @@ export declare const OptionalProps: unique symbol;
 export declare const EagerProps: unique symbol;
 export declare const HiddenProps: unique symbol;
 export declare const Config: unique symbol;
-declare const __optional: unique symbol;
-declare const __requiredNullable: unique symbol;
-declare const __hidden: unique symbol;
-declare const __config: unique symbol;
-export type Opt<T = unknown> = T & {
-    [__optional]?: 1;
-};
-export type RequiredNullable<T = never> = (T & {
-    [__requiredNullable]?: 1;
-}) | null;
-export type Hidden<T = unknown> = T & {
-    [__hidden]?: 1;
-};
-export type DefineConfig<T extends TypeConfig> = T & {
-    [__config]?: 1;
-};
+export type Opt<T = unknown> = T & Opt.Brand;
+export declare namespace Opt {
+    const __optional: unique symbol;
+    interface Brand {
+        [__optional]?: 1;
+    }
+}
+export type RequiredNullable<T = never> = (T & RequiredNullable.Brand) | null;
+export declare namespace RequiredNullable {
+    const __requiredNullable: unique symbol;
+    interface Brand {
+        [__requiredNullable]?: 1;
+    }
+}
+export type Hidden<T = unknown> = T & Hidden.Brand;
+export declare namespace Hidden {
+    const __hidden: unique symbol;
+    interface Brand {
+        [__hidden]?: 1;
+    }
+}
+export type DefineConfig<T extends TypeConfig> = T & DefineConfig.Brand;
+export declare namespace DefineConfig {
+    const __config: unique symbol;
+    interface Brand {
+        [__config]?: 1;
+    }
+}
 export type CleanTypeConfig<T> = Compute<Pick<T, Extract<keyof T, keyof TypeConfig>>>;
 export interface TypeConfig {
     forceObject?: boolean;
@@ -82,9 +94,9 @@ export type Primary<T> = IsAny<T> extends true ? any : T extends {
 } ? (PK extends keyof T ? ReadonlyPrimary<UnwrapPrimary<T[PK]>> : (PK extends (keyof T)[] ? ReadonlyPrimary<PrimaryPropToType<T, PK>> : PK)) : T extends {
     _id?: infer PK;
 } ? ReadonlyPrimary<PK> | string : T extends {
-    uuid?: infer PK;
-} ? ReadonlyPrimary<PK> : T extends {
     id?: infer PK;
+} ? ReadonlyPrimary<PK> : T extends {
+    uuid?: infer PK;
 } ? ReadonlyPrimary<PK> : T;
 /** @internal */
 export type PrimaryProperty<T> = T extends {
@@ -94,10 +106,10 @@ export type PrimaryProperty<T> = T extends {
 } ? (T extends {
     id?: any;
 } ? 'id' | '_id' : '_id') : T extends {
-    uuid?: any;
-} ? 'uuid' : T extends {
     id?: any;
-} ? 'id' : never;
+} ? 'id' : T extends {
+    uuid?: any;
+} ? 'uuid' : never;
 export type IPrimaryKeyValue = number | string | bigint | Date | {
     toHexString(): string;
 };
@@ -229,9 +241,7 @@ export type EntityDataProp<T, C extends boolean> = T extends Date ? string | Dat
     __runtime?: infer Runtime;
     __raw?: infer Raw;
 } ? (C extends true ? Raw : Runtime) : T extends Reference<infer U> ? EntityDataNested<U, C> : T extends ScalarReference<infer U> ? EntityDataProp<U, C> : T extends Collection<infer U, any> ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
-export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : Exclude<T, null> extends {
-    [__requiredNullable]?: 1;
-} ? T | null : T extends Scalar ? T : T extends {
+export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : Exclude<T, null> extends RequiredNullable.Brand ? T | null : T extends Scalar ? T : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
 } ? (C extends true ? Raw : Runtime) : T extends Reference<infer U> ? RequiredEntityDataNested<U, O, C> : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends Collection<infer U, any> ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
@@ -247,9 +257,7 @@ type NullableKeys<T, V = null> = {
     [K in keyof T]: V extends T[K] ? K : never;
 }[keyof T];
 type RequiredNullableKeys<T> = {
-    [K in keyof T]: Exclude<T[K], null> extends {
-        [__requiredNullable]?: 1;
-    } ? K : never;
+    [K in keyof T]: Exclude<T[K], null> extends RequiredNullable.Brand ? K : never;
 }[keyof T];
 type ProbablyOptionalProps<T> = PrimaryProperty<T> | ExplicitlyOptionalProps<T> | Exclude<NonNullable<NullableKeys<T, null | undefined>>, RequiredNullableKeys<T>>;
 type IsOptional<T, K extends keyof T, I> = T[K] extends Collection<any, any> ? true : ExtractType<T[K]> extends I ? true : K extends ProbablyOptionalProps<T> ? true : false;

package/utils/Configuration.d.ts

@@ -82,6 +82,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
         ensureDatabase: true;
         ensureIndexes: false;
         batchSize: number;
+        hashAlgorithm: "md5";
         debug: false;
         ignoreDeprecations: false;
         verbose: false;
@@ -104,6 +105,8 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
             disableForeignKeys: false;
             createForeignKeyConstraints: true;
             ignoreSchema: never[];
+            skipTables: never[];
+            skipColumns: {};
         };
         embeddables: {
             prefixMode: "relative";
@@ -143,7 +146,6 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
             fileName: (className: string) => string;
         };
         preferReadReplicas: true;
-        dynamicImportProvider: (id: string) => Promise<any>;
     };
     private readonly options;
     private readonly logger;
@@ -380,6 +382,8 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
         disableForeignKeys?: boolean;
         createForeignKeyConstraints?: boolean;
         ignoreSchema?: string[];
+        skipTables?: (string | RegExp)[];
+        skipColumns?: Dictionary<(string | RegExp)[]>;
         managementDbName?: string;
     };
     embeddables: {
@@ -408,6 +412,6 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     };
     seeder: SeederOptions;
     preferReadReplicas: boolean;
-    dynamicImportProvider: (id: string) => Promise<unknown>;
+    hashAlgorithm: 'md5' | 'sha256';
 }
 export type Options<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager = D[typeof EntityManagerType] & EntityManager> = Pick<MikroORMOptions<D, EM>, Exclude<keyof MikroORMOptions<D, EM>, keyof typeof Configuration.DEFAULTS>> & Partial<MikroORMOptions<D, EM>>;

package/utils/Configuration.js

@@ -72,6 +72,7 @@ export class Configuration {
         ensureDatabase: true,
         ensureIndexes: false,
         batchSize: 300,
+        hashAlgorithm: 'md5',
         debug: false,
         ignoreDeprecations: false,
         verbose: false,
@@ -94,6 +95,8 @@ export class Configuration {
             disableForeignKeys: false,
             createForeignKeyConstraints: true,
             ignoreSchema: [],
+            skipTables: [],
+            skipColumns: {},
         },
         embeddables: {
             prefixMode: 'relative',
@@ -131,7 +134,6 @@ export class Configuration {
             fileName: (className) => className,
         },
         preferReadReplicas: true,
-        dynamicImportProvider: /* v8 ignore next */ (id) => import(id),
     };
     options;
     logger;
@@ -140,9 +142,6 @@ export class Configuration {
     cache = new Map();
     extensions = new Map();
     constructor(options, validate = true) {
-        if (options.dynamicImportProvider) {
-            Utils.setDynamicImportProvider(options.dynamicImportProvider);
-        }
         this.options = Utils.mergeConfig({}, Configuration.DEFAULTS, options);
         this.options.baseDir = Utils.absolutePath(this.options.baseDir);
         this.options.preferTs ??= options.preferTs;
@@ -269,7 +268,7 @@ export class Configuration {
      * Gets instance of metadata CacheAdapter. (cached)
      */
     getMetadataCacheAdapter() {
-        return this.getCachedService(this.options.metadataCache.adapter, this.options.metadataCache.options, this.options.baseDir, this.options.metadataCache.pretty);
+        return this.getCachedService(this.options.metadataCache.adapter, this.options.metadataCache.options, this.options.baseDir, this.options.metadataCache.pretty, this.options.hashAlgorithm);
     }
     /**
      * Gets instance of CacheAdapter for result cache. (cached)

package/utils/ConfigurationLoader.d.ts

@@ -40,8 +40,6 @@ export declare class ConfigurationLoader {
     static loadEnvironmentVars<D extends IDatabaseDriver>(): Promise<Partial<Options<D>>>;
     static loadEnvironmentVarsSync<D extends IDatabaseDriver>(): Partial<Options<D>>;
     static getORMPackages(): Set<string>;
-    /** @internal */
-    static commonJSCompat(options: Partial<Options>): void;
     static getORMPackageVersion(name: string): string | undefined;
     static checkPackageVersion(): string;
 }

package/utils/ConfigurationLoader.js

@@ -1,7 +1,5 @@
 import dotenv from 'dotenv';
 import { realpathSync } from 'node:fs';
-import { platform } from 'node:os';
-import { fileURLToPath } from 'node:url';
 import { colors } from '../logging/colors.js';
 import { Configuration } from './Configuration.js';
 import { Utils } from './Utils.js';
@@ -12,7 +10,6 @@ export class ConfigurationLoader {
     static async getConfiguration(contextName = 'default', paths = ConfigurationLoader.getConfigPaths(), options = {}) {
         // Backwards compatibility layer
         if (typeof contextName === 'boolean' || !Array.isArray(paths)) {
-            this.commonJSCompat(options);
             this.registerDotenv(options);
             const configPathFromArg = ConfigurationLoader.configPathsFromArg();
             const configPaths = configPathFromArg ?? (Array.isArray(paths) ? paths : ConfigurationLoader.getConfigPaths());
@@ -300,25 +297,6 @@ export class ConfigurationLoader {
             ...Object.keys(pkg.devDependencies ?? {}),
         ]);
     }
-    /** @internal */
-    static commonJSCompat(options) {
-        if (this.isESM()) {
-            return;
-        }
-        /* v8 ignore next 11 */
-        options.dynamicImportProvider ??= id => {
-            if (platform() === 'win32') {
-                try {
-                    id = fileURLToPath(id);
-                }
-                catch {
-                    // ignore
-                }
-            }
-            return Utils.requireFrom(id);
-        };
-        Utils.setDynamicImportProvider(options.dynamicImportProvider);
-    }
     static getORMPackageVersion(name) {
         try {
             const pkg = Utils.requireFrom(`${name}/package.json`);

package/utils/EntityComparator.js

@@ -562,7 +562,9 @@ export class EntityComparator {
         return comparator;
     }
     getGenericComparator(prop, cond) {
-        return `  if (current${prop} == null && last${prop} == null) {\n\n` +
+        return `  if (current${prop} === null && last${prop} === undefined) {\n` +
+            `    diff${prop} = current${prop};\n` +
+            `  } else if (current${prop} == null && last${prop} == null) {\n\n` +
             `  } else if ((current${prop} != null && last${prop} == null) || (current${prop} == null && last${prop} != null)) {\n` +
             `    diff${prop} = current${prop};\n` +
             `  } else if (${cond}) {\n` +

package/utils/TransactionManager.js

@@ -3,6 +3,7 @@ import { TransactionEventBroadcaster } from '../events/TransactionEventBroadcast
 import { TransactionContext } from '../utils/TransactionContext.js';
 import { ChangeSetType } from '../unit-of-work/ChangeSet.js';
 import { TransactionStateError } from '../errors.js';
+import { helper } from '../entity/wrap.js';
 /**
  * Manages transaction lifecycle and propagation for EntityManager.
  */
@@ -149,8 +150,28 @@ export class TransactionManager {
      * Merges entities from fork to parent EntityManager.
      */
     mergeEntitiesToParent(fork, parent) {
+        const parentUoW = parent.getUnitOfWork(false);
+        // perf: if parent is empty, we can just move all entities from the fork to skip the `em.merge` overhead
+        if (parentUoW.getIdentityMap().keys().length === 0) {
+            for (const entity of fork.getUnitOfWork(false).getIdentityMap()) {
+                parentUoW.getIdentityMap().store(entity);
+                helper(entity).__em = parent;
+            }
+            return;
+        }
         for (const entity of fork.getUnitOfWork(false).getIdentityMap()) {
-            parent.merge(entity, { disableContextResolution: true, keepIdentity: true, refresh: true });
+            const wrapped = helper(entity);
+            const meta = wrapped.__meta;
+            // eslint-disable-next-line dot-notation
+            const parentEntity = parentUoW.getById(meta.className, wrapped.getPrimaryKey(), parent['_schema'], true);
+            if (parentEntity && parentEntity !== entity) {
+                const parentWrapped = helper(parentEntity);
+                parentWrapped.__data = helper(entity).__data;
+                parentWrapped.__originalEntityData = helper(entity).__originalEntityData;
+            }
+            else {
+                parentUoW.merge(entity, new Set([entity]));
+            }
         }
     }
     /**

package/utils/Utils.d.ts

@@ -15,7 +15,6 @@ export declare function equals(a: any, b: any): boolean;
 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
      */
@@ -206,7 +205,7 @@ export declare class Utils {
      * 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 hash(data: string, length?: number, algorithm?: 'md5' | 'sha256'): string;
     static runIfNotEmpty(clause: () => any, data: any): void;
     static defaultValue<T extends Dictionary>(prop: T, option: keyof T, defaultValue: any): void;
     static findDuplicates<T>(items: T[]): T[];
@@ -237,7 +236,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 pathExistsSync(path: string): boolean;
     static readJSONSync(path: string): Dictionary;

package/utils/Utils.js

@@ -1,7 +1,6 @@
 import { createRequire } from 'node:module';
 import { glob, isDynamicPattern } from 'tinyglobby';
 import { extname, isAbsolute, join, normalize, relative, resolve } from 'node:path';
-import { platform } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
@@ -132,8 +131,6 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    /* v8 ignore next */
-    static dynamicImportProvider = (id) => import(id);
     /**
      * Checks if the argument is not undefined
      */
@@ -789,8 +786,9 @@ export class Utils {
         }
         return Utils.normalizePath(path);
     }
-    static hash(data, length) {
-        const hash = createHash('md5').update(data).digest('hex');
+    static hash(data, length, algorithm) {
+        const hashAlgorithm = algorithm || 'sha256';
+        const hash = createHash(hashAlgorithm).update(data).digest('hex');
         if (length) {
             return hash.substring(0, length);
         }
@@ -907,21 +905,9 @@ export class Utils {
         return parts.join('/');
     }
     static async dynamicImport(id) {
-        /* v8 ignore next 7 */
-        if (platform() === 'win32') {
-            try {
-                id = pathToFileURL(id).toString();
-            }
-            catch {
-                // ignore
-            }
-        }
         /* v8 ignore next */
-        return this.dynamicImportProvider(id);
-    }
-    /* v8 ignore next 3 */
-    static setDynamicImportProvider(provider) {
-        this.dynamicImportProvider = provider;
+        const specifier = id.startsWith('file://') ? id : pathToFileURL(id).href;
+        return import(specifier);
     }
     static ensureDir(path) {
         if (!existsSync(path)) {