@mikro-orm/core 6.4.7-dev.8 → 6.4.7

package/EntityManager.js

@@ -702,7 +702,7 @@ class EntityManager {
                 convertCustomTypes: true,
                 connectionType: 'write',
             });
-            em.getHydrator().hydrate(entity, meta, data2, em.entityFactory, 'full');
+            em.getHydrator().hydrate(entity, meta, data2, em.entityFactory, 'full', false, true);
         }
         // recompute the data as there might be some values missing (e.g. those with db column defaults)
         const snapshot = this.comparator.prepareEntity(entity);
@@ -897,7 +897,7 @@ class EntityManager {
                 if (!row) {
                     throw new Error(`Cannot find matching entity for condition ${JSON.stringify(cond)}`);
                 }
-                em.getHydrator().hydrate(entity, meta, row, em.entityFactory, 'full');
+                em.getHydrator().hydrate(entity, meta, row, em.entityFactory, 'full', false, true);
             }
             if (loadPK.size !== data2.length && Array.isArray(uniqueFields)) {
                 for (let i = 0; i < allData.length; i++) {

package/decorators/Entity.d.ts

@@ -1,11 +1,11 @@
-import type { Constructor, Dictionary, FilterQuery } from '../typings';
+import type { AnyString, Constructor, Dictionary, EntityClass, FilterQuery } from '../typings';
 import type { FindOptions } from '../drivers/IDatabaseDriver';
-export declare function Entity(options?: EntityOptions<any>): <T>(target: T & Dictionary) => T & Dictionary;
+export declare function Entity<T extends EntityClass<unknown>>(options?: EntityOptions<T>): (target: T) => void;
 export type EntityOptions<T> = {
     tableName?: string;
     schema?: string;
     collection?: string;
-    discriminatorColumn?: string;
+    discriminatorColumn?: (T extends EntityClass<infer P> ? keyof P : string) | AnyString;
     discriminatorMap?: Dictionary<string>;
     discriminatorValue?: number | string;
     forceConstructor?: boolean;

package/decorators/Entity.js

@@ -11,6 +11,5 @@ function Entity(options = {}) {
         if (!options.abstract || meta.discriminatorColumn) {
             meta.name = target.name;
         }
-        return target;
     };
 }

package/decorators/Indexed.d.ts

@@ -1,17 +1,19 @@
-import type { AnyEntity, Dictionary } from '../typings';
+import type { EntityClass, Dictionary, AutoPath } from '../typings';
 import type { DeferMode } from '../enums';
-export declare function Index<T>(options?: IndexOptions<T>): (target: AnyEntity, propertyName?: string) => any;
-export declare function Unique<T>(options?: UniqueOptions<T>): (target: AnyEntity, propertyName?: string) => any;
-interface BaseOptions<T> {
+export declare function Index<T extends object, H extends string>(options?: IndexOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
+export declare function Unique<T extends object, H extends string>(options?: UniqueOptions<T, H>): (target: T, propertyName?: (T extends EntityClass<unknown> ? undefined : keyof T) | undefined) => any;
+type MaybeArray<T> = T | T[];
+type Properties<T, H extends string> = MaybeArray<AutoPath<T, H>>;
+interface BaseOptions<T, H extends string> {
     name?: string;
-    properties?: keyof T | (keyof T)[];
+    properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
     options?: Dictionary;
     expression?: string;
 }
-export interface UniqueOptions<T> extends BaseOptions<T> {
+export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
     deferMode?: DeferMode | `${DeferMode}`;
 }
-export interface IndexOptions<T> extends BaseOptions<T> {
+export interface IndexOptions<T, H extends string = string> extends BaseOptions<T, H> {
     type?: string;
 }
 export {};

package/decorators/Indexed.js

@@ -7,7 +7,7 @@ const Utils_1 = require("../utils/Utils");
 function createDecorator(options, unique) {
     return function (target, propertyName) {
         const meta = metadata_1.MetadataStorage.getMetadataFromDecorator(propertyName ? target.constructor : target);
-        options.properties = options.properties || propertyName;
+        options.properties ??= propertyName;
         const key = unique ? 'uniques' : 'indexes';
         meta[key].push(options);
         if (!propertyName) {

package/entity/EntityFactory.js

@@ -89,7 +89,9 @@ class EntityFactory {
         }
         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,
             });

package/metadata/EntitySchema.d.ts

@@ -60,8 +60,8 @@ export declare class EntitySchema<Entity = any, Base = never> {
     addManyToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: ManyToManyOptions<Entity, Target>): void;
     addOneToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToManyOptions<Entity, Target>): void;
     addOneToOne<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToOneOptions<Entity, Target>): void;
-    addIndex(options: IndexOptions<Entity>): void;
-    addUnique(options: UniqueOptions<Entity>): void;
+    addIndex<Key extends string>(options: IndexOptions<Entity, Key>): void;
+    addUnique<Key extends string>(options: UniqueOptions<Entity, Key>): void;
     setCustomRepository(repository: () => Constructor): void;
     setExtends(base: string | EntitySchema): void;
     setClass(proto: EntityClass<Entity>): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.7-dev.8",
+  "version": "6.4.7",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.4.7-dev.8",
+    "mikro-orm": "6.4.7",
     "reflect-metadata": "0.2.2"
   }
 }

package/unit-of-work/UnitOfWork.js

@@ -884,7 +884,7 @@ class UnitOfWork {
                 collectionUpdates.push(coll);
             }
         }
-        await this.em.getDriver().syncCollections(collectionUpdates, { ctx });
+        await this.em.getDriver().syncCollections(collectionUpdates, { ctx, schema: this.em.schema });
         for (const coll of this.collectionUpdates) {
             coll.takeSnapshot();
         }

package/utils/AbstractSchemaGenerator.js

@@ -35,7 +35,7 @@ class AbstractSchemaGenerator {
         }
         else {
             await this.ensureDatabase();
-            await this.dropSchema();
+            await this.dropSchema(options);
         }
         await this.createSchema(options);
     }

package/utils/EntityComparator.js

@@ -77,7 +77,7 @@ class EntityComparator {
                 lines.push(`  if (entity${this.wrap(pk)} != null && (entity${this.wrap(pk)}.__entity || entity${this.wrap(pk)}.__reference)) {`);
                 lines.push(`    const pk = entity${this.wrap(pk)}.__helper.getPrimaryKey();`);
                 if (meta.properties[pk].targetMeta.compositePK) {
-                    lines.push(`    if (typeof pk === 'object') {`);
+                    lines.push(`    if (typeof pk === 'object' && pk != null) {`);
                     lines.push(`      return [`);
                     for (const childPK of meta.properties[pk].targetMeta.primaryKeys) {
                         lines.push(`        pk${this.wrap(childPK)},`);