@solidxai/core 0.1.6 → 0.1.7

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';
@@ -133,6 +137,8 @@ import { ChatterMessageController } from './controllers/chatter-message.controll
 import { DashboardQuestionSqlDatasetConfigController } from './controllers/dashboard-question-sql-dataset-config.controller';
 import { DashboardQuestionController } from './controllers/dashboard-question.controller';
 import { DashboardVariableController } from './controllers/dashboard-variable.controller';
+import { DashboardLayoutController } from './controllers/dashboard-layout.controller';
+
 import { DashboardController } from './controllers/dashboard.controller';
 import { ExportTemplateController } from './controllers/export-template.controller';
 import { ExportTransactionController } from './controllers/export-transaction.controller';
@@ -156,6 +162,8 @@ import { ChatterMessage } from './entities/chatter-message.entity';
 import { DashboardQuestionSqlDatasetConfig } from './entities/dashboard-question-sql-dataset-config.entity';
 import { DashboardQuestion } from './entities/dashboard-question.entity';
 import { DashboardVariable } from './entities/dashboard-variable.entity';
+import { DashboardLayout } from './entities/dashboard-layout.entity';
+
 import { Dashboard } from './entities/dashboard.entity';
 import { ExportTemplate } from './entities/export-template.entity';
 import { ExportTransaction } from './entities/export-transaction.entity';
@@ -221,6 +229,8 @@ import { DashboardQuestionSqlDatasetConfigRepository } from './repository/dashbo
 import { DashboardQuestionRepository } from './repository/dashboard-question.repository';
 import { DashboardVariableRepository } from './repository/dashboard-variable.repository';
 import { DashboardRepository } from './repository/dashboard.repository';
+import { DashboardLayoutRepository } from './repository/dashboard-layout.repository';
+
 import { EmailTemplateRepository } from './repository/email-template.repository';
 import { ExportTemplateRepository } from './repository/export-template.repository';
 import { ExportTransactionRepository } from './repository/export-transaction.repository';
@@ -263,6 +273,8 @@ import { DashboardVariableSQLDynamicProvider } from './services/dashboard-select
 import { DasbhoardVariableTestDynamicProvider } from './services/dashboard-selection-providers/dashboard-variable-test-dynamic-provider.service';
 import { DashboardVariableService } from './services/dashboard-variable.service';
 import { DashboardService } from './services/dashboard.service';
+import { DashboardLayoutService } from './services/dashboard-layout.service';
+
 import { ExcelService } from './services/excel.service';
 import { ExportTemplateService } from './services/export-template.service';
 import { ExportTransactionService } from './services/export-transaction.service';
@@ -329,6 +341,7 @@ import { ImageEncodingService } from './helpers/image-encoding.helper';
 import { SolidMicroserviceAdapter } from './helpers/solid-microservice-adapter.service';
 import { InfoCommand } from './commands/info.command';
 import { ListOfRolesSelectionProvider } from './services/selection-providers/list-of-roles-selectionproviders.service';
+import { Entity } from 'typeorm';
 
 
 @Global()
@@ -343,6 +356,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
       DashboardQuestion,
       DashboardQuestionSqlDatasetConfig,
       DashboardVariable,
+      DashboardLayout,
       EmailAttachment,
       EmailTemplate,
       ExportTemplate,
@@ -414,6 +428,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     DashboardQuestionController,
     DashboardQuestionSqlDatasetConfigController,
     DashboardVariableController,
+    DashboardLayoutController,
     EmailTemplateController,
     ExportTemplateController,
     ExportTransactionController,
@@ -584,8 +599,10 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     TestQueuePublisher,
     TestQueueSubscriber,
 
-    // ChatterQueuePublisher,
-    // ChatterQueueSubscriber,
+    ChatterQueuePublisherRabbitmq,
+    ChatterQueueSubscriberRabbitmq,
+    ChatterQueuePublisherDatabase,
+    ChatterQueueSubscriberDatabase,
 
     TestQueuePublisherDatabase,
     TestQueueSubscriberDatabase,
@@ -638,6 +655,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     UserActivityHistoryService,
     DashboardService,
     DashboardVariableService,
+    DashboardLayoutService,
     DashboardQuestionService,
     DashboardVariableSQLDynamicProvider,
     DasbhoardVariableTestDynamicProvider,
@@ -682,6 +700,7 @@ import { ListOfRolesSelectionProvider } from './services/selection-providers/lis
     DashboardQuestionSqlDatasetConfigRepository,
     DashboardQuestionRepository,
     DashboardVariableRepository,
+    DashboardLayoutRepository,
     EmailTemplateRepository,
     ExportTemplateRepository,
     ExportTransactionRepository,

package/src/subscribers/audit.subscriber.ts

@@ -1,32 +1,20 @@
-import { forwardRef, Inject, Injectable, Scope } from '@nestjs/common';
-import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
+import { Injectable, Logger, Scope } from '@nestjs/common';
 import { lowerFirst } from 'src/helpers/string.helper';
-import { ModelMetadataRepository } from 'src/repository/model-metadata.repository';
+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(
-        // @InjectDataSource()
-        // private readonly dataSource: DataSource,
-        private readonly chatterMessageService: ChatterMessageService,
-        // @InjectRepository(ModelMetadata)
-        // private readonly modelMetadataRepo: Repository<ModelMetadata>,
-        @Inject(forwardRef(() => ModelMetadataRepository))
-        private readonly modelMetadataRepo: ModelMetadataRepository,
-        private readonly modelMetadataHelperService: ModelMetadataHelperService,
-    ) {
-        // this.dataSource.subscribers.push(this);
-    }
+        private readonly publisherFactory: PublisherFactory<AuditQueuePayload>,
+        private readonly solidRegistry: SolidRegistry,
+        private readonly requestContextService: RequestContextService,
+    ) { }
 
     bindToDataSource(dataSource: DataSource) {
         this.dataSource = dataSource;
@@ -34,90 +22,61 @@ 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);
     }
 
-    private async shouldTrackAudit(entity: any, metadata: EntityMetadata): Promise<boolean> {
-        const model = await this.modelMetadataRepo.findOne({
-            where: {
-                singularName: lowerFirst(metadata.name)
-            },
-            relations: {
-                fields: true,
-                module: true
-            }
-        });
-
-        if (!model || !model.enableAuditTracking) {
-            return false;
-        }
-
-        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')
-        );
-
-        if (auditFields.length === 0) {
-            return false;
-        }
-
-        // if (!entity) {
-        //     console.warn(`[AuditSubscriber] Skipping audit for ${metadata.name} – entity is undefined or null`);
-        //     return false;
-        // }
+    private shouldTrackAudit(metadata: EntityMetadata): boolean {
+        return this.solidRegistry.isAuditableModel(lowerFirst(metadata.name));
+    }
 
-        return entity && auditFields.some(field => {
-            const fieldValue = entity[field.name];
-            return fieldValue !== undefined && fieldValue !== null;
-        });
+    private activeUserId(): number | null {
+        return this.requestContextService.getActiveUser()?.sub ?? null;
     }
 
     async afterInsert(event: InsertEvent<any>) {
-        if (await this.shouldTrackAudit(event.entity, 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 (await this.shouldTrackAudit(event.entity, 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 (await this.shouldTrackAudit(event.entity, 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 ----------
@@ -125,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);
-//     }
-
-
-// }

package/src/subscribers/computed-entity-field.subscriber.ts

@@ -78,9 +78,9 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
             modelName
         );
         //TODO: We can add a feature i.e dependsOn, where we can check if the computed field depends on other computed fields and evaluate them first
-        await Promise.all(
-            computedFieldsTobeEvaluated.map(c => this.evaluateComputedField(this.attachContext(c, eventContext), entity, currentOperation))
-        )
+        for (const computedField of computedFieldsTobeEvaluated) {
+            await this.evaluateComputedField(this.attachContext(computedField, eventContext), entity, currentOperation);
+        }
     }
 
     private handleComputedFieldEvaluationJob(entity: any, currentOperation: ComputedFieldTriggerOperation, modelName: string, eventContext?: TypeOrmEventContext) {

package/src/subscribers/created-by-updated-by.subscriber.ts

@@ -1,11 +1,9 @@
 import { Injectable, Scope } from "@nestjs/common";
 import { InjectDataSource } from "@nestjs/typeorm";
-import { User } from "src/entities/user.entity";
-import { ActiveUserData } from "src/interfaces/active-user-data.interface";
 import { RequestContextService } from "src/services/request-context.service";
-import { DataSource, EntitySubscriberInterface, EventSubscriber, InsertEvent, UpdateEvent } from "typeorm";
+import { DataSource, EntitySubscriberInterface, InsertEvent, UpdateEvent } from "typeorm";
 
-@Injectable({scope: Scope.TRANSIENT})
+@Injectable({ scope: Scope.TRANSIENT })
 // @EventSubscriber()
 export class CreatedByUpdatedBySubscriber implements EntitySubscriberInterface {
     private dataSource: DataSource;
@@ -30,7 +28,7 @@ export class CreatedByUpdatedBySubscriber implements EntitySubscriberInterface {
         await this.stampUserField(event, false);
     }
 
-    private async stampUserField(event: InsertEvent<any> | UpdateEvent<any>, isInsert: boolean){
+    private async stampUserField(event: InsertEvent<any> | UpdateEvent<any>, isInsert: boolean) {
         if (!event.entity) {
             return;
         }
@@ -40,21 +38,29 @@ export class CreatedByUpdatedBySubscriber implements EntitySubscriberInterface {
             return;
         }
 
-        const loadedUser = await this.loadUser(activeUserOrUndefined as unknown as ActiveUserData);
+        // const loadedUser = await this.loadUser(activeUserOrUndefined as unknown as ActiveUserData);
+        // if (isInsert) {
+        //     event.entity.createdBy = loadedUser?.id;
+        //     event.entity.updatedBy = loadedUser?.id; // For insert, we set both createdBy and updatedBy to the same user
+        // }
+        // else {
+        //     event.entity.updatedBy = loadedUser?.id;
+        // }
+
         if (isInsert) {
-            event.entity.createdBy = loadedUser?.id;
-            event.entity.updatedBy = loadedUser?.id; // For insert, we set both createdBy and updatedBy to the same user
+            event.entity.createdBy = activeUserOrUndefined?.sub;
+            event.entity.updatedBy = activeUserOrUndefined?.sub; // For insert, we set both createdBy and updatedBy to the same user
         }
         else {
-            event.entity.updatedBy = loadedUser?.id;
+            event.entity.updatedBy = activeUserOrUndefined?.sub;
         }
     }
 
-    private async loadUser(activeUser: ActiveUserData): Promise<User> {
-        const userRepo = this.defaultDataSource.getRepository(User); // Assuming 'User' is the entity name for users in your application
-        const loadedUser = await userRepo.findOne({
-            where: { id: activeUser.sub }, // Assuming 'sub' is the user ID in the JWT token
-        });
-        return loadedUser;;
-    }
+    // private async loadUser(activeUser: ActiveUserData): Promise<User> {
+    //     const userRepo = this.defaultDataSource.getRepository(User); // Assuming 'User' is the entity name for users in your application
+    //     const loadedUser = await userRepo.findOne({
+    //         where: { id: activeUser.sub }, // Assuming 'sub' is the user ID in the JWT token
+    //     });
+    //     return loadedUser;;
+    // }
 }

package/src/transformers/typeorm/local-date-time-transformer.ts

@@ -20,59 +20,67 @@ function dateToUtcComponentString(d: Date): string {
     const ss = pad(d.getUTCSeconds());
     const ms = pad(d.getUTCMilliseconds(), 3);
 
-    // A “naive” timestamp string representing the DB wall-clock components
+    // A "naive" timestamp string representing the DB wall-clock components
     return `${yyyy}-${mm}-${dd} ${hh}:${mi}:${ss}.${ms}`;
 }
 
-export const LocalDateTimeTransformer: ValueTransformer & { utc: ValueTransformer } = {
-    // DB → Entity
-    from(value: Date | string | null | undefined): Date | null | undefined {
+function getWallClockConfig(): { tz: string; wallTimeMode: boolean } {
+    return {
+        tz: process.env.SOLIDX_WALL_TIME_TIMEZONE || process.env.SOLIDX_TIMEZONE || "UTC",
+        wallTimeMode: (process.env.SOLIDX_TIME_STORED_AS_WALL_TIME || "").toLowerCase() === "true",
+    };
+}
+
+/**
+ * Returns a dayjs instance positioned at the wall-clock time for the given Date.
+ * - Wall-clock mode ON:  dayjs in the configured timezone (components = wall-clock components)
+ * - Wall-clock mode OFF: dayjs in UTC
+ * Counterpart to serializeDate — use this to format/display a date value correctly.
+ */
+export function parseDate(date: Date): dayjs.Dayjs {
+    const { tz, wallTimeMode } = getWallClockConfig();
+    if (!wallTimeMode) return dayjs.utc(date);
+    return dayjs(date).tz(tz);
+}
 
-        const SOLIDX_WALL_TIME_TZ = process.env.SOLIDX_WALL_TIME_TIMEZONE || process.env.SOLIDX_TIMEZONE || "UTC";
-        const SOLIDX_TIME_STORED_AS_WALL_TIME = (process.env.SOLIDX_TIME_STORED_AS_WALL_TIME || "").toLowerCase() === "true";
+/**
+ * Converts a Date to a string for storage in plain text columns (e.g. audit values).
+ * - Wall-clock mode ON:  "YYYY-MM-DD HH:mm:ss.SSS" in the configured timezone (no Z suffix)
+ * - Wall-clock mode OFF: ISO 8601 UTC string with Z suffix
+ * The presence/absence of the Z suffix lets consumers distinguish the two cases.
+ */
+export function serializeDate(date: Date): string {
+    const { wallTimeMode } = getWallClockConfig();
+    if (!wallTimeMode) return date.toISOString();
+    return parseDate(date).format("YYYY-MM-DD HH:mm:ss.SSS");
+}
 
-        // critical... super important to return undefined here 
+export const LocalDateTimeTransformer: ValueTransformer = {
+    // DB -> Entity
+    from(value: Date | string | null | undefined): Date | null | undefined {
+        // critical... super important to return undefined here
         if (value === undefined) return undefined;
         if (value === null) return null;
 
-        if (!SOLIDX_TIME_STORED_AS_WALL_TIME) {
+        const { tz, wallTimeMode } = getWallClockConfig();
+
+        if (!wallTimeMode) {
             return dayjs(value).toDate();
         }
 
         const naive = value instanceof Date ? dateToUtcComponentString(value) : String(value);
-        return dayjs.tz(naive, SOLIDX_WALL_TIME_TZ).utc().toDate();
+        return dayjs.tz(naive, tz).utc().toDate();
     },
 
-    // Entity → DB
+    // Entity -> DB
     to(value: Date | null | undefined): Date | null | undefined {
-
-        const SOLIDX_WALL_TIME_TZ = process.env.SOLIDX_WALL_TIME_TIMEZONE || process.env.SOLIDX_TIMEZONE || "UTC";
-        const SOLIDX_TIME_STORED_AS_WALL_TIME = (process.env.SOLIDX_TIME_STORED_AS_WALL_TIME || "").toLowerCase() === "true";
-
-        // critical... super important to return undefined here 
+        // critical... super important to return undefined here
         if (value === undefined) return undefined;
         if (value === null) return null;
 
-        if (!SOLIDX_TIME_STORED_AS_WALL_TIME) {
-            return dayjs(value).toDate();
-        }
-
-        const wallTimeStr = dayjs(value).tz(SOLIDX_WALL_TIME_TZ).format("YYYY-MM-DD HH:mm:ss.SSS");
+        const wallTimeStr = serializeDate(value);
         return dayjs.utc(wallTimeStr).toDate();
     },
 
-    utc: {
-        from(value: Date | string | null | undefined): Date | null | undefined {
-            if (value === undefined) return undefined;
-            if (value === null) return null;
-            return dayjs(value).toDate();
-        },
-        to(value: Date | null | undefined): Date | null | undefined {
-            if (value === undefined) return undefined;
-            if (value === null) return null;
-            return dayjs(value).toDate();
-        }
-    }
 };
 
-export const UtcDateTimeTransformer = LocalDateTimeTransformer.utc;