@mikro-orm/core 6.6.6-dev.2 → 6.6.6-dev.4

package/EntityManager.d.ts

@@ -507,7 +507,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     private lockAndPopulate;
     private buildFields;
     /** @internal */
-    preparePopulate<Entity extends object>(entityName: string, options: Pick<FindOptions<Entity, any, any>, 'populate' | 'strategy' | 'fields' | 'flags' | 'filters'>, validate?: boolean): Promise<PopulateOptions<Entity>[]>;
+    preparePopulate<Entity extends object>(entityName: string, options: Pick<FindOptions<Entity, any, any, any>, 'populate' | 'strategy' | 'fields' | 'flags' | 'filters' | 'exclude'>, validate?: boolean): Promise<PopulateOptions<Entity>[]>;
     /**
      * 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

package/EntityManager.js

@@ -1624,7 +1624,7 @@ class EntityManager {
             options.populate = pruneToOneRelations(meta, this.buildFields(options.fields));
         }
         if (!options.populate) {
-            const populate = this.entityLoader.normalizePopulate(entityName, [], options.strategy);
+            const populate = this.entityLoader.normalizePopulate(entityName, [], options.strategy, true, options.exclude);
             await this.autoJoinRefsForFilters(meta, { ...options, populate });
             return populate;
         }
@@ -1646,7 +1646,7 @@ class EntityManager {
                 return [field];
             }).flat();
         }
-        const populate = this.entityLoader.normalizePopulate(entityName, options.populate, options.strategy);
+        const populate = this.entityLoader.normalizePopulate(entityName, options.populate, options.strategy, true, options.exclude);
         const invalid = populate.find(({ field }) => !this.canPopulate(entityName, field));
         if (validate && invalid) {
             throw errors_1.ValidationError.invalidPropertyName(entityName, invalid.field);

package/entity/EntityLoader.d.ts

@@ -31,7 +31,7 @@ export declare class EntityLoader {
      * 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: 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>[];
+    normalizePopulate<Entity>(entityName: string, populate: (PopulateOptions<Entity> | boolean)[] | PopulateOptions<Entity> | boolean, strategy?: LoadStrategy, lookup?: boolean, exclude?: string[]): PopulateOptions<Entity>[];
     private setSerializationContext;
     /**
      * Merge multiple populates for the same entity with different children. Also skips `*` fields, those can come from

package/entity/EntityLoader.js

@@ -42,7 +42,7 @@ class EntityLoader {
         if (references.length > 0) {
             await this.populateScalar(meta, references, { ...options, populateWhere: undefined });
         }
-        populate = this.normalizePopulate(entityName, populate, options.strategy, options.lookup);
+        populate = this.normalizePopulate(entityName, populate, options.strategy, options.lookup, options.exclude);
         const invalid = populate.find(({ field }) => !this.em.canPopulate(entityName, field));
         /* istanbul ignore next */
         if (options.validate && invalid) {
@@ -59,7 +59,7 @@ class EntityLoader {
             visited.delete(entity);
         }
     }
-    normalizePopulate(entityName, populate, strategy, lookup = true) {
+    normalizePopulate(entityName, populate, strategy, lookup = true, exclude) {
         const meta = this.metadata.find(entityName);
         let normalized = Utils_1.Utils.asArray(populate).map(field => {
             return typeof field === 'boolean' || field.field === enums_1.PopulatePath.ALL ? { all: !!field, field: meta.primaryKeys[0] } : field;
@@ -70,7 +70,7 @@ class EntityLoader {
         // convert nested `field` with dot syntax to PopulateOptions with `children` array
         (0, utils_1.expandDotPaths)(meta, normalized, true);
         if (lookup && populate !== false) {
-            normalized = this.lookupEagerLoadedRelationships(entityName, normalized, strategy);
+            normalized = this.lookupEagerLoadedRelationships(entityName, normalized, strategy, '', [], exclude);
             // convert nested `field` with dot syntax produced by eager relations
             (0, utils_1.expandDotPaths)(meta, normalized, true);
         }
@@ -572,7 +572,7 @@ class EntityLoader {
         }
         return `${this.getRelationName(meta, meta.properties[prop.embedded[0]])}.${prop.embedded[1]}`;
     }
-    lookupEagerLoadedRelationships(entityName, populate, strategy, prefix = '', visited = []) {
+    lookupEagerLoadedRelationships(entityName, populate, strategy, prefix = '', visited = [], exclude) {
         const meta = this.metadata.find(entityName);
         if (!meta && !prefix) {
             return populate;
@@ -584,16 +584,19 @@ class EntityLoader {
         const ret = prefix === '' ? [...populate] : [];
         meta.relations
             .filter(prop => {
+            const field = this.getRelationName(meta, prop);
+            const prefixed = prefix ? `${prefix}.${field}` : field;
+            const isExcluded = exclude?.includes(prefixed);
             const eager = prop.eager && !populate.some(p => p.field === `${prop.name}:ref`);
             const populated = populate.some(p => p.field === prop.name);
             const disabled = populate.some(p => p.field === prop.name && p.all === false);
-            return !disabled && (eager || populated);
+            return !disabled && !isExcluded && (eager || populated);
         })
             .forEach(prop => {
             const field = this.getRelationName(meta, prop);
             const prefixed = prefix ? `${prefix}.${field}` : field;
             const nestedPopulate = populate.filter(p => p.field === prop.name).flatMap(p => p.children).filter(Boolean);
-            const nested = this.lookupEagerLoadedRelationships(prop.type, nestedPopulate, strategy, prefixed, visited.slice());
+            const nested = this.lookupEagerLoadedRelationships(prop.type, nestedPopulate, strategy, prefixed, visited.slice(), exclude);
             if (nested.length > 0) {
                 ret.push(...nested);
             }

package/entity/defineEntity.d.ts

@@ -416,12 +416,13 @@ declare const propertyBuilders: {
     interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
     unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
 };
-export interface EntityMetadataWithProperties<TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques'> {
+export interface EntityMetadataWithProperties<TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository'> {
     name: string;
     extends?: EntityName<TBase>;
     properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
     hooks?: DefineEntityHooks<InferEntityFromProperties<TProperties, TPK>>;
+    repository?: (() => Constructor) | (() => unknown);
     discriminatorColumn?: keyof TProperties;
     versionProperty?: keyof TProperties;
     concurrencyCheckKeys?: Set<keyof TProperties>;

package/metadata/MetadataDiscovery.js

@@ -977,7 +977,6 @@ class MetadataDiscovery {
         if (meta.root === meta) {
             return;
         }
-        let i = 1;
         Object.values(meta.properties).forEach(prop => {
             const newProp = { ...prop };
             const rootProp = meta.root.properties[prop.name];
@@ -985,11 +984,11 @@ class MetadataDiscovery {
                 const name = newProp.name;
                 this.initFieldName(newProp, newProp.object);
                 newProp.renamedFrom = name;
-                newProp.name = name + '_' + (i++);
+                newProp.name = `${name}_${meta._id}`;
                 meta.root.addProperty(newProp);
+                this.initFieldName(prop, prop.object);
                 // Track all field variants and map discriminator values to field names
                 if (!rootProp.stiFieldNames) {
-                    this.initFieldName(prop, prop.object);
                     this.initFieldName(rootProp, rootProp.object);
                     rootProp.stiFieldNames = [...rootProp.fieldNames];
                     rootProp.stiFieldNameMap = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.6.6-dev.2",
+  "version": "6.6.6-dev.4",
   "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.6-dev.2",
+    "mikro-orm": "6.6.6-dev.4",
     "reflect-metadata": "0.2.2"
   }
 }