@solidxai/core 0.1.6-beta.23 → 0.1.6-beta.25

package/src/entities/mq-message-queue.entity.ts

@@ -1,14 +1,14 @@
 import { CommonEntity } from "src/entities/common.entity"
-import {Entity, Column, OneToMany} from "typeorm";
+import { Entity, Column, OneToMany } from "typeorm";
 import { MqMessage } from 'src/entities/mq-message.entity'
 @Entity("ss_mq_message_queue")
-export class MqMessageQueue extends CommonEntity{
-@Column({ type: "varchar", unique: true })
-name: string;
+export class MqMessageQueue extends CommonEntity {
+    @Column({ type: "varchar", unique: true })
+    name: string;
 
-@Column({ type: "varchar", nullable: true })
-description: string;
+    @Column({ type: "varchar", nullable: true })
+    description: string;
 
-@OneToMany(() => MqMessage, mqMessage => mqMessage.mqMessageQueue, { cascade: true })
-mqMessages: MqMessage[];
+    @OneToMany(() => MqMessage, mqMessage => mqMessage.mqMessageQueue, { cascade: true })
+    mqMessages: MqMessage[];
 }

package/src/helpers/bootstrap.helper.ts

@@ -110,7 +110,7 @@ export async function bootstrapSolidApp(
     if (req.query) {
       req.query = qs.parse(req.url.split('?')[1], {
         allowDots: true,
-        depth: 10,
+        depth: 20,
         arrayLimit: 100,
       });
     }

package/src/helpers/cors.helper.ts

@@ -1,8 +1,10 @@
+import { log } from 'console';
 import { CorsOptions } from 'cors';
 
 /** Build CorsOptions from env; supports wildcards like https://*.example.com */
 export function buildDefaultCorsOptions(): CorsOptions {
   const rawOrigins = process.env.SECURITY_CORS_ORIGINS ?? '*';
+  log(`CORS allowed origins: ${rawOrigins}`);
 
   const allowed = rawOrigins.split(',').map(s => s.trim()).filter(Boolean);
 
@@ -18,6 +20,8 @@ export function buildDefaultCorsOptions(): CorsOptions {
   };
 
   const matchers = allowed.map(patternToRegex);
+  log(`CORS regexes: ${matchers.map(r => r.toString()).join(', ')}`);
+
   const isAllowed = (origin: string) =>
     matchers.length > 0 && matchers.some(rx => rx.test(origin));
 
@@ -25,7 +29,7 @@ export function buildDefaultCorsOptions(): CorsOptions {
     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);
+      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'],

package/src/interfaces.ts

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

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

@@ -6,12 +6,12 @@ import { MqMessageService } from '../services/mq-message.service';
 import { MqMessageQueueService } from '../services/mq-message-queue.service';
 import { QueuesModuleOptions } from "../interfaces";
 import chatterQueueOptions from './chatter-queue-options';
-import { ChatterMessagePayload } from './chatter-queue-publisher.service';
+import { AuditQueuePayload } from './chatter-queue-publisher.service';
 import { ChatterMessageService } from 'src/services/chatter-message.service';
 
 @Injectable()
-export class ChatterQueueSubscriber extends RabbitMqSubscriber<any> {
-    private readonly chatterQueueLogger = new Logger(ChatterQueueSubscriber.name);
+export class ChatterQueueSubscriberRabbitmq extends RabbitMqSubscriber<AuditQueuePayload> {
+    private readonly chatterLogger = new Logger(ChatterQueueSubscriberRabbitmq.name);
 
     constructor(
         readonly mqMessageService: MqMessageService,
@@ -27,19 +27,24 @@ export class ChatterQueueSubscriber extends RabbitMqSubscriber<any> {
         }
     }
 
-    async subscribe(message: QueueMessage<ChatterMessagePayload>) {
+    async subscribe(message: QueueMessage<AuditQueuePayload>) {
         const p = message.payload;
-        this.chatterQueueLogger.debug(`Audit event ${p.eventType} ${p.model}#${p.entityId}`);
+        this.chatterLogger.debug(`Audit event ${p.eventType} ${p.modelName}#${p.entityId}`);
 
         switch (p.eventType) {
             case 'insert':
-                await this.chatterMessageService.postAuditMessageOnInsert(p.after, { name: p.model } as any);
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, p.modelName);
                 break;
             case 'update':
-                await this.chatterMessageService.postAuditMessageOnUpdate(p.after, { name: p.model } as any, p.before, (p.diff || []).map(n => ({ propertyName: n })));
+                await this.chatterMessageService.postAuditMessageOnUpdate(
+                    p.after,
+                    p.modelName,
+                    p.before,
+                    (p.updatedColumnNames ?? []).map(n => ({ propertyName: n })),
+                );
                 break;
             case 'delete':
-                await this.chatterMessageService.postAuditMessageOnDelete(p.before, { name: p.model } as any, p.before);
+                await this.chatterMessageService.postAuditMessageOnDelete(p.modelName, p.before);
                 break;
         }
     }

package/src/jobs/computed-field-evaluation-queue-options.ts

@@ -7,4 +7,5 @@ export default {
     type: BrokerType.RabbitMQ,
     queueName: QUEUE_NAME,
     prefetch: 10,
+    persistToDatabase: false,
 };

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

@@ -0,0 +1,9 @@
+import { BrokerType } from "../../interfaces";
+
+const QUEUE_NAME = 'solid_chatter_queue_database';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.Database,
+    queueName: QUEUE_NAME,
+};

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

@@ -0,0 +1,24 @@
+import { Injectable } from '@nestjs/common';
+
+import { DatabasePublisher } from 'src/services/queues/database-publisher.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { AuditQueuePayload } from '../chatter-queue-publisher.service';
+import chatterQueueOptionsDatabase from './chatter-queue-options-database';
+
+@Injectable()
+export class ChatterQueuePublisherDatabase extends DatabasePublisher<AuditQueuePayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...chatterQueueOptionsDatabase
+        };
+    }
+}

package/src/jobs/database/chatter-queue-subscriber-database.service.ts

@@ -0,0 +1,53 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { PollerService } from 'src/services/poller.service';
+import { AuditQueuePayload } from '../chatter-queue-publisher.service';
+import { ChatterMessageService } from 'src/services/chatter-message.service';
+import chatterQueueOptionsDatabase from './chatter-queue-options-database';
+
+@Injectable()
+export class ChatterQueueSubscriberDatabase extends DatabaseSubscriber<AuditQueuePayload> {
+    private readonly chatterLogger = new Logger(ChatterQueueSubscriberDatabase.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        private readonly chatterMessageService: ChatterMessageService,
+    ) {
+        super(mqMessageService, mqMessageQueueService, poller);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...chatterQueueOptionsDatabase
+        };
+    }
+
+    async subscribe(message: QueueMessage<AuditQueuePayload>) {
+        const p = message.payload;
+        this.chatterLogger.debug(`Audit event ${p.eventType} ${p.modelName}#${p.entityId}`);
+
+        switch (p.eventType) {
+            case 'insert':
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, p.modelName);
+                break;
+            case 'update':
+                await this.chatterMessageService.postAuditMessageOnUpdate(
+                    p.after,
+                    p.modelName,
+                    p.before,
+                    (p.updatedColumnNames ?? []).map(n => ({ propertyName: n })),
+                );
+                break;
+            case 'delete':
+                await this.chatterMessageService.postAuditMessageOnDelete(p.modelName, p.before);
+                break;
+        }
+    }
+}

package/src/services/chatter-message.service.ts

@@ -90,13 +90,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         return savedMessage;
     }
 
-    async postAuditMessageOnInsert(entity: any, metadata: EntityMetadata, messageQueue: boolean = false) {
+    async postAuditMessageOnInsert(entity: any, modelName: string, messageQueue: boolean = false) {
         if (!entity) {
             return;
         }
         const model = await this.modelMetadataRepo.findOne({
             where: {
-                singularName: lowerFirst(metadata.name)
+                singularName: lowerFirst(modelName)
             },
             relations: {
                 fields: true,
@@ -152,13 +152,13 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         }
     }
 
-    async postAuditMessageOnUpdate(entity: any, metadata: EntityMetadata, databaseEntity: any, updatedColumns: any[] = [], messageQueue: boolean = false) {
+    async postAuditMessageOnUpdate(entity: any, modelName: string, databaseEntity: any, updatedColumns: any[] = [], messageQueue: boolean = false) {
         if (!databaseEntity || !entity) {
             return;
         }
         const model = await this.modelMetadataRepo.findOne({
             where: {
-                singularName: lowerFirst(metadata.name)
+                singularName: lowerFirst(modelName)
             },
             relations: {
                 fields: true,
@@ -204,6 +204,7 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
 
         const changedRelationFields = [];
         if (potentialRelationFields.length > 0) {
+            const metadata = this.entityManager.connection.entityMetadatas.find(m => m.name === modelName);
             const populatedOldEntity = await this.populateRelationFields(databaseEntity, potentialRelationFields, metadata);
 
             for (const field of potentialRelationFields) {
@@ -268,13 +269,12 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
         }
     }
 
-    async postAuditMessageOnDelete(entity: any, metadata: EntityMetadata, databaseEntity: any, messageQueue: boolean = false) {
+    async postAuditMessageOnDelete(modelName: string, databaseEntity: any, messageQueue: boolean = false) {
         const model = await this.modelMetadataRepo.findOne({
             where: {
-                singularName: lowerFirst(metadata.name)
+                singularName: lowerFirst(modelName)
             },
             relations: {
-                fields: true,
                 module: true,
                 userKeyField: true
             }
@@ -284,13 +284,29 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             return;
         }
 
+        const modelFields = await this.modelMetadataHelperService.loadFieldHierarchy(model.singularName);
+
+        const auditFields = modelFields.filter(field =>
+            field.enableAuditTracking &&
+            !['mediaSingle', 'mediaMultiple', 'richText', 'json'].includes(field.type) &&
+            !(field.type === 'relation' && field.relationType === 'one-to-many')
+        );
+
+        // Populate relation fields so display values (e.g. names) are resolvable.
+        // The related entities themselves still exist in the DB after a delete.
+        const relationFields = auditFields.filter(field => field.type === 'relation');
+        const entityMetadata = this.entityManager.connection.entityMetadatas.find(m => m.name === modelName);
+        const populatedEntity = relationFields.length > 0 && entityMetadata
+            ? await this.populateRelationFields(databaseEntity, relationFields, entityMetadata)
+            : { ...databaseEntity };
+
         const chatterMessage = new ChatterMessage();
         chatterMessage.messageType = CHATTER_MESSAGE_TYPE.AUDIT;
         chatterMessage.messageSubType = CHATTER_MESSAGE_SUBTYPE.AUDIT_DELETE;
         chatterMessage.coModelEntityId = databaseEntity?.id;
         chatterMessage.coModelName = model?.singularName;
         chatterMessage.modelDisplayName = model?.displayName;
-        chatterMessage.modelUserKey = entity[model?.userKeyField?.name];
+        chatterMessage.modelUserKey = databaseEntity[model?.userKeyField?.name];
         chatterMessage.messageBody = `${model?.displayName} deleted`;
 
         const activeUser = this.requestContextService.getActiveUser();
@@ -302,7 +318,23 @@ export class ChatterMessageService extends CRUDService<ChatterMessage> {
             chatterMessage.user = null;
         }
 
-        await this.repo.save(chatterMessage);
+        const savedMessage = await this.repo.save(chatterMessage);
+
+        for (const field of auditFields) {
+            const fieldValue = populatedEntity[field.name];
+            if (fieldValue !== undefined && fieldValue !== null && fieldValue !== '') {
+                const messageDetail = new ChatterMessageDetails();
+                messageDetail.chatterMessage = savedMessage;
+                messageDetail.fieldName = field.name;
+                messageDetail.fieldDisplayName = field.displayName;
+                messageDetail.fieldType = field.type;
+                messageDetail.oldValue = this.formatFieldValue(field, fieldValue);
+                messageDetail.oldValueDisplay = await this.formatFieldValueDisplay(field, fieldValue);
+                messageDetail.newValue = null;
+                messageDetail.newValueDisplay = null;
+                await this.chatterMessageDetailsRepo.save(messageDetail);
+            }
+        }
     }
 
     private formatFieldValue(field: any, value: any): string {

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);

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

@@ -56,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);
@@ -236,7 +240,9 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         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`;
@@ -254,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}`);
@@ -355,7 +362,9 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
      * Abstract method for message processing logic.
      */
     protected async processMessage(message: QueueMessage<T>, rawMessage, channel, queueName: string): Promise<void> {
-        await this.updateStatusInDatabase('started', message);
+        if (this.shouldPersistToDatabase()) {
+            await this.updateStatusInDatabase('started', message);
+        }
 
         // Capture the results of handling the task.
         const result = await this.subscribeWithTimeout(message, queueName);
@@ -364,7 +373,9 @@ export abstract class RabbitMqSubscriber<T> implements OnModuleInit, QueueSubscr
         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) : '');
+        }
 
     }
 

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/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';
@@ -595,8 +599,10 @@ import { Entity } from 'typeorm';
     TestQueuePublisher,
     TestQueueSubscriber,
 
-    // ChatterQueuePublisher,
-    // ChatterQueueSubscriber,
+    ChatterQueuePublisherRabbitmq,
+    ChatterQueueSubscriberRabbitmq,
+    ChatterQueuePublisherDatabase,
+    ChatterQueueSubscriberDatabase,
 
     TestQueuePublisherDatabase,
     TestQueueSubscriberDatabase,