@mikro-orm/core 7.0.3-dev.9 → 7.0.4-dev.0

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/entity/defineEntity.d.ts

@@ -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,26 +578,26 @@ 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?: keyof TProperties | (keyof TProperties)[];
+        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?: keyof TProperties | (keyof TProperties)[];
+        include?: NoInfer<AllKeys<TProperties, TBase>> | NoInfer<AllKeys<TProperties, TBase>>[];
         fillFactor?: number;
         disabled?: boolean;
     }[];
@@ -673,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.9",
+  "version": "7.0.4-dev.0",
   "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'
@@ -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/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.9';
+    static #ORM_VERSION = '7.0.4-dev.0';
     /**
      * 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) {