@mikro-orm/core 7.0.0-dev.230 → 7.0.0-dev.232

package/entity/EntityLoader.js

@@ -578,16 +578,18 @@ export class EntityLoader {
             }
             return ret;
         }, []);
-        if (ret.length === 0) {
-            return undefined;
-        }
         // we need to automatically select the FKs too, e.g. for 1:m relations to be able to wire them with the items
         if (prop.kind === ReferenceKind.ONE_TO_MANY || prop.kind === ReferenceKind.MANY_TO_MANY) {
             const owner = prop.targetMeta.properties[prop.mappedBy];
-            if (owner && !ret.includes(owner.name)) {
+            // when the owning FK is lazy, we need to explicitly select it even without user-provided fields,
+            // otherwise the driver will exclude it and we won't be able to map children to their parent collections
+            if (owner && !ret.includes(owner.name) && (ret.length > 0 || owner.lazy)) {
                 ret.push(owner.name);
             }
         }
+        if (ret.length === 0) {
+            return undefined;
+        }
         return ret;
     }
     getChildReferences(entities, prop, options, ref) {

package/metadata/types.d.ts

@@ -511,16 +511,67 @@ export interface SerializedPrimaryKeyOptions<T> extends PropertyOptions<T> {
 }
 type MaybeArray<T> = T | T[];
 type Properties<T, H extends string> = MaybeArray<AutoPath<T, H>>;
+/** Options for column within an index, supporting advanced index features like prefix length and collation. */
+export interface IndexColumnOptions {
+    /** Column name or property path. */
+    name: string;
+    /** Sort order for the column (default: ASC). */
+    sort?: 'ASC' | 'DESC' | 'asc' | 'desc';
+    /** NULLS ordering for the column (PostgreSQL). */
+    nulls?: 'FIRST' | 'LAST' | 'first' | 'last';
+    /** Prefix length for the column (MySQL, MariaDB). */
+    length?: number;
+    /** Collation for the column (PostgreSQL, SQLite, or MySQL/MariaDB via expression). */
+    collation?: string;
+}
 interface BaseOptions<T, H extends string> {
     name?: string;
     properties?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
     options?: Dictionary;
     expression?: string | (T extends EntityClass<infer P> ? IndexCallback<P> : IndexCallback<T>);
+    /**
+     * Advanced column options for the index.
+     * When specified, allows fine-grained control over each column in the index including
+     * sort order, nulls ordering, prefix length, and collation.
+     * If both `columns` and `properties` are specified, `columns` takes precedence for index creation.
+     */
+    columns?: IndexColumnOptions[];
+    /**
+     * Columns to include in the index but not as part of the key (PostgreSQL, MSSQL).
+     * These columns are stored in the leaf level of the index but not used for searching.
+     */
+    include?: (T extends EntityClass<infer P> ? Properties<P, H> : Properties<T, H>);
+    /** Fill factor for the index as a percentage 0-100 (PostgreSQL, MSSQL). */
+    fillFactor?: number;
 }
 export interface UniqueOptions<T, H extends string = string> extends BaseOptions<T, H> {
     deferMode?: DeferMode | `${DeferMode}`;
+    /**
+     * Whether the index is disabled (MSSQL only).
+     * A disabled index is not used for query planning and is not maintained on writes.
+     * It can be re-enabled later using `ALTER INDEX ... REBUILD`.
+     */
+    disabled?: boolean;
 }
 export interface IndexOptions<T, H extends string = string> extends BaseOptions<T, H> {
     type?: string;
+    /**
+     * Whether the index is invisible/hidden from the query optimizer (MySQL 8+, MariaDB 10.6+, MongoDB).
+     * An invisible index is still maintained on writes but not used for query planning.
+     * Useful for testing the impact of removing an index before actually dropping it.
+     */
+    invisible?: boolean;
+    /**
+     * Whether the index is disabled (MSSQL only).
+     * A disabled index is not used for query planning and is not maintained on writes.
+     * It can be re-enabled later using `ALTER INDEX ... REBUILD`.
+     */
+    disabled?: boolean;
+    /**
+     * Whether the index should be clustered (MariaDB, MSSQL).
+     * A clustered index determines the physical order of data in the table.
+     * Only one clustered index can exist per table.
+     */
+    clustered?: boolean;
 }
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.230",
+  "version": "7.0.0-dev.232",
   "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",

package/typings.d.ts

@@ -11,6 +11,7 @@ import type { SerializationContext } from './serialization/SerializationContext.
 import type { SerializeOptions } from './serialization/EntitySerializer.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { EntitySchema } from './metadata/EntitySchema.js';
+import type { IndexColumnOptions } from './metadata/types.js';
 import type { Type, types } from './types/index.js';
 import type { Platform } from './platforms/Platform.js';
 import type { Configuration } from './utils/Configuration.js';
@@ -637,6 +638,12 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         type?: string;
         options?: Dictionary;
         expression?: string | IndexCallback<Entity>;
+        columns?: IndexColumnOptions[];
+        include?: EntityKey<Entity> | EntityKey<Entity>[];
+        fillFactor?: number;
+        invisible?: boolean;
+        disabled?: boolean;
+        clustered?: boolean;
     }[];
     uniques: {
         properties?: EntityKey<Entity> | EntityKey<Entity>[];
@@ -644,6 +651,10 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
         options?: Dictionary;
         expression?: string | IndexCallback<Entity>;
         deferMode?: DeferMode | `${DeferMode}`;
+        columns?: IndexColumnOptions[];
+        include?: EntityKey<Entity> | EntityKey<Entity>[];
+        fillFactor?: number;
+        disabled?: boolean;
     }[];
     checks: CheckConstraint<Entity>[];
     repositoryClass?: string;

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.230';
+    static #ORM_VERSION = '7.0.0-dev.232';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */