@mikro-orm/core 6.4.7-dev.2 → 6.4.7-dev.21

package/EntityManager.js

@@ -360,7 +360,7 @@ class EntityManager {
                 if (!args && filter.cond.length > 0 && filter.args !== false) {
                     throw new Error(`No arguments provided for filter '${filter.name}'`);
                 }
-                cond = await filter.cond(args, type, this, findOptions);
+                cond = await filter.cond(args, type, this, findOptions, entityName);
             }
             else {
                 cond = filter.cond;
@@ -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/index.d.ts

@@ -2,7 +2,7 @@
  * @packageDocumentation
  * @module core
  */
-export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, FilterKey, Opt, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, Hidden, FilterValue, MergeLoaded, MergeSelected, Config, DefineConfig, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, } from './typings';
+export { Constructor, ConnectionType, Dictionary, PrimaryKeyProp, Primary, IPrimaryKey, ObjectQuery, FilterQuery, IWrappedEntity, EntityName, EntityData, Highlighter, MaybePromise, AnyEntity, EntityClass, EntityProperty, EntityMetadata, QBFilterQuery, PopulateOptions, Populate, Loaded, New, LoadedReference, LoadedCollection, IMigrator, IMigrationGenerator, MigratorEvent, GetRepository, EntityRepositoryType, MigrationObject, DeepPartial, PrimaryProperty, Cast, IsUnknown, EntityDictionary, EntityDTO, MigrationDiff, GenerateOptions, FilterObject, IEntityGenerator, ISeedManager, EntityClassGroup, OptionalProps, EagerProps, HiddenProps, RequiredEntityData, CheckCallback, SimpleColumnMeta, Rel, Ref, ScalarRef, EntityRef, ISchemaGenerator, UmzugMigration, MigrateOptions, MigrationResult, MigrationRow, EntityKey, EntityValue, EntityDataValue, FilterKey, Opt, EntityType, FromEntityType, Selected, IsSubset, NoInfer, EntityProps, ExpandProperty, ExpandScalar, FilterItemValue, ExpandQuery, Scalar, ExpandHint, Hidden, FilterValue, MergeLoaded, MergeSelected, Config, DefineConfig, TypeConfig, ClearDatabaseOptions, CreateSchemaOptions, EnsureDatabaseOptions, UpdateSchemaOptions, DropSchemaOptions, RefreshDatabaseOptions, AutoPath, UnboxArray, MetadataProcessor, ImportsResolver, } from './typings';
 export * from './enums';
 export * from './errors';
 export * from './exceptions';

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.2",
+  "version": "6.4.7-dev.21",
   "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.2",
+    "mikro-orm": "6.4.7-dev.21",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -19,6 +19,7 @@ export type EntityKey<T = unknown, B extends boolean = false> = string & {
     [K in keyof T]-?: CleanKeys<T, K, B> extends never ? never : K;
 }[keyof T];
 export type EntityValue<T> = T[EntityKey<T>];
+export type EntityDataValue<T> = EntityData<T>[EntityKey<T>];
 export type FilterKey<T> = keyof FilterQuery<T>;
 export type AsyncFunction<R = any, T = Dictionary> = (args: T) => Promise<T>;
 export type Compute<T> = {
@@ -231,7 +232,7 @@ type IsOptional<T, K extends keyof T, I> = T[K] extends Collection<any, any> ? t
 type RequiredKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? CleanKeys<T, K> : never;
 type OptionalKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? never : CleanKeys<T, K>;
 export type EntityData<T, C extends boolean = false> = {
-    [K in EntityKey<T>]?: EntityDataItem<T[K], C>;
+    [K in EntityKey<T>]?: EntityDataItem<T[K] & {}, C>;
 };
 export type RequiredEntityData<T, I = never, C extends boolean = false> = {
     [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]>;
@@ -283,7 +284,8 @@ export type EntityDTO<T, C extends TypeConfig = never> = {
 } & {
     [K in keyof T as DTOOptionalKeys<T, K>]?: EntityDTOProp<T, T[K], C> | AddOptional<T[K]>;
 };
-export type CheckCallback<T> = (columns: Record<keyof T, string>) => string;
+type CheckKey<T> = IsUnknown<T> extends false ? keyof T : string;
+export type CheckCallback<T> = (columns: Record<CheckKey<T>, string>) => string;
 export type GeneratedColumnCallback<T> = (columns: Record<keyof T, string>) => string;
 export interface CheckConstraint<T = any> {
     name?: string;
@@ -671,7 +673,7 @@ export interface MigrationObject {
 }
 export type FilterDef = {
     name: string;
-    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>) => Dictionary | Promise<Dictionary>);
+    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>, entityName?: EntityName<any>) => Dictionary | Promise<Dictionary>);
     default?: boolean;
     entity?: string[];
     args?: boolean;

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);
     }
@@ -104,7 +104,10 @@ class AbstractSchemaGenerator {
         }
         return calc.sort()
             .map(cls => this.metadata.find(cls))
-            .filter(meta => schema ? [schema, '*'].includes(meta.schema) : meta.schema !== '*');
+            .filter(meta => {
+            const targetSchema = meta.schema ?? this.config.get('schema', this.platform.getDefaultSchemaName());
+            return schema ? [schema, '*'].includes(targetSchema) : meta.schema !== '*';
+        });
     }
     notImplemented() {
         throw new Error(`This method is not supported by ${this.driver.constructor.name} driver`);

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)},`);

package/utils/RawQueryFragment.js

@@ -24,6 +24,7 @@ class RawQueryFragment {
     }
     as(alias) {
         // TODO: to be removed in v7
+        /* istanbul ignore next */
         if (alias.startsWith('`') || alias.startsWith('"')) {
             return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
         }