@solidxai/core 0.1.6 → 0.1.8-beta.0

package/src/jobs/redis/three60-whatsapp-publisher-redis.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisPublisher } from 'src/services/queues/redis-publisher.service';
+import three60WhatsappQueueConfig from './three60-whatsapp-queue-options-redis';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { QueuesModuleOptions } from "../../interfaces";
+
+@Injectable()
+export class Three60WhatsappQueuePublisherRedis extends RedisPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...three60WhatsappQueueConfig
+        }
+    }
+}

package/src/jobs/redis/three60-whatsapp-queue-options-redis.ts

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

package/src/jobs/redis/three60-whatsapp-subscriber-redis.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import three60WhatsappQueueConfig from './three60-whatsapp-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { Three60WhatsappService } from '../../services/whatsapp/Three60WhatsappService';
+
+@Injectable()
+export class Three60WhatsappQueueSubscriberRedis extends RedisSubscriber<any> {
+    constructor(
+        private readonly whatsappService: Three60WhatsappService,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...three60WhatsappQueueConfig
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        this.whatsappService.sendWhatsAppMessageSynchronously(message);
+    }
+}

package/src/jobs/redis/trigger-mcp-client-publisher-redis.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisPublisher } from 'src/services/queues/redis-publisher.service';
+import triggerMcpClientQueueConfig from './trigger-mcp-client-queue-options-redis';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { TriggerMcpClientOptions, QueuesModuleOptions } from "../../interfaces";
+
+@Injectable()
+export class TriggerMcpClientPublisherRedis extends RedisPublisher<TriggerMcpClientOptions> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...triggerMcpClientQueueConfig
+        }
+    }
+}

package/src/jobs/redis/trigger-mcp-client-queue-options-redis.ts

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

package/src/jobs/redis/trigger-mcp-client-subscriber-redis.service.ts

@@ -0,0 +1,98 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import triggerMcpClientQueueConfig from './trigger-mcp-client-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { TriggerMcpClientOptions, QueuesModuleOptions } from "../../interfaces";
+import { AiInteractionService } from '../../services/ai-interaction.service';
+import { PollerService } from '../../services/poller.service';
+
+@Injectable()
+export class TriggerMcpClientSubscriberRedis extends RedisSubscriber<TriggerMcpClientOptions> {
+    private readonly triggerMcpClientSubscriberLogger = new Logger(TriggerMcpClientSubscriberRedis.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        readonly aiInteractionService: AiInteractionService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...triggerMcpClientQueueConfig
+        }
+    }
+
+    async subscribe(message: QueueMessage<TriggerMcpClientOptions>) {
+        this.triggerMcpClientSubscriberLogger.debug(`Received message: ${JSON.stringify(message)}`);
+
+        const codeGnerationOptions = message.payload;
+
+        const aiInteraction = await this.aiInteractionService.findOne(codeGnerationOptions.aiInteractionId, {
+            populate: ['user']
+        });
+        if (!aiInteraction) {
+            const m = `Unable to identified the aiInteraction entry that triggered this job... using id: ${codeGnerationOptions.aiInteractionId}`
+            this.triggerMcpClientSubscriberLogger.log(m);
+            throw new Error(m);
+        }
+
+        const prompt = aiInteraction.message;
+
+        const aiResponse = await this.aiInteractionService.runMcpPrompt(prompt);
+        this.triggerMcpClientSubscriberLogger.log(`aiResponse: `);
+        this.triggerMcpClientSubscriberLogger.log(JSON.stringify(aiResponse));
+
+        if (!aiResponse.success) {
+            this.triggerMcpClientSubscriberLogger.log(`Gen ai has returned with a false status code`);
+
+            const errorsStr = aiResponse.errors.join('; ');
+
+            await this.aiInteractionService.create({
+                userId: aiInteraction.user.id,
+                threadId: aiInteraction.threadId,
+                parentInteractionId: aiInteraction.id,
+                role: 'gen-ai',
+                message: '-',
+                contentType: aiResponse.content_type,
+                errorMessage: errorsStr,
+                modelUsed: aiResponse.model,
+                responseTimeMs: aiResponse.duration_ms,
+                metadata: JSON.stringify(aiResponse),
+                isApplied: aiInteraction.isApplied,
+                status: aiResponse.success ? 'succeeded' : 'failed'
+            });
+
+            throw new Error(errorsStr);
+        }
+        else {
+            let nestedResponse = aiResponse.response.trim();
+
+            const genAiInteraction = await this.aiInteractionService.create({
+                userId: aiInteraction.user.id,
+                threadId: aiInteraction.threadId,
+                parentInteractionId: aiInteraction.id,
+                role: 'gen-ai',
+                message: nestedResponse,
+                contentType: aiResponse.content_type,
+                errorMessage: '',
+                modelUsed: aiResponse.model,
+                responseTimeMs: aiResponse.duration_ms,
+                metadata: JSON.stringify(aiResponse),
+                isApplied: aiInteraction.isApplied,
+                status: aiResponse.success ? 'succeeded' : 'failed'
+            });
+
+            if (aiInteraction.isAutoApply) {
+                this.aiInteractionService.applySolidAiInteraction(genAiInteraction.id);
+            }
+        }
+
+        return aiResponse;
+    }
+}

package/src/jobs/redis/twilio-sms-publisher-redis.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisPublisher } from 'src/services/queues/redis-publisher.service';
+import twilioSmsQueueConfig from './twilio-sms-queue-options-redis';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { QueuesModuleOptions } from "../../interfaces";
+
+@Injectable()
+export class TwilioSmsQueuePublisherRedis extends RedisPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...twilioSmsQueueConfig
+        }
+    }
+}

package/src/jobs/redis/twilio-sms-queue-options-redis.ts

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

package/src/jobs/redis/twilio-sms-subscriber-redis.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import twilioSmsQueueConfig from './twilio-sms-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { TwilioSMSService } from '../../services/sms/TwilioSMSService';
+import { SmsFactory } from 'src/factories/sms.factory';
+import { PollerService } from '../../services/poller.service';
+
+@Injectable()
+export class TwilioSmsQueueSubscriberRedis extends RedisSubscriber<any> {
+    constructor(
+        private readonly smsFactory: SmsFactory,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...twilioSmsQueueConfig
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        const smsService: TwilioSMSService = this.smsFactory.getSmsService(TwilioSMSService.name) as TwilioSMSService;
+        return smsService.sendSMSSynchronously(message);
+    }
+}

package/src/repository/dashboard-layout.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { RequestContextService } from 'src/services/request-context.service';
+import { DataSource } from 'typeorm';
+import { SecurityRuleRepository } from './security-rule.repository';
+import { SolidBaseRepository } from './solid-base.repository';
+import { DashboardLayout } from 'src/entities/dashboard-layout.entity';
+
+@Injectable()
+export class DashboardLayoutRepository extends SolidBaseRepository<DashboardLayout> {
+    constructor(
+        readonly dataSource: DataSource,
+        readonly requestContextService: RequestContextService,
+        readonly securityRuleRepository: SecurityRuleRepository,
+    ) {
+        super(DashboardLayout, dataSource, requestContextService, securityRuleRepository);
+    }
+}

package/src/repository/model-metadata.repository.ts

@@ -1,5 +1,9 @@
-import { Injectable } from '@nestjs/common';
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable } from '@nestjs/common';
+import { Cache } from 'cache-manager';
+import { createHash } from 'crypto';
 import { ModelMetadata } from 'src';
+import { shouldUseCache } from 'src/helpers/cache.helper';
 import { DataSource } from 'typeorm';
 import { SolidBaseRepository } from './solid-base.repository';
 
@@ -7,9 +11,48 @@ import { SolidBaseRepository } from './solid-base.repository';
 export class ModelMetadataRepository extends SolidBaseRepository<ModelMetadata> {
     constructor(
         readonly dataSource: DataSource,
+        @Inject(CACHE_MANAGER) private readonly cacheManager: Cache,
         // readonly requestContextService: RequestContextService,
         // readonly securityRuleRepository: SecurityRuleRepository,
     ) {
         super(ModelMetadata, dataSource, null, null);
     }
-}
+
+    async find(options?: any): Promise<ModelMetadata[]> {
+        if (!shouldUseCache()) {
+            return super.find(options);
+        }
+
+        const cacheKey = this.buildCacheKey('find', options);
+        const cached = await this.cacheManager.get<ModelMetadata[]>(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const result = await super.find(options);
+        await this.cacheManager.set(cacheKey, result);
+        return result;
+    }
+
+    async findOne(options: any): Promise<ModelMetadata | null> {
+        if (!shouldUseCache()) {
+            return super.findOne(options);
+        }
+
+        const cacheKey = this.buildCacheKey('findOne', options);
+        const cached = await this.cacheManager.get<ModelMetadata | null>(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const result = await super.findOne(options);
+        await this.cacheManager.set(cacheKey, result);
+        return result;
+    }
+
+    private buildCacheKey(method: 'find' | 'findOne', options: unknown): string {
+        const serialized = JSON.stringify(options ?? {});
+        const hash = createHash('sha256').update(serialized).digest('hex');
+        return `modelMetadataRepo:${method}:${hash}`;
+    }
+}

package/src/seeders/module-metadata-seeder.service.ts

@@ -140,17 +140,17 @@ export class ModuleMetadataSeederService {
                 console.log(`▶ Seeding Metadata for Module: ${moduleMetadata.name}`);
                 this.logger.log(`Seeding Metadata for Module: ${moduleMetadata.name}`);
 
+                currentStep = 'seedMediaStorageProviders';
+                this.logger.log(`Seeding Media Storage Providers`);
+                const mediaStorageCounts = await this.seedMediaStorageProviders(overallMetadata.mediaStorageProviders);
+                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Media Storage Providers', mediaStorageCounts)}`);
+
                 // Process module metadata first.
                 currentStep = 'seedModuleModelFields';
                 this.logger.log(`Seeding Module / Model / Fields`);
                 const moduleModelFieldCounts = await this.seedModuleModelFields(moduleMetadata);
                 console.log(`${this.formatSeedResult(moduleMetadata.name, 'Module/Model/Fields', moduleModelFieldCounts)}`);
 
-                currentStep = 'seedMediaStorageProviders';
-                this.logger.log(`Seeding Media Storage Providers`);
-                const mediaStorageCounts = await this.seedMediaStorageProviders(overallMetadata.mediaStorageProviders);
-                console.log(`${this.formatSeedResult(moduleMetadata.name, 'Media Storage Providers', mediaStorageCounts)}`);
-
                 currentStep = 'seedRoles';
                 this.logger.log(`Seeding Roles`);
                 const roleCounts = await this.seedRoles(overallMetadata);