@mikro-orm/core 6.4.17-dev.9 → 6.4.17-dev.91

package/entity/index.js

@@ -27,3 +27,5 @@ __exportStar(require("./Reference"), exports);
 __exportStar(require("./BaseEntity"), exports);
 __exportStar(require("./WrappedEntity"), exports);
 __exportStar(require("./wrap"), exports);
+__exportStar(require("./defineEntity"), exports);
+__exportStar(require("./utils"), exports);

package/entity/utils.d.ts

@@ -1,5 +1,12 @@
 import type { EntityMetadata, PopulateOptions } from '../typings';
+import { LoadStrategy, ReferenceKind } from '../enums';
 /**
  * @internal
  */
 export declare function expandDotPaths<Entity>(meta: EntityMetadata<Entity>, populate?: readonly (string | PopulateOptions<Entity>)[], normalized?: boolean): PopulateOptions<Entity>[];
+/**
+ * Returns the loading strategy based on the provided hint.
+ * If `BALANCED` strategy is used, it will return JOINED if the property is a to-one relation.
+ * @internal
+ */
+export declare function getLoadingStrategy(strategy: LoadStrategy | `${LoadStrategy}`, kind: ReferenceKind): LoadStrategy.SELECT_IN | LoadStrategy.JOINED;

package/entity/utils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expandDotPaths = expandDotPaths;
+exports.getLoadingStrategy = getLoadingStrategy;
 const enums_1 = require("../enums");
-const core_1 = require("@mikro-orm/core");
+const Utils_1 = require("../utils/Utils");
 /**
  * Expands `books.perex` like populate to use `children` array instead of the dot syntax
  */
@@ -20,7 +21,7 @@ function expandNestedPopulate(parentProp, parts, strategy, all) {
  * @internal
  */
 function expandDotPaths(meta, populate, normalized = false) {
-    const ret = normalized ? populate : core_1.Utils.asArray(populate).map(field => {
+    const ret = normalized ? populate : Utils_1.Utils.asArray(populate).map(field => {
         if (typeof field === 'string') {
             return { field };
         }
@@ -37,7 +38,6 @@ function expandDotPaths(meta, populate, normalized = false) {
         p.field = f;
         p.children ??= [];
         const prop = meta.properties[p.field];
-        p.strategy ??= prop.strategy;
         if (parts[0] === enums_1.PopulatePath.ALL) {
             prop.targetMeta.props
                 .filter(prop => prop.lazy || prop.kind !== enums_1.ReferenceKind.SCALAR)
@@ -58,3 +58,16 @@ function expandDotPaths(meta, populate, normalized = false) {
     }
     return ret;
 }
+/**
+ * Returns the loading strategy based on the provided hint.
+ * If `BALANCED` strategy is used, it will return JOINED if the property is a to-one relation.
+ * @internal
+ */
+function getLoadingStrategy(strategy, kind) {
+    if (strategy === enums_1.LoadStrategy.BALANCED) {
+        return [enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(kind)
+            ? enums_1.LoadStrategy.JOINED
+            : enums_1.LoadStrategy.SELECT_IN;
+    }
+    return strategy;
+}

package/enums.d.ts

@@ -85,6 +85,7 @@ export declare enum QueryFlag {
     INCLUDE_LAZY_FORMULAS = "INCLUDE_LAZY_FORMULAS",
     AUTO_JOIN_ONE_TO_ONE_OWNER = "AUTO_JOIN_ONE_TO_ONE_OWNER",
     INFER_POPULATE = "INFER_POPULATE",
+    DISABLE_NESTED_INNER_JOIN = "DISABLE_NESTED_INNER_JOIN",
     IDENTITY_INSERT = "IDENTITY_INSERT"
 }
 export declare const SCALAR_TYPES: string[];
@@ -108,7 +109,8 @@ export declare enum Cascade {
 }
 export declare enum LoadStrategy {
     SELECT_IN = "select-in",
-    JOINED = "joined"
+    JOINED = "joined",
+    BALANCED = "balanced"
 }
 export declare enum DataloaderType {
     NONE = 0,

package/enums.js

@@ -98,6 +98,7 @@ var QueryFlag;
     QueryFlag["INCLUDE_LAZY_FORMULAS"] = "INCLUDE_LAZY_FORMULAS";
     QueryFlag["AUTO_JOIN_ONE_TO_ONE_OWNER"] = "AUTO_JOIN_ONE_TO_ONE_OWNER";
     QueryFlag["INFER_POPULATE"] = "INFER_POPULATE";
+    QueryFlag["DISABLE_NESTED_INNER_JOIN"] = "DISABLE_NESTED_INNER_JOIN";
     QueryFlag["IDENTITY_INSERT"] = "IDENTITY_INSERT";
 })(QueryFlag || (exports.QueryFlag = QueryFlag = {}));
 exports.SCALAR_TYPES = ['string', 'number', 'boolean', 'bigint', 'Date', 'Buffer', 'RegExp'];
@@ -125,6 +126,7 @@ var LoadStrategy;
 (function (LoadStrategy) {
     LoadStrategy["SELECT_IN"] = "select-in";
     LoadStrategy["JOINED"] = "joined";
+    LoadStrategy["BALANCED"] = "balanced";
 })(LoadStrategy || (exports.LoadStrategy = LoadStrategy = {}));
 var DataloaderType;
 (function (DataloaderType) {

package/hydration/ObjectHydrator.js

@@ -65,7 +65,7 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
             const ret = [];
             const idx = this.tmpIndex++;
             const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
-            if (prop.getter && !prop.setter) {
+            if (prop.getter && !prop.setter && prop.persist === false) {
                 return [];
             }
             if (prop.ref) {

package/index.d.ts

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, Opt, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, Hidden, FilterValue, MergeLoaded, MergeSelected, Config, DefineConfig, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, } from './typings';
+export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, IndexCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, Opt, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, Hidden, FilterValue, MergeLoaded, MergeSelected, Config, DefineConfig, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, } from './typings';
 export * from './enums';
 export * from './errors';
 export * from './exceptions';

package/index.mjs

@@ -182,11 +182,15 @@ export const compareBuffers = mod.compareBuffers;
 export const compareObjects = mod.compareObjects;
 export const createSqlFunction = mod.createSqlFunction;
 export const defineConfig = mod.defineConfig;
+export const defineEntity = mod.defineEntity;
 export const equals = mod.equals;
+export const expandDotPaths = mod.expandDotPaths;
+export const getLoadingStrategy = mod.getLoadingStrategy;
 export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;
 export const helper = mod.helper;
 export const parseJsonSafe = mod.parseJsonSafe;
+export const quote = mod.quote;
 export const raw = mod.raw;
 export const ref = mod.ref;
 export const rel = mod.rel;

package/metadata/MetadataDiscovery.d.ts

@@ -54,7 +54,6 @@ export declare class MetadataDiscovery {
     private initAutoincrement;
     private initCheckConstraints;
     private initGeneratedColumn;
-    private createColumnMappingObject;
     private getDefaultVersionValue;
     private inferDefaultValue;
     private initDefaultValue;

package/metadata/MetadataDiscovery.js

@@ -622,7 +622,7 @@ class MetadataDiscovery {
         }
         data.properties[meta.name + '_owner'] = this.definePivotProperty(prop, meta.name + '_owner', meta.className, targetType + '_inverse', true, meta.className === targetType);
         data.properties[targetType + '_inverse'] = this.definePivotProperty(prop, targetType + '_inverse', targetType, meta.name + '_owner', false, meta.className === targetType);
-        return this.metadata.set(data.className, data);
+        return this.metadata.set(data.className, EntitySchema_1.EntitySchema.fromMetadata(data).init().meta);
     }
     defineFixedOrderProperty(prop, targetType) {
         const pk = prop.fixedOrderColumn || this.namingStrategy.referenceColumnName();
@@ -825,9 +825,16 @@ class MetadataDiscovery {
             }
             return prop.embedded ? isParentObject(meta.properties[prop.embedded[0]]) : false;
         };
+        const isParentArray = (prop) => {
+            if (prop.array) {
+                return true;
+            }
+            return prop.embedded ? isParentArray(meta.properties[prop.embedded[0]]) : false;
+        };
         const rootProperty = getRootProperty(embeddedProp);
         const parentProperty = meta.properties[embeddedProp.embedded?.[0] ?? ''];
         const object = isParentObject(embeddedProp);
+        const array = isParentArray(embeddedProp);
         this.initFieldName(embeddedProp, rootProperty !== embeddedProp && object);
         // the prefix of the parent cannot be a boolean; it already passed here
         const prefix = this.getPrefix(embeddedProp, parentProperty);
@@ -840,7 +847,8 @@ class MetadataDiscovery {
             meta.propertyOrder.set(name, (order += 0.01));
             embeddedProp.embeddedProps[prop.name] = meta.properties[name];
             meta.properties[name].persist ??= embeddedProp.persist;
-            if (embeddedProp.nullable) {
+            const refInArray = array && [enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.owner;
+            if (embeddedProp.nullable || refInArray) {
                 meta.properties[name].nullable = true;
             }
             if (meta.properties[name].fieldNames) {
@@ -969,7 +977,7 @@ class MetadataDiscovery {
         }
     }
     initCheckConstraints(meta) {
-        const map = this.createColumnMappingObject(meta);
+        const map = meta.createColumnMappingObject();
         for (const check of meta.checks) {
             const columns = check.property ? meta.properties[check.property].fieldNames : [];
             check.name ??= this.namingStrategy.indexName(meta.tableName, columns, 'check');
@@ -992,19 +1000,11 @@ class MetadataDiscovery {
             }
             return;
         }
-        const map = this.createColumnMappingObject(meta);
+        const map = meta.createColumnMappingObject();
         if (prop.generated instanceof Function) {
             prop.generated = prop.generated(map);
         }
     }
-    createColumnMappingObject(meta) {
-        return Object.values(meta.properties).reduce((o, prop) => {
-            if (prop.fieldNames) {
-                o[prop.name] = prop.fieldNames[0];
-            }
-            return o;
-        }, {});
-    }
     getDefaultVersionValue(meta, prop) {
         if (typeof prop.defaultRaw !== 'undefined') {
             return prop.defaultRaw;
@@ -1058,7 +1058,7 @@ class MetadataDiscovery {
             prop.defaultRaw = this.platform.formatQuery(raw.sql, raw.params);
             return;
         }
-        if (prop.customType instanceof types_1.ArrayType && Array.isArray(prop.default)) {
+        if (Array.isArray(prop.default) && prop.customType) {
             val = prop.customType.convertToDatabaseValue(prop.default, this.platform);
         }
         prop.defaultRaw = typeof val === 'string' ? `'${val}'` : '' + val;
@@ -1112,6 +1112,9 @@ class MetadataDiscovery {
         if (prop.kind === enums_1.ReferenceKind.SCALAR && !prop.customType && prop.columnTypes && ['json', 'jsonb'].includes(prop.columnTypes[0])) {
             prop.customType = new types_1.JsonType();
         }
+        if (prop.kind === enums_1.ReferenceKind.EMBEDDED && !prop.customType && (prop.object || prop.array)) {
+            prop.customType = new types_1.JsonType();
+        }
         if (!prop.customType && prop.array && prop.items) {
             prop.customType = new types_1.EnumArrayType(`${meta.className}.${prop.name}`, prop.items);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.17-dev.9",
+  "version": "6.4.17-dev.91",
   "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",
@@ -60,11 +60,11 @@
   },
   "dependencies": {
     "dataloader": "2.2.3",
-    "dotenv": "16.5.0",
+    "dotenv": "17.2.1",
     "esprima": "4.0.1",
-    "fs-extra": "11.3.0",
+    "fs-extra": "11.3.1",
     "globby": "11.1.0",
-    "mikro-orm": "6.4.17-dev.9",
+    "mikro-orm": "6.4.17-dev.91",
     "reflect-metadata": "0.2.2"
   }
 }

package/platforms/Platform.d.ts

@@ -173,7 +173,9 @@ export declare abstract class Platform {
     getExtension<T>(extensionName: string, extensionKey: string, moduleName: string, em: EntityManager): T;
     getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): ISchemaGenerator;
     processDateProperty(value: unknown): string | number | Date;
-    quoteIdentifier(id: string, quote?: string): string;
+    quoteIdentifier(id: string | {
+        toString: () => string;
+    }, quote?: string): string;
     quoteValue(value: any): string;
     escape(value: any): string;
     formatQuery(sql: string, params: readonly any[]): string;

package/types/BooleanType.d.ts

@@ -1,7 +1,7 @@
 import { Type } from './Type';
 import type { Platform } from '../platforms';
 import type { EntityProperty } from '../typings';
-export declare class BooleanType extends Type<number | null | undefined, number | null | undefined> {
+export declare class BooleanType extends Type<boolean | null | undefined, boolean | null | undefined> {
     getColumnType(prop: EntityProperty, platform: Platform): string;
     compareAsType(): string;
     ensureComparable(): boolean;

package/types/DecimalType.js

@@ -15,7 +15,7 @@ class DecimalType extends Type_1.Type {
         if ((this.mode ?? this.prop?.runtimeType) === 'number') {
             return +value;
         }
-        return value;
+        return String(value);
     }
     compareValues(a, b) {
         return this.format(a) === this.format(b);

package/types/DoubleType.js

@@ -10,7 +10,7 @@ class DoubleType extends Type_1.Type {
         if (this.prop?.runtimeType === 'number') {
             return +value;
         }
-        return value;
+        return String(value);
     }
     getColumnType(prop, platform) {
         return platform.getDoubleDeclarationSQL();

package/typings.d.ts

@@ -6,7 +6,7 @@ import type { SerializationContext, SerializeOptions } from './serialization';
 import type { EntitySchema, MetadataStorage } from './metadata';
 import type { Type, types } from './types';
 import type { Platform } from './platforms';
-import type { Configuration } from './utils';
+import type { Configuration, RawQueryFragment } from './utils';
 import type { EntityManager } from './EntityManager';
 import type { EmbeddedPrefixMode } from './decorators/Embedded';
 import type { EventSubscriber } from './events';
@@ -73,6 +73,7 @@ export type Primary<T> = IsAny<T> extends true ? any : T extends {
 } ? ReadonlyPrimary<PK> : T extends {
     id?: infer PK;
 } ? ReadonlyPrimary<PK> : T;
+/** @internal */
 export type PrimaryProperty<T> = T extends {
     [PrimaryKeyProp]?: infer PK;
 } ? (PK extends keyof T ? PK : (PK extends any[] ? PK[number] : never)) : T extends {
@@ -287,8 +288,14 @@ export type EntityDTO<T, C extends TypeConfig = never> = {
 } & {
     [K in keyof T as DTOOptionalKeys<T, K>]?: EntityDTOProp<T, T[K], C> | AddOptional<T[K]>;
 };
-type CheckKey<T> = IsUnknown<T> extends false ? keyof T : string;
-export type CheckCallback<T> = (columns: Record<CheckKey<T>, string>) => string;
+type PropertyName<T> = IsUnknown<T> extends false ? keyof T : string;
+type TableName = {
+    name: string;
+    schema?: string;
+    toString: () => string;
+};
+export type IndexCallback<T> = (table: TableName, columns: Record<PropertyName<T>, string>) => string | RawQueryFragment;
+export type CheckCallback<T> = (columns: Record<PropertyName<T>, string>) => string;
 export type GeneratedColumnCallback<T> = (columns: Record<keyof T, string>) => string;
 export interface CheckConstraint<T = any> {
     name?: string;
@@ -394,8 +401,9 @@ export declare class EntityMetadata<T = any> {
     constructor(meta?: Partial<EntityMetadata>);
     addProperty(prop: Partial<EntityProperty<T>>, sync?: boolean): void;
     removeProperty(name: string, sync?: boolean): void;
-    getPrimaryProps(): EntityProperty<T>[];
+    getPrimaryProps(flatten?: boolean): EntityProperty<T>[];
     getPrimaryProp(): EntityProperty<T>;
+    createColumnMappingObject(): Dictionary<any>;
     get tableName(): string;
     set tableName(name: string);
     sync(initIndexes?: boolean): void;
@@ -447,18 +455,18 @@ export interface EntityMetadata<T = any> {
     uniqueProps: EntityProperty<T>[];
     getterProps: EntityProperty<T>[];
     indexes: {
-        properties: EntityKey<T> | EntityKey<T>[];
+        properties?: EntityKey<T> | EntityKey<T>[];
         name?: string;
         type?: string;
         options?: Dictionary;
-        expression?: string;
+        expression?: string | IndexCallback<T>;
     }[];
     uniques: {
-        properties: EntityKey<T> | EntityKey<T>[];
+        properties?: EntityKey<T> | EntityKey<T>[];
         name?: string;
         options?: Dictionary;
-        expression?: string;
-        deferMode?: DeferMode;
+        expression?: string | IndexCallback<T>;
+        deferMode?: DeferMode | `${DeferMode}`;
     }[];
     checks: CheckConstraint<T>[];
     repositoryClass?: string;
@@ -690,6 +698,7 @@ export type PopulateOptions<T> = {
     strategy?: LoadStrategy;
     all?: boolean;
     filter?: boolean;
+    joinType?: 'inner join' | 'left join';
     children?: PopulateOptions<T[keyof T]>[];
 };
 type Loadable<T extends object> = Collection<T, any> | Reference<T> | Ref<T> | readonly T[];

package/typings.js

@@ -47,12 +47,29 @@ class EntityMetadata {
             this.sync();
         }
     }
-    getPrimaryProps() {
-        return this.primaryKeys.map(pk => this.properties[pk]);
+    getPrimaryProps(flatten = false) {
+        const pks = this.primaryKeys.map(pk => this.properties[pk]);
+        if (flatten) {
+            return pks.flatMap(pk => {
+                if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(pk.kind)) {
+                    return pk.targetMeta.getPrimaryProps(true);
+                }
+                return [pk];
+            });
+        }
+        return pks;
     }
     getPrimaryProp() {
         return this.properties[this.primaryKeys[0]];
     }
+    createColumnMappingObject() {
+        return Object.values(this.properties).reduce((o, prop) => {
+            if (prop.fieldNames) {
+                o[prop.name] = prop.fieldNames[0];
+            }
+            return o;
+        }, {});
+    }
     get tableName() {
         return this.collection;
     }
@@ -72,7 +89,7 @@ class EntityMetadata {
             // `prop.userDefined` is either `undefined` or `false`
             const discriminator = this.root.discriminatorColumn === prop.name && prop.userDefined === false;
             // even if we don't have a setter, do not ignore value from database!
-            const onlyGetter = prop.getter && !prop.setter;
+            const onlyGetter = prop.getter && !prop.setter && prop.persist === false;
             return !prop.inherited && prop.hydrate !== false && !discriminator && !prop.embedded && !onlyGetter;
         });
         this.trackingProps = this.hydrateProps
@@ -115,7 +132,7 @@ class EntityMetadata {
                         wrapped.__data[prop.name] = entity_1.Reference.wrapReference(val, prop);
                         // when propagation from inside hydration, we set the FK to the entity data immediately
                         if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
-                            wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(val, prop.targetMeta.primaryKeys, true);
+                            wrapped.__originalEntityData[prop.name] = Utils_1.Utils.getPrimaryKeyValues(val, prop.targetMeta, true);
                         }
                         else {
                             wrapped.__touched = !hydrator.isRunning();

package/unit-of-work/ChangeSetPersister.d.ts

@@ -4,6 +4,7 @@ import { type EntityFactory, type EntityValidator } from '../entity';
 import { type ChangeSet } from './ChangeSet';
 import { type Configuration } from '../utils';
 import type { DriverMethodOptions, IDatabaseDriver } from '../drivers';
+import type { EntityManager } from '../EntityManager';
 export declare class ChangeSetPersister {
     private readonly driver;
     private readonly metadata;
@@ -11,10 +12,11 @@ export declare class ChangeSetPersister {
     private readonly factory;
     private readonly validator;
     private readonly config;
+    private readonly em;
     private readonly platform;
     private readonly comparator;
     private readonly usesReturningStatement;
-    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, validator: EntityValidator, config: Configuration);
+    constructor(driver: IDatabaseDriver, metadata: MetadataStorage, hydrator: IHydrator, factory: EntityFactory, validator: EntityValidator, config: Configuration, em: EntityManager);
     executeInserts<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeUpdates<T extends object>(changeSets: ChangeSet<T>[], batched: boolean, options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
     executeDeletes<T extends object>(changeSets: ChangeSet<T>[], options?: DriverMethodOptions, withSchema?: boolean): Promise<void>;
@@ -22,7 +24,7 @@ export declare class ChangeSetPersister {
     private processProperties;
     private persistNewEntity;
     private persistNewEntities;
-    private propagateSchemaFromMetadata;
+    private prepareOptions;
     private persistNewEntitiesBatch;
     private persistManagedEntity;
     private persistManagedEntities;

package/unit-of-work/ChangeSetPersister.js

@@ -13,16 +13,18 @@ class ChangeSetPersister {
     factory;
     validator;
     config;
+    em;
     platform;
     comparator;
     usesReturningStatement;
-    constructor(driver, metadata, hydrator, factory, validator, config) {
+    constructor(driver, metadata, hydrator, factory, validator, config, em) {
         this.driver = driver;
         this.metadata = metadata;
         this.hydrator = hydrator;
         this.factory = factory;
         this.validator = validator;
         this.config = config;
+        this.em = em;
         this.platform = this.driver.getPlatform();
         this.comparator = this.config.getComparator(this.metadata);
         this.usesReturningStatement = this.platform.usesReturningStatement() || this.platform.usesOutputStatement();
@@ -63,7 +65,7 @@ class ChangeSetPersister {
         for (let i = 0; i < changeSets.length; i += size) {
             const chunk = changeSets.slice(i, i + size);
             const pks = chunk.map(cs => cs.getPrimaryKey());
-            options = this.propagateSchemaFromMetadata(meta, options);
+            options = this.prepareOptions(meta, options);
             await this.driver.nativeDelete(meta.root.className, { [pk]: { $in: pks } }, options);
         }
     }
@@ -91,7 +93,7 @@ class ChangeSetPersister {
     }
     async persistNewEntity(meta, changeSet, options) {
         const wrapped = (0, entity_1.helper)(changeSet.entity);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
         const res = await this.driver.nativeInsertMany(meta.className, [changeSet.payload], options);
@@ -117,15 +119,17 @@ class ChangeSetPersister {
             }
         }
     }
-    propagateSchemaFromMetadata(meta, options, additionalOptions) {
+    prepareOptions(meta, options, additionalOptions) {
+        const loggerContext = utils_1.Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
         return {
             ...options,
             ...additionalOptions,
             schema: options?.schema ?? meta.schema,
+            loggerContext,
         };
     }
     async persistNewEntitiesBatch(meta, changeSets, options) {
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
             processCollections: false,
         });
@@ -176,7 +180,7 @@ class ChangeSetPersister {
     }
     async persistManagedEntitiesBatch(meta, changeSets, options) {
         await this.checkOptimisticLocks(meta, changeSets, options);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
             processCollections: false,
         });
@@ -236,7 +240,7 @@ class ChangeSetPersister {
     }
     async updateEntity(meta, changeSet, options) {
         const cond = changeSet.getPrimaryKey(true);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
         if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
@@ -263,7 +267,7 @@ class ChangeSetPersister {
             return cond;
         });
         const primaryKeys = meta.primaryKeys.concat(...meta.concurrencyCheckKeys);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             fields: primaryKeys,
         });
         const res = await this.driver.find(meta.root.className, { $or }, options);
@@ -322,12 +326,12 @@ class ChangeSetPersister {
             }
             return val;
         });
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             fields: utils_1.Utils.unique(reloadProps.map(prop => prop.name)),
         });
         const data = await this.driver.find(meta.className, { [pk]: { $in: pks } }, options);
         const map = new Map();
-        data.forEach(item => map.set(utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        data.forEach(item => map.set(utils_1.Utils.getCompositeKeyHash(item, meta, false, this.platform, true), item));
         for (const changeSet of changeSets) {
             const data = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
             this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);

package/unit-of-work/UnitOfWork.d.ts

@@ -38,7 +38,7 @@ export declare class UnitOfWork {
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string): T | undefined;
+    getById<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string, convertCustomTypes?: boolean): T | undefined;
     tryGetById<T extends object>(entityName: string, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
     /**
      * Returns map of all managed entities.

package/unit-of-work/UnitOfWork.js

@@ -42,7 +42,7 @@ class UnitOfWork {
         this.eventManager = this.em.getEventManager();
         this.comparator = this.em.getComparator();
         this.changeSetComputer = new ChangeSetComputer_1.ChangeSetComputer(this.em.getValidator(), this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
-        this.changeSetPersister = new ChangeSetPersister_1.ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config);
+        this.changeSetPersister = new ChangeSetPersister_1.ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config, this.em);
     }
     merge(entity, visited) {
         const wrapped = (0, entity_1.helper)(entity);
@@ -88,7 +88,7 @@ class UnitOfWork {
                 }
                 wrapped.__loadedProperties.add(key);
                 if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
                 else if (prop.kind === enums_1.ReferenceKind.EMBEDDED && !prop.object && Utils_1.Utils.isPlainObject(data[prop.name])) {
                     for (const p of prop.targetMeta.props) {
@@ -96,7 +96,7 @@ class UnitOfWork {
                         const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
                         data[prefix + p.name] = data[prop.name][p.name];
                     }
-                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                    data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
                 }
                 if (forceUndefined) {
                     if (data[key] === null) {
@@ -124,7 +124,7 @@ class UnitOfWork {
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById(entityName, id, schema) {
+    getById(entityName, id, schema, convertCustomTypes) {
         if (id == null || (Array.isArray(id) && id.length === 0)) {
             return undefined;
         }
@@ -134,7 +134,16 @@ class UnitOfWork {
             hash = '' + id;
         }
         else {
-            const keys = Array.isArray(id) ? Utils_1.Utils.flatten(id) : [id];
+            let keys = Array.isArray(id) ? Utils_1.Utils.flatten(id) : [id];
+            keys = meta.getPrimaryProps(true).map((p, i) => {
+                if (!convertCustomTypes && p.customType) {
+                    return p.customType.convertToDatabaseValue(keys[i], this.platform, {
+                        key: p.name,
+                        mode: 'hydration',
+                    });
+                }
+                return keys[i];
+            });
             hash = Utils_1.Utils.getPrimaryKeyHash(keys);
         }
         schema ??= meta.schema ?? this.em.config.getSchema();
@@ -312,9 +321,11 @@ class UnitOfWork {
             const platform = this.em.getPlatform();
             const runInTransaction = !this.em.isInTransaction() && platform.supportsTransactions() && this.em.config.get('implicitTransactions');
             if (runInTransaction) {
+                const loggerContext = Utils_1.Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
                 await this.em.getConnection('write').transactional(trx => this.persistToDatabase(groups, trx), {
                     ctx: oldTx,
                     eventBroadcaster: new events_1.TransactionEventBroadcaster(this.em, this),
+                    loggerContext,
                 });
             }
             else {
@@ -888,7 +899,12 @@ class UnitOfWork {
     }
     async commitCollectionUpdates(ctx) {
         this.filterCollectionUpdates();
-        await this.em.getDriver().syncCollections(this.collectionUpdates, { ctx, schema: this.em.schema });
+        const loggerContext = Utils_1.Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
+        await this.em.getDriver().syncCollections(this.collectionUpdates, {
+            ctx,
+            schema: this.em.schema,
+            loggerContext,
+        });
         for (const coll of this.collectionUpdates) {
             coll.takeSnapshot();
         }