@solidstarters/solid-core 1.2.0

package/src/services/file.service.ts

@@ -0,0 +1,149 @@
+import { Inject, Injectable } from '@nestjs/common';
+import * as fs from 'fs';
+// import * as AWS from 'aws-sdk';
+import { S3Client, PutObjectCommand, DeleteObjectCommand, ObjectCannedACL } from '@aws-sdk/client-s3';
+import { ConfigType } from '@nestjs/config';
+import commonConfig from '../config/common.config';
+
+
+
+
+@Injectable()
+export class FileService {
+
+  private readonly s3Client: S3Client;
+
+  constructor(
+    @Inject(commonConfig.KEY)
+    private readonly commonConfiguration: ConfigType<typeof commonConfig>,
+
+  ) {
+    this.s3Client = new S3Client({
+      region: this.commonConfiguration.awsS3Credentials.S3_AWS_REGION_NAME,
+      credentials: {
+        accessKeyId: this.commonConfiguration.awsS3Credentials.S3_AWS_ACCESS_KEY,
+        secretAccessKey: this.commonConfiguration.awsS3Credentials.S3_AWS_SECRET_KEY,
+      },
+      // endpoint: `https://${process.env.S3_AWS_BUCKET_NAME}.s3.${process.env.S3_AWS_REGION_NAME}.amazonaws.com`, // Correct regional endpoint
+
+    });
+  }
+
+  readFile(filePath: string): Promise<string | Buffer> {
+    return new Promise((resolve, reject) => {
+      fs.readFile(filePath, (err, data) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(data);
+      });
+    });
+  }
+
+  readImageFile(filePath: string): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+      fs.readFile(filePath, (err, data) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve(data); // Resolve with Buffer instead of string
+      });
+
+    });
+  }
+
+  writeFile(filePath: string, data: string | Buffer): Promise<void> {
+    return new Promise((resolve, reject) => {
+      fs.writeFile(filePath, data, (err) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve();
+      });
+    });
+  }
+
+  async copyFile(sourcePath: string, destinationPath: string): Promise<void> {
+    try {
+      const data = await this.readFile(sourcePath);
+      await this.writeFile(destinationPath, data);
+    } catch (error) {
+      throw new Error(`Error copying file: ${error.message}`);
+    }
+  }
+
+  deleteFile(filePath: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      fs.unlink(filePath, (err) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve();
+      });
+    });
+  }
+
+  async copyToS3(filePath: string, ContentType: string, fileName: string, bucketName: string): Promise<string> {
+    try {
+      // Read Image File TO Fetch Buffer 
+      const data = await this.readImageFile(filePath);
+
+      const params = {
+        Bucket: bucketName,
+        Key: fileName,
+        Body: data,
+        ContentType: ContentType, // Set the correct MIME type
+
+      };
+      // Upload it to S3
+      // const response = await this.s3.upload(params).promise();
+      const command = new PutObjectCommand(params);
+      const response = await this.s3Client.send(command);
+
+      // Return the URL file Name
+      // To access the file  - https://rep-public-files.s3.amazonaws.com/${fileName}
+      return fileName
+
+    } catch (error) {
+      throw new Error(`Error copying file: ${error.message}`);
+    }
+  }
+
+  async copyToS3WithPublic(filePath: string, ContentType: string, fileName: string, bucketName: string): Promise<string> {
+    try {
+      // Read Image File TO Fetch Buffer 
+      const data = await this.readImageFile(filePath);
+
+      const params = {
+        Bucket: bucketName,
+        Key: fileName,
+        Body: data,
+        ContentType: ContentType, // Set the correct MIME type
+        ACL: "public-read" as ObjectCannedACL
+      };
+      // Upload it to S3
+      // const response = await this.s3.upload(params).promise();
+      const command = new PutObjectCommand(params);
+      const response = await this.s3Client.send(command);
+
+      // Return the URL file Name
+      // To access the file  - https://rep-public-files.s3.amazonaws.com/${fileName}
+      return fileName
+
+    } catch (error) {
+      throw new Error(`Error copying file: ${error.message}`);
+    }
+  }
+
+  async deleteFromS3(fileName: string, bucketName: string): Promise<string> {
+
+    const params = {
+      Bucket: bucketName,  // your S3 bucket name
+      Key: fileName        // the name of the file you want to delete    
+    };
+
+    const command = new DeleteObjectCommand(params)
+    const response = await this.s3Client.send(command);
+    return fileName
+  }
+}

package/src/services/groupBy.json

@@ -0,0 +1,92 @@
+{
+    "meta": {
+        "totalRecords": 1,
+        "currentPage": 1,
+        "nextPage": null,
+        "prevPage": null,
+        "totalPages": 1,
+        "perPage": 10
+    },
+    "records": [
+        {
+            "status": "draft",
+            "id": 9,
+            "createdAt": "2025-01-06T21:07:11.054Z",
+            "updatedAt": "2025-01-06T21:07:11.054Z",
+            "deletedAt": null,
+            "deletedTracker": "not-deleted",
+            "title": "Test blog draft",
+            "content": "Test blog draft content",
+            "introduction": "Test blog draft introduction"
+        }
+    ]
+}
+{
+    "group":{
+        {
+           "meta": {
+                "groups": [
+                   {"status":"draft"},
+                   {"status":"published"} 
+                ]
+           } 
+           "records": [
+            {
+               "groupName":"draft",
+               "groupData":[
+                    {
+                        "meta": {
+                            "totalRecords": 1,
+                            "currentPage": 1,
+                            "nextPage": null,
+                            "prevPage": null,
+                            "totalPages": 1,
+                            "perPage": 10
+                        },
+                        "records": [
+                            {
+                                "status": "draft",
+                                "id": 9,
+                                "createdAt": "2025-01-06T21:07:11.054Z",
+                                "updatedAt": "2025-01-06T21:07:11.054Z",
+                                "deletedAt": null,
+                                "deletedTracker": "not-deleted",
+                                "title": "Test blog draft",
+                                "content": "Test blog draft content",
+                                "introduction": "Test blog draft introduction"
+                            }
+                        ]
+                    }
+               ] 
+
+            },
+            {
+
+            }
+           ]
+        }
+    }
+}
+{
+    "meta": {
+        "totalRecords": 1,
+        "currentPage": 1,
+        "nextPage": null,
+        "prevPage": null,
+        "totalPages": 1,
+        "perPage": 10
+    },
+    "records": [
+        {
+            "status": "draft",
+            "id": 9,
+            "createdAt": "2025-01-06T21:07:11.054Z",
+            "updatedAt": "2025-01-06T21:07:11.054Z",
+            "deletedAt": null,
+            "deletedTracker": "not-deleted",
+            "title": "Test blog draft",
+            "content": "Test blog draft content",
+            "introduction": "Test blog draft introduction"
+        }
+    ]
+}

package/src/services/hashing.service.ts

@@ -0,0 +1,7 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export abstract class HashingService {
+    abstract hash(data: string | Buffer): Promise<string>;
+    abstract compare(data: string | Buffer, encrypted: string): Promise<boolean>;
+}

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

@@ -0,0 +1,54 @@
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+import { ListOfValues } from "../entities/list-of-values.entity";
+import { PaginationQueryDto } from "src/dtos/pagination-query.dto";
+import { Injectable, NotFoundException } from "@nestjs/common";
+
+@Injectable()
+export class ListOfValuesService {
+    constructor(
+        @InjectRepository(ListOfValues)
+        private readonly listOfValuesRepo: Repository<ListOfValues>,
+    ) { }
+
+    findAll(paginationQuery: PaginationQueryDto) {
+        const { limit, offset } = paginationQuery;
+        return this.listOfValuesRepo.find({
+            relations: {},
+            skip: offset,
+            take: limit,
+        });
+    }
+
+    async findOneByValueAndType(lovValue: string, lovType: string) {
+        return await this.listOfValuesRepo.findOne({
+            where: {
+                value: lovValue,
+                type: lovType,
+            },
+        });
+    }
+
+    async findOne(id: number, relations = {}) {
+        const lov = await this.listOfValuesRepo.findOne({
+            where: {
+                id: id,
+            },
+            relations: relations,
+        });
+        if (!lov) {
+            throw new NotFoundException(`list of values #${id} not found`);
+        }
+        return lov;
+    }
+
+    async create(createDto: any) {
+        const lov = this.listOfValuesRepo.create(createDto);
+        return this.listOfValuesRepo.save(lov);
+    }
+
+    async remove(id: number) {
+        const lov = await this.findOne(id);
+        return this.listOfValuesRepo.remove(lov);
+    }
+}

package/src/services/mail/ElasticEmailService.ts

@@ -0,0 +1,177 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { ConfigType } from '@nestjs/config';
+import Handlebars, { template } from "handlebars";
+import commonConfig from 'src/config/common.config';
+import { EmailAttachment } from 'src/entities/email-attachment.entity';
+import { ApiEmailQueuePublisher } from 'src/jobs/api-email-publisher.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import { EmailTemplateService } from '../email-template.service';
+import { PdfService } from '../pdf.service';
+import { FileService } from '../file.service';
+import { IMail, MailAttachment, MailAttachmentWrapper } from "../../interfaces";
+
+const ElasticEmail = require('@elasticemail/elasticemail-client');
+
+@Injectable()
+export class ElasticEmailService implements IMail {
+    private readonly logger = new Logger(ElasticEmailService.name);
+    private readonly emailsApi;
+
+    constructor(
+        @Inject(commonConfig.KEY)
+        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
+        private readonly emailPublisher: ApiEmailQueuePublisher,
+        private readonly emailTemplateService: EmailTemplateService,
+        private readonly pdfService: PdfService,
+        private readonly fileService: FileService,
+    ) {
+        const client = ElasticEmail.ApiClient.instance;
+        const apikey = client.authentications['apikey'];
+        apikey.apiKey = commonConfiguration.apiMail.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.commonConfiguration.smtpMail.from,
+                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.commonConfiguration.shouldQueueEmails === true) {
+            this.sendEmailAsynchronously(message);
+        }
+        // Else we send synch
+        else {
+            await this.sendEmailSynchronously(message);
+        }
+    }
+
+    async sendEmailAsynchronously(message: QueueMessage<any>) {
+        const { to, subject, body } = message.payload;
+        // this.notificationPublisherService.publish(message);
+        this.emailPublisher.publish(message);
+        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 template = await this.fileService.readFile(attachmentTemplatePath)
+        const bodyTemplate = Handlebars.compile(template);
+        const html = bodyTemplate(templateParams);
+        const pdfBuffer = await this.pdfService.generatePdf(html);
+        const buffer = Buffer.from(pdfBuffer);
+        return buffer;
+    }
+}

package/src/services/mail/SMTPEmailService.ts

@@ -0,0 +1,101 @@
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { ConfigType } from '@nestjs/config';
+import { QueueMessage } from 'src/interfaces/mq';
+import { EmailQueuePublisher } from 'src/jobs/email-publisher.service';
+import commonConfig from 'src/config/common.config';
+import { EmailTemplateService } from '../email-template.service';
+import Handlebars from "handlebars";
+import { IMail } from "../../interfaces";
+
+const nodemailer = require("nodemailer");
+
+
+@Injectable()
+export class SMTPEMailService implements IMail {
+    private readonly logger = new Logger(SMTPEMailService.name);
+    private readonly transporter: any;
+
+    constructor(
+        @Inject(commonConfig.KEY)
+        private readonly commonConfiguration: ConfigType<typeof commonConfig>,
+        private readonly emailPublisher: EmailQueuePublisher,
+        private readonly emailTemplateService: EmailTemplateService,
+    ) {
+        this.transporter = nodemailer.createTransport({
+            host: this.commonConfiguration.smtpMail.host,
+            port: this.commonConfiguration.smtpMail.port,
+            secure: this.commonConfiguration.smtpMail.port === 465,
+            auth: {
+                user: this.commonConfiguration.smtpMail.username,
+                pass: this.commonConfiguration.smtpMail.password
+            }
+        });
+    }
+
+    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);
+        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.
+        await this.sendEmail(to, subject, body, shouldQueueEmails, parentEntity, parentEntityId);
+    }
+
+    async sendEmail(to: string, subject: string, body: string, shouldQueueEmails = false, parentEntity = null, parentEntityId = null): Promise<void> {
+        const message = {
+            payload: {
+                from: this.commonConfiguration.smtpMail.from,
+                to: to,
+                subject: subject,
+                body: body
+            },
+            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.commonConfiguration.shouldQueueEmails === true) {
+            this.sendEmailAsynchronously(message);
+        }
+        // Else we send synch
+        else {
+            await this.sendEmailSynchronously(message);
+        }
+    }
+
+    async sendEmailAsynchronously(message) {
+        const { to, subject, body } = message.payload;
+        // this.notificationPublisherService.publish(message);
+        this.emailPublisher.publish(message);
+        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 } = message.payload;
+        // throw new Error('Random error....');
+        const r = await this.transporter.sendMail({
+            from: from,
+            to: to,
+            subject: subject,
+            html: body
+        });
+        // 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;
+    }
+}

package/src/services/media-storage-provider-metadata-seeder.service.ts

@@ -0,0 +1,33 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { MediaStorageProviderMetadataService } from './media-storage-provider-metadata.service';
+
+
+
+/**
+ * solid seed -s ModuleMetadataSeederService
+ */
+@Injectable()
+export class MediaStorageProviderMetadataSeederService {
+    private readonly logger = new Logger(MediaStorageProviderMetadataSeederService.name);
+
+    constructor(
+        private readonly mediaStorageProviderMetadataService: MediaStorageProviderMetadataService,
+    ) { }
+
+    async seed() {
+        const existingDefaultFs = await this.mediaStorageProviderMetadataService.findOneByUserKey('default-filesystem');
+        if (!existingDefaultFs) {
+            await this.mediaStorageProviderMetadataService.create({
+                name: 'default-filesystem',
+                type: 'filesystem'
+            });
+        }
+        const existingDefaultAws = await this.mediaStorageProviderMetadataService.findOneByUserKey('default-aws-s3');
+        if (!existingDefaultAws) {
+            await this.mediaStorageProviderMetadataService.create({
+                name: 'default-aws-s3',
+                type: 'aws-s3'
+            });
+        }
+    }
+}