@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/entity/EntityHelper.d.ts

@@ -6,9 +6,9 @@ import { type EntityMetadata, type EntityProperty, type IHydrator } from '../typ
 export declare class EntityHelper {
     static decorate<T extends object>(meta: EntityMetadata<T>, em: EntityManager): void;
     /**
-     * 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.
      */
     private static defineBaseProperties;

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
  */
@@ -30,19 +31,31 @@ export class EntityHelper {
             EntityHelper.defineProperties(meta, fork);
         }
         const prototype = meta.prototype;
-        if (!prototype.toJSON) { // toJSON can be overridden
-            prototype.toJSON = function (...args) {
-                return EntityTransformer.toObject(this, ...args.slice(meta.toJsonParams.length));
-            };
+        if (!prototype.toJSON) {
+            // toJSON can be overridden
+            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) {
+        // oxfmt-ignore
         const helperParams = meta.embeddable || meta.virtual ? [] : [em.getComparator().getPkGetter(meta), em.getComparator().getPkSerializer(meta), em.getComparator().getPkGetterConverted(meta)];
         Object.defineProperties(prototype, {
             __entity: { value: !meta.embeddable, configurable: true },
@@ -72,10 +85,9 @@ export class EntityHelper {
      * than on its prototype. Thanks to this we still have those properties enumerable (e.g. part of `Object.keys(entity)`).
      */
     static defineProperties(meta, em) {
-        Object
-            .values(meta.properties)
-            .forEach(prop => {
+        Object.values(meta.properties).forEach(prop => {
             const isCollection = [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind);
+            // oxfmt-ignore
             const isReference = [ReferenceKind.ONE_TO_ONE, ReferenceKind.MANY_TO_ONE].includes(prop.kind) && (prop.inversedBy || prop.mappedBy) && !prop.mapToPk;
             if (isReference) {
                 Object.defineProperty(meta.prototype, prop.name, {
@@ -87,7 +99,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 +110,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 +122,25 @@ 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]);
-            meta.props
-                .filter(prop => object[prop.name] === undefined)
-                .forEach(prop => delete object[prop.name]);
+            [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,6 +165,7 @@ export class EntityHelper {
             set(val) {
                 const entity = Reference.unwrapReference(val ?? wrapped.__data[prop.name]);
                 const old = Reference.unwrapReference(wrapped.__data[prop.name]);
+                // oxfmt-ignore
                 if (old && old !== entity && prop.kind === ReferenceKind.MANY_TO_ONE && prop.inversedBy && old[prop.inversedBy]) {
                     old[prop.inversedBy].removeWithoutPropagation(this);
                 }
@@ -154,9 +174,6 @@ export class EntityHelper {
                 if (val && hydrator.isRunning() && wrapped.__originalEntityData && prop.owner) {
                     wrapped.__originalEntityData[prop.name] = Utils.getPrimaryKeyValues(wrapped.__data[prop.name], prop.targetMeta, true);
                 }
-                else {
-                    wrapped.__touched = !hydrator.isRunning();
-                }
                 EntityHelper.propagate(meta, entity, this, prop, Reference.unwrapReference(val), old);
             },
             enumerable: true,
@@ -164,14 +181,31 @@ 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;
             }
+            // oxfmt-ignore
             if (prop2.targetMeta.abstract ? prop2.targetMeta.root.class !== meta.root.class : prop2.targetMeta.class !== meta.class) {
                 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;
             }
@@ -195,13 +229,21 @@ export class EntityHelper {
     static propagateOneToOne(entity, owner, prop, prop2, value, old) {
         helper(entity).__pk = helper(entity).getPrimaryKey();
         // the inverse side will be changed on the `value` too, so we need to clean-up and schedule orphan removal there too
-        if (!prop.primary && !prop2.mapToPk && value?.[prop2.name] != null && Reference.unwrapReference(value[prop2.name]) !== entity) {
+        if (!prop.primary &&
+            !prop2.mapToPk &&
+            value?.[prop2.name] != null &&
+            Reference.unwrapReference(value[prop2.name]) !== entity) {
             const other = Reference.unwrapReference(value[prop2.name]);
             delete helper(other).__data[prop.name];
             if (prop2.orphanRemoval) {
                 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;
         }

package/entity/EntityLoader.d.ts

@@ -1,37 +1,35 @@
-import type { AnyEntity, ConnectionType, Dictionary, EntityProperty, 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;
-    private readonly driver;
+    #private;
     constructor(em: EntityManager);
     /**
      * 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,6 +41,7 @@ export declare class EntityLoader {
      */
     private populateMany;
     private populateScalar;
+    private populatePolymorphic;
     private initializeCollections;
     private initializeOneToMany;
     private initializeManyToMany;