@solidstarters/solid-core 1.2.32 → 1.2.33

package/src/controllers/view-metadata.controller.ts

@@ -4,6 +4,8 @@ import { ApiBearerAuth, ApiQuery, ApiTags } from '@nestjs/swagger';
 import { ViewMetadataService } from '../services/view-metadata.service';
 import { CreateViewMetadataDto } from '../dtos/create-view-metadata.dto';
 import { UpdateViewMetadataDto } from '../dtos/update-view-metadata.dto';
+import { SolidRequestContextDecorator } from 'src/decorators/solid-request-context.decorator';
+import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
 
 @ApiTags('App')
 @Controller('view-metadata') //FIXME: Change this to the model plural name 
@@ -13,23 +15,23 @@ export class ViewMetadataController {
   @ApiBearerAuth("jwt")
   @Post()
   @UseInterceptors(AnyFilesInterceptor())
-  create(@Body() createDto: CreateViewMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>) {
-    return this.service.create(createDto, files);
+  create(@Body() createDto: CreateViewMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
+    return this.service.create(createDto, files,solidRequestContext);
   }
 
   @ApiBearerAuth("jwt")
   @Post('/bulk')
   @UseInterceptors(AnyFilesInterceptor())
-  insertMany(@Body() createDtos: CreateViewMetadataDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = []) {
-    return this.service.insertMany(createDtos, filesArray);
+  insertMany(@Body() createDtos: CreateViewMetadataDto[], @UploadedFiles() filesArray: Express.Multer.File[][] = [],@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
+    return this.service.insertMany(createDtos, filesArray,solidRequestContext);
   }
 
 
   @ApiBearerAuth("jwt")
   @Put(':id')
   @UseInterceptors(AnyFilesInterceptor())
-  update(@Param('id') id: number, @Body() updateDto: UpdateViewMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>) {
-    return this.service.update(id, updateDto, files);
+  update(@Param('id') id: number, @Body() updateDto: UpdateViewMetadataDto, @UploadedFiles() files: Array<Express.Multer.File>,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
+    return this.service.update(id, updateDto, files,false,solidRequestContext);
   }
 
   @ApiBearerAuth("jwt")
@@ -44,25 +46,25 @@ export class ViewMetadataController {
   @ApiQuery({ name: 'populateMedia', required: false, type: Array })
   @ApiQuery({ name: 'filters', required: false, type: Array })
   @Get()
-  async findMany(@Query() query: any) {
-    return this.service.find(query);
+  async findMany(@Query() query: any,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
+    return this.service.find(query,solidRequestContext);
   }
 
   @ApiBearerAuth("jwt")
   @Get(':id')
-  async findOne(@Param('id') id: string, @Query() query: any) {
-    return this.service.findOne(+id, query);
+  async findOne(@Param('id') id: string, @Query() query: any,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
+    return this.service.findOne(+id, query,solidRequestContext);
   }
 
   @Delete('/bulk')
-  async deleteMany(@Body() ids: number[]) {
-    return this.service.deleteMany(ids);
+  async deleteMany(@Body() ids: number[],@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
+    return this.service.deleteMany(ids,solidRequestContext);
   }
 
   @ApiBearerAuth("jwt")
   @Delete(':id')
-  async delete(@Param('id') id: number) {
-    return this.service.delete(id);
+  async delete(@Param('id') id: number,@SolidRequestContextDecorator() solidRequestContext:SolidRequestContextDto) {
+    return this.service.delete(id,solidRequestContext);
   }
 
   @ApiBearerAuth("jwt")

package/src/decorators/solid-request-context.decorator.ts

@@ -0,0 +1,17 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { ActiveUserData } from '../interfaces/active-user-data.interface';
+import { REQUEST_USER_KEY } from '../constants';
+import { SolidRequestContextDto } from 'src/dtos/solid-request-context.dto';
+
+export const SolidRequestContextDecorator = createParamDecorator(
+  (data: unknown, ctx: ExecutionContext): SolidRequestContextDto => {
+    const request = ctx.switchToHttp().getRequest();
+    const activeUser: ActiveUserData | undefined = request[REQUEST_USER_KEY]; // Get active user
+
+    // Create a new instance of SolidRequestContextDto and stamp user data
+    const solidRequestContext = new SolidRequestContextDto();
+    solidRequestContext.activeUser = activeUser;
+
+    return solidRequestContext; // Return modified request context DTO
+  },
+);

package/src/dtos/solid-request-context.dto.ts

@@ -0,0 +1,10 @@
+import { IsOptional } from 'class-validator';
+import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
+
+export class SolidRequestContextDto {
+
+    
+    @IsOptional()
+    activeUser: ActiveUserData;
+    
+}

package/src/index.ts

@@ -10,6 +10,7 @@ export * from './config/iam.config'
 export * from './config/cache.options'
 
 export * from './decorators/active-user.decorator'
+export * from './decorators/solid-request-context.decorator'
 export * from './decorators/auth.decorator'
 export * from './decorators/computed-field-provider.decorator'
 export * from './decorators/is-not-in-enum.decorator'
@@ -19,8 +20,8 @@ export * from './decorators/roles.decorator'
 export * from './decorators/selection-provider.decorator'
 export * from './decorators/solid-database-module.decorator'
 export * from './decorators/solid-service.decorator'
-
 export * from './dtos/basic-filters.dto'
+export * from './dtos/solid-request-context.dto'
 export * from './dtos/change-password.dto'
 export * from './dtos/confirm-forgot-password.dto'
 export * from './dtos/create-action-metadata.dto'

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

@@ -1,12 +1,14 @@
 import { Brackets, SelectQueryBuilder, WhereExpressionBuilder } from "typeorm";
 import { BasicFilterDto } from "../dtos/basic-filters.dto";
+import { classify } from "@angular-devkit/core/src/utils/strings";
+import { ActiveUserData } from "src/interfaces/active-user-data.interface";
 
 export class CrudHelperService {
     constructor(
 
     ) { }
 
-    
+
     private orderOptions(sort: any[] = []) {
         const orderOptions = {};
         sort.forEach((s: string) => {
@@ -51,7 +53,7 @@ export class CrudHelperService {
                 }
                 else { // Recursively call the applyFilters method to handle nested conditions
                     selectQb.leftJoin(`${alias}.${key}`, key);
-                    this.applyFilters(qb, primaryFilterObj, key, selectQb);    
+                    this.applyFilters(qb, primaryFilterObj, key, selectQb);
                 }
             });
         }
@@ -139,7 +141,7 @@ export class CrudHelperService {
         }, {});
     }
 
-    private normalize(value: string|string[]): string[] {
+    private 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
     }
@@ -150,7 +152,7 @@ export class CrudHelperService {
 
     buildFilterQuery(qb: SelectQueryBuilder<any>, basicFilterDto: BasicFilterDto, entityAlias: string): SelectQueryBuilder<any> { //TODO : Check how to pass a type to SelectQueryBuilder instead of any
         let { limit, offset, showSoftDeleted, filters } = basicFilterDto;
-        const { fields, sort, groupBy, populate = [] } = basicFilterDto; 
+        const { fields, sort, groupBy, populate = [] } = basicFilterDto;
 
         // Normalize the fields, sort, groupBy and populate options i.e (since they can be either a string or an array of strings, when coming from the request)
         const normalizedFields = this.normalize(fields);
@@ -158,7 +160,7 @@ export class CrudHelperService {
         const normalizedSort = this.normalize(sort);
         const normalizedGroupBy = this.normalize(groupBy);
         if (normalizedGroupBy.length > 1) {
-             throw new Error('buildFilterQuery: Only 1 Group by field is supported currently');
+            throw new Error('buildFilterQuery: Only 1 Group by field is supported currently');
         }
 
         if (filters) {
@@ -171,7 +173,7 @@ export class CrudHelperService {
         if (normalizedFields && normalizedFields.length) {
             qb.select(normalizedFields.map(field => {
                 // If the field contains a (, do not prefix the entity alias
-                return this.isAggregateField(field) ?  field : `${entityAlias}.${field}`;
+                return this.isAggregateField(field) ? field : `${entityAlias}.${field}`;
             }));
         }
 
@@ -200,11 +202,11 @@ export class CrudHelperService {
         if (showSoftDeleted === 'inclusive') {
             qb.withDeleted();
         }
-        
+
         if (showSoftDeleted === 'exclusive') {
             qb.withDeleted();
             qb.where(`${entityAlias}.deletedAt IS NOT NULL`);
-        }        
+        }
 
         // Apply the group by options
         if (normalizedGroupBy && normalizedGroupBy.length) {
@@ -245,9 +247,9 @@ export class CrudHelperService {
 
     getGroupName(group: any, alias: string): string {
         return Object.keys(group)
-        .filter(key => !this.isAggregateFieldKey(key, alias))
-        .map(key => group[key])
-        .join('_');
+            .filter(key => !this.isAggregateFieldKey(key, alias))
+            .map(key => group[key])
+            .join('_');
     }
 
     createGroupRecords(group: any, alias: string, groupData: any) {
@@ -272,4 +274,36 @@ export class CrudHelperService {
         };
     }
 
+
+    hasReadPermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
+        const permissionNames = [`${classify(modelName)}Controller.findOne`, `${classify(modelName)}Controller.findMany`];
+        const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+        return matchingPermssions.length > 0
+    }
+
+    hasWritePermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
+        const permissionNames = [`${classify(modelName)}Controller.create`, `${classify(modelName)}Controller.insertMany`, `${classify(modelName)}Controller.update`];
+        const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+        return matchingPermssions.length > 0
+    }
+
+    hasUpdatePermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
+        const permissionNames = [`${classify(modelName)}Controller.update`];
+        const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+        return matchingPermssions.length > 0
+    }
+
+    hasDeletePermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
+        const permissionNames = [`${classify(modelName)}Controller.delete`, `${classify(modelName)}Controller.deleteMany`];
+        const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+        return matchingPermssions.length > 0
+    }
+    hasCreatePermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
+        const permissionNames = [`${classify(modelName)}Controller.create`];
+        const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
+        return matchingPermssions.length > 0
+    }
+
+
+
 }

package/src/services/crud.service.ts

@@ -36,6 +36,7 @@ import { MediaService } from "./media.service";
 import { getMediaStorageProvider } from "./mediaStorageProviders";
 import { ModelMetadataService } from "./model-metadata.service";
 import { ModuleMetadataService } from "./module-metadata.service";
+import { SolidRequestContextDto } from "src/dtos/solid-request-context.dto";
 
 const DEFAULT_LIMIT = 10;
 const DEFAULT_OFFSET = 0;
@@ -57,7 +58,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         //We can just have the Model Entity here
     ) { }
 
-    async create(createDto: any, files: Express.Multer.File[] = []): Promise<T> {
+    async create(createDto: any, files: Express.Multer.File[] = [],solidRequestContext :any = {}): Promise<T> {
         // This class will be extended by the generated service class i.e PersonService
         // The data required to identify the model and module name will be passed from the generate CrudService subclass
         //TODO: Algorithm to create the entity
@@ -66,6 +67,13 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         let hasMediaFields = false;
 
         const model = await this.loadModel();
+        // Check wheather user has create permission for model
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasCreatePermissionOnModel(solidRequestContext.activeUser, model.singularName);
+            if (!hasPermission) {
+                throw new BadRequestException('Forbidden');
+            }
+        }
         // const inverseRelationFields = await this.loadInverseRelationFields();
         const fieldsToProcess = [...model.fields];
 
@@ -162,10 +170,18 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
     }
 
     //TODO: Will the updates be partial i.e PATCH or full i.e PUT
-    async update(id: number, updateDto: any, files: Express.Multer.File[] = [], isPartialUpdate: boolean = false): Promise<T> {
+    async update(id: number, updateDto: any, files: Express.Multer.File[] = [], isPartialUpdate: boolean = false, solidRequestContext: any = {}): Promise<T> {
         if (!id) {
             throw new Error('Id is required for update');
         }
+        const model = await this.loadModel();
+        // Check wheather user has update permission for model
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasUpdatePermissionOnModel(solidRequestContext.activeUser, model.singularName);
+            if (!hasPermission) {
+                throw new BadRequestException('Forbidden');
+            }
+        }
         const entity = await this.repo.findOne({
             where: {
                 //@ts-ignore
@@ -184,7 +200,6 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         // FIXME This can be optimized to take in module name i.e (handle scenario wherein same model exists in multiple modules)
         let hasMediaFields = false;
 
-        const model = await this.loadModel();
         const fieldsToProcess = [...model.fields];
 
         // 2. Loop through the fields with a switch statement
@@ -208,11 +223,19 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
     }
 
     //TODO: Will the updates be partial i.e PATCH or full i.e PUT
-    async delete(id: number) {
+    async delete(id: number, solidRequestContext: any = {}) {
         if (!id) {
             throw new Error('Id is required for update');
         }
-
+        const loadedmodel = await this.loadModel();
+        // Check wheather user has update permission for model
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasDeletePermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
+            if (!hasPermission) {
+                throw new BadRequestException('Forbidden');
+            }
+        }
+        
         const model = await this.modelMetadataService.findOneBySingularName(this.modelName, {
             fields: {
                 model: true,
@@ -305,25 +328,25 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
             case SolidFieldType.relation: {
                 // Identify if the field is for the inverse side or not
                 if (fieldMetadata.relationType === RelationType.manyToOne) {
-                        const manyToOneOptions: ManyToOneRelationFieldOptions = {
-                            ...commonOptions,
-                            relationCoModelSingularName: fieldMetadata.relationCoModelSingularName,
-                            modelUserKeyFieldName: fieldMetadata.model.userKeyField?.name,
-                            modelSingularName: fieldMetadata.model.singularName,
-                            entityManager,
-                        }
-                        return new ManyToOneRelationFieldCrudManager(manyToOneOptions);
+                    const manyToOneOptions: ManyToOneRelationFieldOptions = {
+                        ...commonOptions,
+                        relationCoModelSingularName: fieldMetadata.relationCoModelSingularName,
+                        modelUserKeyFieldName: fieldMetadata.model.userKeyField?.name,
+                        modelSingularName: fieldMetadata.model.singularName,
+                        entityManager,
+                    }
+                    return new ManyToOneRelationFieldCrudManager(manyToOneOptions);
                 }
                 else if (fieldMetadata.relationType === RelationType.oneToMany) {
-                        const oneToManyOptions: OneToManyRelationFieldOptions = {
-                            ...commonOptions,
-                            relationCoModelSingularName: fieldMetadata.relationCoModelSingularName,
-                            modelSingularName: fieldMetadata.model.singularName,
-                            entityManager,
-                            inverseFieldName: fieldMetadata.relationCoModelFieldName,
-                            inverseRelationCoModelFieldName: fieldMetadata.name,
-                        }
-                        return new OneToManyRelationFieldCrudManager(oneToManyOptions);
+                    const oneToManyOptions: OneToManyRelationFieldOptions = {
+                        ...commonOptions,
+                        relationCoModelSingularName: fieldMetadata.relationCoModelSingularName,
+                        modelSingularName: fieldMetadata.model.singularName,
+                        entityManager,
+                        inverseFieldName: fieldMetadata.relationCoModelFieldName,
+                        inverseRelationCoModelFieldName: fieldMetadata.name,
+                    }
+                    return new OneToManyRelationFieldCrudManager(oneToManyOptions);
                 }
                 else if (fieldMetadata.relationType === RelationType.manyTomany) {
                     if (fieldMetadata.isRelationManyToManyOwner) {
@@ -335,7 +358,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                             entityManager,
                             fieldName: fieldMetadata.name,
                         }
-                        return new ManyToManyRelationFieldCrudManager(manyToManyOptions); 
+                        return new ManyToManyRelationFieldCrudManager(manyToManyOptions);
                     }
                     else {
                         const inverseManyToManyOptions: ManyToManyRelationFieldOptions = {
@@ -392,10 +415,18 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
     }
 
 
-    async find(basicFilterDto: BasicFilterDto) {
+    async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}) {
         const alias = 'entity';
         // Extract the required keys from the input query
-        let { limit, offset, populateMedia, populateGroup,groupFilter } = basicFilterDto;
+        let { limit, offset, populateMedia, populateGroup, groupFilter } = basicFilterDto;
+        const model = await this.loadModel();
+        // Check wheather user has update permission for model
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasReadPermissionOnModel(solidRequestContext.activeUser, model.singularName);
+            if (!hasPermission) {
+                throw new BadRequestException('Forbidden');
+            }
+        }
 
         // Create above query on pincode table using query builder
         var qb: SelectQueryBuilder<T> = this.repo.createQueryBuilder(alias)
@@ -403,7 +434,7 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
 
         if (basicFilterDto.groupBy) {
             // 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);
             return {
                 groupMeta,
                 groupRecords,
@@ -430,7 +461,7 @@ 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 handleGroupFind(qb: SelectQueryBuilder<T>, groupFilter: BasicFilterDto, populateGroup: boolean, alias: string, populateMedia: string[]) {
         const groupByResult = await qb.getRawMany();
 
         const groupMeta = [];
@@ -515,8 +546,18 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         }
     }
 
-    async findOne(id: number, query: any) {
+    async findOne(id: number, query: any, solidRequestContext: any = {}) {
         const { populate = [], fields = [], populateMedia = [] } = query;
+
+        const model = await this.loadModel();
+        // Check wheather user has update permission for model
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasReadPermissionOnModel(solidRequestContext.activeUser, model.singularName);
+            if (!hasPermission) {
+                throw new BadRequestException('Forbidden');
+            }
+        }
+
         const entity = await this.repo.findOne({
             where: {
                 //@ts-ignore
@@ -557,13 +598,22 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         return entity;
     }
 
-    async insertMany(createDtos: any[], filesArray: Express.Multer.File[][] = []): Promise<T[]> {
+    async insertMany(createDtos: any[], filesArray: Express.Multer.File[][] = [],solidRequestContext: any = {}): Promise<T[]> {
 
 
         // if (createDtos.length !== filesArray.length) {
         //     throw new BadRequestException('Mismatch between data objects and file arrays.');
         // }
 
+        const loadedmodel = await this.loadModel();
+        // Check wheather user has create permission for model
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasCreatePermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
+            if (!hasPermission) {
+                throw new BadRequestException('Forbidden');
+            }
+        }
+
         // Fetch model metadata once
         const model = await this.modelMetadataService.findOneBySingularName(this.modelName, {
             fields: {
@@ -607,12 +657,20 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
         return savedEntities;
     }
 
-    async deleteMany(ids: number[]): Promise<any> {
+    async deleteMany(ids: number[],solidRequestContext: any = {}): Promise<any> {
 
         if (!ids || ids.length === 0) {
             throw new Error('At least one ID is required for deletion');
         }
 
+        const loadedmodel = await this.loadModel();
+        // Check wheather user has update permission for model
+        if (solidRequestContext.activeUser) {
+            const hasPermission = this.crudHelperService.hasDeletePermissionOnModel(solidRequestContext.activeUser, loadedmodel.singularName);
+            if (!hasPermission) {
+                throw new BadRequestException('Forbidden');
+            }
+        }
         const model = await this.modelMetadataService.findOneBySingularName(this.modelName, {
             fields: {
                 model: true,
@@ -645,41 +703,41 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
 
     async recover(id: number) {
         try {
-          const softDeletedRows = await this.repo.findOne({
-            where: { 
-                //@ts-ignore
-                id, deletedAt: Not(IsNull()) 
-            },
-            withDeleted: true,
-          });
-      
-          if (!softDeletedRows) {
-            throw new Error('No soft-deleted record found with the given ID.');
-          }
-      
-          await this.repo.update(id, {
+            const softDeletedRows = await this.repo.findOne({
+                where: {
+                    //@ts-ignore
+                    id, deletedAt: Not(IsNull())
+                },
+                withDeleted: true,
+            });
+
+            if (!softDeletedRows) {
+                throw new Error('No soft-deleted record found with the given ID.');
+            }
+
+            await this.repo.update(id, {
                 //@ts-ignore
-                deletedAt: null, deletedTracker: "not-deleted" 
+                deletedAt: null, deletedTracker: "not-deleted"
             });
-      
-          return { message: 'Record successfully recovered', data: softDeletedRows };
+
+            return { message: 'Record successfully recovered', data: softDeletedRows };
         } catch (error) {
-          if (error instanceof QueryFailedError) {
-            if ((error as any).code === '23505') {
-              throw new Error('Another record is conflicting with the record you are attempting to Un-Archive, either delete or change the other record so as to avoid this conflict.');
+            if (error instanceof QueryFailedError) {
+                if ((error as any).code === '23505') {
+                    throw new Error('Another record is conflicting with the record you are attempting to Un-Archive, either delete or change the other record so as to avoid this conflict.');
+                }
             }
-          }
-    
-          throw new Error(error);
+
+            throw new Error(error);
         }
     }
-    
+
     async recoverMany(ids: number[]) {
         try {
             if (!ids || ids.length === 0) {
                 throw new Error("No IDs provided for recovery.");
             }
-    
+
             // Find soft-deleted records matching the given IDs
             const softDeletedRows = await this.repo.find({
                 where: {
@@ -689,18 +747,18 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                 },
                 withDeleted: true,
             });
-    
+
             if (softDeletedRows.length === 0) {
                 throw new Error("No matching soft-deleted records found.");
             }
-    
+
             // Recover the specific records by setting deletedAt to null
             await this.repo.update(
                 //@ts-ignore
                 { id: In(ids) },
                 { deletedAt: null, deletedTracker: "not-deleted" }
             );
-    
+
             return { message: "Selected records successfully recovered", recoveredIds: ids };
         } catch (error) {
             if (error instanceof QueryFailedError) {
@@ -710,10 +768,10 @@ export class CRUDService<T> { //Add two generic value i.e Person,CreatePersonDto
                     );
                 }
             }
-    
+
             throw new Error(error);
         }
     }
-    
+
 
 }

package/src/services/menu-item-metadata.service.ts

@@ -17,7 +17,6 @@ import { UpdateMenuItemMetadataDto } from '../dtos/update-menu-item-metadata.dto
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
 import { ModuleMetadata } from '../entities/module-metadata.entity';
 import { dasherize } from '@angular-devkit/core/src/utils/strings';
-import { hasReadPermissionOnModel } from './permission-metadata.service';
 
 @Injectable()
 export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
@@ -148,13 +147,13 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
   // Recursive function to build the tree
   private buildMenuTree(rootItems: MenuItemMetadata[], allMenuItems: MenuItemMetadata[], activeUser: ActiveUserData): any[] {
     const menuItemsData = rootItems.map(rootItem => {
-      const allowedMenuItems =allMenuItems.filter(i => {
-        if(!i.parentMenuItem){
+      const allowedMenuItems = allMenuItems.filter(i => {
+        if (!i.parentMenuItem) {
           return true
-        }else{
-          const hasPermission = hasReadPermissionOnModel(activeUser, i.action.model.singularName);
-          return  hasReadPermissionOnModel(activeUser, i.action.model.singularName)
-        }}); 
+        } else {
+          return this.crudHelperService.hasReadPermissionOnModel(activeUser, i.action.model.singularName)
+        }
+      });
       // Get immediate children of the current loop variable menuItem.
       const children = allowedMenuItems.filter(item => item.parentMenuItem && item.parentMenuItem.id === rootItem.id);
 
@@ -166,7 +165,7 @@ export class MenuItemMetadataService extends CRUDService<MenuItemMetadata> {
         path = rootItem.action.customComponent;
       }
       if (rootItem.action && rootItem.action.type === 'solid') {
-        if (hasReadPermissionOnModel(activeUser, rootItem.action.model.singularName)) {
+        if (this.crudHelperService.hasReadPermissionOnModel(activeUser, rootItem.action.model.singularName)) {
 
 
           // TODO: Here we are assuming that we will always take the user to collection view of a model. 

package/src/services/permission-metadata.service.ts

@@ -61,33 +61,4 @@ export class PermissionMetadataService extends CRUDService<PermissionMetadata> {
 
 }
 
-export const hasReadPermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
-  const permissionNames = [`${classify(modelName)}Controller.findOne`, `${classify(modelName)}Controller.findMany`];
-  const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
-  return matchingPermssions.length > 0
-}
-
-export const hasWritePermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
-  const permissionNames = [`${classify(modelName)}Controller.create`, `${classify(modelName)}Controller.insertMany`, `${classify(modelName)}Controller.update`];
-  const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
-  return matchingPermssions.length > 0
-}
-
-export const hasUpdatePermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
-  const permissionNames = [`${classify(modelName)}Controller.update`];
-  const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
-  return matchingPermssions.length > 0
-}
-
-export const hasDeletePermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
-  const permissionNames = [`${classify(modelName)}Controller.delete`, `${classify(modelName)}Controller.deleteMany`];
-  const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
-  return matchingPermssions.length > 0
-}
-export const hasCreatePermissionOnModel = (activeUser: ActiveUserData, modelName: string) => {
-  const permissionNames = [`${classify(modelName)}Controller.create`];
-  const matchingPermssions = activeUser.permissions.filter((p) => permissionNames.includes(p));
-  return matchingPermssions.length > 0
-}
-
 

package/src/services/user.service.ts

@@ -75,7 +75,7 @@ export class UserService extends CRUDService<User> {
     // return entity;
   }
 
-  async updateUser(id: any, updateDto, files) {
+  async updateUser(id: any, updateDto, files,solidRequestContext :any = {}) {
     const user = await this.repo.findOne({
       where: { id: id },
       relations: {