@mikro-orm/core 6.3.4-dev.1 → 6.3.4-dev.10

package/drivers/IDatabaseDriver.d.ts

@@ -68,12 +68,14 @@ export interface FindAllOptions<T, P extends string = never, F extends string =
     where?: FilterQuery<T>;
 }
 export type FilterOptions = Dictionary<boolean | Dictionary> | string[] | boolean;
-export interface FindOptions<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 = PopulatePath.ALL, Excludes extends string = never> {
     populate?: Populate<Entity, Hint>;
-    populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
-    populateOrderBy?: OrderDefinition<Entity>;
     fields?: readonly AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
     exclude?: readonly AutoPath<Entity, Excludes>[];
+}
+export interface FindOptions<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> extends LoadHint<Entity, Hint, Fields, Excludes> {
+    populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    populateOrderBy?: OrderDefinition<Entity>;
     orderBy?: OrderDefinition<Entity>;
     cache?: boolean | number | [string, number];
     limit?: number;

package/entity/Collection.d.ts

@@ -24,6 +24,7 @@ export declare class Collection<T extends object, O extends object = object> ext
      * Returns the Collection instance (itself), works the same as `Reference.load()`.
      */
     load<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<LoadedCollection<Loaded<TT, P>>>;
+    private setSerializationContext;
     /**
      * Initializes the collection and returns the items
      */

package/entity/Collection.js

@@ -37,12 +37,20 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         if (this.isInitialized(true) && !options.refresh) {
             const em = this.getEntityManager(this.items, false);
             await em?.populate(this.items, options.populate, options);
+            this.setSerializationContext(options);
         }
         else {
             await this.init({ refresh: false, ...options });
         }
         return this;
     }
+    setSerializationContext(options) {
+        (0, wrap_1.helper)(this.owner).setSerializationContext({
+            populate: Array.isArray(options.populate)
+                ? options.populate.map(hint => `${this.property.name}.${hint}`)
+                : options.populate ?? [this.property.name],
+        });
+    }
     /**
      * Initializes the collection and returns the items
      */
@@ -86,6 +94,7 @@ class Collection extends ArrayCollection_1.ArrayCollection {
         }
         if (options.store) {
             this.hydrate(items, true);
+            this.setSerializationContext(options);
             this.populated();
             this.readonly = true;
         }

package/entity/EntityLoader.d.ts

@@ -33,16 +33,11 @@ export declare class EntityLoader {
     populate<Entity extends object, Fields extends string = PopulatePath.ALL>(entityName: string, entities: Entity[], populate: PopulateOptions<Entity>[] | boolean, options: EntityLoaderOptions<Entity, Fields>): Promise<void>;
     normalizePopulate<Entity>(entityName: string, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean): PopulateOptions<Entity>[];
     private setSerializationContext;
-    private expandDotPaths;
     /**
      * Merge multiple populates for the same entity with different children. Also skips `*` fields, those can come from
      * partial loading hints (`fields`) that are used to infer the `populate` hint if missing.
      */
     private mergeNestedPopulate;
-    /**
-     * Expands `books.perex` like populate to use `children` array instead of the dot syntax
-     */
-    private expandNestedPopulate;
     /**
      * preload everything in one call (this will update already existing references in IM)
      */

package/entity/EntityLoader.js

@@ -8,6 +8,7 @@ const enums_1 = require("../enums");
 const Reference_1 = require("./Reference");
 const wrap_1 = require("./wrap");
 const RawQueryFragment_1 = require("../utils/RawQueryFragment");
+const utils_1 = require("./utils");
 class EntityLoader {
     em;
     metadata;
@@ -64,52 +65,24 @@ class EntityLoader {
             normalized = this.lookupAllRelationships(entityName);
         }
         // convert nested `field` with dot syntax to PopulateOptions with `children` array
-        this.expandDotPaths(normalized, meta);
+        (0, utils_1.expandDotPaths)(meta, normalized, true);
         if (lookup && populate !== false) {
             normalized = this.lookupEagerLoadedRelationships(entityName, normalized, strategy);
             // convert nested `field` with dot syntax produced by eager relations
-            this.expandDotPaths(normalized, meta);
+            (0, utils_1.expandDotPaths)(meta, normalized, true);
         }
         // merge same fields
         return this.mergeNestedPopulate(normalized);
     }
     setSerializationContext(entities, populate, options) {
-        const exclude = options.exclude ?? [];
         for (const entity of entities) {
-            const context = (0, wrap_1.helper)(entity).__serializationContext;
-            context.populate = context.populate ? context.populate.concat(populate) : populate;
-            context.exclude = context.exclude ? context.exclude.concat(exclude) : exclude;
-            if (context.fields && options.fields) {
-                options.fields.forEach(f => context.fields.add(f));
-            }
-            else if (options.fields) {
-                context.fields = new Set(options.fields);
-            }
-            else {
-                context.fields = new Set([enums_1.PopulatePath.ALL]);
-            }
+            (0, wrap_1.helper)(entity).setSerializationContext({
+                populate,
+                fields: options.fields,
+                exclude: options.exclude,
+            });
         }
     }
-    expandDotPaths(normalized, meta) {
-        normalized.forEach(p => {
-            if (!p.field.includes('.')) {
-                return;
-            }
-            const [f, ...parts] = p.field.split('.');
-            p.field = f;
-            p.children ??= [];
-            const prop = meta.properties[f];
-            p.strategy ??= prop.strategy;
-            if (parts[0] === enums_1.PopulatePath.ALL) {
-                prop.targetMeta.props
-                    .filter(prop => prop.lazy || prop.kind !== enums_1.ReferenceKind.SCALAR)
-                    .forEach(prop => p.children.push({ field: prop.name, strategy: p.strategy }));
-            }
-            else {
-                p.children.push(this.expandNestedPopulate(prop.type, parts, p.strategy, p.all));
-            }
-        });
-    }
     /**
      * Merge multiple populates for the same entity with different children. Also skips `*` fields, those can come from
      * partial loading hints (`fields`) that are used to infer the `populate` hint if missing.
@@ -138,19 +111,6 @@ class EntityLoader {
             return item;
         });
     }
-    /**
-     * Expands `books.perex` like populate to use `children` array instead of the dot syntax
-     */
-    expandNestedPopulate(entityName, parts, strategy, all) {
-        const meta = this.metadata.find(entityName);
-        const field = parts.shift();
-        const prop = meta.properties[field];
-        const ret = { field, strategy, all };
-        if (parts.length > 0) {
-            ret.children = [this.expandNestedPopulate(prop.type, parts, strategy)];
-        }
-        return ret;
-    }
     /**
      * preload everything in one call (this will update already existing references in IM)
      */
@@ -404,6 +364,9 @@ class EntityLoader {
         const where = options.where;
         const subCond = Utils_1.Utils.isPlainObject(where[prop.name]) ? where[prop.name] : {};
         const meta2 = this.metadata.find(prop.type);
+        if (!meta2) {
+            return {};
+        }
         const pk = Utils_1.Utils.getPrimaryKeyHash(meta2.primaryKeys);
         ['$and', '$or'].forEach(op => {
             if (where[op]) {

package/entity/WrappedEntity.d.ts

@@ -8,7 +8,7 @@ import type { EntityLoaderOptions } from './EntityLoader';
 import type { EntityIdentifier } from './EntityIdentifier';
 import type { SerializationContext } from '../serialization/SerializationContext';
 import { type SerializeOptions } from '../serialization/EntitySerializer';
-import type { FindOneOptions } from '../drivers/IDatabaseDriver';
+import type { FindOneOptions, LoadHint } from '../drivers/IDatabaseDriver';
 export declare class WrappedEntity<Entity extends object> {
     __initialized: boolean;
     __touched: boolean;
@@ -17,14 +17,15 @@ export declare class WrappedEntity<Entity extends object> {
     __onLoadFired?: boolean;
     __schema?: string;
     __em?: EntityManager;
+    __loadedProperties: Set<string>;
+    __data: Dictionary;
+    __processing: boolean;
     __serializationContext: {
         root?: SerializationContext<Entity>;
         populate?: PopulateOptions<Entity>[];
-        fields?: string[];
+        fields?: Set<string>;
+        exclude?: readonly string[];
     };
-    __loadedProperties: Set<string>;
-    __data: Dictionary;
-    __processing: boolean;
     /** stores last known primary key, as its current state might be broken due to propagation/orphan removal, but we need to know the PK to be able t remove the entity */
     __pk?: Primary<Entity>;
     /** holds the reference wrapper instance (if created), so we can maintain the identity on reference wrappers too */
@@ -43,6 +44,7 @@ export declare class WrappedEntity<Entity extends object> {
     isTouched(): boolean;
     isManaged(): boolean;
     populated(populated?: boolean | undefined): void;
+    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>>;

package/entity/WrappedEntity.js

@@ -9,6 +9,7 @@ const Utils_1 = require("../utils/Utils");
 const errors_1 = require("../errors");
 const wrap_1 = require("./wrap");
 const EntitySerializer_1 = require("../serialization/EntitySerializer");
+const utils_1 = require("./utils");
 class WrappedEntity {
     constructor(entity, hydrator, pkGetter, pkSerializer, pkGetterConverted) {
         this.entity = entity;
@@ -35,6 +36,22 @@ class WrappedEntity {
     populated(populated = true) {
         this.__populated = populated;
     }
+    setSerializationContext(options) {
+        const exclude = options.exclude ?? [];
+        const context = this.__serializationContext;
+        const populate = (0, utils_1.expandDotPaths)(this.__meta, options.populate);
+        context.populate = context.populate ? context.populate.concat(populate) : populate;
+        context.exclude = context.exclude ? context.exclude.concat(exclude) : exclude;
+        if (context.fields && options.fields) {
+            options.fields.forEach(f => context.fields.add(f));
+        }
+        else if (options.fields) {
+            context.fields = new Set(options.fields);
+        }
+        else {
+            context.fields = new Set(['*']);
+        }
+    }
     toReference() {
         this.__reference ??= new Reference_1.Reference(this.entity);
         return this.__reference;

package/entity/utils.d.ts

@@ -0,0 +1,5 @@
+import type { EntityMetadata, PopulateOptions } from '../typings';
+/**
+ * @internal
+ */
+export declare function expandDotPaths<Entity>(meta: EntityMetadata<Entity>, populate?: readonly (string | PopulateOptions<Entity>)[], normalized?: boolean): PopulateOptions<Entity>[];

package/entity/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandDotPaths = expandDotPaths;
+const enums_1 = require("../enums");
+const core_1 = require("@mikro-orm/core");
+/**
+ * Expands `books.perex` like populate to use `children` array instead of the dot syntax
+ */
+function expandNestedPopulate(parentProp, parts, strategy, all) {
+    const meta = parentProp.targetMeta;
+    const field = parts.shift();
+    const prop = meta.properties[field];
+    const ret = { field, strategy, all };
+    if (parts.length > 0) {
+        ret.children = [expandNestedPopulate(prop, parts, strategy)];
+    }
+    return ret;
+}
+/**
+ * @internal
+ */
+function expandDotPaths(meta, populate, normalized = false) {
+    const ret = normalized ? populate : core_1.Utils.asArray(populate).map(field => {
+        if (typeof field === 'string') {
+            return { field };
+        }
+        /* istanbul ignore next */
+        return typeof field === 'boolean' || field.field === enums_1.PopulatePath.ALL
+            ? { all: !!field, field: meta.primaryKeys[0] }
+            : field;
+    });
+    for (const p of ret) {
+        if (!p.field.includes('.')) {
+            continue;
+        }
+        const [f, ...parts] = p.field.split('.');
+        p.field = f;
+        p.children ??= [];
+        const prop = meta.properties[p.field];
+        p.strategy ??= prop.strategy;
+        if (parts[0] === enums_1.PopulatePath.ALL) {
+            prop.targetMeta.props
+                .filter(prop => prop.lazy || prop.kind !== enums_1.ReferenceKind.SCALAR)
+                .forEach(prop => p.children.push({ field: prop.name, strategy: p.strategy }));
+        }
+        else if (prop.kind === enums_1.ReferenceKind.EMBEDDED) {
+            ret.push({
+                ...p,
+                field: Object.values(prop.embeddedProps).find(c => c.embedded[1] === parts[0])?.name,
+                children: [],
+            });
+            p.children.push(expandNestedPopulate(prop, parts, p.strategy, p.all));
+        }
+        else {
+            p.children.push(expandNestedPopulate(prop, parts, p.strategy, p.all));
+        }
+    }
+    return ret;
+}

package/metadata/MetadataDiscovery.js

@@ -896,10 +896,13 @@ class MetadataDiscovery {
                 prop.hydrate = false;
                 return;
             }
-            prop = Utils_1.Utils.copy(prop, false);
-            prop.nullable = true;
-            prop.inherited = true;
-            meta.root.addProperty(prop);
+            const newProp = Utils_1.Utils.copy(prop, false);
+            if (prop.enum && prop.items && meta.root.properties[prop.name]?.items) {
+                newProp.items = Utils_1.Utils.unique([...meta.root.properties[prop.name].items, ...prop.items]);
+            }
+            newProp.nullable = true;
+            newProp.inherited = true;
+            meta.root.addProperty(newProp);
         });
         meta.collection = meta.root.collection;
         meta.root.indexes = Utils_1.Utils.unique([...meta.root.indexes, ...meta.indexes]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.4-dev.1",
+  "version": "6.3.4-dev.10",
   "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.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.3.4-dev.1",
+    "mikro-orm": "6.3.4-dev.10",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.d.ts

@@ -8,7 +8,7 @@ import type { Platform } from './platforms';
 import type { Configuration } from './utils';
 import type { EntityManager } from './EntityManager';
 import type { EventSubscriber } from './events';
-import type { FindOneOptions, FindOptions } from './drivers';
+import type { FindOneOptions, FindOptions, LoadHint } from './drivers';
 export type Constructor<T = unknown> = new (...args: any[]) => T;
 export type Dictionary<T = any> = {
     [k: string]: T;
@@ -135,7 +135,7 @@ export interface IWrappedEntity<Entity extends object> {
     isManaged(): boolean;
     populated(populated?: boolean): void;
     populate<Hint extends string = never>(populate: AutoPath<Entity, Hint>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
-    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 = '*', 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>;
@@ -143,6 +143,7 @@ export interface IWrappedEntity<Entity extends object> {
     toJSON(...args: any[]): EntityDTO<Entity>;
     toPOJO(): EntityDTO<Entity>;
     serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): EntityDTO<Loaded<Entity, Hint>>;
+    setSerializationContext<Hint extends string = never, Fields extends string = '*', 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;