@mikro-orm/core 7.0.3-dev.2 → 7.0.3-dev.20

package/EntityManager.d.ts

@@ -61,7 +61,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
      */
-    find<Entity extends object, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
+    find<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
     /**
      * Finds all entities and returns an async iterable (async generator) that yields results one by one.
      * The results are merged and mapped to entity instances, without adding them to the identity map.
@@ -79,11 +79,11 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * }
      * ```
      */
-    stream<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: EntityName<Entity>, options?: StreamOptions<NoInfer<Entity>, Hint, Fields, Excludes>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
+    stream<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, options?: StreamOptions<NoInfer<Entity>, Hint, Fields, Excludes>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
     /**
      * Finds all entities of given type, optionally matching the `where` condition provided in the `options` parameter.
      */
-    findAll<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: EntityName<Entity>, options?: FindAllOptions<NoInfer<Entity>, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
+    findAll<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, options?: FindAllOptions<NoInfer<Entity>, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
     private getPopulateWhere;
     /**
      * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
@@ -110,7 +110,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     }): T;
     /** Sets the flush mode for this EntityManager. Pass `undefined` to reset to the global default. */
     setFlushMode(flushMode?: FlushMode | `${FlushMode}`): void;
-    protected processWhere<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<Entity>, options: FindOptions<Entity, Hint, Fields, Excludes> | FindOneOptions<Entity, Hint, Fields, Excludes>, type: 'read' | 'update' | 'delete'): Promise<FilterQuery<Entity>>;
+    protected processWhere<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<Entity>, options: FindOptions<Entity, Hint, Fields, Excludes> | FindOneOptions<Entity, Hint, Fields, Excludes>, type: 'read' | 'update' | 'delete'): Promise<FilterQuery<Entity>>;
     protected processUnionWhere<Entity extends object, Hint extends string = never>(entityName: EntityName<Entity>, options: FindOptions<Entity, Hint, any, any> | CountOptions<Entity, Hint> | UpdateOptions<Entity> | DeleteOptions<Entity>, type: 'read' | 'update' | 'delete'): Promise<void>;
     protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity>): FilterQuery<Entity>;
     protected createPopulateWhere<Entity extends object>(cond: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any> | CountOptions<Entity, any>): ObjectQuery<Entity>;
@@ -130,7 +130,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as tuple
      * where the first element is the array of entities, and the second is the count.
      */
-    findAndCount<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<[Loaded<Entity, Hint, Fields, Excludes>[], number]>;
+    findAndCount<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<[Loaded<Entity, Hint, Fields, Excludes>[], number]>;
     /**
      * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as {@apilink Cursor} object.
      * Supports `before`, `after`, `first` and `last` options while disallowing `limit` and `offset`. Explicit `orderBy` option
@@ -187,30 +187,30 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * }
      * ```
      */
-    findByCursor<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true>(entityName: EntityName<Entity>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
+    findByCursor<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never, IncludeCount extends boolean = true>(entityName: EntityName<Entity>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
     /**
      * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
      * persisted. Returns the same entity instance (same object reference), but re-hydrated. If the entity is no longer
      * in database, the method throws an error just like `em.findOneOrFail()` (and respects the same config options).
      */
-    refreshOrFail<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entity: Entity, options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true>>;
+    refreshOrFail<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entity: Entity, options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true>>;
     /**
      * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
      * persisted. Returns the same entity instance (same object reference), but re-hydrated. If the entity is no longer
      * in database, the method returns `null`.
      */
-    refresh<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entity: Entity, options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true> | null>;
+    refresh<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entity: Entity, options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true> | null>;
     /**
      * Finds first entity matching your `where` query.
      */
-    findOne<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
+    findOne<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
     /**
      * Finds first entity matching your `where` query. If nothing found, it will throw an error.
      * If the `strict` option is specified and nothing is found or more than one matching entity is found, it will throw an error.
      * You can override the factory for creating this method via `options.failHandler` locally
      * or via `Configuration.findOneOrFailHandler` (`findExactlyOneOrFailHandler` when specifying `strict`) globally.
      */
-    findOneOrFail<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>>;
+    findOneOrFail<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>>;
     /**
      * Creates or updates the entity, based on whether it is already present in the database.
      * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
@@ -512,7 +512,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * 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
      */
-    protected shouldRefresh<T extends object, P extends string = never, F extends string = '*', E extends string = never>(meta: EntityMetadata<T>, entity: T, options: FindOneOptions<T, P, F, E>): boolean;
+    protected shouldRefresh<T extends object, P extends string = never, F extends string = never, E extends string = never>(meta: EntityMetadata<T>, entity: T, options: FindOneOptions<T, P, F, E>): boolean;
     protected prepareOptions(options: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any> | CountOptions<any, any>): void;
     /**
      * @internal

package/EntityManager.js

@@ -405,8 +405,22 @@ export class EntityManager {
                 continue;
             }
             options = { ...options, filters: QueryHelper.mergePropertyFilters(prop.filters, options.filters) };
-            const cond = await this.applyFilters(prop.targetMeta.class, {}, options.filters, 'read', options);
-            if (!Utils.isEmpty(cond)) {
+            // For polymorphic relations, check all targets for filters (not just the first targetMeta)
+            let hasActiveFilter = false;
+            if (prop.polymorphic && prop.polymorphTargets?.length) {
+                for (const targetMeta of prop.polymorphTargets) {
+                    const cond = await this.applyFilters(targetMeta.class, {}, options.filters, 'read', options);
+                    if (!Utils.isEmpty(cond)) {
+                        hasActiveFilter = true;
+                        break;
+                    }
+                }
+            }
+            else {
+                const cond = await this.applyFilters(prop.targetMeta.class, {}, options.filters, 'read', options);
+                hasActiveFilter = !Utils.isEmpty(cond);
+            }
+            if (hasActiveFilter) {
                 const populated = options.populate.filter(({ field }) => field.split(':')[0] === prop.name);
                 let found = false;
                 for (const hint of populated) {

package/README.md

@@ -64,7 +64,7 @@ export class Book extends BookSchema.class {}
 BookSchema.setClass(Book);
 ```
 
-You can also define entities using [decorators](https://mikro-orm.io/docs/defining-entities) or [`EntitySchema`](https://mikro-orm.io/docs/entity-schema). See the [defining entities guide](https://mikro-orm.io/docs/defining-entities) for all options.
+You can also define entities using [decorators](https://mikro-orm.io/docs/using-decorators) or [`EntitySchema`](https://mikro-orm.io/docs/define-entity#entityschema-low-level-api). See the [defining entities guide](https://mikro-orm.io/docs/defining-entities) for all options.
 
 ### Initialize and Use
 

package/drivers/DatabaseDriver.d.ts

@@ -21,8 +21,8 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     protected comparator: EntityComparator;
     protected metadata: MetadataStorage;
     protected constructor(config: Configuration, dependencies: string[]);
-    abstract find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
-    abstract findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    abstract find<T extends object, P extends string = never, F extends string = never, E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    abstract findOne<T extends object, P extends string = never, F extends string = never, E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     abstract nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     abstract nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
     abstract nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;

package/drivers/IDatabaseDriver.d.ts

@@ -33,11 +33,11 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
     /**
      * Finds selection of entities
      */
-    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    find<T extends object, P extends string = never, F extends string = never, E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
     /**
      * Finds single entity (table row, document)
      */
-    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    findOne<T extends object, P extends string = never, F extends string = never, E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     /** Finds entities backed by a virtual (expression-based) definition. */
     findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     /** Returns an async iterator that streams query results one entity at a time. */
@@ -100,11 +100,11 @@ export type OrderDefinition<T> = (QueryOrderMap<T> & {
     0?: never;
 }) | QueryOrderMap<T>[];
 /** Options for `em.findAll()`, extends FindOptions with an optional `where` clause. */
-export interface FindAllOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends FindOptions<T, P, F, E> {
+export interface FindAllOptions<T, P extends string = never, F extends string = never, E extends string = never> extends FindOptions<T, P, F, E> {
     where?: FilterQuery<T>;
 }
 /** Options for streaming query results via `em.stream()`. */
-export interface StreamOptions<Entity, Populate extends string = never, Fields extends string = '*', Exclude extends string = never> extends Omit<FindAllOptions<Entity, Populate, Fields, Exclude>, 'cache' | 'before' | 'after' | 'first' | 'last' | 'overfetch' | 'strategy'> {
+export interface StreamOptions<Entity, Populate extends string = never, Fields extends string = never, Exclude extends string = never> extends Omit<FindAllOptions<Entity, Populate, Fields, Exclude>, 'cache' | 'before' | 'after' | 'first' | 'last' | 'overfetch' | 'strategy'> {
     /**
      * When populating to-many relations, the ORM streams fully merged entities instead of yielding every row.
      * You can opt out of this behavior by specifying `mergeResults: false`. This will yield every row from
@@ -119,13 +119,13 @@ export interface StreamOptions<Entity, Populate extends string = never, Fields e
 /** Configuration for enabling/disabling named filters on a query. */
 export type FilterOptions = Dictionary<boolean | Dictionary> | string[] | boolean;
 /** Specifies which relations to populate and which fields to select or exclude. */
-export interface LoadHint<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
+export interface LoadHint<Entity, Hint extends string = never, Fields extends string = never, Excludes extends string = never> {
     populate?: Populate<Entity, Hint>;
     fields?: readonly AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
     exclude?: readonly AutoPath<Entity, Excludes>[];
 }
 /** Options for `em.find()` queries, including population, ordering, pagination, and locking. */
-export interface FindOptions<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> extends LoadHint<Entity, Hint, Fields, Excludes> {
+export interface FindOptions<Entity, Hint extends string = never, Fields extends string = never, Excludes extends string = never> extends LoadHint<Entity, Hint, Fields, Excludes> {
     /**
      * Where condition for populated relations. This will have no effect on the root entity.
      * With `select-in` strategy, this is applied only to the populate queries.
@@ -227,16 +227,16 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     em?: EntityManager;
 }
 /** Options for cursor-based pagination via `em.findByCursor()`. */
-export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindAllOptions<T, P, F, E>, 'limit' | 'offset'> {
+export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = never, E extends string = never, I extends boolean = true> extends Omit<FindAllOptions<T, P, F, E>, 'limit' | 'offset'> {
     includeCount?: I;
 }
 /** Options for `em.findOne()`, extends FindOptions with optimistic lock version support. */
-export interface FindOneOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
+export interface FindOneOptions<T, P extends string = never, F extends string = never, E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;
     lockVersion?: number | Date;
 }
 /** Options for `em.findOneOrFail()`, adds a custom error handler for missing entities. */
-export interface FindOneOrFailOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends FindOneOptions<T, P, F, E> {
+export interface FindOneOrFailOptions<T extends object, P extends string = never, F extends string = never, E extends string = never> extends FindOneOptions<T, P, F, E> {
     failHandler?: (entityName: string, where: Dictionary | IPrimaryKey | any) => Error;
     strict?: boolean;
 }

package/entity/BaseEntity.d.ts

@@ -84,7 +84,7 @@ export declare abstract class BaseEntity {
     /** Assigns the given data to this entity, updating its properties and relations. */
     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>;
     /** Initializes (refreshes) the entity by reloading it from the database. Returns null if not found. */
-    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>;
+    init<Entity extends this = this, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
     /** Returns the database schema this entity belongs to. */
     getSchema(): string | undefined;
     /** Sets the database schema for this entity. */

package/entity/Collection.d.ts

@@ -177,7 +177,7 @@ export declare class Collection<T extends object, O extends object = object> {
     protected incrementCount(value: number): void;
 }
 /** Options for initializing a collection via `init()` or `load()`. */
-export interface InitCollectionOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends EntityLoaderOptions<T, F, E> {
+export interface InitCollectionOptions<T, P extends string = never, F extends string = never, E extends string = never> extends EntityLoaderOptions<T, F, E> {
     /** Whether to use the dataloader for batching collection loads. */
     dataloader?: boolean;
     /** Relations to populate on the loaded items. */

package/entity/EntityLoader.d.ts

@@ -4,7 +4,7 @@ import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type Quer
 import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 import type { LoggingOptions } from '../logging/Logger.js';
 /** Options for controlling how relations are loaded by the EntityLoader. */
-export interface EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
+export interface EntityLoaderOptions<Entity, Fields extends string = never, Excludes extends string = never> {
     /** Select specific fields to load (partial loading). */
     fields?: readonly AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
     /** Fields to exclude from loading. */
@@ -46,7 +46,7 @@ export declare class EntityLoader {
      * 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, Fields extends string = PopulatePath.ALL>(entityName: EntityName<Entity>, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
+    populate<Entity extends object, Fields extends string = never>(entityName: EntityName<Entity>, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
     /** Normalizes populate hints into a structured array of PopulateOptions, expanding dot paths and eager relations. */
     normalizePopulate<Entity>(entityName: EntityName<Entity>, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean, exclude?: string[]): PopulateOptions<Entity>[];
     private setSerializationContext;

package/entity/EntityRepository.d.ts

@@ -13,13 +13,13 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * Finds first entity matching your `where` query.
      */
-    findOne<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
+    findOne<Hint extends string = never, Fields extends string = never, Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
     /**
      * Finds first entity matching your `where` query. If nothing is found, it will throw an error.
      * You can override the factory for creating this method via `options.failHandler` locally
      * or via `Configuration.findOneOrFailHandler` globally.
      */
-    findOneOrFail<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>>;
+    findOneOrFail<Hint extends string = never, Fields extends string = never, Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>>;
     /**
      * Creates or updates the entity, based on whether it is already present in the database.
      * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
@@ -72,24 +72,24 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
      */
-    find<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
+    find<Hint extends string = never, Fields extends string = never, Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
     /**
      * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as tuple
      * where first element is the array of entities, and the second is the count.
      */
-    findAndCount<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<[Loaded<Entity, Hint, Fields, Excludes>[], number]>;
+    findAndCount<Hint extends string = never, Fields extends string = never, Excludes extends string = never>(where: FilterQuery<Entity>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<[Loaded<Entity, Hint, Fields, Excludes>[], number]>;
     /**
      * @inheritDoc EntityManager.findByCursor
      */
-    findByCursor<Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true>(options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
+    findByCursor<Hint extends string = never, Fields extends string = never, Excludes extends string = never, IncludeCount extends boolean = true>(options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
     /**
      * Finds all entities of given type. You can pass additional options via the `options` parameter.
      */
-    findAll<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindAllOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
+    findAll<Hint extends string = never, Fields extends string = never, Excludes extends string = never>(options?: FindAllOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
     /**
      * @inheritDoc EntityManager.stream
      */
-    stream<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: StreamOptions<Entity, Hint, Fields, Excludes>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
+    stream<Hint extends string = never, Fields extends string = never, Excludes extends string = never>(options?: StreamOptions<Entity, Hint, Fields, Excludes>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
     /**
      * @inheritDoc EntityManager.insert
      */

package/entity/Reference.d.ts

@@ -32,12 +32,12 @@ export declare class Reference<T extends object> {
      * If the entity is not found in the database (e.g. it was deleted in the meantime, or currently active filters disallow loading of it)
      * the method returns `null`. Use `loadOrFail()` if you want an error to be thrown in such a case.
      */
-    load<TT extends T, P extends string = never, F extends string = '*', E extends string = never>(options?: LoadReferenceOptions<TT, P, F, E>): Promise<Loaded<TT, P, F, E> | null>;
+    load<TT extends T, P extends string = never, F extends string = never, E extends string = never>(options?: LoadReferenceOptions<TT, P, F, E>): Promise<Loaded<TT, P, F, E> | null>;
     /**
      * Ensures the underlying entity is loaded first (without reloading it if it already is loaded).
      * Returns the entity or throws an error just like `em.findOneOrFail()` (and respects the same config options).
      */
-    loadOrFail<TT extends T, P extends string = never, F extends string = '*', E extends string = never>(options?: LoadReferenceOrFailOptions<TT, P, F, E>): Promise<Loaded<TT, P, F, E>>;
+    loadOrFail<TT extends T, P extends string = never, F extends string = never, E extends string = never>(options?: LoadReferenceOrFailOptions<TT, P, F, E>): Promise<Loaded<TT, P, F, E>>;
     private set;
     /** Returns the underlying entity without checking initialization state. */
     unwrap(): T;
@@ -80,12 +80,12 @@ export declare class ScalarReference<Value> {
     isInitialized(): boolean;
 }
 /** Options for `Reference.load()` to control how the referenced entity is loaded. */
-export interface LoadReferenceOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends FindOneOptions<T, P, F, E> {
+export interface LoadReferenceOptions<T extends object, P extends string = never, F extends string = never, E extends string = never> extends FindOneOptions<T, P, F, E> {
     /** Whether to use the dataloader for batching reference loads. */
     dataloader?: boolean;
 }
 /** Options for `Reference.loadOrFail()` which throws when the entity is not found. */
-export interface LoadReferenceOrFailOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends FindOneOrFailOptions<T, P, F, E> {
+export interface LoadReferenceOrFailOptions<T extends object, P extends string = never, F extends string = never, E extends string = never> extends FindOneOrFailOptions<T, P, F, E> {
     /** Whether to use the dataloader for batching reference loads. */
     dataloader?: boolean;
 }

package/entity/WrappedEntity.d.ts

@@ -48,7 +48,7 @@ export declare class WrappedEntity<Entity extends object> {
     /** Marks the entity as populated or not for serialization purposes. */
     populated(populated?: boolean | undefined): void;
     /** Sets the serialization context with populate hints, field selections, and exclusions. */
-    setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
+    setSerializationContext<Hint extends string = never, Fields extends string = never, Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     /** Returns a Reference wrapper for this entity, creating one if it does not already exist. */
     toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     /** Converts the entity to a plain object representation, optionally excluding specified fields. */
@@ -62,7 +62,7 @@ export declare class WrappedEntity<Entity extends object> {
     /** Assigns the given data to this entity, updating its properties and relations. */
     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>;
     /** Initializes (refreshes) the entity by reloading it from the database. Returns null if not found. */
-    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>;
+    init<Hint extends string = never, Fields extends string = never, Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
     /** Loads the specified relations on this entity. */
     populate<Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     /** Returns whether this entity has a primary key value set. */

package/entity/defineEntity.d.ts

@@ -1,5 +1,5 @@
 import type { EntityManager } from '../EntityManager.js';
-import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions } from '../metadata/types.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 { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
@@ -12,7 +12,7 @@ import type { Collection } from './Collection.js';
 import type { FilterOptions } 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';
+type BuilderExtraKeys = '~options' | '~type' | '$type' | 'strictNullable';
 type ExcludeKeys = 'entity' | 'items';
 type BuilderKeys = Exclude<UniversalPropertyKeys, ExcludeKeys> | BuilderExtraKeys;
 type IncludeKeysForProperty = Exclude<keyof PropertyOptions<any>, ExcludeKeys> | BuilderExtraKeys;
@@ -32,6 +32,10 @@ export interface PropertyChain<Value, Options> {
     nullable(): PropertyChain<Value, Omit<Options, 'nullable'> & {
         nullable: true;
     }>;
+    strictNullable(): PropertyChain<Value, Omit<Options, 'nullable' | 'strictNullable'> & {
+        nullable: true;
+        strictNullable: true;
+    }>;
     ref(): PropertyChain<Value, Omit<Options, 'ref'> & {
         ref: true;
     }>;
@@ -281,6 +285,14 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     nullable(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'nullable'> & {
         nullable: true;
     }, IncludeKeys>, IncludeKeys>;
+    /**
+     * Set column as nullable without adding `| undefined` to the type.
+     * Use this when the property is always explicitly set (e.g. in constructor) but can be `null`.
+     */
+    strictNullable(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'nullable' | 'strictNullable'> & {
+        nullable: true;
+        strictNullable: true;
+    }, IncludeKeys>, IncludeKeys>;
     /**
      * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
@@ -566,18 +578,28 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     concurrencyCheckKeys?: Set<AllKeys<TProperties, TBase>>;
     serializedPrimaryKey?: AllKeys<TProperties, TBase>;
     indexes?: {
-        properties?: keyof TProperties | (keyof TProperties)[];
+        properties?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         name?: string;
         type?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
+        columns?: IndexColumnOptions[];
+        include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
+        fillFactor?: number;
+        invisible?: boolean;
+        disabled?: boolean;
+        clustered?: boolean;
     }[];
     uniques?: {
-        properties?: keyof TProperties | (keyof TProperties)[];
+        properties?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         name?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<InferEntityFromProperties<TProperties, TPK, TBase>>;
         deferMode?: DeferMode | `${DeferMode}`;
+        columns?: IndexColumnOptions[];
+        include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
+        fillFactor?: number;
+        disabled?: boolean;
     }[];
 }
 /** Defines an entity schema using property builders, with full type inference from the property definitions. */
@@ -663,7 +685,9 @@ type MaybeMapToPk<Value, Options> = Options extends {
 } ? Primary<Value> : Value;
 type MaybeNullable<Value, Options> = Options extends {
     nullable: true;
-} ? Value | null | undefined : Value;
+} ? Options extends {
+    strictNullable: true;
+} ? Value | null : Value | null | undefined : Value;
 type MaybeRelationRef<Value, Options> = Options extends {
     mapToPk: true;
 } ? Value : Options extends {

package/entity/defineEntity.js

@@ -145,6 +145,13 @@ export class UniversalPropertyOptionsBuilder {
     nullable() {
         return this.assignOptions({ nullable: true });
     }
+    /**
+     * Set column as nullable without adding `| undefined` to the type.
+     * Use this when the property is always explicitly set (e.g. in constructor) but can be `null`.
+     */
+    strictNullable() {
+        return this.assignOptions({ nullable: true });
+    }
     /**
      * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */

package/metadata/MetadataDiscovery.js

@@ -1726,12 +1726,12 @@ export class MetadataDiscovery {
             }
         }
         if (prop.kind === ReferenceKind.SCALAR && !(mappedType instanceof t.unknown)) {
-            if (!prop.columnTypes &&
-                prop.nativeEnumName &&
+            if (prop.nativeEnumName &&
                 meta.schema !== this.#platform.getDefaultSchemaName() &&
                 meta.schema &&
                 !prop.nativeEnumName.includes('.')) {
-                prop.columnTypes = [`${meta.schema}.${prop.nativeEnumName}`];
+                const suffix = prop.columnTypes?.[0]?.endsWith('[]') ? '[]' : '';
+                prop.columnTypes = [`${meta.schema}.${prop.nativeEnumName}${suffix}`];
             }
             else {
                 prop.columnTypes ??= [mappedType.getColumnType(prop, this.#platform)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.3-dev.2",
+  "version": "7.0.3-dev.20",
   "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/serialization/EntitySerializer.d.ts

@@ -1,4 +1,4 @@
-import type { ArrayElement, AutoPath, CleanTypeConfig, SerializeDTO, FromEntityType, TypeConfig, UnboxArray } from '../typings.js';
+import type { ArrayElement, AutoPath, CleanTypeConfig, ExtractFieldsHint, FromEntityType, SerializeDTO, TypeConfig, UnboxArray } from '../typings.js';
 import { type PopulatePath } from '../enums.js';
 /** Converts entity instances to plain DTOs via `serialize()`, with fine-grained control over populate, exclude, and serialization groups. */
 export declare class EntitySerializer {
@@ -41,4 +41,4 @@ export interface SerializeOptions<T, P extends string = never, E extends string
  * const dto2 = wrap(user).serialize({ exclude: ['id', 'email'], forceObject: true });
  * ```
  */
-export declare function serialize<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Populate extends string = never, Exclude extends string = never, Config extends TypeConfig = never>(entity: Entity, options?: Config & SerializeOptions<UnboxArray<Entity>, Populate, Exclude>): Naked extends object[] ? SerializeDTO<ArrayElement<Naked>, Populate, Exclude, CleanTypeConfig<Config>>[] : SerializeDTO<Naked, Populate, Exclude, CleanTypeConfig<Config>>;
+export declare function serialize<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Populate extends string = never, Exclude extends string = never, Config extends TypeConfig = never>(entity: Entity, options?: Config & SerializeOptions<UnboxArray<Entity>, Populate, Exclude>): Naked extends object[] ? SerializeDTO<ArrayElement<Naked>, Populate, Exclude, CleanTypeConfig<Config>>[] : SerializeDTO<Naked, Populate, Exclude, CleanTypeConfig<Config>, ExtractFieldsHint<Entity>>;

package/typings.d.ts

@@ -201,6 +201,7 @@ export interface TypeConfig {
 declare const __selectedType: unique symbol;
 declare const __loadedType: unique symbol;
 declare const __loadHint: unique symbol;
+declare const __fieldsHint: unique symbol;
 /**
  * Expands a populate hint into all its prefixes.
  * e.g., Prefixes<'a.b.c'> = 'a' | 'a.b' | 'a.b.c'
@@ -331,7 +332,7 @@ export interface IWrappedEntity<Entity extends object> {
     isManaged(): boolean;
     populated(populated?: boolean): void;
     populate<Hint extends string = never, Fields extends string = never>(populate: readonly AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
-    init<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Exclude>): Promise<Loaded<Entity, Hint, Fields, Exclude> | null>;
+    init<Hint extends string = never, Fields extends string = never, Exclude extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Exclude>): Promise<Loaded<Entity, Hint, Fields, Exclude> | null>;
     toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     toObject(): EntityDTO<Entity>;
     toObject(ignoreFields: never[]): EntityDTO<Entity>;
@@ -339,7 +340,7 @@ export interface IWrappedEntity<Entity extends object> {
     toJSON(...args: any[]): EntityDTO<Entity>;
     toPOJO(): EntityDTO<Entity>;
     serialize<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
-    setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
+    setSerializationContext<Hint extends string = never, Fields extends string = never, Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     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, Convert>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     getSchema(): string | undefined;
     setSchema(schema?: string): void;
@@ -527,13 +528,18 @@ export type EntityDTOFlat<T, C extends TypeConfig = never> = {
  */
 type SerializeTopHints<H extends string> = H extends `${infer Top}.${string}` ? Top : H;
 type SerializeSubHints<K extends string, H extends string> = H extends `${K}.${infer Rest}` ? Rest : never;
+type SerializeSubFields<K extends string, F extends string> = K extends F ? '*' : [F extends `${K & string}.${infer Rest}` ? Rest : never] extends [never] ? '*' : F extends `${K & string}.${infer Rest}` ? Rest : never;
+type SerializeFieldsFilter<T, K extends keyof T, F extends string> = K extends Prefix<T, F> | PrimaryProperty<T> ? K : never;
 type SerializePropValue<T, K extends keyof T, H extends string, C extends TypeConfig = never> = K & string extends SerializeTopHints<H> ? NonNullable<T[K]> extends CollectionShape<infer U> ? SerializeDTO<U & object, SerializeSubHints<K & string, H>, never, C>[] : SerializeDTO<ExpandProperty<T[K]>, SerializeSubHints<K & string, H>, never, C> | Extract<T[K], null | undefined> : EntityDTOProp<T, T[K], C>;
+type SerializePropValueWithFields<T, K extends keyof T, H extends string, C extends TypeConfig, F extends string> = K & string extends SerializeTopHints<H> ? NonNullable<T[K]> extends CollectionShape<infer U> ? SerializeDTO<U & object, SerializeSubHints<K & string, H>, never, C, SerializeSubFields<K & string, F>>[] : SerializeDTO<ExpandProperty<T[K]>, SerializeSubHints<K & string, H>, never, C, SerializeSubFields<K & string, F>> | Extract<T[K], null | undefined> : EntityDTOProp<T, T[K], C>;
 /**
  * Return type of `serialize()`. Combines Loaded + EntityDTO in a single pass for better performance.
- * Respects populate hints (`H`) and exclude hints (`E`).
+ * Respects populate hints (`H`), exclude hints (`E`), and fields hints (`F`).
  */
-export type SerializeDTO<T, H extends string = never, E extends string = never, C extends TypeConfig = never> = string extends H ? EntityDTOFlat<T, C> : {
+export type SerializeDTO<T, H extends string = never, E extends string = never, C extends TypeConfig = never, F extends string = '*'> = string extends H ? EntityDTOFlat<T, C> : [F] extends ['*'] ? {
     [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K> & (IsNever<E> extends true ? K : Exclude<K, E>)]: SerializePropValue<T, K, H, C> | Extract<T[K], null | undefined>;
+} : {
+    [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K> & (IsNever<E> extends true ? K : Exclude<K, E>) & SerializeFieldsFilter<T, K, F>]: SerializePropValueWithFields<T, K, H, C, F> | Extract<T[K], null | undefined>;
 };
 type TargetKeys<T> = T extends EntityClass<infer P> ? keyof P : keyof T;
 type PropertyName<T> = IsUnknown<T> extends false ? TargetKeys<T> : string;
@@ -1186,6 +1192,7 @@ export type Selected<T, L extends string = never, F extends string = '*'> = {
     [K in keyof T as IsPrefixed<T, K, L | F | AddEager<T>> | FunctionKeys<T, K>]: T[K] extends Function ? T[K] : NonNullable<T[K]> extends Scalar ? T[K] : LoadedProp<NonNullable<T[K]>, Suffix<K, L, true>, Suffix<K, F, true>> | AddOptional<T[K]>;
 } & {
     [__selectedType]?: T;
+    [__fieldsHint]?: (hint: F) => void;
 };
 type LoadedEntityType<T> = {
     [__loadedType]?: T;
@@ -1196,6 +1203,10 @@ type LoadedEntityType<T> = {
 export type EntityType<T> = T | LoadedEntityType<T>;
 /** Extracts the base entity type from a `Loaded`/`Selected` wrapper, or returns `T` as-is. */
 export type FromEntityType<T> = T extends LoadedEntityType<infer U> ? U : T;
+/** Extracts the fields hint (`F`) from a `Loaded`/`Selected` type, or returns `'*'` (all fields) for unwrapped entities. */
+export type ExtractFieldsHint<T> = T extends {
+    [__fieldsHint]?: (hint: infer F extends string) => void;
+} ? F : '*';
 type LoadedInternal<T, L extends string = never, F extends string = '*', E extends string = never> = [F] extends ['*'] ? IsNever<E> extends true ? T & {
     [K in keyof T as IsPrefixed<T, K, ExpandHint<T, L>>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L>, Suffix<K, F>, Suffix<K, E>> | AddOptional<T[K]>;
 } : {

package/utils/Cursor.d.ts

@@ -48,7 +48,7 @@ import { type QueryOrder } from '../enums.js';
  * }
  * ```
  */
-export declare class Cursor<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true> {
+export declare class Cursor<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never, IncludeCount extends boolean = true> {
     #private;
     readonly items: Loaded<Entity, Hint, Fields, Excludes>[];
     readonly totalCount: IncludeCount extends true ? number : undefined;

package/utils/Utils.js

@@ -129,7 +129,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.3-dev.2';
+    static #ORM_VERSION = '7.0.3-dev.20';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */
@@ -802,14 +802,11 @@ export class Utils {
             return await import(module);
         }
         catch (err) {
-            if (err.code === 'ERR_MODULE_NOT_FOUND') {
-                if (warning) {
-                    // eslint-disable-next-line no-console
-                    console.warn(warning);
-                }
-                return undefined;
+            if (warning && err.code === 'ERR_MODULE_NOT_FOUND') {
+                // eslint-disable-next-line no-console
+                console.warn(warning);
             }
-            throw err;
+            return undefined;
         }
     }
     static xor(a, b) {