@solidstarters/solid-core 1.2.48 → 1.2.49

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

@@ -739,6 +739,7 @@ export class FieldMetadataService {
                     "relationCoModelSingularName",
                     "relationCoModelColumnName",
                     "relationModelModuleName",
+                    "relationCascade",
                     "required",
                     "unique",
                     "index",

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

@@ -150,6 +150,7 @@ export class ModuleMetadataService {
         emailTemplates: [],
         smsTemplates: [],
         mediaStorageProviders: [],
+        securityRules: [],
       };
 
       // Convert the object to JSON string

package/src/services/request-context.service.ts

@@ -0,0 +1,16 @@
+import { Inject, Injectable, Scope } from "@nestjs/common";
+import { REQUEST } from "@nestjs/core";
+import { REQUEST_USER_KEY } from "src/constants";
+import { ActiveUserData } from "src/interfaces/active-user-data.interface";
+
+@Injectable({scope: Scope.REQUEST})
+export class RequestContextService {
+    constructor(@Inject(REQUEST) private readonly request: Request) {
+    }
+
+    // This method i.e getActiveUser() will fetch the user from the request object in the context
+    getActiveUser() {
+        return this.request[REQUEST_USER_KEY] as ActiveUserData| undefined;
+    }
+
+}

package/src/services/security-rule.service.ts

@@ -0,0 +1,54 @@
+import { Injectable, OnApplicationBootstrap } from '@nestjs/common';
+import { InjectEntityManager, InjectRepository } from '@nestjs/typeorm';
+import { DiscoveryService, ModuleRef } from "@nestjs/core";
+import { EntityManager, Repository } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { ModuleMetadataService } from 'src/services/module-metadata.service';
+import { ConfigService } from '@nestjs/config';
+import { FileService } from 'src/services/file.service';
+import { CrudHelperService } from 'src/services/crud-helper.service';
+
+
+import { SecurityRule } from '../entities/security-rule.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+
+@Injectable()
+export class SecurityRuleService extends CRUDService<SecurityRule> implements OnApplicationBootstrap {
+  constructor(
+    readonly modelMetadataService: ModelMetadataService,
+    readonly moduleMetadataService: ModuleMetadataService,
+    readonly configService: ConfigService,
+    readonly fileService: FileService,
+    readonly discoveryService: DiscoveryService,
+    readonly crudHelperService: CrudHelperService,
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    @InjectRepository(SecurityRule, 'default')
+    readonly repo: Repository<SecurityRule>,
+    readonly moduleRef: ModuleRef,
+    readonly solidRegistry: SolidRegistry,
+
+  ) {
+    super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'securityRule', 'solid-core', moduleRef);
+  }
+
+  onApplicationBootstrap() {
+    // Load the security rules from the database
+    this.loadSecurityRules();
+  }
+
+  async loadSecurityRules() {
+    const securityRules = await this.repo.find(
+      {
+        relations: {
+          modelMetadata: true,
+          role: true,
+        }
+      }
+    );
+    this.solidRegistry.registerSecurityRules(securityRules);
+  }
+
+}

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

@@ -108,13 +108,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     }
 
     // We also need to fetch a map of fields.
-    const fields = await this.fieldMetadataRepo.find({
-      where: {
-        model: {
-          singularName: modelName,
-        }
-      }
-    });
+    const fields = await this.loadFieldHierarchy(modelName);
     const fieldsMap = new Map<string, FieldMetadata>();
     for (let i = 0; i < fields.length; i++) {
       const field = fields[i];
@@ -179,6 +173,31 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
     return r;
   }
 
+  private async loadFieldHierarchy(modelName: any) {
+    const model = await this.modelMetadataRepo.findOne({
+      where: {
+        singularName: modelName,
+      },
+      relations: {
+        fields: true,
+        parentModel: {
+          fields: true,
+        }
+      }
+    });
+    const fields = [];
+    if (model) {
+      // Add the fields of the current model
+      fields.push(...model.fields);
+
+      // Add the fields of the parent model
+      if (model.parentModel) {
+        fields.push(...model.parentModel.fields);
+      }
+    }
+    return fields;        
+  }
+
   async findOneByUserKey(name: string, relations = {}) {
     const entity = await this.repo.findOne({
       where: {

package/src/solid-core.module.ts

@@ -144,6 +144,12 @@ import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
 import { UserViewMetadata } from './entities/user-view-metadata.entity';
 import { UserViewMetadataService } from './services/user-view-metadata.service';
 import { UserViewMetadataController } from './controllers/user-view-metadata.controller';
+import { SecurityRule } from './entities/security-rule.entity';
+import { SecurityRuleService } from './services/security-rule.service';
+import { SecurityRuleController } from './controllers/security-rule.controller';
+import { RequestContextService } from './services/request-context.service';
+import { SecurityRuleRepository } from './repository/security-rule.repository';
+import { SecurityRuleSubscriber } from './subscribers/security-rule.subscriber';
 
 
 @Global()
@@ -189,6 +195,7 @@ import { UserViewMetadataController } from './controllers/user-view-metadata.con
     ConfigModule,
     TypeOrmModule.forFeature([Setting]),
     TypeOrmModule.forFeature([UserViewMetadata]),
+    TypeOrmModule.forFeature([SecurityRule]),
     // TypeOrmModule.forFeature([User]),
   ],
   controllers: [
@@ -215,6 +222,7 @@ import { UserViewMetadataController } from './controllers/user-view-metadata.con
     UserController,
     SettingController,
     UserViewMetadataController,
+    SecurityRuleController,
   ],
   providers: [
     {
@@ -309,7 +317,11 @@ import { UserViewMetadataController } from './controllers/user-view-metadata.con
     FileS3StorageProvider,
     MediaRepository,
     ViewMetadataSubsciber,
-    UserViewMetadataService
+    UserViewMetadataService,
+    SecurityRuleService,
+    SecurityRuleRepository,
+    SecurityRuleSubscriber,
+    RequestContextService,
   ],
   exports: [
     ModuleMetadataService,
@@ -337,6 +349,8 @@ import { UserViewMetadataController } from './controllers/user-view-metadata.con
     MqMessageService,
     RefreshModelCommand,
     RefreshModuleCommand,
+    RequestContextService,
+    SecurityRuleRepository,
   ],
 })
 export class SolidCoreModule { }

package/src/subscribers/security-rule.subscriber.ts

@@ -0,0 +1,78 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectDataSource } from "@nestjs/typeorm";
+import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
+import { ModelMetadata } from 'src/entities/model-metadata.entity';
+import { SecurityRule } from 'src/entities/security-rule.entity';
+import { ModuleMetadataHelperService } from "src/helpers/module-metadata-helper.service";
+import { SecurityRuleRepository } from 'src/repository/security-rule.repository';
+import { DataSource, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
+
+@Injectable()
+export class SecurityRuleSubscriber implements EntitySubscriberInterface<SecurityRule> {
+    private readonly logger = new Logger(SecurityRuleSubscriber.name);
+    constructor(
+        @InjectDataSource()
+        private readonly dataSource: DataSource,
+        readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+        readonly securityRuleRepo: SecurityRuleRepository,
+    ) {
+        this.dataSource.subscribers.push(this);
+    }
+
+    listenTo() {
+        return SecurityRule;
+    }
+
+    async afterInsert(event: InsertEvent<SecurityRule>) {
+        await this.saveSecurityRules(event);
+    }
+    
+    async afterUpdate(event: UpdateEvent<SecurityRule>) {
+        await this.saveSecurityRules(event);
+    }
+
+    async saveSecurityRules(event: UpdateEvent<SecurityRule>| InsertEvent<SecurityRule>) {
+        const securityRule = event.entity as SecurityRule;
+        const modelMetadata = event.entity.modelMetadata;
+        if (!modelMetadata) {
+            this.logger.error(`Model metadata not found for security rule with id ${event.entity.id}`);
+            return;
+        }
+        
+        const modelMetadataRepo = this.dataSource.getRepository(ModelMetadata);
+        const populatedModelMetadata = await modelMetadataRepo.findOne({
+            where: {
+                id: modelMetadata.id
+            },
+            relations: {
+                module: true,
+            }
+        });
+
+        const filePath = this.moduleMetadataHelperService.getModuleMetadataFilePath(populatedModelMetadata.module.name);
+        try {
+            await fs.access(filePath);
+        } catch (error) {
+            // FIXME - Should we actually delete the security rule here, if the file is not found?
+            this.logger.error(`File not found at path: ${filePath}`);
+            return;
+        }
+        const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
+
+        if (metaData.securityRule) {
+            const securityRuleIndex = metaData.securityRules?.findIndex((ruleFromFile: { name: string }) => ruleFromFile.name === securityRule.name);
+            const {id, roleId, modelMetadataId, ...requiredDto} = await this.securityRuleRepo.toDto(securityRule)
+            metaData.securityRules[securityRuleIndex] = {requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig)}
+        }
+        else {
+            const securityRules = []
+            const {id, roleId, modelMetadataId, ...requiredDto} = await this.securityRuleRepo.toDto(securityRule)
+            securityRules.push({...requiredDto, securityRuleConfig: JSON.parse(securityRule.securityRuleConfig)})
+            metaData.securityRules = securityRules
+        }
+        // Write the updated object back to the file
+        const updatedContent = JSON.stringify(metaData, null, 2);
+        await fs.writeFile(filePath, updatedContent);
+    }
+
+}