@mikro-orm/core 7.0.7-dev.9 → 7.0.8-dev.0

package/entity/EntityFactory.js

@@ -47,11 +47,32 @@ export class EntityFactory {
         const exists = this.findEntity(data, meta2, options);
         let wrapped = exists && helper(exists);
         if (wrapped && !options.refresh) {
+            const wasInitialized = wrapped.isInitialized();
             wrapped.__processing = true;
             Utils.dropUndefinedProperties(data);
             this.mergeData(meta2, exists, data, options);
             wrapped.__processing = false;
+            wrapped.__initialized ||= !!options.initialized;
             if (wrapped.isInitialized()) {
+                if (!wasInitialized) {
+                    if (meta.root.inheritanceType && !(exists instanceof meta2.class)) {
+                        Object.setPrototypeOf(exists, meta2.prototype);
+                    }
+                    if (options.merge && wrapped.hasPrimaryKey()) {
+                        this.unitOfWork.register(exists, data, { loaded: options.initialized });
+                        // ensure all data keys are tracked as loaded for shouldRefresh checks,
+                        // but don't overwrite __originalEntityData — mergeData already set it
+                        // with DB values for non-user-modified keys, leaving user changes detectable
+                        for (const key of Utils.keys(data)) {
+                            if (meta2.properties[key]) {
+                                wrapped.__loadedProperties.add(key);
+                            }
+                        }
+                    }
+                    if (this.#eventManager.hasListeners(EventType.onInit, meta2)) {
+                        this.#eventManager.dispatchEvent(EventType.onInit, { entity: exists, meta: meta2, em: this.#em });
+                    }
+                }
                 return exists;
             }
         }
@@ -125,8 +146,18 @@ export class EntityFactory {
             diff[meta.versionProperty] = data[meta.versionProperty];
         }
         const diff2 = this.#comparator.diffEntities(meta.class, existsData, data, { includeInverseSides: true });
-        // do not override values changed by user
-        Utils.keys(diff).forEach(key => delete diff2[key]);
+        // do not override values changed by user; for uninitialized entities,
+        // the diff may include stale snapshot entries (value is undefined) — skip those
+        if (helper(entity).__initialized) {
+            Utils.keys(diff).forEach(key => delete diff2[key]);
+        }
+        else {
+            Utils.keys(diff).forEach(key => {
+                if (diff[key] !== undefined) {
+                    delete diff2[key];
+                }
+            });
+        }
         Utils.keys(diff2)
             .filter(key => {
             // ignore null values if there is already present non-null value

package/entity/EntityHelper.js

@@ -223,10 +223,20 @@ export class EntityHelper {
                     if (entity && (!prop.owner || helper(entity).__initialized)) {
                         EntityHelper.propagateOneToOne(entity, owner, prop, prop2, value, old);
                     }
-                    if (old && prop.orphanRemoval) {
-                        helper(old).__em?.getUnitOfWork().scheduleOrphanRemoval(old);
+                }
+                else if (old && old !== value) {
+                    // Inverse already points to owner — propagation is not needed,
+                    // but we still need to clean up old's inverse side.
+                    helper(old).__pk ??= helper(old).getPrimaryKey();
+                    if (old[prop2.name] != null) {
+                        delete helper(old).__data[prop2.name];
+                        old[prop2.name] = null;
                     }
                 }
+                if (old && old !== value && prop.orphanRemoval) {
+                    helper(old).__pk ??= helper(old).getPrimaryKey();
+                    helper(old).__em?.getUnitOfWork().scheduleOrphanRemoval(old);
+                }
             }
         }
     }

package/entity/EntityLoader.js

@@ -399,10 +399,17 @@ export class EntityLoader {
             for (const child of children) {
                 childrenMap.add(getKey(child));
             }
+            const isInverseOneToOne = prop.kind === ReferenceKind.ONE_TO_ONE && !prop.owner;
             for (const entity of entities) {
-                const ref = entity[prop.name] ?? {};
-                const key = helper(ref) ? getKey(ref) : undefined;
-                if (key && childrenMap.has(key) && !itemsMap.has(key)) {
+                const ref = entity[prop.name];
+                if (ref == null) {
+                    continue;
+                }
+                const refKey = getKey(ref);
+                // For 1:1 inverse, `children` contains parent entities, so `childrenMap`
+                // has parent PKs — match against the entity's own PK, not the referenced entity's PK.
+                const childKey = isInverseOneToOne ? getKey(entity) : refKey;
+                if (childrenMap.has(childKey) && !itemsMap.has(refKey)) {
                     entity[prop.name] = nullVal;
                     helper(entity).__originalEntityData[prop.name] = null;
                 }

package/entity/defineEntity.d.ts

@@ -1,6 +1,6 @@
 import type { EntityManager } from '../EntityManager.js';
 import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions, IndexColumnOptions } from '../metadata/types.js';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config } from '../typings.js';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config, MaybePromise } from '../typings.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
@@ -9,7 +9,7 @@ import type { EventSubscriber } from '../events/EventSubscriber.js';
 import type { IType, Type } from '../types/Type.js';
 import { types } from '../types/index.js';
 import type { Collection } from './Collection.js';
-import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
+import type { FilterOptions, FindOptions, FindOneOptions } from '../drivers/IDatabaseDriver.js';
 /** Union of all option keys supported across all property definition types (scalar, enum, embedded, relations). */
 export type UniversalPropertyKeys = keyof PropertyOptions<any> | keyof EnumOptions<any> | keyof EmbeddedOptions<any, any> | keyof ReferenceOptions<any, any> | keyof ManyToOneOptions<any, any> | keyof OneToManyOptions<any, any> | keyof OneToOneOptions<any, any> | keyof ManyToManyOptions<any, any>;
 type BuilderExtraKeys = '~options' | '~type' | '$type' | 'strictNullable';
@@ -556,16 +556,24 @@ export type PropertyBuilders = {
 /** Own keys + base entity keys (when TBase is not `never`). Guards against `keyof never = string | number | symbol`. */
 type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends true ? never : keyof TBase);
 /** Metadata descriptor for `defineEntity()`, combining entity options with property definitions. */
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'orderBy'> {
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'filters' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
         '~entity': TBase;
     } | EntityCtor<TBase>;
     properties: TProperties | ((properties: PropertyBuilders) => TProperties);
-    primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
+    primaryKeys?: TPK & InferPrimaryKeyConstraint<TProperties>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
+    filters?: Dictionary<{
+        name: string;
+        cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: string) => MaybePromise<FilterQuery<any>>);
+        default?: boolean;
+        entity?: EntityName<any> | EntityName<any>[];
+        args?: boolean;
+        strict?: boolean;
+    }>;
     forceObject?: TForceObject;
     inheritance?: 'tpt';
     orderBy?: {
@@ -671,6 +679,14 @@ export type InferPrimaryKey<Properties extends Record<string, any>> = {
         };
     } ? K : never;
 }[keyof Properties];
+/** Like InferPrimaryKey, but skips evaluating function return types to prevent circular inference (GH #7445). */
+export type InferPrimaryKeyConstraint<Properties extends Record<string, any>> = {
+    [K in keyof Properties]: Properties[K] extends (...args: any) => any ? K : Properties[K] extends {
+        '~options': {
+            primary: true;
+        };
+    } ? K : never;
+}[keyof Properties];
 type InferBuilderValue<Builder> = Builder extends {
     '~type'?: {
         value: infer Value;
@@ -706,6 +722,9 @@ type MaybeScalarRef<Value, Options> = Options extends {
 } ? Value : Options extends {
     ref: true;
 } ? ScalarReference<Value> : Value;
+type IsAllPropsOpt<T> = [Exclude<keyof T, symbol>] extends [never] ? false : {
+    [K in Exclude<keyof T, symbol>]-?: T[K] extends Opt ? never : K;
+}[Exclude<keyof T, symbol>] extends never ? true : false;
 type MaybeOpt<Value, Options> = Options extends {
     mapToPk: true;
 } ? Value extends Opt<infer OriginalValue> ? OriginalValue : Value : Options extends {
@@ -722,7 +741,9 @@ type MaybeOpt<Value, Options> = Options extends {
     version: true;
 } | {
     formula: string | ((...args: any[]) => any);
-} ? Opt<NonNullable<Value>> | Extract<Value, null | undefined> : Value;
+} ? Opt<NonNullable<Value>> | Extract<Value, null | undefined> : Options extends {
+    kind: 'embedded';
+} ? IsAllPropsOpt<Value> extends true ? Opt<NonNullable<Value>> | Extract<Value, null | undefined> : Value : Value;
 type MaybeHidden<Value, Options> = Options extends {
     hidden: true;
 } ? Hidden<NonNullable<Value>> | Extract<Value, null | undefined> : Value;

package/metadata/MetadataDiscovery.js

@@ -428,13 +428,13 @@ export class MetadataDiscovery {
             prop.fieldNames = this.initManyToManyFieldName(prop, prop.name);
         }
     }
-    initManyToOneFieldName(prop, name, tableName) {
+    initManyToOneFieldName(prop, name) {
         const meta2 = prop.targetMeta;
         const ret = [];
         for (const primaryKey of meta2.primaryKeys) {
             this.initFieldName(meta2.properties[primaryKey]);
             for (const fieldName of meta2.properties[primaryKey].fieldNames) {
-                ret.push(this.#namingStrategy.joinKeyColumnName(name, fieldName, meta2.compositePK, tableName));
+                ret.push(this.#namingStrategy.joinKeyColumnName(name, fieldName, meta2.compositePK));
             }
         }
         return ret;
@@ -487,11 +487,9 @@ export class MetadataDiscovery {
             prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.#namingStrategy.joinKeyColumnName(prop.discriminator, referencedColumnName, prop.referencedColumnNames.length > 1));
         }
         else {
-            const ownerTableName = this.isExplicitTableName(meta.root) ? meta.root.tableName : undefined;
-            prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.#namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK, ownerTableName));
+            prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.#namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK));
         }
-        const inverseTableName = this.isExplicitTableName(meta2.root) ? meta2.root.tableName : undefined;
-        prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className, inverseTableName);
+        prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className);
     }
     isExplicitTableName(meta) {
         return meta.tableName !== this.#namingStrategy.classToTableName(meta.className);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.7-dev.9",
+  "version": "7.0.8-dev.0",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/typings.d.ts

@@ -1300,6 +1300,10 @@ export interface EntitySchemaWithMeta<TName extends string = string, TTableName
     readonly tableName: TTableName;
     /** @internal Direct entity type access - avoids expensive pattern matching */
     readonly '~entity': TEntity;
+    /** @internal */
+    readonly class: TClass & {
+        '~entityName'?: TName;
+    };
 }
 /**
  * Extracts the entity type from an `EntitySchema`, `EntitySchemaWithMeta`, or entity class.

package/unit-of-work/ChangeSetPersister.js

@@ -101,6 +101,8 @@ export class ChangeSetPersister {
                 !prop.generated &&
                 !prop.embedded &&
                 ![ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(prop.kind) &&
+                !(prop.kind === ReferenceKind.EMBEDDED &&
+                    prop.targetMeta?.props.every(p => p.formula || p.persist === false || p.primary)) &&
                 prop.name !== wrapped.__meta.root.discriminatorColumn &&
                 prop.type !== 'ObjectId' &&
                 prop.persist !== false &&

package/utils/Utils.js

@@ -132,7 +132,7 @@ export function parseJsonSafe(value) {
 /** Collection of general-purpose utility methods used throughout the ORM. */
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.7-dev.9';
+    static #ORM_VERSION = '7.0.8-dev.0';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */