@solidxai/core 0.0.2

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

@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { ModelMetadata } from 'src';
+import { DataSource } from 'typeorm';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class ModelMetadataRepository extends SolidBaseRepository<ModelMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        // readonly requestContextService: RequestContextService,
+        // readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ModelMetadata, dataSource, null, null);
+    }
+}

package/src/repository/model-sequence.repository.ts

@@ -0,0 +1,97 @@
+import { Injectable } from '@nestjs/common';
+import { ModelSequence } from 'src/entities/model-sequence.entity';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+import { CreateModelSequenceDto } from 'src/dtos/create-model-sequence.dto';
+import { ModuleMetadata } from 'src/entities/module-metadata.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+
+@Injectable()
+export class ModelSequenceRepository extends SolidBaseRepository<ModelSequence> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ModelSequence, dataSource, requestContextService, securityRuleRepository);
+    }
+
+    async upsertWithDto(createDto: CreateModelSequenceDto) {
+        // Populate the module from moduleId or moduleUserKey
+        const moduleRepository = this.dataSource.getRepository(ModuleMetadata);
+        if (createDto.moduleId) {
+            const module = await moduleRepository.findOne({
+                where: {
+                    id: createDto.moduleId,
+                },
+            });
+            createDto['module'] = module;
+        }
+
+        if (createDto.moduleUserKey) {
+            const module = await moduleRepository.findOne({
+                where: {
+                    name: createDto.moduleUserKey,
+                },
+            });
+            createDto['module'] = module;
+        }
+
+        // Populate the model from modelId or modelUserKey
+        const modelRepository = this.dataSource.getRepository(ModelMetadata);
+        if (createDto.modelId) {
+            const model = await modelRepository.findOne({
+                where: {
+                    id: createDto.modelId,
+                },
+            });
+            createDto['model'] = model;
+        }
+        if (createDto.modelUserKey) {
+            const model = await modelRepository.findOne({
+                where: {
+                    singularName: createDto.modelUserKey,
+                },
+            });
+            createDto['model'] = model;
+        }
+
+        // Populate the field from fieldId or fieldUserKey
+        const fieldRepository = this.dataSource.getRepository(FieldMetadata);
+        if (createDto.fieldId) {
+            const field = await fieldRepository.findOne({
+                where: {
+                    id: createDto.fieldId,
+                },
+            });
+            createDto['field'] = field;
+        }
+        if (createDto.fieldUserKey) {
+            const field = await fieldRepository.findOne({
+                where: {
+                    name: createDto.fieldUserKey,
+                },
+            });
+            createDto['field'] = field;
+        }
+
+        // First check if sequence already exists using name
+        const existingModelSequence = await this.findOne({
+            where: {
+                sequenceName: createDto.sequenceName,
+            },
+        });
+
+        if (existingModelSequence) {
+            const updatedModelSequence = this.merge(existingModelSequence, createDto);
+            return this.save(updatedModelSequence);
+        }
+        else {
+            const modelSequence = this.create(createDto);
+            return this.save(modelSequence);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleMetadata } from 'src';
+import { DataSource } from 'typeorm';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class ModuleMetadataRepository extends SolidBaseRepository<ModuleMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        // readonly requestContextService: RequestContextService,
+        // readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(ModuleMetadata, dataSource, null, null);
+    }
+}

package/src/repository/mq-message-queue.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { MenuItemMetadata, MqMessageQueue } 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 MqMessageQueueRepository extends SolidBaseRepository<MqMessageQueue> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(MqMessageQueue, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/mq-message.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { MqMessage } 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 MqMessageRepository extends SolidBaseRepository<MqMessage> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(MqMessage, dataSource, requestContextService, securityRuleRepository);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { PermissionMetadata } 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 PermissionMetadataRepository extends SolidBaseRepository<PermissionMetadata> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(PermissionMetadata, dataSource, requestContextService, securityRuleRepository);
+    }
+}

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

@@ -0,0 +1,105 @@
+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 { 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 = {
+//   scheduleName: string;
+//   isActive?: boolean;
+//   frequency: string;
+//   startTime?: Date;
+//   endTime?: Date;
+//   startDate?: Date;
+//   endDate?: Date;
+//   dayOfMonth?: number;
+//   lastRunAt?: Date;
+//   nextRunAt?: Date;
+//   dayOfWeek?: string;
+//   job: string;
+//   moduleUserKey: string;
+// };
+
+@Injectable()
+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.
+   */
+  async toDto(scheduledJob: ScheduledJob): Promise<CreateScheduledJobDto> {
+    let populatedScheduledJob: ScheduledJob = scheduledJob;
+    // If the scheduled job does not have the module relation loaded, load it
+    if (!scheduledJob.module) {
+        populatedScheduledJob = await this.findOne({
+            where: {
+                id: scheduledJob.id,
+            },
+            relations: {
+                module: true,
+            },
+        });
+    }
+
+    if (!populatedScheduledJob.module) {
+        throw new Error(`Module not found for scheduled job ID ${populatedScheduledJob.id}`);
+    }
+
+    return {
+      scheduleName: populatedScheduledJob.scheduleName,
+      isActive: populatedScheduledJob.isActive,
+      frequency: populatedScheduledJob.frequency,
+      startTime: populatedScheduledJob.startTime,
+      endTime: populatedScheduledJob.endTime,
+      startDate: populatedScheduledJob.startDate,
+      endDate: populatedScheduledJob.endDate,
+      dayOfMonth: populatedScheduledJob.dayOfMonth,
+      lastRunAt: populatedScheduledJob.lastRunAt,
+      nextRunAt: populatedScheduledJob.nextRunAt,
+      dayOfWeek: populatedScheduledJob.dayOfWeek,
+      job: populatedScheduledJob.job,
+      moduleUserKey: populatedScheduledJob.module.name,
+      moduleId: populatedScheduledJob.module.id,
+      cronExpression: populatedScheduledJob.cronExpression,
+    };
+  }
+
+  async upsertWithDto(dto: CreateScheduledJobDto): Promise<ScheduledJob> {
+    const moduleRepo = this.dataSource.getRepository(ModuleMetadata);
+
+    const moduleEntity = await moduleRepo.findOne({
+      where: { name: dto.moduleUserKey },
+    });
+
+    if (!moduleEntity) {
+      throw new Error(`Module with userKey ${dto.moduleUserKey} not found`);
+    }
+
+    const jobData = {
+      ...dto,
+      module: moduleEntity,
+    };
+    const existing = await this.findOne({
+      where: { scheduleName: dto.scheduleName },
+    });
+
+    if (existing) {
+      const merged = this.merge(existing, jobData);
+      this.logger.debug(`Updating scheduled job: ${dto.scheduleName}`);
+      return this.save(merged);
+    } else {
+      this.logger.debug(`Creating scheduled job: ${dto.scheduleName}`);
+      return this.save(this.create(jobData));
+    }
+  }
+}

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

@@ -0,0 +1,173 @@
+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';
+import { CommonEntity } from 'src/entities/common.entity';
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+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 } from 'src/services/crud-helper.service';
+import { Brackets, DataSource, SelectQueryBuilder } from 'typeorm';
+import { SolidBaseRepository } from './solid-base.repository';
+
+@Injectable()
+export class SecurityRuleRepository extends SolidBaseRepository<SecurityRule> {
+    constructor(
+        readonly dataSource: DataSource,
+        // readonly requestContextService: RequestContextService,
+        readonly solidRegistry: SolidRegistry,
+        readonly crudHelperService: CrudHelperService,
+    ) {
+        super(SecurityRule, dataSource, null, null);
+    }
+
+    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);
+
+        // If no security rules, return the original query builder
+        if (!securityRules.length) {
+            return qb;
+        }
+
+        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);
+                    if (!securityRuleConfigProviderInstance) {
+                        throw new Error(`Unable to resolve instance for security rule config provider: ${rule.securityRuleConfigProvider}`);
+                    }
+                    evaluatedRule = await securityRuleConfigProviderInstance.securityRuleConfig(activeUser, rule);
+                }
+                else {
+                    evaluatedRule = JSON.parse(
+                        this.resolveSecurityRuleConfig(rule.securityRuleConfig, activeUser)
+                    ) as SecurityRuleConfig;
+                }
+
+                evaluatedRules.push(evaluatedRule);
+
+            } catch (error) {
+                this.logger.error(`Error parsing security rule: ${rule.securityRuleConfig}`, error);
+                this.logger.error(error.stack);
+                throw 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
+                        })
+                    );
+                }
+            }
+        }));
+
+        return qb;
+    }
+
+    private resolveSecurityRuleConfig(configString: string, activeUser: ActiveUserData) {
+        return configString.replace('$activeUserId', activeUser.sub.toString());
+    }
+
+    async toDto(securityRule: SecurityRule): Promise<UpdateSecurityRuleDto> {
+        // load the role and model relations for the security rule
+        let populatedSecurityRule: SecurityRule = securityRule;
+        // If the security rule does not have the role and model relations loaded, load them
+        if (!securityRule.role || !securityRule.modelMetadata) {
+            populatedSecurityRule = await this.findOne({
+                where: {
+                    id: securityRule.id,
+                },
+                relations: {
+                    role: true,
+                    modelMetadata: true,
+                },
+            });
+        }
+
+        return {
+            id: populatedSecurityRule.id,
+            name: populatedSecurityRule.name,
+            description: populatedSecurityRule.description,
+            roleId: populatedSecurityRule.role.id,
+            roleUserKey: populatedSecurityRule.role.name,
+            modelMetadataId: populatedSecurityRule.modelMetadata.id,
+            modelMetadataUserKey: populatedSecurityRule.modelMetadata.singularName,
+            securityRuleConfig: populatedSecurityRule.securityRuleConfig,
+            securityRuleConfigProvider: populatedSecurityRule.securityRuleConfigProvider,
+        };
+    }
+
+    async upsertWithDto(createDto: CreateSecurityRuleDto) {
+        // Populate the role from roleId or roleUserKey
+        const roleRepository = this.dataSource.getRepository(RoleMetadata);
+        if (createDto.roleId) {
+            const role = await roleRepository.findOne({
+                where: {
+                    id: createDto.roleId,
+                },
+            });
+            createDto['role'] = role;
+        }
+
+        if (createDto.roleUserKey) {
+            const role = await roleRepository.findOne({
+                where: {
+                    name: createDto.roleUserKey,
+                },
+            });
+            createDto['role'] = role;
+        }
+
+        // Populate the model from modelMetadataId or modelMetadataUserKey
+        const modelMetadataRepository = this.dataSource.getRepository(ModelMetadata);
+        if (createDto.modelMetadataId) {
+            const modelMetadata = await modelMetadataRepository.findOne({
+                where: {
+                    id: createDto.modelMetadataId,
+                },
+            });
+            createDto['modelMetadata'] = modelMetadata;
+        }
+        if (createDto.modelMetadataUserKey) {
+            const modelMetadata = await modelMetadataRepository.findOne({
+                where: {
+                    singularName: createDto.modelMetadataUserKey,
+                },
+            });
+            createDto['modelMetadata'] = modelMetadata;
+        }
+
+        // First check if module already exists using name
+        const existingSecurityRule = await this.findOne({
+            where: {
+                name: createDto.name,
+            },
+        });
+
+        if (existingSecurityRule) {
+            const updatedSecurityRule = this.merge(existingSecurityRule, createDto);
+            return this.save(updatedSecurityRule);
+        }
+        else {
+            const securityRule = this.create(createDto);
+            return this.save(securityRule);
+        }
+    }
+
+}

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);
+    }
+}