@solidstarters/solid-core 1.2.128 → 1.2.129

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.128",
+  "version": "1.2.129",
   "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/filters/http-exception.filter.ts

@@ -1,11 +1,16 @@
-import { ExceptionFilter, Catch, ArgumentsHost, Logger } from '@nestjs/common';
+import { ExceptionFilter, Catch, ArgumentsHost, Logger, Injectable } from '@nestjs/common';
 import { Response } from 'express';
 import { HttpStatusCodeMessages } from '../interceptors/logging.interceptor';
 
 @Catch()
+@Injectable()
 export class HttpExceptionFilter implements ExceptionFilter {
     private readonly logger = new Logger(HttpExceptionFilter.name);
 
+    constructor() {
+        this.logger.debug('HttpExceptionFilter initialized');
+    } 
+
     catch(exception: any, host: ArgumentsHost) {
         const ctx = host.switchToHttp();
         const response = ctx.getResponse<Response>();
@@ -19,20 +24,16 @@ export class HttpExceptionFilter implements ExceptionFilter {
         this.logger.error(exception.stack || 'No stack trace available');
 
         // Send the response to the client
-        if (exception.response) {
-            response.status(status).json({
-                ...exception.response,
-                error: message,
-                data: {}
-            });
-        }
-        else {
-            response.status(status).json({
-                statusCode: status,
-                message: [message],
-                error: message,
-                data: {}
-            });
+        const errorJson = this.getErrorJson(status, message, exception.response);
+        response.status(status).json(errorJson);
+    }
+
+    private getErrorJson(status: number|string, message: string, additionalErrorData: unknown = {}): any {
+        return {
+            statusCode: status,
+            message: [message],
+            error: HttpStatusCodeMessages[status] || 'Internal Server Error',
+            data: additionalErrorData
         }
     }
 }

package/src/helpers/schematic.service.ts

@@ -84,7 +84,7 @@ export class SchematicService {
           return !this.solidRegistry.getCommonEntityKeys().includes(field.name);
         })
         .map((field) => {
-          return `--fields='${JSON.stringify(field)}'`;
+          return `--fields='${JSON.stringify(field).replace(/'/g, "\\'")}'`;
         })
         .join(' ');
       const schematicCommand = modelCommand + ' ' + fieldCommand;

package/src/helpers/solid-registry.ts

@@ -191,16 +191,6 @@ export class SolidRegistry {
     });
   }
 
-  /**
-  * @deprecated You can directly pass the entityName to typeORM, if you are using this just for doing operations against a particular entity.
-  */
-  // Returns the entity target class from the entity name
-  // getEntityTarget(entityManager: EntityManager, entityName: string): any { //TODO Can be refactored to use this function from crud helper service
-  //   const entityMetadatas = entityManager.connection.entityMetadatas;
-  //   const entityMetadata = entityMetadatas.find(em => em.name === entityName);
-  //   return entityMetadata.target;
-  // }
-
   getCommonEntityKeys(): (keyof CommonEntity)[] {
     return ['id', 'createdAt', 'updatedAt', 'deletedAt', 'createdBy', 'updatedBy', 'deletedTracker', 'localeName', 'defaultEntityLocaleId', 'publishedAt'];
     // return Reflect.getMetadataKeys(CommonEntity.prototype) as (keyof CommonEntity)[];

package/src/seeders/seed-data/solid-core-metadata.json

@@ -5050,7 +5050,8 @@
           "rowButtons": [
             {
               "attrs": {
-                "className": "pi pi-cog",
+                "className":"p-button-text",
+                "icon": "pi pi-cog",
                 "label": "Generate Code",
                 "action": "GenerateModuleCodeRowAction",
                 "openInPopup": true,
@@ -5217,11 +5218,23 @@
           "truncateAfter": 50,
           "create": true,
           "edit": true,
-          "delete": true,
+          "delete": false,
           "rowButtons": [
             {
               "attrs": {
-                "className": "pi pi-cog",
+                "icon":"pi pi-trash",
+                "className": "p-button-danger p-button-text",
+                "label": "Delete",
+                "action": "DeleteModelRowAction",
+                "customComponentIsSystem": true,
+                "actionInContextMenu": true,
+                "openInPopup": true
+              }
+            },
+            {
+              "attrs": {
+                "icon": "pi pi-cog",
+                "className":"p-button-text",
                 "label": "Generate Code",
                 "action": "GenerateModelCodeRowAction",
                 "customComponentIsSystem": true,

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

@@ -714,29 +714,27 @@ export class ModelMetadataService {
 
   @DisallowInProduction()
   async handleGenerateCode(options: CodeGenerationOptions): Promise<any> {
-    // // see if the model record exists. 
-    // const model = await this.modelMetadataRepo.findOne({
-    //   where: {
-    //     id: options.modelId,
-    //   },
-    // });
-    // if (!model) {
-    //   throw new NotFoundException(`Model record with #${options.modelId} not found`);
-    // }
+    const affectedModelIds = [], refreshModelCodeOutputLines = [], removeFieldCodeOutputLines = [];
 
-    // const m = {
-    //   payload: options,
-    //   parentEntity: model.singularName,
-    //   parentEntityId: options.modelId,
-    // };
+    // Generate the code for the passed model
+    const { model, removeFieldCodeOuput, refreshModelCodeOutput } = await this.generateCode(options);
+    affectedModelIds.push(model.id);
+    refreshModelCodeOutputLines.push(refreshModelCodeOutput);
+    removeFieldCodeOutputLines.push(removeFieldCodeOuput);
 
-    // const messageId = await this.generateCodePublihser.publish(m);
+    // Generate the code for models which are linked to fields having an inverse relation
+    await this.generateCodeForInverseModels(model, options, affectedModelIds, refreshModelCodeOutputLines, removeFieldCodeOutputLines);
 
-    // return { messageId: messageId };
+    // Generate the VAM config for all the affected models
+    for (const modelId of affectedModelIds) {
+      await this.generateVAMConfig(modelId);
+    }
 
-    const { model, removeFieldCodeOuput, refreshModelCodeOutput } = await this.generateCode(options);
+    // Return the aggregated code output
+    return `${removeFieldCodeOutputLines.join('\n')} \n ${refreshModelCodeOutputLines.join('\n')}`;
+  }
 
-    // Generate the code for models which are linked to fields having an inverse relation
+  private async generateCodeForInverseModels(model: ModelMetadata, options: CodeGenerationOptions, affectedModelIds: any[], refreshModelCodeOutputLines: any[], removeFieldCodeOutputLines: any[]) {
     const coModelSingularNames = model.fields.
       filter(field => field.type === SolidFieldType.relation && field.relationCreateInverse === true)
       .map(field => field.relationCoModelSingularName);
@@ -747,11 +745,11 @@ export class ModelMetadataService {
         modelId: coModel.id,
         dryRun: options.dryRun
       };
-      await this.generateCode(inverseOptions);
+      const { removeFieldCodeOuput, refreshModelCodeOutput } = await this.generateCode(inverseOptions);
+      affectedModelIds.push(coModel.id);
+      refreshModelCodeOutputLines.push(refreshModelCodeOutput);
+      removeFieldCodeOutputLines.push(removeFieldCodeOuput);
     }
-    await this.generateVAMConfig(model.id);
-
-    return `${removeFieldCodeOuput} \n ${refreshModelCodeOutput}`;
   }
 
   // Generate the View, Action and Menu configuration for the model
@@ -801,7 +799,7 @@ export class ModelMetadataService {
   }
 
   // Populate the View, Actions and Menus in the config file
-  private populateVAMConfigInFileInternal(formViewLayoutFields: any[], model: ModelMetadata, listViewLayoutFields: { type: string; attrs: { name: string;  }; }[], metaData: any) {
+  private populateVAMConfigInFileInternal(formViewLayoutFields: any[], model: ModelMetadata, listViewLayoutFields: { type: string; attrs: { name: string; }; }[], metaData: any) {
     const column1Fields = [];
     const column2Fields = [];
 

package/src/solid-core.module.ts

@@ -1,6 +1,7 @@
 import { Global, Module } from '@nestjs/common';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import {
+  APP_FILTER,
   APP_GUARD,
   APP_INTERCEPTOR,
   DiscoveryService,
@@ -212,6 +213,7 @@ import { ComputedEntityFieldSubscriber } from './subscribers/computed-entity-fie
 import { CreatedByUpdatedBySubscriber } from './subscribers/created-by-updated-by.subscriber';
 import { SecurityRuleSubscriber } from './subscribers/security-rule.subscriber';
 import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
+import { HttpExceptionFilter } from './filters/http-exception.filter';
 
 
 @Global()
@@ -326,6 +328,10 @@ import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
       provide: APP_GUARD,
       useClass: PermissionsGuard,
     },
+    {
+      provide: APP_FILTER,
+      useClass: HttpExceptionFilter
+    },
     ModuleMetadataService,
     ModuleMetadataHelperService,
     ModelMetadataService,

package/src/subscribers/computed-entity-field.subscriber.ts

@@ -1,5 +1,5 @@
 import { camelize } from "@angular-devkit/core/src/utils/strings";
-import { Injectable } from "@nestjs/common";
+import { Injectable, InternalServerErrorException, Logger } from "@nestjs/common";
 import { InjectDataSource } from "@nestjs/typeorm";
 import { ComputedFieldTriggerOperation } from "src/dtos/create-field-metadata.dto";
 import { ComputedFieldMetadata, SolidRegistry } from "src/helpers/solid-registry";
@@ -15,6 +15,7 @@ export interface ComputedFieldEvaluationPayload extends ComputedFieldMetadata {
 @Injectable()
 @EventSubscriber()
 export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface {
+    private readonly logger = new Logger(this.constructor.name);
     constructor(
         @InjectDataSource()
         private readonly dataSource: DataSource,
@@ -28,61 +29,80 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         await this.handleComputedFieldEvaluation(event.entity, ComputedFieldTriggerOperation.beforeInsert);
     }
 
-    async beforeUpdate(event: UpdateEvent<any>): Promise<any>{
+    async beforeUpdate(event: UpdateEvent<any>): Promise<any> {
         await this.handleComputedFieldEvaluation(event.databaseEntity, ComputedFieldTriggerOperation.beforeUpdate);
     }
 
-    async afterInsert(event: InsertEvent<any>) {
-        await this.handleComputedFieldEvaluationJob(event.entity, ComputedFieldTriggerOperation.afterInsert);
+    afterInsert(event: InsertEvent<any>) {
+        this.handleComputedFieldEvaluationJob(event.entity, ComputedFieldTriggerOperation.afterInsert);
     }
 
-    async afterUpdate(event: UpdateEvent<any>) {
-        await this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterUpdate);
+    afterUpdate(event: UpdateEvent<any>) {
+        this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterUpdate);
     }
 
-    async afterRemove(event: any) {
-        await this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterRemove);
+    afterRemove(event: any) {
+        this.handleComputedFieldEvaluationJob(event.databaseEntity, ComputedFieldTriggerOperation.afterRemove);
     }
 
-    //FIXME: Need to add support for beforeRemmove, beforeSoftRemove, afterSoftRemove, beforeRecover, afterRecover
+    //FIXME: Need to add support for beforeRemove, beforeSoftRemove, afterSoftRemove, beforeRecover, afterRecover
 
     private async handleComputedFieldEvaluation(entity: any, currentOperation: ComputedFieldTriggerOperation): Promise<void> {
         if (!entity) {
             return;
         }
-        const currentModelName = camelize(entity.constructor.name); // Resolve the model name from the entity class name
-        const computedFieldsTobeEvaluated = this.getComputedFieldsToBeEvaluated(
+        const computedFieldsTobeEvaluated = this.getComputedFieldsForEvaluation(
             this.solidRegistry.getComputedFieldMetadata(),
             currentOperation,
-            currentModelName
+            camelize(entity.constructor.name)
         );
-        for (const computedFieldMetadata of computedFieldsTobeEvaluated) {
-            const computedValue = await this.getComputedValue(computedFieldMetadata, entity); //FIXME: There should some way to check/assert if the provider actually has a postComputeAndSaveValue
-            entity[computedFieldMetadata.fieldName] = computedValue; // Set the computed value on the entity
-        }
+        //TODO: We can add a feature i.e dependsOn, where we can check if the computed field depends on other computed fields and evaluate them first
+        await Promise.all(
+            computedFieldsTobeEvaluated.map(c => this.evaluateComputedField(c, entity))
+        )
     }
 
-    private async handleComputedFieldEvaluationJob(entity: any, currentOperation: ComputedFieldTriggerOperation): Promise<void> {
+    private handleComputedFieldEvaluationJob(entity: any, currentOperation: ComputedFieldTriggerOperation) {
         if (!entity) {
             return;
         }
-        const currentModelName = camelize(entity.constructor.name); //Resolve the model name from the entity class name
-        const computedFieldsTobeEvaluated = this.getComputedFieldsToBeEvaluated(
+        const computedFieldsTobeEvaluated = this.getComputedFieldsForEvaluation(
             this.solidRegistry.getComputedFieldMetadata(),
             currentOperation,
-            currentModelName
+            camelize(entity.constructor.name)
         );
+        //TODO: We can add a feature i.e dependsOn, where we can check if the computed field depends on other computed fields and evaluate them first
         for (const computedField of computedFieldsTobeEvaluated) {
             this.enqueueComputedFieldEvaluationJob(computedField, entity);
         }
     }
 
+    // Based on the current model name and current operation, identify all the computed providers that need to be evaluated
+    // Pass the database entity and the context to the provider of type IEntityComputedFieldProvider
+    private getComputedFieldsForEvaluation(computedFieldMetadata: ComputedFieldMetadata[] = [], currentOperation: ComputedFieldTriggerOperation, currentModelName: string) {
+        return computedFieldMetadata.filter(
+            (computedField) => computedField.computedFieldTriggerConfig.some(
+                (trigger) => trigger.operations.includes(currentOperation) &&
+                    trigger.modelName === currentModelName
+            )
+        );
+    }
+
+    private async evaluateComputedField(computedFieldMetadata: ComputedFieldMetadata<any>, entity: any) {
+        const computedValue = await this.getComputedValue(computedFieldMetadata, entity);
+        entity[computedFieldMetadata.fieldName] = computedValue; // Set the computed value on the entity
+    }
+
     private async getComputedValue(computedFieldMetadata: ComputedFieldMetadata<any>, entity: any) {
-        const provider = this.solidRegistry.getComputedFieldProvider(computedFieldMetadata.computedFieldValueProviderName);
-        // Get the instance of the provider and assert it is of type IEntityComputedFieldProvider
-        const providerInstance = provider.instance as IEntityPreComputeFieldProvider<any, any, any>; // IEntityComputedFieldProvider
-        const computedValue = await providerInstance.preComputeValue(entity, computedFieldMetadata); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
-        return computedValue;
+        try {
+            const provider = this.solidRegistry.getComputedFieldProvider(computedFieldMetadata.computedFieldValueProviderName);
+            // Get the instance of the provider and assert it is of type IEntityComputedFieldProvider
+            const providerInstance = provider.instance as IEntityPreComputeFieldProvider<any, any, any>; // IEntityComputedFieldProvider
+            const computedValue = await providerInstance.preComputeValue(entity, computedFieldMetadata); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
+            return computedValue;
+        } catch (error) {
+            throw new InternalServerErrorException(`Error evaluating computed field ${computedFieldMetadata.fieldName} for model ${computedFieldMetadata.modelName} for triggered entity ${entity.constructor.name}: ${error.message}`);
+        }
     }
 
     private enqueueComputedFieldEvaluationJob(computedField: ComputedFieldMetadata<any>, databaseEntity: any) {
@@ -95,14 +115,4 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         });
     }
 
-    // Based on the current model name and current operation, identify all the computed providers that need to be evaluated
-    // Pass the database entity and the context to the provider of type IEntityComputedFieldProvider
-    private getComputedFieldsToBeEvaluated(computedFieldMetadata: ComputedFieldMetadata[], currentOperation: ComputedFieldTriggerOperation, currentModelName: string) {
-        return computedFieldMetadata.filter(
-            (computedField) => computedField.computedFieldTriggerConfig.some(
-                (trigger) => trigger.operations.includes(currentOperation) &&
-                    trigger.modelName === currentModelName
-            )
-        );
-    }
 }