@solidxai/core 0.1.6-beta.9 → 0.1.7

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

@@ -6,6 +6,17 @@ 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 _loggerInstance?: Logger;
@@ -45,6 +56,10 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
 
     abstract options(): QueuesModuleOptions;
 
+    protected shouldPersistToDatabase(): boolean {
+        return this.options().persistToDatabase ?? true;
+    }
+
     async establishConnection(): Promise<amqp.Connection> {
 
         const url = new URL(this.url);
@@ -73,9 +88,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;
 
@@ -113,6 +134,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 {
@@ -197,7 +222,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);
                 }
@@ -212,10 +237,12 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
     // Retry flow: update DB -> increment retry -> send to retry queue with per-message expiration -> ack original.
     private async handleProcessingError(message: QueueMessage<T>, rawMessage: amqp.ConsumeMessage, channel: amqp.Channel, error: any, queueName: string): Promise<void> {
         const errorMessage = (error as Error)?.message || String(error);
-        this.logger.error(`Error processing message on queue ${queueName}: ${errorMessage}`);
+        this.logger.error(`Error processing message on queue ${queueName}: ${errorMessage}`, (error as Error)?.stack);
 
         if (message.currentRetry < message.retryCount) {
-            await this.updateStatusInDatabase('retrying', message);
+            if (this.shouldPersistToDatabase()) {
+                await this.updateStatusInDatabase('retrying', message);
+            }
 
             message.currentRetry++;
             const retryQueue = `${queueName}.retry`;
@@ -233,8 +260,9 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
             this.logger.warn(`Retrying message (${message.currentRetry}/${message.retryCount}) after ${message.retryInterval}ms on queue ${queueName}`);
             return;
         }
-
-        await this.updateStatusInDatabase('failed', message, errorMessage, '');
+        if (this.shouldPersistToDatabase()) {
+            await this.updateStatusInDatabase('failed', message, errorMessage, '');
+        }
         channel.ack(rawMessage);
         await this.publishToFailedQueue(queueName, Buffer.from(JSON.stringify(message)), channel, error);
         this.logger.error(`Message failed after ${message.retryCount} attempts on queue ${queueName}: ${errorMessage}`);
@@ -333,17 +361,21 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
     /**
      * Abstract method for message processing logic.
      */
-    protected async processMessage(message: QueueMessage<T>, rawMessage, channel): Promise<void> {
-        await this.updateStatusInDatabase('started', message);
+    protected async processMessage(message: QueueMessage<T>, rawMessage, channel, queueName: string): Promise<void> {
+        if (this.shouldPersistToDatabase()) {
+            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);
 
         // Persist success output and timing.
-        await this.updateStatusInDatabase('succeeded', message, '', result ? JSON.stringify(result, null, 2) : '');
+        if (this.shouldPersistToDatabase()) {
+            await this.updateStatusInDatabase('succeeded', message, '', result ? JSON.stringify(result, null, 2) : '');
+        }
 
     }
 
@@ -381,4 +413,89 @@ 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]);
+        } catch (error) {
+            const errorMessage = (error as Error)?.message || String(error);
+            this.logger.error(
+                `Subscriber execution failed for queue ${queueName} and messageId ${messageId}: ${errorMessage}`,
+                (error as Error)?.stack,
+            );
+            throw error;
+        } finally {
+            // Always clear timer once race settles to avoid timer leaks.
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }
+    }
+
 }

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

@@ -2,6 +2,7 @@ import { Injectable } from "@nestjs/common";
 import { ClsService } from "nestjs-cls";
 import { REQUEST_USER_KEY } from "src/constants";
 import { BasicFilterDto } from "src/dtos/basic-filters.dto";
+import { ActiveUserData } from "src/interfaces/active-user-data.interface";
 
 @Injectable()
 export class RequestContextService {
@@ -9,7 +10,7 @@ export class RequestContextService {
     }
 
     // This method i.e getActiveUser() will fetch the user from the request object in the context
-    getActiveUser() {
+    getActiveUser(): ActiveUserData | undefined {
         return this.cls.get(REQUEST_USER_KEY);
     }
 

package/src/services/scheduled-jobs/scheduler.service.ts

@@ -24,13 +24,23 @@ export class SchedulerServiceImpl implements ISchedulerService {
     async runScheduledJobs(): Promise<void> {
         const solidSchedulerEnabled = process.env.SOLID_SCHEDULER_ENABLED || "true";
         if (solidSchedulerEnabled.toLowerCase() !== "true") {
-            // this.logger.debug('Solid scheduler is disabled via environment variable');
+            this.logger.debug('Solid scheduler is disabled via environment variable');
             return;
         }
         const solidCliRunning = process.env.SOLID_CLI_RUNNING || "false";
         if (solidCliRunning === "true") {
             return;
         }
+        const jobsRegexToEnable = (process.env.SOLID_SCHEDULER_JOBS_REGEX_TO_ENABLE || '').trim();
+        let jobsRegex: RegExp | null = null;
+        if (jobsRegexToEnable && jobsRegexToEnable !== "all") {
+            try {
+                jobsRegex = new RegExp(jobsRegexToEnable);
+            } catch (error) {
+                this.logger.error(`Invalid SOLID_SCHEDULER_JOBS_REGEX_TO_ENABLE regex "${jobsRegexToEnable}". Scheduler loop will skip this run.`);
+                return;
+            }
+        }
 
         const now = new Date();
 
@@ -53,6 +63,12 @@ export class SchedulerServiceImpl implements ISchedulerService {
 
         for (const job of dueJobs) {
             const jobKey = String(job.id ?? job.scheduleName ?? job.job);
+            const jobName = String(job.job ?? '');
+
+            if (jobsRegex && !jobsRegex.test(jobName)) {
+                this.logger.log(`[${now.getTime()}]: scheduler service skipping job ${jobName} because it does not match SOLID_SCHEDULER_JOBS_REGEX_TO_ENABLE=${jobsRegexToEnable}`);
+                continue;
+            }
 
             if (this.runningJobs.has(jobKey)) {
                 this.logger.log(`[${now.getTime()}]: scheduler service skipping job ${job.job} because a run is already in progress`);
@@ -194,16 +210,18 @@ export class SchedulerServiceImpl implements ISchedulerService {
                 tz: 'UTC'
             });
             const nextRun = interval.next().toDate();
+            const runAfterNext = interval.next().toDate();
 
-            // Validate minimum 1 minute interval
-            if (nextRun.getTime() - from.getTime() < 60000) {
+            // Validate minimum 1 minute cadence between consecutive runs.
+            // Comparing nextRun to "from" is incorrect near minute boundaries.
+            if (runAfterNext.getTime() - nextRun.getTime() < 60000) {
                 throw new Error('Cron expression interval must be at least 1 minute');
             }
             
             this.logger.log(`Custom cron '${job.cronExpression}' next run: ${nextRun}`);
             return nextRun;
         } catch (error) {
-            this.logger.error(`Invalid cron expression for job ${job.scheduleName}: ${job.cronExpression}`, error);
+            this.logger.error(`Invalid cron expression for job ${job.scheduleName}: ${job.cronExpression}. Reason: ${(error as Error).message}`);
             // Fallback to daily if cron parsing fails
             return new Date(base.getTime() + 24 * 60 * 60 * 1000);
         }

package/src/services/solid-introspect.service.ts

@@ -1,6 +1,8 @@
 import { classify } from '@angular-devkit/core/src/utils/strings';
 import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
 import { DiscoveryService, MetadataScanner, ModuleRef, Reflector } from '@nestjs/core';
+import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
+import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
 import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
 import { getDataSourceToken } from '@nestjs/typeorm';
 import { IS_COMPUTED_FIELD_PROVIDER } from 'src/decorators/computed-field-provider.decorator';
@@ -40,6 +42,8 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
     private readonly solidRegistry: SolidRegistry,
     private readonly moduleRef: ModuleRef,
     private readonly settingService: SettingService,
+    private readonly modelMetadataRepo: ModelMetadataRepository,
+    private readonly modelMetadataHelperService: ModelMetadataHelperService,
   ) { }
 
   private readonly logger = new Logger(SolidIntrospectService.name);
@@ -142,9 +146,33 @@ export class SolidIntrospectService implements OnApplicationBootstrap {
 
     // Register the core subscribers against all the configured database modules / datasources
     await this.bootstrapCoreTypeOrmSubscribers(solidDatabaseModules);
+    await this.cacheAuditableModels();
     await this.settingService.updateSettingsCache();
   }
 
+  private async cacheAuditableModels(): Promise<void> {
+    const models = await this.modelMetadataRepo.find({
+      where: { enableAuditTracking: true },
+      relations: { fields: true, module: true },
+    });
+
+    const auditableSet = new Set<string>();
+    for (const model of models) {
+      const allFields = await this.modelMetadataHelperService.loadFieldHierarchy(model.singularName);
+      const hasAuditableField = allFields.some(field =>
+        field.enableAuditTracking &&
+        !['mediaSingle', 'mediaMultiple', 'richText', 'json'].includes(field.type) &&
+        !(field.type === 'relation' && field.relationType === 'one-to-many')
+      );
+      if (hasAuditableField) {
+        auditableSet.add(model.singularName.toLowerCase());
+      }
+    }
+
+    this.solidRegistry.registerAuditableModels(auditableSet);
+    this.logger.debug(`Cached ${auditableSet.size} auditable model(s): ${[...auditableSet].join(', ')}`);
+  }
+
   async bootstrapCoreTypeOrmSubscribers(dbModules: Array<InstanceWrapper<any>>): Promise<void> {
     // Register core subscribers for each Solid database module
     for (const wrapper of dbModules) {

package/src/services/solid-ts-morph.service.ts

@@ -324,6 +324,104 @@ export class SolidTsMorphService {
         return { staged: true, overwritten: false, skipped: false };
     }
 
+
+    //Removes all import declarations from a file whose module specifier matches the given predicate.
+    //Returns the set of identifier names that were imported by the removed declarations.
+    removeImports(
+        filePath: string,
+        filter: (moduleSpecifier: string) => boolean
+    ): { removedIdentifiers: Set<string>; staged: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs)) {
+            this.logger.warn(`removeImport: file not found at ${filePath}, skipping.`);
+            return { removedIdentifiers: new Set(), staged: false, skipped: true };
+        }
+
+        const existing = this.project.getSourceFile(abs);
+        const sourceFile = existing
+            ? existing
+            : this.project.createSourceFile(abs, readFileSync(abs, "utf8"), { overwrite: true });
+
+        const importsToRemove = sourceFile.getImportDeclarations().filter(decl => {
+            const spec = decl.getModuleSpecifierValue().replace(/\\/g, "/");
+            return filter(spec);
+        });
+
+        if (importsToRemove.length === 0) {
+            return { removedIdentifiers: new Set(), staged: false, skipped: true };
+        }
+
+        const removedIdentifiers = new Set<string>();
+        for (const decl of importsToRemove) {
+            for (const named of decl.getNamedImports()) {
+                removedIdentifiers.add(named.getAliasNode()?.getText() ?? named.getName());
+            }
+            const defaultImport = decl.getDefaultImport();
+            if (defaultImport) removedIdentifiers.add(defaultImport.getText());
+            decl.remove();
+        }
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged removal of ${importsToRemove.length} import(s) in: ${this.rel(abs)}`);
+        return { removedIdentifiers, staged: true, skipped: false };
+    }
+
+    //Removes the given identifier names from all @Module decorator array properties
+    removeModuleMembers(
+        filePath: string,
+        names: Set<string> | string[]
+    ): { staged: boolean; skipped: boolean } {
+        const abs = this.resolveRepoPath(filePath);
+        if (!existsSync(abs)) {
+            this.logger.warn(`removeImportMembers: file not found at ${filePath}, skipping.`);
+            return { staged: false, skipped: true };
+        }
+
+        const identifiers = names instanceof Set ? names : new Set(names);
+        if (identifiers.size === 0) return { staged: false, skipped: true };
+
+        const existing = this.project.getSourceFile(abs);
+        const sourceFile = existing
+            ? existing
+            : this.project.createSourceFile(abs, readFileSync(abs, "utf8"), { overwrite: true });
+
+        const nestModuleClass = sourceFile.getClasses().find(cls =>
+            cls.getDecorators().some(dec => dec.getName() === "Module")
+        );
+        if (!nestModuleClass) {
+            this.logger.warn(`removeImportMembers: no @Module() class found in ${filePath}`);
+            return { staged: false, skipped: true };
+        }
+
+        const moduleDec = nestModuleClass.getDecorators().find(dec => dec.getName() === "Module");
+        const arg0 = moduleDec?.getCallExpression()?.getArguments()[0];
+        if (!arg0 || !Node.isObjectLiteralExpression(arg0)) return { staged: false, skipped: true };
+
+        const meta = arg0 as ObjectLiteralExpression;
+        for (const propName of ["imports", "providers", "controllers", "exports"] as const) {
+            const prop = meta.getProperty(propName);
+            if (!prop || !Node.isPropertyAssignment(prop)) continue;
+            const init = prop.getInitializer();
+            if (!init || !Node.isArrayLiteralExpression(init)) continue;
+            const arr = init as ArrayLiteralExpression;
+            const elements = arr.getElements();
+            for (let i = elements.length - 1; i >= 0; i--) {
+                const elemText = elements[i].getText().trim();
+                // Match direct identifiers (e.g. TestService) or call expressions that reference them (e.g. TypeOrmModule.forFeature([Test])).
+                const shouldRemove = identifiers.has(elemText) ||
+                    [...identifiers].some(id => new RegExp(`\\b${id}\\b`).test(elemText));
+                if (shouldRemove) {
+                    arr.removeElement(i);
+                }
+            }
+        }
+
+        this.dirtySourceFiles.add(abs);
+        this.logger.log(`Staged removal of [${[...identifiers].join(", ")}] from @Module arrays in: ${this.rel(abs)}`);
+        return { staged: true, skipped: false };
+    }
+
+
     addImport(
         filePath: string,
         importLine: string

package/src/solid-core.module.ts

@@ -94,6 +94,10 @@ import { Msg91SmsQueuePublisher } from './jobs/msg91-sms-publisher.service';
 import { Msg91SmsQueueSubscriber } from './jobs/msg91-sms-subscriber.service';
 import { SmtpEmailQueuePublisherRabbitmq } from './jobs/smtp-email-publisher.service';
 import { SmtpEmailQueueSubscriberRabbitmq } from './jobs/smtp-email-subscriber.service';
+import { ChatterQueuePublisherRabbitmq } from './jobs/chatter-queue-publisher.service';
+import { ChatterQueueSubscriberRabbitmq } from './jobs/chatter-queue-subscriber.service';
+import { ChatterQueuePublisherDatabase } from './jobs/database/chatter-queue-publisher-database.service';
+import { ChatterQueueSubscriberDatabase } from './jobs/database/chatter-queue-subscriber-database.service';
 import { TestQueuePublisher } from './jobs/test-queue-publisher.service';
 import { TestQueueSubscriber } from './jobs/test-queue-subscriber.service';
 import { UserRegistrationListener } from './listeners/user-registration.listener';
@@ -133,6 +137,8 @@ import { ChatterMessageController } from './controllers/chatter-message.controll
 import { DashboardQuestionSqlDatasetConfigController } from './controllers/dashboard-question-sql-dataset-config.controller';
 import { DashboardQuestionController } from './controllers/dashboard-question.controller';
 import { DashboardVariableController } from './controllers/dashboard-variable.controller';
+import { DashboardLayoutController } from './controllers/dashboard-layout.controller';
+
 import { DashboardController } from './controllers/dashboard.controller';
 import { ExportTemplateController } from './controllers/export-template.controller';
 import { ExportTransactionController } from './controllers/export-transaction.controller';
@@ -156,6 +162,8 @@ import { ChatterMessage } from './entities/chatter-message.entity';
 import { DashboardQuestionSqlDatasetConfig } from './entities/dashboard-question-sql-dataset-config.entity';
 import { DashboardQuestion } from './entities/dashboard-question.entity';
 import { DashboardVariable } from './entities/dashboard-variable.entity';
+import { DashboardLayout } from './entities/dashboard-layout.entity';
+
 import { Dashboard } from './entities/dashboard.entity';
 import { ExportTemplate } from './entities/export-template.entity';
 import { ExportTransaction } from './entities/export-transaction.entity';
@@ -221,6 +229,8 @@ import { DashboardQuestionSqlDatasetConfigRepository } from './repository/dashbo
 import { DashboardQuestionRepository } from './repository/dashboard-question.repository';
 import { DashboardVariableRepository } from './repository/dashboard-variable.repository';
 import { DashboardRepository } from './repository/dashboard.repository';
+import { DashboardLayoutRepository } from './repository/dashboard-layout.repository';
+
 import { EmailTemplateRepository } from './repository/email-template.repository';
 import { ExportTemplateRepository } from './repository/export-template.repository';
 import { ExportTransactionRepository } from './repository/export-transaction.repository';
@@ -263,6 +273,8 @@ import { DashboardVariableSQLDynamicProvider } from './services/dashboard-select
 import { DasbhoardVariableTestDynamicProvider } from './services/dashboard-selection-providers/dashboard-variable-test-dynamic-provider.service';
 import { DashboardVariableService } from './services/dashboard-variable.service';
 import { DashboardService } from './services/dashboard.service';
+import { DashboardLayoutService } from './services/dashboard-layout.service';
+
 import { ExcelService } from './services/excel.service';
 import { ExportTemplateService } from './services/export-template.service';
 import { ExportTransactionService } from './services/export-transaction.service';
@@ -329,6 +341,7 @@ import { ImageEncodingService } from './helpers/image-encoding.helper';
 import { SolidMicroserviceAdapter } from './helpers/solid-microservice-adapter.service';
 import { InfoCommand } from './commands/info.command';
 import { ListOfRolesSelectionProvider } from './services/selection-providers/list-of-roles-selectionproviders.service';
+import { Entity } from 'typeorm';
 
 
 @Global()
@@ -343,6 +356,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
       DashboardQuestion,
       DashboardQuestionSqlDatasetConfig,
       DashboardVariable,
+      DashboardLayout,
       EmailAttachment,
       EmailTemplate,
       ExportTemplate,
@@ -414,6 +428,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     DashboardQuestionController,
     DashboardQuestionSqlDatasetConfigController,
     DashboardVariableController,
+    DashboardLayoutController,
     EmailTemplateController,
     ExportTemplateController,
     ExportTransactionController,
@@ -584,8 +599,10 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     TestQueuePublisher,
     TestQueueSubscriber,
 
-    // ChatterQueuePublisher,
-    // ChatterQueueSubscriber,
+    ChatterQueuePublisherRabbitmq,
+    ChatterQueueSubscriberRabbitmq,
+    ChatterQueuePublisherDatabase,
+    ChatterQueueSubscriberDatabase,
 
     TestQueuePublisherDatabase,
     TestQueueSubscriberDatabase,
@@ -638,6 +655,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     UserActivityHistoryService,
     DashboardService,
     DashboardVariableService,
+    DashboardLayoutService,
     DashboardQuestionService,
     DashboardVariableSQLDynamicProvider,
     DasbhoardVariableTestDynamicProvider,
@@ -682,6 +700,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     DashboardQuestionSqlDatasetConfigRepository,
     DashboardQuestionRepository,
     DashboardVariableRepository,
+    DashboardLayoutRepository,
     EmailTemplateRepository,
     ExportTemplateRepository,
     ExportTransactionRepository,