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

package/unit-of-work/ChangeSetPersister.js

@@ -1,29 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeSetPersister = void 0;
-const entity_1 = require("../entity");
-const ChangeSet_1 = require("./ChangeSet");
-const RawQueryFragment_1 = require("../utils/RawQueryFragment");
-const Utils_1 = require("../utils/Utils");
-const errors_1 = require("../errors");
-const enums_1 = require("../enums");
-class ChangeSetPersister {
+import { EntityIdentifier } from '../entity/EntityIdentifier.js';
+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, 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();
@@ -60,11 +58,11 @@ class ChangeSetPersister {
         }
         const size = this.config.get('batchSize');
         const meta = changeSets[0].meta;
-        const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         for (let i = 0; i < changeSets.length; i += size) {
             const chunk = changeSets.slice(i, i + size);
             const pks = chunk.map(cs => cs.getPrimaryKey());
-            options = this.propagateSchemaFromMetadata(meta, options);
+            options = this.prepareOptions(meta, options);
             await this.driver.nativeDelete(meta.root.className, { [pk]: { $in: pks } }, options);
         }
     }
@@ -81,18 +79,37 @@ 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);
         for (const prop of meta.relations) {
             this.processProperty(changeSet, prop);
         }
-        if (changeSet.type === ChangeSet_1.ChangeSetType.CREATE && this.config.get('validateRequired')) {
-            this.validator.validateRequired(changeSet.entity);
+        if (changeSet.type === ChangeSetType.CREATE && this.config.get('validateRequired')) {
+            this.validateRequired(changeSet.entity);
         }
     }
     async persistNewEntity(meta, changeSet, options) {
-        const wrapped = (0, entity_1.helper)(changeSet.entity);
-        options = this.propagateSchemaFromMetadata(meta, options, {
+        const wrapped = helper(changeSet.entity);
+        options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
         const res = await this.driver.nativeInsertMany(meta.className, [changeSet.payload], options);
@@ -118,22 +135,24 @@ 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);
         for (let i = 0; i < changeSets.length; i++) {
             const changeSet = changeSets[i];
-            const wrapped = (0, entity_1.helper)(changeSet.entity);
+            const wrapped = helper(changeSet.entity);
             if (!wrapped.hasPrimaryKey()) {
                 const field = meta.getPrimaryProps()[0].fieldNames[0];
                 this.mapPrimaryKey(meta, res.rows[i][field], changeSet);
@@ -172,12 +191,12 @@ class ChangeSetPersister {
             }
         }
         if (tmp.length === 0 && meta.concurrencyCheckKeys.size > 0) {
-            throw errors_1.OptimisticLockError.lockFailed(changeSet.entity);
+            throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
     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,
         });
@@ -191,10 +210,10 @@ class ChangeSetPersister {
         }
         const res = await this.driver.nativeUpdateMany(meta.className, cond, payload, options);
         const map = new Map();
-        res.rows?.forEach(item => map.set(Utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        res.rows?.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
         for (const changeSet of changeSets) {
             if (res.rows) {
-                const row = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
+                const row = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
                 this.mapReturnedValues(changeSet.entity, changeSet.payload, row, meta);
             }
             changeSet.persisted = true;
@@ -203,7 +222,7 @@ class ChangeSetPersister {
     mapPrimaryKey(meta, value, changeSet) {
         const prop = meta.properties[meta.primaryKeys[0]];
         const insertId = prop.customType ? prop.customType.convertToJSValue(value, this.platform) : value;
-        const wrapped = (0, entity_1.helper)(changeSet.entity);
+        const wrapped = helper(changeSet.entity);
         if (!wrapped.hasPrimaryKey()) {
             wrapped.setPrimaryKey(insertId);
         }
@@ -212,30 +231,32 @@ class ChangeSetPersister {
         // of using the raw value from db, we convert it back to the db value explicitly
         value = prop.customType ? prop.customType.convertToDatabaseValue(insertId, this.platform, { mode: 'serialization' }) : value;
         changeSet.payload[wrapped.__meta.primaryKeys[0]] = value;
-        wrapped.__identifier?.setValue(value);
+        if (wrapped.__identifier && !Array.isArray(wrapped.__identifier)) {
+            wrapped.__identifier.setValue(value);
+        }
     }
     /**
      * Sets populate flag to new entities so they are serialized like if they were loaded from the db
      */
     markAsPopulated(changeSet, meta) {
-        (0, entity_1.helper)(changeSet.entity).__schema = this.driver.getSchemaName(meta, changeSet);
+        helper(changeSet.entity).__schema = this.driver.getSchemaName(meta, changeSet);
         if (!this.config.get('populateAfterFlush')) {
             return;
         }
-        (0, entity_1.helper)(changeSet.entity).populated();
+        helper(changeSet.entity).populated();
         meta.relations.forEach(prop => {
             const value = changeSet.entity[prop.name];
-            if (Utils_1.Utils.isEntity(value, true)) {
+            if (Utils.isEntity(value, true)) {
                 value.__helper.populated();
             }
-            else if (Utils_1.Utils.isCollection(value)) {
+            else if (Utils.isCollection(value)) {
                 value.populated();
             }
         });
     }
     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)) {
@@ -252,9 +273,9 @@ class ChangeSetPersister {
             return;
         }
         // skip entity references as they don't have version values loaded
-        changeSets = changeSets.filter(cs => (0, entity_1.helper)(cs.entity).__initialized);
+        changeSets = changeSets.filter(cs => helper(cs.entity).__initialized);
         const $or = changeSets.map(cs => {
-            const cond = Utils_1.Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
+            const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
             if (meta.versionProperty) {
                 // @ts-ignore
                 cond[meta.versionProperty] = this.platform.quoteVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
@@ -262,21 +283,21 @@ 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);
         if (res.length !== changeSets.length) {
             const compare = (a, b, keys) => keys.every(k => a[k] === b[k]);
             const entity = changeSets.find(cs => {
-                return !res.some(row => compare(Utils_1.Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
+                return !res.some(row => compare(Utils.getPrimaryKeyCond(cs.entity, primaryKeys), row, primaryKeys));
             }).entity;
-            throw errors_1.OptimisticLockError.lockFailed(entity);
+            throw OptimisticLockError.lockFailed(entity);
         }
     }
     checkOptimisticLock(meta, changeSet, res) {
         if ((meta.versionProperty || meta.concurrencyCheckKeys.size > 0) && res && !res.affectedRows) {
-            throw errors_1.OptimisticLockError.lockFailed(changeSet.entity);
+            throw OptimisticLockError.lockFailed(changeSet.entity);
         }
     }
     /**
@@ -285,18 +306,29 @@ class ChangeSetPersister {
      */
     async reloadVersionValues(meta, changeSets, options) {
         const reloadProps = meta.versionProperty && !this.usesReturningStatement ? [meta.properties[meta.versionProperty]] : [];
-        if (changeSets[0].type === ChangeSet_1.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') || (0, RawQueryFragment_1.isRaw)(changeSets[0].entity[prop.name]))
-                .forEach(prop => reloadProps.push(prop));
-        }
-        if (changeSets[0].type === ChangeSet_1.ChangeSetType.UPDATE) {
+        if (changeSets[0].type === ChangeSetType.CREATE) {
+            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();
             changeSets.forEach(cs => {
-                Utils_1.Utils.keys(cs.payload).forEach(k => {
-                    if ((0, RawQueryFragment_1.isRaw)(cs.payload[k]) && (0, RawQueryFragment_1.isRaw)(cs.entity[k])) {
+                Utils.keys(cs.payload).forEach(k => {
+                    if (isRaw(cs.payload[k]) && isRaw(cs.entity[k])) {
                         returning.add(meta.properties[k]);
                     }
                 });
@@ -313,22 +345,22 @@ class ChangeSetPersister {
             return;
         }
         reloadProps.unshift(...meta.getPrimaryProps());
-        const pk = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+        const pk = Utils.getPrimaryKeyHash(meta.primaryKeys);
         const pks = changeSets.map(cs => {
-            const val = (0, entity_1.helper)(cs.entity).getPrimaryKey(true);
-            if (Utils_1.Utils.isPlainObject(val)) {
-                return Utils_1.Utils.getCompositeKeyValue(val, meta, false, this.platform);
+            const val = helper(cs.entity).getPrimaryKey(true);
+            if (Utils.isPlainObject(val)) {
+                return Utils.getCompositeKeyValue(val, meta, false, this.platform);
             }
             return val;
         });
-        options = this.propagateSchemaFromMetadata(meta, options, {
-            fields: Utils_1.Utils.unique(reloadProps.map(prop => prop.name)),
+        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 map = new Map();
-        data.forEach(item => map.set(Utils_1.Utils.getCompositeKeyHash(item, meta, true, this.platform, true), item));
+        data.forEach(item => map.set(Utils.getCompositeKeyHash(item, meta, false, this.platform, true), item));
         for (const changeSet of changeSets) {
-            const data = map.get((0, entity_1.helper)(changeSet.entity).getSerializedPrimaryKey());
+            const data = map.get(helper(changeSet.entity).getSerializedPrimaryKey());
             this.hydrator.hydrate(changeSet.entity, meta, data, this.factory, 'full', false, true);
             Object.assign(changeSet.payload, data); // merge to the changeset payload, so it gets saved to the entity snapshot
         }
@@ -336,21 +368,25 @@ class ChangeSetPersister {
     processProperty(changeSet, prop) {
         const meta = this.metadata.find(changeSet.name);
         const value = changeSet.payload[prop.name]; // for inline embeddables
-        if (value instanceof entity_1.EntityIdentifier) {
+        if (value instanceof EntityIdentifier) {
             changeSet.payload[prop.name] = value.getValue();
             return;
         }
-        if (prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
-            changeSet.payload[prop.name] = value.map(val => val instanceof entity_1.EntityIdentifier ? val.getValue() : val);
+        if (Array.isArray(value) && value.every(item => item instanceof EntityIdentifier)) {
+            changeSet.payload[prop.name] = value.map(item => item.getValue());
+            return;
+        }
+        if (prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
+            changeSet.payload[prop.name] = value.map(val => val instanceof EntityIdentifier ? val.getValue() : val);
             return;
         }
         if (prop.name in changeSet.payload) {
             return;
         }
-        const values = Utils_1.Utils.unwrapProperty(changeSet.payload, meta, prop, true); // for object embeddables
+        const values = Utils.unwrapProperty(changeSet.payload, meta, prop, true); // for object embeddables
         values.forEach(([value, indexes]) => {
-            if (value instanceof entity_1.EntityIdentifier) {
-                Utils_1.Utils.setPayloadProperty(changeSet.payload, meta, prop, value.getValue(), indexes);
+            if (value instanceof EntityIdentifier) {
+                Utils.setPayloadProperty(changeSet.payload, meta, prop, value.getValue(), indexes);
             }
         });
     }
@@ -360,7 +396,7 @@ class ChangeSetPersister {
      * We do need to map to the change set payload too, as it will be used in the originalEntityData for new entities.
      */
     mapReturnedValues(entity, payload, row, meta, upsert = false) {
-        if ((!this.usesReturningStatement && !upsert) || !row || !Utils_1.Utils.hasObjectKeys(row)) {
+        if ((!this.usesReturningStatement && !upsert) || !row || !Utils.hasObjectKeys(row)) {
             return;
         }
         const mapped = this.comparator.mapResult(meta.className, row);
@@ -377,4 +413,3 @@ class ChangeSetPersister {
         Object.assign(payload, mapped);
     }
 }
-exports.ChangeSetPersister = ChangeSetPersister;

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

@@ -1,4 +1,4 @@
-import type { Dictionary, EntityProperty } from '../typings';
+import type { Dictionary, EntityProperty } from '../typings.js';
 export declare const enum NodeState {
     NOT_VISITED = 0,
     IN_PROGRESS = 1,

package/unit-of-work/CommitOrderCalculator.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommitOrderCalculator = exports.NodeState = void 0;
-const enums_1 = require("../enums");
-var NodeState;
+import { ReferenceKind } from '../enums.js';
+export var NodeState;
 (function (NodeState) {
     NodeState[NodeState["NOT_VISITED"] = 0] = "NOT_VISITED";
     NodeState[NodeState["IN_PROGRESS"] = 1] = "IN_PROGRESS";
     NodeState[NodeState["VISITED"] = 2] = "VISITED";
-})(NodeState || (exports.NodeState = NodeState = {}));
+})(NodeState || (NodeState = {}));
 /**
  * CommitOrderCalculator implements topological sorting, which is an ordering
  * algorithm for directed graphs (DG) and/or directed acyclic graphs (DAG) by
@@ -18,7 +15,7 @@ var NodeState;
  * Based on https://github.com/doctrine/orm/blob/master/lib/Doctrine/ORM/Internal/CommitOrderCalculator.php
  * @internal
  */
-class CommitOrderCalculator {
+export class CommitOrderCalculator {
     /** Matrix of nodes, keys are provided hashes and values are the node definition objects. */
     nodes = {};
     /** Volatile variable holding calculated nodes during sorting process. */
@@ -42,8 +39,8 @@ class CommitOrderCalculator {
         this.nodes[from].dependencies[to] = { from, to, weight };
     }
     discoverProperty(prop, entityName) {
-        const toOneOwner = (prop.kind === enums_1.ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === enums_1.ReferenceKind.MANY_TO_ONE;
-        const toManyOwner = prop.kind === enums_1.ReferenceKind.MANY_TO_MANY && prop.owner && !prop.pivotEntity;
+        const toOneOwner = (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) || prop.kind === ReferenceKind.MANY_TO_ONE;
+        const toManyOwner = prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !prop.pivotEntity;
         if (!toOneOwner && !toManyOwner) {
             return;
         }
@@ -110,4 +107,3 @@ class CommitOrderCalculator {
         this.sortedNodeList.push(target.hash);
     }
 }
-exports.CommitOrderCalculator = CommitOrderCalculator;

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

@@ -1,4 +1,4 @@
-import type { AnyEntity, EntityMetadata } from '../typings';
+import type { AnyEntity, EntityMetadata } from '../typings.js';
 export declare class IdentityMap {
     private readonly defaultSchema?;
     constructor(defaultSchema?: string | undefined);

package/unit-of-work/IdentityMap.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IdentityMap = void 0;
-class IdentityMap {
+export class IdentityMap {
     defaultSchema;
     constructor(defaultSchema) {
         this.defaultSchema = defaultSchema;
@@ -73,4 +70,3 @@ class IdentityMap {
         return hash;
     }
 }
-exports.IdentityMap = IdentityMap;

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

@@ -1,10 +1,11 @@
-import type { AnyEntity, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary } from '../typings';
-import { Collection, Reference } from '../entity';
-import { ChangeSet, ChangeSetType } from './ChangeSet';
-import { ChangeSetPersister } from './ChangeSetPersister';
-import type { EntityManager } from '../EntityManager';
-import { IdentityMap } from './IdentityMap';
-import type { LockOptions } from '../drivers/IDatabaseDriver';
+import type { AnyEntity, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary } from '../typings.js';
+import { Collection } from '../entity/Collection.js';
+import { Reference } from '../entity/Reference.js';
+import { ChangeSet, ChangeSetType } from './ChangeSet.js';
+import { ChangeSetPersister } from './ChangeSetPersister.js';
+import type { EntityManager } from '../EntityManager.js';
+import { IdentityMap } from './IdentityMap.js';
+import type { LockOptions } from '../drivers/IDatabaseDriver.js';
 export declare class UnitOfWork {
     private readonly em;
     /** map of references to managed entities */
@@ -27,6 +28,12 @@ export declare class UnitOfWork {
     private working;
     constructor(em: EntityManager);
     merge<T extends object>(entity: T, visited?: Set<AnyEntity>): void;
+    /**
+     * 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<T extends object>(meta: EntityMetadata<T>, data: EntityData<T>): void;
     /**
      * @internal
      */
@@ -38,7 +45,7 @@ export declare class UnitOfWork {
     /**
      * Returns entity from the identity map. For composite keys, you need to pass an array of PKs in the same order as they are defined in `meta.primaryKeys`.
      */
-    getById<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string): T | undefined;
+    getById<T extends object>(entityName: string, id: Primary<T> | Primary<T>[], schema?: string, convertCustomTypes?: boolean): T | undefined;
     tryGetById<T extends object>(entityName: string, where: FilterQuery<T>, schema?: string, strict?: boolean): T | null;
     /**
      * Returns map of all managed entities.
@@ -102,6 +109,7 @@ export declare class UnitOfWork {
     private commitDeleteChangeSets;
     private commitExtraUpdates;
     private commitCollectionUpdates;
+    private filterCollectionUpdates;
     /**
      * Orders change sets so FK constrains are maintained, ensures stable order (needed for node < 11)
      */