@mikro-orm/core 7.0.0-dev.2 → 7.0.0-dev.4

package/EntityManager.js

@@ -250,7 +250,7 @@ export class EntityManager {
             aliased: type === 'read',
         });
         where = (await this.applyFilters(entityName, where, options.filters ?? {}, type, options));
-        where = await this.applyDiscriminatorCondition(entityName, where);
+        where = this.applyDiscriminatorCondition(entityName, where);
         return where;
     }
     // this method only handles the problem for mongo driver, SQL drivers have their implementation inside QueryBuilder
@@ -367,7 +367,7 @@ export 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;
@@ -717,7 +717,7 @@ export 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);
@@ -911,7 +911,7 @@ export 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/MikroORM.js

@@ -24,7 +24,7 @@ export class MikroORM {
      */
     static async init(options) {
         ConfigurationLoader.registerDotenv(options);
-        const coreVersion = await ConfigurationLoader.checkPackageVersion();
+        const coreVersion = ConfigurationLoader.checkPackageVersion();
         const env = await ConfigurationLoader.loadEnvironmentVars();
         if (!options) {
             const configPathFromArg = ConfigurationLoader.configPathsFromArg();
@@ -35,7 +35,7 @@ export class MikroORM {
             }
         }
         options = Utils.mergeConfig(options, env);
-        await ConfigurationLoader.commonJSCompat(options);
+        ConfigurationLoader.commonJSCompat(options);
         if ('DRIVER' in this && !options.driver) {
             options.driver = this.DRIVER;
         }

package/decorators/CreateRequestContext.js

@@ -4,10 +4,13 @@ import { TransactionContext } from '../utils/TransactionContext.js';
 export function CreateRequestContext(context, respectExistingContext = false) {
     return function (target, propertyKey, descriptor) {
         const originalMethod = descriptor.value;
+        const name = respectExistingContext ? 'EnsureRequestContext' : 'CreateRequestContext';
+        if (originalMethod.constructor.name !== 'AsyncFunction') {
+            throw new Error(`@${name}() should be use with async functions`);
+        }
         descriptor.value = async function (...args) {
             const em = await resolveContextProvider(this, context);
             if (!em) {
-                const name = respectExistingContext ? 'EnsureRequestContext' : 'CreateRequestContext';
                 throw new Error(`@${name}() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@${name}(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
             }
             // reuse existing context if available for given respect `contextName`

package/decorators/Entity.d.ts

@@ -1,11 +1,11 @@
-import type { Constructor, Dictionary, FilterQuery } from '../typings.js';
+import type { AnyString, Constructor, Dictionary, EntityClass, FilterQuery } from '../typings.js';
 import type { FindOptions } from '../drivers/IDatabaseDriver.js';
-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

@@ -8,6 +8,5 @@ export 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.js';
+import type { EntityClass, Dictionary, AutoPath } from '../typings.js';
 import type { DeferMode } from '../enums.js';
-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

@@ -3,7 +3,7 @@ import { Utils } from '../utils/Utils.js';
 function createDecorator(options, unique) {
     return function (target, propertyName) {
         const meta = 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

@@ -86,7 +86,9 @@ export 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.js';
+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.js';
 export * from './enums.js';
 export * from './errors.js';
 export * from './exceptions.js';

package/metadata/EntitySchema.d.ts

@@ -68,8 +68,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,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.2",
+  "version": "7.0.0-dev.4",
   "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.",
   "exports": {
     "./package.json": "./package.json",
@@ -55,7 +55,7 @@
     "dotenv": "16.4.7",
     "esprima": "4.0.1",
     "globby": "11.1.0",
-    "mikro-orm": "7.0.0-dev.2",
+    "mikro-orm": "7.0.0-dev.4",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -28,6 +28,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> = {
@@ -240,7 +241,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]>;
@@ -292,7 +293,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;
@@ -681,7 +683,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 @@ export 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

@@ -32,7 +32,7 @@ export class AbstractSchemaGenerator {
         }
         else {
             await this.ensureDatabase();
-            await this.dropSchema();
+            await this.dropSchema(options);
         }
         if (options?.createSchema !== false) {
             await this.createSchema(options);
@@ -103,7 +103,10 @@ export 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

@@ -74,7 +74,7 @@ export 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

@@ -17,7 +17,12 @@ export class RawQueryFragment {
         this.#key = `[raw]: ${this.sql} (#${RawQueryFragment.#index++})`;
     }
     as(alias) {
-        return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
+        // TODO: to be removed in v7
+        /* istanbul ignore next */
+        if (alias.startsWith('`') || alias.startsWith('"')) {
+            return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
+        }
+        return new RawQueryFragment(`${this.sql} as ??`, [...this.params, alias]);
     }
     valueOf() {
         throw new Error(`Trying to modify raw SQL fragment: '${this.sql}'`);