@mikro-orm/core 6.6.5-dev.4 → 6.6.5-dev.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.6.5-dev.4",
+  "version": "6.6.5-dev.5",
   "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.3",
     "globby": "11.1.0",
-    "mikro-orm": "6.6.5-dev.4",
+    "mikro-orm": "6.6.5-dev.5",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -729,17 +729,19 @@ export type PopulateOptions<T> = {
     filter?: boolean;
     joinType?: 'inner join' | 'left join';
     children?: PopulateOptions<T[keyof T]>[];
+    /** When true, ignores `mapToPk` on the property and returns full entity data instead of just PKs. */
+    dataOnly?: boolean;
 };
 type Loadable<T extends object> = Collection<T, any> | Reference<T> | Ref<T> | readonly T[];
 type ExtractType<T> = T extends Loadable<infer U> ? U : T;
 type ExtractStringKeys<T> = {
-    [K in keyof T]: CleanKeys<T, K>;
+    [K in keyof T]-?: CleanKeys<T, K>;
 }[keyof T] & {};
 type StringKeys<T, E extends string = never> = T extends Collection<any, any> ? ExtractStringKeys<ExtractType<T>> | E : T extends Reference<any> ? ExtractStringKeys<ExtractType<T>> | E : T extends object ? ExtractStringKeys<ExtractType<T>> | E : never;
 type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : (K extends E ? keyof T : never);
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 type CollectionKeys<T> = T extends object ? {
-    [K in keyof T]: T[K] extends Collection<any> ? IsAny<T[K]> extends true ? never : K & string : never;
+    [K in keyof T]-?: T[K] extends Collection<any> ? IsAny<T[K]> extends true ? never : K & string : never;
 }[keyof T] & {} : never;
 export type AutoPath<O, P extends string | boolean, E extends string = never, D extends Prev[number] = 9> = P extends boolean ? P : [D] extends [never] ? never : P extends any ? P extends string ? (P & `${string}.` extends never ? P : P & `${string}.`) extends infer Q ? Q extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<NonNullable<GetStringKey<O, A, E>>, B, E, Prev[D]>}` : never : Q extends StringKeys<O, E> ? (NonNullable<GetStringKey<O, Q, E>> extends unknown ? Exclude<P, `${string}.`> : never) | (StringKeys<NonNullable<GetStringKey<O, Q, E>>, E> extends never ? never : `${Q & string}.`) : StringKeys<O, E> | `${CollectionKeys<O>}:ref` : never : never : never;
 export type UnboxArray<T> = T extends any[] ? ArrayElement<T> : T;

package/utils/Utils.d.ts

@@ -215,7 +215,7 @@ export declare class Utils {
      * Extracts all possible values of a TS enum. Works with both string and numeric enums.
      */
     static extractEnumValues(target: Dictionary): (string | number)[];
-    static flatten<T>(arrays: T[][]): T[];
+    static flatten<T>(arrays: T[][], deep?: boolean): T[];
     static isOperator(key: PropertyKey, includeGroupOperators?: boolean): boolean;
     static isGroupOperator(key: PropertyKey): boolean;
     static isArrayOperator(key: PropertyKey): boolean;

package/utils/Utils.js

@@ -862,8 +862,8 @@ class Utils {
         }
         return values;
     }
-    static flatten(arrays) {
-        return [].concat.apply([], arrays);
+    static flatten(arrays, deep) {
+        return arrays.flatMap(v => deep && Array.isArray(v) ? this.flatten(v, true) : v);
     }
     static isOperator(key, includeGroupOperators = true) {
         if (!includeGroupOperators) {