@solidxai/core 0.0.2

package/src/services/list-of-values.service.ts

@@ -0,0 +1,239 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
+
+import { CRUDService } from 'src/services/crud.service';
+
+
+import * as fs from 'fs/promises'; // Use the Promise-based version of fs for async/await
+import { ModuleMetadataHelperService } from 'src/helpers/module-metadata-helper.service';
+import { ListOfValuesMapper } from 'src/mappers/list-of-values-mapper';
+import { ListOfValuesRepository } from 'src/repository/list-of-values.repository';
+import { ListOfValues } from '../entities/list-of-values.entity';
+
+
+@Injectable()
+export class ListOfValuesService extends CRUDService<ListOfValues> {
+  logger: any;
+  // moduleMetadataHelperService: any;
+  // listOfValuesMapper: any;
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    // @InjectRepository(ListOfValues, 'default')
+    // readonly repo: Repository<ListOfValues>,
+    readonly repo: ListOfValuesRepository,
+    readonly moduleRef: ModuleRef,
+    private readonly moduleMetadataHelperService: ModuleMetadataHelperService,
+    readonly listOfValuesMapper: ListOfValuesMapper,
+
+  ) {
+    super(entityManager, repo, 'listOfValues', 'solid-core', moduleRef);
+  }
+  async findOneByValueAndType(lovValue: string, lovType: string) {
+    return await this.repo.findOne({
+      where: {
+        value: lovValue,
+        type: lovType,
+      },
+    });
+  }
+
+  async findAll(): Promise<ListOfValues[]> {
+    return await this.repo.find();
+  }
+
+  async upsert(updateListOfValuesDto: any) {
+    // First check if module already exists using name
+    const existingListOfValue = await this.repo.findOne({
+      where: {
+        value: updateListOfValuesDto.value,
+        type: updateListOfValuesDto.type,
+      }
+    })
+
+    // if found
+    if (existingListOfValue) {
+      const updatedListOfValuesDto = { ...existingListOfValue, ...updateListOfValuesDto };
+      return this.repo.save(updatedListOfValuesDto);
+    }
+    // if not found - create new 
+    else {
+      const listOfValue = this.repo.create(updateListOfValuesDto);
+      return this.repo.save(listOfValue);
+    }
+  }
+
+
+  async saveListofValuesToConfig(entity: ListOfValues) {
+    if (!entity) {
+      this.logger.debug('No entity found in the ListofValuesSubscriber saveListofvalueToConfig method');
+      return;
+    }
+
+    // Validate list of value details
+    const listofvalue = entity as ListOfValues;
+    const moduleMetadata = entity.module;
+    if (!moduleMetadata) {
+      throw new Error(`Module metadata not found for listofvalue id ${entity.id}`);
+    }
+
+    // Get config file details
+    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name); // sting expected module name
+    if (!filePath || !metaData) {
+      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
+    }
+
+    // Write the listofvalue to the config file
+    await this.writeToConfig(metaData, listofvalue, filePath);
+  }
+
+  async updateListofValuesToConfig(oldentity: ListOfValues, entity: ListOfValues) {
+    if (!entity) {
+      this.logger.debug('No entity found in the ListofValuesSubscriber saveListofvalueToConfig method');
+      return;
+    }
+
+    // Validate list of value details
+    const oldlistofvalue = oldentity as ListOfValues;
+    const listofvalue = entity as ListOfValues;
+    const moduleMetadata = entity.module;
+    if (!moduleMetadata) {
+      throw new Error(`Module metadata not found for listofvalue id ${entity.id}`);
+    }
+
+    // Get config file details
+    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name); // sting expected module name
+    if (!filePath || !metaData) {
+      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
+    }
+
+    // Write the listofvalue to the config file
+    await this.updateToConfig(metaData, oldlistofvalue, listofvalue, filePath);
+  }
+
+  async deleteListOfValuesFromConfig(entity: ListOfValues) {
+    if (!entity) {
+      this.logger.debug('No entity found in the ListofValuesSubscriber saveListofvalueToConfig method');
+      return;
+    }
+
+    // Validate list of value details
+    const listofvalue = entity as ListOfValues;
+    const moduleMetadata = entity.module;
+    if (!moduleMetadata) {
+      throw new Error(`Module metadata not found for listofvalue id ${entity.id}`);
+    }
+
+    // Get config file details
+    const { filePath, metaData } = await this.getConfigFileDetails(moduleMetadata.name); // sting expected module name
+    if (!filePath || !metaData) {
+      throw new Error(`Configuration details not found for module: ${moduleMetadata.name}`);
+    }
+
+    // delete the listofvalue to the config file
+    await this.deleteFromConfig(metaData, listofvalue, filePath);
+  }
+
+  private async getConfigFileDetails(moduleName: string): Promise<{ filePath: string; metaData: any }> {
+    const filePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+    try {
+      await fs.access(filePath);
+    } catch (error) {
+      throw new Error(`Configuration file not found for module: ${moduleName}`);
+    }
+    const metaData = await this.moduleMetadataHelperService.getModuleMetadataConfiguration(filePath);
+    return { filePath, metaData };
+  }
+
+  private async writeToConfig(metaData: any, listofvalues: ListOfValues, filePath: string) {
+    const dto = await this.listOfValuesMapper.toDto(listofvalues);
+
+    if (!Array.isArray(metaData.listOfValues)) {
+      metaData.listOfValues = [];
+    }
+
+    // Match by type + value + module
+    const existingIndex = metaData.listOfValues.findIndex(
+      (item: { type: string; value: string; module: number }) =>
+        item.type === dto.type &&
+        item.value === dto.value &&
+        item.module === dto.module
+    );
+
+    if (existingIndex !== -1) {
+      // Replace existing entry
+      metaData.listOfValues[existingIndex] = dto;
+    } else {
+      // Insert new entry
+      // metaData.listOfValues.unshift(dto);
+
+      if (metaData.listOfValues.length === 0) {
+        // Case 1: Empty array → add first item
+        metaData.listOfValues.push(dto);
+      } else {
+        // Case 2: Insert new item right after index 0
+        metaData.listOfValues.unshift(dto);
+      }
+
+    }
+
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+  }
+
+  private async updateToConfig(metaData: any, oldlistofvalues: ListOfValues, listofvalues: ListOfValues, filePath: string) {
+    const newvalue = await this.listOfValuesMapper.toDto(listofvalues);
+    const oldvalue = await this.listOfValuesMapper.toDto(oldlistofvalues);
+
+    if (!Array.isArray(metaData.listOfValues)) {
+      metaData.listOfValues = [];
+    }
+
+    const searchType = oldvalue.type || newvalue.type;
+    const searchValue = oldvalue.value || newvalue.value;
+    const searchModule = oldvalue.module || newvalue.module;
+
+    const existingIndex = metaData.listOfValues.findIndex(
+      (item: { type: string; value: string; module: number }) =>
+        item.type === searchType && item.value === searchValue && item.module === searchModule
+    );
+    if (existingIndex !== -1) {
+      // Replace existing match
+      metaData.listOfValues[existingIndex] = newvalue;
+    }
+
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+  }
+
+  private async deleteFromConfig(metaData: any, listofvalues: ListOfValues, filePath: string) {
+    const dto = await this.listOfValuesMapper.toDto(listofvalues);
+
+    if (!Array.isArray(metaData.listOfValues)) {
+      metaData.listOfValues = [];
+    }
+
+    // Match by type + value + module
+    const existingIndex = metaData.listOfValues.findIndex(
+      (item: { type: string; value: string; module: number }) =>
+        item.type === dto.type &&
+        item.value === dto.value &&
+        item.module === dto.module
+    );
+
+    if (existingIndex !== -1) {
+      // Remove the item
+      metaData.listOfValues.splice(existingIndex, 1);
+      this.logger.debug(`Deleted LOV ${dto.type}:${dto.value} (module ${dto.module}) from config`);
+    } else {
+      this.logger.warn(
+        `LOV ${dto.type}:${dto.value} (module ${dto.module}) not found in config during delete`
+      );
+    }
+    const updatedContent = JSON.stringify(metaData, null, 2);
+    await fs.writeFile(filePath, updatedContent);
+
+  }
+}

package/src/services/locale.service.ts

@@ -0,0 +1,39 @@
+import { Injectable, Logger, OnApplicationBootstrap } from '@nestjs/common';
+import { ModuleRef } from "@nestjs/core";
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { EntityManager } from 'typeorm';
+
+import { Locale } from 'src/entities/locale.entity';
+import { SolidRegistry } from 'src/helpers/solid-registry';
+import { LocaleRepository } from 'src/repository/locale.repository';
+import { CRUDService } from 'src/services/crud.service';
+import { RequestContextService } from './request-context.service';
+@Injectable()
+export class LocaleService extends CRUDService<Locale> implements OnApplicationBootstrap{
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    // @InjectRepository(Locale, 'default')
+    // readonly repo: Repository<Locale>,
+    readonly repo: LocaleRepository,
+    // @InjectRepository(Locale, 'default')
+    readonly moduleRef: ModuleRef,
+    // @InjectRepository(ModelMetadata)
+    // private readonly modelMetadataRepo: Repository<ModelMetadata>,
+    // private readonly modelMetadataRepo: ModelMetadataRepository,
+    readonly requestContextService: RequestContextService,
+    readonly solidRegistry: SolidRegistry,
+ ) {
+   super(entityManager, repo, 'locale', 'solid-core', moduleRef);
+ }
+  private readonly logger = new Logger(LocaleService.name)
+  onApplicationBootstrap() {
+    // Load the security rules from the database
+    this.loadLocales();
+  }
+   async loadLocales() {
+    const locales = await this.repo.find();
+    this.logger.debug(`Loaded ${locales.length} locales into registry`);
+    this.solidRegistry.registerlocales(locales);
+  }
+}

package/src/services/mail/elastic-email.service.ts

@@ -0,0 +1,181 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { ConfigType } from '@nestjs/config';
+import Handlebars from "handlebars";
+import { EmailAttachment } from 'src/entities/email-attachment.entity';
+import { QueueMessage } from 'src/interfaces/mq';
+import { EmailTemplateService } from '../email-template.service';
+import { PdfService } from '../pdf.service';
+import { DiskFileService } from '../file';
+import { IMail, MailAttachment, MailAttachmentWrapper } from "../../interfaces";
+import { PublisherFactory } from '../queues/publisher-factory.service';
+import { MailProvider } from 'src/decorators/mail-provider.decorator';
+import { SettingService } from '../setting.service';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
+
+const ElasticEmail = require('@elasticemail/elasticemail-client');
+
+@Injectable()
+@MailProvider()
+export class ElasticEmailService implements IMail {
+    private readonly logger = new Logger(ElasticEmailService.name);
+    private readonly emailsApi;
+
+    constructor(
+        // private readonly emailPublisher: ApiEmailQueuePublisher,
+        private readonly publisherFactory: PublisherFactory<any>,
+        private readonly emailTemplateService: EmailTemplateService,
+        private readonly pdfService: PdfService,
+        private readonly fileService: DiskFileService,
+        private readonly settingService: SettingService
+    ) {
+        const client = ElasticEmail.ApiClient.instance;
+        const apikey = client.authentications['apikey'];
+        apikey.apiKey = process.env.COMMON_API_EMAIL_KEY;
+        this.emailsApi = new ElasticEmail.EmailsApi();
+    }
+
+    async sendEmailUsingTemplate(to: string, templateName: string, templateParams: any, shouldQueueEmails = false, parentEntity = null, parentEntityId = null): Promise<void> {
+        // Load template and evaluate it. 
+        const emailTemplate = await this.emailTemplateService.findOneByName(templateName, { attachments: true });
+        if (!emailTemplate) {
+            throw new Error(`Invalid template name ${templateName}`);
+        }
+
+        // Evaluate the body template.
+        const bodyTemplate = Handlebars.compile(emailTemplate.body);
+        const body = bodyTemplate(templateParams);
+
+        // Evaluate the subject template 
+        const subjectTemplate = Handlebars.compile(emailTemplate.subject);
+        const subject = subjectTemplate(templateParams);
+
+        // Populate the email with the template.
+        const emailTemplateAttachments = emailTemplate.attachments;
+        const attachmentWrappers: MailAttachmentWrapper[] = [];
+        for (const attachment of emailTemplateAttachments) {
+            const attachmentWrapper = await this.toAttachmentWrapper(attachment, templateParams);
+            attachmentWrappers.push(attachmentWrapper);
+        }
+
+        // Finally send the email.
+        await this.sendEmail(to, subject, body, shouldQueueEmails, parentEntity, parentEntityId, attachmentWrappers);
+    }
+
+    async sendEmail(to: string, subject: string, body: string, shouldQueueEmails = false, parentEntity = null, parentEntityId = null, wrapperAttachments: MailAttachmentWrapper[] = []): Promise<void> {
+        const message = {
+            payload: {
+                from: this.settingService.getConfigValue<SolidCoreSetting>("smtpMailFrom"),
+                to: to,
+                subject: subject,
+                body: body,
+                wrapperAttachments: wrapperAttachments,
+            },
+            parentEntity: parentEntity,
+            parentEntityId: parentEntityId,
+        };
+
+        // Send using queue if the developer has explicitly invoked with true.
+        if (shouldQueueEmails === true) {
+            this.sendEmailAsynchronously(message);
+        }
+        // If developer has not, however system config mandates that we send using queue, still we send.
+        else if (shouldQueueEmails == false && this.settingService.getConfigValue<SolidCoreSetting>("shouldQueueEmails") === true) {
+            this.sendEmailAsynchronously(message);
+        }
+        // Else we send synch
+        else {
+            await this.sendEmailSynchronously(message);
+        }
+    }
+
+    sendEmailAsynchronously(message: QueueMessage<any>) {
+        const { to, subject, body } = message.payload;
+        // this.notificationPublisherService.publish(message);
+        // this.emailPublisher.publish(message);
+        this.publisherFactory.publish(message, 'ApiEmailQueuePublisher');
+        this.logger.debug(`Queueing email to ${to} with subject ${subject} and body ${body}`);
+    }
+
+    async sendEmailSynchronously(message: QueueMessage<any>): Promise<void> {
+        const { from, to, subject, body, wrapperAttachments }: { from: string, to: string, subject: string, body: string, wrapperAttachments: MailAttachmentWrapper[] } = message.payload;
+        const emailData = {
+            Recipients: {
+                To: [to]
+            },
+            Content: {
+                Body: [
+                    {
+                        ContentType: "HTML", //ContentType Text version is handled by elastic email automatically through a config setting
+                        Charset: "utf-8",
+                        Content: body
+                    }
+                ],
+                From: from,
+                Subject: subject
+            }
+        };
+
+        // Handle relative attachments i.e attachments that are uploaded to the email service.
+        const relativeAttachments = wrapperAttachments.filter(wrapperAttachment => wrapperAttachment.relativePath);
+        if (relativeAttachments.length > 0) {
+            emailData.Content['AttachFiles'] = relativeAttachments.map(attachment => attachment.relativePath);
+        }
+
+        const binaryAttachments = wrapperAttachments.filter(wrapperAttachment => wrapperAttachment.attachment);
+        if (binaryAttachments.length > 0) {
+            //FIXME Replace this with actual attachment.
+            // const dummyAttachmentBuffer = await this.dummyAttachment();
+            // emailData.Content['Attachments'] = [{
+            //     "BinaryContent": dummyAttachmentBuffer.toString('base64'),
+            //     "Name": "Invoice.pdf", 
+            // }];
+            const attachments = [];
+            for (const wrapperAttachment of binaryAttachments) {
+                const attachment = await this.toMessageAttachment(wrapperAttachment.attachment, wrapperAttachment.attachment.templateParams);
+                attachments.push(attachment);
+            }
+            emailData.Content['Attachments'] = attachments;
+        }
+
+        const callback = (error, _data, _response) => {
+            if (error) {
+                this.logger.debug(`Error while sending email to ${to} with subject ${subject}`, error);
+            } else {
+                this.logger.debug(`Sending email to ${to} with subject ${subject}`);
+            }
+        };
+
+        this.emailsApi.emailsTransactionalPost(emailData, callback);
+    }
+
+    private async toAttachmentWrapper(attachment: EmailAttachment, templateParams: any): Promise<MailAttachmentWrapper> {
+        const attachmentWrapper: MailAttachmentWrapper = {}
+        if (attachment.template) {
+            attachmentWrapper.attachment = {
+                filename: attachment.displayName,
+                templatePath: attachment.template,
+                templateParams: templateParams,
+            }
+        } else {
+            attachmentWrapper.relativePath = attachment.relativePath
+        }
+        return attachmentWrapper;
+    }
+
+    private async toMessageAttachment(attachment: MailAttachment, templateParams: any): Promise<any> {
+        const attachmentContent = await this.getAttachmentAsPDF(attachment.templatePath, templateParams);
+        return {
+            "BinaryContent": attachmentContent.toString('base64'),
+            "Name": attachment.filename,
+        }
+    }
+
+    private async getAttachmentAsPDF(attachmentTemplatePath: string, templateParams: any): Promise<Buffer> {
+        const templateBuffer = await this.fileService.read(attachmentTemplatePath);
+        const bodyTemplate = Handlebars.compile(templateBuffer.toString('utf-8'));
+        const html = bodyTemplate(templateParams);
+        const pdfBuffer = await this.pdfService.generatePdf(html);
+        const buffer = Buffer.from(pdfBuffer);
+        return buffer;
+    }
+}

package/src/services/mail/smtp-email.service.ts

@@ -0,0 +1,168 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { ConfigType } from '@nestjs/config';
+import Handlebars from "handlebars";
+import { MailProvider } from 'src/decorators/mail-provider.decorator';
+import { QueueMessage } from 'src/interfaces/mq';
+import { IMail, MailAttachment, MailAttachmentWrapper } from "../../interfaces";
+import { EmailTemplateService } from '../email-template.service';
+import { PublisherFactory } from '../queues/publisher-factory.service';
+import { SettingService } from '../setting.service';
+import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
+
+const nodemailer = require("nodemailer");
+
+@Injectable()
+@MailProvider()
+export class SMTPEMailService implements IMail {
+    private readonly logger = new Logger(SMTPEMailService.name);
+    private readonly transporter: any;
+
+    constructor(
+        // private readonly emailPublisher: EmailQueuePublisher,
+        // private readonly emailDbPublisher: EmailQueueDbPublisher,
+        private readonly publisherFactory: PublisherFactory<any>,
+        private readonly emailTemplateService: EmailTemplateService,
+        private readonly settingService: SettingService
+
+    ) {
+
+        const host = process.env.COMMON_SMTP_EMAIL_SMTP_HOST;
+        const port = +(process.env.COMMON_SMTP_EMAIL_SMTP_PORT ?? 587);
+        const username = process.env.COMMON_SMTP_EMAIL_USERNAME;
+        const password = process.env.COMMON_SMTP_EMAIL_PASSWORD;
+        const from = process.env.COMMON_SMTP_EMAIL_FROM ?? process.env.COMMON_EMAIL_FROM;
+
+        this.transporter = nodemailer.createTransport({
+            host: host,
+            port: port,
+            secure: port === 465,
+            auth: {
+                user: username,
+                pass: password
+            }
+        });
+    }
+
+    async sendEmailUsingTemplate(
+        to: string,
+        templateName: string,
+        templateParams: any,
+        shouldQueueEmails = false,
+        wrapperAttachments?: MailAttachmentWrapper[],
+        attachments?: MailAttachment[],
+        parentEntity?: any,
+        parentEntityId?: any,
+        cc?: string[],
+        bcc?: string[],
+        from?: string
+    ) {
+        // Load template and evaluate it.
+        const emailTemplate = await this.emailTemplateService.findOneByName(templateName);
+        if (!emailTemplate) {
+            throw new Error(`Invalid template name ${templateName}`);
+        }
+
+        // Evaluate the body template.
+        const bodyTemplate = Handlebars.compile(emailTemplate.body);
+        const body = bodyTemplate(templateParams);
+
+        // Evaluate the subject template 
+        const subjectTemplate = Handlebars.compile(emailTemplate.subject);
+        const subject = subjectTemplate(templateParams);
+
+        // Finally send the email.
+        return await this.sendEmail(to, subject, body, shouldQueueEmails, wrapperAttachments, attachments, parentEntity, parentEntityId, cc, bcc, from);
+    }
+
+    async sendEmail(
+        to: string,
+        subject: string,
+        body: string,
+        shouldQueueEmails = false,
+        wrapperAttachments?: MailAttachmentWrapper[],
+        attachments?: MailAttachment[],
+        parentEntity?: any,
+        parentEntityId?: any,
+        cc?: string[],
+        bcc?: string[],
+        from?: string
+    ) {
+        const message = {
+            payload: {
+                from: from || this.settingService.getConfigValue<SolidCoreSetting>("smtpMailFrom"),
+                to: to,
+                subject: subject,
+                body: body,
+                attachments: attachments,
+                cc: cc,
+                bcc: bcc,
+            },
+            parentEntity: parentEntity,
+            parentEntityId: parentEntityId,
+        };
+
+        // Send using queue if the developer has explicitly invoked with true.
+        if (shouldQueueEmails === true) {
+            return this.sendEmailAsynchronously(message);
+        }
+        // If developer has not, however system config mandates that we send using queue, still we send.
+        else if (shouldQueueEmails == false && this.settingService.getConfigValue<SolidCoreSetting>("shouldQueueEmails") === true) {
+            return this.sendEmailAsynchronously(message);
+        }
+        // Else we send synchronously
+        else {
+            return await this.sendEmailSynchronously(message);
+        }
+    }
+
+    async sendEmailAsynchronously(message) {
+        const { to, subject, body } = message.payload;
+        this.logger.debug(`Queueing email to ${to} with subject ${subject} and body ${body}`);
+        return this.publisherFactory.publish(message, 'SmtpEmailQueuePublisher');
+    }
+
+    async sendEmailSynchronously(message: QueueMessage<any>) {
+        let from;
+        const { to, subject, body, attachments = [], cc, bcc } = message.payload;
+
+        const envFrom = this.settingService.getConfigValue<SolidCoreSetting>("smtpMailFrom");
+        if (envFrom) {
+            from = envFrom;
+        }
+
+        // if any of the required fields are missing, throw an error.
+        if (!from || !to || !subject || !body) {
+            this.logger.error(`Required fields are missing in the email message: ${JSON.stringify(message.payload)}`);
+            return;
+        }
+
+        const attachmentsList = attachments?.map((attachment: MailAttachment) => {
+            const attachmentEntry = {
+                filename: attachment.filename,
+                contentType: attachment.contentType,
+            }
+            if (attachment.path) {
+                attachmentEntry['path'] = attachment.path;
+            }
+            if (attachment.content) {
+                attachmentEntry['content'] = attachment.content;
+            }
+            return attachmentEntry;
+        }) || [];
+
+        // throw new Error('Random error....');
+        const r = await this.transporter.sendMail({
+            from: from,
+            to: to,
+            cc: cc,
+            bcc: bcc,
+            subject: subject,
+            html: body,
+            attachments: attachmentsList,
+        });
+        // this.logger.debug(`Sending email to ${to} with subject ${subject} and body ${body}`);
+        // this.logger.debug(`Sending email to ${to} with subject ${subject}`);
+
+        return r;
+    }
+}