@solidxai/core 0.1.6-beta.2 → 0.1.6-beta.21

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

@@ -1,6 +1,9 @@
 import { BadRequestException, forwardRef, Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
 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 { Cache } from 'cache-manager';
 import { DataSource, EntityManager, In, Repository, SelectQueryBuilder } from 'typeorm';
 import { CreateModelMetadataDto } from '../dtos/create-model-metadata.dto';
 import { ModelMetadata } from '../entities/model-metadata.entity';
@@ -11,6 +14,7 @@ import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { DisallowInProduction } from 'src/decorators/disallow-in-production.decorator';
 import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
 import { PermissionMetadata } from 'src/entities/permission-metadata.entity';
+import { shouldUseCache } from 'src/helpers/cache.helper';
 import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
 import { FieldMetadataRepository } from 'src/repository/field-metadata.repository';
 import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
@@ -33,6 +37,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 +59,10 @@ export class ModelMetadataService {
     private readonly roleService: RoleMetadataService,
     private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
     readonly introspectService: SolidIntrospectService,
+    private readonly solidTsMorphService: SolidTsMorphService,
+    @Inject(CACHE_MANAGER) private readonly cacheManager: Cache,
 
-    // No longer used. 
+    // No longer used.
     // private readonly generateCodePublihser: GenerateCodePublisherDatabase,
   ) { }
 
@@ -109,7 +116,23 @@ export class ModelMetadataService {
     return entity;
   }
 
+  private buildModelBySingularNameCacheKey(singularName: string): string {
+    return `modelMetadata:singularName:${singularName}`;
+  }
+
   async findOneBySingularName(singularName: string, relations = {}) {
+    const useCache = shouldUseCache();
+    const cacheKey = this.buildModelBySingularNameCacheKey(singularName);
+
+    if (useCache) {
+      const cached = await this.cacheManager.get<ModelMetadata>(cacheKey);
+      if (cached) {
+        // this.logger.debug(`Cache hit for findOneBySingularName: key=${cacheKey}`);
+        return cached;
+      }
+      // this.logger.debug(`Cache miss for findOneBySingularName: key=${cacheKey}`);
+    }
+
     const entity = await this.modelMetadataRepo.findOne({
       where: {
         singularName: singularName,
@@ -119,10 +142,27 @@ export class ModelMetadataService {
     if (!entity) {
       throw new NotFoundException(ERROR_MESSAGES.ENTITY_NOT_FOUND(singularName));
     }
+
+    if (useCache) {
+      await this.cacheManager.set(cacheKey, entity);
+    }
+
     return entity;
   }
 
   async findOneByUserKey(singularName: string, relations = {}) {
+    const useCache = shouldUseCache();
+    const cacheKey = this.buildModelBySingularNameCacheKey(singularName);
+
+    if (useCache) {
+      const cached = await this.cacheManager.get<ModelMetadata>(cacheKey);
+      if (cached) {
+        // this.logger.debug(`Cache hit for findOneByUserKey: key=${cacheKey}`);
+        return cached;
+      }
+      // this.logger.debug(`Cache miss for findOneByUserKey: key=${cacheKey}`);
+    }
+
     const entity = await this.modelMetadataRepo.findOne({
       where: {
         singularName: singularName,
@@ -132,6 +172,11 @@ export class ModelMetadataService {
     if (!entity) {
       throw new NotFoundException(ERROR_MESSAGES.ENTITY_NOT_FOUND(singularName));
     }
+
+    if (useCache) {
+      await this.cacheManager.set(cacheKey, entity);
+    }
+
     return entity;
   }
 
@@ -225,6 +270,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 +291,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 +752,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 +841,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 +849,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 +864,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 +877,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 +892,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 +918,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 +946,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 +1020,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 +1053,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 +1101,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 +1169,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 +1185,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/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/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