@solidxai/core 0.1.6-beta.0 → 0.1.6-beta.10

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

@@ -1,6 +1,7 @@
 import { BadRequestException, forwardRef, Inject, Injectable, Logger, NotFoundException } 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 * as path from 'path';
 import { DataSource, EntityManager, In, Repository, SelectQueryBuilder } from 'typeorm';
 import { CreateModelMetadataDto } from '../dtos/create-model-metadata.dto';
 import { ModelMetadata } from '../entities/model-metadata.entity';
@@ -33,6 +34,7 @@ import { RoleMetadataService } from './role-metadata.service';
 import { NavigationDto } from 'src/dtos/navigation.dto';
 import { SolidIntrospectService } from './solid-introspect.service';
 import { CRUDService } from './crud.service';
+import { SolidTsMorphService } from './solid-ts-morph.service';
 
 @Injectable()
 export class ModelMetadataService {
@@ -54,8 +56,9 @@ export class ModelMetadataService {
     private readonly roleService: RoleMetadataService,
     private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
     readonly introspectService: SolidIntrospectService,
+    private readonly solidTsMorphService: SolidTsMorphService,
 
-    // No longer used. 
+    // No longer used.
     // private readonly generateCodePublihser: GenerateCodePublisherDatabase,
   ) { }
 
@@ -225,6 +228,7 @@ export class ModelMetadataService {
     let userKeyField = null;
     const listViewLayout = [];
     const formViewLayout = [];
+    const treeViewLayout = [];
 
     for (let k = 0; k < fieldsMetadata.length; k++) {
       const fieldMetadata = fieldsMetadata[k];
@@ -245,6 +249,7 @@ export class ModelMetadataService {
       }
       listViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}` } })
       formViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}` } })
+      treeViewLayout.push({ type: "field", attrs: { name: `${affectedField.name}` } })
 
     }
 
@@ -705,48 +710,24 @@ export class ModelMetadataService {
       await fs.writeFile(filePath, updatedContent);
     }
 
-    // <moduleName>.module.ts | Remove all references and imports of the above files. | Manual (X)
-    // const moduleFilePath = path.resolve(modulePath, `${dasherize(modelEntity.module.name)}.module.ts`);
-
-    // this.logger.log(`Working on module file ${moduleFilePath}`);
-    // const project = new Project();
-    // const sourceFile = project.addSourceFileAtPath(moduleFilePath);
-
-    // // Remove import declarations related to deleted files
-    // sourceFile.getImportDeclarations().forEach(importDecl => {
-    //   const moduleSpecifier = importDecl.getModuleSpecifierValue();
-    //   const resolvedPath = importDecl.getModuleSpecifierSourceFile()?.getFilePath() || '';
-    //   if (filesToDelete.some(file => resolvedPath.endsWith(file))) {
-    //     importDecl.remove();
-    //   }
-    // });
-
-    // // Remove identifiers from `@Module` metadata (imports, providers, controllers)
-    // const moduleDecorator = sourceFile.getFirstDescendantByKind(SyntaxKind.Decorator);
-    // const objectLiteral = moduleDecorator?.getCallExpression()?.getArguments()?.[0];
-
-    // if (objectLiteral && objectLiteral.getKind() === SyntaxKind.ObjectLiteralExpression) {
-    //   const objectLiteralExpr = objectLiteral.asKindOrThrow(SyntaxKind.ObjectLiteralExpression);
-
-    //   for (const propName of ['imports', 'providers', 'controllers', 'exports']) {
-    //     const prop = objectLiteralExpr.getProperty(propName);
-    //     if (prop && prop.getKind() === SyntaxKind.PropertyAssignment) {
-    //       const elements = prop.getFirstDescendantByKind(SyntaxKind.ArrayLiteralExpression);
-    //       elements?.getElements().forEach(el => {
-    //         const text = el.getText();
-    //         if (filesToDelete.some(file => text.toLowerCase().includes(file.split('.')[0]))) {
-    //           // @ts-ignore
-    //           el.remove();
-    //         }
-    //       });
-    //     }
-    //   }
-    // }
-
-    // // Save changes
-    // sourceFile.saveSync();
-
-    // Run seeder to reflect the removal. 
+    // <moduleName>.module.ts | Remove all references and imports of the deleted model files. | Automatic
+    if (modulePath) {
+      const moduleFilePath = path.resolve(modulePath, `${dasherize(modelEntity.module?.name)}.module.ts`);
+      this.logger.log(`Removing model '${modelEntity.singularName}' references from module file: ${moduleFilePath}`);
+      try {
+        this.solidTsMorphService.begin();
+        const modelPathSegment = `/${dasherize(modelEntity.singularName)}.`;
+        const { removedIdentifiers } = this.solidTsMorphService.removeImports(
+          moduleFilePath,
+          spec => spec.includes(modelPathSegment)
+        );
+        this.solidTsMorphService.removeModuleMembers(moduleFilePath, removedIdentifiers);
+        await this.solidTsMorphService.commit();
+      } catch (error) {
+        this.solidTsMorphService.rollback();
+        this.logger.error(`Failed to clean up module file for model '${modelEntity.singularName}':`, error);
+      }
+    }
 
     // - | Drop database table | Removes the database table from the DB, this is a very risky step. Best to review all relations to other models etc and then do this manually | Manual (X)
 
@@ -818,6 +799,7 @@ export class ModelMetadataService {
       const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
 
       const listViewLayoutFields = [{ type: "field", attrs: { name: `id` } }];
+      const treeViewLayoutFields = [{ type: "field", attrs: { name: `id` } }];
       const formViewLayoutFields = [];
 
       for (let i = 0; i < model.fields.length; i++) {
@@ -825,8 +807,9 @@ export class ModelMetadataService {
         if (field.isSystem) continue;
         listViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}` } })
         formViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}` } })
+        treeViewLayoutFields.push({ type: "field", attrs: { name: `${field.name}` } })
       }
-      this.populateVAMConfigInFileInternal(formViewLayoutFields, model, listViewLayoutFields, metaData);
+      this.populateVAMConfigInFileInternal(formViewLayoutFields, model, listViewLayoutFields, treeViewLayoutFields, metaData);
       // Write the updated object back to the file
       const updatedContent = JSON.stringify(metaData, null, 2);
       await fs.writeFile(filePath, updatedContent);
@@ -839,7 +822,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; }; }[], treeViewLayoutFields: { type: string; attrs: { name: string; }; }[], metaData: any) {
     const column1Fields = [];
     const column2Fields = [];
 
@@ -852,7 +835,9 @@ export class ModelMetadataService {
       }
     }
     const actionName = `${model.singularName}-list-action`;
-    const viewName = `${model.singularName}-list-view`;
+    const treeViewActionName = `${model.singularName}-tree-view-action`;
+    const listViewName = `${model.singularName}-list-view`;
+    const treeViewName = `${model.singularName}-tree-view`;
     const formViewName = `${model.singularName}-form-view`;
     const menuName = `${model.singularName}-menu-item`;
 
@@ -865,7 +850,21 @@ export class ModelMetadataService {
       customComponent: ``,
       customIsModal: true,
       serverEndpoint: "",
-      viewUserKey: viewName,
+      viewUserKey: listViewName,
+      moduleUserKey: `${model.module.name}`,
+      modelUserKey: `${model.singularName}`
+    };
+
+    const treeViewAction = {
+      displayName: `${model.displayName} Tree View Action`,
+      name: treeViewActionName,
+      type: "solid",
+      domain: "",
+      context: "",
+      customComponent: ``,
+      customIsModal: true,
+      serverEndpoint: "",
+      viewUserKey: treeViewName,
       moduleUserKey: `${model.module.name}`,
       modelUserKey: `${model.singularName}`
     };
@@ -877,11 +876,11 @@ export class ModelMetadataService {
       actionUserKey: actionName,
       moduleUserKey: `${model.module.name}`,
       parentMenuItemUserKey: "",
-      iconName : ""
+      iconName: ""
     };
 
     const modelListview = {
-      name: viewName,
+      name: listViewName,
       displayName: `${model.displayName}`,
       type: "list",
       context: "{}",
@@ -905,6 +904,31 @@ export class ModelMetadataService {
       }
     };
 
+    const modelTreeview = {
+      name: treeViewName,
+      displayName: `${model.displayName}`,
+      type: "tree",
+      context: "{}",
+      moduleUserKey: `${model.module.name}`,
+      modelUserKey: `${model.singularName}`,
+      layout: {
+        type: "tree",
+        attrs: {
+          pagination: true,
+          pageSizeOptions: [
+            10,
+            25,
+            50
+          ],
+          enableGlobalSearch: true,
+          create: true,
+          edit: true,
+          delete: true
+        },
+        children: treeViewLayoutFields
+      }
+    };
+
 
     const modelFormView = {
       name: formViewName,
@@ -954,10 +978,18 @@ export class ModelMetadataService {
       metaData.actions.push(action);
     }
 
-    if (notExists(metaData.views, viewName)) {
+    if (notExists(metaData.actions, treeViewActionName)) {
+      metaData.actions.push(treeViewAction);
+    }
+
+    if (notExists(metaData.views, listViewName)) {
       metaData.views.push(modelListview);
     }
 
+    if (notExists(metaData.views, treeViewName)) {
+      metaData.views.push(modelTreeview);
+    }
+
     if (notExists(metaData.views, formViewName)) {
       metaData.views.push(modelFormView);
     }
@@ -979,6 +1011,14 @@ export class ModelMetadataService {
       }
     }));
 
+    const treeViewLayout = jsonFieldsList.map(field => ({
+      type: "field",
+      attrs: {
+        name: `${field.name}`,
+        isSearchable: true,
+      }
+    }));
+
     const formViewLayout = jsonFieldsList.map(field => ({
       type: "field",
       attrs: {
@@ -1019,6 +1059,26 @@ export class ModelMetadataService {
           children: listViewLayout
         }, null, 3)
       },
+      {
+        name: `${model.singularName}-tree-view`,
+        displayName: `${model.displayName}`,
+        type: 'tree',
+        context: "{}",
+        module: resolvedModule,
+        model: model,
+        layout: JSON.stringify({
+          type: "tree",
+          attrs: {
+            pagination: true,
+            pageSizeOptions: [10, 25, 50],
+            enableGlobalSearch: true,
+            create: true,
+            edit: true,
+            delete: true
+          },
+          children: treeViewLayout
+        }, null, 3)
+      },
       {
         name: `${model.singularName}-form-view`,
         displayName: `${model.displayName}`,
@@ -1067,6 +1127,7 @@ export class ModelMetadataService {
     }
 
     let view = await viewRepo.findOne({ where: { name: `${model.singularName}-list-view` } });
+    let treeView = await viewRepo.findOne({ where: { name: `${model.singularName}-tree-view` } });
 
     const actionData = {
       displayName: `${model.displayName} List Action`,
@@ -1082,13 +1143,33 @@ export class ModelMetadataService {
       model: model
     };
 
+    const treeViewActionData = {
+      displayName: `${model.displayName} Tree View Action`,
+      name: `${model.singularName}-tree-view-action`,
+      type: "solid",
+      domain: "",
+      context: "",
+      customComponent: ``,
+      customIsModal: true,
+      serverEndpoint: "",
+      view: treeView,
+      module: resolvedModule,
+      model: model
+    };
+
     let existingAction = await actionRepo.findOne({ where: { name: actionData.name } });
+    let existingTreeViewAction = await actionRepo.findOne({ where: { name: treeViewActionData.name } });
 
     if (!existingAction) {
       const createdAction = actionRepo.create(actionData);
       existingAction = await actionRepo.save(createdAction);
     }
 
+    if (!existingTreeViewAction) {
+      const createdTreeViewAction = actionRepo.create(treeViewActionData);
+      existingTreeViewAction = await actionRepo.save(createdTreeViewAction);
+    }
+
     const adminRole = await this.roleService.findRoleByName('Admin');
 
     const menuData = {

package/src/services/question-data-providers/chartjs-sql-data-provider.service.ts

@@ -1,16 +1,11 @@
 import { Injectable, Logger } from "@nestjs/common";
 import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
 import { DashboardQuestion } from "src/entities/dashboard-question.entity";
-import { IDashboardQuestionDataProvider } from "src/interfaces";
+import { IDashboardQuestionDataProvider, QuestionSqlDataProviderContext } from "src/interfaces";
 import { EntityManager } from "typeorm";
 import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
 import { getKpi, getLabels } from "./helpers";
 
-export interface QuestionSqlDataProviderContext {
-    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
-    // questionId: number;
-    // question: Question;
-}
 
 export enum SqlExpressionOperator {
     EQUALS = '$equals',
@@ -49,7 +44,8 @@ export class ChartJsSqlDataProvider implements IDashboardQuestionDataProvider<Qu
         return "ChartJsSqlDataProvider";
     }
 
-    async getData(question: DashboardQuestion, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+    async getData(question: DashboardQuestion, context?: QuestionSqlDataProviderContext): Promise<any> {
+        const expressions: SqlExpression[] = context?.expressions || [];
         // TODO: put some validation to check if the results of each SQL in each dataset returns the same number of rows 
 
         // This is what we have to return.

package/src/services/question-data-providers/prime-react-datatable-sql-data-provider.service.ts

@@ -1,19 +1,13 @@
 import { Injectable } from "@nestjs/common";
 import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
 import { DashboardQuestion } from "src/entities/dashboard-question.entity";
-import { IDashboardQuestionDataProvider } from "src/interfaces";
+import { IDashboardQuestionDataProvider, QuestionSqlDataProviderContext } from "src/interfaces";
 import { EntityManager } from "typeorm";
 import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
 import { Logger } from '@nestjs/common';
 import { SqlExpression } from "./chartjs-sql-data-provider.service";
 import { getKpi } from "./helpers";
 
-export interface QuestionSqlDataProviderContext {
-    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
-    // questionId: number;
-    // question: Question;
-}
-
 @DashboardQuestionDataProvider()
 @Injectable()
 export class PrimeReactDatatableSqlDataProvider implements IDashboardQuestionDataProvider<QuestionSqlDataProviderContext, any> {
@@ -29,7 +23,9 @@ export class PrimeReactDatatableSqlDataProvider implements IDashboardQuestionDat
         return "PrimeReactDatatableSqlDataProvider";
     }
 
-    async getData(question: DashboardQuestion, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+    async getData(question: DashboardQuestion, context?: QuestionSqlDataProviderContext): Promise<any> {
+        const expressions: SqlExpression[] = context?.expressions || [];
+
         // TODO: put some validation to check if the results of each SQL in each dataset returns the same number of rows 
 
         // Check the expected response for prime react data tables to understand what is going on here...

package/src/services/question-data-providers/prime-react-meter-group-sql-data-provider.service.ts

@@ -1,19 +1,13 @@
 import { Injectable } from "@nestjs/common";
 import { DashboardQuestionDataProvider } from "src/decorators/dashboard-question-data-provider.decorator";
 import { DashboardQuestion } from "src/entities/dashboard-question.entity";
-import { IDashboardQuestionDataProvider } from "src/interfaces";
+import { IDashboardQuestionDataProvider, QuestionSqlDataProviderContext } from "src/interfaces";
 import { EntityManager } from "typeorm";
 import { SqlExpressionResolverService } from "../sql-expression-resolver.service";
 import { Logger } from '@nestjs/common';
 import { SqlExpression } from "./chartjs-sql-data-provider.service";
 import { getKpi } from "./helpers";
 
-export interface QuestionSqlDataProviderContext {
-    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
-    // questionId: number;
-    // question: Question;
-}
-
 @DashboardQuestionDataProvider()
 @Injectable()
 export class PrimeReactMeterGroupSqlDataProvider implements IDashboardQuestionDataProvider<QuestionSqlDataProviderContext, any> {
@@ -58,7 +52,9 @@ export class PrimeReactMeterGroupSqlDataProvider implements IDashboardQuestionDa
         return colors;
     }
 
-    async getData(question: DashboardQuestion, expressions?: SqlExpression[], context?: QuestionSqlDataProviderContext): Promise<any> {
+    async getData(question: DashboardQuestion, context?: QuestionSqlDataProviderContext): Promise<any> {
+        const expressions: SqlExpression[] = context?.expressions || [];
+
         // TODO: put some validation to check if the results of each SQL in each dataset returns the same number of rows 
 
         // This is what we have to return.

package/src/services/queues/database-subscriber.service.ts

@@ -7,7 +7,7 @@ import { PollerService } from '../poller.service';
 import { buildNamespacedQueueName } from './common';
 
 export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscriber<T> {
-    private readonly logger = new Logger(DatabaseSubscriber.name);
+    private _loggerInstance?: Logger;
     private readonly url: string;
     private readonly serviceRole: string;
 
@@ -23,6 +23,17 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
         // this.logger.debug(`DatabaseSubscriber instance created with options: ${JSON.stringify(this.options())}`);
     }
 
+    protected get loggerContext(): string {
+        return this.constructor.name;
+    }
+
+    protected get logger(): Logger {
+        if (!this._loggerInstance) {
+            this._loggerInstance = new Logger(this.loggerContext);
+        }
+        return this._loggerInstance;
+    }
+
     abstract subscribe(message: QueueMessage<T>);
 
     abstract options(): QueuesModuleOptions;
@@ -78,9 +89,15 @@ export abstract class DatabaseSubscriber<T> implements OnModuleInit, QueueSubscr
         const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'database';
         const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
         const queueNameRegex = (process.env.QUEUES_QUEUE_NAME_REGEX_TO_ENABLE || '').trim();
+        const roleAllowed = ['both', 'subscriber'].includes(this.serviceRole);
+
+        if (!roleAllowed) {
+            this.logger.log(`DatabaseSubscriber is disabled because QUEUES_SERVICE_ROLE is "${this.serviceRole}". Expected "both" or "subscriber".`);
+            return;
+        }
 
         // we will start subscriber only if the current service role is subscriber. 
-        if (['both', 'subscriber'].includes(this.serviceRole) && defaultBroker === 'database' && solidCliRunning === "false") {
+        if (defaultBroker === 'database' && solidCliRunning === "false") {
             const options = this.options();
             const queueName = options.queueName;
 

package/src/services/queues/publisher-factory.service.ts

@@ -23,14 +23,16 @@ export class PublisherFactory<T> {
         // Register all ISolidDatabaseModules implementations
         let actualPublisherToUse = this.solidIntrospectionService.getProvider(resolvedPublisherName);
         if (!actualPublisherToUse) {
+            // Relaxed extra check in place to make sure we do not have to refactor old publishers or publishers named without the ____RabbitMq or ____Database convention
+            actualPublisherToUse = this.solidIntrospectionService.getProvider(publisherName);
 
             // Extra check in place to make sure we do not have to refactor old publishers which have been created earlier. 
-            if (defaultBrokerToUse === 'rabbitmq') {
-                actualPublisherToUse = this.solidIntrospectionService.getProvider(publisherName);
-                if (!actualPublisherToUse) {
-                    throw new Error(`Unable to locate publisher with name ${resolvedPublisherName}`);
-                }
-            }
+            // if (defaultBrokerToUse === 'rabbitmq') {
+            //     actualPublisherToUse = this.solidIntrospectionService.getProvider(publisherName);
+            // }
+        }
+        if (!actualPublisherToUse) {
+            throw new Error(`Unable to locate publisher with name ${resolvedPublisherName}`);
         }
 
         // type safe

package/src/services/queues/rabbitmq-subscriber.service.ts

@@ -6,9 +6,20 @@ import { MqMessageQueueService } from '../mq-message-queue.service';
 import { MqMessageService } from '../mq-message.service';
 import { buildNamespacedQueueName } from './common';
 
+class ConsumerProcessingTimeoutError extends Error {
+    constructor(
+        readonly queueName: string,
+        readonly messageId: string,
+        readonly timeoutMs: number,
+    ) {
+        super(`Subscriber processing timed out after ${timeoutMs}ms for queue ${queueName} and messageId ${messageId}`);
+        this.name = 'ConsumerProcessingTimeoutError';
+    }
+}
+
 
 export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscriber<T> { // TODO This can be made a generic type for better type visibility
-    private readonly logger = new Logger(RabbitMqSubscriber.name);
+    private _loggerInstance?: Logger;
     private readonly url: string;
     private readonly serviceRole: string;
     private connection: amqp.Connection | null = null;
@@ -30,6 +41,17 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         // this.logger.debug(`RabbitMqSubscriber instance created with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
     }
 
+    protected get loggerContext(): string {
+        return this.constructor.name;
+    }
+
+    protected get logger(): Logger {
+        if (!this._loggerInstance) {
+            this._loggerInstance = new Logger(this.loggerContext);
+        }
+        return this._loggerInstance;
+    }
+
     abstract subscribe(message: QueueMessage<T>);
 
     abstract options(): QueuesModuleOptions;
@@ -62,9 +84,15 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'rabbitmq';
         const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
         const queueNameRegex = (process.env.QUEUES_QUEUE_NAME_REGEX_TO_ENABLE || '').trim();
+        const roleAllowed = ['both', 'subscriber'].includes(this.serviceRole);
+
+        if (!roleAllowed) {
+            this.logger.log(`RabbitMqSubscriber is disabled because QUEUES_SERVICE_ROLE is "${this.serviceRole}". Expected "both" or "subscriber".`);
+            return;
+        }
 
         // we will start subscriber only if the current service role is subscriber. 
-        if (this.url && ['both', 'subscriber'].includes(this.serviceRole) && solidCliRunning === "false" && defaultBroker === 'rabbitmq') {
+        if (this.url && solidCliRunning === "false" && defaultBroker === 'rabbitmq') {
             const options = this.options();
             const queueName = options.queueName;
 
@@ -102,6 +130,10 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         if (prefetch < 1) {
             throw new Error(`RabbitMqSubscriber prefetch must be >= 1 for queue ${queueName}`);
         }
+        const processingTimeoutMs = this.resolveProcessingTimeoutMs();
+        if (processingTimeoutMs > 0) {
+            this.logger.log(`RabbitMqSubscriber using processing timeout ${processingTimeoutMs}ms for queue ${queueName}`);
+        }
 
         let connection: amqp.Connection;
         try {
@@ -186,7 +218,7 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
                 if (!message.currentRetry) message.currentRetry = 0;
 
                 try {
-                    await this.processMessage(message, rawMessage, channel);
+                    await this.processMessage(message, rawMessage, channel, queueName);
                 } catch (error) {
                     await this.handleProcessingError(message, rawMessage, channel, error, queueName);
                 }
@@ -322,11 +354,11 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
     /**
      * Abstract method for message processing logic.
      */
-    protected async processMessage(message: QueueMessage<T>, rawMessage, channel): Promise<void> {
+    protected async processMessage(message: QueueMessage<T>, rawMessage, channel, queueName: string): Promise<void> {
         await this.updateStatusInDatabase('started', message);
 
         // Capture the results of handling the task.
-        const result = await this.subscribe(message);
+        const result = await this.subscribeWithTimeout(message, queueName);
 
         // Ack the message. 
         channel.ack(rawMessage);
@@ -370,4 +402,82 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
 
     }
 
+    private resolveProcessingTimeoutMs(): number {
+        // Broker-side delivery-ack timeout (ms). If not provided, assume RabbitMQ default
+        // behavior used in this project: 30 minutes.
+        // Example (RabbitMQ broker):
+        // - Broker ack timeout: 30m => 1,800,000ms (QUEUES_RABBITMQ_CONSUMER_ACK_TIMEOUT_MS)
+        // - App soft timeout should be slightly lower, e.g. 29m30s => 1,770,000ms
+        //   (QUEUES_RABBITMQ_SUBSCRIBER_PROCESSING_TIMEOUT_MS), so application code fails first,
+        //   records DB state/error, and avoids broker-forced channel close as primary failure signal.
+        const brokerTimeoutMs = this.parsePositiveInt(process.env.QUEUES_RABBITMQ_CONSUMER_ACK_TIMEOUT_MS, 30 * 60 * 1000);
+
+        // Soft timeout should fire *before* broker timeout so we can fail explicitly,
+        // persist status/error, and avoid broker-forced channel closure as primary signal.
+        // Keep at least 1s to avoid zero/negative values when broker timeout is very small.
+        const defaultSoftTimeoutMs = Math.max(1_000, brokerTimeoutMs - 30_000);
+
+        // Final timeout precedence:
+        // 1) QUEUES_RABBITMQ_SUBSCRIBER_PROCESSING_TIMEOUT_MS (if valid positive int)
+        // 2) Derived defaultSoftTimeoutMs (broker timeout - 30s)
+        return this.parsePositiveInt(process.env.QUEUES_RABBITMQ_SUBSCRIBER_PROCESSING_TIMEOUT_MS, defaultSoftTimeoutMs);
+    }
+
+    private parsePositiveInt(value: string | undefined, fallback: number): number {
+        // Shared env parsing helper:
+        // - missing/invalid/non-positive => fallback
+        // - valid positive integer => parsed value
+        if (!value) return fallback;
+        const parsed = Number.parseInt(value, 10);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+    }
+
+    private async subscribeWithTimeout(message: QueueMessage<T>, queueName: string): Promise<any> {
+        const timeoutMs = this.resolveProcessingTimeoutMs();
+        const messageId = message?.messageId || 'unknown';
+
+        // Allow an escape hatch: non-positive timeout means run without a soft timeout.
+        if (timeoutMs <= 0) {
+            return this.subscribe(message);
+        }
+
+        let timedOut = false;
+        let timeoutHandle: NodeJS.Timeout | null = null;
+
+        // Main subscriber work promise.
+        // If timeout has already fired, suppress rethrow to avoid unhandled rejection noise
+        // (the timeout error is already the authoritative failure we track).
+        const subscribePromise = this.subscribe(message).catch((error) => {
+            if (timedOut) {
+                this.logger.error(
+                    `Subscriber promise rejected after timeout for queue ${queueName} and messageId ${messageId}: ${(error as Error)?.message || String(error)}`,
+                    (error as Error)?.stack,
+                );
+                return undefined;
+            }
+            throw error;
+        });
+
+        // Timeout promise rejects after timeoutMs with an explicit domain-specific error.
+        const timeoutPromise = new Promise<never>((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                timedOut = true;
+                reject(new ConsumerProcessingTimeoutError(queueName, messageId, timeoutMs));
+            }, timeoutMs);
+        });
+
+        try {
+            // Promise.race settles as soon as the *first* promise settles.
+            // - If subscribePromise resolves/rejects first, we use that outcome.
+            // - If timeoutPromise rejects first, we fail fast with timeout error.
+            // This ensures we mark DB status via normal error handling before broker ack-timeout.
+            return await Promise.race([subscribePromise, timeoutPromise]);
+        } finally {
+            // Always clear timer once race settles to avoid timer leaks.
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }
+    }
+
 }