@solidstarters/solid-core 1.2.189 → 1.2.192

package/src/repository/role-metadata.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { RoleMetadata } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class RoleMetadataRepository extends SolidBaseRepository<RoleMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(RoleMetadata, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/saved-filters.repository.ts

@@ -0,0 +1,65 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { CreateSavedFiltersDto } from "src/dtos/create-saved-filters.dto";
+import { ModelMetadata } from "src/entities/model-metadata.entity";
+import { SavedFilters } from "src/entities/saved-filters.entity";
+import { User } from "src/entities/user.entity";
+import { ViewMetadata } from "src/entities/view-metadata.entity";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { CrudHelperService } from "src/services/crud-helper.service";
+import { DataSource, Repository } from "typeorm";
+import { SolidBaseRepository } from "./solid-base.repository";
+
+@Injectable()
+export class SavedFiltersRepository extends SolidBaseRepository<SavedFilters> {
+    readonly logger = new Logger(SavedFiltersRepository.name);
+
+    constructor(
+        private dataSource: DataSource,
+    ) {
+        super(SavedFilters, dataSource, null , null);
+    }
+
+    /**
+     * Converts an entity to a plain DTO object.
+     */
+
+    async upsertWithDto(dto: CreateSavedFiltersDto): Promise<SavedFilters> {
+        const modelRepo = this.dataSource.getRepository(ModelMetadata);
+        const viewRepo = this.dataSource.getRepository(ViewMetadata);
+
+        // Find related entities based on keys from DTO
+        const [modelEntity, viewEntity] = await Promise.all([
+            modelRepo.findOne({ where: { singularName: dto.modelUserKey } }),
+            viewRepo.findOne({ where: { name: dto.viewUserKey } }),
+        ]);
+
+
+        if (!modelEntity || !viewEntity) {
+            throw new Error(
+                `Missing related entity for SavedFilter: model=${dto.modelUserKey}, view=${dto.viewUserKey}`
+            );
+        }
+
+        const filterData:Partial<SavedFilters> = {
+            ...dto,
+            isPrivate: false,
+            user: null,
+            model: modelEntity,
+            view: viewEntity,
+        };
+
+        const existing = await this.findOne({
+            where: { name: dto.name },
+        });
+
+        if (existing) {
+            const merged = this.merge(existing, filterData);
+            this.logger.debug(`Updating saved filter: ${dto.name}`);
+            return this.save(merged);
+        } else {
+            this.logger.debug(`Creating saved filter: ${dto.name}`);
+            return this.save(this.create(filterData));
+        }
+    }
+
+}

package/src/repository/scheduled-job.repository.ts

@@ -1,10 +1,11 @@
-import { Injectable, Logger } from "@nestjs/common";
+import { Injectable } from "@nestjs/common";
 import { CreateScheduledJobDto } from "src/dtos/create-scheduled-job.dto";
 import { ModuleMetadata } from "src/entities/module-metadata.entity";
 import { ScheduledJob } from "src/entities/scheduled-job.entity";
-import { SolidRegistry } from "src/helpers/solid-registry";
-import { CrudHelperService } from "src/services/crud-helper.service";
-import { DataSource, Repository } from "typeorm";
+import { RequestContextService } from "src/services/request-context.service";
+import { DataSource } from "typeorm";
+import { SecurityRuleRepository } from "./security-rule.repository";
+import { SolidBaseRepository } from "./solid-base.repository";
 
 // This should match whatever DTO structure you’re using in your seeding logic
 // export type CreateScheduledJobDto = {
@@ -24,16 +25,14 @@ import { DataSource, Repository } from "typeorm";
 // };
 
 @Injectable()
-export class ScheduledJobRepository extends Repository<ScheduledJob> {
-  private readonly logger = new Logger(ScheduledJobRepository.name);
-
-  constructor(
-    private dataSource: DataSource,
-    private readonly solidRegistry: SolidRegistry,
-    private readonly crudHelperService: CrudHelperService
-  ) {
-    super(ScheduledJob, dataSource.createEntityManager());
-  }
+export class ScheduledJobRepository extends SolidBaseRepository<ScheduledJob> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ScheduledJob, dataSource, requestContextService, securityRuleRepository);
+    }
 
   /**
    * Converts an entity to a plain DTO object.

package/src/repository/security-rule.repository.ts

@@ -1,4 +1,4 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { CreateSecurityRuleDto } from 'src/dtos/create-security-rule.dto';
 import { SecurityRuleConfig } from 'src/dtos/security-rule-config.dto';
 import { UpdateSecurityRuleDto } from 'src/dtos/update-security-rule.dto';
@@ -8,21 +8,22 @@ import { RoleMetadata } from 'src/entities/role-metadata.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
-import { CrudHelperService, FilterCombinator } from 'src/services/crud-helper.service';
-import { Brackets, DataSource, Repository, SelectQueryBuilder } from 'typeorm';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+import { Brackets, DataSource, SelectQueryBuilder } from 'typeorm';
+import { SolidBaseRepository } from './solid-base.repository';
 
 @Injectable()
-export class SecurityRuleRepository extends Repository<SecurityRule> {
-    private readonly logger = new Logger(SecurityRuleRepository.name);
+export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
     constructor(
-        private dataSource: DataSource,
-        private readonly solidRegistry: SolidRegistry,
-        private readonly crudHelperService: CrudHelperService,
+        readonly dataSource: DataSource,
+        // readonly requestContextService: RequestContextService,
+        readonly solidRegistry: SolidRegistry,
+        readonly crudHelperService: CrudHelperService,
     ) {
-        super(SecurityRule, dataSource.createEntityManager());
+        super(SecurityRule, dataSource, null, null);
     }
 
-    applySecurityRules<T extends CommonEntity>(qb: SelectQueryBuilder<T>, modelSingularName: string, activeUser: ActiveUserData, securityRuleAlias: string = qb.alias): SelectQueryBuilder<T> {
+    async applySecurityRules<T extends CommonEntity>(qb: SelectQueryBuilder<T>, modelSingularName: string, activeUser: ActiveUserData, securityRuleAlias: string = qb.alias): Promise<SelectQueryBuilder<T>> {
         // Fetch the security rules for the model and roles
         const securityRules = this.solidRegistry.getSecurityRules(modelSingularName, activeUser.roles);
 
@@ -31,23 +32,42 @@ export class SecurityRuleRepository extends Repository<SecurityRule> {
             return qb;
         }
 
-        // Apply each security rule to the query builder. The rules are combined with OR logic at the top level.
-        qb.andWhere(new Brackets((outerQb) => {
-            for (const rule of securityRules) {
-                try {
-                    const parsedRule = JSON.parse(
+        const evaluatedRules = [];
+
+        for (const rule of securityRules) {
+
+            let evaluatedRule = null;
+
+            try {
+                // First check if the rule has a "dynamic" security rule config provider. 
+                if (rule.securityRuleConfigProvider) {
+                    // TODO: Evaluation of the securityRuleConfig Provider should happen outside first...
+                    const securityRuleConfigProviderInstance = this.solidRegistry.getSecurityRuleConfigProviderInstance(rule.securityRuleConfigProvider);
+                    evaluatedRule = await securityRuleConfigProviderInstance.securityRuleConfig(activeUser, rule);
+                }
+                else {
+                    evaluatedRule = JSON.parse(
                         this.resolveSecurityRuleConfig(rule.securityRuleConfig, activeUser)
                     ) as SecurityRuleConfig;
+                }
+
+                evaluatedRules.push(evaluatedRule);
 
-                if (parsedRule && parsedRule.filters) {
-                        outerQb.orWhere( // combine each rule-group with OR at the outer level
-                            new Brackets((innerQb) => {
-                               this.crudHelperService.applyFilters(innerQb, parsedRule.filters, securityRuleAlias, qb); // AND within a rule
-                            })
-                        );
-                    }
-                } catch (error) {
-                    this.logger.warn(`Error parsing security rule: ${rule.securityRuleConfig}`, error);
+            } catch (error) {
+                this.logger.warn(`Error parsing security rule: ${rule.securityRuleConfig}`, error);
+            }
+        }
+
+
+        // Apply each security rule to the query builder. The rules are combined with OR logic at the top level.
+        qb.andWhere(new Brackets(async (outerQb) => {
+            for (const evaluatedRule of evaluatedRules) {
+                if (evaluatedRule && evaluatedRule.filters) {
+                    outerQb.orWhere( // combine each rule-group with OR at the outer level
+                        new Brackets((innerQb) => {
+                            this.crudHelperService.applyFilters(innerQb, evaluatedRule.filters, securityRuleAlias, qb); // AND within a rule
+                        })
+                    );
                 }
             }
         }));
@@ -55,7 +75,6 @@ export class SecurityRuleRepository extends Repository<SecurityRule> {
         return qb;
     }
 
-
     private resolveSecurityRuleConfig(configString: string, activeUser: ActiveUserData) {
         return configString.replace('$activeUserId', activeUser.sub.toString());
     }
@@ -85,6 +104,7 @@ export class SecurityRuleRepository extends Repository<SecurityRule> {
             modelMetadataId: populatedSecurityRule.modelMetadata.id,
             modelMetadataUserKey: populatedSecurityRule.modelMetadata.singularName,
             securityRuleConfig: populatedSecurityRule.securityRuleConfig,
+            securityRuleConfigProvider: ""
         };
     }
 

package/src/repository/setting.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { Setting } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class SettingRepository extends SolidBaseRepository<Setting> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(Setting, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/sms-template.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { SmsTemplate } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class SmsTemplateRepository extends SolidBaseRepository<SmsTemplate> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(SmsTemplate, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/solid-base.repository.ts

@@ -22,8 +22,8 @@ export class SolidBaseRepository<T extends CommonEntity> extends Repository<T> {
     constructor(
         entity: EntityTarget<T>,
         dataSource: DataSource,
-        protected readonly requestContextService: RequestContextService,
-        protected readonly securityRuleRepository: SecurityRuleRepository
+        protected readonly requestContextService: RequestContextService | null,
+        protected readonly securityRuleRepository: SecurityRuleRepository | null,
     ) {
         super(entity, dataSource.createEntityManager());
         this.logger = new Logger(this.constructor.name);
@@ -33,12 +33,20 @@ export class SolidBaseRepository<T extends CommonEntity> extends Repository<T> {
         return camelize(this.metadata.name);
     }
 
-    createQueryBuilder(alias?: string, queryRunner?: QueryRunner): SelectQueryBuilder<T> {
-        const activeUserOrUndefined = this.requestContextService.getActiveUser();
+    override createQueryBuilder(alias?: string, queryRunner?: QueryRunner): SelectQueryBuilder<T> {
+        throw new Error('createQueryBuilder() is disabled. Use createSecurityRuleAwareQueryBuilder instead');
+    }
+
+    async createSecurityRuleAwareQueryBuilder(alias?: string, queryRunner?: QueryRunner): Promise<SelectQueryBuilder<T>> {
         const qb = super.createQueryBuilder(alias, queryRunner);
+
+        if (!this.securityRuleRepository) return qb;
+        if (!this.requestContextService) return qb;
+
+        const activeUserOrUndefined = this.requestContextService.getActiveUser();
         if (!activeUserOrUndefined) return qb;
 
-        return this.securityRuleRepository.applySecurityRules(
+        return await this.securityRuleRepository.applySecurityRules(
             qb,
             this.modelSingularName(),
             activeUserOrUndefined as ActiveUserData
@@ -51,7 +59,7 @@ export class SolidBaseRepository<T extends CommonEntity> extends Repository<T> {
     */
     override async findOne(options?: FindOneOptions<T>): Promise<T | null> {
         const alias = this.modelSingularName();
-        const qb = this.createQueryBuilder(alias);
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
 
         if (options) {
             // Apply all standard find options (relations, selects, order, where, etc.)
@@ -85,7 +93,7 @@ export class SolidBaseRepository<T extends CommonEntity> extends Repository<T> {
      */
     override async find(options?: FindManyOptions<T>): Promise<T[]> {
         const alias = this.modelSingularName();
-        const qb = this.createQueryBuilder(alias);
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
 
         if (options) {
             qb.setFindOptions(options);
@@ -100,7 +108,7 @@ export class SolidBaseRepository<T extends CommonEntity> extends Repository<T> {
      */
     override async findAndCount(options?: FindManyOptions<T>): Promise<[T[], number]> {
         const alias = this.modelSingularName();
-        const qb = this.createQueryBuilder(alias);
+        const qb = await this.createSecurityRuleAwareQueryBuilder(alias);
 
         if (options) {
             qb.setFindOptions(options);

package/src/repository/user-activity-history.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { UserActivityHistory } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class UserActivityHistoryRepository extends SolidBaseRepository<UserActivityHistory> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(UserActivityHistory, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/user-view-metadata.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { UserViewMetadata } from 'src';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class UserViewMetadataRepository extends SolidBaseRepository<UserViewMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(UserViewMetadata, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/view-metadata.repository.ts

@@ -1,16 +1,18 @@
-import { Injectable, Logger } from "@nestjs/common";
-import { Dashboard } from "src/entities/dashboard.entity";
+import { Injectable } from "@nestjs/common";
 import { ViewMetadata } from "src/entities/view-metadata.entity";
-import { DataSource, Repository, View } from "typeorm";
+import { RequestContextService } from "src/services/request-context.service";
+import { DataSource } from "typeorm";
+import { SecurityRuleRepository } from "./security-rule.repository";
+import { SolidBaseRepository } from "./solid-base.repository";
 
 @Injectable()
-export class ViewMetadataRepository extends Repository<ViewMetadata> {
-    private readonly logger = new Logger(this.constructor.name);
-
+export class ViewMetadataRepository extends SolidBaseRepository<ViewMetadata> {
     constructor(
-        private dataSource: DataSource,
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
     ) {
-        super(ViewMetadata, dataSource.createEntityManager());
+        super(ViewMetadata, dataSource, requestContextService, securityRuleRepository);
     }
 
     // Custom repository methods can be added here if needed

package/src/seeders/module-metadata-seeder.service.ts

@@ -40,10 +40,14 @@ import { ViewMetadataService } from '../services/view-metadata.service';
 import solidCoreMetadata from './seed-data/solid-core-metadata.json';
 import { SystemFieldsSeederService } from './system-fields-seeder.service';
 // import { CreateScheduledJobDto } from 'src/dtos/create-scheduled-job.dto';
+import { ActionMetadata, MENU_ROLE_JOIN_TABLE_NAME, MENU_ROLE_JOIN_TABLE_NAME_MENU_COL, MENU_ROLE_JOIN_TABLE_NAME_ROLE_COL, MenuItemMetadata, ModuleMetadata, RoleMetadata } from 'src';
 import { ADMIN_ROLE_NAME, INTERNAL_ROLE_NAME, INTERNAL_ROLE_PERMISSIONS, PUBLIC_ROLE_NAME } from 'src/dtos/create-role-metadata.dto';
 import { CreateScheduledJobDto } from 'src/dtos/create-scheduled-job.dto';
 import { ScheduledJobRepository } from 'src/repository/scheduled-job.repository';
-import { ActionMetadata, MENU_ROLE_JOIN_TABLE_NAME, MENU_ROLE_JOIN_TABLE_NAME_MENU_COL, MENU_ROLE_JOIN_TABLE_NAME_ROLE_COL, MenuItemMetadata, ModuleMetadata, RoleMetadata } from 'src';
+import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
+import { SettingRepository } from 'src/repository/setting.repository';
+import { CreateSavedFiltersDto } from 'src/dtos/create-saved-filters.dto';
+import { SavedFiltersRepository } from 'src/repository/saved-filters.repository';
 
 
 @Injectable()
@@ -66,8 +70,9 @@ export class ModuleMetadataSeederService {
         private readonly emailTemplateService: EmailTemplateService,
         private readonly smsTemplateService: SmsTemplateService,
         private readonly listOfValuesService: ListOfValuesService,
-        @InjectRepository(PermissionMetadata)
-        private readonly permissionRepo: Repository<PermissionMetadata>,
+        // @InjectRepository(PermissionMetadata)
+        // private readonly permissionRepo: Repository<PermissionMetadata>,
+        private readonly permissionRepo: PermissionMetadataRepository,
         private readonly solidRegistry: SolidRegistry,
         @Inject(appBuilderConfig.KEY)
         private readonly appBuilderConfiguration: ConfigType<typeof appBuilderConfig>,
@@ -75,12 +80,14 @@ export class ModuleMetadataSeederService {
         @Inject(commonConfig.KEY)
         private readonly commonConfiguration: ConfigType<typeof commonConfig>,
         private readonly settingService: SettingService,
-        @InjectRepository(Setting, 'default')
-        readonly settingsRepo: Repository<Setting>,
+        // @InjectRepository(Setting, 'default')
+        // readonly settingsRepo: Repository<Setting>,
+        private readonly settingsRepo: SettingRepository,
         readonly securityRuleRepo: SecurityRuleRepository,
         readonly systemFieldsSeederService: SystemFieldsSeederService,
         readonly dashboardRepo: DashboardRepository,
         readonly scheduledJobRepository: ScheduledJobRepository,
+        readonly savedFiltersRepo : SavedFiltersRepository,
         readonly dataSource: DataSource,
     ) { }
 
@@ -155,6 +162,10 @@ export class ModuleMetadataSeederService {
             this.logger.log(`Seeding Scheduled Jobs`);
             await this.seedScheduledJobs(moduleMetadata, overallMetadata);
 
+             // Saved Filters
+             this.logger.log(`Seeding Saved Filters`);
+             await this.seedSavedFilters(moduleMetadata, overallMetadata);
+ 
             this.logger.debug(`[End] module seed data: ${overallMetadata}`);
         }
 
@@ -176,6 +187,15 @@ export class ModuleMetadataSeederService {
         this.logger.debug(`[End] Processing scheduled jobs for ${moduleMetadata.name}`);
     }
 
+    private async seedSavedFilters(moduleMetadata: CreateModuleMetadataDto, overallMetadata: any) {
+        this.logger.debug(`[Start] Processing saved filters for ${moduleMetadata.name}`);
+        const savedFilters: CreateSavedFiltersDto[] = overallMetadata.savedFilters;
+        if (savedFilters?.length > 0) {
+            await this.handleSeedSavedFilters(savedFilters);
+        }
+        this.logger.debug(`[End] Processing saved filters for ${moduleMetadata.name}`);
+    }   
+
     private async seedDashboards(moduleMetadata: CreateModuleMetadataDto, overallMetadata: any) {
         this.logger.debug(`[Start] Processing dashboards for ${moduleMetadata.name}`);
         const dashboards: CreateDashboardDto[] = overallMetadata.dashboards;
@@ -709,4 +729,14 @@ export class ModuleMetadataSeederService {
         }
     }
 
+    private async handleSeedSavedFilters(createSavedFilterDto: CreateSavedFiltersDto[]) {
+        if (!createSavedFilterDto || createSavedFilterDto.length === 0) {
+            this.logger.debug(`No saved filters found to seed`);
+            return;
+        }
+        for (const dto of createSavedFilterDto) {
+            await this.savedFiltersRepo.upsertWithDto({ ...dto, filterQueryJson: JSON.stringify(dto.filterQueryJson) });
+        }
+    }
+
 }

package/src/seeders/permission-metadata-seeder.service.ts

@@ -4,14 +4,16 @@ import { Repository } from 'typeorm';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { PermissionMetadata } from '../entities/permission-metadata.entity';
 import { RoleMetadataService } from '../services/role-metadata.service';
+import { PermissionMetadataRepository } from 'src/repository/permission-metadata.repository';
 
 @Injectable()
 export class PermissionMetadataSeederService {
   private readonly logger = new Logger(PermissionMetadataSeederService.name);
 
   constructor(
-    @InjectRepository(PermissionMetadata)
-    private readonly permissionRepo: Repository<PermissionMetadata>,
+    // @InjectRepository(PermissionMetadata)
+    // private readonly permissionRepo: Repository<PermissionMetadata>,
+    private readonly permissionRepo: PermissionMetadataRepository,
     private readonly solidRegistry: SolidRegistry,
     @Inject(forwardRef(() => RoleMetadataService))
     private readonly roleService: RoleMetadataService,