@koalarx/nest 3.1.7 → 3.1.8

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

@@ -8,14 +8,12 @@ interface RepositoryInitProps<TEntity extends EntityBase<TEntity>, TContext exte
     context: TContext;
     modelName: Type<TEntity>;
     transactionContext?: Type<TContext>;
-    deepIncludeLimit?: number;
 }
 export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>, TContext extends PrismaTransactionalClient = PrismaTransactionalClient, TModelKey extends keyof TContext = keyof TContext> {
     protected _context: TContext;
     private readonly _modelName;
-    private readonly _include?;
     private readonly _includeFindMany?;
-    constructor({ context, modelName, deepIncludeLimit, }: RepositoryInitProps<TEntity, TContext>);
+    constructor({ context, modelName, }: RepositoryInitProps<TEntity, TContext>);
     private getConnectPrismaSchemaForRelation;
     private getSelectRootPrismaSchema;
     private getPropNameFromEntitySource;
@@ -27,6 +25,8 @@ export declare abstract class RepositoryBase<TEntity extends EntityBase<TEntity>
     private createEntity;
     private orphanRemoval;
     private getIdPropName;
+    private enrichEntityWithRelations;
+    private loadRelationForEntity;
     private persistRelations;
     protected context(transactionalClient?: TContext): TContext[TModelKey];
     protected findById(id: IComparableId): Promise<TEntity | null>;

package/core/database/repository.base.js

@@ -11,18 +11,13 @@ const entity_base_1 = require("./entity.base");
 class RepositoryBase {
     _context;
     _modelName;
-    _include;
     _includeFindMany;
-    constructor({ context, modelName, deepIncludeLimit, }) {
+    constructor({ context, modelName, }) {
         this._context = context;
         this._modelName = modelName;
-        this._include = (0, generate_prisma_include_schema_1.generateIncludeSchema)({
-            deepLimit: deepIncludeLimit || 5,
-            entity: this._modelName,
-        });
         this._includeFindMany = (0, generate_prisma_include_schema_1.generateIncludeSchema)({
             forList: true,
-            deepLimit: 3,
+            deepLimit: 1,
             entity: this._modelName,
         });
     }
@@ -170,7 +165,7 @@ class RepositoryBase {
         return prismaSchema;
     }
     getInclude(include) {
-        include = include ?? this._include ?? {};
+        include = include ?? {};
         const result = {};
         Object.keys(include).forEach((key) => {
             if (typeof include[key] === 'boolean') {
@@ -209,6 +204,42 @@ class RepositoryBase {
     getIdPropName(entity) {
         return (Reflect.getMetadata('entity:id', entity ? entity.constructor.prototype : this._modelName.prototype) ?? 'id');
     }
+    async enrichEntityWithRelations(entity) {
+        const relationQueries = [];
+        const relationKeys = [];
+        Object.keys(entity).forEach((key) => {
+            const propDef = auto_mapping_list_1.AutoMappingList.getPropDefinitions(this._modelName.prototype, key);
+            if (propDef) {
+                relationKeys.push(key);
+                relationQueries.push(this.loadRelationForEntity(entity[this.getIdPropName()], key));
+            }
+        });
+        if (relationQueries.length > 0) {
+            const results = await Promise.all(relationQueries);
+            relationKeys.forEach((key, index) => {
+                entity[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;
+    }
     persistRelations(transaction, entity) {
         const { relationCreates, relationUpdates, relationDeletes } = this.listToRelationActionList(entity);
         return Promise.all([
@@ -249,17 +280,13 @@ class RepositoryBase {
         return this._context[contextKey];
     }
     async findById(id) {
-        return this.context()
-            .findFirst({
-            include: this.getInclude(),
+        const entity = await this.context().findFirst({
             where: { [this.getIdPropName()]: id },
-        })
-            .then((response) => {
-            if (response) {
-                return this.createEntity(response);
-            }
-            return null;
         });
+        if (!entity)
+            return null;
+        const enrichedEntity = await this.enrichEntityWithRelations(entity);
+        return this.createEntity(enrichedEntity);
     }
     async findFirst(where) {
         return this.context()

package/package.json

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