@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

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 */
         if (sync) {
             this.sync();
         }
@@ -43,17 +40,34 @@ class EntityMetadata {
     removeProperty(name, sync = true) {
         delete this.properties[name];
         this.propertyOrder.delete(name);
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (sync) {
             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 ([ReferenceKind.MANY_TO_ONE, 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;
     }
@@ -64,28 +78,35 @@ 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.validateProps = this.props.filter(prop => {
+            if (prop.inherited || (prop.persist === false && prop.userDefined !== false)) {
+                return false;
+            }
+            return prop.kind === ReferenceKind.SCALAR && ['string', 'number', 'boolean', 'Date'].includes(prop.type);
+        });
         this.hydrateProps = this.props.filter(prop => {
             // `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
-            .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 => !prop.serializedPrimaryKey);
-        this.selfReferencing = this.relations.some(prop => [this.className, this.root.className].includes(prop.targetMeta?.root.className ?? prop.type));
+        this.trackingProps = this.hydrateProps.filter(prop => {
+            return !prop.getter && !prop.setter && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind);
+        });
+        this.selfReferencing = this.relations.some(prop => {
+            return [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 => typeof item === 'string')) {
                     const name = config.getNamingStrategy().indexName(this.tableName, prop.fieldNames, 'check');
                     const exists = this.checks.findIndex(check => check.name === name);
                     if (exists !== -1) {
@@ -99,11 +120,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 +133,7 @@ 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 isReference = (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
             if (isReference) {
                 // eslint-disable-next-line @typescript-eslint/no-this-alias
                 const meta = this;
@@ -124,53 +144,36 @@ 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, 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,
                 };
             }
-            if (prop.inherited || prop.primary || isCollection || prop.persist === false || prop.trackChanges === false || isReference || prop.embedded) {
-                return o;
-            }
-            o[prop.name] = {
-                get() {
-                    return this.__helper.__data[prop.name];
-                },
-                set(val) {
-                    if (typeof val === 'object' && !!val && '__raw' in val) {
-                        val.assign();
-                    }
-                    this.__helper.__data[prop.name] = val;
-                    this.__helper.__touched = !this.__helper.hydrator.isRunning();
-                },
-                enumerable: true,
-                configurable: true,
-            };
             return o;
         }, { __gettersDefined: { value: true, enumerable: false } });
     }
     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 +181,7 @@ class EntityMetadata {
             this.indexes.push({ properties: prop.name });
             prop.index = false;
         }
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (owner && prop.fieldNames.length > 1 && prop.unique) {
             this.uniques.push({ properties: prop.name });
             prop.unique = false;
@@ -189,4 +192,3 @@ class EntityMetadata {
         return this;
     }
 }
-exports.EntityMetadata = EntityMetadata;

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

@@ -1,5 +1,4 @@
-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;
@@ -10,8 +9,6 @@ export declare class ChangeSet<T extends object> {
     constructor(entity: T, type: ChangeSetType, payload: EntityDictionary<T>, meta: EntityMetadata<T>);
     getPrimaryKey(object?: boolean): Primary<T> | null;
     getSerializedPrimaryKey(): string | null;
-    /** @ignore */
-    [inspect.custom](depth?: number): string;
 }
 export interface ChangeSet<T> {
     name: string;

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 { helper } from '../entity/wrap.js';
+import { Utils } from '../utils/Utils.js';
+import { inspect } from '../logging/inspect.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) {
+    [Symbol.for('nodejs.util.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,19 +1,18 @@
-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 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;
     private readonly metadata;
     private readonly platform;
     private readonly config;
     private readonly em;
     private readonly comparator;
-    constructor(validator: EntityValidator, collectionUpdates: Set<Collection<AnyEntity>>, metadata: MetadataStorage, platform: Platform, config: Configuration, em: EntityManager);
+    constructor(collectionUpdates: Set<Collection<AnyEntity>>, metadata: MetadataStorage, platform: Platform, config: Configuration, em: EntityManager);
     computeChangeSet<T extends object>(entity: T): ChangeSet<T> | null;
     /**
      * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.

package/unit-of-work/ChangeSetComputer.js

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeSetComputer = void 0;
-const Utils_1 = require("../utils/Utils");
-const ChangeSet_1 = require("./ChangeSet");
-const entity_1 = require("../entity");
-const enums_1 = require("../enums");
-class ChangeSetComputer {
-    validator;
+import { Utils } from '../utils/Utils.js';
+import { ChangeSet, ChangeSetType } from './ChangeSet.js';
+import { helper } from '../entity/wrap.js';
+import { validateEntity } from '../entity/validators.js';
+import { ReferenceKind } from '../enums.js';
+export class ChangeSetComputer {
     collectionUpdates;
     metadata;
     platform;
     config;
     em;
     comparator;
-    constructor(validator, collectionUpdates, metadata, platform, config, em) {
-        this.validator = validator;
+    constructor(collectionUpdates, metadata, platform, config, em) {
         this.collectionUpdates = collectionUpdates;
         this.metadata = metadata;
         this.platform = platform;
@@ -27,33 +23,34 @@ class ChangeSetComputer {
         if (meta.readonly) {
             return null;
         }
-        const wrapped = (0, entity_1.helper)(entity);
-        const type = wrapped.__originalEntityData ? ChangeSet_1.ChangeSetType.UPDATE : ChangeSet_1.ChangeSetType.CREATE;
+        const wrapped = helper(entity);
+        const type = wrapped.__originalEntityData ? ChangeSetType.UPDATE : ChangeSetType.CREATE;
         const map = new Map();
         // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
         // to the `map` as we want to apply those only if something else changed.
-        if (type === ChangeSet_1.ChangeSetType.CREATE) { // run update hooks only after we know there are other changes
+        if (type === ChangeSetType.CREATE) { // run update hooks only after we know there are other changes
             for (const prop of meta.hydrateProps) {
                 this.processPropertyInitializers(entity, prop, type, map);
             }
         }
-        if (type === ChangeSet_1.ChangeSetType.UPDATE && !wrapped.__initialized && !wrapped.isTouched()) {
-            return null;
+        if (type === ChangeSetType.UPDATE && !wrapped.__initialized) {
+            const data = this.comparator.prepareEntity(entity);
+            if (Utils.equals(data, wrapped.__originalEntityData)) {
+                return null;
+            }
         }
-        const changeSet = new ChangeSet_1.ChangeSet(entity, type, this.computePayload(entity), meta);
+        const changeSet = new ChangeSet(entity, type, this.computePayload(entity), meta);
         changeSet.originalEntity = wrapped.__originalEntityData;
-        if (this.config.get('validate')) {
-            this.validator.validate(changeSet.entity, changeSet.payload, meta);
-        }
         for (const prop of meta.relations.filter(prop => prop.persist !== false || prop.userDefined === false)) {
             this.processProperty(changeSet, prop);
         }
-        if (changeSet.type === ChangeSet_1.ChangeSetType.UPDATE && !Utils_1.Utils.hasObjectKeys(changeSet.payload)) {
+        if (changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload)) {
             return null;
         }
+        validateEntity(changeSet.entity, meta);
         // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
         // to the `map` as we want to apply those only if something else changed.
-        if (type === ChangeSet_1.ChangeSetType.UPDATE) {
+        if (type === ChangeSetType.UPDATE) {
             for (const prop of meta.hydrateProps) {
                 this.processPropertyInitializers(entity, prop, type, map);
             }
@@ -66,7 +63,7 @@ class ChangeSetComputer {
             }
             // Recompute the changeset, we need to merge this as here we ignore relations.
             const diff = this.computePayload(entity, true);
-            Utils_1.Utils.merge(changeSet.payload, diff);
+            Utils.merge(changeSet.payload, diff);
         }
         return changeSet;
     }
@@ -75,17 +72,17 @@ class ChangeSetComputer {
      */
     processPropertyInitializers(entity, prop, type, map, nested) {
         if (prop.onCreate
-            && type === ChangeSet_1.ChangeSetType.CREATE
+            && type === ChangeSetType.CREATE
             && (entity[prop.name] == null
-                || (Utils_1.Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
+                || (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
             entity[prop.name] = prop.onCreate(entity, this.em);
         }
-        if (prop.onUpdate && type === ChangeSet_1.ChangeSetType.UPDATE) {
+        if (prop.onUpdate && type === ChangeSetType.UPDATE) {
             const pairs = map.get(entity) ?? [];
             pairs.push([prop.name, prop.onUpdate(entity, this.em)]);
             map.set(entity, pairs);
         }
-        if (prop.kind === enums_1.ReferenceKind.EMBEDDED && entity[prop.name]) {
+        if (prop.kind === ReferenceKind.EMBEDDED && entity[prop.name]) {
             for (const embeddedProp of prop.targetMeta.hydrateProps) {
                 this.processPropertyInitializers(entity[prop.name], embeddedProp, type, map, nested || prop.object);
             }
@@ -93,7 +90,7 @@ class ChangeSetComputer {
     }
     computePayload(entity, ignoreUndefined = false) {
         const data = this.comparator.prepareEntity(entity);
-        const wrapped = (0, entity_1.helper)(entity);
+        const wrapped = helper(entity);
         const entityName = wrapped.__meta.className;
         const originalEntityData = wrapped.__originalEntityData;
         if (!wrapped.__initialized) {
@@ -106,7 +103,7 @@ class ChangeSetComputer {
             const comparator = this.comparator.getEntityComparator(entityName);
             const diff = comparator(originalEntityData, data);
             if (ignoreUndefined) {
-                Utils_1.Utils.keys(diff)
+                Utils.keys(diff)
                     .filter(k => diff[k] === undefined)
                     .forEach(k => delete diff[k]);
             }
@@ -116,38 +113,39 @@ class ChangeSetComputer {
     }
     processProperty(changeSet, prop, target) {
         if (!target) {
-            const targets = Utils_1.Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
+            const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
             targets.forEach(([t]) => this.processProperty(changeSet, prop, t));
             return;
         }
-        if (Utils_1.Utils.isCollection(target)) { // m:n or 1:m
+        if (Utils.isCollection(target)) { // m:n or 1:m
             this.processToMany(prop, changeSet);
         }
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
             this.processToOne(prop, changeSet);
         }
     }
     processToOne(prop, changeSet) {
-        const isToOneOwner = prop.kind === enums_1.ReferenceKind.MANY_TO_ONE || (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner);
+        const isToOneOwner = prop.kind === ReferenceKind.MANY_TO_ONE || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner);
         if (!isToOneOwner || prop.mapToPk) {
             return;
         }
-        const targets = Utils_1.Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
+        const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
         targets.forEach(([target, idx]) => {
             if (!target.__helper.hasPrimaryKey()) {
-                Utils_1.Utils.setPayloadProperty(changeSet.payload, this.metadata.find(changeSet.name), prop, target.__helper.__identifier, idx);
+                Utils.setPayloadProperty(changeSet.payload, this.metadata.find(changeSet.name), prop, target.__helper.__identifier, idx);
             }
         });
     }
     processToMany(prop, changeSet) {
         const target = changeSet.entity[prop.name];
-        if (!target.isDirty() && changeSet.type !== ChangeSet_1.ChangeSetType.CREATE) {
+        if (!target.isDirty() && changeSet.type !== ChangeSetType.CREATE) {
             return;
         }
-        this.collectionUpdates.add(target);
+        if (target.isDirty()) {
+            this.collectionUpdates.add(target);
+        }
         if (prop.owner && !this.platform.usesPivotTable()) {
             changeSet.payload[prop.name] = target.getItems(false).map((item) => item.__helper.__identifier ?? item.__helper.getPrimaryKey());
         }
     }
 }
-exports.ChangeSetComputer = ChangeSetComputer;

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

@@ -1,28 +1,30 @@
-import type { MetadataStorage } from '../metadata';
-import type { Dictionary, EntityDictionary, EntityMetadata, IHydrator } from '../typings';
-import { type EntityFactory, type EntityValidator } from '../entity';
-import { type ChangeSet } from './ChangeSet';
-import { type Configuration } from '../utils/Configuration';
-import type { DriverMethodOptions, IDatabaseDriver } from '../drivers';
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+import type { Dictionary, EntityDictionary, EntityMetadata, IHydrator } from '../typings.js';
+import { type EntityFactory } from '../entity/EntityFactory.js';
+import { type ChangeSet } from './ChangeSet.js';
+import { type Configuration } from '../utils/Configuration.js';
+import type { DriverMethodOptions, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
+import type { EntityManager } from '../EntityManager.js';
 export declare class ChangeSetPersister {
     private readonly driver;
     private readonly metadata;
     private readonly hydrator;
     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, 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>;
     private runForEachSchema;
+    private validateRequired;
     private processProperties;
     private persistNewEntity;
     private persistNewEntities;
-    private propagateSchemaFromMetadata;
+    private prepareOptions;
     private persistNewEntitiesBatch;
     private persistManagedEntity;
     private persistManagedEntities;