@mikro-orm/core 7.0.0-dev.3 → 7.0.0-dev.300

package/entity/EntityHelper.js

@@ -1,11 +1,12 @@
-import { inspect } from 'node:util';
-import { EagerProps, EntityRepositoryType, HiddenProps, OptionalProps, PrimaryKeyProp, } from '../typings.js';
+import { EagerProps, EntityName, EntityRepositoryType, HiddenProps, OptionalProps, PrimaryKeyProp, } from '../typings.js';
 import { EntityTransformer } from '../serialization/EntityTransformer.js';
 import { Reference } from './Reference.js';
 import { Utils } from '../utils/Utils.js';
 import { WrappedEntity } from './WrappedEntity.js';
 import { ReferenceKind } from '../enums.js';
 import { helper } from './wrap.js';
+import { inspect } from '../logging/inspect.js';
+import { getEnv } from '../utils/env-vars.js';
 /**
  * @internal
  */
@@ -31,15 +32,25 @@ export class EntityHelper {
         }
         const prototype = meta.prototype;
         if (!prototype.toJSON) { // toJSON can be overridden
-            prototype.toJSON = function (...args) {
-                return EntityTransformer.toObject(this, ...args.slice(meta.toJsonParams.length));
-            };
+            Object.defineProperty(prototype, 'toJSON', {
+                value: function (...args) {
+                    // Guard against being called on the prototype itself (e.g. by serializers
+                    // walking the object graph and calling toJSON on prototype objects)
+                    if (this === prototype) {
+                        return {};
+                    }
+                    return EntityTransformer.toObject(this, ...args);
+                },
+                writable: true,
+                configurable: true,
+                enumerable: false,
+            });
         }
     }
     /**
-     * As a performance optimization, we create entity state methods in a lazy manner. We first add
+     * As a performance optimization, we create entity state methods lazily. We first add
      * the `null` value to the prototype to reserve space in memory. Then we define a setter on the
-     * prototype, that will be executed exactly once per entity instance. There we redefine given
+     * prototype that will be executed exactly once per entity instance. There we redefine the given
      * property on the entity instance, so shadowing the prototype setter.
      */
     static defineBaseProperties(meta, prototype, em) {
@@ -87,7 +98,7 @@ export class EntityHelper {
                 });
                 return;
             }
-            if (prop.inherited || prop.primary || prop.persist === false || prop.trackChanges === false || prop.embedded || isCollection) {
+            if (prop.inherited || prop.primary || prop.accessor || prop.persist === false || prop.embedded || isCollection) {
                 return;
             }
             Object.defineProperty(meta.prototype, prop.name, {
@@ -98,13 +109,11 @@ export class EntityHelper {
                         },
                         set(val) {
                             this.__helper.__data[prop.name] = val;
-                            this.__helper.__touched = !this.__helper.hydrator.isRunning();
                         },
                         enumerable: true,
                         configurable: true,
                     });
                     this.__helper.__data[prop.name] = val;
-                    this.__helper.__touched = !this.__helper.hydrator.isRunning();
                 },
                 configurable: true,
             });
@@ -112,16 +121,27 @@ export class EntityHelper {
     }
     static defineCustomInspect(meta) {
         // @ts-ignore
-        meta.prototype[inspect.custom] ??= function (depth = 2) {
-            const object = { ...this };
+        meta.prototype[Symbol.for('nodejs.util.inspect.custom')] ??= function (depth = 2) {
+            const object = {};
+            const keys = new Set(Utils.keys(this));
+            for (const prop of meta.props) {
+                if (keys.has(prop.name) || (prop.getter && prop.accessor === prop.name)) {
+                    object[prop.name] = this[prop.name];
+                }
+            }
+            for (const key of keys) {
+                if (!meta.properties[key]) {
+                    object[key] = this[key];
+                }
+            }
             // ensure we dont have internal symbols in the POJO
-            [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps].forEach(sym => delete object[sym]);
+            [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps, EntityName].forEach(sym => delete object[sym]);
             meta.props
                 .filter(prop => object[prop.name] === undefined)
                 .forEach(prop => delete object[prop.name]);
             const ret = inspect(object, { depth });
-            let name = (this).constructor.name;
-            const showEM = ['true', 't', '1'].includes(process.env.MIKRO_ORM_LOG_EM_ID?.toString().toLowerCase() ?? '');
+            let name = this.constructor.name;
+            const showEM = ['true', 't', '1'].includes(getEnv('MIKRO_ORM_LOG_EM_ID')?.toLowerCase() ?? '');
             if (showEM) {
                 if (helper(this).__em) {
                     name += ` [managed by ${helper(this).__em.id}]`;
@@ -146,13 +166,13 @@ export class EntityHelper {
             set(val) {
                 const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
                 const old = Reference.unwrapReference(wrapped.__data[prop.name]);
+                if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
+                    old[prop.inversedBy].removeWithoutPropagation(this);
+                }
                 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(wrapped.__data[prop.name], prop.targetMeta.primaryKeys, true);
-                }
-                else {
-                    wrapped.__touched = !hydrator.isRunning();
+                    wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta, true);
                 }
                 EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
             },
@@ -161,7 +181,19 @@ export class EntityHelper {
         });
     }
     static propagate(meta, entity, owner, prop, value, old) {
-        for (const prop2 of prop.targetMeta.bidirectionalRelations) {
+        // For polymorphic relations, get bidirectional relations from the actual entity's metadata
+        let bidirectionalRelations;
+        if (prop.polymorphic && prop.polymorphTargets?.length) {
+            // For polymorphic relations, we need to get the bidirectional relations from the actual value's metadata
+            if (!value) {
+                return; // No value means no propagation needed
+            }
+            bidirectionalRelations = helper(value).__meta.bidirectionalRelations;
+        }
+        else {
+            bidirectionalRelations = prop.targetMeta.bidirectionalRelations;
+        }
+        for (const prop2 of bidirectionalRelations) {
             if ((prop2.inversedBy || prop2.mappedBy) !== prop.name) {
                 continue;
             }
@@ -169,6 +201,13 @@ export class EntityHelper {
                 continue;
             }
             const inverse = value?.[prop2.name];
+            if (prop.ref && owner[prop.name]) {
+                // eslint-disable-next-line dot-notation
+                owner[prop.name]['property'] = prop;
+            }
+            if (Utils.isCollection(inverse) && inverse.isPartial()) {
+                continue;
+            }
             if (prop.kind === ReferenceKind.MANY_TO_ONE && Utils.isCollection(inverse) && inverse.isInitialized()) {
                 inverse.addWithoutPropagation(owner);
                 helper(owner).__em?.getUnitOfWork().cancelOrphanRemoval(owner);
@@ -196,6 +235,11 @@ export class EntityHelper {
                 helper(other).__em?.getUnitOfWork().scheduleOrphanRemoval(other);
             }
         }
+        // Skip setting the inverse side to null if it's a primary key - the entity will be removed via orphan removal
+        // Setting a primary key to null would corrupt the entity and cause validation errors
+        if (value == null && prop.orphanRemoval && prop2.primary) {
+            return;
+        }
         if (value == null) {
             entity[prop2.name] = value;
         }
@@ -207,6 +251,7 @@ export class EntityHelper {
         }
         if (old?.[prop2.name] != null) {
             delete helper(old).__data[prop2.name];
+            old[prop2.name] = null;
         }
     }
     static ensurePropagation(entity) {

package/entity/EntityLoader.d.ts

@@ -1,26 +1,26 @@
-import type { ConnectionType, Dictionary, FilterQuery, PopulateOptions } from '../typings.js';
+import type { AnyEntity, AutoPath, ConnectionType, EntityName, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
-import type { EntityField } from '../drivers/IDatabaseDriver.js';
+import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 import type { LoggingOptions } from '../logging/Logger.js';
-export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> = {
+export interface EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
+    fields?: readonly AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
+    exclude?: readonly AutoPath<Entity, Excludes>[];
     where?: FilterQuery<Entity>;
     populateWhere?: PopulateHint | `${PopulateHint}`;
-    fields?: readonly EntityField<Entity, Fields>[];
-    exclude?: readonly EntityField<Entity, Excludes>[];
     orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     refresh?: boolean;
     validate?: boolean;
     lookup?: boolean;
     convertCustomTypes?: boolean;
     ignoreLazyScalarProperties?: boolean;
-    filters?: Dictionary<boolean | Dictionary> | string[] | boolean;
-    strategy?: LoadStrategy;
+    filters?: FilterOptions;
+    strategy?: LoadStrategy | `${LoadStrategy}`;
     lockMode?: Exclude<LockMode, LockMode.OPTIMISTIC>;
     schema?: string;
     connectionType?: ConnectionType;
     logging?: LoggingOptions;
-};
+}
 export declare class EntityLoader {
     private readonly em;
     private readonly metadata;
@@ -30,8 +30,8 @@ export declare class EntityLoader {
      * Loads specified relations in batch.
      * This will execute one query for each relation, that will populate it on all the specified entities.
      */
-    populate<Entity extends object, Fields extends string = PopulatePath.ALL>(entityName: string, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
-    normalizePopulate<Entity>(entityName: string, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean): PopulateOptions<Entity>[];
+    populate<Entity extends object, Fields extends string = PopulatePath.ALL>(entityName: EntityName<Entity>, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
+    normalizePopulate<Entity>(entityName: EntityName<Entity>, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean, exclude?: string[]): PopulateOptions<Entity>[];
     private setSerializationContext;
     /**
      * Merge multiple populates for the same entity with different children. Also skips `*` fields, those can come from
@@ -43,13 +43,15 @@ export declare class EntityLoader {
      */
     private populateMany;
     private populateScalar;
+    private populatePolymorphic;
     private initializeCollections;
     private initializeOneToMany;
     private initializeManyToMany;
     private findChildren;
     private mergePrimaryCondition;
     private populateField;
-    private findChildrenFromPivotTable;
+    /** @internal */
+    findChildrenFromPivotTable<Entity extends object>(filtered: Entity[], prop: EntityProperty<Entity>, options: Required<EntityLoaderOptions<Entity>>, orderBy?: QueryOrderMap<Entity>[], populate?: PopulateOptions<Entity>, pivotJoin?: boolean): Promise<AnyEntity[][]>;
     private extractChildCondition;
     private buildFields;
     private getChildReferences;