@mikro-orm/core 7.0.0-rc.0 → 7.0.0-rc.2

package/EntityManager.d.ts

@@ -456,7 +456,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * 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, Naked extends FromEntityType<UnboxArray<Entity>> = FromEntityType<UnboxArray<Entity>>, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entities: Entity, populate: readonly AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Entity extends object[] ? MergeLoaded<ArrayElement<Entity>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Entity, Naked, Hint, Fields, Excludes>>;
+    populate<Entity extends object, Naked extends FromEntityType<UnboxArray<Entity>> = FromEntityType<UnboxArray<Entity>>, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entities: Entity, populate: readonly AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Entity extends object[] ? MergeLoaded<ArrayElement<Entity>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Entity, Naked, Hint, Fields, Excludes>>;
     /**
      * Returns new EntityManager instance with its own identity map
      */
@@ -515,7 +515,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     private lockAndPopulate;
     private buildFields;
     /** @internal */
-    preparePopulate<Entity extends object>(entityName: EntityName<Entity>, options: Pick<FindOptions<Entity, any, any, any>, 'populate' | 'strategy' | 'fields' | 'flags' | 'filters' | 'exclude'>, validate?: boolean): Promise<PopulateOptions<Entity>[]>;
+    preparePopulate<Entity extends object>(entityName: EntityName<Entity>, options: Pick<FindOptions<Entity, any, any, any>, 'populate' | 'strategy' | 'fields' | 'flags' | 'filters' | 'exclude' | 'populateHints'>, validate?: boolean): Promise<PopulateOptions<Entity>[]>;
     /**
      * when the entity is found in identity map, we check if it was partially loaded or we are trying to populate
      * some additional lazy properties, if so, we reload and merge the data from database

package/EntityManager.js

@@ -1,7 +1,6 @@
 import { getOnConflictReturningFields, getWhereCondition } from './utils/upsert-utils.js';
 import { Utils } from './utils/Utils.js';
 import { Cursor } from './utils/Cursor.js';
-import { DataloaderUtils } from './utils/DataloaderUtils.js';
 import { QueryHelper } from './utils/QueryHelper.js';
 import { TransactionContext } from './utils/TransactionContext.js';
 import { isRaw, Raw } from './utils/RawQueryFragment.js';
@@ -17,7 +16,7 @@ import { EventType, FlushMode, LoadStrategy, LockMode, PopulateHint, PopulatePat
 import { EventManager } from './events/EventManager.js';
 import { TransactionEventBroadcaster } from './events/TransactionEventBroadcaster.js';
 import { OptimisticLockError, ValidationError } from './errors.js';
-import { getLoadingStrategy } from './entity/utils.js';
+import { applyPopulateHints, getLoadingStrategy } from './entity/utils.js';
 import { TransactionManager } from './utils/TransactionManager.js';
 /**
  * The EntityManager is the central access point to ORM functionality. It is a facade to all different ORM subsystems
@@ -1683,12 +1682,15 @@ export class EntityManager {
             throw ValidationError.invalidPropertyName(entityName, invalid.field);
         }
         await this.autoJoinRefsForFilters(meta, { ...options, populate });
-        return populate.map(field => {
+        for (const field of populate) {
             // force select-in strategy when populating all relations as otherwise we could cause infinite loops when self-referencing
             const all = field.all ?? (Array.isArray(options.populate) && options.populate.includes('*'));
             field.strategy = all ? LoadStrategy.SELECT_IN : (options.strategy ?? field.strategy);
-            return field;
-        });
+        }
+        if (options.populateHints) {
+            applyPopulateHints(populate, options.populateHints);
+        }
+        return populate;
     }
     /**
      * when the entity is found in identity map, we check if it was partially loaded or we are trying to populate
@@ -1813,6 +1815,7 @@ export class EntityManager {
         if (em.loaders[type]) {
             return em.loaders[type];
         }
+        const { DataloaderUtils } = await import('@mikro-orm/core/dataloader');
         const DataLoader = await DataloaderUtils.getDataLoader();
         switch (type) {
             case 'ref': return (em.loaders[type] ??= new DataLoader(DataloaderUtils.getRefBatchLoadFn(em)));

package/drivers/IDatabaseDriver.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName } from '../typings.js';
+import type { ConnectionType, Constructor, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName, PopulateHintOptions, Prefixes } from '../typings.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -7,6 +7,7 @@ import type { Collection } from '../entity/Collection.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { DriverException } from '../exceptions.js';
 import type { Configuration } from '../utils/Configuration.js';
+import type { MikroORM } from '../MikroORM.js';
 import type { LoggingOptions, LogContext } from '../logging/Logger.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 export declare const EntityManagerType: unique symbol;
@@ -65,6 +66,10 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
         schema?: string;
         parentSchema?: string;
     }): string | undefined;
+    /**
+     * @internal
+     */
+    getORMClass(): Constructor<MikroORM>;
 }
 export type EntityField<T, P extends string = PopulatePath.ALL> = keyof T | PopulatePath.ALL | AutoPath<T, P, `${PopulatePath.ALL}`>;
 export type OrderDefinition<T> = (QueryOrderMap<T> & {
@@ -107,6 +112,10 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     populateFilter?: ObjectQuery<Entity>;
     /** Used for ordering of the populate queries. If not specified, the value of `options.orderBy` is used. */
     populateOrderBy?: OrderDefinition<Entity>;
+    /** Per-relation overrides for populate loading behavior. Keys are populate paths (same as used in `populate`). */
+    populateHints?: [Hint] extends [never] ? never : {
+        [K in Prefixes<Hint>]?: PopulateHintOptions;
+    };
     /** Ordering of the results.Can be an object or array of objects, keys are property names, values are ordering (asc/desc) */
     orderBy?: OrderDefinition<Entity>;
     /** Control result caching for this query. Result cache is by default disabled, not to be confused with the identity map. */
@@ -155,12 +164,18 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     lockTableAliases?: string[];
     ctx?: Transaction;
     connectionType?: ConnectionType;
-    /** sql only */
-    indexHint?: string;
+    /** SQL: appended to FROM clause (e.g. `'force index(my_index)'`); MongoDB: index name or spec passed as `hint`. */
+    indexHint?: string | Dictionary;
     /** sql only */
     comments?: string | string[];
     /** sql only */
     hintComments?: string | string[];
+    /** SQL: collation name string applied as COLLATE to ORDER BY; MongoDB: CollationOptions object. */
+    collation?: CollationOptions | string;
+    /** mongodb only */
+    maxTimeMS?: number;
+    /** mongodb only */
+    allowDiskUse?: boolean;
     loggerContext?: LogContext;
     logging?: LoggingOptions;
     /** @internal used to apply filters to the auto-joined relations */
@@ -211,12 +226,16 @@ export interface CountOptions<T extends object, P extends string = never> {
     ctx?: Transaction;
     connectionType?: ConnectionType;
     flushMode?: FlushMode | `${FlushMode}`;
-    /** sql only */
-    indexHint?: string;
+    /** SQL: appended to FROM clause (e.g. `'force index(my_index)'`); MongoDB: index name or spec passed as `hint`. */
+    indexHint?: string | Dictionary;
     /** sql only */
     comments?: string | string[];
     /** sql only */
     hintComments?: string | string[];
+    /** SQL: collation name string applied as COLLATE; MongoDB: CollationOptions object. */
+    collation?: CollationOptions | string;
+    /** mongodb only */
+    maxTimeMS?: number;
     loggerContext?: LogContext;
     logging?: LoggingOptions;
     /** @internal used to apply filters to the auto-joined relations */
@@ -244,6 +263,16 @@ export interface DriverMethodOptions {
     schema?: string;
     loggerContext?: LogContext;
 }
+export interface CollationOptions {
+    locale: string;
+    caseLevel?: boolean;
+    caseFirst?: string;
+    strength?: number;
+    numericOrdering?: boolean;
+    alternate?: string;
+    maxVariable?: string;
+    backwards?: boolean;
+}
 export interface GetReferenceOptions {
     wrapped?: boolean;
     convertCustomTypes?: boolean;

package/entity/BaseEntity.d.ts

@@ -1,5 +1,5 @@
 import { type Ref } from './Reference.js';
-import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected, SerializeDTO } from '../typings.js';
 import { type AssignOptions } from './EntityAssigner.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 import { type SerializeOptions } from '../serialization/EntitySerializer.js';
@@ -8,7 +8,7 @@ import type { PopulatePath } from '../enums.js';
 export declare abstract class BaseEntity {
     isInitialized(): boolean;
     populated(populated?: boolean): void;
-    populate<Entity extends this = this, Hint extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Entity extends this = this, Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     /**
      * Converts the entity to a plain object representation.
@@ -73,7 +73,7 @@ export declare abstract class BaseEntity {
      */
     toObject<Entity extends this = this, Ignored extends EntityKey<Entity> = never>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toPOJO<Entity extends this = this>(): EntityDTO<Entity>;
-    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): EntityDTO<Loaded<Naked, Hint>>;
+    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
     assign<Entity extends this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     init<Entity extends this = this, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
     getSchema(): string | undefined;

package/entity/EntityFactory.js

@@ -129,7 +129,10 @@ export class EntityFactory {
             .filter(key => meta.properties[key]?.formula || [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
             .forEach(key => diff2[key] = data[key]);
         // rehydrated with the new values, skip those changed by user
-        this.hydrate(entity, meta, diff2, options);
+        // use full hydration if the entity is already initialized, even if the caller used `initialized: false`
+        // (e.g. from createReference), otherwise scalar properties in diff2 won't be applied
+        const initialized = options.initialized || helper(entity).__initialized;
+        this.hydrate(entity, meta, diff2, initialized ? { ...options, initialized } : options);
         // we need to update the entity data only with keys that were not present before
         const nullVal = this.config.get('forceUndefined') ? undefined : null;
         Utils.keys(diff2).forEach(key => {
@@ -137,7 +140,7 @@ export class EntityFactory {
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
                 diff2[key] = entity[prop.name] ? helper(entity[prop.name]).getPrimaryKey(options.convertCustomTypes) : null;
             }
-            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) && prop.customType?.ensureComparable(meta, prop) && diff2[key] != null) {
+            if (!options.convertCustomTypes && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) && prop.customType?.ensureComparable(meta, prop) && diff2[key] != null) {
                 const converted = prop.customType.convertToJSValue(diff2[key], this.platform, { force: true });
                 diff2[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { fromQuery: true });
             }

package/entity/EntityHelper.js

@@ -1,4 +1,4 @@
-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';
@@ -130,7 +130,7 @@ export class EntityHelper {
                 }
             }
             // ensure we dont have internal symbols in the POJO
-            [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps].forEach(sym => delete object[sym]);
+            [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]);

package/entity/EntityLoader.d.ts

@@ -1,13 +1,13 @@
-import type { AnyEntity, ConnectionType, EntityName, 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, FilterOptions } 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;
@@ -20,7 +20,7 @@ export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL
     schema?: string;
     connectionType?: ConnectionType;
     logging?: LoggingOptions;
-};
+}
 export declare class EntityLoader {
     private readonly em;
     private readonly metadata;

package/entity/EntityRepository.d.ts

@@ -150,7 +150,7 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
      */
-    populate<Ent extends Entity | Entity[], Hint extends string = never, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Fields extends string = '*', Excludes extends string = never>(entities: Ent, populate: AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Ent extends object[] ? MergeLoaded<ArrayElement<Ent>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Ent, Naked, Hint, Fields, Excludes>>;
+    populate<Ent extends Entity | Entity[], Hint extends string = never, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Fields extends string = never, Excludes extends string = never>(entities: Ent, populate: AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Ent extends object[] ? MergeLoaded<ArrayElement<Ent>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Ent, Naked, Hint, Fields, Excludes>>;
     /**
      * Creates new instance of given entity and populates it with given data.
      * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.

package/entity/WrappedEntity.d.ts

@@ -1,6 +1,6 @@
 import type { PopulatePath } from '../enums.js';
 import type { EntityManager } from '../EntityManager.js';
-import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, SerializeDTO, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
 import { Reference } from './Reference.js';
 import { type AssignOptions } from './EntityAssigner.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
@@ -44,12 +44,12 @@ export declare class WrappedEntity<Entity extends object> {
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     toObject<Ignored extends EntityKey<Entity> = never>(ignoreFields?: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
-    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): EntityDTO<Loaded<Entity, Hint>>;
+    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): SerializeDTO<Entity, Hint, Exclude>;
     toPOJO(): EntityDTO<Entity>;
     toJSON(...args: any[]): EntityDictionary<Entity>;
     assign<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     init<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
-    populate<Hint extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     hasPrimaryKey(): boolean;
     getPrimaryKey(convertCustomTypes?: boolean): Primary<Entity> | null;
     getPrimaryKeys(convertCustomTypes?: boolean): Primary<Entity>[] | null;