@mikro-orm/core 6.5.6-dev.1 → 6.5.6-dev.11

package/EntityManager.d.ts

@@ -264,6 +264,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>;
     /**

package/EntityManager.js

@@ -971,6 +971,29 @@ 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);

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

@@ -11,12 +11,14 @@ class FileCacheAdapter {
     options;
     baseDir;
     pretty;
+    hashAlgorithm;
     VERSION = Utils_1.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
@@ -84,7 +86,7 @@ class FileCacheAdapter {
             return null;
         }
         const contents = (0, fs_extra_1.readFileSync)(origin);
-        return Utils_1.Utils.hash(contents.toString() + this.VERSION);
+        return Utils_1.Utils.hash(contents.toString() + this.VERSION, undefined, this.hashAlgorithm);
     }
 }
 exports.FileCacheAdapter = FileCacheAdapter;

package/entity/EntityLoader.js

@@ -465,23 +465,20 @@ class EntityLoader {
     }
     getChildReferences(entities, prop, options, ref) {
         const filtered = this.filterCollections(entities, prop.name, options, ref);
-        const children = [];
         if (prop.kind === enums_1.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 === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner) {
-            children.push(...filtered.reduce((a, b) => {
+        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner) {
+            return filtered.reduce((a, b) => {
                 a.push(...b[prop.name].getItems());
                 return a;
-            }, []));
-        }
-        else if (prop.kind === enums_1.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 === enums_1.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/defineEntity.d.ts

@@ -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

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

package/metadata/MetadataDiscovery.js

@@ -1136,7 +1136,7 @@ class MetadataDiscovery {
         if (prop.fieldNames?.length === 1 && !prop.customType) {
             [types_1.BigIntType, types_1.DoubleType, types_1.DecimalType, types_1.IntervalType, types_1.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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.5.6-dev.1",
+  "version": "6.5.6-dev.11",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.2",
     "globby": "11.1.0",
-    "mikro-orm": "6.5.6-dev.1",
+    "mikro-orm": "6.5.6-dev.11",
     "reflect-metadata": "0.2.2"
   }
 }

package/types/BigIntType.d.ts

@@ -5,13 +5,15 @@ import type { EntityProperty } from '../typings';
  * 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';
 /**
  * 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/utils/Configuration.d.ts

@@ -81,6 +81,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
         ensureDatabase: true;
         ensureIndexes: false;
         batchSize: number;
+        hashAlgorithm: "md5";
         debug: false;
         ignoreDeprecations: false;
         verbose: false;
@@ -103,6 +104,8 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
             disableForeignKeys: false;
             createForeignKeyConstraints: true;
             ignoreSchema: never[];
+            skipTables: never[];
+            skipColumns: {};
         };
         embeddables: {
             prefixMode: "absolute";
@@ -395,6 +398,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: {
@@ -423,6 +428,7 @@ export interface MikroORMOptions<D extends IDatabaseDriver = IDatabaseDriver, EM
     };
     seeder: SeederOptions;
     preferReadReplicas: boolean;
+    hashAlgorithm: 'md5' | 'sha256';
     dynamicImportProvider: (id: string) => Promise<unknown>;
 }
 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

@@ -75,6 +75,7 @@ class Configuration {
         ensureDatabase: true,
         ensureIndexes: false,
         batchSize: 300,
+        hashAlgorithm: 'md5',
         debug: false,
         ignoreDeprecations: false,
         verbose: false,
@@ -97,6 +98,8 @@ class Configuration {
             disableForeignKeys: false,
             createForeignKeyConstraints: true,
             ignoreSchema: [],
+            skipTables: [],
+            skipColumns: {},
         },
         embeddables: {
             prefixMode: 'absolute',
@@ -266,7 +269,7 @@ 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/Utils.d.ts

@@ -204,7 +204,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[];

package/utils/Utils.js

@@ -805,8 +805,9 @@ class Utils {
         }
         return Utils.normalizePath(path);
     }
-    static hash(data, length) {
-        const hash = (0, node_crypto_1.createHash)('md5').update(data).digest('hex');
+    static hash(data, length, algorithm) {
+        const hashAlgorithm = algorithm || 'sha256';
+        const hash = (0, node_crypto_1.createHash)(hashAlgorithm).update(data).digest('hex');
         if (length) {
             return hash.substring(0, length);
         }