@solidstarters/solid-core 1.2.163 → 1.2.166

package/src/jobs/chatter-queue-publisher.service.ts

@@ -0,0 +1,37 @@
+import { Injectable } from '@nestjs/common';
+
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import chatterQueueOptions from './chatter-queue-options';
+import { MqMessageQueueService } from '../services/mq-message-queue.service';
+import { MqMessageService } from '../services/mq-message.service';
+import { QueuesModuleOptions } from "../interfaces";
+
+
+export type ChatterEventType = 'insert' | 'update' | 'delete';
+
+export interface ChatterMessagePayload {
+    eventType: ChatterEventType;
+    model: string;         // entity name
+    entityId: string;      // id string
+    occurredAt: string;    // ISO
+    before?: any;
+    after?: any;
+    diff?: string[];       // changed column names for updates
+    userId?: string | null;
+}
+
+@Injectable()
+export class ChatterQueuePublisher extends RabbitMqPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...chatterQueueOptions
+        }
+    }
+}

package/src/jobs/chatter-queue-subscriber.service.ts

@@ -0,0 +1,46 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageService } from '../services/mq-message.service';
+import { MqMessageQueueService } from '../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../interfaces";
+import chatterQueueOptions from './chatter-queue-options';
+import { ChatterMessagePayload } from './chatter-queue-publisher.service';
+import { ChatterMessageService } from 'src/services/chatter-message.service';
+
+@Injectable()
+export class ChatterQueueSubscriber extends RabbitMqSubscriber<any> {
+    private readonly chatterQueueLogger = new Logger(ChatterQueueSubscriber.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        private readonly chatterMessageService: ChatterMessageService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...chatterQueueOptions
+        }
+    }
+
+    async subscribe(message: QueueMessage<ChatterMessagePayload>) {
+        const p = message.payload;
+        this.chatterQueueLogger.debug(`Audit event ${p.eventType} ${p.model}#${p.entityId}`);
+
+        switch (p.eventType) {
+            case 'insert':
+                await this.chatterMessageService.postAuditMessageOnInsert(p.after, { name: p.model } as any);
+                break;
+            case 'update':
+                await this.chatterMessageService.postAuditMessageOnUpdate(p.after, { name: p.model } as any, p.before, (p.diff || []).map(n => ({ propertyName: n })));
+                break;
+            case 'delete':
+                await this.chatterMessageService.postAuditMessageOnDelete(p.before, { name: p.model } as any, p.before);
+                break;
+        }
+    }
+}

package/src/jobs/computed-field-evaluation-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from "@nestjs/common";
+import { QueuesModuleOptions } from "src/interfaces";
+import { MqMessageQueueService } from "src/services/mq-message-queue.service";
+import { MqMessageService } from "src/services/mq-message.service";
+import { RabbitMqPublisher } from "src/services/queues/rabbitmq-publisher.service";
+import { ComputedFieldEvaluationPayload } from "src/subscribers/computed-entity-field.subscriber";
+import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options";
+
+@Injectable()
+export class ComputedFieldEvaluationPublisherRabbitmq extends RabbitMqPublisher<ComputedFieldEvaluationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...computedFieldEvaluationQueueOptions
+        };
+    }
+}

package/src/jobs/{database/computed-field-evaluation-queue-options.ts → computed-field-evaluation-queue-options.ts}

@@ -1,9 +1,9 @@
-import { BrokerType } from "../../interfaces";
+import { BrokerType } from "../interfaces";
 
 const QUEUE_NAME = 'computed_field_evaluation_queue';
 
 export default {
     name: 'computedFieldEvaluationQueue',
-    type: BrokerType.Database,
+    type: BrokerType.RabbitMQ,
     queueName: QUEUE_NAME,
 };

package/src/jobs/computed-field-evaluation-subscriber.service.ts

@@ -0,0 +1,38 @@
+import { Injectable } from "@nestjs/common";
+import { SolidRegistry } from "src/helpers/solid-registry";
+import { IEntityPostComputeFieldProvider, QueuesModuleOptions } from "src/interfaces";
+import { QueueMessage } from "src/interfaces/mq";
+import { MqMessageQueueService } from "src/services/mq-message-queue.service";
+import { MqMessageService } from "src/services/mq-message.service";
+import { PollerService } from "src/services/poller.service";
+import { RabbitMqSubscriber } from "src/services/queues/rabbitmq-subscriber.service";
+import { ComputedFieldEvaluationPayload } from "src/subscribers/computed-entity-field.subscriber";
+import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options";
+
+@Injectable()
+export class ComputedFieldEvaluationSubscriberRabbitmq extends RabbitMqSubscriber<ComputedFieldEvaluationPayload> {
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly solidRegistry: SolidRegistry,
+        readonly poller: PollerService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...computedFieldEvaluationQueueOptions
+        }
+    }
+
+    // This method will use the ComputedFieldEvaluationPayload to evaluate the computed fields
+    // It will then call the corresponding provider computeAndSave method to perform the evaluation
+    async subscribe(message: QueueMessage<ComputedFieldEvaluationPayload>) {
+        const { databaseEntity, ...computedFieldMetadata } = message.payload;
+        const provider = this.solidRegistry.getComputedFieldProvider(computedFieldMetadata.computedFieldValueProviderName);
+        // Get the instance of the provider and assert it is of type IEntityComputedFieldProvider
+        const providerInstance = provider.instance as IEntityPostComputeFieldProvider<any, any>; // IEntityComputedFieldProvider
+        await providerInstance.postComputeAndSaveValue(databaseEntity, computedFieldMetadata); //FIXME There should some way to check/assert if the provider actually has a postComputeAndSaveValue
+    }
+}

package/src/jobs/database/{computed-field-evaluation-publisher.service.ts → computed-field-evaluation-publisher-database.service.ts}

@@ -4,10 +4,10 @@ import { MqMessageQueueService } from "src/services/mq-message-queue.service";
 import { MqMessageService } from "src/services/mq-message.service";
 import { DatabasePublisher } from "src/services/queues/database-publisher.service";
 import { ComputedFieldEvaluationPayload } from "src/subscribers/computed-entity-field.subscriber";
-import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options";
+import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options-database";
 
 @Injectable()
-export class ComputedFieldEvaluationPublisher extends DatabasePublisher<ComputedFieldEvaluationPayload> {
+export class ComputedFieldEvaluationPublisherDatabase extends DatabasePublisher<ComputedFieldEvaluationPayload> {
     constructor(
         protected readonly mqMessageService: MqMessageService,
         protected readonly mqMessageQueueService: MqMessageQueueService,

package/src/jobs/database/computed-field-evaluation-queue-options-database.ts

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

package/src/jobs/database/{computed-field-evaluation-subscriber.service.ts → computed-field-evaluation-subscriber-database.service.ts}

@@ -6,11 +6,11 @@ import { MqMessageQueueService } from "src/services/mq-message-queue.service";
 import { MqMessageService } from "src/services/mq-message.service";
 import { DatabaseSubscriber } from "src/services/queues/database-subscriber.service";
 import { ComputedFieldEvaluationPayload } from "src/subscribers/computed-entity-field.subscriber";
-import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options";
+import computedFieldEvaluationQueueOptions from "./computed-field-evaluation-queue-options-database";
 import { PollerService } from "src/services/poller.service";
 
 @Injectable()
-export class ComputedFieldEvaluationSubscriber extends DatabaseSubscriber<ComputedFieldEvaluationPayload> {
+export class ComputedFieldEvaluationSubscriberDatabase extends DatabaseSubscriber<ComputedFieldEvaluationPayload> {
     constructor(
         readonly mqMessageService: MqMessageService,
         readonly mqMessageQueueService: MqMessageQueueService,

package/src/jobs/database/generate-code-queue-options-database.ts

@@ -1,9 +1,9 @@
 import { BrokerType } from "../../interfaces";
 
-const QUEUE_NAME = 'generate_code_queue';
+const QUEUE_NAME = 'generate_code_queue_database';
 
 export default {
-    name: 'generateCodeQueue',
+    name: 'generateCodeQueueDatabase',
     type: BrokerType.Database,
     queueName: QUEUE_NAME,
 };

package/src/jobs/database/test-queue-subscriber-database.service.ts

@@ -29,12 +29,20 @@ export class TestQueueSubscriberDatabase extends DatabaseSubscriber<any> {
         // console.log(`Received message ${JSON.stringify(message)}`);
         this.testQueueLogger.debug(`Received message: ${JSON.stringify(message)}`);
 
+        let timeoutSecondsParsed = 10;
+        const timeoutSeconds = message?.payload?.timeoutSeconds;
+        if (timeoutSeconds) {
+            timeoutSecondsParsed = +timeoutSeconds;
+        }
+
+        this.testQueueLogger.debug(`Processing message with timeout: ${timeoutSecondsParsed}`);
+
+        // Simulate some processing time
         return new Promise((resolve, reject) => {
-            // Simulate some processing time
             setTimeout(() => {
                 this.testQueueLogger.debug(`Processed message: ${JSON.stringify(message)}`);
                 resolve({ status: 'success', messageId: message.messageId, message: `Processed message` });
-            }, 10000); // Simulate 1 second processing time
+            }, timeoutSecondsParsed * 1000);
         });
     }
 }

package/src/jobs/generate-code-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import { CodeGenerationOptions, QueuesModuleOptions } from "../interfaces";
+import { MqMessageQueueService } from '../services/mq-message-queue.service';
+import { MqMessageService } from '../services/mq-message.service';
+import generateCodeQueueOptions from './generate-code-queue-options';
+
+@Injectable()
+export class GenerateCodePublisherRabbitmq extends RabbitMqPublisher<CodeGenerationOptions> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...generateCodeQueueOptions
+        }
+    }
+}

package/src/jobs/generate-code-queue-options.ts

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

package/src/jobs/generate-code-subscriber.service.ts

@@ -0,0 +1,59 @@
+import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+
+import { QueueMessage } from 'src/interfaces/mq';
+import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
+import { SolidFieldType } from 'src/dtos/create-field-metadata.dto';
+import { ModelMetadataService } from 'src/services/model-metadata.service';
+import { PollerService } from 'src/services/poller.service';
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import { CodeGenerationOptions, QueuesModuleOptions } from 'src/interfaces';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import generateCodeQueueOptions from './generate-code-queue-options';
+
+@Injectable()
+export class GenerateCodeSubscriberRabbitmq extends RabbitMqSubscriber<CodeGenerationOptions> {
+    private readonly generateCodeSubscriberLogger = new Logger(GenerateCodeSubscriberRabbitmq.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        @Inject(forwardRef(() => ModelMetadataService))
+        readonly modelMetadataService: ModelMetadataService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...generateCodeQueueOptions
+        }
+    }
+
+    async subscribe(message: QueueMessage<CodeGenerationOptions>) {
+        this.generateCodeSubscriberLogger.debug(`Received message: ${JSON.stringify(message)}`);
+
+        const codeGnerationOptions = message.payload;
+
+        const { model, removeFieldCodeOuput, refreshModelCodeOutput } = await this.modelMetadataService.generateCode(codeGnerationOptions);
+
+        // Generate the code for models which are linked to fields having an inverse relation
+        const coModelSingularNames = model.fields.
+            filter(field => field.type === SolidFieldType.relation && field.relationCreateInverse === true)
+            .map(field => field.relationCoModelSingularName);
+
+        for (const singularName of coModelSingularNames) {
+            const coModel = await this.modelMetadataService.findOneBySingularName(singularName);
+            const inverseOptions: CodeGenerationOptions = {
+                modelId: coModel.id,
+                dryRun: codeGnerationOptions.dryRun
+            };
+            await this.modelMetadataService.generateCode(inverseOptions);
+        }
+
+        await this.modelMetadataService.generateVAMConfig(model.id);
+
+        return `${removeFieldCodeOuput} \n ${refreshModelCodeOutput}`;
+    }
+}

package/src/jobs/test-queue-subscriber.service.ts

@@ -27,12 +27,20 @@ export class TestQueueSubscriber extends RabbitMqSubscriber<any> {
         // console.log(`Received message ${JSON.stringify(message)}`);
         this.testQueueLogger.debug(`Received message: ${JSON.stringify(message)}`);
 
-        return new Promise((resolve, reject) => {
-            // Simulate some processing time
-            setTimeout(() => {
-                this.testQueueLogger.debug(`Processed message: ${JSON.stringify(message)}`);
-                resolve({ status: 'success', messageId: message.messageId, message: `Processed message` });
-            }, 10000); // Simulate 1 second processing time
-        });
+        let timeoutSecondsParsed = 10;
+        const timeoutSeconds = message?.payload?.timeoutSeconds;
+        if (timeoutSeconds) {
+            timeoutSecondsParsed = +timeoutSeconds;
+        }
+
+        this.testQueueLogger.debug(`Processing message with timeout: ${timeoutSecondsParsed}`);
+
+        // Simulate some processing time
+        setTimeout(() => {
+            this.testQueueLogger.debug(`Processed message: ${JSON.stringify(message)}`);
+            // resolve({ status: 'success', messageId: message.messageId, message: `Processed message` });
+        }, timeoutSecondsParsed * 1000);
+
+        // return new Promise((resolve, reject) => {});
     }
 }

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

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

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

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const TRIGGER_MCP_CLIENT_QUEUE_NAME = 'trigger_mcp_client_queue_rabbitmq';
+
+export default {
+    name: 'triggerMcpClientQueueRabbitmq',
+    type: BrokerType.RabbitMQ,
+    queueName: TRIGGER_MCP_CLIENT_QUEUE_NAME,
+};

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

@@ -0,0 +1,104 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { QueueMessage } from 'src/interfaces/mq';
+import triggerMcpClientQueueOptions from "./trigger-mcp-client-queue-options";
+import { AiInteractionService } from 'src/services/ai-interaction.service';
+import { PollerService } from 'src/services/poller.service';
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import { TriggerMcpClientOptions, QueuesModuleOptions } from 'src/interfaces';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+
+@Injectable()
+export class TriggerMcpClientSubscriberRabbitmq extends RabbitMqPublisher<TriggerMcpClientOptions> {
+    private readonly triggerMcpClientSubscriberLogger = new Logger(TriggerMcpClientSubscriberRabbitmq.name);
+
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        readonly aiInteractionService: AiInteractionService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...triggerMcpClientQueueOptions
+        }
+    }
+
+    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);
+        }
+
+        // The message contains the users prompt.
+        const prompt = aiInteraction.message;
+
+        // Use this to invoke our mcp client
+        // TODO: try / catch ... 
+        // Handle the rejection gracefully...
+        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'
+            });
+
+            // update the job entry with failure... raising an error will lead the job to be marked as 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 the human interaction was with isAutoApply=true, then we can go ahead and autoApply.
+            if (aiInteraction.isAutoApply) {
+                this.aiInteractionService.applySolidAiInteraction(genAiInteraction.id);
+            }
+        }
+
+        return aiResponse;
+    }
+}

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

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

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

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const SMS_QUEUE_NAME = 'twilio_sms_queue_rabbitmq';
+
+export default {
+    name: 'twilioSmsInstanceRabbitmq',
+    type: BrokerType.RabbitMQ,
+    queueName: SMS_QUEUE_NAME,
+};

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

@@ -0,0 +1,32 @@
+import { Injectable } from '@nestjs/common';
+
+import { QueuesModuleOptions } from 'src/interfaces';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { PollerService } from 'src/services/poller.service';
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import { TwilioSMSService } from 'src/services/sms/TwilioSMSService';
+import smsQueueOptions from './twilio-sms-queue-options';
+
+@Injectable()
+export class TwilioSmsQueueSubscriberRabbitmq extends RabbitMqPublisher<any> {
+    constructor(
+        private readonly smsService: TwilioSMSService,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...smsQueueOptions
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        return this.smsService.sendSMSSynchronously(message);
+    }
+}

package/src/repository/security-rule.repository.ts

@@ -91,7 +91,7 @@ export class SecurityRuleRepository extends Repository<SecurityRule> {
     async upsertWithDto(createDto: CreateSecurityRuleDto) {
         // Populate the role from roleId or roleUserKey
         const roleRepository = this.dataSource.getRepository(RoleMetadata);
-        if (!createDto.roleId) {
+        if (createDto.roleId) {
             const role = await roleRepository.findOne({
                 where: {
                     id: createDto.roleId,
@@ -111,7 +111,7 @@ export class SecurityRuleRepository extends Repository<SecurityRule> {
 
         // Populate the model from modelMetadataId or modelMetadataUserKey
         const modelMetadataRepository = this.dataSource.getRepository(ModelMetadata);
-        if (!createDto.modelMetadataId) {
+        if (createDto.modelMetadataId) {
             const modelMetadata = await modelMetadataRepository.findOne({
                 where: {
                     id: createDto.modelMetadataId,

package/src/seeders/seed-data/solid-core-metadata.json

@@ -3058,8 +3058,8 @@
             "ormType": "varchar",
             "length": 128,
             "required": true,
-            "unique": true,
-            "index": true,
+            "unique": false,
+            "index": false,
             "private": false,
             "encrypt": false,
             "isSystem": true

package/src/services/authentication.service.ts

@@ -764,13 +764,13 @@ export class AuthenticationService {
             isValidUser = false            
             // throw new NotFoundException(ERROR_MESSAGES.INVALID_CREDENTIALS);
         }
-        if (!user.active) {
+        if (isValidUser && !user?.active) {
             isValidUser = false
             // throw new UnauthorizedException(ERROR_MESSAGES.INVALID_CREDENTIALS);
         }
 
         // 2. Validate if user has used a provider which is "local", only then it makes sense for us to initiate the forgot password routine. 
-        if (user.lastLoginProvider !== 'local') {
+        if (isValidUser && user?.lastLoginProvider !== 'local') {
             isValidUser = false
             // throw new BadRequestException(ERROR_MESSAGES.INVALID_CREDENTIALS);
         }
@@ -792,8 +792,8 @@ export class AuthenticationService {
             error: '',
             errorCode: '',
             data: {
-                user: {
-                    email: user.email,
+                user:  {
+                    email: user?.email,
                     // mobile: user.mobile,
                     // username: user.username,
                 },

package/src/services/queues/database-publisher.service.ts

@@ -18,7 +18,7 @@ export abstract class DatabasePublisher<T> implements QueuePublisher<T> {
         if (!this.serviceRole) {
             this.logger.debug('Queue service Role is not defined in the environment variables');
         }
-        this.logger.debug(`DatabasePublisher instance created with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
+        this.logger.debug(`DatabasePublisher instance created with options: ${JSON.stringify(this.options())}`);
     }
 
     abstract options(): QueuesModuleOptions;
@@ -33,7 +33,7 @@ export abstract class DatabasePublisher<T> implements QueuePublisher<T> {
             throw new Error('Queue service Role is subscriber, cannot publish messages');
         }
 
-        this.logger.debug(`DatabasePublisher publishing with options: ${JSON.stringify(this.options())} and url: ${this.url}`);
+        this.logger.debug(`DatabasePublisher publishing with options: ${JSON.stringify(this.options())}`);
 
         const options = this.options();