@mikro-orm/core 7.0.0-dev.9 → 7.0.0-dev.90

package/unit-of-work/UnitOfWork.js

@@ -42,8 +42,8 @@ export class UnitOfWork {
         this.identityMap = new IdentityMap(this.platform.getDefaultSchemaName());
         this.eventManager = this.em.getEventManager();
         this.comparator = this.em.getComparator();
-        this.changeSetComputer = new ChangeSetComputer(this.em.getValidator(), this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
-        this.changeSetPersister = new ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.getValidator(), this.em.config);
+        this.changeSetComputer = new ChangeSetComputer(this.collectionUpdates, this.metadata, this.platform, this.em.config, this.em);
+        this.changeSetPersister = new ChangeSetPersister(this.em.getDriver(), this.metadata, this.em.config.getHydrator(this.metadata), this.em.getEntityFactory(), this.em.config, this.em);
     }
     merge(entity, visited) {
         const wrapped = helper(entity);
@@ -61,10 +61,43 @@ export class UnitOfWork {
         // as there can be some entity with already changed state that is not yet flushed
         if (wrapped.__initialized && (!visited || !wrapped.__originalEntityData)) {
             wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
-            wrapped.__touched = false;
         }
         this.cascade(entity, Cascade.MERGE, visited ?? new Set());
     }
+    /**
+     * Entity data can wary in its shape, e.g. we might get a deep relation graph with joined strategy, but for diffing,
+     * we need to normalize the shape, so relation values are only raw FKs. This method handles that.
+     * @internal
+     */
+    normalizeEntityData(meta, data) {
+        const forceUndefined = this.em.config.get('forceUndefined');
+        for (const key of Utils.keys(data)) {
+            const prop = meta.properties[key];
+            if (!prop) {
+                continue;
+            }
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+                data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+            }
+            else if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && Utils.isPlainObject(data[prop.name])) {
+                for (const p of prop.targetMeta.props) {
+                    /* v8 ignore next */
+                    const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
+                    data[prefix + p.name] = data[prop.name][p.name];
+                }
+                data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
+            }
+            if (prop.hydrate === false && prop.customType?.ensureComparable(meta, prop)) {
+                const converted = prop.customType.convertToJSValue(data[key], this.platform, { key, mode: 'hydration', force: true });
+                data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
+            }
+            if (forceUndefined) {
+                if (data[key] === null) {
+                    data[key] = undefined;
+                }
+            }
+        }
+    }
     /**
      * @internal
      */
@@ -82,31 +115,14 @@ export class UnitOfWork {
         wrapped.__em ??= this.em;
         wrapped.__managed = true;
         if (data && (options?.refresh || !wrapped.__originalEntityData)) {
+            this.normalizeEntityData(wrapped.__meta, data);
             for (const key of Utils.keys(data)) {
                 const prop = wrapped.__meta.properties[key];
-                if (!prop) {
-                    continue;
-                }
-                wrapped.__loadedProperties.add(key);
-                if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
-                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
-                }
-                else if (prop.kind === ReferenceKind.EMBEDDED && !prop.object && Utils.isPlainObject(data[prop.name])) {
-                    for (const p of prop.targetMeta.props) {
-                        /* v8 ignore next */
-                        const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
-                        data[prefix + p.name] = data[prop.name][p.name];
-                    }
-                    data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
-                }
-                if (forceUndefined) {
-                    if (data[key] === null) {
-                        data[key] = undefined;
-                    }
+                if (prop) {
+                    wrapped.__loadedProperties.add(key);
                 }
             }
             wrapped.__originalEntityData = data;
-            wrapped.__touched = false;
         }
         return entity;
     }
@@ -125,7 +141,7 @@ export class UnitOfWork {
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById(entityName, id, schema) {
+    getById(entityName, id, schema, convertCustomTypes) {
         if (id == null || (Array.isArray(id) && id.length === 0)) {
             return undefined;
         }
@@ -135,7 +151,16 @@ export class UnitOfWork {
             hash = '' + id;
         }
         else {
-            const keys = Array.isArray(id) ? Utils.flatten(id) : [id];
+            let keys = Array.isArray(id) ? Utils.flatten(id) : [id];
+            keys = meta.getPrimaryProps(true).map((p, i) => {
+                if (!convertCustomTypes && p.customType) {
+                    return p.customType.convertToDatabaseValue(keys[i], this.platform, {
+                        key: p.name,
+                        mode: 'hydration',
+                    });
+                }
+                return keys[i];
+            });
             hash = Utils.getPrimaryKeyHash(keys);
         }
         schema ??= meta.schema ?? this.em.config.getSchema();
@@ -185,10 +210,8 @@ export class UnitOfWork {
         if (this.queuedActions.has(meta.className) || this.queuedActions.has(meta.root.className)) {
             return true;
         }
-        for (const entity of this.identityMap.getStore(meta).values()) {
-            if (helper(entity).__initialized && helper(entity).isTouched()) {
-                return true;
-            }
+        if (meta.discriminatorMap && Object.values(meta.discriminatorMap).some(v => this.queuedActions.has(v))) {
+            return true;
         }
         return false;
     }
@@ -209,7 +232,6 @@ export class UnitOfWork {
         this.changeSets.set(entity, cs);
         this.persistStack.delete(entity);
         wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
-        wrapped.__touched = false;
     }
     recomputeSingleChangeSet(entity) {
         const changeSet = this.changeSets.get(entity);
@@ -220,7 +242,6 @@ export class UnitOfWork {
         if (cs && !this.checkUniqueProps(cs)) {
             Object.assign(changeSet.payload, cs.payload);
             helper(entity).__originalEntityData = this.comparator.prepareEntity(entity);
-            helper(entity).__touched = false;
         }
     }
     persist(entity, visited, options = {}) {
@@ -303,17 +324,21 @@ export class UnitOfWork {
                 cs.entity.__helper.__processing = true;
             }
             await this.eventManager.dispatchEvent(EventType.onFlush, { em: this.em, uow: this });
+            this.filterCollectionUpdates();
             // nothing to do, do not start transaction
             if (this.changeSets.size === 0 && this.collectionUpdates.size === 0 && this.extraUpdates.size === 0) {
-                return void (await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this }));
+                await this.eventManager.dispatchEvent(EventType.afterFlush, { em: this.em, uow: this });
+                return;
             }
             const groups = this.getChangeSetGroups();
             const platform = this.em.getPlatform();
             const runInTransaction = !this.em.isInTransaction() && platform.supportsTransactions() && this.em.config.get('implicitTransactions');
             if (runInTransaction) {
+                const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
                 await this.em.getConnection('write').transactional(trx => this.persistToDatabase(groups, trx), {
                     ctx: oldTx,
                     eventBroadcaster: new TransactionEventBroadcaster(this.em),
+                    loggerContext,
                 });
             }
             else {
@@ -369,7 +394,6 @@ export class UnitOfWork {
         }
         delete wrapped.__identifier;
         delete wrapped.__originalEntityData;
-        wrapped.__touched = false;
         wrapped.__managed = false;
     }
     computeChangeSets() {
@@ -379,14 +403,14 @@ export class UnitOfWork {
             this.cascade(entity, Cascade.REMOVE, visited);
         }
         visited.clear();
-        for (const entity of this.persistStack) {
-            this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
-        }
         for (const entity of this.identityMap) {
             if (!this.removeStack.has(entity) && !this.persistStack.has(entity) && !this.orphanRemoveStack.has(entity)) {
                 this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
             }
         }
+        for (const entity of this.persistStack) {
+            this.cascade(entity, Cascade.PERSIST, visited, { checkRemoveStack: true });
+        }
         visited.clear();
         for (const entity of this.persistStack) {
             this.findNewEntities(entity, visited);
@@ -411,7 +435,7 @@ export class UnitOfWork {
         }
         for (const entity of this.removeStack) {
             const wrapped = helper(entity);
-            /* v8 ignore next 3 */
+            /* v8 ignore next */
             if (wrapped.__processing) {
                 continue;
             }
@@ -701,7 +725,7 @@ export class UnitOfWork {
         if (!meta.versionProperty) {
             throw OptimisticLockError.notVersioned(meta);
         }
-        if (!Utils.isDefined(version)) {
+        if (typeof version === 'undefined') {
             return;
         }
         const wrapped = helper(entity);
@@ -841,9 +865,16 @@ export class UnitOfWork {
         }
         await this.changeSetPersister.executeUpdates(changeSets, batched, { ctx });
         for (const changeSet of changeSets) {
-            helper(changeSet.entity).__originalEntityData = this.comparator.prepareEntity(changeSet.entity);
-            helper(changeSet.entity).__touched = false;
-            helper(changeSet.entity).__initialized = true;
+            const wrapped = helper(changeSet.entity);
+            wrapped.__originalEntityData = this.comparator.prepareEntity(changeSet.entity);
+            if (!wrapped.__initialized) {
+                for (const prop of changeSet.meta.relations) {
+                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && changeSet.entity[prop.name] == null) {
+                        changeSet.entity[prop.name] = Collection.create(changeSet.entity, prop.name, undefined, wrapped.isInitialized());
+                    }
+                }
+                wrapped.__initialized = true;
+            }
             await this.runHooks(EventType.afterUpdate, changeSet);
         }
     }
@@ -886,23 +917,34 @@ export class UnitOfWork {
         }
     }
     async commitCollectionUpdates(ctx) {
-        const collectionUpdates = [];
+        this.filterCollectionUpdates();
+        const loggerContext = Utils.merge({ id: this.em._id }, this.em.getLoggerContext({ disableContextResolution: true }));
+        await this.em.getDriver().syncCollections(this.collectionUpdates, {
+            ctx,
+            schema: this.em.schema,
+            loggerContext,
+        });
+        for (const coll of this.collectionUpdates) {
+            coll.takeSnapshot();
+        }
+    }
+    filterCollectionUpdates() {
         for (const coll of this.collectionUpdates) {
+            let skip = true;
             if (coll.property.owner || coll.getItems(false).filter(item => !item.__helper.__initialized).length > 0) {
                 if (this.platform.usesPivotTable()) {
-                    collectionUpdates.push(coll);
+                    skip = false;
                 }
             }
             else if (coll.property.kind === ReferenceKind.ONE_TO_MANY && coll.getSnapshot() === undefined) {
-                collectionUpdates.push(coll);
+                skip = false;
             }
             else if (coll.property.kind === ReferenceKind.MANY_TO_MANY && !coll.property.owner) {
-                collectionUpdates.push(coll);
+                skip = false;
+            }
+            if (skip) {
+                this.collectionUpdates.delete(coll);
             }
-        }
-        await this.em.getDriver().syncCollections(collectionUpdates, { ctx, schema: this.em.schema });
-        for (const coll of this.collectionUpdates) {
-            coll.takeSnapshot();
         }
     }
     /**

package/utils/AbstractSchemaGenerator.d.ts

@@ -10,18 +10,18 @@ export declare abstract class AbstractSchemaGenerator<D extends IDatabaseDriver>
     protected readonly platform: ReturnType<D['getPlatform']>;
     protected readonly connection: ReturnType<D['getConnection']>;
     constructor(em: D | D[typeof EntityManagerType]);
-    createSchema(options?: CreateSchemaOptions): Promise<void>;
+    create(options?: CreateSchemaOptions): Promise<void>;
     /**
      * Returns true if the database was created.
      */
     ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
-    refreshDatabase(options?: RefreshDatabaseOptions): Promise<void>;
-    clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
+    refresh(options?: RefreshDatabaseOptions): Promise<void>;
+    clear(options?: ClearDatabaseOptions): Promise<void>;
     protected clearIdentityMap(): void;
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
-    dropSchema(options?: DropSchemaOptions): Promise<void>;
+    drop(options?: DropSchemaOptions): Promise<void>;
     getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
-    updateSchema(options?: UpdateSchemaOptions): Promise<void>;
+    update(options?: UpdateSchemaOptions): Promise<void>;
     getUpdateSchemaSQL(options?: UpdateSchemaOptions): Promise<string>;
     getUpdateSchemaMigrationSQL(options?: UpdateSchemaOptions): Promise<{
         up: string;

package/utils/AbstractSchemaGenerator.js

@@ -15,7 +15,7 @@ export class AbstractSchemaGenerator {
         this.platform = this.driver.getPlatform();
         this.connection = this.driver.getConnection();
     }
-    async createSchema(options) {
+    async create(options) {
         this.notImplemented();
     }
     /**
@@ -24,7 +24,7 @@ export class AbstractSchemaGenerator {
     async ensureDatabase(options) {
         this.notImplemented();
     }
-    async refreshDatabase(options) {
+    async refresh(options) {
         if (options?.dropDb) {
             const name = this.config.get('dbName');
             await this.dropDatabase(name);
@@ -32,20 +32,22 @@ export class AbstractSchemaGenerator {
         }
         else {
             await this.ensureDatabase();
-            await this.dropSchema(options);
+            await this.drop(options);
         }
         if (options?.createSchema !== false) {
-            await this.createSchema(options);
+            await this.create(options);
         }
     }
-    async clearDatabase(options) {
+    async clear(options) {
         for (const meta of this.getOrderedMetadata(options?.schema).reverse()) {
             await this.driver.nativeDelete(meta.className, {}, options);
         }
-        this.clearIdentityMap();
+        if (options?.clearIdentityMap ?? true) {
+            this.clearIdentityMap();
+        }
     }
     clearIdentityMap() {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (!this.em) {
             return;
         }
@@ -57,13 +59,13 @@ export class AbstractSchemaGenerator {
     async getCreateSchemaSQL(options) {
         this.notImplemented();
     }
-    async dropSchema(options) {
+    async drop(options) {
         this.notImplemented();
     }
     async getDropSchemaSQL(options) {
         this.notImplemented();
     }
-    async updateSchema(options) {
+    async update(options) {
         this.notImplemented();
     }
     async getUpdateSchemaSQL(options) {