@mikro-orm/core 7.0.0-dev.0 → 7.0.0-dev.10

package/types/index.js

@@ -1,80 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.t = exports.types = exports.CharacterType = exports.IntervalType = exports.UnknownType = exports.TextType = exports.UuidType = exports.StringType = exports.DecimalType = exports.BooleanType = exports.DoubleType = exports.FloatType = exports.MediumIntType = exports.TinyIntType = exports.SmallIntType = exports.IntegerType = exports.JsonType = exports.EnumType = exports.EnumArrayType = exports.ArrayType = exports.Uint8ArrayType = exports.BlobType = exports.BigIntType = exports.DateTimeType = exports.TimeType = exports.DateType = exports.Type = void 0;
-const ArrayType_1 = require("./ArrayType");
-Object.defineProperty(exports, "ArrayType", { enumerable: true, get: function () { return ArrayType_1.ArrayType; } });
-const BigIntType_1 = require("./BigIntType");
-Object.defineProperty(exports, "BigIntType", { enumerable: true, get: function () { return BigIntType_1.BigIntType; } });
-const BlobType_1 = require("./BlobType");
-Object.defineProperty(exports, "BlobType", { enumerable: true, get: function () { return BlobType_1.BlobType; } });
-const BooleanType_1 = require("./BooleanType");
-Object.defineProperty(exports, "BooleanType", { enumerable: true, get: function () { return BooleanType_1.BooleanType; } });
-const DateTimeType_1 = require("./DateTimeType");
-Object.defineProperty(exports, "DateTimeType", { enumerable: true, get: function () { return DateTimeType_1.DateTimeType; } });
-const DateType_1 = require("./DateType");
-Object.defineProperty(exports, "DateType", { enumerable: true, get: function () { return DateType_1.DateType; } });
-const DecimalType_1 = require("./DecimalType");
-Object.defineProperty(exports, "DecimalType", { enumerable: true, get: function () { return DecimalType_1.DecimalType; } });
-const DoubleType_1 = require("./DoubleType");
-Object.defineProperty(exports, "DoubleType", { enumerable: true, get: function () { return DoubleType_1.DoubleType; } });
-const EnumArrayType_1 = require("./EnumArrayType");
-Object.defineProperty(exports, "EnumArrayType", { enumerable: true, get: function () { return EnumArrayType_1.EnumArrayType; } });
-const EnumType_1 = require("./EnumType");
-Object.defineProperty(exports, "EnumType", { enumerable: true, get: function () { return EnumType_1.EnumType; } });
-const CharacterType_1 = require("./CharacterType");
-Object.defineProperty(exports, "CharacterType", { enumerable: true, get: function () { return CharacterType_1.CharacterType; } });
-const FloatType_1 = require("./FloatType");
-Object.defineProperty(exports, "FloatType", { enumerable: true, get: function () { return FloatType_1.FloatType; } });
-const IntegerType_1 = require("./IntegerType");
-Object.defineProperty(exports, "IntegerType", { enumerable: true, get: function () { return IntegerType_1.IntegerType; } });
-const IntervalType_1 = require("./IntervalType");
-Object.defineProperty(exports, "IntervalType", { enumerable: true, get: function () { return IntervalType_1.IntervalType; } });
-const JsonType_1 = require("./JsonType");
-Object.defineProperty(exports, "JsonType", { enumerable: true, get: function () { return JsonType_1.JsonType; } });
-const MediumIntType_1 = require("./MediumIntType");
-Object.defineProperty(exports, "MediumIntType", { enumerable: true, get: function () { return MediumIntType_1.MediumIntType; } });
-const SmallIntType_1 = require("./SmallIntType");
-Object.defineProperty(exports, "SmallIntType", { enumerable: true, get: function () { return SmallIntType_1.SmallIntType; } });
-const StringType_1 = require("./StringType");
-Object.defineProperty(exports, "StringType", { enumerable: true, get: function () { return StringType_1.StringType; } });
-const TextType_1 = require("./TextType");
-Object.defineProperty(exports, "TextType", { enumerable: true, get: function () { return TextType_1.TextType; } });
-const TimeType_1 = require("./TimeType");
-Object.defineProperty(exports, "TimeType", { enumerable: true, get: function () { return TimeType_1.TimeType; } });
-const TinyIntType_1 = require("./TinyIntType");
-Object.defineProperty(exports, "TinyIntType", { enumerable: true, get: function () { return TinyIntType_1.TinyIntType; } });
-const Type_1 = require("./Type");
-Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return Type_1.Type; } });
-const Uint8ArrayType_1 = require("./Uint8ArrayType");
-Object.defineProperty(exports, "Uint8ArrayType", { enumerable: true, get: function () { return Uint8ArrayType_1.Uint8ArrayType; } });
-const UnknownType_1 = require("./UnknownType");
-Object.defineProperty(exports, "UnknownType", { enumerable: true, get: function () { return UnknownType_1.UnknownType; } });
-const UuidType_1 = require("./UuidType");
-Object.defineProperty(exports, "UuidType", { enumerable: true, get: function () { return UuidType_1.UuidType; } });
-exports.types = {
-    date: DateType_1.DateType,
-    time: TimeType_1.TimeType,
-    datetime: DateTimeType_1.DateTimeType,
-    bigint: BigIntType_1.BigIntType,
-    blob: BlobType_1.BlobType,
-    uint8array: Uint8ArrayType_1.Uint8ArrayType,
-    array: ArrayType_1.ArrayType,
-    enumArray: EnumArrayType_1.EnumArrayType,
-    enum: EnumType_1.EnumType,
-    json: JsonType_1.JsonType,
-    integer: IntegerType_1.IntegerType,
-    smallint: SmallIntType_1.SmallIntType,
-    tinyint: TinyIntType_1.TinyIntType,
-    mediumint: MediumIntType_1.MediumIntType,
-    float: FloatType_1.FloatType,
-    double: DoubleType_1.DoubleType,
-    boolean: BooleanType_1.BooleanType,
-    decimal: DecimalType_1.DecimalType,
-    character: CharacterType_1.CharacterType,
-    string: StringType_1.StringType,
-    uuid: UuidType_1.UuidType,
-    text: TextType_1.TextType,
-    interval: IntervalType_1.IntervalType,
-    unknown: UnknownType_1.UnknownType,
+import { ArrayType } from './ArrayType.js';
+import { BigIntType } from './BigIntType.js';
+import { BlobType } from './BlobType.js';
+import { BooleanType } from './BooleanType.js';
+import { DateTimeType } from './DateTimeType.js';
+import { DateType } from './DateType.js';
+import { DecimalType } from './DecimalType.js';
+import { DoubleType } from './DoubleType.js';
+import { EnumArrayType } from './EnumArrayType.js';
+import { EnumType } from './EnumType.js';
+import { CharacterType } from './CharacterType.js';
+import { FloatType } from './FloatType.js';
+import { IntegerType } from './IntegerType.js';
+import { IntervalType } from './IntervalType.js';
+import { JsonType } from './JsonType.js';
+import { MediumIntType } from './MediumIntType.js';
+import { SmallIntType } from './SmallIntType.js';
+import { StringType } from './StringType.js';
+import { TextType } from './TextType.js';
+import { TimeType } from './TimeType.js';
+import { TinyIntType } from './TinyIntType.js';
+import { Type } from './Type.js';
+import { Uint8ArrayType } from './Uint8ArrayType.js';
+import { UnknownType } from './UnknownType.js';
+import { UuidType } from './UuidType.js';
+export { Type, DateType, TimeType, DateTimeType, BigIntType, BlobType, Uint8ArrayType, ArrayType, EnumArrayType, EnumType, JsonType, IntegerType, SmallIntType, TinyIntType, MediumIntType, FloatType, DoubleType, BooleanType, DecimalType, StringType, UuidType, TextType, UnknownType, IntervalType, CharacterType, };
+export const types = {
+    date: DateType,
+    time: TimeType,
+    datetime: DateTimeType,
+    bigint: BigIntType,
+    blob: BlobType,
+    uint8array: Uint8ArrayType,
+    array: ArrayType,
+    enumArray: EnumArrayType,
+    enum: EnumType,
+    json: JsonType,
+    integer: IntegerType,
+    smallint: SmallIntType,
+    tinyint: TinyIntType,
+    mediumint: MediumIntType,
+    float: FloatType,
+    double: DoubleType,
+    boolean: BooleanType,
+    decimal: DecimalType,
+    character: CharacterType,
+    string: StringType,
+    uuid: UuidType,
+    text: TextType,
+    interval: IntervalType,
+    unknown: UnknownType,
 };
-exports.t = exports.types;
+export const t = types;

package/typings.d.ts

@@ -1,22 +1,25 @@
-import type { Transaction } from './connections';
-import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind } from './enums';
-import { type AssignOptions } from './entity/EntityAssigner';
-import { type EntityIdentifier } from './entity/EntityIdentifier';
-import { type EntityLoaderOptions } from './entity/EntityLoader';
-import { type Collection } from './entity/Collection';
-import { type EntityFactory } from './entity/EntityFactory';
-import { type EntityRepository } from './entity/EntityRepository';
-import { Reference, type ScalarReference } from './entity/Reference';
-import type { MikroORM } from './MikroORM';
-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, RawQueryFragment } from './utils';
-import type { EntityManager } from './EntityManager';
-import type { EmbeddedPrefixMode } from './decorators/Embedded';
-import type { EventSubscriber } from './events';
-import type { FindOneOptions, FindOptions, LoadHint } from './drivers';
+import type { Transaction } from './connections/Connection.js';
+import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind } from './enums.js';
+import { type AssignOptions } from './entity/EntityAssigner.js';
+import { type EntityIdentifier } from './entity/EntityIdentifier.js';
+import { type EntityLoaderOptions } from './entity/EntityLoader.js';
+import { type Collection } from './entity/Collection.js';
+import { type EntityFactory } from './entity/EntityFactory.js';
+import { type EntityRepository } from './entity/EntityRepository.js';
+import { Reference, type ScalarReference } from './entity/Reference.js';
+import type { MikroORM } from './MikroORM.js';
+import type { SerializationContext } from './serialization/SerializationContext.js';
+import type { SerializeOptions } from './serialization/EntitySerializer.js';
+import type { MetadataStorage } from './metadata/MetadataStorage.js';
+import type { EntitySchema } from './metadata/EntitySchema.js';
+import type { Type, types } from './types/index.js';
+import type { Platform } from './platforms/Platform.js';
+import type { Configuration } from './utils/Configuration.js';
+import type { RawQueryFragment } from './utils/RawQueryFragment.js';
+import type { EntityManager } from './EntityManager.js';
+import type { EmbeddedPrefixMode } from './decorators/Embedded.js';
+import type { EventSubscriber } from './events/EventSubscriber.js';
+import type { FindOneOptions, FindOptions, LoadHint } from './drivers/IDatabaseDriver.js';
 export type Constructor<T = unknown> = new (...args: any[]) => T;
 export type Dictionary<T = any> = {
     [k: string]: T;
@@ -25,6 +28,7 @@ export type EntityKey<T = unknown, B extends boolean = false> = string & {
     [K in keyof T]-?: CleanKeys<T, K, B> extends never ? never : K;
 }[keyof T];
 export type EntityValue<T> = T[EntityKey<T>];
+export type EntityDataValue<T> = EntityData<T>[EntityKey<T>];
 export type FilterKey<T> = keyof FilterQuery<T>;
 export type AsyncFunction<R = any, T = Dictionary> = (args: T) => Promise<T>;
 export type Compute<T> = {
@@ -173,7 +177,7 @@ export interface IWrappedEntityInternal<Entity extends object> extends IWrappedE
     __touched: boolean;
     __originalEntityData?: EntityData<Entity>;
     __loadedProperties: Set<string>;
-    __identifier?: EntityIdentifier;
+    __identifier?: EntityIdentifier | EntityIdentifier[];
     __managed: boolean;
     __processing: boolean;
     __schema?: string;
@@ -202,7 +206,7 @@ export type EntityName<T> = string | EntityClass<T> | EntitySchema<T, any> | {
 };
 export type GetRepository<Entity extends {
     [k: PropertyKey]: any;
-}, Fallback> = Entity[typeof EntityRepositoryType] extends EntityRepository<Entity> | undefined ? NonNullable<Entity[typeof EntityRepositoryType]> : Fallback;
+}, Fallback> = Entity[typeof EntityRepositoryType] extends EntityRepository<any> | undefined ? NonNullable<Entity[typeof EntityRepositoryType]> : Fallback;
 export type EntityDataPropValue<T> = T | Primary<T>;
 type ExpandEntityProp<T, C extends boolean = false> = T extends Record<string, any> ? {
     [K in keyof T as CleanKeys<T, K>]?: EntityDataProp<ExpandProperty<T[K]>, C> | EntityDataPropValue<ExpandProperty<T[K]>> | null;
@@ -237,7 +241,7 @@ type IsOptional<T, K extends keyof T, I> = T[K] extends Collection<any, any> ? t
 type RequiredKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? CleanKeys<T, K> : never;
 type OptionalKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? never : CleanKeys<T, K>;
 export type EntityData<T, C extends boolean = false> = {
-    [K in EntityKey<T>]?: EntityDataItem<T[K], C>;
+    [K in EntityKey<T>]?: EntityDataItem<T[K] & {}, C>;
 };
 export type RequiredEntityData<T, I = never, C extends boolean = false> = {
     [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]>;
@@ -279,7 +283,7 @@ type PrimaryOrObject<T, U, C extends TypeConfig> = PreferExplicitConfig<C, Extra
 } : Primary<U>;
 export type EntityDTOProp<E, T, C extends TypeConfig = never> = T extends Scalar ? T : T extends {
     __serialized?: infer U;
-} ? U : T extends LoadedReference<infer U> ? EntityDTO<U, C> : T extends Reference<infer U> ? PrimaryOrObject<E, U, C> : T extends ScalarReference<infer U> ? U : T extends LoadedCollection<infer U> ? EntityDTO<U, C>[] : T extends Collection<infer U> ? PrimaryOrObject<E, U, C>[] : T extends readonly (infer U)[] ? (T extends readonly any[] ? T : U[]) : T extends Relation<T> ? EntityDTO<T, C> : T;
+} ? (IsUnknown<U> extends false ? U : T) : T extends LoadedReference<infer U> ? EntityDTO<U, C> : T extends Reference<infer U> ? PrimaryOrObject<E, U, C> : T extends ScalarReference<infer U> ? U : T extends LoadedCollection<infer U> ? EntityDTO<U, C>[] : T extends Collection<infer U> ? PrimaryOrObject<E, U, C>[] : T extends readonly (infer U)[] ? (T extends readonly any[] ? T : U[]) : T extends Relation<T> ? EntityDTO<T, C> : T;
 type DTOProbablyOptionalProps<T> = NonNullable<NullableKeys<T, undefined>>;
 type DTOIsOptional<T, K extends keyof T> = T[K] extends LoadedCollection<any> ? false : K extends PrimaryProperty<T> ? false : K extends DTOProbablyOptionalProps<T> ? true : false;
 type DTORequiredKeys<T, K extends keyof T> = DTOIsOptional<T, K> extends false ? ExcludeHidden<T, K> & CleanKeys<T, K> : never;
@@ -289,7 +293,9 @@ export type EntityDTO<T, C extends TypeConfig = never> = {
 } & {
     [K in keyof T as DTOOptionalKeys<T, K>]?: EntityDTOProp<T, T[K], C> | AddOptional<T[K]>;
 };
-export type CheckCallback<T> = (columns: Record<keyof T, string>) => string;
+type TargetKeys<T> = T extends EntityClass<infer P> ? keyof P : keyof T;
+type CheckKey<T> = IsUnknown<T> extends false ? TargetKeys<T> : string;
+export type CheckCallback<T> = (columns: Record<CheckKey<T>, string>) => string;
 export type GeneratedColumnCallback<T> = (columns: Record<keyof T, string>) => string;
 export interface CheckConstraint<T = any> {
     name?: string;
@@ -413,7 +419,7 @@ export interface EntityMetadata<T = any> {
     schema?: string;
     pivotTable?: boolean;
     virtual?: boolean;
-    expression?: string | ((em: any, where: FilterQuery<T>, options: FindOptions<T, any, any, any>) => MaybePromise<RawQueryFragment | object | string>);
+    expression?: string | ((em: any, where: ObjectQuery<T>, options: FindOptions<T, any, any, any>) => MaybePromise<RawQueryFragment | object | string>);
     discriminatorColumn?: EntityKey<T> | AnyString;
     discriminatorValue?: number | string;
     discriminatorMap?: Dictionary<string>;
@@ -468,7 +474,6 @@ export interface EntityMetadata<T = any> {
     prototype: T;
     class: EntityClass<T>;
     abstract: boolean;
-    useCache: boolean;
     filters: Dictionary<FilterDef>;
     comment?: string;
     selfReferencing?: boolean;
@@ -679,7 +684,7 @@ export interface MigrationObject {
 }
 export type FilterDef = {
     name: string;
-    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>) => Dictionary | Promise<Dictionary>);
+    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: EntityName<any>) => Dictionary | Promise<Dictionary>);
     default?: boolean;
     entity?: string[];
     args?: boolean;
@@ -724,7 +729,7 @@ export type MergeSelected<T, U, F extends string> = T extends Loaded<infer TT, i
 type MergeFields<F1 extends string, F2 extends string, P1, P2> = P1 | P2 extends '*' ? '*' : F1 | F2;
 type MergeExcludes<F extends string, E extends string> = F extends E ? never : Exclude<E, F>;
 export type MergeLoaded<T, U, P extends string, F extends string, E extends string, R extends boolean = false> = T extends Loaded<U, infer PP, infer FF, infer EE> ? string extends FF ? Loaded<T, P, F, AnyStringToNever<EE> | E> : string extends P ? Loaded<U, never, F | (FF & string), MergeExcludes<F | (FF & string), EE | E>> : Loaded<U, P | AnyStringToNever<PP>, MergeFields<F, AnyStringToNever<FF>, P, PP>, MergeExcludes<MergeFields<F, AnyStringToNever<FF>, P, PP>, (R extends true ? never : EE) | E>> : Loaded<T, P, F>;
-type AddOptional<T> = undefined | null extends T ? null | undefined : null extends T ? null : undefined extends T ? undefined : never;
+export type AddOptional<T> = undefined | null extends T ? null | undefined : null extends T ? null : undefined extends T ? undefined : never;
 type LoadedProp<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedLoadable<T, Loaded<ExtractType<T>, L, F, E>>;
 export type AddEager<T> = ExtractEagerProps<T> & string;
 export type ExpandHint<T, L extends string> = L | AddEager<T>;

package/typings.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityMetadata = exports.Config = exports.HiddenProps = exports.EagerProps = exports.OptionalProps = exports.PrimaryKeyProp = exports.EntityRepositoryType = void 0;
-const enums_1 = require("./enums");
-const Reference_1 = require("./entity/Reference");
-const EntityHelper_1 = require("./entity/EntityHelper");
-const Utils_1 = require("./utils/Utils");
-const EntityComparator_1 = require("./utils/EntityComparator");
-exports.EntityRepositoryType = Symbol('EntityRepositoryType');
-exports.PrimaryKeyProp = Symbol('PrimaryKeyProp');
-exports.OptionalProps = Symbol('OptionalProps');
-exports.EagerProps = Symbol('EagerProps');
-exports.HiddenProps = Symbol('HiddenProps');
-exports.Config = Symbol('Config');
-class EntityMetadata {
+import { ReferenceKind, } from './enums.js';
+import { Reference } from './entity/Reference.js';
+import { EntityHelper } from './entity/EntityHelper.js';
+import { Utils } from './utils/Utils.js';
+import { EntityComparator } from './utils/EntityComparator.js';
+export const EntityRepositoryType = Symbol('EntityRepositoryType');
+export const PrimaryKeyProp = Symbol('PrimaryKeyProp');
+export const OptionalProps = Symbol('OptionalProps');
+export const EagerProps = Symbol('EagerProps');
+export const HiddenProps = Symbol('HiddenProps');
+export const Config = Symbol('Config');
+export class EntityMetadata {
     static counter = 0;
     _id = 1000 * EntityMetadata.counter++; // keep the id >= 1000 to allow computing cache keys by simple addition
     propertyOrder = new Map();
@@ -35,7 +32,7 @@ class EntityMetadata {
         }
         this.properties[prop.name] = prop;
         this.propertyOrder.set(prop.name, this.props.length);
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (sync) {
             this.sync();
         }
@@ -43,7 +40,7 @@ class EntityMetadata {
     removeProperty(name, sync = true) {
         delete this.properties[name];
         this.propertyOrder.delete(name);
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (sync) {
             this.sync();
         }
@@ -64,11 +61,11 @@ class EntityMetadata {
         this.root ??= this;
         const props = Object.values(this.properties).sort((a, b) => this.propertyOrder.get(a.name) - this.propertyOrder.get(b.name));
         this.props = [...props.filter(p => p.primary), ...props.filter(p => !p.primary)];
-        this.relations = this.props.filter(prop => typeof prop.kind !== 'undefined' && prop.kind !== enums_1.ReferenceKind.SCALAR && prop.kind !== enums_1.ReferenceKind.EMBEDDED);
+        this.relations = this.props.filter(prop => typeof prop.kind !== 'undefined' && prop.kind !== ReferenceKind.SCALAR && prop.kind !== ReferenceKind.EMBEDDED);
         this.bidirectionalRelations = this.relations.filter(prop => prop.mappedBy || prop.inversedBy);
         this.uniqueProps = this.props.filter(prop => prop.unique);
         this.getterProps = this.props.filter(prop => prop.getter);
-        this.comparableProps = this.props.filter(prop => EntityComparator_1.EntityComparator.isComparable(prop, this));
+        this.comparableProps = this.props.filter(prop => EntityComparator.isComparable(prop, this));
         this.hydrateProps = this.props.filter(prop => {
             // `prop.userDefined` is either `undefined` or `false`
             const discriminator = this.root.discriminatorColumn === prop.name && prop.userDefined === false;
@@ -78,14 +75,14 @@ class EntityMetadata {
         });
         this.trackingProps = this.hydrateProps
             .filter(prop => !prop.getter && !prop.setter && prop.trackChanges !== false)
-            .filter(prop => ![enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind))
+            .filter(prop => ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind))
             .filter(prop => !prop.serializedPrimaryKey);
         this.selfReferencing = this.relations.some(prop => [this.className, this.root.className].includes(prop.targetMeta?.root.className ?? prop.type));
         this.hasUniqueProps = this.uniques.length + this.uniqueProps.length > 0;
         this.virtual = !!this.expression;
         if (config) {
             for (const prop of this.props) {
-                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => Utils_1.Utils.isString(item))) {
+                if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => Utils.isString(item))) {
                     const name = config.getNamingStrategy().indexName(this.tableName, prop.fieldNames, 'check');
                     const exists = this.checks.findIndex(check => check.name === name);
                     if (exists !== -1) {
@@ -99,11 +96,11 @@ class EntityMetadata {
                 }
             }
         }
-        this.checks = Utils_1.Utils.removeDuplicates(this.checks);
-        this.indexes = Utils_1.Utils.removeDuplicates(this.indexes);
-        this.uniques = Utils_1.Utils.removeDuplicates(this.uniques);
-        for (const hook of Utils_1.Utils.keys(this.hooks)) {
-            this.hooks[hook] = Utils_1.Utils.removeDuplicates(this.hooks[hook]);
+        this.checks = Utils.removeDuplicates(this.checks);
+        this.indexes = Utils.removeDuplicates(this.indexes);
+        this.uniques = Utils.removeDuplicates(this.uniques);
+        for (const hook of Utils.keys(this.hooks)) {
+            this.hooks[hook] = Utils.removeDuplicates(this.hooks[hook]);
         }
         if (this.virtual) {
             this.readonly = true;
@@ -112,8 +109,8 @@ class EntityMetadata {
             this.props.forEach(prop => this.initIndexes(prop));
         }
         this.definedProperties = this.trackingProps.reduce((o, prop) => {
-            const isCollection = [enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind);
-            const isReference = [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
+            const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
+            const isReference = [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
             if (isReference) {
                 // eslint-disable-next-line @typescript-eslint/no-this-alias
                 const meta = this;
@@ -124,17 +121,20 @@ class EntityMetadata {
                     set(val) {
                         const wrapped = this.__helper;
                         const hydrator = wrapped.hydrator;
-                        const entity = Reference_1.Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
-                        const old = Reference_1.Reference.unwrapReference(wrapped.__data[prop.name]);
-                        wrapped.__data[prop.name] = Reference_1.Reference.wrapReference(val, prop);
+                        const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
+                        const old = Reference.unwrapReference(wrapped.__data[prop.name]);
+                        if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
+                            old[prop.inversedBy].removeWithoutPropagation(this);
+                        }
+                        wrapped.__data[prop.name] = 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.getPrimaryKeyValues(val, prop.targetMeta.primaryKeys, true);
                         }
                         else {
                             wrapped.__touched = !hydrator.isRunning();
                         }
-                        EntityHelper_1.EntityHelper.propagate(meta, entity, this, prop, Reference_1.Reference.unwrapReference(val), old);
+                        EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
                     },
                     enumerable: true,
                     configurable: true,
@@ -163,14 +163,14 @@ class EntityMetadata {
     initIndexes(prop) {
         const simpleIndex = this.indexes.find(index => index.properties === prop.name && !index.options && !index.type && !index.expression);
         const simpleUnique = this.uniques.find(index => index.properties === prop.name && !index.options);
-        const owner = prop.kind === enums_1.ReferenceKind.MANY_TO_ONE;
+        const owner = prop.kind === ReferenceKind.MANY_TO_ONE;
         if (!prop.index && simpleIndex) {
-            Utils_1.Utils.defaultValue(simpleIndex, 'name', true);
+            Utils.defaultValue(simpleIndex, 'name', true);
             prop.index = simpleIndex.name;
             this.indexes.splice(this.indexes.indexOf(simpleIndex), 1);
         }
         if (!prop.unique && simpleUnique) {
-            Utils_1.Utils.defaultValue(simpleUnique, 'name', true);
+            Utils.defaultValue(simpleUnique, 'name', true);
             prop.unique = simpleUnique.name;
             this.uniques.splice(this.uniques.indexOf(simpleUnique), 1);
         }
@@ -178,7 +178,7 @@ class EntityMetadata {
             this.indexes.push({ properties: prop.name });
             prop.index = false;
         }
-        /* istanbul ignore next */
+        /* v8 ignore next 4 */
         if (owner && prop.fieldNames.length > 1 && prop.unique) {
             this.uniques.push({ properties: prop.name });
             prop.unique = false;
@@ -189,4 +189,3 @@ class EntityMetadata {
         return this;
     }
 }
-exports.EntityMetadata = EntityMetadata;

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

@@ -1,5 +1,5 @@
 import { inspect } from 'node:util';
-import type { EntityData, EntityMetadata, EntityDictionary, Primary } from '../typings';
+import type { EntityData, EntityMetadata, EntityDictionary, Primary } from '../typings.js';
 export declare class ChangeSet<T extends object> {
     entity: T;
     type: ChangeSetType;

package/unit-of-work/ChangeSet.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeSetType = exports.ChangeSet = void 0;
-const node_util_1 = require("node:util");
-const wrap_1 = require("../entity/wrap");
-const Utils_1 = require("../utils/Utils");
-class ChangeSet {
+import { inspect } from 'node:util';
+import { helper } from '../entity/wrap.js';
+import { Utils } from '../utils/Utils.js';
+export class ChangeSet {
     entity;
     type;
     payload;
@@ -19,11 +16,11 @@ class ChangeSet {
         this.name = meta.className;
         this.rootName = meta.root.className;
         this.collection = meta.root.collection;
-        this.schema = (0, wrap_1.helper)(entity).__schema ?? meta.root.schema;
+        this.schema = helper(entity).__schema ?? meta.root.schema;
     }
     getPrimaryKey(object = false) {
         if (!this.originalEntity) {
-            this.primaryKey ??= (0, wrap_1.helper)(this.entity).getPrimaryKey(true);
+            this.primaryKey ??= helper(this.entity).getPrimaryKey(true);
         }
         else if (this.meta.compositePK) {
             this.primaryKey = this.meta.primaryKeys.map(pk => this.originalEntity[pk]);
@@ -40,31 +37,30 @@ class ChangeSet {
             });
         }
         if (object && this.primaryKey != null) {
-            return Utils_1.Utils.primaryKeyToObject(this.meta, this.primaryKey);
+            return Utils.primaryKeyToObject(this.meta, this.primaryKey);
         }
         return this.primaryKey ?? null;
     }
     getSerializedPrimaryKey() {
-        this.serializedPrimaryKey ??= (0, wrap_1.helper)(this.entity).getSerializedPrimaryKey();
+        this.serializedPrimaryKey ??= helper(this.entity).getSerializedPrimaryKey();
         return this.serializedPrimaryKey;
     }
     /** @ignore */
-    [node_util_1.inspect.custom](depth = 2) {
+    [inspect.custom](depth = 2) {
         const object = { ...this };
         const hidden = ['meta', 'serializedPrimaryKey'];
         hidden.forEach(k => delete object[k]);
-        const ret = (0, node_util_1.inspect)(object, { depth });
+        const ret = inspect(object, { depth });
         const name = `${this.constructor.name}<${this.meta.className}>`;
-        /* istanbul ignore next */
+        /* v8 ignore next */
         return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }
 }
-exports.ChangeSet = ChangeSet;
-var ChangeSetType;
+export var ChangeSetType;
 (function (ChangeSetType) {
     ChangeSetType["CREATE"] = "create";
     ChangeSetType["UPDATE"] = "update";
     ChangeSetType["DELETE"] = "delete";
     ChangeSetType["UPDATE_EARLY"] = "update_early";
     ChangeSetType["DELETE_EARLY"] = "delete_early";
-})(ChangeSetType || (exports.ChangeSetType = ChangeSetType = {}));
+})(ChangeSetType || (ChangeSetType = {}));

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

@@ -1,10 +1,11 @@
-import { type Configuration } from '../utils/Configuration';
-import type { MetadataStorage } from '../metadata';
-import type { AnyEntity } from '../typings';
-import { ChangeSet } from './ChangeSet';
-import { type Collection, type EntityValidator } from '../entity';
-import type { Platform } from '../platforms';
-import type { EntityManager } from '../EntityManager';
+import { type Configuration } from '../utils/Configuration.js';
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+import type { AnyEntity } from '../typings.js';
+import { ChangeSet } from './ChangeSet.js';
+import { type EntityValidator } from '../entity/EntityValidator.js';
+import { type Collection } from '../entity/Collection.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetComputer {
     private readonly validator;
     private readonly collectionUpdates;