@solidstarters/solid-core 1.2.163 → 1.2.165

package/src/solid-core.module.ts

@@ -94,6 +94,10 @@ import { SmsQueuePublisher } from './jobs/sms-publisher.service';
 import { SmsQueueSubscriber } from './jobs/sms-subscriber.service';
 import { TestQueuePublisher } from './jobs/test-queue-publisher.service';
 import { TestQueueSubscriber } from './jobs/test-queue-subscriber.service';
+
+// import { ChatterQueuePublisher } from './jobs/chatter-queue-publisher.service';
+// import { ChatterQueueSubscriber } from './jobs/chatter-queue-subscriber.service';
+
 import { Msg91WhatsappQueuePublisher } from './jobs/msg91-whatsapp-publisher.service';
 import { Msg91WhatsappQueueSubscriber } from './jobs/msg91-whatsapp-subscriber.service';
 import { UserRegistrationListener } from './listeners/user-registration.listener';
@@ -176,8 +180,8 @@ import { ModelMetadataHelperService } from './helpers/model-metadata-helper.serv
 import { ModuleMetadataHelperService } from './helpers/module-metadata-helper.service';
 import { ApiEmailQueuePublisherDatabase } from './jobs/database/api-email-publisher-database.service';
 import { ApiEmailQueueSubscriberDatabase } from './jobs/database/api-email-subscriber-database.service';
-import { ComputedFieldEvaluationPublisher } from './jobs/database/computed-field-evaluation-publisher.service';
-import { ComputedFieldEvaluationSubscriber } from './jobs/database/computed-field-evaluation-subscriber.service';
+import { ComputedFieldEvaluationPublisherDatabase } from './jobs/database/computed-field-evaluation-publisher-database.service';
+import { ComputedFieldEvaluationSubscriberDatabase } from './jobs/database/computed-field-evaluation-subscriber-database.service';
 import { SmtpEmailQueuePublisherDatabase } from './jobs/database/smtp-email-publisher-database.service';
 import { SmtpEmailQueueSubscriberDatabase } from './jobs/database/smtp-email-subscriber-database.service';
 import { GenerateCodePublisherDatabase } from './jobs/database/generate-code-publisher-database.service';
@@ -288,6 +292,14 @@ import { ErrorMapperService } from './helpers/error-mapper.service';
 import { IngestCommand } from './commands/ingest.command';
 import { R2RHelperService } from './services/genai/r2r-helper.service';
 import { IngestMetadataService } from './services/genai/ingest-metadata.service';
+import { ComputedFieldEvaluationPublisherRabbitmq } from './jobs/computed-field-evaluation-publisher.service';
+import { ComputedFieldEvaluationSubscriberRabbitmq } from './jobs/computed-field-evaluation-subscriber.service';
+import { GenerateCodePublisherRabbitmq } from './jobs/generate-code-publisher.service';
+import { GenerateCodeSubscriberRabbitmq } from './jobs/generate-code-subscriber.service';
+import { TriggerMcpClientPublisherRabbitmq } from './jobs/trigger-mcp-client-publisher.service';
+import { TriggerMcpClientSubscriberRabbitmq } from './jobs/trigger-mcp-client-subscriber.service';
+import { TwilioSmsQueuePublisherRabbitmq } from './jobs/twilio-sms-publisher.service';
+import { TwilioSmsQueueSubscriberRabbitmq } from './jobs/twilio-sms-subscriber.service';
 
 
 @Global()
@@ -368,10 +380,10 @@ import { IngestMetadataService } from './services/genai/ingest-metadata.service'
       inject: [ConfigService],
       useFactory: (configService: ConfigService) => ({
         throttlers: [
-        { name: 'short', ttl: seconds(10),  limit: 10 },
-        { name: 'login', ttl: seconds(10),  limit: 5  },
-        { name: 'burst', ttl: seconds(1),  limit: 100 },
-        { name: 'sustained', ttl: seconds(300), limit: 500 },
+          { name: 'short', ttl: seconds(10), limit: 10 },
+          { name: 'login', ttl: seconds(10), limit: 5 },
+          { name: 'burst', ttl: seconds(1), limit: 100 },
+          { name: 'sustained', ttl: seconds(300), limit: 500 },
         ],
         storage: isRedisConfigured(configService) ? new ThrottlerStorageRedisService(`redis://${configService.get<string>('REDIS_HOST')}:${configService.get<string>('REDIS_PORT')}`) : undefined,
       }),
@@ -494,6 +506,8 @@ import { IngestMetadataService } from './services/genai/ingest-metadata.service'
 
     TriggerMcpClientPublisherDatabase,
     TriggerMcpClientSubscriberDatabase,
+    TriggerMcpClientPublisherRabbitmq,
+    TriggerMcpClientSubscriberRabbitmq,
 
     SmtpEmailQueuePublisherRabbitmq,
     SmtpEmailQueueSubscriberRabbitmq,
@@ -509,6 +523,8 @@ import { IngestMetadataService } from './services/genai/ingest-metadata.service'
     SmsQueueSubscriberDatabase,
     TwilioSmsQueuePublisherDatabase,
     TwilioSmsQueueSubscriberDatabase,
+    TwilioSmsQueuePublisherRabbitmq,
+    TwilioSmsQueueSubscriberRabbitmq,
     OTPQueuePublisher,
     OTPQueueSubscriber,
     OTPQueuePublisherDatabase,
@@ -543,10 +559,17 @@ import { IngestMetadataService } from './services/genai/ingest-metadata.service'
     UserRegistrationListener,
     TestQueuePublisher,
     TestQueueSubscriber,
+
+    // ChatterQueuePublisher,
+    // ChatterQueueSubscriber,
+
     TestQueuePublisherDatabase,
     TestQueueSubscriberDatabase,
     GenerateCodePublisherDatabase,
     GenerateCodeSubscriberDatabase,
+    GenerateCodePublisherRabbitmq,
+    GenerateCodeSubscriberRabbitmq,
+    OTPQueuePublisher,
     MqMessageQueueService,
     MqMessageService,
     ScheduledJobService,
@@ -584,8 +607,10 @@ import { IngestMetadataService } from './services/genai/ingest-metadata.service'
     SystemFieldsSeederService,
     FieldMetadataRepository,
     ComputedEntityFieldSubscriber,
-    ComputedFieldEvaluationPublisher,
-    ComputedFieldEvaluationSubscriber,
+    ComputedFieldEvaluationPublisherDatabase,
+    ComputedFieldEvaluationSubscriberDatabase,
+    ComputedFieldEvaluationPublisherRabbitmq,
+    ComputedFieldEvaluationSubscriberRabbitmq,
     ConcatEntityComputedFieldProvider,
     UserActivityHistoryService,
     DashboardService,

package/src/subscribers/audit.subscriber.ts

@@ -6,6 +6,12 @@ import { ChatterMessageService } from '../services/chatter-message.service';
 import { lowerFirst } from 'src/helpers/string.helper';
 import { ModelMetadataHelperService } from 'src/helpers/model-metadata-helper.service';
 
+
+type DeferredCall =
+    | { kind: 'insert'; args: Parameters<ChatterMessageService['postAuditMessageOnInsert']> }
+    | { kind: 'update'; args: Parameters<ChatterMessageService['postAuditMessageOnUpdate']> }
+    | { kind: 'delete'; args: Parameters<ChatterMessageService['postAuditMessageOnDelete']> };
+
 @Injectable()
 @EventSubscriber()
 export class AuditSubscriber implements EntitySubscriberInterface {
@@ -16,11 +22,21 @@ export class AuditSubscriber implements EntitySubscriberInterface {
         private readonly chatterMessageService: ChatterMessageService,
         @InjectRepository(ModelMetadata)
         private readonly modelMetadataRepo: Repository<ModelMetadata>,
-        private readonly modelMetadataHelperService : ModelMetadataHelperService,
+        private readonly modelMetadataHelperService: ModelMetadataHelperService,
     ) {
         this.dataSource.subscribers.push(this);
     }
 
+    // Per-transaction buffer (auto-GC when queryRunner is gone)
+    private perTxn = new WeakMap<any, DeferredCall[]>();
+
+    private enqueue(event: { queryRunner: any }, call: DeferredCall) {
+        const qr = event.queryRunner;
+        const arr = this.perTxn.get(qr) ?? [];
+        arr.push(call);
+        this.perTxn.set(qr, arr);
+    }
+
     private async shouldTrackAudit(entity: any, metadata: EntityMetadata): Promise<boolean> {
         const model = await this.modelMetadataRepo.findOne({
             where: {
@@ -56,19 +72,233 @@ export class AuditSubscriber implements EntitySubscriberInterface {
 
     async afterInsert(event: InsertEvent<any>) {
         if (await this.shouldTrackAudit(event.entity, event.metadata)) {
-            await this.chatterMessageService.postAuditMessageOnInsert(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']>,
+            });
         }
     }
 
     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 || []);
+            // 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']>,
+            });
         }
     }
 
     async afterRemove(event: RemoveEvent<any>) {
         if (await this.shouldTrackAudit(event.entity, event.metadata)) {
-            await this.chatterMessageService.postAuditMessageOnDelete(event.entity, event.metadata, event.databaseEntity);
+            // 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']>,
+            });
+        }
+    }
+
+    // --------- transaction lifecycle ----------
+    async afterTransactionCommit(event: { queryRunner: any }) {
+        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
+            }
         }
     }
-} 
+
+    afterTransactionRollback(event: { queryRunner: any }) {
+        // Drop buffered calls; 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

@@ -4,7 +4,7 @@ import { InjectDataSource } from "@nestjs/typeorm";
 import { ComputedFieldTriggerOperation } from "src/dtos/create-field-metadata.dto";
 import { ComputedFieldMetadata, SolidRegistry } from "src/helpers/solid-registry";
 import { IEntityPreComputeFieldProvider } from "src/interfaces";
-import { ComputedFieldEvaluationPublisher } from "src/jobs/database/computed-field-evaluation-publisher.service";
+import { PublisherFactory } from "src/services/queues/publisher-factory.service";
 import { DataSource, EntitySubscriberInterface, EventSubscriber, InsertEvent, UpdateEvent } from "typeorm";
 
 // Create an interface i.e ComputedFieldEvaluationPayload which has same fields as the ComputedFieldMetadata and an additional field for the database entity
@@ -20,7 +20,8 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
         @InjectDataSource()
         private readonly dataSource: DataSource,
         private readonly solidRegistry: SolidRegistry,
-        private readonly computedFieldPublisher: ComputedFieldEvaluationPublisher,
+        private readonly publisherFactory: PublisherFactory<ComputedFieldEvaluationPayload>
+        // private readonly computedFieldPublisher: ComputedFieldEvaluationPublisherDatabase,
     ) {
         this.dataSource.subscribers.push(this);
     }
@@ -112,9 +113,10 @@ export class ComputedEntityFieldSubscriber implements EntitySubscriberInterface
             ...computedField,
             databaseEntity,
         };
-        this.computedFieldPublisher.publish({
-            payload
-        });
+        this.publisherFactory.publish({payload}, 'ComputedFieldEvaluationPublisher')
+        // this.computedFieldPublisher.publish({
+        //     payload
+        // });
     }
 
 }

package/dist/jobs/database/computed-field-evaluation-publisher.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-field-evaluation-publisher.service.d.ts","sourceRoot":"","sources":["../../../src/jobs/database/computed-field-evaluation-publisher.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AACnF,OAAO,EAAE,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AAGlG,qBACa,gCAAiC,SAAQ,iBAAiB,CAAC,8BAA8B,CAAC;IAE/F,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB;IACrD,SAAS,CAAC,QAAQ,CAAC,qBAAqB,EAAE,qBAAqB;gBAD5C,gBAAgB,EAAE,gBAAgB,EAClC,qBAAqB,EAAE,qBAAqB;IAKnE,OAAO,IAAI,mBAAmB;CAKjC"}

package/dist/jobs/database/computed-field-evaluation-publisher.service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-field-evaluation-publisher.service.js","sourceRoot":"","sources":["../../../src/jobs/database/computed-field-evaluation-publisher.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAA4C;AAE5C,sFAA8E;AAC9E,0EAAmE;AACnE,iGAAmF;AAEnF,wHAA4F;AAGrF,IAAM,gCAAgC,GAAtC,MAAM,gCAAiC,SAAQ,8CAAiD;IACnG,YACuB,gBAAkC,EAClC,qBAA4C;QAE/D,KAAK,CAAC,gBAAgB,EAAE,qBAAqB,CAAC,CAAC;QAH5B,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,0BAAqB,GAArB,qBAAqB,CAAuB;IAGnE,CAAC;IAED,OAAO;QACH,OAAO;YACH,GAAG,iDAAmC;SACzC,CAAC;IACN,CAAC;CACJ,CAAA;AAbY,4EAAgC;2CAAhC,gCAAgC;IAD5C,IAAA,mBAAU,GAAE;qCAGgC,qCAAgB;QACX,gDAAqB;GAH1D,gCAAgC,CAa5C","sourcesContent":["import { Injectable } from \"@nestjs/common\";\nimport { QueuesModuleOptions } from \"src/interfaces\";\nimport { MqMessageQueueService } from \"src/services/mq-message-queue.service\";\nimport { MqMessageService } from \"src/services/mq-message.service\";\nimport { DatabasePublisher } from \"src/services/queues/database-publisher.service\";\nimport { ComputedFieldEvaluationPayload } from \"src/subscribers/computed-entity-field.subscriber\";\nimport computedFieldEvaluationQueueOptions from \"./computed-field-evaluation-queue-options\";\n\n@Injectable()\nexport class ComputedFieldEvaluationPublisher extends DatabasePublisher<ComputedFieldEvaluationPayload> {\n    constructor(\n        protected readonly mqMessageService: MqMessageService,\n        protected readonly mqMessageQueueService: MqMessageQueueService,\n    ) {\n        super(mqMessageService, mqMessageQueueService);\n    }\n\n    options(): QueuesModuleOptions {\n        return {\n            ...computedFieldEvaluationQueueOptions\n        };\n    }\n}"]}

package/dist/jobs/database/computed-field-evaluation-queue-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-field-evaluation-queue-options.d.ts","sourceRoot":"","sources":["../../../src/jobs/database/computed-field-evaluation-queue-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;;;;;;AAI9C,wBAIE"}

package/dist/jobs/database/computed-field-evaluation-queue-options.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-field-evaluation-queue-options.js","sourceRoot":"","sources":["../../../src/jobs/database/computed-field-evaluation-queue-options.ts"],"names":[],"mappings":";;AAAA,iDAA8C;AAE9C,MAAM,UAAU,GAAG,iCAAiC,CAAC;AAErD,kBAAe;IACX,IAAI,EAAE,8BAA8B;IACpC,IAAI,EAAE,uBAAU,CAAC,QAAQ;IACzB,SAAS,EAAE,UAAU;CACxB,CAAC","sourcesContent":["import { BrokerType } from \"../../interfaces\";\n\nconst QUEUE_NAME = 'computed_field_evaluation_queue';\n\nexport default {\n    name: 'computedFieldEvaluationQueue',\n    type: BrokerType.Database,\n    queueName: QUEUE_NAME,\n};\n"]}

package/dist/jobs/database/computed-field-evaluation-subscriber.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-field-evaluation-subscriber.service.d.ts","sourceRoot":"","sources":["../../../src/jobs/database/computed-field-evaluation-subscriber.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAiE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACpH,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,EAAE,8BAA8B,EAAE,MAAM,kDAAkD,CAAC;AAElG,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D,qBACa,iCAAkC,SAAQ,kBAAkB,CAAC,8BAA8B,CAAC;IAEjG,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB;IAC3C,QAAQ,CAAC,qBAAqB,EAAE,qBAAqB;IACrD,QAAQ,CAAC,aAAa,EAAE,aAAa;IACrC,QAAQ,CAAC,MAAM,EAAE,aAAa;gBAHrB,gBAAgB,EAAE,gBAAgB,EAClC,qBAAqB,EAAE,qBAAqB,EAC5C,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,aAAa;IAKlC,OAAO,IAAI,mBAAmB;IAQxB,SAAS,CAAC,OAAO,EAAE,YAAY,CAAC,8BAA8B,CAAC;CAOxE"}

package/dist/jobs/database/computed-field-evaluation-subscriber.service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-field-evaluation-subscriber.service.js","sourceRoot":"","sources":["../../../src/jobs/database/computed-field-evaluation-subscriber.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAA4C;AAC5C,iEAA2D;AAG3D,sFAA8E;AAC9E,0EAAmE;AACnE,mGAAqF;AAErF,wHAA4F;AAC5F,kEAA4D;AAGrD,IAAM,iCAAiC,GAAvC,MAAM,iCAAkC,SAAQ,gDAAkD;IACrG,YACa,gBAAkC,EAClC,qBAA4C,EAC5C,aAA4B,EAC5B,MAAqB;QAE9B,KAAK,CAAC,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,CAAC,CAAC;QAL9C,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,kBAAa,GAAb,aAAa,CAAe;QAC5B,WAAM,GAAN,MAAM,CAAe;IAGlC,CAAC;IAED,OAAO;QACH,OAAO;YACH,GAAG,iDAAmC;SACzC,CAAA;IACL,CAAC;IAID,KAAK,CAAC,SAAS,CAAC,OAAqD;QACjE,MAAM,EAAE,cAAc,EAAE,GAAG,qBAAqB,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;QACrE,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,wBAAwB,CAAC,qBAAqB,CAAC,8BAA8B,CAAC,CAAC;QAEnH,MAAM,gBAAgB,GAAG,QAAQ,CAAC,QAAqD,CAAC;QACxF,MAAM,gBAAgB,CAAC,uBAAuB,CAAC,cAAc,EAAE,qBAAqB,CAAC,CAAC;IAC1F,CAAC;CACJ,CAAA;AAzBY,8EAAiC;4CAAjC,iCAAiC;IAD7C,IAAA,mBAAU,GAAE;qCAGsB,qCAAgB;QACX,gDAAqB;QAC7B,8BAAa;QACpB,8BAAa;GALzB,iCAAiC,CAyB7C","sourcesContent":["import { Injectable } from \"@nestjs/common\";\nimport { SolidRegistry } from \"src/helpers/solid-registry\";\nimport { IEntityPostComputeFieldProvider, IEntityComputedFieldProvider, QueuesModuleOptions } from \"src/interfaces\";\nimport { QueueMessage } from \"src/interfaces/mq\";\nimport { MqMessageQueueService } from \"src/services/mq-message-queue.service\";\nimport { MqMessageService } from \"src/services/mq-message.service\";\nimport { DatabaseSubscriber } from \"src/services/queues/database-subscriber.service\";\nimport { ComputedFieldEvaluationPayload } from \"src/subscribers/computed-entity-field.subscriber\";\nimport computedFieldEvaluationQueueOptions from \"./computed-field-evaluation-queue-options\";\nimport { PollerService } from \"src/services/poller.service\";\n\n@Injectable()\nexport class ComputedFieldEvaluationSubscriber extends DatabaseSubscriber<ComputedFieldEvaluationPayload> {\n    constructor(\n        readonly mqMessageService: MqMessageService,\n        readonly mqMessageQueueService: MqMessageQueueService,\n        readonly solidRegistry: SolidRegistry,\n        readonly poller: PollerService,\n    ) {\n        super(mqMessageService, mqMessageQueueService, poller);\n    }\n\n    options(): QueuesModuleOptions {\n        return {\n            ...computedFieldEvaluationQueueOptions\n        }\n    }\n\n    // This method will use the ComputedFieldEvaluationPayload to evaluate the computed fields\n    // It will then call the corresponding provider computeAndSave method to perform the evaluation\n    async subscribe(message: QueueMessage<ComputedFieldEvaluationPayload>) {\n        const { databaseEntity, ...computedFieldMetadata } = message.payload;\n        const provider = this.solidRegistry.getComputedFieldProvider(computedFieldMetadata.computedFieldValueProviderName);\n        // Get the instance of the provider and assert it is of type IEntityComputedFieldProvider\n        const providerInstance = provider.instance as IEntityPostComputeFieldProvider<any, any>; // IEntityComputedFieldProvider\n        await providerInstance.postComputeAndSaveValue(databaseEntity, computedFieldMetadata); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue\n    }\n}"]}