@solidstarters/solid-core 1.2.193 → 1.2.201

package/src/helpers/model-metadata-helper.service.ts

@@ -1,6 +1,8 @@
 // Return the system fields metadata for a model
 
-import { Injectable, Logger } from "@nestjs/common";
+import { forwardRef, Inject, Injectable, Logger } from "@nestjs/common";
+import { _ } from "lodash";
+import { LEGACY_TABLE_FIELDS_PREFIX } from "src/entities/legacy-common.entity";
 import { ModelMetadataRepository } from "src/repository/model-metadata.repository";
 import { SolidRegistry } from "./solid-registry";
 
@@ -8,104 +10,135 @@ import { SolidRegistry } from "./solid-registry";
 export class ModelMetadataHelperService {
     private readonly logger = new Logger(ModelMetadataHelperService.name);
 
-    constructor(private readonly registry: SolidRegistry,
+    constructor(
+        private readonly registry: SolidRegistry,
         // @InjectRepository(ModelMetadata)
         // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+        @Inject(forwardRef(() => ModelMetadataRepository))
         private readonly modelMetadataRepo: ModelMetadataRepository,
     ) {
     }
 
-    getSystemFieldsMetadata(): any[] {
-        const systemFieldsMetadata = [
+    getSystemFieldsMetadata(isLegacyTable: boolean=false, isLegacyTableWithId: boolean=false): any[] {
+        let systemFieldsMetadata: any[];
+        if (isLegacyTableWithId) {
+            systemFieldsMetadata = this.getSystemFieldsMetadataMappingForLegacyTable(true);
+        }
+        else if (isLegacyTable) {
+            systemFieldsMetadata = this.getSystemFieldsMetadataMappingForLegacyTable(false);
+        }
+        else {
+            systemFieldsMetadata = this.getSystemFieldsMetadataMapping();
+        }
+
+        this.checkWithRegistry(systemFieldsMetadata);
+
+        return systemFieldsMetadata;
+    }
+
+    // TODO: Do an additional check and add a warning if the common entity keys and system field metadata keys don't match exactly
+    // Ideally this should be reflection based code
+    private checkWithRegistry(systemFieldsMetadata: ({ name: string; displayName: string; type: string; ormType: string; isSystem: boolean; relationType?: undefined; relationCoModelSingularName?: undefined; relationCreateInverse?: undefined; relationCascade?: undefined; relationModelModuleName?: undefined; } | { name: string; displayName: string; type: string; isSystem: boolean; ormType?: undefined; relationType?: undefined; relationCoModelSingularName?: undefined; relationCreateInverse?: undefined; relationCascade?: undefined; relationModelModuleName?: undefined; } | { name: string; displayName: string; type: string; ormType: string; isSystem: boolean; relationType: string; relationCoModelSingularName: string; relationCreateInverse: boolean; relationCascade: string; relationModelModuleName: string; })[]) {
+        const commonEntityKeys = this.registry.getCommonEntityKeys();
+        const systemFieldNames = systemFieldsMetadata.map(field => field.name);
+        const missingKeys = commonEntityKeys.filter(key => !systemFieldNames.includes(key));
+        if (missingKeys.length > 0) {
+            this.logger.warn(`Missing system fields metadata for common entity keys: ${missingKeys.join(', ')}`);
+        }
+    }
+
+    private getSystemFieldsMetadataMapping() {
+        return [
             {
                 name: "id",
                 displayName: "Id",
                 type: "int",
-                ormType: "bigint",
                 isSystem: true,
             },
             {
                 name: "createdAt",
                 displayName: "Created At",
                 type: "datetime",
-                ormType: "timestamp",
                 isSystem: true,
             },
             {
                 name: "updatedAt",
                 displayName: "Updated At",
                 type: "datetime",
-                ormType: "timestamp",
                 isSystem: true,
             },
             {
                 name: "deletedAt",
                 displayName: "Deleted At",
                 type: "datetime",
-                ormType: "timestamp",
                 isSystem: true,
             },
             {
                 name: "deletedTracker",
                 displayName: "Deleted Tracker",
                 type: "shortText",
-                ormType: "varchar",
                 isSystem: true,
             },
             {
                 name: "publishedAt",
                 displayName: "Published At",
                 type: "datetime",
-                ormType: "timestamp",
                 isSystem: true,
+                enableAuditTracking:true
             },
             {
                 name: "localeName",
                 displayName: "Locale",
                 type: "shortText",
-                ormType: "varchar",
                 isSystem: true,
             },
             {
                 name: "defaultEntityLocaleId",
                 displayName: "Default Entity Locale Id",
                 type: "int",
-                ormType: "integer",
                 isSystem: true,
             },
             {
                 name: "createdBy",
                 displayName: "Created By",
-                type: "relation",
-                ormType: "integer",
+                type: "int",
                 isSystem: true,
-                relationType: "many-to-one",
-                relationCoModelSingularName: "user",
-                relationCreateInverse: false,
-                relationCascade: "restrict",
-                relationModelModuleName: "solid-core"
+                columnName: "created_by_id",
             },
             {
                 name: "updatedBy",
                 displayName: "Updated By",
-                type: "relation",
-                ormType: "integer",
+                type: "int",
                 isSystem: true,
-                relationType: "many-to-one",
-                relationCoModelSingularName: "user",
-                relationCreateInverse: false,
-                relationCascade: "restrict",
-                relationModelModuleName: "solid-core"
-            },
-        ]
+                columnName: "updated_by_id",
+            }
+        ];
+    }
 
-        // Do an additional check and add a warning if the common entity keys and system field metadata keys don't match exactly
-        const commonEntityKeys = this.registry.getCommonEntityKeys();
-        const systemFieldNames = systemFieldsMetadata.map(field => field.name);
-        const missingKeys = commonEntityKeys.filter(key => !systemFieldNames.includes(key));
-        if (missingKeys.length > 0) {
-            this.logger.warn(`Missing system fields metadata for common entity keys: ${missingKeys.join(', ')}`);
+    private getSystemFieldsMetadataMappingForLegacyTable(withId: boolean=true) {
+        const systemFieldsMetadata = this.getSystemFieldsMetadataMapping();
+        if (!withId) {
+            // Remove the id field metadata
+            const index = systemFieldsMetadata.findIndex(field => field.name === 'id');
+            if (index !== -1) {
+                systemFieldsMetadata.splice(index, 1);
+            }
         }
+
+        // For legacy table, system fields, remove the ormType atribute from the metadata
+        // systemFieldsMetadata.forEach(field => {
+        //     delete field.ormType;
+        // });
+
+        // Except for createdBy and updatedBy fields, for which we need to keep the columnName as created_by_id and updated_by_id respectively,
+        // we need to add a columnName attribute with legacy prefix concatenated with the kebab cased field name of the system field
+        systemFieldsMetadata.forEach(field => {
+            if (field.name === 'createdBy' || field.name === 'updatedBy') {
+                field['columnName'] = `${LEGACY_TABLE_FIELDS_PREFIX}_${_.snakeCase(field.name)}_id`;
+            } else {
+                field['columnName'] = `${LEGACY_TABLE_FIELDS_PREFIX}_${_.snakeCase(field.name)}`;
+            }
+        });
         return systemFieldsMetadata;
     }
 

package/src/helpers/module-metadata-helper.service.ts

@@ -57,4 +57,21 @@ export class ModuleMetadataHelperService {
         }
         return filePath;
     }
-}
+    async getModuleMetadataFolderPath(moduleName: string): Promise<string> {
+        if (!moduleName) {
+            return '';
+        }
+
+        const dashModuleName = dasherize(moduleName);
+
+        const folderPath = path.resolve(
+            process.cwd(),
+            'module-metadata',
+            dashModuleName,
+        );
+
+        const exists = await this.fileService.pathExists(folderPath);
+        return exists ? folderPath : '';
+    }
+
+}

package/src/helpers/module.helper.ts

@@ -1,6 +1,8 @@
+import { Logger } from '@nestjs/common';
 import * as fs from 'fs'; // Use the Promise-based version of fs for async/await
 import * as path from 'path'; // To handle file paths
 
+const logger = new Logger('module.helper');
 
 export const getDynamicModuleNames = (): string[] => {
   const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
@@ -21,6 +23,7 @@ export const getDynamicModuleNames = (): string[] => {
 
       if (!isValidDirectory) return false;
 
+      // return true
       const fullPath = path.join(srcPath, dirent.name);
       const files = fs.readdirSync(fullPath);
       // skip if empty directory
@@ -28,7 +31,40 @@ export const getDynamicModuleNames = (): string[] => {
     })
     .map(dirent => dirent.name);
 
-  console.log(`Enabled dynamic modules:`, enabledModules);
+  // logger.debug(`Enabled dynamic modules:`, enabledModules);
+  return enabledModules;
+}
+
+export const getDynamicModuleNamesBasedOnMetadata = (): string[] => {
+  const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
+
+  // Find a path that is ../${srcPath}/module-metadata save it in a variable.
+  // const srcPath = path.join(process.cwd(), 'src');
+  const moduleMetadataPath = path.join(process.cwd(), 'module-metadata');
+  const coreModuleNames = getCoreModuleNames();
+  const allExcludedModules = [...new Set([...coreModuleNames, ...dynamicModulesToExclude])];
+
+  // if module-metadata path does not exist, return empty array
+  if (!fs.existsSync(moduleMetadataPath)) {
+    logger.warn(`Module metadata path does not exist: ${moduleMetadataPath}`);
+    return [];
+  }
+
+  const moduleMetadataDirectories = fs.readdirSync(moduleMetadataPath, { withFileTypes: true });
+  const enabledModules = moduleMetadataDirectories
+    .filter(dirent => {
+      const isValidDirectory = dirent.isDirectory() && !allExcludedModules.includes(dirent.name);
+
+      if (!isValidDirectory) return false;
+
+      const fullPath = path.join(moduleMetadataPath, dirent.name, `${dirent.name}-metadata.json`);
+
+      const stats = fs.statSync(fullPath, { throwIfNoEntry: false });
+      return !!stats && stats.isFile();
+    })
+    .map(dirent => dirent.name);
+
+  // logger.debug(`Enabled dynamic modules basis src:`, enabledModules);
   return enabledModules;
 }
 

package/src/helpers/schematic.service.ts

@@ -1,24 +1,29 @@
 import { Injectable, Logger } from '@nestjs/common';
-import { CommandService } from './command.service';
 import { snakeCase } from "lodash";
-import { CommonEntity } from 'src/entities/common.entity';
+import { FieldMetadata } from 'src/entities/field-metadata.entity';
+import { CommandService } from './command.service';
 import { SolidRegistry } from './solid-registry';
 
 export const ADD_MODULE_COMMAND = 'add-module';
 export type GenerateModuleOptions = {
   module: string;
 };
-type FieldOptions = {
+type ModelGenerationOptions = Omit<ModelAndFieldGenerationOptions, 'fields'>;
+
+type ModelAndFieldGenerationOptions = {
   module: string;
   model: string;
   moduleDisplayName: string;
   table?: string;
   dataSource: string;
-  fields: any[]; //FIXME This type can be improved
   modelEnableSoftDelete?: boolean;
   parentModel?: string; 
   parentModule?: string;
   draftPublishWorkflowEnabled?: boolean;
+  isLegacyTable?: boolean;
+  isLegacyTableWithId?: boolean;
+  dataSourceType?: string;
+  fields: FieldMetadata[]; //FIXME This type can be improved
 };
 export const REMOVE_FIELDS_COMMAND = 'remove-fields';
 export const REFRESH_MODEL_COMMAND = 'refresh-model';
@@ -32,7 +37,7 @@ export class SchematicService {
 
   async executeSchematicCommand(
     command: string,
-    options: GenerateModuleOptions | FieldOptions,
+    options: GenerateModuleOptions | ModelAndFieldGenerationOptions,
     debug = false,
   ): Promise<string> {
     return await this.commandService.executeCommand(
@@ -42,7 +47,7 @@ export class SchematicService {
 
   private generateSchematicCommand(
     command: string,
-    options: GenerateModuleOptions | FieldOptions,
+    options: GenerateModuleOptions | ModelAndFieldGenerationOptions,
     debug: boolean,
   ): string {
     const baseCommand = `schematics ${this.SCHEMATIC_PROJECT}:${command} --debug=${debug}`;
@@ -50,55 +55,76 @@ export class SchematicService {
       command === REMOVE_FIELDS_COMMAND ||
       command === REFRESH_MODEL_COMMAND
     ) {
-      const fieldOptions = options as FieldOptions;
-      let modelCommand = `${baseCommand} --module=${fieldOptions.module} --model=${fieldOptions.model}`;
-      if (fieldOptions.moduleDisplayName) {
-        modelCommand += ` --module-display-name=${snakeCase(fieldOptions.moduleDisplayName)}`;
-      }
-
-      if (fieldOptions.table) {
-        modelCommand += ` --table=${fieldOptions.table}`;
-      }
-
-      if (fieldOptions.dataSource) {
-        modelCommand += ` --data-source=${fieldOptions.dataSource}`;
-      }
-
-      if (fieldOptions.modelEnableSoftDelete) {
-        modelCommand += ` --model-enable-soft-delete=${fieldOptions.modelEnableSoftDelete}`;
-      }
-
-      if (fieldOptions.parentModel) {
-        modelCommand += ` --parent-model=${fieldOptions.parentModel}`;
-      }
-      if (fieldOptions.parentModule) {
-        modelCommand += ` --parent-module=${fieldOptions.parentModule}`;
-      }
-
-      if (fieldOptions.draftPublishWorkflowEnabled) {
-        modelCommand += ` --draft-publish-workflow-enabled=${fieldOptions.draftPublishWorkflowEnabled}`;
-      }
-      
-      let fieldCommand = fieldOptions.fields
-        .filter((field) => {
-          return !this.solidRegistry.getCommonEntityKeys().includes(field.name);
-        })
-        .map((field) => {
-          return `--fields='${JSON.stringify(field).replace(/'/g, "\\'")}'`;
-        })
-        .join(' ');
+      const {fields, ...modelSpecificOptions} = options as ModelAndFieldGenerationOptions;
+      const modelCommand = this.buildModelGenerationCommand(baseCommand, modelSpecificOptions);
+      const fieldCommand = this.buildFieldGenerationCommand(fields);
       const schematicCommand = modelCommand + ' ' + fieldCommand;
-      // console.log('schematicCommand', schematicCommand);
+      this.logger.debug('schematicCommand', schematicCommand);
       return schematicCommand;
     } else if (command === ADD_MODULE_COMMAND) {
       const moduleOptions = options as GenerateModuleOptions;
-      // console.log('moduleOptions', moduleOptions);
       const schematicCommand = ` ${baseCommand} --module=${moduleOptions.module}`;
-      // console.log('schematicCommand', schematicCommand);
       this.logger.debug('schematicCommand', schematicCommand);
       return schematicCommand;
     } else {
       throw new Error('Schematic command not supported.');
     }
   }
+
+  private buildFieldGenerationCommand(fields: FieldMetadata[]) {
+    return fields
+      .filter((field) => {
+        return !this.solidRegistry.getCommonEntityKeys().map(key => key.toString()).includes(field.name);
+      })
+      .map((field) => {
+        return `--fields='${JSON.stringify(field).replace(/'/g, "\\'")}'`;
+      })
+      .join(' ');
+  }
+
+  private buildModelGenerationCommand(baseCommand: string, modelSpecificOptions: ModelGenerationOptions): string {
+    let modelCommand = `${baseCommand} --module=${modelSpecificOptions.module} --model=${modelSpecificOptions.model}`;
+
+    // Make below options code generate i.e if option exists then add to command with proper casing
+    if (modelSpecificOptions.moduleDisplayName) {
+      modelCommand += ` --module-display-name=${snakeCase(modelSpecificOptions.moduleDisplayName)}`;
+    }
+
+    if (modelSpecificOptions.table) {
+      modelCommand += ` --table=${modelSpecificOptions.table}`;
+    }
+
+    if (modelSpecificOptions.dataSource) {
+      modelCommand += ` --data-source=${modelSpecificOptions.dataSource}`;
+    }
+
+    if (modelSpecificOptions.modelEnableSoftDelete) {
+      modelCommand += ` --model-enable-soft-delete=${modelSpecificOptions.modelEnableSoftDelete}`;
+    }
+
+    if (modelSpecificOptions.parentModel) {
+      modelCommand += ` --parent-model=${modelSpecificOptions.parentModel}`;
+    }
+    if (modelSpecificOptions.parentModule) {
+      modelCommand += ` --parent-module=${modelSpecificOptions.parentModule}`;
+    }
+
+    if (modelSpecificOptions.draftPublishWorkflowEnabled) {
+      modelCommand += ` --draft-publish-workflow-enabled=${modelSpecificOptions.draftPublishWorkflowEnabled}`;
+    }
+
+    if (modelSpecificOptions.isLegacyTable) {
+      modelCommand += ` --is-legacy-table=${modelSpecificOptions.isLegacyTable}`;
+    }
+
+    if (modelSpecificOptions.isLegacyTableWithId) {
+      modelCommand += ` --is-legacy-table-with-id=${modelSpecificOptions.isLegacyTableWithId}`;
+    }
+
+    if (modelSpecificOptions.dataSourceType) {
+      modelCommand += ` --data-source-type=${modelSpecificOptions.dataSourceType}`;
+    }
+    
+    return modelCommand;
+  }
 }

package/src/helpers/solid-registry.ts

@@ -5,7 +5,11 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { Locale } from 'src/entities/locale.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
-import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext } from "../interfaces";
+import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule } from "../interfaces";
+import { DatasourceType } from 'src/dtos/create-model-metadata.dto';
+import { ObjectLiteral } from 'typeorm';
+import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
+import { RelationMetadata } from 'typeorm/metadata/RelationMetadata';
 
 type ControllerMetadata = {
   name: string;
@@ -38,6 +42,16 @@ export enum RESERVED_SOLID_KEYWORDS {
   locale = "locale"
 }
 
+export interface TypeOrmEventContext {
+  eventType?: string;
+  entity?: ObjectLiteral | undefined;
+  databaseEntity?: any;
+  entityId?: any;
+  metadataName?: string;
+  updatedColumns?: string[];
+  updatedRelations?: string[];
+}
+
 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
@@ -48,6 +62,7 @@ export interface ComputedFieldMetadata<TContext = any> {
   computedFieldValueProviderName: string; // Name of the provider that computes the field value
   // Example: '{"contextKey": "contextValue"}'
   computedFieldValueProviderCtxt: TContext; // Context for the computed field value
+  eventContext: TypeOrmEventContext;
 }
 
 @Injectable()
@@ -247,6 +262,17 @@ export class SolidRegistry {
     return Array.from(this.solidDatabaseModules);
   }
 
+  getDefaultSolidDatabaseModule(): ISolidDatabaseModule {
+    const solidDatabaseModulesAsArray = Array.from(this.solidDatabaseModules);
+    for (let i = 0; i < solidDatabaseModulesAsArray.length; i++) {
+      const solidDatabaseModule = solidDatabaseModulesAsArray[i];
+      const solidDatabaseModuleInstance: ISolidDatabaseModule = solidDatabaseModule.instance;
+      if (solidDatabaseModuleInstance.name() === 'default') {
+        return solidDatabaseModuleInstance;
+      }
+    }
+  }
+
   getModules(): Array<InstanceWrapper> {
     return Array.from(this.modules);
   }
@@ -288,7 +314,7 @@ export class SolidRegistry {
     });
   }
 
-  getCommonEntityKeys(): (keyof CommonEntity)[] {
+  getCommonEntityKeys(): (keyof CommonEntity | 'createdBy' | 'updatedBy')[] {
     return ['id', 'createdAt', 'updatedAt', 'deletedAt', 'createdBy', 'updatedBy', 'deletedTracker', 'localeName', 'defaultEntityLocaleId', 'publishedAt'];
     // return Reflect.getMetadataKeys(CommonEntity.prototype) as (keyof CommonEntity)[];
   }

package/src/helpers/typeorm-db-helper.ts

@@ -0,0 +1,26 @@
+import { ColumnOptions } from "typeorm";
+import { DatasourceType } from "src/dtos/create-model-metadata.dto";
+
+const LONG_TEXT_MAP: Record<DatasourceType, ColumnOptions> = {
+    [DatasourceType.postgres]: { type: "text" },
+    [DatasourceType.mssql]: { type: "nvarchar", length: "max" },
+    [DatasourceType.mysql]: { type: "longtext" },
+    [DatasourceType.mariadb]: { type: "longtext" },
+    [DatasourceType.oracle]: { type: "clob" },
+};
+
+const solidCoreDbType: DatasourceType =
+    Object.values(DatasourceType).includes(process.env.SOLID_CORE_DB_TYPE as DatasourceType)
+        ? (process.env.SOLID_CORE_DB_TYPE as DatasourceType)
+        : DatasourceType.postgres;
+
+export function getColumnType(solidType: string): ColumnOptions {
+    switch (solidType) {
+        case "longText":
+        case "richText":
+            return LONG_TEXT_MAP[solidCoreDbType];
+
+        default:
+            return {};
+    }
+}

package/src/index.ts

@@ -26,6 +26,7 @@ export * from './decorators/mail-provider.decorator'
 export * from './decorators/security-rule-config-provider.decorator'
 
 export * from './dtos/post-chatter-message.dto'
+export * from './dtos/security-rule-config.dto'
 export * from './dtos/basic-filters.dto'
 export * from './dtos/solid-request-context.dto'
 export * from './dtos/change-password.dto'
@@ -99,6 +100,8 @@ export * from './dtos/update-user-activity-history.dto'
 
 export * from './entities/action-metadata.entity'
 export * from './entities/common.entity'
+export * from './entities/legacy-common.entity'
+export * from './entities/legacy-common-with-id.entity'
 export * from './entities/email-attachment.entity'
 export * from './entities/email-template.entity'
 export * from './entities/field-metadata.entity'
@@ -134,6 +137,7 @@ export * from './entities/dashboard-variable.entity'
 export * from './entities/dashboard-question.entity'
 export * from './entities/dashboard-question-sql-dataset-config.entity'
 export * from './entities/ai-interaction.entity'
+export * from './entities/model-sequence.entity'
 
 export * from './enums/auth-type.enum'
 export * from './decorators/disallow-in-production.decorator'
@@ -205,7 +209,7 @@ export * from './listeners/user-registration.listener'
 export * from './passport-strategies/google-oauth.strategy'
 export * from './passport-strategies/local.strategy'
 
-export * from './providers/list-of-values-selection-providers.service'
+export * from './services/selection-providers/list-of-values-selection-providers.service'
 
 // seed-data
 export * from './seeders/email-template-seeder.service'
@@ -296,6 +300,8 @@ export * from './subscribers/audit.subscriber'
 export * from './transformers/array-transformer'
 export * from './transformers/boolean-transformer'
 export * from './transformers/integer-transformer'
+export { default as datetimeTransformer } from './transformers/datetime-transformer'
+export * from './transformers/typeorm/local-date-time-transformer'
 
 export * from './validators/is-parsable-int'
 
@@ -304,6 +310,5 @@ export * from './interfaces'
 export * from './solid-core.module'
 
 export * from './winston.logger'
-export { default as datetimeTransformer } from './transformers/datetime-transformer'
 
 export { ERROR_MESSAGES } from './constants/error-messages'

package/src/interfaces.ts

@@ -64,7 +64,10 @@ export interface CodeGenerationOptions {
   modelId?: number;
   modelUserKey?: string;
   fieldIdsForRemoval?: number[];
+  fieldNamesForRemoval?: string[];
   dryRun?: boolean;
+  fieldIdsForRefresh?: number[];
+  fieldNamesForRefresh?: string[];
 }
 
 export interface TriggerMcpClientOptions {

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

@@ -1,4 +1,4 @@
-import { Injectable } from "@nestjs/common";
+import { Injectable, Logger } from "@nestjs/common";
 import { SolidRegistry } from "src/helpers/solid-registry";
 import { IEntityPostComputeFieldProvider, QueuesModuleOptions } from "src/interfaces";
 import { QueueMessage } from "src/interfaces/mq";
@@ -11,6 +11,7 @@ import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-que
 
 @Injectable()
 export class ComputedFieldEvaluationSubscriberRabbitmq extends RabbitMqSubscriber<ComputedFieldEvaluationPayload> {
+    private readonly _logger = new Logger(ComputedFieldEvaluationSubscriberRabbitmq.name);
     constructor(
         readonly mqMessageService: MqMessageService,
         readonly mqMessageQueueService: MqMessageQueueService,
@@ -30,9 +31,19 @@ export class ComputedFieldEvaluationSubscriberRabbitmq extends RabbitMqSubscribe
     // 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);
+        const { computedFieldValueProviderName } = computedFieldMetadata;
+        const provider = this.solidRegistry.getComputedFieldProvider(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
+        if (typeof providerInstance.postComputeAndSaveValue !== 'function') {
+            this._logger.warn(`Provider "${computedFieldValueProviderName}" does not implement postComputeAndSaveValue; skipping post-compute.`);
+            return;
+        }
+        await providerInstance.postComputeAndSaveValue(databaseEntity, {
+            ...computedFieldMetadata,
+            computedFieldValueProviderCtxt: {
+                ...(computedFieldMetadata.computedFieldValueProviderCtxt || {}),
+            },
+        }); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
     }
-}
+}