@koalarx/nest 3.1.11 → 3.1.12

package/core/database/repository.base.d.ts

@@ -14,8 +14,10 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private readonly _modelName;
     private readonly _includeFindMany?;
     constructor({ context, modelName }: RepositoryInitProps<TEntity, TContext>);
+    private getIdPropName;
     private getConnectPrismaSchemaForRelation;
     private getSelectRootPrismaSchema;
+    private getSelectWithRelationsId;
     private getPropNameFromEntitySource;
     private listRelationEntities;
     private listToRelationActionList;
@@ -24,9 +26,8 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private findManySchema;
     private createEntity;
     private orphanRemoval;
-    private getIdPropName;
-    private enrichEntityWithRelations;
     private loadRelationForEntity;
+    private enrichEntityWithRelations;
     private persistRelations;
     protected context(transactionalClient?: TContext): TContext[TModelKey];
     protected findById(id: IComparableId): Promise<TEntity | null>;

package/core/database/repository.base.js

@@ -21,6 +21,9 @@ class RepositoryBase {
             entity: this._modelName,
         });
     }
+    getIdPropName(entity) {
+        return (Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype) ?? 'id');
+    }
     getConnectPrismaSchemaForRelation(entity, data) {
         const propIdName = this.getIdPropName(entity);
         return {
@@ -46,6 +49,39 @@ class RepositoryBase {
         });
         return selectSchema;
     }
+    getSelectWithRelationsId(entity) {
+        const selectSchema = {};
+        const entityProps = auto_mapping_list_1.AutoMappingList.getAllProps(entity);
+        entityProps.forEach((prop) => {
+            let instance;
+            try {
+                instance = new (prop.type())();
+            }
+            catch {
+                instance = null;
+            }
+            if (instance instanceof entity_base_1.EntityBase) {
+                selectSchema[prop.name] = {
+                    select: {
+                        [this.getIdPropName(entity[prop.name])]: true,
+                    },
+                };
+            }
+            else if (instance instanceof list_1.List) {
+                const list = new entity()[prop.name];
+                const entityInstance = list.entityType;
+                selectSchema[prop.name] = {
+                    select: {
+                        [this.getIdPropName(entityInstance)]: true,
+                    },
+                };
+            }
+            else {
+                selectSchema[prop.name] = true;
+            }
+        });
+        return selectSchema;
+    }
     getPropNameFromEntitySource(source, entity) {
         return Object.keys(source).find((key) => {
             const propDefinitions = auto_mapping_list_1.AutoMappingList.getPropDefinitions(source.constructor, key);
@@ -201,47 +237,47 @@ class RepositoryBase {
             .forEach((key) => (where[key] = entity[key]));
         return client[(0, KlString_1.toCamelCase)(entity.constructor.name)].delete({ where });
     }
-    getIdPropName(entity) {
-        return (Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype) ?? 'id');
+    async loadRelationForEntity(where, entity) {
+        return this._context[(0, KlString_1.toCamelCase)((0, KlString_1.toCamelCase)(entity.name))]
+            .findUnique({
+            select: this.getSelectWithRelationsId(entity),
+            where,
+        })
+            .then((data) => this.enrichEntityWithRelations(entity, data));
     }
-    async enrichEntityWithRelations(entity) {
+    async enrichEntityWithRelations(entity, data) {
         const relationQueries = [];
         const relationKeys = [];
-        const allProps = auto_mapping_list_1.AutoMappingList.getAllProps(this._modelName);
+        const allProps = auto_mapping_list_1.AutoMappingList.getAllProps(entity);
         allProps.forEach((prop) => {
             const propName = prop.name;
-            const propDef = auto_mapping_list_1.AutoMappingList.getPropDefinitions(this._modelName.prototype.constructor, propName);
+            const propDef = auto_mapping_list_1.AutoMappingList.getPropDefinitions(entity, propName);
+            if (propDef?.type === list_1.List.name) {
+                const list = new entity()[prop.name];
+                const entityInstance = list.entityType;
+                relationKeys.push(propName);
+                const items = [];
+                data[propName].forEach((item) => {
+                    items.push(this.loadRelationForEntity(item, entityInstance));
+                });
+                relationQueries.push(Promise.all(items));
+                return;
+            }
             const relationEntity = auto_mapping_list_1.AutoMappingList.getSourceByName(propDef?.type ?? '');
             if (relationEntity) {
                 relationKeys.push(propName);
-                relationQueries.push(this.loadRelationForEntity(entity[this.getIdPropName()], propName));
+                relationQueries.push(this.loadRelationForEntity({
+                    [this.getIdPropName(relationEntity)]: data[propName][this.getIdPropName(relationEntity)],
+                }, relationEntity));
             }
         });
         if (relationQueries.length > 0) {
             const results = await Promise.all(relationQueries);
             relationKeys.forEach((key, index) => {
-                entity[key] = results[index];
+                data[key] = results[index];
             });
         }
-        return entity;
-    }
-    async loadRelationForEntity(entityId, relationName) {
-        const result = await this.context().findUnique({
-            where: { [this.getIdPropName()]: entityId },
-            include: {
-                [relationName]: true,
-            },
-        });
-        const relationData = result?.[relationName];
-        if (relationData) {
-            if (Array.isArray(relationData)) {
-                return Promise.all(relationData.map((item) => this.enrichEntityWithRelations(item)));
-            }
-            else {
-                return this.enrichEntityWithRelations(relationData);
-            }
-        }
-        return relationData;
+        return data;
     }
     persistRelations(transaction, entity) {
         const { relationCreates, relationUpdates, relationDeletes } = this.listToRelationActionList(entity);
@@ -283,30 +319,33 @@ class RepositoryBase {
         return this._context[contextKey];
     }
     async findById(id) {
-        const entity = await this.context().findFirst({
+        const data = await this.context().findFirst({
+            select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
             where: { [this.getIdPropName()]: id },
         });
-        if (!entity)
+        if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(entity);
+        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, data);
         return this.createEntity(enrichedEntity);
     }
     async findFirst(where) {
-        const entity = await this.context().findFirst({
+        const data = await this.context().findFirst({
+            select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
             where,
         });
-        if (!entity)
+        if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(entity);
+        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, data);
         return this.createEntity(enrichedEntity);
     }
     async findUnique(where) {
-        const entity = await this.context().findUnique({
+        const data = await this.context().findUnique({
+            select: this.getSelectWithRelationsId(this._modelName.prototype.constructor),
             where,
         });
-        if (!entity)
+        if (!data)
             return null;
-        const enrichedEntity = await this.enrichEntityWithRelations(entity);
+        const enrichedEntity = await this.enrichEntityWithRelations(this._modelName.prototype.constructor, data);
         return this.createEntity(enrichedEntity);
     }
     async findMany(where, pagination) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koalarx/nest",
-  "version": "3.1.11",
+  "version": "3.1.12",
   "description": "",
   "author": "Igor D. Rangel",
   "license": "MIT",