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

package/entity/EntityAssigner.d.ts

@@ -1,5 +1,5 @@
-import type { EntityManager } from '../EntityManager';
-import type { EntityData, EntityDTO, EntityProperty, FromEntityType, IsSubset, MergeSelected } from '../typings';
+import type { EntityManager } from '../EntityManager.js';
+import type { EntityData, EntityDTO, EntityProperty, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
 export declare class EntityAssigner {
     static assign<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(entity: Entity, data: Data & IsSubset<EntityData<Naked, Convert>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     private static assignProperty;
@@ -36,7 +36,7 @@ export interface AssignOptions<Convert extends boolean> {
      */
     onlyProperties?: boolean;
     /**
-     * With `onlyOwnProperties` enabled, to-many relations are skipped, and payloads of to-one relations are converted
+     * With `onlyOwnProperties` enabled, inverse sides of to-many relations are skipped, and payloads of other relations are converted
      * to foreign keys. Defaults to `false`.
      */
     onlyOwnProperties?: boolean;

package/entity/EntityAssigner.js

@@ -1,25 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assign = exports.EntityAssigner = void 0;
-const node_util_1 = require("node:util");
-const Collection_1 = require("./Collection");
-const Utils_1 = require("../utils/Utils");
-const Reference_1 = require("./Reference");
-const enums_1 = require("../enums");
-const EntityValidator_1 = require("./EntityValidator");
-const wrap_1 = require("./wrap");
-const EntityHelper_1 = require("./EntityHelper");
-const validator = new EntityValidator_1.EntityValidator(false);
-class EntityAssigner {
+import { Collection } from './Collection.js';
+import { Utils } from '../utils/Utils.js';
+import { Reference } from './Reference.js';
+import { ReferenceKind, SCALAR_TYPES } from '../enums.js';
+import { validateProperty } from './validators.js';
+import { helper, wrap } from './wrap.js';
+import { EntityHelper } from './EntityHelper.js';
+import { ValidationError } from '../errors.js';
+export class EntityAssigner {
     static assign(entity, data, options = {}) {
         let opts = options;
         if (opts.visited?.has(entity)) {
             return entity;
         }
-        EntityHelper_1.EntityHelper.ensurePropagation(entity);
+        EntityHelper.ensurePropagation(entity);
         opts.visited ??= new Set();
         opts.visited.add(entity);
-        const wrapped = (0, wrap_1.helper)(entity);
+        const wrapped = helper(entity);
         opts = {
             ...wrapped.__config.get('assign'),
             schema: wrapped.__schema,
@@ -45,37 +41,45 @@ class EntityAssigner {
         }
         const prop = { ...props[propName], name: propName };
         if (prop && options.onlyOwnProperties) {
-            if ([enums_1.ReferenceKind.MANY_TO_MANY, enums_1.ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
+            if ([ReferenceKind.ONE_TO_MANY].includes(prop.kind)) {
                 return;
             }
-            if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-                value = Utils_1.Utils.extractPK(value, prop.targetMeta);
+            if ([ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+                if (!prop.owner) {
+                    return;
+                }
+                else if (value?.map) {
+                    value = value.map((v) => Utils.extractPK(v, prop.targetMeta));
+                }
+            }
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                value = Utils.extractPK(value, prop.targetMeta);
             }
         }
         if (propName in props && !prop.nullable && value == null) {
             throw new Error(`You must pass a non-${value} value to the property ${propName} of entity ${entity.constructor.name}.`);
         }
         // create collection instance if its missing so old items can be deleted with orphan removal
-        if ([enums_1.ReferenceKind.MANY_TO_MANY, enums_1.ReferenceKind.ONE_TO_MANY].includes(prop?.kind) && entity[prop.name] == null) {
-            entity[prop.name] = Collection_1.Collection.create(entity, prop.name, undefined, (0, wrap_1.helper)(entity).isInitialized());
+        if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop?.kind) && entity[prop.name] == null) {
+            entity[prop.name] = Collection.create(entity, prop.name, undefined, helper(entity).isInitialized());
         }
-        if (prop && Utils_1.Utils.isCollection(entity[prop.name])) {
+        if (prop && Utils.isCollection(entity[prop.name])) {
             return EntityAssigner.assignCollection(entity, entity[prop.name], value, prop, options.em, options);
         }
         const customType = prop?.customType;
-        if (options.convertCustomTypes && customType && prop.kind === enums_1.ReferenceKind.SCALAR && !Utils_1.Utils.isEntity(data)) {
+        if (options.convertCustomTypes && customType && prop.kind === ReferenceKind.SCALAR && !Utils.isEntity(data)) {
             value = customType.convertToJSValue(value, options.platform);
         }
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop?.kind) && value != null) {
-            if (options.updateNestedEntities && Object.hasOwn(entity, propName) && Utils_1.Utils.isEntity(entity[propName], true) && Utils_1.Utils.isPlainObject(value)) {
-                const unwrappedEntity = Reference_1.Reference.unwrapReference(entity[propName]);
-                const wrapped = (0, wrap_1.helper)(unwrappedEntity);
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop?.kind) && value != null) {
+            if (options.updateNestedEntities && Object.hasOwn(entity, propName) && Utils.isEntity(entity[propName], true) && Utils.isPlainObject(value)) {
+                const unwrappedEntity = Reference.unwrapReference(entity[propName]);
+                const wrapped = helper(unwrappedEntity);
                 if (options.updateByPrimaryKey) {
-                    const pk = Utils_1.Utils.extractPK(value, prop.targetMeta);
+                    const pk = Utils.extractPK(value, prop.targetMeta);
                     if (pk) {
                         const ref = options.em.getReference(prop.type, pk, options);
                         // if the PK differs, we want to change the target entity, not update it
-                        const wrappedChild = (0, wrap_1.helper)(ref);
+                        const wrappedChild = helper(ref);
                         const sameTarget = wrappedChild.getSerializedPrimaryKey() === wrapped.getSerializedPrimaryKey();
                         if (wrappedChild.__managed && wrappedChild.isInitialized() && sameTarget) {
                             return EntityAssigner.assign(ref, value, options);
@@ -83,21 +87,22 @@ class EntityAssigner {
                     }
                     return EntityAssigner.assignReference(entity, value, prop, options.em, options);
                 }
-                if (wrapped.__managed && (0, wrap_1.wrap)(unwrappedEntity).isInitialized()) {
+                if (wrapped.__managed && wrap(unwrappedEntity).isInitialized()) {
                     return EntityAssigner.assign(unwrappedEntity, value, options);
                 }
             }
             return EntityAssigner.assignReference(entity, value, prop, options.em, options);
         }
-        if (prop.kind === enums_1.ReferenceKind.SCALAR && enums_1.SCALAR_TYPES.includes(prop.runtimeType) && (prop.setter || !prop.getter)) {
-            return entity[prop.name] = validator.validateProperty(prop, value, entity);
+        if (prop.kind === ReferenceKind.SCALAR && SCALAR_TYPES.has(prop.runtimeType) && (prop.setter || !prop.getter)) {
+            validateProperty(prop, value, entity);
+            return entity[prop.name] = value;
         }
-        if (prop.kind === enums_1.ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
+        if (prop.kind === ReferenceKind.EMBEDDED && EntityAssigner.validateEM(options.em)) {
             return EntityAssigner.assignEmbeddable(entity, value, prop, options.em, options);
         }
-        if (options.mergeObjectProperties && Utils_1.Utils.isPlainObject(entity[propName]) && Utils_1.Utils.isPlainObject(value)) {
+        if (options.mergeObjectProperties && Utils.isPlainObject(entity[propName]) && Utils.isPlainObject(value)) {
             entity[propName] ??= {};
-            entity[propName] = Utils_1.Utils.merge({}, entity[propName], value);
+            entity[propName] = Utils.merge({}, entity[propName], value);
         }
         else if (!prop || prop.setter || !prop.getter) {
             entity[propName] = value;
@@ -110,18 +115,18 @@ class EntityAssigner {
      */
     static autoWireOneToOne(prop, entity) {
         const ref = entity[prop.name];
-        if (prop.kind !== enums_1.ReferenceKind.ONE_TO_ONE || !Utils_1.Utils.isEntity(ref)) {
+        if (prop.kind !== ReferenceKind.ONE_TO_ONE || !Utils.isEntity(ref)) {
             return;
         }
-        const meta2 = (0, wrap_1.helper)(ref).__meta;
+        const meta2 = helper(ref).__meta;
         const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (prop2 && !ref[prop2.name]) {
-            if (Reference_1.Reference.isReference(ref)) {
-                ref.unwrap()[prop2.name] = Reference_1.Reference.wrapReference(entity, prop2);
+            if (Reference.isReference(ref)) {
+                ref.unwrap()[prop2.name] = Reference.wrapReference(entity, prop2);
             }
             else {
-                ref[prop2.name] = Reference_1.Reference.wrapReference(entity, prop2);
+                ref[prop2.name] = Reference.wrapReference(entity, prop2);
             }
         }
     }
@@ -132,17 +137,17 @@ class EntityAssigner {
         return true;
     }
     static assignReference(entity, value, prop, em, options) {
-        if (Utils_1.Utils.isEntity(value, true)) {
-            entity[prop.name] = Reference_1.Reference.wrapReference(value, prop);
+        if (Utils.isEntity(value, true)) {
+            entity[prop.name] = Reference.wrapReference(value, prop);
         }
-        else if (Utils_1.Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = prop.mapToPk ? value : Reference_1.Reference.wrapReference(em.getReference(prop.type, value, options), prop);
+        else if (Utils.isPrimaryKey(value, true) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = prop.mapToPk ? value : Reference.wrapReference(em.getReference(prop.type, value, options), prop);
         }
-        else if (Utils_1.Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = Reference_1.Reference.wrapReference(em.merge(prop.type, value, options), prop);
+        else if (Utils.isPlainObject(value) && options.merge && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = Reference.wrapReference(em.merge(prop.type, value, options), prop);
         }
-        else if (Utils_1.Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
-            entity[prop.name] = Reference_1.Reference.wrapReference(em.create(prop.type, value, options), prop);
+        else if (Utils.isPlainObject(value) && EntityAssigner.validateEM(em)) {
+            entity[prop.name] = Reference.wrapReference(em.create(prop.type, value, options), prop);
         }
         else {
             const name = entity.constructor.name;
@@ -152,32 +157,31 @@ class EntityAssigner {
     }
     static assignCollection(entity, collection, value, prop, em, options) {
         const invalid = [];
-        const items = Utils_1.Utils.asArray(value).map((item, idx) => {
+        const items = Utils.asArray(value).map((item, idx) => {
             // try to propagate missing owning side reference to the payload first
             const prop2 = prop.targetMeta?.properties[prop.mappedBy];
-            if (Utils_1.Utils.isPlainObject(item) && prop2 && item[prop2.name] == null) {
-                item = { ...item, [prop2.name]: Reference_1.Reference.wrapReference(entity, prop2) };
+            if (Utils.isPlainObject(item) && prop2 && item[prop2.name] == null) {
+                item = { ...item, [prop2.name]: Reference.wrapReference(entity, prop2) };
             }
-            if (options.updateNestedEntities && options.updateByPrimaryKey && Utils_1.Utils.isPlainObject(item)) {
-                const pk = Utils_1.Utils.extractPK(item, prop.targetMeta);
+            if (options.updateNestedEntities && options.updateByPrimaryKey && Utils.isPlainObject(item)) {
+                const pk = Utils.extractPK(item, prop.targetMeta);
                 if (pk && EntityAssigner.validateEM(em)) {
                     const ref = em.getUnitOfWork().getById(prop.type, pk, options.schema);
-                    /* istanbul ignore else */
                     if (ref) {
                         return EntityAssigner.assign(ref, item, options);
                     }
                 }
                 return this.createCollectionItem(item, em, prop, invalid, options);
             }
-            /* istanbul ignore next */
-            if (options.updateNestedEntities && !options.updateByPrimaryKey && collection[idx] && (0, wrap_1.helper)(collection[idx])?.isInitialized()) {
+            /* v8 ignore next */
+            if (options.updateNestedEntities && !options.updateByPrimaryKey && collection[idx] && helper(collection[idx])?.isInitialized()) {
                 return EntityAssigner.assign(collection[idx], item, options);
             }
             return this.createCollectionItem(item, em, prop, invalid, options);
         });
         if (invalid.length > 0) {
             const name = entity.constructor.name;
-            throw new Error(`Invalid collection values provided for '${name}.${prop.name}' in ${name}.assign(): ${(0, node_util_1.inspect)(invalid)}`);
+            throw ValidationError.invalidCollectionValues(name, prop.name, invalid);
         }
         if (Array.isArray(value)) {
             collection.set(items);
@@ -197,7 +201,7 @@ class EntityAssigner {
             entity[propName] = [];
         }
         if (prop.array) {
-            return Utils_1.Utils.asArray(value).forEach(item => {
+            return Utils.asArray(value).forEach(item => {
                 const tmp = {};
                 this.assignEmbeddable(tmp, item, { ...prop, array: false }, em, options);
                 entity[propName].push(...Object.values(tmp));
@@ -213,21 +217,20 @@ class EntityAssigner {
         });
     }
     static createCollectionItem(item, em, prop, invalid, options) {
-        if (Utils_1.Utils.isEntity(item)) {
+        if (Utils.isEntity(item)) {
             return item;
         }
-        if (Utils_1.Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
+        if (Utils.isPrimaryKey(item) && EntityAssigner.validateEM(em)) {
             return em.getReference(prop.type, item, options);
         }
-        if (Utils_1.Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
+        if (Utils.isPlainObject(item) && options.merge && EntityAssigner.validateEM(em)) {
             return em.merge(prop.type, item, options);
         }
-        if (Utils_1.Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
+        if (Utils.isPlainObject(item) && EntityAssigner.validateEM(em)) {
             return em.create(prop.type, item, options);
         }
         invalid.push(item);
         return item;
     }
 }
-exports.EntityAssigner = EntityAssigner;
-exports.assign = EntityAssigner.assign;
+export const assign = EntityAssigner.assign;

package/entity/EntityFactory.d.ts

@@ -1,15 +1,21 @@
-import type { EntityData, EntityMetadata, EntityName, New, Primary } from '../typings';
-import type { EntityManager } from '../EntityManager';
-import type { EntityComparator } from '../utils/EntityComparator';
+import type { EntityData, EntityMetadata, EntityName, New, Primary } from '../typings.js';
+import type { EntityManager } from '../EntityManager.js';
+import type { EntityComparator } from '../utils/EntityComparator.js';
 export interface FactoryOptions {
     initialized?: boolean;
     newEntity?: boolean;
+    /**
+     * Property `onCreate` hooks are normally executed during `flush` operation.
+     * With this option, they will be processed early inside `em.create()` method.
+     */
+    processOnCreateHooksEarly?: boolean;
     merge?: boolean;
     refresh?: boolean;
     convertCustomTypes?: boolean;
     recomputeSnapshot?: boolean;
     schema?: string;
     parentSchema?: string;
+    normalizeAccessors?: boolean;
 }
 export declare class EntityFactory {
     private readonly em;
@@ -27,6 +33,7 @@ export declare class EntityFactory {
     createEmbeddable<T extends object>(entityName: EntityName<T>, data: EntityData<T>, options?: Pick<FactoryOptions, 'newEntity' | 'convertCustomTypes'>): T;
     getComparator(): EntityComparator;
     private createEntity;
+    private assignDefaultValues;
     private hydrate;
     private findEntity;
     private processDiscriminatorColumn;