@mikro-orm/core 7.0.0-dev.12 → 7.0.0-dev.120

package/typings.js

@@ -25,38 +25,56 @@ export class EntityMetadata {
         this.referencingProperties = [];
         this.concurrencyCheckKeys = new Set();
         Object.assign(this, meta);
-    }
-    addProperty(prop, sync = true) {
-        if (prop.pivotTable && !prop.pivotEntity) {
-            prop.pivotEntity = prop.pivotTable;
+        const name = meta.className ?? meta.name;
+        if (!this.class && name) {
+            this.class = ({ [name]: class {
+                } })[name];
         }
+    }
+    addProperty(prop) {
         this.properties[prop.name] = prop;
         this.propertyOrder.set(prop.name, this.props.length);
-        /* v8 ignore next 3 */
-        if (sync) {
-            this.sync();
-        }
+        this.sync();
     }
     removeProperty(name, sync = true) {
         delete this.properties[name];
         this.propertyOrder.delete(name);
-        /* v8 ignore next 3 */
         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;
     }
     set tableName(name) {
         this.collection = name;
     }
+    get uniqueName() {
+        return this.tableName + '_' + this._id;
+    }
     sync(initIndexes = false, config) {
         this.root ??= this;
         const props = Object.values(this.properties).sort((a, b) => this.propertyOrder.get(a.name) - this.propertyOrder.get(b.name));
@@ -66,23 +84,30 @@ export class EntityMetadata {
         this.uniqueProps = this.props.filter(prop => prop.unique);
         this.getterProps = this.props.filter(prop => prop.getter);
         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 => ![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.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.root.uniqueName === prop.targetMeta?.root.uniqueName;
+        });
         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.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) {
@@ -109,8 +134,7 @@ export class EntityMetadata {
             this.props.forEach(prop => this.initIndexes(prop));
         }
         this.definedProperties = this.trackingProps.reduce((o, prop) => {
-            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;
+            const isReference = (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
             if (isReference) {
                 // eslint-disable-next-line @typescript-eslint/no-this-alias
                 const meta = this;
@@ -129,10 +153,7 @@ export class EntityMetadata {
                         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.getPrimaryKeyValues(val, prop.targetMeta.primaryKeys, true);
-                        }
-                        else {
-                            wrapped.__touched = !hydrator.isRunning();
+                            wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(val, prop.targetMeta, true);
                         }
                         EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
                     },
@@ -140,23 +161,6 @@ export class EntityMetadata {
                     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 } });
     }
@@ -178,7 +182,7 @@ export class EntityMetadata {
             this.indexes.push({ properties: prop.name });
             prop.index = false;
         }
-        /* v8 ignore next 4 */
+        /* v8 ignore next */
         if (owner && prop.fieldNames.length > 1 && prop.unique) {
             this.uniques.push({ properties: prop.name });
             prop.unique = false;
@@ -188,4 +192,8 @@ export class EntityMetadata {
     clone() {
         return this;
     }
+    /** @ignore */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return `[${this.constructor.name}<${this.className}>]`;
+    }
 }

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

@@ -1,4 +1,3 @@
-import { inspect } from 'node:util';
 import type { EntityData, EntityMetadata, EntityDictionary, Primary } from '../typings.js';
 export declare class ChangeSet<T extends object> {
     entity: T;
@@ -10,13 +9,10 @@ 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;
-    rootName: string;
-    collection: string;
+    meta: EntityMetadata<T>;
+    rootMeta: EntityMetadata<T>;
     schema?: string;
     type: ChangeSetType;
     entity: T;

package/unit-of-work/ChangeSet.js

@@ -1,6 +1,6 @@
-import { inspect } from 'node:util';
 import { helper } from '../entity/wrap.js';
 import { Utils } from '../utils/Utils.js';
+import { inspect } from '../logging/inspect.js';
 export class ChangeSet {
     entity;
     type;
@@ -13,9 +13,8 @@ export class ChangeSet {
         this.type = type;
         this.payload = payload;
         this.meta = meta;
-        this.name = meta.className;
-        this.rootName = meta.root.className;
-        this.collection = meta.root.collection;
+        this.meta = meta;
+        this.rootMeta = meta.root;
         this.schema = helper(entity).__schema ?? meta.root.schema;
     }
     getPrimaryKey(object = false) {
@@ -46,7 +45,7 @@ export class ChangeSet {
         return this.serializedPrimaryKey;
     }
     /** @ignore */
-    [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]);

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

@@ -2,19 +2,17 @@ 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;
     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,17 +1,16 @@
 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 {
-    validator;
     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;
@@ -20,7 +19,7 @@ export class ChangeSetComputer {
         this.comparator = this.config.getComparator(this.metadata);
     }
     computeChangeSet(entity) {
-        const meta = this.metadata.get(entity.constructor.name);
+        const meta = this.metadata.get(entity.constructor);
         if (meta.readonly) {
             return null;
         }
@@ -34,20 +33,21 @@ export class ChangeSetComputer {
                 this.processPropertyInitializers(entity, prop, type, map);
             }
         }
-        if (type === 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(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 === 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 === ChangeSetType.UPDATE) {
@@ -91,7 +91,7 @@ export class ChangeSetComputer {
     computePayload(entity, ignoreUndefined = false) {
         const data = this.comparator.prepareEntity(entity);
         const wrapped = helper(entity);
-        const entityName = wrapped.__meta.className;
+        const entityName = wrapped.__meta.class;
         const originalEntityData = wrapped.__originalEntityData;
         if (!wrapped.__initialized) {
             for (const prop of wrapped.__meta.primaryKeys) {
@@ -132,7 +132,7 @@ export class ChangeSetComputer {
         const targets = Utils.unwrapProperty(changeSet.entity, changeSet.meta, prop);
         targets.forEach(([target, idx]) => {
             if (!target.__helper.hasPrimaryKey()) {
-                Utils.setPayloadProperty(changeSet.payload, this.metadata.find(changeSet.name), prop, target.__helper.__identifier, idx);
+                Utils.setPayloadProperty(changeSet.payload, changeSet.meta, prop, target.__helper.__identifier, idx);
             }
         });
     }
@@ -141,7 +141,9 @@ export class ChangeSetComputer {
         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());
         }

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

@@ -1,29 +1,30 @@
 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 EntityValidator } from '../entity/EntityValidator.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;

package/unit-of-work/ChangeSetPersister.js

@@ -3,25 +3,25 @@ import { helper } from '../entity/wrap.js';
 import { ChangeSetType } from './ChangeSet.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
 import { Utils } from '../utils/Utils.js';
-import { OptimisticLockError } from '../errors.js';
+import { OptimisticLockError, ValidationError } from '../errors.js';
 import { ReferenceKind } from '../enums.js';
 export class ChangeSetPersister {
     driver;
     metadata;
     hydrator;
     factory;
-    validator;
     config;
+    em;
     platform;
     comparator;
     usesReturningStatement;
-    constructor(driver, metadata, hydrator, factory, validator, config) {
+    constructor(driver, metadata, hydrator, factory, 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();
@@ -30,7 +30,7 @@ export class ChangeSetPersister {
         if (!withSchema) {
             return this.runForEachSchema(changeSets, 'executeInserts', options);
         }
-        const meta = this.metadata.find(changeSets[0].name);
+        const meta = changeSets[0].meta;
         changeSets.forEach(changeSet => this.processProperties(changeSet));
         if (changeSets.length > 1 && this.config.get('useBatchInserts', this.platform.usesBatchInserts())) {
             return this.persistNewEntities(meta, changeSets, options);
@@ -43,7 +43,7 @@ export class ChangeSetPersister {
         if (!withSchema) {
             return this.runForEachSchema(changeSets, 'executeUpdates', options, batched);
         }
-        const meta = this.metadata.find(changeSets[0].name);
+        const meta = changeSets[0].meta;
         changeSets.forEach(changeSet => this.processProperties(changeSet));
         if (batched && changeSets.length > 1 && this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
             return this.persistManagedEntities(meta, changeSets, options);
@@ -62,8 +62,8 @@ export 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);
-            await this.driver.nativeDelete(meta.root.className, { [pk]: { $in: pks } }, options);
+            options = this.prepareOptions(meta, options);
+            await this.driver.nativeDelete(meta.root.class, { [pk]: { $in: pks } }, options);
         }
     }
     async runForEachSchema(changeSets, method, options, ...args) {
@@ -79,21 +79,40 @@ export class ChangeSetPersister {
             await this[method](group, ...args, options, true);
         }
     }
+    validateRequired(entity) {
+        const wrapped = helper(entity);
+        for (const prop of wrapped.__meta.props) {
+            if (!prop.nullable &&
+                !prop.autoincrement &&
+                !prop.default &&
+                !prop.defaultRaw &&
+                !prop.onCreate &&
+                !prop.generated &&
+                !prop.embedded &&
+                ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
+                prop.name !== wrapped.__meta.root.discriminatorColumn &&
+                prop.type !== 'ObjectId' &&
+                prop.persist !== false &&
+                entity[prop.name] == null) {
+                throw ValidationError.propertyRequired(entity, prop);
+            }
+        }
+    }
     processProperties(changeSet) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         for (const prop of meta.relations) {
             this.processProperty(changeSet, prop);
         }
         if (changeSet.type === ChangeSetType.CREATE && this.config.get('validateRequired')) {
-            this.validator.validateRequired(changeSet.entity);
+            this.validateRequired(changeSet.entity);
         }
     }
     async persistNewEntity(meta, changeSet, options) {
         const wrapped = 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);
+        const res = await this.driver.nativeInsertMany(meta.class, [changeSet.payload], options);
         if (!wrapped.hasPrimaryKey()) {
             this.mapPrimaryKey(meta, res.insertId, changeSet);
         }
@@ -116,19 +135,21 @@ export class ChangeSetPersister {
             }
         }
     }
-    propagateSchemaFromMetadata(meta, options, additionalOptions) {
+    prepareOptions(meta, options, additionalOptions) {
+        const loggerContext = 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,
         });
-        const res = await this.driver.nativeInsertMany(meta.className, changeSets.map(cs => cs.payload), options);
+        const res = await this.driver.nativeInsertMany(meta.class, changeSets.map(cs => cs.payload), options);
         for (let i = 0; i < changeSets.length; i++) {
             const changeSet = changeSets[i];
             const wrapped = helper(changeSet.entity);
@@ -146,7 +167,7 @@ export class ChangeSetPersister {
         }
     }
     async persistManagedEntity(changeSet, options) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         const res = await this.updateEntity(meta, changeSet, options);
         this.checkOptimisticLock(meta, changeSet, res);
         this.mapReturnedValues(changeSet.entity, changeSet.payload, res.row, meta);
@@ -175,7 +196,7 @@ export 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,
         });
@@ -187,7 +208,7 @@ export class ChangeSetPersister {
             cond.push(where);
             payload.push(changeSet.payload);
         }
-        const res = await this.driver.nativeUpdateMany(meta.className, cond, payload, options);
+        const res = await this.driver.nativeUpdateMany(meta.class, cond, payload, options);
         const map = new Map();
         res.rows?.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
         for (const changeSet of changeSets) {
@@ -235,17 +256,17 @@ export 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)) {
-            return this.driver.nativeUpdate(changeSet.name, cond, changeSet.payload, options);
+            return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
         }
         if (meta.versionProperty) {
             cond[meta.versionProperty] = this.platform.quoteVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
         }
         this.checkConcurrencyKeys(meta, changeSet, cond);
-        return this.driver.nativeUpdate(changeSet.name, cond, changeSet.payload, options);
+        return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
     }
     async checkOptimisticLocks(meta, changeSets, options) {
         if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
@@ -262,10 +283,10 @@ export 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);
+        const res = await this.driver.find(meta.root.class, { $or }, options);
         if (res.length !== changeSets.length) {
             const compare = (a, b, keys) => keys.every(k => a[k] === b[k]);
             const entity = changeSets.find(cs => {
@@ -286,11 +307,22 @@ export class ChangeSetPersister {
     async reloadVersionValues(meta, changeSets, options) {
         const reloadProps = meta.versionProperty && !this.usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
         if (changeSets[0].type === ChangeSetType.CREATE) {
-            // do not reload things that already had a runtime value
-            meta.props
-                .filter(prop => prop.persist !== false && (prop.autoincrement || prop.generated || prop.defaultRaw))
-                .filter(prop => (changeSets[0].entity[prop.name] == null && prop.defaultRaw !== 'null') || isRaw(changeSets[0].entity[prop.name]))
-                .forEach(prop => reloadProps.push(prop));
+            for (const prop of meta.props) {
+                if (prop.persist === false) {
+                    continue;
+                }
+                if (isRaw(changeSets[0].entity[prop.name])) {
+                    reloadProps.push(prop);
+                    continue;
+                }
+                // do not reload things that already had a runtime value
+                if (changeSets[0].entity[prop.name] != null || prop.defaultRaw === 'null') {
+                    continue;
+                }
+                if (prop.autoincrement || prop.generated || prop.defaultRaw) {
+                    reloadProps.push(prop);
+                }
+            }
         }
         if (changeSets[0].type === ChangeSetType.UPDATE) {
             const returning = new Set();
@@ -321,12 +353,12 @@ export class ChangeSetPersister {
             }
             return val;
         });
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        options = this.prepareOptions(meta, options, {
             fields: Utils.unique(reloadProps.map(prop => prop.name)),
         });
-        const data = await this.driver.find(meta.className, { [pk]: { $in: pks } }, options);
+        const data = await this.driver.find(meta.class, { [pk]: { $in: pks } }, options);
         const map = new Map();
-        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, false, this.platform, true), item));
         for (const changeSet of changeSets) {
             const data = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
             this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);
@@ -334,7 +366,7 @@ export class ChangeSetPersister {
         }
     }
     processProperty(changeSet, prop) {
-        const meta = this.metadata.find(changeSet.name);
+        const meta = changeSet.meta;
         const value = changeSet.payload[prop.name]; // for inline embeddables
         if (value instanceof EntityIdentifier) {
             changeSet.payload[prop.name] = value.getValue();
@@ -367,7 +399,7 @@ export class ChangeSetPersister {
         if ((!this.usesReturningStatement && !upsert) || !row || !Utils.hasObjectKeys(row)) {
             return;
         }
-        const mapped = this.comparator.mapResult(meta.className, row);
+        const mapped = this.comparator.mapResult(meta, row);
         if (entity) {
             this.hydrator.hydrate(entity, meta, mapped, this.factory, 'full', false, true);
         }