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

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

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

@@ -1,49 +0,0 @@
-    [2026-04-01T11:32:43.795Z] ERROR: [200 OK] POST /api/iam/otp/login/confirm - Connection terminated unexpectedly 59891ms
-    [2026-04-01T11:32:43.795Z] ERROR: [500 Internal Server Error] POST /api/iam/otp/login/confirm - Connection terminated unexpectedly [code=solidx-unknown-error]
-    [2026-04-01T11:32:43.795Z] ERROR: QueryFailedError: Connection terminated unexpectedly
-        at PostgresQueryRunner.query (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/driver/src/driver/postgres/PostgresQueryRunner.ts:325:19)
-        at process.processTicksAndRejections (node:internal/process/task_queues:105:5)
-        at async SelectQueryBuilder.loadRawResults (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:3868:25)
-        at async SelectQueryBuilder.executeEntitiesAndRawResults (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:3614:26)
-        at async SelectQueryBuilder.getRawAndEntities (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:1671:29)
-        at async SelectQueryBuilder.getOne (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:1698:25)
-        at async AuthenticationService.findUserForLogin (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@solidxai/core/src/services/authentication.service.ts:725:22)
-        at async AuthenticationService.otpConfirmLogin (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@solidxai/core/src/services/authentication.service.ts:821:22)
-    [2026-04-01T11:32:43.796Z] ERROR: [200 OK] POST /api/iam/otp/login/confirm - Connection terminated unexpectedly 59912ms
-    [2026-04-01T11:32:43.796Z] ERROR: [500 Internal Server Error] POST /api/iam/otp/login/confirm - Connection terminated unexpectedly [code=solidx-unknown-error]
-    [2026-04-01T11:32:43.796Z] ERROR: QueryFailedError: Connection terminated unexpectedly
-        at PostgresQueryRunner.query (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/driver/src/driver/postgres/PostgresQueryRunner.ts:325:19)
-        at process.processTicksAndRejections (node:internal/process/task_queues:105:5)
-        at async SelectQueryBuilder.loadRawResults (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:3868:25)
-        at async SelectQueryBuilder.executeEntitiesAndRawResults (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:3614:26)
-        at async SelectQueryBuilder.getRawAndEntities (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:1671:29)
-        at async SelectQueryBuilder.getOne (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:1698:25)
-        at async AuthenticationService.findUserForLogin (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@solidxai/core/src/services/authentication.service.ts:725:22)
-        at async AuthenticationService.otpConfirmLogin (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@solidxai/core/src/services/authentication.service.ts:821:22)
-    [2026-04-01T11:32:43.797Z] ERROR: [500 Internal Server Error] POST /api/lead - Connection terminated unexpectedly [code=solidx-unknown-error]
-    [2026-04-01T11:32:43.797Z] ERROR: QueryFailedError: Connection terminated unexpectedly
-        at PostgresQueryRunner.query (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/driver/src/driver/postgres/PostgresQueryRunner.ts:325:19)
-        at process.processTicksAndRejections (node:internal/process/task_queues:105:5)
-        at async SelectQueryBuilder.loadRawResults (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:3868:25)
-        at async SelectQueryBuilder.executeEntitiesAndRawResults (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:3614:26)
-        at async SelectQueryBuilder.getRawAndEntities (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:1671:29)
-        at async SelectQueryBuilder.getMany (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:1761:25)
-        at async AuthenticationGuard.canActivate (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@solidxai/core/src/guards/authentication.guard.ts:55:36)
-        at async GuardsConsumer.tryActivate (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@nestjs/core/guards/guards-consumer.js:16:17)
-        at async canActivateFn (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@nestjs/core/router/router-execution-context.js:135:33)
-        at async /opt/gitco/rnlic-venue-app/solid-api/node_modules/@nestjs/core/router/router-execution-context.js:42:31
-        at async /opt/gitco/rnlic-venue-app/solid-api/node_modules/@nestjs/core/router/router-proxy.js:9:17
-    [2026-04-01T11:32:43.798Z] ERROR: [500 Internal Server Error] POST /api/lead - Connection terminated unexpectedly [code=solidx-unknown-error]
-    [2026-04-01T11:32:43.798Z] ERROR: QueryFailedError: Connection terminated unexpectedly
-        at PostgresQueryRunner.query (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/driver/src/driver/postgres/PostgresQueryRunner.ts:325:19)
-        at process.processTicksAndRejections (node:internal/process/task_queues:105:5)
-        at async SelectQueryBuilder.loadRawResults (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:3868:25)
-        at async SelectQueryBuilder.executeEntitiesAndRawResults (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:3614:26)
-        at async SelectQueryBuilder.getRawAndEntities (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:1671:29)
-        at async SelectQueryBuilder.getMany (/opt/gitco/rnlic-venue-app/solid-api/node_modules/typeorm/query-builder/src/query-builder/SelectQueryBuilder.ts:1761:25)
-        at async AuthenticationGuard.canActivate (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@solidxai/core/src/guards/authentication.guard.ts:55:36)
-        at async GuardsConsumer.tryActivate (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@nestjs/core/guards/guards-consumer.js:16:17)
-        at async canActivateFn (/opt/gitco/rnlic-venue-app/solid-api/node_modules/@nestjs/core/router/router-execution-context.js:135:33)
-        at async /opt/gitco/rnlic-venue-app/solid-api/node_modules/@nestjs/core/router/router-execution-context.js:42:31
-        at async /opt/gitco/rnlic-venue-app/solid-api/node_modules/@nestjs/core/router/router-proxy.js:9:17
-    [2026-04-01T11:32:43.799Z] ERROR: [500 Internal Server Error] POST /api/lead - Connection terminated unexpectedly [code=solidx-unknown-error]