@rebasepro/server-core 0.2.5 → 0.4.0

package/src/storage/image-transform.ts

@@ -6,9 +6,10 @@
  * in-memory cache to avoid redundant processing.
  */
 
-// Lazy-load sharp to avoid crashing when it isn't installed (e.g. in tests)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 let sharpFactory: ((input: Buffer | Uint8Array) => any) | undefined;
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function getSharp(): Promise<(input: Buffer | Uint8Array) => any> {
     if (!sharpFactory) {
         try {

package/test/smtp-email-service.test.ts

@@ -0,0 +1,169 @@
+import { SMTPEmailService } from "../src/email/smtp-email-service";
+import nodemailer from "nodemailer";
+
+jest.mock("nodemailer", () => {
+    const mockTransporter = {
+        verify: jest.fn().mockResolvedValue(true),
+        sendMail: jest.fn().mockResolvedValue(true),
+    };
+    return {
+        createTransport: jest.fn().mockReturnValue(mockTransporter),
+    };
+});
+
+describe("SMTPEmailService", () => {
+    let mockCreateTransport: jest.Mock;
+    let mockTransporter: any;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockCreateTransport = nodemailer.createTransport as jest.Mock;
+        mockTransporter = mockCreateTransport({} as any); // gets the mocked object
+        mockCreateTransport.mockClear();
+    });
+
+    it("should create transport with explicit name", () => {
+        new SMTPEmailService({
+            from: "test@example.com",
+            smtp: {
+                host: "smtp.example.com",
+                port: 587,
+                name: "explicit-hostname",
+            },
+        });
+
+        expect(mockCreateTransport).toHaveBeenCalledWith(
+            expect.objectContaining({
+                name: "explicit-hostname",
+                host: "smtp.example.com",
+                port: 587,
+            })
+        );
+    });
+
+    it("should infer name from FRONTEND_URL if smtp.name is undefined", () => {
+        const originalFrontendUrl = process.env.FRONTEND_URL;
+        process.env.FRONTEND_URL = "https://frontend-url.com/some-path";
+
+        try {
+            new SMTPEmailService({
+                from: "test@example.com",
+                smtp: {
+                    host: "smtp.example.com",
+                    port: 587,
+                },
+            });
+
+            expect(mockCreateTransport).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    name: "frontend-url.com",
+                })
+            );
+        } finally {
+            process.env.FRONTEND_URL = originalFrontendUrl;
+        }
+    });
+
+    it("should infer name from resetPasswordUrl if FRONTEND_URL and smtp.name are undefined", () => {
+        const originalFrontendUrl = process.env.FRONTEND_URL;
+        delete process.env.FRONTEND_URL;
+
+        try {
+            new SMTPEmailService({
+                from: "test@example.com",
+                smtp: {
+                    host: "smtp.example.com",
+                    port: 587,
+                },
+                resetPasswordUrl: "http://reset-password-url.org",
+            });
+
+            expect(mockCreateTransport).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    name: "reset-password-url.org",
+                })
+            );
+        } finally {
+            process.env.FRONTEND_URL = originalFrontendUrl;
+        }
+    });
+
+    it("should infer name from verifyEmailUrl if FRONTEND_URL, resetPasswordUrl and smtp.name are undefined", () => {
+        const originalFrontendUrl = process.env.FRONTEND_URL;
+        delete process.env.FRONTEND_URL;
+
+        try {
+            new SMTPEmailService({
+                from: "test@example.com",
+                smtp: {
+                    host: "smtp.example.com",
+                    port: 587,
+                },
+                verifyEmailUrl: "verify-email-url.net/auth",
+            });
+
+            expect(mockCreateTransport).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    name: "verify-email-url.net",
+                })
+            );
+        } finally {
+            process.env.FRONTEND_URL = originalFrontendUrl;
+        }
+    });
+
+    it("should leave name undefined if no URLs are provided", () => {
+        const originalFrontendUrl = process.env.FRONTEND_URL;
+        delete process.env.FRONTEND_URL;
+
+        try {
+            new SMTPEmailService({
+                from: "test@example.com",
+                smtp: {
+                    host: "smtp.example.com",
+                    port: 587,
+                },
+            });
+
+            expect(mockCreateTransport).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    name: undefined,
+                })
+            );
+        } finally {
+            process.env.FRONTEND_URL = originalFrontendUrl;
+        }
+    });
+
+    it("should successfully verify SMTP connection", async () => {
+        mockTransporter.verify.mockResolvedValueOnce(true);
+
+        const service = new SMTPEmailService({
+            from: "test@example.com",
+            smtp: {
+                host: "smtp.example.com",
+                port: 587,
+            },
+        });
+
+        const verified = await service.verifyConnection();
+        expect(verified).toBe(true);
+        expect(mockTransporter.verify).toHaveBeenCalled();
+    });
+
+    it("should return false if SMTP connection verification fails", async () => {
+        mockTransporter.verify.mockRejectedValueOnce(new Error("Connection timeout"));
+
+        const service = new SMTPEmailService({
+            from: "test@example.com",
+            smtp: {
+                host: "smtp.example.com",
+                port: 587,
+            },
+        });
+
+        const verified = await service.verifyConnection();
+        expect(verified).toBe(false);
+        expect(mockTransporter.verify).toHaveBeenCalled();
+    });
+});