@solidstarters/solid-core 1.2.123 → 1.2.125

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.123",
+  "version": "1.2.125",
   "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/# computed field pending issues.md

@@ -0,0 +1,3 @@
+# computed fields
+1. we want the computation to happen before insert / update.
+2. we want the the provider to do both computation and saving

package/src/decorators/disallow-in-production.decorator.ts

@@ -0,0 +1,28 @@
+export enum Environment {
+  Production = 'prod',
+  Development = 'dev',
+}
+
+export function DisallowInProduction(action?: string) {
+  return function (
+    target: any,
+    propertyKey: string,
+    descriptor: PropertyDescriptor,
+  ) {
+    const originalMethod = descriptor.value;
+
+    descriptor.value = function (...args: any[]) {
+      const currentEnv = process.env.ENV as Environment;
+
+      if (currentEnv === Environment.Production) {
+        const className = target.constructor.name;
+        const methodName = action || propertyKey;
+        throw new Error(`❌ Cannot execute "${className}.${methodName}" in production`);
+      }
+
+      return originalMethod.apply(this, args);
+    };
+
+    return descriptor;
+  };
+}

package/src/dtos/create-field-metadata.dto.ts

@@ -171,6 +171,21 @@ export enum ComputedFieldValueType {
   datetime = 'datetime',
 }
 
+export enum ComputedFieldTriggerOperation {
+    beforeInsert = "before-insert",
+    afterInsert = "after-insert",
+    beforeUpdate = "before-update",
+    afterUpdate = "after-update",
+    beforeRemove = "before-delete",
+    afterRemove = "after-delete",
+}
+
+export interface ComputedFieldTriggerConfig {
+  moduleName: string; // Name of the module where the computed field is defined
+  modelName: string;
+  operations: ComputedFieldTriggerOperation[]; // List of operations where this computed field should be triggered
+}
+
 export class CreateFieldMetadataDto {
   @ApiProperty({ description: 'Name of your field, this is also the name of the column or attribute', })
   // @Matches(/[a-z]+(_[a-z]+)*/, { message: 'Field name should follow snake case conventions only with all lower case.', })
@@ -370,6 +385,9 @@ export class CreateFieldMetadataDto {
   @IsOptional()
   computedFieldValueType: ComputedFieldValueType;
 
+  @IsOptional()
+  computedFieldTriggerConfig: ComputedFieldTriggerConfig[];
+
   @IsOptional()
   @ApiProperty({ description: 'Uuid.', })
   @IsString()

package/src/entities/field-metadata.entity.ts

@@ -2,6 +2,7 @@ import { CommonEntity } from "src/entities/common.entity";
 import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
 import { MediaStorageProviderMetadata } from "./media-storage-provider-metadata.entity";
 import { ModelMetadata } from "./model-metadata.entity";
+import { ComputedFieldTriggerConfig } from "src/dtos/create-field-metadata.dto";
 
 @Entity("ss_field_metadata")
 export class FieldMetadata extends CommonEntity {
@@ -132,6 +133,9 @@ export class FieldMetadata extends CommonEntity {
     @Column({ name: 'computed_field_value_type', nullable: true })
     computedFieldValueType: string;
 
+    @Column({ name: 'computed_field_trigger_config', nullable: true, type: 'jsonb' })
+    computedFieldTriggerConfig: ComputedFieldTriggerConfig[];
+
     @Column({ name: 'uuid', nullable: true })
     uuid: string;
 

package/src/helpers/solid-registry.ts

@@ -1,10 +1,11 @@
 import { Injectable } from '@nestjs/common';
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { ComputedFieldTriggerConfig, ComputedFieldValueType } from 'src/dtos/create-field-metadata.dto';
 import { CommonEntity } from 'src/entities/common.entity';
+import { Locale } from 'src/entities/locale.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { EntityManager } from 'typeorm';
 import { ISelectionProvider, ISelectionProviderContext } from "../interfaces";
-import { Locale } from 'src/entities/locale.entity';
 
 type ControllerMetadata = {
   name: string;
@@ -38,6 +39,18 @@ export enum RESERVED_SOLID_KEYWORDS {
   locale = "locale"
 }
 
+export interface ComputedFieldMetadata<TContext = any> {
+  moduleName: string; // Name of the module where the computed field is defined
+  modelName: string; // Name of the model where the computed field is defined
+  fieldName: string; // Name of the field that is computed
+  computedFieldValueType: ComputedFieldValueType; // Type of the computed field value (e.g., string, number, etc.)
+  computedFieldTriggerConfig: ComputedFieldTriggerConfig[]; // JSON stringified object containing the trigger configuration
+  // Example: '{"models": ["User", "Product"], "operations": ["create", "update"]}'
+  computedFieldValueProviderName: string; // Name of the provider that computes the field value
+  // Example: '{"contextKey": "contextValue"}'
+  computedFieldValueProviderCtxt: TContext; // Context for the computed field value
+}
+
 @Injectable()
 export class SolidRegistry {
   private seeders: Set<InstanceWrapper> = new Set();
@@ -47,7 +60,8 @@ export class SolidRegistry {
   private controllers: Set<ControllerMetadata> = new Set();
   private modules: Set<InstanceWrapper> = new Set();
   private securityRules: SecurityRule[] = [];
-  private locales : Locale[] = [];
+  private locales: Locale[] = [];
+  private computedFieldMetadata: ComputedFieldMetadata[] = [];
 
   registerController(name: string, methodNames: string[]): void {
     this.controllers.add({ name: name, methods: methodNames });
@@ -104,6 +118,14 @@ export class SolidRegistry {
     return Array.from(this.computedFieldProviders);
   }
 
+  getComputedFieldProvider(name: string): InstanceWrapper {
+    const provider = this.getComputedFieldProviders().filter((provider) => provider.name === name).pop();
+    if (!provider) {
+      throw new Error(`Computed Field Provider with name ${name} not found`);
+    }
+    return provider
+  }
+
   getSolidDatabaseModules(): Array<InstanceWrapper> {
     return Array.from(this.solidDatabaseModules);
   }
@@ -121,10 +143,18 @@ export class SolidRegistry {
     this.securityRules = securityRules;
   }
 
-  registerlocales(locales : Locale[]){
+  registerlocales(locales: Locale[]) {
     this.locales = locales;
   }
-  
+
+  registerComputedFieldMetadata(computedFieldMetadata: ComputedFieldMetadata[]) {
+    this.computedFieldMetadata = computedFieldMetadata;
+  }
+
+  getComputedFieldMetadata(): ComputedFieldMetadata[] {
+    return this.computedFieldMetadata;
+  }
+
   //TODO:getlocales from locale model and return default locale where isDefault:true 
   getDefaultLocale(): Locale | null {
     return this.locales.find(locale => locale.isDefault === true) || null;
@@ -141,16 +171,19 @@ 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)[];
+  // 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/interfaces.ts

@@ -12,6 +12,7 @@ import { CreateViewMetadataDto } from './dtos/create-view-metadata.dto';
 import { FieldMetadata } from './entities/field-metadata.entity';
 import { Media } from './entities/media.entity';
 import { Readable } from 'stream';
+import { ComputedFieldMetadata } from './helpers/solid-registry';
 
 export interface FieldCrudManager {
   // fieldMetadata: FieldMetadata;
@@ -80,6 +81,9 @@ export interface ISelectionProvider<T extends ISelectionProviderContext> {
   values(query: any, ctxt: T): Promise<readonly ISelectionProviderValues[]>;
 }
 
+/**
+ * @deprecated Use `IEntityComputedFieldProvider` instead.
+ */
 export interface IComputedFieldProvider<T> {
   help(): string;
 
@@ -90,6 +94,20 @@ export interface IComputedFieldProvider<T> {
   computeValue(dto: any, ctxt: T): Promise<string | number>; // FIXME : Improve the types to make it more specific using generics
 }
 
+export interface IEntityComputedFieldProvider {  
+  help(): string;
+
+  name(): string;
+}
+
+export interface IEntityPreComputeFieldProvider<TTriggerEntity, TContext, TValue> extends IEntityComputedFieldProvider {
+  preComputeValue(entity: TTriggerEntity, computedFieldMetadata: ComputedFieldMetadata<TContext>): Promise<TValue>;
+}
+
+export interface IEntityPostComputeFieldProvider<TTriggerEntity, TContext> extends IEntityComputedFieldProvider {
+  postComputeAndSaveValue(triggerEntity: TTriggerEntity, computedFieldMetadata: ComputedFieldMetadata<TContext>): Promise<void>;
+}
+
 export interface ISolidDatabaseModule {
   name(): string;
 

package/src/jobs/database/computed-field-evaluation-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from "@nestjs/common";
+import { QueuesModuleOptions } from "src/interfaces";
+import { MqMessageQueueService } from "src/services/mq-message-queue.service";
+import { MqMessageService } from "src/services/mq-message.service";
+import { DatabasePublisher } from "src/services/queues/database-publisher.service";
+import { ComputedFieldEvaluationPayload } from "src/subscribers/computed-entity-field.subscriber";
+import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options";
+
+@Injectable()
+export class ComputedFieldEvaluationPublisher extends DatabasePublisher<ComputedFieldEvaluationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...computedFieldEvaluationQueueOptions
+        };
+    }
+}

package/src/jobs/database/computed-field-evaluation-queue-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "../../interfaces";
+
+const QUEUE_NAME = 'computed_field_evaluation_queue';
+
+export default {
+    name: 'computedFieldEvaluationQueue',
+    type: BrokerType.Database,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/database/computed-field-evaluation-subscriber.service.ts

@@ -0,0 +1,36 @@
+import { Injectable } from "@nestjs/common";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { IEntityPostComputeFieldProvider, IEntityComputedFieldProvider, QueuesModuleOptions } from "src/interfaces";
+import { QueueMessage } from "src/interfaces/mq";
+import { MqMessageQueueService } from "src/services/mq-message-queue.service";
+import { MqMessageService } from "src/services/mq-message.service";
+import { DatabaseSubscriber } from "src/services/queues/database-subscriber.service";
+import { ComputedFieldEvaluationPayload } from "src/subscribers/computed-entity-field.subscriber";
+import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options";
+
+@Injectable()
+export class ComputedFieldEvaluationSubscriber extends DatabaseSubscriber<ComputedFieldEvaluationPayload> {
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly solidRegistry: SolidRegistry
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...computedFieldEvaluationQueueOptions
+        }
+    }
+
+    // This method will use the ComputedFieldEvaluationPayload to evaluate the computed fields
+    // It will then call the corresponding provider computeAndSave method to perform the evaluation
+    async subscribe(message: QueueMessage<ComputedFieldEvaluationPayload>) {
+        const { databaseEntity, ...computedFieldMetadata } = message.payload;
+        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 IEntityPostComputeFieldProvider<any, any>; // IEntityComputedFieldProvider
+        await providerInstance.postComputeAndSaveValue(databaseEntity, computedFieldMetadata); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
+    }
+}

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

@@ -0,0 +1,26 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+import { DataSource, Repository } from 'typeorm';
+
+@Injectable()
+export class FieldMetadataRepository extends Repository<FieldMetadata> {
+    private readonly logger = new Logger(FieldMetadataRepository.name);
+    constructor(
+        dataSource: DataSource,
+    ) {
+        super(FieldMetadata, dataSource.createEntityManager());
+    }
+
+    async findComputedFieldsPopulatedWithModelAndModule() {
+        const computedFields = await this.find({
+            where: {
+                type: SolidFieldType.computed,
+            },
+            relations: ['model', 'model.module'],
+        });
+
+        return computedFields;
+    }
+
+}

package/src/repository/field.repository.ts

@@ -1,8 +1,11 @@
-import { Repository, DataSource } from 'typeorm';
 import { Injectable } from '@nestjs/common';
-import { FieldMetadata } from 'src/entities/field-metadata.entity';
 import { InjectRepository } from '@nestjs/typeorm';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+import { DataSource, Repository } from 'typeorm';
 
+/**
+ * @deprecated Use `FieldMetadataRepository` instead.
+ */
 @Injectable()
 export class FieldRepository extends Repository<FieldMetadata> {
     constructor(

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

@@ -844,6 +844,19 @@
             "columnName": "computed_field_value_type",
             "isSystem": true
           },
+          {
+            "name": "computedFieldTriggerConfig",
+            "displayName": "Computed Field Value Trigger Configuration",
+            "type": "json",
+            "ormType": "text",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "columnName": "computed_field_trigger_config",
+            "isSystem": true
+          },
           {
             "name": "uuid",
             "displayName": "UUID",
@@ -2609,7 +2622,7 @@
             "ormType": "integer",
             "isSystem": false,
             "relationType": "many-to-one",
-            "relationCoModelFieldName": "bondTransactionDetailLogs",
+            "relationCoModelFieldName": "savedFilters",
             "relationCreateInverse": false,
             "relationCoModelSingularName": "user",
             "relationCoModelColumnName": null,

package/src/seeders/system-fields-seeder.service.ts

@@ -4,7 +4,7 @@
 import { InjectRepository } from "@nestjs/typeorm";
 import { ModelMetadata } from "src/entities/model-metadata.entity";
 import { ModelMetadataHelperService } from "src/helpers/model-metadata-helper.service";
-import { FieldRepository } from "src/repository/field.repository";
+import { FieldMetadataRepository } from "src/repository/field-metadata.repository";
 import { Repository } from "typeorm";
 
 export class SystemFieldsSeederService {
@@ -15,8 +15,7 @@ export class SystemFieldsSeederService {
       private readonly modelHelperService: ModelMetadataHelperService,
       @InjectRepository(ModelMetadata)
       private readonly modelRepository: Repository<ModelMetadata>, // Replace with actual model repository type
-      @InjectRepository(FieldRepository)
-      private readonly fieldRepository: Repository<FieldRepository>, // Replace with actual field repository type
+      private readonly fieldMetadataRepository: FieldMetadataRepository, // Replace with actual field repository type
    ) {}
   
    async seed() {
@@ -46,7 +45,7 @@ export class SystemFieldsSeederService {
                 ...field,
                 model: model, // Associate the field with the current model
             }));
-            await this.fieldRepository.save(newFields);
+            await this.fieldMetadataRepository.save(newFields);
         }
     }
 }

package/src/services/computed-fields/entity/concat-entity-computed-field-provider.service.ts

@@ -0,0 +1,52 @@
+import { Injectable } from "@nestjs/common";
+import { kebabCase } from "lodash";
+import { ComputedFieldProvider } from "src/decorators/computed-field-provider.decorator";
+import { CommonEntity } from "src/entities/common.entity";
+import { ComputedFieldMetadata } from "src/helpers/solid-registry";
+import { IEntityPreComputeFieldProvider } from "src/interfaces";
+
+
+export interface ConcatComputedFieldContext {
+    separator: string; // The separator to use between concatenated values
+    fields: string[]; // The fields to concatenate
+    slugify?: boolean; // Optional: if true, slugify each field value before concatenation
+}
+
+@ComputedFieldProvider()
+@Injectable()
+export class ConcatEntityComputedFieldProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, ConcatComputedFieldContext, string> {
+
+    name(): string {
+        return "ConcatEntityComputedFieldProvider";
+    }
+
+    help(): string {
+        return "Computed field provider used to create fields whose value is a concatenation of other fields in the same model.";
+    }
+
+    async preComputeValue(entity: T, computedFieldMetadata: ComputedFieldMetadata<ConcatComputedFieldContext>): Promise<string> {
+        const { computedFieldValueProviderCtxt } = computedFieldMetadata;
+        const separator = computedFieldValueProviderCtxt.separator || ' '; // Default to space if no separator is provided
+        const fields = computedFieldValueProviderCtxt.fields || [];
+        const slugify = computedFieldValueProviderCtxt.slugify || false;
+
+        let concatenatedString = '';
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+
+            // if slugify then each field val to be converted to a slug before concatenation
+            let fieldVal = entity[field];
+            if (slugify && typeof fieldVal === 'string') {
+                fieldVal = kebabCase(fieldVal);
+            }
+
+            if (concatenatedString) {
+                concatenatedString += separator;
+            }
+            concatenatedString += fieldVal;
+        }
+
+        return concatenatedString;
+    }
+
+}

package/src/services/crud.service.ts

@@ -403,7 +403,7 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
 
                 //    The value will be computed by the computed provider
                 //    Invoke the appropriate computed provider, get the value and add to the dto
-                const options = { ...commonOptions, computedFieldProvider: fieldMetadata.computedFieldValueProvider, computedFieldValueProviderCtxt: fieldMetadata.computedFieldValueProviderCtxt, computedFieldValueType: fieldMetadata.computedFieldValueType as ComputedFieldValueType, discoveryService: this.discoveryService, skipComputation: isPartialUpdate };
+                const options = { ...commonOptions, computedFieldProvider: fieldMetadata.computedFieldValueProvider, computedFieldValueProviderCtxt: fieldMetadata.computedFieldValueProviderCtxt, computedFieldValueType: fieldMetadata.computedFieldValueType as ComputedFieldValueType, discoveryService: this.discoveryService, skipComputation: this.isSkipComputation(isPartialUpdate, fieldMetadata) };
                 return new ComputedFieldCrudManager(options);
             }
             default:
@@ -411,6 +411,14 @@ export class CRUDService<T> { // Add two generic value i.e Person,CreatePersonDt
         }
     }
 
+    private isSkipComputation(isPartialUpdate: boolean, computedFieldMetadata: FieldMetadata) {
+       if (isPartialUpdate) return true; // If it is a partial update, then skip computation
+       if (computedFieldMetadata.computedFieldTriggerConfig && computedFieldMetadata.computedFieldTriggerConfig.length > 0) {
+           return true; // computedFieldTriggerConfig is a new field introduced as part of the IEntityComputedFieldProvider new interface, so this computation will be skiipped in crud service & will be called in the subscriber instead
+       }
+       return false; // If it is not a partial update, then do not skip computation
+    }
+
     async find(basicFilterDto: BasicFilterDto, solidRequestContext: any = {}) {
         const alias = 'entity';
         // Extract the required keys from the input query

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

@@ -1,25 +1,25 @@
-import { Injectable, Logger, NotFoundException } from '@nestjs/common';
-import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { Injectable, Logger, NotFoundException, OnApplicationBootstrap } 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 { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
-import { SolidRegistry } from 'src/helpers/solid-registry';
+import { ComputedFieldMetadata, SolidRegistry } from 'src/helpers/solid-registry';
+import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { DataSource, Repository, SelectQueryBuilder } from 'typeorm';
 import { BasicFilterDto } from '../dtos/basic-filters.dto';
-import { CascadeType, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, PSQLType, RelationType, SelectionValueType, SolidFieldType } from '../dtos/create-field-metadata.dto';
+import { CascadeType, ComputedFieldTriggerConfig, ComputedFieldTriggerOperation, ComputedFieldValueType, CreateFieldMetadataDto, DecryptWhenType, EncryptionType, MediaType, PSQLType, RelationType, SelectionValueType, SolidFieldType } from '../dtos/create-field-metadata.dto';
 import { SelectionDynamicQueryDto } from '../dtos/selection-dynamic-query.dto';
 import { UpdateFieldMetaDataDto } from '../dtos/update-field-metadata.dto';
 import { FieldMetadata } from '../entities/field-metadata.entity';
 import { ModelMetadata } from '../entities/model-metadata.entity';
 import { ISelectionProviderValues } from '../interfaces';
 import { CrudHelperService } from './crud-helper.service';
-import { classify } from '@angular-devkit/core/src/utils/strings';
 
 
 @Injectable()
-export class FieldMetadataService {
+export class FieldMetadataService implements OnApplicationBootstrap {
     constructor(
-        @InjectRepository(FieldMetadata)
-        private readonly fieldMetadataRepo: Repository<FieldMetadata>,
+        private readonly fieldMetadataRepo: FieldMetadataRepository,
         @InjectDataSource()
         private readonly dataSource: DataSource,
         private readonly solidRegistry: SolidRegistry,
@@ -29,6 +29,36 @@ export class FieldMetadataService {
 
     private logger = new Logger(FieldMetadataService.name);
 
+    onApplicationBootstrap() {
+        this.loadAndRegisterComputedFieldsDetails();
+    }
+
+   async loadAndRegisterComputedFieldsDetails() {
+        // Load all the modules and models and within that load all the computed fields
+        const computedFieldsWithModelAndModule =  await this.fieldMetadataRepo.findComputedFieldsPopulatedWithModelAndModule();
+
+        // Convert the computed fields object above to the ComputedFieldMetadata type
+        const computedFieldMetadata: ComputedFieldMetadata[] = computedFieldsWithModelAndModule.map((field) => {
+            // const defaultComputedFieldTriggerConfig: ComputedFieldTriggerConfig = {
+            //     moduleName: field.model.module.name,
+            //     modelName: field.model.singularName,
+            //     operations: [ComputedFieldTriggerOperation.create, ComputedFieldTriggerOperation.update, ComputedFieldTriggerOperation.delete], // Default operations, can be overridden
+            // }
+            return {
+                moduleName: field.model.module.name,
+                modelName: field.model.singularName,
+                fieldName: field.name,
+                computedFieldValueType: field.computedFieldValueType as ComputedFieldValueType,
+                computedFieldTriggerConfig: field.computedFieldTriggerConfig ?? [], // Ensure it's an array, default to empty if not provided
+                computedFieldValueProviderName: field.computedFieldValueProvider,
+                computedFieldValueProviderCtxt: field.computedFieldValueProviderCtxt ? JSON.parse(field.computedFieldValueProviderCtxt) : {}, // Parse the context if it exists, default to empty object
+            };
+        });
+
+        // Register the computed fields in the SolidRegistry. Capture only computed field related info
+        this.solidRegistry.registerComputedFieldMetadata(computedFieldMetadata);
+    }
+
     async updateInverseField(field: FieldMetadata, fieldRepository: Repository<FieldMetadata>, modelRepository: Repository<ModelMetadata>) {
         if (!field.model || !field.model.module) {
             throw new Error('Model and module are required to update inverse field');

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

@@ -27,6 +27,7 @@ import { RoleMetadataService } from './role-metadata.service';
 import { GenerateCodePublisher } from 'src/jobs/database/generate-code-publisher.service';
 import { PermissionMetadata } from 'src/entities/permission-metadata.entity';
 import { classify, dasherize } from '@angular-devkit/core/src/utils/strings';
+import { DisallowInProduction } from 'src/decorators/disallow-in-production.decorator';
 
 @Injectable()
 export class ModelMetadataService {
@@ -711,6 +712,7 @@ export class ModelMetadataService {
 
   }
 
+  @DisallowInProduction()
   async handleGenerateCode(options: CodeGenerationOptions): Promise<any> {
     // // see if the model record exists. 
     // const model = await this.modelMetadataRepo.findOne({

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

@@ -21,6 +21,7 @@ import { CodeGenerationOptions, ModuleMetadataConfiguration } from '../interface
 import { CrudHelperService } from './crud-helper.service';
 import { ModelMetadataService } from './model-metadata.service';
 import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
+import { DisallowInProduction } from 'src/decorators/disallow-in-production.decorator';
 
 @Injectable()
 export class ModuleMetadataService {
@@ -349,6 +350,7 @@ export class ModuleMetadataService {
     return true
   }
 
+  @DisallowInProduction()
   async generateCode(options: CodeGenerationOptions): Promise<string> {
     if (!options.moduleId && !options.moduleUserKey) {
       throw new BadRequestException('Module ID or Module Name is required for generating code');

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

@@ -57,8 +57,8 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
   defaultEntityLocaleIdFromQuery?: string
 ): Promise<{ records: any[], defaultEntityLocaleId: string | null }> {
   const solidRegistry = await this.moduleRef.get(SolidRegistry, { strict: false });
-  const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
-  const currentEntityRepository = this.entityManager.getRepository(currentEntityTarget);
+  // const currentEntityTarget = solidRegistry.getEntityTarget(this.entityManager, classify(modelName));
+  const currentEntityRepository = this.entityManager.getRepository(classify(modelName));
 
   // Case 1: Creating a new record with no defaultEntityLocaleId to clone
   if (id === 'new' && !defaultEntityLocaleIdFromQuery) {