@solidxai/core 0.1.6-beta.24 → 0.1.6-beta.26

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/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/1.js

@@ -0,0 +1,6 @@
+1. Do i need to create a storeStreams method for aws service too?
+    - Handle later
+2. queues handling -> if queues is enabled by default, i.e triggerExport(exportTransactionEntity.id).
+    - startExport should either return the data or return the transaction id
+3. How to handle scenarios wherein, nested related exist.(do i need to only get the userkey)
+    - show the userKey

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/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,

package/src/subscribers/audit.subscriber.ts

@@ -1,22 +1,19 @@
-import { Injectable, Scope } from '@nestjs/common';
+import { Injectable, Logger, Scope } from '@nestjs/common';
 import { lowerFirst } from 'src/helpers/string.helper';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { DataSource, EntityMetadata, EntitySubscriberInterface, InsertEvent, RemoveEvent, UpdateEvent } from 'typeorm';
-import { ChatterMessageService } from '../services/chatter-message.service';
-
-
-type DeferredCall =
-    | { kind: 'insert'; args: Parameters<ChatterMessageService['postAuditMessageOnInsert']> }
-    | { kind: 'update'; args: Parameters<ChatterMessageService['postAuditMessageOnUpdate']> }
-    | { kind: 'delete'; args: Parameters<ChatterMessageService['postAuditMessageOnDelete']> };
+import { AuditQueuePayload } from 'src/jobs/chatter-queue-publisher.service';
+import { RequestContextService } from 'src/services/request-context.service';
+import { PublisherFactory } from 'src/services/queues/publisher-factory.service';
 
 @Injectable({scope: Scope.TRANSIENT})
-// @EventSubscriber()
 export class AuditSubscriber implements EntitySubscriberInterface {
+    private readonly logger = new Logger(AuditSubscriber.name);
     private dataSource: DataSource;
     constructor(
-        private readonly chatterMessageService: ChatterMessageService,
+        private readonly publisherFactory: PublisherFactory<AuditQueuePayload>,
         private readonly solidRegistry: SolidRegistry,
+        private readonly requestContextService: RequestContextService,
     ) { }
 
     bindToDataSource(dataSource: DataSource) {
@@ -25,12 +22,12 @@ export class AuditSubscriber implements EntitySubscriberInterface {
     }
 
     // Per-transaction buffer (auto-GC when queryRunner is gone)
-    private perTxn = new WeakMap<any, DeferredCall[]>();
+    private perTxn = new WeakMap<any, AuditQueuePayload[]>();
 
-    private enqueue(event: { queryRunner: any }, call: DeferredCall) {
+    private enqueue(event: { queryRunner: any }, payload: AuditQueuePayload) {
         const qr = event.queryRunner;
         const arr = this.perTxn.get(qr) ?? [];
-        arr.push(call);
+        arr.push(payload);
         this.perTxn.set(qr, arr);
     }
 
@@ -38,43 +35,48 @@ export class AuditSubscriber implements EntitySubscriberInterface {
         return this.solidRegistry.isAuditableModel(lowerFirst(metadata.name));
     }
 
+    private activeUserId(): number | null {
+        return this.requestContextService.getActiveUser()?.sub ?? null;
+    }
+
     async afterInsert(event: InsertEvent<any>) {
-        if (this.shouldTrackAudit(event.metadata)) {
-            // await this.chatterMessageService.postAuditMessageOnInsert(event.entity, event.metadata);
-            this.enqueue(event, {
-                kind: 'insert',
-                args: [event.entity, event.metadata] as Parameters<ChatterMessageService['postAuditMessageOnInsert']>,
-            });
-        }
+        if (!this.shouldTrackAudit(event.metadata)) return;
+        this.enqueue(event, {
+            eventType: 'insert',
+            modelName: event.metadata.name,
+            entityId: event.entity?.id ?? null,
+            occurredAt: new Date().toISOString(),
+            after: event.entity ?? null,
+            userId: this.activeUserId(),
+        });
     }
 
     async afterUpdate(event: UpdateEvent<any>) {
-        if (this.shouldTrackAudit(event.metadata)) {
-            // await this.chatterMessageService.postAuditMessageOnUpdate(event.entity, event.metadata, event.databaseEntity, event.updatedColumns || []);
-            this.enqueue(event, {
-                kind: 'update',
-                args: [
-                    event.entity, // entity (after)
-                    event.metadata,
-                    event.databaseEntity, // entity (before)
-                    event.updatedColumns ?? [],
-                ] as Parameters<ChatterMessageService['postAuditMessageOnUpdate']>,
-            });
-        }
+        if (!this.shouldTrackAudit(event.metadata)) return;
+        this.enqueue(event, {
+            eventType: 'update',
+            modelName: event.metadata.name,
+            entityId: event.entity?.id ?? null,
+            occurredAt: new Date().toISOString(),
+            after: event.entity ?? null,
+            // databaseEntity is only populated when the entity was fetched first (save() path).
+            // QueryBuilder update() leaves this undefined; postAuditMessageOnUpdate guards for it.
+            before: event.databaseEntity ?? null,
+            updatedColumnNames: (event.updatedColumns ?? []).map(c => c.propertyName),
+            userId: this.activeUserId(),
+        });
     }
 
     async afterRemove(event: RemoveEvent<any>) {
-        if (this.shouldTrackAudit(event.metadata)) {
-            // await this.chatterMessageService.postAuditMessageOnDelete(event.entity, event.metadata, event.databaseEntity);
-            this.enqueue(event, {
-                kind: 'delete',
-                args: [
-                    event.entity,
-                    event.metadata,
-                    event.databaseEntity,
-                ] as Parameters<ChatterMessageService['postAuditMessageOnDelete']>,
-            });
-        }
+        if (!this.shouldTrackAudit(event.metadata)) return;
+        this.enqueue(event, {
+            eventType: 'delete',
+            modelName: event.metadata.name,
+            entityId: event.databaseEntity?.id ?? null,
+            occurredAt: new Date().toISOString(),
+            before: event.databaseEntity,
+            userId: this.activeUserId(),
+        });
     }
 
     // --------- transaction lifecycle ----------
@@ -82,191 +84,24 @@ export class AuditSubscriber implements EntitySubscriberInterface {
         const batch = this.perTxn.get(event.queryRunner) ?? [];
         this.perTxn.delete(event.queryRunner);
 
-        // Now we’re OUTSIDE the DB transaction — safe to do I/O/DB writes inside chatter service.
-        for (const item of batch) {
-            try {
-                switch (item.kind) {
-                    case 'insert': await this.chatterMessageService.postAuditMessageOnInsert(...item.args); break;
-                    case 'update': await this.chatterMessageService.postAuditMessageOnUpdate(...item.args); break;
-                    case 'delete': await this.chatterMessageService.postAuditMessageOnDelete(...item.args); break;
-                }
-            } catch (e) {
-                // Best effort: log and continue; your core txn was already committed
-                // Optionally: send to a generic error logger/metric here
+        // Now outside the DB transaction — safe to publish to the queue.
+        // allSettled: publish in parallel; a single failure does not block the rest.
+        const results = await Promise.allSettled(
+            batch.map(payload => this.publisherFactory.publish({ payload }, 'ChatterQueuePublisher'))
+        );
+
+        results.forEach((result, i) => {
+            if (result.status === 'rejected') {
+                this.logger.error(
+                    `Failed to publish audit event for ${batch[i].modelName}#${batch[i].entityId}`,
+                    result.reason,
+                );
             }
-        }
+        });
     }
 
     afterTransactionRollback(event: { queryRunner: any }) {
-        // Drop buffered calls; the write never happened
+        // Drop buffered payloads; the write never happened.
         this.perTxn.delete(event.queryRunner);
     }
 }
-
-// import { DataSource, EntityMetadata, EntitySubscriberInterface, EventSubscriber, InsertEvent, RemoveEvent, UpdateEvent } from 'typeorm';
-// import { Injectable } from '@nestjs/common';
-// import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
-// import { Repository } from 'typeorm';
-// import { ModelMetadata } from '../entities/model-metadata.entity';
-// import { lowerFirst } from 'src/helpers/string.helper';
-// import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
-// import { ChatterMessagePayload } from 'src/jobs/chatter-queue-publisher.service';
-// import { RequestContextService } from 'src/services/request-context.service';
-// import { PublisherFactory } from 'src/services/queues/publisher-factory.service';
-
-// @EventSubscriber()
-// @Injectable()
-// export class AuditSubscriber implements EntitySubscriberInterface {
-//     private perTxn = new WeakMap<any, ChatterMessagePayload[]>();
-
-//     constructor(
-//         @InjectDataSource() private readonly dataSource: DataSource,
-//         @InjectRepository(ModelMetadata) private readonly modelMetadataRepo: Repository<ModelMetadata>,
-//         private readonly modelMetadataHelperService: ModelMetadataHelperService,
-//         private readonly requestContext: RequestContextService,
-//         private readonly publisherFactory: PublisherFactory<any>
-//     ) {
-//         this.dataSource.subscribers.push(this);
-//     }
-
-//     // --- small cache to avoid metadata queries on every row ---
-//     private modelCache = new Map<string, { enable: boolean; fields: Array<{ name: string; enableAuditTracking: boolean; type: string; relationType?: string }>; ts: number }>();
-//     private cacheTTLms = 60_000;
-
-//     private async shouldTrackAudit(entity: any, metadata: EntityMetadata): Promise<{ enable: boolean; auditFields?: string[] }> {
-//         const key = metadata.name;
-//         const now = Date.now();
-//         const cached = this.modelCache.get(key);
-//         if (cached && (now - cached.ts) < this.cacheTTLms) {
-//             if (!cached.enable) return { enable: false };
-//             const fields = cached.fields.filter(f =>
-//                 f.enableAuditTracking &&
-//                 !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(f.type) &&
-//                 !(f.type === 'relation' && f.relationType === 'one-to-many')
-//             );
-//             const present = fields.map(f => f.name).filter(n => entity?.[n] !== undefined);
-//             return { enable: present.length > 0, auditFields: present };
-//         }
-
-//         const model = await this.modelMetadataRepo.findOne({
-//             where: { singularName: lowerFirst(metadata.name) },
-//             relations: { fields: true, module: true },
-//         });
-//         const enable = !!model?.enableAuditTracking;
-//         const fields = model?.fields ?? [];
-//         this.modelCache.set(key, { enable, fields, ts: now });
-
-//         if (!enable) return { enable: false };
-//         const filtered = fields.filter(f =>
-//             f.enableAuditTracking &&
-//             !['mediaSingle', 'mediaMultiple', 'computed', 'richText', 'json'].includes(f.type) &&
-//             !(f.type === 'relation' && f.relationType === 'one-to-many')
-//         );
-//         const present = filtered.map(f => f.name).filter(n => entity?.[n] !== undefined);
-//         return { enable: present.length > 0, auditFields: present };
-//     }
-
-//     private push(event: { queryRunner: any }, msg: ChatterMessagePayload) {
-//         const arr = this.perTxn.get(event.queryRunner) ?? [];
-//         arr.push(msg);
-//         this.perTxn.set(event.queryRunner, arr);
-//     }
-
-//     async afterInsert(event: InsertEvent<any>) {
-//         if (!event.entity) return;
-//         const enable = await this.shouldTrackAudit(event.entity, event.metadata);
-//         if (!enable) return;
-
-//         const payload: ChatterMessagePayload = {
-//             eventType: 'insert',
-//             model: event.metadata.name,
-//             entityId: String(event.entity.id ?? event.entity.uuid ?? ''),
-//             occurredAt: new Date().toISOString(),
-//             after: this.safeCopy(event.entity),
-//             userId: this.getUserId(),
-//         };
-//         this.push(event, payload);
-//     }
-
-//     async afterUpdate(event: UpdateEvent<any>) {
-//         // Updated entity may be null if you used raw query; fall back to databaseEntity
-//         const current = event.entity ?? {};
-//         const before = event.databaseEntity ?? {};
-//         const { enable, auditFields } = await this.shouldTrackAudit(current, event.metadata);
-//         if (!enable) return;
-
-//         const changedCols = (event.updatedColumns || []).map(c => c.propertyName);
-//         const payload: ChatterMessagePayload = {
-//             eventType: 'update',
-//             model: event.metadata.name,
-//             entityId: String((current as any).id ?? (before as any).id ?? ''),
-//             occurredAt: new Date().toISOString(),
-//             before: this.pick(before, auditFields || changedCols),
-//             after: this.pick(current, auditFields || changedCols),
-//             diff: changedCols,
-//             userId: this.getUserId(),
-//         };
-//         this.push(event, payload);
-//     }
-
-//     async afterRemove(event: RemoveEvent<any>) {
-//         const base = event.entity ?? event.databaseEntity;
-//         if (!base) return;
-
-//         const { enable } = await this.shouldTrackAudit(base, event.metadata);
-//         if (!enable) return;
-
-//         const payload: ChatterMessagePayload = {
-//             eventType: 'delete',
-//             model: event.metadata.name,
-//             entityId: String((base as any).id ?? ''),
-//             occurredAt: new Date().toISOString(),
-//             before: this.safeCopy(base),
-//             userId: this.getUserId(),
-//         };
-//         this.push(event, payload);
-//     }
-
-//     // Publish AFTER the transaction commits -> no idle-in-transaction
-//     async afterTransactionCommit(event: { queryRunner: any }) {
-//         const batch = this.perTxn.get(event.queryRunner) ?? [];
-//         this.perTxn.delete(event.queryRunner);
-//         for (const msg of batch) {
-//             try {
-//                 await this.publisherFactory.publish({ payload: msg, parentEntity: msg.model, parentEntityId: msg.entityId }, 'ChatterQueuePublisher');
-//             } catch (err) {
-//                 // log + optionally send to a DLQ or retry queue
-//                 // do NOT throw; commit already happened
-//                 // your RabbitMqPublisher likely tracks failures in MqMessage tables anyway
-//             }
-//         }
-//     }
-
-//     afterTransactionRollback(event: { queryRunner: any }) {
-//         this.perTxn.delete(event.queryRunner);
-//     }
-
-//     // --- small helpers to keep payloads JSON-safe and small ---
-//     private safeCopy(obj: any) {
-//         try {
-//             return JSON.parse(JSON.stringify(obj));
-//         } catch {
-//             return {}; // strip circular refs
-//         }
-//     }
-
-//     private pick(obj: any, keys: string[]) {
-//         const out: any = {};
-//         for (const k of keys) out[k] = obj?.[k];
-//         return this.safeCopy(out);
-//     }
-
-//     private getUserId(): string | null {
-
-//         const activeUser = this.requestContext.getActiveUser();
-//         if (activeUser?.sub)
-//             return String(activeUser.sub);
-//     }
-
-
-// }