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

package/entity/EntityFactory.js

@@ -1,13 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityFactory = void 0;
-const Utils_1 = require("../utils/Utils");
-const QueryHelper_1 = require("../utils/QueryHelper");
-const enums_1 = require("../enums");
-const Reference_1 = require("./Reference");
-const wrap_1 = require("./wrap");
-const EntityHelper_1 = require("./EntityHelper");
-class EntityFactory {
+import { Utils } from '../utils/Utils.js';
+import { QueryHelper } from '../utils/QueryHelper.js';
+import { EventType, ReferenceKind } from '../enums.js';
+import { Reference } from './Reference.js';
+import { helper } from './wrap.js';
+import { EntityHelper } from './EntityHelper.js';
+import { JsonType } from '../types/JsonType.js';
+export class EntityFactory {
     em;
     driver;
     platform;
@@ -27,12 +25,12 @@ class EntityFactory {
         this.comparator = this.em.getComparator();
     }
     create(entityName, data, options = {}) {
-        data = Reference_1.Reference.unwrapReference(data);
+        data = Reference.unwrapReference(data);
         options.initialized ??= true;
         if (data.__entity) {
             return data;
         }
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         if (meta.virtual) {
             data = { ...data };
@@ -40,14 +38,15 @@ class EntityFactory {
             this.hydrate(entity, meta, data, options);
             return entity;
         }
-        if (this.platform.usesDifferentSerializedPrimaryKey()) {
-            meta.primaryKeys.forEach(pk => this.denormalizePrimaryKey(data, pk, meta.properties[pk]));
+        if (meta.serializedPrimaryKey) {
+            this.denormalizePrimaryKey(meta, data);
         }
         const meta2 = this.processDiscriminatorColumn(meta, data);
         const exists = this.findEntity(data, meta2, options);
-        let wrapped = exists && (0, wrap_1.helper)(exists);
+        let wrapped = exists && helper(exists);
         if (wrapped && !options.refresh) {
             wrapped.__processing = true;
+            Utils.dropUndefinedProperties(data);
             this.mergeData(meta2, exists, data, options);
             wrapped.__processing = false;
             if (wrapped.isInitialized()) {
@@ -56,12 +55,12 @@ class EntityFactory {
         }
         data = { ...data };
         const entity = exists ?? this.createEntity(data, meta2, options);
-        wrapped = (0, wrap_1.helper)(entity);
+        wrapped = helper(entity);
         wrapped.__processing = true;
         wrapped.__initialized = options.initialized;
         if (options.newEntity || meta.forceConstructor || meta.virtual) {
             const tmp = { ...data };
-            meta.constructorParams.forEach(prop => delete tmp[prop]);
+            meta.constructorParams?.forEach(prop => delete tmp[prop]);
             this.hydrate(entity, meta2, tmp, options);
             // since we now process only a copy of the `data` via hydrator, but later we register the state with the full snapshot,
             // we need to go through all props with custom types that have `ensureComparable: true` and ensure they are comparable
@@ -69,13 +68,15 @@ class EntityFactory {
             if (options.convertCustomTypes) {
                 for (const prop of meta.props) {
                     if (prop.customType?.ensureComparable(meta, prop) && data[prop.name]) {
-                        if ([enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                        if ([ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
                             continue;
                         }
-                        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                            data[prop.name] = Utils_1.Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta.primaryKeys, true);
+                        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);
+                        }
+                        if (prop.customType instanceof JsonType && this.platform.convertsJsonAutomatically()) {
+                            data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                         }
-                        data[prop.name] = prop.customType.convertToDatabaseValue(data[prop.name], this.platform, { key: prop.name, mode: 'hydration' });
                     }
                 }
             }
@@ -83,13 +84,14 @@ class EntityFactory {
         else {
             this.hydrate(entity, meta2, data, options);
         }
-        wrapped.__touched = false;
         if (exists && meta.discriminatorColumn && !(entity instanceof meta2.class)) {
             Object.setPrototypeOf(entity, meta2.prototype);
         }
         if (options.merge && wrapped.hasPrimaryKey()) {
             this.unitOfWork.register(entity, data, {
-                refresh: options.refresh && options.initialized,
+                // Always refresh to ensure the payload is in correct shape for joined strategy. When loading nested relations,
+                // they will be created early without `Type.ensureComparable` being properly handled, resulting in extra updates.
+                refresh: options.initialized,
                 newEntity: options.newEntity,
                 loaded: options.initialized,
             });
@@ -97,26 +99,26 @@ class EntityFactory {
                 wrapped.__originalEntityData = this.comparator.prepareEntity(entity);
             }
         }
-        if (this.eventManager.hasListeners(enums_1.EventType.onInit, meta2)) {
-            this.eventManager.dispatchEvent(enums_1.EventType.onInit, { entity, meta: meta2, em: this.em });
+        if (this.eventManager.hasListeners(EventType.onInit, meta2)) {
+            this.eventManager.dispatchEvent(EventType.onInit, { entity, meta: meta2, em: this.em });
         }
         wrapped.__processing = false;
         return entity;
     }
     mergeData(meta, entity, data, options = {}) {
         // merge unchanged properties automatically
-        data = QueryHelper_1.QueryHelper.processParams(data);
+        data = QueryHelper.processParams(data);
         const existsData = this.comparator.prepareEntity(entity);
-        const originalEntityData = (0, wrap_1.helper)(entity).__originalEntityData ?? {};
+        const originalEntityData = helper(entity).__originalEntityData ?? {};
         const diff = this.comparator.diffEntities(meta.className, originalEntityData, existsData);
         // version properties are not part of entity snapshots
         if (meta.versionProperty && data[meta.versionProperty] && data[meta.versionProperty] !== originalEntityData[meta.versionProperty]) {
             diff[meta.versionProperty] = data[meta.versionProperty];
         }
-        const diff2 = this.comparator.diffEntities(meta.className, existsData, data);
+        const diff2 = this.comparator.diffEntities(meta.className, existsData, data, { includeInverseSides: true });
         // do not override values changed by user
-        Utils_1.Utils.keys(diff).forEach(key => delete diff2[key]);
-        Utils_1.Utils.keys(diff2).filter(key => {
+        Utils.keys(diff).forEach(key => delete diff2[key]);
+        Utils.keys(diff2).filter(key => {
             // ignore null values if there is already present non-null value
             if (existsData[key] != null) {
                 return diff2[key] == null;
@@ -124,40 +126,44 @@ class EntityFactory {
             return diff2[key] === undefined;
         }).forEach(key => delete diff2[key]);
         // but always add collection properties and formulas if they are part of the `data`
-        Utils_1.Utils.keys(data)
-            .filter(key => meta.properties[key]?.formula || [enums_1.ReferenceKind.ONE_TO_MANY, enums_1.ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
+        Utils.keys(data)
+            .filter(key => meta.properties[key]?.formula || [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
             .forEach(key => diff2[key] = data[key]);
         // rehydrated with the new values, skip those changed by user
         this.hydrate(entity, meta, diff2, options);
         // we need to update the entity data only with keys that were not present before
         const nullVal = this.config.get('forceUndefined') ? undefined : null;
-        Utils_1.Utils.keys(diff2).forEach(key => {
+        Utils.keys(diff2).forEach(key => {
             const prop = meta.properties[key];
-            if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name])) {
-                diff2[key] = entity[prop.name] ? (0, wrap_1.helper)(entity[prop.name]).getPrimaryKey(options.convertCustomTypes) : null;
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+                diff2[key] = entity[prop.name] ? helper(entity[prop.name]).getPrimaryKey(options.convertCustomTypes) : null;
+            }
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) && prop.customType?.ensureComparable(meta, prop) && diff2[key] != null) {
+                const converted = prop.customType.convertToJSValue(diff2[key], this.platform, { force: true });
+                diff2[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { fromQuery: true });
             }
             originalEntityData[key] = diff2[key] === null ? nullVal : diff2[key];
-            (0, wrap_1.helper)(entity).__loadedProperties.add(key);
+            helper(entity).__loadedProperties.add(key);
         });
         // in case of joined loading strategy, we need to cascade the merging to possibly loaded relations manually
         meta.relations.forEach(prop => {
-            if ([enums_1.ReferenceKind.MANY_TO_MANY, enums_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind) && Array.isArray(data[prop.name])) {
+            if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && Array.isArray(data[prop.name])) {
                 // instead of trying to match the collection items (which could easily fail if the collection was loaded with different ordering),
                 // we just create the entity from scratch, which will automatically pick the right one from the identity map and call `mergeData` on it
                 data[prop.name]
-                    .filter(child => Utils_1.Utils.isPlainObject(child)) // objects with prototype can be PKs (e.g. `ObjectId`)
+                    .filter(child => Utils.isPlainObject(child)) // objects with prototype can be PKs (e.g. `ObjectId`)
                     .forEach(child => this.create(prop.type, child, options)); // we can ignore the value, we just care about the `mergeData` call
                 return;
             }
-            if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(data[prop.name]) && entity[prop.name] && (0, wrap_1.helper)(entity[prop.name]).__initialized) {
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name]) && entity[prop.name] && helper(entity[prop.name]).__initialized) {
                 this.create(prop.type, data[prop.name], options); // we can ignore the value, we just care about the `mergeData` call
             }
         });
-        (0, wrap_1.helper)(entity).__touched = false;
+        this.unitOfWork.normalizeEntityData(meta, originalEntityData);
     }
     createReference(entityName, id, options = {}) {
         options.convertCustomTypes ??= true;
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         const meta = this.metadata.get(entityName);
         const schema = this.driver.getSchemaName(meta, options);
         if (meta.simplePK) {
@@ -165,24 +171,24 @@ class EntityFactory {
             if (exists) {
                 return exists;
             }
-            const data = Utils_1.Utils.isPlainObject(id) ? id : { [meta.primaryKeys[0]]: Array.isArray(id) ? id[0] : id };
+            const data = Utils.isPlainObject(id) ? id : { [meta.primaryKeys[0]]: Array.isArray(id) ? id[0] : id };
             return this.create(entityName, data, { ...options, initialized: false });
         }
         if (Array.isArray(id)) {
-            id = Utils_1.Utils.getPrimaryKeyCondFromArray(id, meta);
+            id = Utils.getPrimaryKeyCondFromArray(id, meta);
         }
-        const pks = Utils_1.Utils.getOrderedPrimaryKeys(id, meta, this.platform, options.convertCustomTypes);
-        const exists = this.unitOfWork.getById(entityName, pks, schema);
+        const pks = Utils.getOrderedPrimaryKeys(id, meta, this.platform);
+        const exists = this.unitOfWork.getById(entityName, pks, schema, options.convertCustomTypes);
         if (exists) {
             return exists;
         }
-        if (Utils_1.Utils.isPrimaryKey(id)) {
+        if (Utils.isPrimaryKey(id)) {
             id = { [meta.primaryKeys[0]]: id };
         }
         return this.create(entityName, id, { ...options, initialized: false });
     }
     createEmbeddable(entityName, data, options = {}) {
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         data = { ...data };
         const meta = this.metadata.get(entityName);
         const meta2 = this.processDiscriminatorColumn(meta, data);
@@ -211,37 +217,48 @@ class EntityFactory {
             if (meta.virtual) {
                 return entity;
             }
-            (0, wrap_1.helper)(entity).__schema = schema;
+            helper(entity).__schema = schema;
             if (options.initialized) {
-                EntityHelper_1.EntityHelper.ensurePropagation(entity);
+                EntityHelper.ensurePropagation(entity);
             }
             return entity;
         }
         // creates new entity instance, bypassing constructor call as its already persisted entity
         const entity = Object.create(meta.class.prototype);
-        (0, wrap_1.helper)(entity).__managed = true;
-        (0, wrap_1.helper)(entity).__processing = !meta.embeddable && !meta.virtual;
-        (0, wrap_1.helper)(entity).__schema = schema;
+        helper(entity).__managed = true;
+        helper(entity).__processing = !meta.embeddable && !meta.virtual;
+        helper(entity).__schema = schema;
         if (options.merge && !options.newEntity) {
             this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, options.parentSchema);
             this.unitOfWork.register(entity);
         }
         if (options.initialized) {
-            EntityHelper_1.EntityHelper.ensurePropagation(entity);
+            EntityHelper.ensurePropagation(entity);
         }
         return entity;
     }
+    assignDefaultValues(entity, meta) {
+        for (const prop of meta.props) {
+            if (prop.onCreate) {
+                entity[prop.name] ??= prop.onCreate(entity, this.em);
+            }
+        }
+    }
     hydrate(entity, meta, data, options) {
         if (options.initialized) {
-            this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
+            this.hydrator.hydrate(entity, meta, data, this, 'full', options.newEntity, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options), options.normalizeAccessors);
         }
         else {
-            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options));
+            this.hydrator.hydrateReference(entity, meta, data, this, options.convertCustomTypes, options.schema, this.driver.getSchemaName(meta, options), options.normalizeAccessors);
         }
-        Utils_1.Utils.keys(data).forEach(key => {
-            (0, wrap_1.helper)(entity)?.__loadedProperties.add(key);
-            (0, wrap_1.helper)(entity)?.__serializationContext.fields?.add(key);
+        Utils.keys(data).forEach(key => {
+            helper(entity)?.__loadedProperties.add(key);
+            helper(entity)?.__serializationContext.fields?.add(key);
         });
+        const processOnCreateHooksEarly = options.processOnCreateHooksEarly ?? this.config.get('processOnCreateHooksEarly');
+        if (options.newEntity && processOnCreateHooksEarly) {
+            this.assignDefaultValues(entity, meta);
+        }
     }
     findEntity(data, meta, options) {
         const schema = this.driver.getSchemaName(meta, options);
@@ -251,7 +268,7 @@ class EntityFactory {
         if (!Array.isArray(data) && meta.primaryKeys.some(pk => data[pk] == null)) {
             return undefined;
         }
-        const pks = Utils_1.Utils.getOrderedPrimaryKeys(data, meta, this.platform);
+        const pks = Utils.getOrderedPrimaryKeys(data, meta, this.platform, options.convertCustomTypes);
         return this.unitOfWork.getById(meta.className, pks, schema);
     }
     processDiscriminatorColumn(meta, data) {
@@ -267,69 +284,73 @@ class EntityFactory {
     /**
      * denormalize PK to value required by driver (e.g. ObjectId)
      */
-    denormalizePrimaryKey(data, primaryKey, prop) {
-        const pk = this.platform.getSerializedPrimaryKeyField(primaryKey);
-        if (data[pk] != null || data[primaryKey] != null) {
-            let id = (data[pk] || data[primaryKey]);
-            if (prop.type.toLowerCase() === 'objectid') {
-                id = this.platform.denormalizePrimaryKey(id);
-            }
-            delete data[pk];
-            data[primaryKey] = id;
+    denormalizePrimaryKey(meta, data) {
+        const pk = meta.getPrimaryProp();
+        const spk = meta.properties[meta.serializedPrimaryKey];
+        if (!spk?.serializedPrimaryKey) {
+            return;
+        }
+        if (pk.type === 'ObjectId' && (data[pk.name] != null || data[spk.name] != null)) {
+            data[pk.name] = this.platform.denormalizePrimaryKey((data[spk.name] || data[pk.name]));
+            delete data[spk.name];
         }
     }
     /**
      * returns parameters for entity constructor, creating references from plain ids
      */
     extractConstructorParams(meta, data, options) {
+        if (!meta.constructorParams) {
+            return [data];
+        }
         return meta.constructorParams.map(k => {
-            if (meta.properties[k] && [enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(meta.properties[k].kind) && data[k]) {
-                const pk = Reference_1.Reference.unwrapReference(data[k]);
-                const entity = this.unitOfWork.getById(meta.properties[k].type, pk, options.schema);
+            const prop = meta.properties[k];
+            const value = data[k];
+            if (prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && value) {
+                const pk = Reference.unwrapReference(value);
+                const entity = this.unitOfWork.getById(prop.type, pk, options.schema, true);
                 if (entity) {
                     return entity;
                 }
-                if (Utils_1.Utils.isEntity(data[k])) {
-                    return data[k];
+                if (Utils.isEntity(value)) {
+                    return value;
                 }
-                const nakedPk = Utils_1.Utils.extractPK(data[k], meta.properties[k].targetMeta, true);
-                if (Utils_1.Utils.isObject(data[k]) && !nakedPk) {
-                    return this.create(meta.properties[k].type, data[k], options);
+                const nakedPk = Utils.extractPK(value, prop.targetMeta, true);
+                if (Utils.isObject(value) && !nakedPk) {
+                    return this.create(prop.type, value, options);
                 }
                 const { newEntity, initialized, ...rest } = options;
-                const target = this.createReference(meta.properties[k].type, nakedPk, rest);
-                return Reference_1.Reference.wrapReference(target, meta.properties[k]);
+                const target = this.createReference(prop.type, nakedPk, rest);
+                return Reference.wrapReference(target, prop);
             }
-            if (meta.properties[k]?.kind === enums_1.ReferenceKind.EMBEDDED && data[k]) {
-                /* istanbul ignore next */
-                if (Utils_1.Utils.isEntity(data[k])) {
-                    return data[k];
+            if (prop?.kind === ReferenceKind.EMBEDDED && value) {
+                /* v8 ignore next */
+                if (Utils.isEntity(value)) {
+                    return value;
                 }
-                return this.createEmbeddable(meta.properties[k].type, data[k], options);
+                return this.createEmbeddable(prop.type, value, options);
             }
-            if (!meta.properties[k]) {
+            if (!prop) {
                 const tmp = { ...data };
                 for (const prop of meta.props) {
                     if (!options.convertCustomTypes || !prop.customType || tmp[prop.name] == null) {
                         continue;
                     }
-                    if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils_1.Utils.isPlainObject(tmp[prop.name]) && !Utils_1.Utils.extractPK(tmp[prop.name], meta.properties[prop.name].targetMeta, true)) {
-                        tmp[prop.name] = Reference_1.Reference.wrapReference(this.create(meta.properties[prop.name].type, tmp[prop.name], options), prop);
+                    if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(tmp[prop.name]) && !Utils.extractPK(tmp[prop.name], meta.properties[prop.name].targetMeta, true)) {
+                        tmp[prop.name] = Reference.wrapReference(this.create(meta.properties[prop.name].type, tmp[prop.name], options), prop);
                     }
-                    else if (prop.kind === enums_1.ReferenceKind.SCALAR) {
+                    else if (prop.kind === ReferenceKind.SCALAR) {
                         tmp[prop.name] = prop.customType.convertToJSValue(tmp[prop.name], this.platform);
                     }
                 }
                 return tmp;
             }
-            if (options.convertCustomTypes && meta.properties[k].customType && data[k] != null) {
-                return meta.properties[k].customType.convertToJSValue(data[k], this.platform);
+            if (options.convertCustomTypes && prop.customType && value != null) {
+                return prop.customType.convertToJSValue(value, this.platform);
             }
-            return data[k];
+            return value;
         });
     }
     get unitOfWork() {
         return this.em.getUnitOfWork(false);
     }
 }
-exports.EntityFactory = EntityFactory;

package/entity/EntityHelper.d.ts

@@ -1,5 +1,5 @@
-import type { EntityManager } from '../EntityManager';
-import { type EntityMetadata, type EntityProperty, type IHydrator } from '../typings';
+import type { EntityManager } from '../EntityManager.js';
+import { type EntityMetadata, type EntityProperty, type IHydrator } from '../typings.js';
 /**
  * @internal
  */