@solidxai/core 0.1.6-beta.9 → 0.1.7

package/src/services/computed-fields/entity/sequence-num-computed-field-provider.ts

@@ -1,20 +1,28 @@
+import { classify } from "@angular-devkit/core/src/utils/strings";
 import { Injectable } from "@nestjs/common";
 import { InjectDataSource } from "@nestjs/typeorm";
+import { ComputedFieldTriggerOperation } from "src/dtos/create-field-metadata.dto";
 import { ComputedFieldProvider } from "src/decorators/computed-field-provider.decorator";
 import { CommonEntity } from "src/entities/common.entity";
 import { ModelSequence } from "src/entities/model-sequence.entity";
 import { ComputedFieldMetadata } from "src/helpers/solid-registry";
-import { IEntityPreComputeFieldProvider } from "src/interfaces";
-import { DataSource, EntityTarget } from "typeorm";
+import { IEntityPostComputeFieldProvider } from "src/interfaces";
+import { DataSource, EntityManager } from "typeorm";
 
 
 export interface SequenceNumComputedFieldContext {
-    sequenceName: string; // The separator to use between concatenated values
+    sequenceName: string;
+    /**
+     * - `'counter'` (default): increments the sequence's `currentValue` and uses it as the number.
+     * - `'entityId'`: uses the entity's own `id` as the number; does not update the counter.
+     *   Only valid on `afterInsert` events.
+     */
+    mode?: 'counter' | 'entityId';
 }
 
 @ComputedFieldProvider()
 @Injectable()
-export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements IEntityPreComputeFieldProvider<T, SequenceNumComputedFieldContext> {
+export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements IEntityPostComputeFieldProvider<T, SequenceNumComputedFieldContext> {
     constructor(
         @InjectDataSource()
         private readonly dataSource: DataSource
@@ -25,23 +33,21 @@ export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements
     }
 
     help(): string {
-        return "Computed field provider used to create fields whose value is based on some prefix, padding & sequence number.";
+        return "Computed field provider used to create fields whose value is based on some prefix, padding & sequence number. " +
+            "Use mode='counter' (default) to auto-increment the sequence's currentValue. " +
+            "Use mode='entityId' to use the entity's own id as the number (afterInsert only, does not update the counter).";
     }
 
-    async preComputeValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<SequenceNumComputedFieldContext>) {
-        const { sequenceName } =
-            computedFieldMetadata.computedFieldValueProviderCtxt ?? {};
-
-        if (!sequenceName) {
-            throw new Error("sequenceName is required for sequence computation");
-        }
+    private buildSequenceString(modelSequence: ModelSequence, numericValue: number): string {
+        const prefix = modelSequence.prefix ?? "";
+        const separator = modelSequence.separator ?? "";
+        const padded = String(numericValue).padStart(modelSequence.padding ?? 5, "0");
+        return `${prefix}${separator}${padded}`;
+    }
 
-        await this.dataSource.transaction(async (manager) => {
-            /**
-             * 1️⃣ Lock sequence row (prevents race conditions)
-             */
-            // 1️⃣ Fetch sequence row
-            const modelSequenceRepo = manager.getRepository(ModelSequence)
+    private async generateCounterSequenceValue(sequenceName: string, manager?: EntityManager): Promise<{ sequenceString: string; currentValue: number; modelSingularName: string }> {
+        const run = async (mgr: EntityManager) => {
+            const modelSequenceRepo = mgr.getRepository(ModelSequence);
             const modelSequence = await modelSequenceRepo.findOne({
                 where: { sequenceName },
                 lock: { mode: "pessimistic_write" }
@@ -51,36 +57,69 @@ export class SequenceNumComputedFieldProvider<T extends CommonEntity> implements
                 throw new Error(`ModelSequence not found for ${sequenceName}`);
             }
 
-            // 2️⃣ Generate next sequence value
             const nextValue = modelSequence.currentValue + 1;
+            const sequenceString = this.buildSequenceString(modelSequence, nextValue);
 
-            const paddedValue = String(nextValue).padStart(modelSequence.padding ?? 5, "0");
+            modelSequence.currentValue = nextValue;
+            await modelSequenceRepo.save(modelSequence);
 
-            const prefix = modelSequence.prefix ?? "";
-            const separator = modelSequence.separator ?? "";
+            // Load model relation in a separate query to avoid FOR UPDATE on joined relation.
+            const modelSequenceWithModel = await modelSequenceRepo.findOne({
+                where: { id: modelSequence.id },
+                relations: { model: true },
+            });
+            const modelSingularName = modelSequenceWithModel?.model?.singularName;
+            if (!modelSingularName) {
+                throw new Error(`Model singularName not found for sequence ${sequenceName}`);
+            }
 
-            const sequenceString = `${prefix}${separator}${paddedValue}`;
+            return { sequenceString, currentValue: nextValue, modelSingularName };
+        };
 
-            // 3️⃣ Duplicate check on TARGET ENTITY (extra safety)
-            const entityRepo = manager.getRepository(triggerEntity.constructor as any);
+        return manager ? run(manager) : this.dataSource.transaction(run);
+    }
 
-            const existing = await entityRepo.findOne({
-                where: {
-                    [computedFieldMetadata.fieldName]: sequenceString,
-                },
-            });
+    private async generateEntityIdSequenceValue(sequenceName: string, entityId: number): Promise<{ sequenceString: string; modelSingularName: string }> {
+        const modelSequenceRepo = this.dataSource.manager.getRepository(ModelSequence);
+        const modelSequence = await modelSequenceRepo.findOne({
+            where: { sequenceName },
+            relations: { model: true },
+        });
 
-            if (existing) {
-                throw new Error(`Duplicate Sequence generated: ${sequenceString}`);
-            }
+        if (!modelSequence) {
+            throw new Error(`ModelSequence not found for ${sequenceName}`);
+        }
 
-            // 4️⃣ set the computed field on the entity
-            (triggerEntity as any)[computedFieldMetadata.fieldName] = sequenceString;
+        const modelSingularName = modelSequence.model?.singularName;
+        if (!modelSingularName) {
+            throw new Error(`Model singularName not found for sequence ${sequenceName}`);
+        }
 
-            // 5️⃣ Persist updated sequence current value
-            modelSequence.currentValue = nextValue;
-            await modelSequenceRepo.save(modelSequence);
-        });
+        return { sequenceString: this.buildSequenceString(modelSequence, entityId), modelSingularName };
     }
 
-}
+    async postComputeAndSaveValue(triggerEntity: T, computedFieldMetadata: ComputedFieldMetadata<SequenceNumComputedFieldContext>): Promise<void> {
+        const { sequenceName, mode = 'counter' } = computedFieldMetadata.computedFieldValueProviderCtxt ?? {};
+
+        if (!sequenceName) {
+            throw new Error("sequenceName is required for sequence computation");
+        }
+
+        let sequenceString: string;
+        let modelSingularName: string;
+
+        if (mode === 'entityId') {
+            const eventType = computedFieldMetadata.eventContext?.eventType;
+            if (eventType !== ComputedFieldTriggerOperation.afterInsert) {
+                throw new Error(`SequenceNumComputedFieldProvider with mode='entityId' only supports "${ComputedFieldTriggerOperation.afterInsert}" events, but received "${eventType}"`);
+            }
+            ({ sequenceString, modelSingularName } = await this.generateEntityIdSequenceValue(sequenceName, triggerEntity.id));
+        } else {
+            ({ sequenceString, modelSingularName } = await this.generateCounterSequenceValue(sequenceName));
+        }
+
+        const entityName = classify(modelSingularName);
+        const entityRepo = this.dataSource.manager.getRepository(entityName);
+        await entityRepo.update(triggerEntity.id, { [computedFieldMetadata.fieldName]: sequenceString });
+    }
+}

package/src/services/crud.service.ts

@@ -432,7 +432,7 @@ export class CRUDService<T extends CommonEntity> { // Add two generic value i.e
                 //     dataSource: string; // The name of the selection provider
                 //     filterSchema : json // This is a custom json object that every data source will handle accordingly. We could validate the query against the selection provider
                 //     values : string[]; // The values returned by the selection provider
-                const options = { ...commonOptions, selectionDynamicProvider: fieldMetadata.selectionDynamicProvider, selectionDynamicProviderCtxt: fieldMetadata.selectionDynamicProviderCtxt, selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, discoveryService: this.discoveryService, isMultiSelect: fieldMetadata.isMultiSelect };
+                const options = { ...commonOptions, selectionDynamicProvider: fieldMetadata.selectionDynamicProvider, selectionDynamicProviderCtxt: JSON.parse(fieldMetadata.selectionDynamicProviderCtxt), selectionValueType: fieldMetadata.selectionValueType as SelectionValueType, discoveryService: this.discoveryService, isMultiSelect: fieldMetadata.isMultiSelect };
                 return new SelectionDynamicFieldCrudManager(options);
             }
             case SolidFieldType.uuid: {

package/src/services/dashboard-layout.service.ts

@@ -0,0 +1,111 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+import { DashboardLayout } from 'src/entities/dashboard-layout.entity';
+import { DashboardLayoutRepository } from 'src/repository/dashboard-layout.repository';
+import { CreateDashboardLayoutDto } from 'src/dtos/create-dashboard-layout.dto';
+import { RequestContextService } from './request-context.service';
+
+
+@Injectable()
+export class DashboardLayoutService extends CRUDService<DashboardLayout> {
+  private readonly logger = new Logger(this.constructor.name);
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    readonly repo: DashboardLayoutRepository,
+    readonly requestContextService: RequestContextService,
+    readonly moduleRef: ModuleRef,
+  ) {
+    super(entityManager, repo, 'dashboardLayout', 'solid-core', moduleRef);
+  }
+
+  async upsertUserDashboardLayout(createDtos: CreateDashboardLayoutDto) {
+    const activeUser = this.requestContextService.getActiveUser();
+
+    if (!activeUser) {
+      throw new Error('User not found');
+    }
+
+    let userId = null;
+    if (activeUser.roles.includes('Admin')) {
+      userId = null;
+    } else {
+      userId = activeUser?.sub;
+    }
+    const existingLayout = await this.repo.findOne({
+      where: {
+        user: { id: userId },
+        dashboard: {
+          id: createDtos.dashboardId
+        }
+      },
+      relations: {
+        user: true,
+        dashboard: true,
+      }
+    });
+
+    if (existingLayout) {
+      return super.update(existingLayout.id, { layout: createDtos.layout }, [], true);
+    } else {
+      const createDto = {
+        layout: createDtos.layout,
+        dashboardId: createDtos.dashboardId,
+        uesrId: userId
+      }
+      return super.create(createDto, []);
+    }
+  }
+
+  async getUserDashboardLayoutByDashboardId(dashboardId: any) {
+    const activeUser = this.requestContextService.getActiveUser();
+
+    if (!activeUser) {
+      throw new Error('User not found');
+    }
+    const userId = activeUser?.sub;
+    const existingUserLayout = await this.repo.findOne({
+      where: {
+        user: { id: userId },
+        dashboard: {
+          id: dashboardId
+        }
+      },
+      relations: {
+        user: true,
+        dashboard: true,
+      }
+    });
+    if (existingUserLayout) {
+      // if dahsboard for userid exists 
+      return existingUserLayout;
+    }
+
+    // if not then check for default dashboard
+    const defaultLayout = await this.repo.findOne({
+      where: {
+        user: { id: null },
+        dashboard: {
+          id: dashboardId
+        }
+      },
+      relations: {
+        user: true,
+        dashboard: true,
+      }
+    });
+    if (defaultLayout) {
+      // if default layout exists return it
+      return defaultLayout;
+    } else {
+      // if default layout does not exist return empty layout 
+      return {
+        layout: null
+      }
+    }
+  }
+}

package/src/services/dashboard.service.ts

@@ -15,6 +15,7 @@ import { SolidRegistry } from 'src/helpers/solid-registry';
 import { DashboardMapper } from 'src/mappers/dashboard-mapper';
 import { DashboardRepository } from 'src/repository/dashboard.repository';
 import { Dashboard } from '../entities/dashboard.entity';
+import { CreateDashboardDto } from 'src/dtos/create-dashboard.dto';
 
 
 export const SQL_DYNAMIC_PROVIDER_NAME = 'DashboardVariableSQLDynamicProvider';
@@ -33,6 +34,12 @@ export class DashboardService extends CRUDService<Dashboard> {
     super(entityManager, repo, 'dashboard', 'solid-core', moduleRef);
   }
 
+
+  async create(createDto: CreateDashboardDto, files: Express.Multer.File[]) {
+    createDto.name = createDto.name.trim().replace(/\s+/g, '-').toLowerCase();
+    return super.create(createDto, files);
+  }
+
   async getSelectionDynamicValues(query: DashboardVariableSelectionDynamicQueryDto) {
     // Get the dashboard variable repo
     const dashboardVariable = await this.loadDashboardVariable(query.variableId);

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,
   ) { }
 
@@ -707,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)
 

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

@@ -1,7 +1,10 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
 import { ModuleRef } from "@nestjs/core";
 import { InjectEntityManager } from '@nestjs/typeorm';
+import { Cache } from 'cache-manager';
 import { CRUDService } from 'src/services/crud.service';
+import { shouldUseCache } from 'src/helpers/cache.helper';
 import { EntityManager, In } from 'typeorm';
 
 
@@ -10,42 +13,92 @@ import { PermissionMetadata } from '../entities/permission-metadata.entity';
 
 @Injectable()
 export class PermissionMetadataService extends CRUDService<PermissionMetadata> {
+  private readonly logger = new Logger(PermissionMetadataService.name);
   constructor(
     @InjectEntityManager()
     readonly entityManager: EntityManager,
     // @InjectRepository(PermissionMetadata, 'default')
     // readonly repo: Repository<PermissionMetadata>,
     readonly repo: PermissionMetadataRepository,
-    readonly moduleRef: ModuleRef
-
+    readonly moduleRef: ModuleRef,
+    @Inject(CACHE_MANAGER) private readonly cacheManager: Cache,
   ) {
     super(entityManager, repo, 'permissionMetadata', 'solid-core',moduleRef);
   }
 
+  private buildPermissionsByRoleCacheKey(roleName: string): string {
+    return `permissions:role:${roleName}`;
+  }
+
+  async findAllUsingRoles(roles: string[]): Promise<PermissionMetadata[]> {
+    const useCache = shouldUseCache();
+    const cached: PermissionMetadata[] = [];
+    const uncachedRoles: string[] = [];
 
-  findAllUsingRoles(roles: string[]) {
-    return this.repo.find({
-      where: {
-        roles: {
-          name: In(roles)
+    if (useCache) {
+      for (const role of roles) {
+        const cacheKey = this.buildPermissionsByRoleCacheKey(role);
+        const hit = await this.cacheManager.get<PermissionMetadata[]>(cacheKey);
+        if (hit) {
+          // this.logger.debug(`Cache hit for findAllUsingRoles: key=${cacheKey}`);
+          cached.push(...hit);
+        } else {
+          // this.logger.debug(`Cache miss for findAllUsingRoles: key=${cacheKey}`);
+          uncachedRoles.push(role);
         }
-      },
-      relations: {}
+      }
+    } else {
+      uncachedRoles.push(...roles);
+    }
+
+    if (uncachedRoles.length === 0) {
+      return cached;
+    }
+
+    const fromDb = await this.repo.find({
+      where: { roles: { name: In(uncachedRoles) } },
+      relations: { roles: true },
+    });
+
+    if (useCache) {
+      for (const role of uncachedRoles) {
+        const permsForRole = fromDb.filter(p => p.roles?.some(r => r.name === role));
+        await this.cacheManager.set(this.buildPermissionsByRoleCacheKey(role), permsForRole);
+      }
+    }
+
+    const seen = new Set<number>();
+    return [...cached, ...fromDb].filter(p => {
+      if (seen.has(p.id)) return false;
+      seen.add(p.id);
+      return true;
     });
   }
 
-  permissionExistsInRole(role: string, permission: string,) {
-    return this.repo.find({
-      where: {
-        name: permission,
-        roles: {
-          name: role
-        }
-      },
-      relations: {}
+  async permissionExistsInRole(role: string, permission: string): Promise<PermissionMetadata[]> {
+    const useCache = shouldUseCache();
+    const cacheKey = this.buildPermissionsByRoleCacheKey(role);
+
+    if (useCache) {
+      const hit = await this.cacheManager.get<PermissionMetadata[]>(cacheKey);
+      if (hit) {
+        // this.logger.debug(`Cache hit for permissionExistsInRole: key=${cacheKey}`);
+        return hit.filter(p => p.name === permission);
+      }
+      // this.logger.debug(`Cache miss for permissionExistsInRole: key=${cacheKey}`);
+    }
+
+    const fromDb = await this.repo.find({
+      where: { roles: { name: role } },
+      relations: { roles: true },
     });
+
+    if (useCache) {
+      await this.cacheManager.set(cacheKey, fromDb);
+    }
+
+    return fromDb.filter(p => p.name === permission);
   }
 
 }
 
-

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

@@ -89,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

@@ -37,7 +37,7 @@ export class PublisherFactory<T> {
 
         // type safe
         const typedActualPublisher: QueuePublisher<T> = actualPublisherToUse.instance;
-        this.logger.debug(`Resolved publisher with name ${actualPublisherToUse.name}, and with options: ${JSON.stringify(typedActualPublisher.options())}`);
+        // this.logger.debug(`Resolved publisher with name ${actualPublisherToUse.name}, and with options: ${JSON.stringify(typedActualPublisher.options())}`);
 
         return typedActualPublisher.publish(message);
     }

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

@@ -34,6 +34,10 @@ export abstract class RabbitMqPublisher<T> implements OnModuleDestroy, QueuePubl
 
     abstract options(): QueuesModuleOptions;
 
+    protected shouldPersistToDatabase(): boolean {
+        return this.options().persistToDatabase ?? true;
+    }
+
     private async ensureConnectionAndChannel(): Promise<amqp.Channel> {
         if (this.channel) {
             return this.channel;
@@ -170,7 +174,9 @@ export abstract class RabbitMqPublisher<T> implements OnModuleDestroy, QueuePubl
         message.messageId = uuidv4();
 
         // Save the message to the DB so that we can then change its status in the subscriber...
-        await this.persistToDatabase(namespacedQueueName, message);
+        if (this.shouldPersistToDatabase()) {
+            await this.persistToDatabase(namespacedQueueName, message);
+        }
 
         // wait for the channel to confirm 
         try {
@@ -199,7 +205,7 @@ export abstract class RabbitMqPublisher<T> implements OnModuleDestroy, QueuePubl
 
     private async persistToDatabase(queueName: string, message: QueueMessage<T>) {
 
-        // TODO: make an entry in the relevant database table, generate a unique id earlier.
+        // make an entry in the relevant database table, generate a unique id earlier.
         try {
             // 1. resolve the queue first
             const mqMessageQueue = await this.mqMessageQueueService.resolveQueue(queueName);