@solidstarters/solid-core 1.2.34 → 1.2.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.34",
+  "version": "1.2.37",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/services/crud-helper.service.ts

@@ -141,7 +141,7 @@ export class CrudHelperService {
         }, {});
     }
 
-    private normalize(value: string | string[]): string[] {
+    normalize(value: string | string[]): string[] {
         if (!value) return [];// if the value is nullish, then return an empty array
         return Array.isArray(value) ? value : [value];        // if the value is an array, return it as is, otherwise return it as an array
     }
@@ -312,6 +312,11 @@ export class CrudHelperService {
         const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
         return matchingPermssions.length > 0
     }
+    hasRecoverPermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
+        const permissionNames = [`${classify(modelName)}Controller.recover`, `${classify(modelName)}Controller.recoverMany`];
+        const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+        return matchingPermssions.length > 0
+    }
 
 
 

package/src/services/crud.service.ts

@@ -428,13 +428,19 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
             }
         }
 
+        // Exclude one-to-many and many-to-one relations from the initial filter query, since they will be queried separately
+        const relationsExcludedFromInitialQuery = this.relationsExcludedFromInitialQuery(model, basicFilterDto.populate);
+        basicFilterDto = this.getRevisedFilterDto(basicFilterDto, relationsExcludedFromInitialQuery);
+        
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias)
         qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
-
+        
         if (basicFilterDto.groupBy) {
+            const relationsExcludedFromInitialQuery = this.relationsExcludedFromInitialQuery(model, groupFilter.populate);
+            groupFilter = this.getRevisedFilterDto(groupFilter, relationsExcludedFromInitialQuery);
             // Get the records and the count
-            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia);
+            const { groupMeta, groupRecords } = await this.handleGroupFind(qb, groupFilter, populateGroup, alias, populateMedia, relationsExcludedFromInitialQuery);
             return {
                 groupMeta,
                 groupRecords,
@@ -442,7 +448,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         }
         else {
             // Get the records and the count
-            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit);
+            const { meta, records } = await this.handleNonGroupFind(qb, populateMedia, offset, limit, alias, relationsExcludedFromInitialQuery);
             return {
                 meta,
                 records,
@@ -450,9 +456,28 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         }
     }
 
-    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateMedia: string[], offset: number, limit: number) {
+    private getRevisedFilterDto(basicFilterDto: BasicFilterDto, relationsExcludedFromInitialQuery: string[]): BasicFilterDto {
+        const normalizedPopulate = this.crudHelperService.normalize(basicFilterDto.populate);
+        if (normalizedPopulate.length === 0 || relationsExcludedFromInitialQuery.length === 0) return basicFilterDto;
+        return  { ...basicFilterDto, populate: normalizedPopulate.filter(populate => !relationsExcludedFromInitialQuery.includes(populate)) };
+    }
+
+    private relationsExcludedFromInitialQuery(model: ModelMetadata, relationsToBePopulated: string[] = []): string[] {
+        const  relationToBeExcluded =
+         model.fields
+        .filter(field => field.type === 'relation' && [RelationType.manyTomany, RelationType.oneToMany].includes(field.relationType as RelationType))
+        .map(field => field.name);
+        return relationsToBePopulated.filter(relation => relationToBeExcluded.includes(relation));
+    }
+
+    private async handleNonGroupFind(qb: SelectQueryBuilder<T>, populateMedia: string[], offset: number, limit: number, alias: string, relationsExcludedFromInitialQuery: string[]) {
         const [entities, count] = await qb.getManyAndCount();
 
+        // Populate the excluded relations for the entities
+        if (relationsExcludedFromInitialQuery.length > 0) {
+            await this.populateExcludedRelations(entities, relationsExcludedFromInitialQuery, alias);
+        }
+
         // Populate the entity with the media
         if (populateMedia && populateMedia.length > 0) {
             await this.handlePopulateMedia(populateMedia, entities);
@@ -461,7 +486,36 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         return this.wrapFindResponse(offset, limit, count, entities);
     }
 
-    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[]) {
+    private async populateExcludedRelations(entities: T[], relationsExcludedFromInitialQuery: string[], alias: string) {
+        //@ts-ignore
+        const ids = entities.map(entity => entity.id);
+
+        // Fire a query to get the records from the relation entity which match the ids
+        // Create a map with key as the entity id and value as the qb records
+        const relationEntitiesMap = {};
+        for (const relation of relationsExcludedFromInitialQuery) {
+            const qb = this.repo.createQueryBuilder(`${alias}`)
+                .leftJoinAndSelect(`${alias}.${relation}`, relation)
+                .where(`${alias}.id IN (:...ids)`, { ids })
+                // .limit(DEFAULT_LIMIT)
+                // .offset(DEFAULT_OFFSET);
+            const relationEntities = await qb.getMany();
+            relationEntitiesMap[relation] = relationEntities;
+        }
+
+        // Iterate over the map and assign the relation entities to the entity
+        for (const relation of relationsExcludedFromInitialQuery) {
+            for (const entity of entities) {
+                const entityRelations = relationEntitiesMap[relation]
+                    //@ts-ignore
+                    .filter((joinedEntity: T) => joinedEntity.id === entity.id)
+                    .flatMap((joinedEntity: T) => joinedEntity[relation]);
+                entity[relation] = entityRelations;
+            }
+        }
+    }
+
+    private async handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[], relationsExcludedFromInitialQuery: string[]) {
         const groupByResult = await qb.getRawMany();
 
         const groupMeta = [];
@@ -470,15 +524,14 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         for (const group of groupByResult) {
             if (populateGroup) {
                 let groupByQb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias);
-                // For the group by records, apply the basic filter
-                // const basicFilterDto = {
-                //     limit: DEFAULT_LIMIT,
-                //     offset: DEFAULT_OFFSET,
-                // };
                 groupByQb = this.crudHelperService.buildFilterQuery(groupByQb, groupFilter, alias);
                 groupByQb = this.crudHelperService.buildGroupByRecordsQuery(groupByQb, group, alias);
                 const [entities, count] = await groupByQb.getManyAndCount();
 
+                // Populate the excluded relations for the entities
+                if (relationsExcludedFromInitialQuery.length > 0) {
+                    await this.populateExcludedRelations(entities, relationsExcludedFromInitialQuery, alias);
+                }
 
                 // Populate the entity with the media
                 if (populateMedia && populateMedia.length > 0) {
@@ -701,8 +754,17 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         // return removedEntities
     }
 
-    async recover(id: number) {
+    async recover(id: number,solidRequestContext: any = {}) {
         try {
+            const loadedmodel = await this.loadModel();
+            // Check wheather user has update permission for model
+            if (solidRequestContext.activeUser) {
+                const hasPermission = this.crudHelperService.hasRecoverPermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
+                if (!hasPermission) {
+                    throw new BadRequestException('Forbidden');
+                }
+            }
+
             const softDeletedRows = await this.repo.findOne({
                 where: {
                     //@ts-ignore
@@ -732,8 +794,17 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         }
     }
 
-    async recoverMany(ids: number[]) {
+    async recoverMany(ids: number[],solidRequestContext: any = {}) {
         try {
+            const loadedmodel = await this.loadModel();
+            // Check wheather user has update permission for model
+            if (solidRequestContext.activeUser) {
+                const hasPermission = this.crudHelperService.hasRecoverPermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
+                if (!hasPermission) {
+                    throw new BadRequestException('Forbidden');
+                }
+            }
+
             if (!ids || ids.length === 0) {
                 throw new Error("No IDs provided for recovery.");
             }