@clairejs/server 3.28.9 → 3.28.11

package/README.md

@@ -1,5 +1,13 @@
 ## Change Log
 
+#### 3.28.11
+
+-   fix LocalJobScheduler publish & subscribe issue
+
+#### 3.28.10
+
+-   allow email service to send attachments
+
 #### 3.28.9
 
 -   update core and allow query fields with nullable

package/dist/job/LocalJobScheduler.js

@@ -63,7 +63,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         this.keyRetentionDurationSeconds = keyRetentionDurationSeconds;
     }
     sendJob(type, data) {
-        this.subscribeClient.publish(this.multiClientChannel, JSON.stringify({ type, data }));
+        this.redisClient.publish(this.multiClientChannel, JSON.stringify({ type, data }));
     }
     async processMessage(type, data) {
         if (!this.isActive) {
@@ -110,7 +110,7 @@ let LocalJobScheduler = class LocalJobScheduler extends AbstractJobScheduler {
         this.logger.debug("LocalJobScheduler init");
         //-- subscribe to multi client channel
         this.logger.debug("Listening on multi client channel");
-        this.redisClient.on("message", (channel, message) => {
+        this.subscribeClient.on("message", (channel, message) => {
             if (channel === this.multiClientChannel) {
                 //-- process message
                 const payload = JSON.parse(message);

package/dist/services/AbstractMailService.d.ts

@@ -1,3 +1,9 @@
+export interface Attachment {
+    filename: string;
+    contentType: string;
+    contentBase64: string;
+    contentId?: string;
+}
 export interface EmailInfo {
     sender: string;
     receivers: string[];
@@ -6,6 +12,7 @@ export interface EmailInfo {
     subject: string;
     content: string;
     contentType: "html" | "text";
+    attachments?: Attachment[];
 }
 export declare abstract class AbstractMailService {
     abstract send(email: EmailInfo): Promise<void>;

package/dist/services/implementations/LocalMailService.js

@@ -1,6 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { AbstractMailService } from "../AbstractMailService";
+import { buildMimeMessage } from "../utils/MimeBuilder";
 export class LocalMailService extends AbstractMailService {
     folderPath;
     constructor(folderPath) {
@@ -11,7 +12,13 @@ export class LocalMailService extends AbstractMailService {
         }
     }
     async send(email) {
-        //-- write email to local folder
+        if (!!email.attachments?.length) {
+            const emlFilePath = path.join(this.folderPath, `${Date.now()}.eml`);
+            const raw = buildMimeMessage(email);
+            fs.writeFileSync(emlFilePath, raw, { encoding: "utf-8" });
+            return;
+        }
+        //-- write simple email to local folder
         const mailFilePath = path.join(this.folderPath, `${Date.now()}.html`);
         fs.writeFileSync(mailFilePath, `
                 From: ${email.sender}\n

package/dist/services/implementations/SesMailService.js

@@ -7,9 +7,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { AbstractLogger, Errors, LogContext } from "@clairejs/core";
+import { AbstractLogger, LogContext } from "@clairejs/core";
 import aws from "aws-sdk";
 import { AbstractMailService } from "../AbstractMailService";
+import { buildMimeMessage } from "../utils/MimeBuilder";
 let SesMailService = class SesMailService extends AbstractMailService {
     config;
     logger;
@@ -21,40 +22,48 @@ let SesMailService = class SesMailService extends AbstractMailService {
         this.emailClient = new aws.SES({ apiVersion: "2010-12-01", region: this.config.SES_REGION });
     }
     async send(email) {
-        try {
-            const param = {
-                Destination: {
-                    BccAddresses: email.bcc,
-                    CcAddresses: email.cc,
-                    ToAddresses: email.receivers,
-                },
-                Message: {
-                    Body: {},
-                    Subject: {
-                        Charset: "UTF-8",
-                        Data: email.subject,
-                    },
-                },
+        const hasAttachments = !!(email.attachments && email.attachments.length > 0);
+        if (hasAttachments) {
+            const raw = buildMimeMessage(email);
+            const destinations = [...(email.receivers || []), ...(email.cc || []), ...(email.bcc || [])];
+            const rawParams = {
+                Destinations: destinations,
                 Source: email.sender,
+                RawMessage: {
+                    Data: Buffer.from(raw, "utf-8"),
+                },
             };
-            if (email.contentType === "html") {
-                param.Message.Body.Html = {
-                    Charset: "UTF-8",
-                    Data: email.content,
-                };
-            }
-            else if (email.contentType === "text") {
-                param.Message.Body.Text = {
+            await this.emailClient.sendRawEmail(rawParams).promise();
+            return;
+        }
+        const param = {
+            Destination: {
+                BccAddresses: email.bcc,
+                CcAddresses: email.cc,
+                ToAddresses: email.receivers,
+            },
+            Message: {
+                Body: {},
+                Subject: {
                     Charset: "UTF-8",
-                    Data: email.content,
-                };
-            }
-            await this.emailClient.sendEmail(param).promise();
+                    Data: email.subject,
+                },
+            },
+            Source: email.sender,
+        };
+        if (email.contentType === "html") {
+            param.Message.Body.Html = {
+                Charset: "UTF-8",
+                Data: email.content,
+            };
         }
-        catch (err) {
-            this.logger.error(err);
-            throw Errors.SYSTEM_ERROR("Cannot send email");
+        else if (email.contentType === "text") {
+            param.Message.Body.Text = {
+                Charset: "UTF-8",
+                Data: email.content,
+            };
         }
+        await this.emailClient.sendEmail(param).promise();
     }
 };
 SesMailService = __decorate([

package/dist/services/utils/MimeBuilder.d.ts

@@ -0,0 +1,4 @@
+import { Attachment, EmailInfo } from "../AbstractMailService";
+export type ParsedAttachment = Attachment;
+export declare function parseAttachments(attachments?: Attachment[]): ParsedAttachment[];
+export declare function buildMimeMessage(email: EmailInfo): string;

package/dist/services/utils/MimeBuilder.js

@@ -0,0 +1,93 @@
+export function parseAttachments(attachments) {
+    if (!attachments || attachments.length === 0)
+        return [];
+    return attachments
+        .map((att) => {
+        if (!att)
+            return undefined;
+        const filename = att.filename || att.name;
+        const contentType = att.contentType || att.mimeType || "application/octet-stream";
+        let contentBase64 = att.contentBase64 || att.base64 || att.content;
+        const contentId = att.contentId;
+        if (!filename || !contentBase64)
+            return undefined;
+        // Strip potential data URL prefixes
+        const commaIdx = contentBase64.indexOf(",");
+        if (contentBase64.startsWith("data:") && commaIdx !== -1) {
+            contentBase64 = contentBase64.substring(commaIdx + 1);
+        }
+        // Remove whitespace
+        contentBase64 = contentBase64.replace(/\s+/g, "");
+        return { filename, contentType, contentBase64, contentId };
+    })
+        .filter((x) => !!x);
+}
+function foldBase64(input, lineLength = 76) {
+    const chunks = [];
+    for (let i = 0; i < input.length; i += lineLength) {
+        chunks.push(input.substring(i, i + lineLength));
+    }
+    return chunks.join("\r\n");
+}
+function encodeHeaderValue(value) {
+    // Simple header escaping for newlines
+    return value.replace(/\r?\n/g, " ");
+}
+function toAddressHeader(name, emails) {
+    if (!emails || emails.length === 0)
+        return "";
+    return `${name}: ${emails.join(", ")}\r\n`;
+}
+function generateBoundary(prefix) {
+    return `${prefix}-${Math.random().toString(36).slice(2)}-${Date.now()}`;
+}
+export function buildMimeMessage(email) {
+    const attachments = parseAttachments(email.attachments);
+    const from = `From: ${encodeHeaderValue(email.sender)}\r\n`;
+    const to = toAddressHeader("To", email.receivers);
+    const cc = toAddressHeader("Cc", email.cc);
+    const subject = `Subject: ${encodeHeaderValue(email.subject)}\r\n`;
+    const mimeVersion = `MIME-Version: 1.0\r\n`;
+    // Build body part
+    const mainContentType = email.contentType === "html" ? "text/html" : "text/plain";
+    const bodyBase64 = Buffer.from(email.content, "utf-8").toString("base64");
+    const bodyPart = `Content-Type: ${mainContentType}; charset="UTF-8"\r\n` +
+        `Content-Transfer-Encoding: base64\r\n\r\n` +
+        `${foldBase64(bodyBase64)}\r\n`;
+    if (attachments.length === 0) {
+        // Simple single-part message
+        const headers = from +
+            to +
+            cc +
+            subject +
+            mimeVersion +
+            `Content-Type: ${mainContentType}; charset="UTF-8"\r\n` +
+            `Content-Transfer-Encoding: base64\r\n\r\n`;
+        return headers + foldBase64(bodyBase64) + "\r\n";
+    }
+    // Multipart/mixed with attachments
+    const mixedBoundary = generateBoundary("mixed");
+    let mime = "";
+    mime += from;
+    mime += to;
+    mime += cc;
+    mime += subject;
+    mime += mimeVersion;
+    mime += `Content-Type: multipart/mixed; boundary="${mixedBoundary}"\r\n\r\n`;
+    // Body part
+    mime += `--${mixedBoundary}\r\n`;
+    mime += bodyPart;
+    // Attachments
+    for (const att of attachments) {
+        mime += `--${mixedBoundary}\r\n`;
+        mime += `Content-Type: ${att.contentType}; name="${encodeHeaderValue(att.filename)}"\r\n`;
+        mime += `Content-Disposition: attachment; filename="${encodeHeaderValue(att.filename)}"\r\n`;
+        if (att.contentId) {
+            mime += `Content-ID: <${encodeHeaderValue(att.contentId)}>\r\n`;
+        }
+        mime += `Content-Transfer-Encoding: base64\r\n\r\n`;
+        mime += `${foldBase64(att.contentBase64)}\r\n`;
+    }
+    mime += `--${mixedBoundary}--\r\n`;
+    return mime;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clairejs/server",
-    "version": "3.28.9",
+    "version": "3.28.11",
     "description": "Claire server NodeJs framework written in Typescript.",
     "types": "dist/index.d.ts",
     "main": "dist/index.js",