@solidxai/core 0.1.6 → 0.1.7

package/src/entities/user.entity.ts

@@ -11,109 +11,144 @@ export class User extends CommonEntity {
     @Column({ type: "varchar", nullable: true })
     @Expose()
     fullName: string;
+
     @Index({ unique: true })
     @Column({ type: "varchar" })
     @Expose()
     username: string;
-    // @Index({ unique: true })
+
+    @Index()
     @Column({ type: "varchar", nullable: true })
     @Expose()
     email: string;
-    // @Index({ unique: true })
+
+    @Index()
     @Column({ type: "varchar", nullable: true })
     @Expose()
     mobile: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     password: string;
+
     @Column({ nullable: true, default: true })
     @Expose()
     forcePasswordChange: boolean = true;
+
     @Column({ type: "varchar", default: "local" })
     // don't send to client
     lastLoginProvider: string = "local";
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client (test)
     accessCode: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleAccessToken: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleId: string;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     googleProfilePicture: string;
+
     @Column({ default: true })
     @Expose()
     active: boolean = true;
+
     @Column({ nullable: true })
     // don't send to client
     forgotPasswordConfirmedAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     verificationTokenOnForgotPassword: string;
+
     @Column({ nullable: true })
     // don't send to client
     verificationTokenOnForgotPasswordExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerifiedOnRegistrationAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     emailVerificationTokenOnRegistration: string;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerificationTokenOnRegistrationExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerifiedOnRegistrationAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     mobileVerificationTokenOnRegistration: string;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerificationTokenOnRegistrationExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerifiedOnLoginAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     emailVerificationTokenOnLogin: string;
+
     @Column({ nullable: true })
     // don't send to client
     emailVerificationTokenOnLoginExpiresAt: Date;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerifiedOnLoginAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     // don't send to client
     mobileVerificationTokenOnLogin: string;
+
     @Column({ nullable: true })
     // don't send to client
     mobileVerificationTokenOnLoginExpiresAt: Date;
+
     @Column({ type: "varchar", nullable: true })
     @Expose()
     customPayload: string;
+
     @ManyToMany(() => RoleMetadata, roleMetadata => roleMetadata.users, { cascade: true })
     @JoinTable()
     @Expose()
     roles: RoleMetadata[];
+
     @OneToMany(() => UserViewMetadata, userViewMetadata => userViewMetadata.user, { cascade: true })
     // don't send to client
     userViewMetadata: UserViewMetadata[];
+
     // dont send to client
     @Column({ type: "varchar", default: "bcrypt" })
     passwordScheme: string;
+
     // dont send to client
     @Column({ type: "int", default: 1 })
     passwordSchemeVersion: number;
+
     // dont send to client
     @Column({ nullable: true })
     rehashedAt: Date;
+
     // dont send to client
     @Column({ type: "int", default: 0 })
     failedLoginAttempts: number = 0;
+
     @Expose()
     _media: any;
+
 }

package/src/entities/view-metadata.entity.ts

@@ -1,5 +1,6 @@
 import { CommonEntity } from "src/entities/common.entity"
 import { Entity, Column, ManyToOne, Index, JoinColumn, OneToMany } from "typeorm";
+import { getColumnType } from 'src/helpers/typeorm-db-helper';
 import { ModuleMetadata } from 'src/entities/module-metadata.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { UserViewMetadata } from 'src/entities/user-view-metadata.entity'
@@ -16,9 +17,11 @@ export class ViewMetadata extends CommonEntity {
     @Column({ name: "type", type: "varchar" })
     type: string;
 
+    //TODO: To make this truly cross db compatible, we should avoid setting a db type
     @Column({ name: "context", type: "text" })
     context: any = "{}";
 
+    //TODO: To make this truly cross db compatible, we should avoid setting a db type
     @Column({ name: "layout", type: "text" })
     layout: any;
 

package/src/helpers/bootstrap.helper.ts

@@ -0,0 +1,222 @@
+import { ValidationPipe } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import { NextFunction, Request, Response } from 'express';
+import helmet from 'helmet';
+import qs from 'qs';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { WINSTON_MODULE_NEST_PROVIDER } from 'nest-winston';
+import { CommandFactory } from 'nest-commander';
+import { WrapResponseInterceptor } from '../interceptors/wrap-response.interceptor';
+import { buildDefaultCorsOptions } from './cors.helper';
+import { buildDefaultSecurityHeaderOptions, buildPermissionsPolicyHeader, PermissionsPolicyConfig } from './security.helper';
+import { parseBooleanEnv } from './environment.helper';
+
+// ---- Shared process handlers ----
+
+function registerGlobalProcessHandlers() {
+  process.on('unhandledRejection', (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  });
+
+  process.on('uncaughtException', (err) => {
+    console.error('Uncaught Exception thrown:', err);
+  });
+
+  // Suppress pg deprecation warning caused by TypeORM's internal query scheduling
+  process.on('warning', (warning) => {
+    if (warning.name === 'DeprecationWarning' && (warning.message.includes('client.query()') || warning.message.includes('punycode'))) {
+      return;
+    }
+    console.warn(warning);
+  });
+}
+
+// ---- HTTP server bootstrap ----
+
+export interface SolidSwaggerOptions {
+  title?: string;
+  description?: string;
+  version?: string;
+}
+
+export interface SolidBootstrapOptions {
+  /** Global API prefix. Defaults to 'api'. Set to '' to disable. */
+  globalPrefix?: string;
+  /** Swagger configuration. Set to false to disable Swagger entirely. */
+  swagger?: SolidSwaggerOptions | false;
+  /** Permissions-Policy header overrides (merged with defaults). */
+  permissionsPolicyOverrides?: Partial<PermissionsPolicyConfig>;
+}
+
+/**
+ * Bootstraps a SolidX NestJS HTTP application with sensible defaults:
+ * security headers, CORS, Winston logger, ValidationPipe,
+ * WrapResponseInterceptor, qs deep query parsing, Swagger, and the
+ * pg BIGINT type parser.
+ *
+ * @example
+ * // main.ts
+ * bootstrapSolidApp(() => AppModule.forRoot(), {
+ *   swagger: { title: 'My API', description: 'My API description' },
+ * });
+ */
+export async function bootstrapSolidApp(
+  appModuleFactory: () => Promise<any>,
+  options: SolidBootstrapOptions = {},
+): Promise<void> {
+  registerGlobalProcessHandlers();
+
+  const { globalPrefix = 'api', swagger = {}, permissionsPolicyOverrides = {} } = options;
+
+  const appModule = await appModuleFactory();
+  const app = await NestFactory.create(appModule);
+
+  const apiEnabled = parseBooleanEnv('API_ENABLED', true);
+
+  if (!apiEnabled) {
+    await app.init();
+    app
+      .get(WINSTON_MODULE_NEST_PROVIDER)
+      .log('API server disabled via API_ENABLED=false. Skipping HTTP listen.', 'Bootstrap');
+    return;
+  }
+
+  // Health check at root path
+  const server = app.getHttpAdapter().getInstance();
+  server.get('/', (_req, res) => res.status(200).send('SOLID OK'));
+
+  // Security headers
+  app.use(helmet(buildDefaultSecurityHeaderOptions()));
+
+  // Permissions-Policy header
+  app.use((_req: Request, res: Response, next: NextFunction) => {
+    res.setHeader('Permissions-Policy', buildPermissionsPolicyHeader(permissionsPolicyOverrides));
+    next();
+  });
+
+  // Winston logger
+  app.useLogger(app.get(WINSTON_MODULE_NEST_PROVIDER));
+
+  const port = process.env.PORT || 3000;
+
+  if (globalPrefix) {
+    app.setGlobalPrefix(globalPrefix);
+  }
+
+  // qs-based deep query parsing (dot notation, nested objects, arrays)
+  app.use((req: Request, _res: Response, next: NextFunction) => {
+    if (req.query) {
+      req.query = qs.parse(req.url.split('?')[1], {
+        allowDots: true,
+        depth: 20,
+        arrayLimit: 100,
+      });
+    }
+    next();
+  });
+
+  // Global ValidationPipe
+  app.useGlobalPipes(
+    new ValidationPipe({
+      transform: true,
+      transformOptions: { enableImplicitConversion: true },
+    }),
+  );
+
+  // Swagger
+  if (swagger !== false) {
+    const { title = 'Solid Starters', description = 'Solid Starters API', version = '1.0' } = swagger;
+    const swaggerConfig = new DocumentBuilder()
+      .setTitle(title)
+      .setDescription(description)
+      .setVersion(version)
+      .setExternalDoc('Postman Collection', '/docs-json')
+      .addBearerAuth(
+        {
+          description: 'Please enter token in following format: Bearer <JWT>',
+          name: 'Authorization',
+          bearerFormat: 'Bearer',
+          scheme: 'Bearer',
+          type: 'http',
+          in: 'Header',
+        },
+        'jwt',
+      )
+      .build();
+    const document = SwaggerModule.createDocument(app, swaggerConfig);
+    SwaggerModule.setup('/docs', app, document);
+  }
+
+  // Global interceptor
+  app.useGlobalInterceptors(new WrapResponseInterceptor());
+
+  // CORS
+  app.enableCors(buildDefaultCorsOptions());
+
+  // Fix pg returning BIGINT columns as strings
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const types = require('pg').types;
+  types.setTypeParser(types.builtins.INT8, (val: string) => parseInt(val));
+
+  await app.listen(port);
+}
+
+// ---- CLI bootstrap ----
+
+/**
+ * Bootstraps a SolidX NestJS CLI application using nest-commander.
+ * Handles verbose flag stripping, project root validation, and clean process exit.
+ *
+ * @example
+ * // main-cli.ts
+ * #!/usr/bin/env node
+ * import { bootstrapSolidCli } from '@solidxai/core';
+ * import { AppModule } from './app.module';
+ *
+ * bootstrapSolidCli(() => AppModule.forRoot());
+ */
+export async function bootstrapSolidCli(
+  appModuleFactory: () => Promise<any>,
+): Promise<void> {
+  registerGlobalProcessHandlers();
+
+  process.on('exit', (code) => {
+    if (code !== 0) {
+      console.error(`Exiting with error status code: ${code}`);
+    }
+  });
+
+  // Validate that cwd is a valid Solid API project
+  const packageJsonPath = resolve(process.cwd(), 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    console.error('Does not seem to be a valid solid-api project.');
+    console.error('Exit reason: missing package.json in the current directory.');
+    process.exit(1);
+  }
+
+  // Strip --verbose / -v before nest-commander processes argv
+  const showLogs = process.argv.includes('--verbose') || process.argv.includes('-v');
+  for (const flag of ['--verbose', '-v']) {
+    const idx = process.argv.indexOf(flag);
+    if (idx !== -1) process.argv.splice(idx, 1);
+  }
+
+  const appModule = await appModuleFactory();
+  process.env.SOLID_CLI_RUNNING = 'true';
+
+  // @ts-ignore
+  const app = await CommandFactory.createWithoutRunning(appModule, {
+    logger: showLogs ? ['debug', 'error', 'fatal', 'log', 'verbose', 'warn'] : false,
+  });
+
+  try {
+    await CommandFactory.runApplication(app);
+  } catch (e) {
+    console.error('CLI exited abruptly due to an error:', e);
+    process.exit(1);
+  }
+
+  process.exit(0);
+}

package/src/helpers/cache.helper.ts

@@ -0,0 +1,5 @@
+export function shouldUseCache(): boolean {
+  const env = (process.env.ENV ?? process.env.NODE_ENV ?? '').toLowerCase();
+  return env === 'prod' || env === 'production';
+}
+

package/src/helpers/cors.helper.ts

@@ -1,8 +1,12 @@
+import { Logger } from '@nestjs/common';
 import { CorsOptions } from 'cors';
 
+const logger = new Logger('CorsHelper');
+
 /** Build CorsOptions from env; supports wildcards like https://*.example.com */
 export function buildDefaultCorsOptions(): CorsOptions {
   const rawOrigins = process.env.SECURITY_CORS_ORIGINS ?? '*';
+  logger.log(`CORS allowed origins: ${rawOrigins}`);
 
   const allowed = rawOrigins.split(',').map(s => s.trim()).filter(Boolean);
 
@@ -18,17 +22,33 @@ export function buildDefaultCorsOptions(): CorsOptions {
   };
 
   const matchers = allowed.map(patternToRegex);
-  const isAllowed = (origin: string) =>
-    matchers.length > 0 && matchers.some(rx => rx.test(origin));
+  logger.log(`CORS regexes: ${matchers.map(r => r.toString()).join(', ')}`);
 
   return {
     origin: (origin, cb) => {
-      if (!origin) return cb(null, true);           // allow no-origin (CLI/mobile/internal)
-      if (isAllowed(origin)) return cb(null, true);
-      return cb(new Error(`Origin ${origin} not allowed by CORS`), false);
+      if (!origin) {
+        logger.debug('CORS origin callback skipped regex evaluation because origin was empty');
+        // allow no-origin (CLI/mobile/internal)
+        return cb(null, true);
+      }
+
+      const matchingRegex = matchers.find(rx => rx.test(origin));
+      if (matchingRegex) {
+        logger.debug(`CORS origin matched: origin=${origin}; regex=${matchingRegex.toString()}`);
+        return cb(null, true);
+      }
+
+      logger.debug(`CORS origin did not match any regex: origin=${origin}; regexes=${matchers.map(r => r.toString()).join(', ')}`);
+      return cb(new Error(`Origin ${origin} not allowed by CORS. Allowed origins: ${allowed.join(', ')}`), false);
     },
     methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
     allowedHeaders: ['Content-Type', 'Authorization'],
     credentials: true,
   };
-}
+}
+
+
+// [2026-04-07T08:27:19.943Z] INFO: CORS allowed origins: leadyatra.indusindnipponlife.com
+// [2026-04-07T08:27:19.944Z] INFO: CORS regexes: /^https?:\/\/leadyatra\.indusindnipponlife\.com(?::\d+)?$/i
+// [2026-04-07T08:27:19.947Z] DEBUG: Mounting ClsMiddleware to *
+// [2026-04-07T08:27:19.950Z] INFO: CityMasterController {/api/city-master}:

package/src/helpers/field-crud-managers/SelectionDynamicFieldCrudManager.ts

@@ -7,7 +7,7 @@ export interface SelectionDynamicFieldOptions {
     selectionDynamicProvider: string;
     selectionValueType: SelectionValueType;
     required: boolean | undefined | null;
-    selectionDynamicProviderCtxt: any;
+    selectionDynamicProviderCtxt: ISelectionProviderContext;
     fieldName: string;
     discoveryService: DiscoveryService;
     isMultiSelect: boolean | undefined | null;
@@ -85,8 +85,11 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
     private async applyFormatValidations(fieldValue: any): Promise<ValidationError[]> {
         const errors: ValidationError[] = [];
         !this.isValidSelectionValueType(fieldValue, this.options.selectionValueType) ? errors.push({ field: this.options.fieldName, error: 'Field value type is invalid' }) : "no errors";
-        const _isValidSelectionValue = await this.isValidSelectionValue(fieldValue, this.options.selectionDynamicProvider)
-        !_isValidSelectionValue ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        const ctxt = this.options.selectionDynamicProviderCtxt;
+        if (ctxt.validateOnSave !== false) {
+            const _isValidSelectionValue = await this.isValidSelectionValue(fieldValue, this.options.selectionDynamicProvider, ctxt);
+            !_isValidSelectionValue ? errors.push({ field: this.options.fieldName, error: 'Field value is invalid' }) : "no errors";
+        }
         return errors;
     }
 
@@ -106,11 +109,11 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
         }
     }
 
-    private async isValidSelectionValue(fieldValue: any, selectionDynamicProvider: string): Promise<boolean> {
+    private async isValidSelectionValue(fieldValue: any, selectionDynamicProvider: string, ctxt: ISelectionProviderContext): Promise<boolean> {
         const providerInstance = this.providerInstance<any>(selectionDynamicProvider);
         try {
             // Use the value method first
-            const valueOption = await providerInstance.value(fieldValue, JSON.parse(this.options.selectionDynamicProviderCtxt));
+            const valueOption = await providerInstance.value(fieldValue, ctxt);
             if (valueOption && valueOption.value === fieldValue) {
                 return true;
             }
@@ -118,7 +121,7 @@ export class SelectionDynamicFieldCrudManager implements FieldCrudManager {
         }
         catch (error) {
             // Use the values method as a fallback, if the value method is not implemented
-            const values = await providerInstance.values('', JSON.parse(this.options.selectionDynamicProviderCtxt));
+            const values = await providerInstance.values('', ctxt);
             const isValid = values.some(v => v.value === fieldValue);
             return isValid;
         }

package/src/helpers/solid-registry.ts

@@ -5,12 +5,8 @@ import { CommonEntity } from 'src/entities/common.entity';
 import { Locale } from 'src/entities/locale.entity';
 import { SecurityRule } from 'src/entities/security-rule.entity';
 import { IScheduledJob } from 'src/services/scheduled-jobs/scheduled-job.interface';
-import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule, ISettingsProvider, SettingDefinition } from "../interfaces";
-import { DatasourceType } from 'src/dtos/create-model-metadata.dto';
+import { IDashboardQuestionDataProvider, IDashboardVariableSelectionProvider, IErrorCodeProvider, ISecurityRuleConfigProvider, ISelectionProvider, ISelectionProviderContext, ISolidDatabaseModule } from "../interfaces";
 import { ObjectLiteral } from 'typeorm';
-import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata';
-import { RelationMetadata } from 'typeorm/metadata/RelationMetadata';
-import { Setting } from 'src/entities/setting.entity';
 
 type ControllerMetadata = {
   name: string;
@@ -86,6 +82,7 @@ export class SolidRegistry {
   private securityRuleConfigProviders: Set<InstanceWrapper> = new Set();
   private errorCodeProviders: Set<InstanceWrapper> = new Set();
   private settingsProviders: Set<InstanceWrapper> = new Set();
+  private auditableModels: Set<string> = new Set();
 
   registerErrorCodeProvider(errorCodeProvider: InstanceWrapper): void {
     this.errorCodeProviders.add(errorCodeProvider);
@@ -342,6 +339,14 @@ export class SolidRegistry {
     });
   }
 
+  registerAuditableModels(models: Set<string>): void {
+    this.auditableModels = models;
+  }
+
+  isAuditableModel(modelSingularName: string): boolean {
+    return this.auditableModels.has(modelSingularName.toLowerCase());
+  }
+
   getCommonEntityKeys(): (keyof CommonEntity | 'createdBy' | 'updatedBy')[] {
     return ['id', 'createdAt', 'updatedAt', 'deletedAt', 'createdBy', 'updatedBy', 'deletedTracker', 'localeName', 'defaultEntityLocaleId', 'publishedAt'];
     // return Reflect.getMetadataKeys(CommonEntity.prototype) as (keyof CommonEntity)[];

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

@@ -9,6 +9,29 @@ const LONG_TEXT_MAP: Record<DatasourceType, ColumnOptions> = {
     [DatasourceType.oracle]: { type: "clob" },
 };
 
+// For simple-json columns that may contain large payloads: on MySQL/MariaDB the default
+// TEXT backing store is limited to 64 KB, so we override the type to longtext and supply
+// an explicit JSON transformer so TypeORM still serialises/deserialises correctly.
+const SIMPLE_JSON_LARGE_TEXT_MAP: Record<DatasourceType, ColumnOptions> = {
+    [DatasourceType.postgres]: {},
+    [DatasourceType.mssql]: {},
+    [DatasourceType.mysql]: {
+        type: "longtext",
+        transformer: {
+            to: (value: any) => (value !== undefined && value !== null ? JSON.stringify(value) : value),
+            from: (value: any) => (value !== null && value !== undefined ? JSON.parse(value) : value),
+        },
+    },
+    [DatasourceType.mariadb]: {
+        type: "longtext",
+        transformer: {
+            to: (value: any) => (value !== undefined && value !== null ? JSON.stringify(value) : value),
+            from: (value: any) => (value !== null && value !== undefined ? JSON.parse(value) : value),
+        },
+    },
+    [DatasourceType.oracle]: { type: "clob" },
+};
+
 const solidCoreDbType: DatasourceType =
     Object.values(DatasourceType).includes(process.env.SOLID_CORE_DB_TYPE as DatasourceType)
         ? (process.env.SOLID_CORE_DB_TYPE as DatasourceType)
@@ -20,6 +43,9 @@ export function getColumnType(solidType: string): ColumnOptions {
         case "richText":
             return LONG_TEXT_MAP[solidCoreDbType];
 
+        case "simpleJsonLargeText":
+            return SIMPLE_JSON_LARGE_TEXT_MAP[solidCoreDbType];
+
         default:
             return {};
     }

package/src/index.ts

@@ -137,6 +137,7 @@ export * from './entities/user-activity-history.entity'
 export * from './entities/dashboard.entity'
 export * from './entities/dashboard-variable.entity'
 export * from './entities/dashboard-question.entity'
+export * from './entities/dashboard-layout.entity'
 export * from './entities/dashboard-question-sql-dataset-config.entity'
 export * from './entities/ai-interaction.entity'
 export * from './entities/model-sequence.entity'
@@ -175,7 +176,9 @@ export * from './helpers/field-crud-managers/SelectionDynamicFieldCrudManager' /
 export * from './helpers/field-crud-managers/SelectionStaticFieldCrudManager' //rename
 export * from './helpers/field-crud-managers/ShortTextFieldCrudManager' //rename
 export * from './helpers/field-crud-managers/UUIDFieldCrudManager' //rename
+export * from './helpers/bootstrap.helper'
 export * from './helpers/environment.helper'
+export * from './helpers/cache.helper'
 export * from './helpers/cors.helper'
 export * from './helpers/security.helper'
 export * from './helpers/model-metadata-helper.service'

package/src/interfaces.ts

@@ -111,6 +111,8 @@ export interface ISelectionProviderContext {
   limit: number;
   offset: number;
   formValues: Record<string, any>;
+  //Attribute to control the validation on creating the record
+  validateOnSave?: boolean;
   // query: string;
 }
 
@@ -136,12 +138,18 @@ export interface IMcpToolResponseHandler {
   apply(aiInteraction: AiInteraction);
 }
 
+export interface QuestionSqlDataProviderContext {
+    // questionSqlDatasetConfig: QuestionSqlDatasetConfig;
+    // questionId: number;
+    // question: Question;
+    expressions?: SqlExpression[]
+}
 export interface IDashboardQuestionDataProvider<TContext, TData> {
   help(): string;
 
   name(): string;
 
-  getData(question: DashboardQuestion, expressions?: SqlExpression[], ctxt?: TContext): Promise<TData[] | TData>;
+  getData(question: DashboardQuestion, ctxt?: TContext): Promise<TData[] | TData>;
 }
 
 /**
@@ -263,6 +271,7 @@ export interface QueuesModuleOptions {
   type: BrokerType;
   queueName: string;
   prefetch?: number;
+  persistToDatabase?: boolean;
 }
 
 export type MediaWithFullUrl = Media & {

package/src/jobs/chatter-queue-options.ts

@@ -1,6 +1,6 @@
 import { BrokerType } from "../interfaces";
 
-const QUEUE_NAME = 'solid_chatter_queue';
+const QUEUE_NAME = 'solid_chatter_queue_rabbitmq';
 
 export default {
     name: QUEUE_NAME,

package/src/jobs/chatter-queue-publisher.service.ts

@@ -7,21 +7,21 @@ import { MqMessageService } from '../services/mq-message.service';
 import { QueuesModuleOptions } from "../interfaces";
 
 
-export type ChatterEventType = 'insert' | 'update' | 'delete';
+export type AuditEventType = 'insert' | 'update' | 'delete';
 
-export interface ChatterMessagePayload {
-    eventType: ChatterEventType;
-    model: string;         // entity name
-    entityId: string;      // id string
-    occurredAt: string;    // ISO
-    before?: any;
-    after?: any;
-    diff?: string[];       // changed column names for updates
-    userId?: string | null;
+export interface AuditQueuePayload {
+    eventType: AuditEventType;
+    modelName: string;              // TypeORM entity class name (e.g. 'Order')
+    entityId: string | number | null;
+    occurredAt: string;             // ISO timestamp, captured at event time
+    after?: any;                    // entity state after operation (insert/update)
+    before?: any;                   // entity state before operation (update/delete)
+    updatedColumnNames?: string[];  // propertyNames of changed columns (update only)
+    userId?: number | null;         // active user captured at event time
 }
 
 @Injectable()
-export class ChatterQueuePublisher extends RabbitMqPublisher<any> {
+export class ChatterQueuePublisherRabbitmq extends RabbitMqPublisher<AuditQueuePayload> {
     constructor(
         protected readonly mqMessageService: MqMessageService,
         protected readonly mqMessageQueueService: MqMessageQueueService,