@rebasepro/server-core 0.3.0 → 0.4.0

package/test/admin-routes.test.ts

@@ -540,174 +540,5 @@ displayName: "Updated" }),
         });
     });
 
-    // ── Role CRUD ───────────────────────────────────────────────────────
-    describe("Role Management", () => {
-        describe("GET /admin/roles", () => {
-            it("returns list of roles", async () => {
-                const app = createApp();
-                mockAuthRepo.listRoles.mockResolvedValueOnce([
-                    mockRole("admin", true),
-                    mockRole("editor"),
-                    mockRole("viewer")
-                ]);
-
-                const res = await app.request("/admin/roles", { headers: { ...adminAuth() } });
-                expect(res.status).toBe(200);
-                const body = await res.json() as any;
-                expect(body.roles).toHaveLength(3);
-                expect(body.roles[0].isAdmin).toBe(true);
-            });
-        });
-
-        describe("GET /admin/roles/:roleId", () => {
-            it("returns role by ID", async () => {
-                const app = createApp();
-                mockAuthRepo.getRoleById.mockResolvedValueOnce(mockRole("admin", true));
-
-                const res = await app.request("/admin/roles/admin", { headers: { ...adminAuth() } });
-                expect(res.status).toBe(200);
-                const body = await res.json() as any;
-                expect(body.role.id).toBe("admin");
-                expect(body.role.isAdmin).toBe(true);
-            });
-
-            it("returns 404 for non-existent role", async () => {
-                const app = createApp();
-                mockAuthRepo.getRoleById.mockResolvedValueOnce(null);
-
-                const res = await app.request("/admin/roles/missing", { headers: { ...adminAuth() } });
-                expect(res.status).toBe(404);
-            });
-        });
-
-        describe("POST /admin/roles", () => {
-            it("creates a new role", async () => {
-                const app = createApp();
-
-                const res = await app.request("/admin/roles", {
-                    ...json({ id: "custom",
-name: "Custom Role" }),
-                    headers: { ...json({}).headers,
-...adminAuth() }
-                });
-                expect(res.status).toBe(201);
-                const body = await res.json() as any;
-                expect(body.role.id).toBe("custom");
-            });
 
-            it("returns 400 for missing id or name", async () => {
-                const app = createApp();
-
-                const res = await app.request("/admin/roles", {
-                    ...json({ id: "nope" }),
-                    headers: { ...json({}).headers,
-...adminAuth() }
-                });
-                expect(res.status).toBe(400);
-            });
-
-            it("returns 409 when role already exists", async () => {
-                const app = createApp();
-                mockAuthRepo.getRoleById.mockResolvedValueOnce(mockRole("custom"));
-
-                const res = await app.request("/admin/roles", {
-                    ...json({ id: "custom",
-name: "Dup" }),
-                    headers: { ...json({}).headers,
-...adminAuth() }
-                });
-                expect(res.status).toBe(409);
-                const body = await res.json() as any;
-                expect(body.error.code).toBe("ROLE_EXISTS");
-            });
-        });
-
-        describe("PUT /admin/roles/:roleId", () => {
-            it("updates an existing role", async () => {
-                const app = createApp();
-                mockAuthRepo.getRoleById.mockResolvedValueOnce(mockRole("editor"));
-
-                const res = await app.request("/admin/roles/editor", {
-                    method: "PUT",
-                    headers: { "Content-Type": "application/json",
-...adminAuth() },
-                    body: JSON.stringify({ name: "Super Editor" })
-                });
-                expect(res.status).toBe(200);
-                expect(mockAuthRepo.updateRole).toHaveBeenCalledWith("editor", expect.objectContaining({
-                    name: "Super Editor"
-                }));
-            });
-
-            it("returns 404 for non-existent role", async () => {
-                const app = createApp();
-                mockAuthRepo.getRoleById.mockResolvedValueOnce(null);
-
-                const res = await app.request("/admin/roles/missing", {
-                    method: "PUT",
-                    headers: { "Content-Type": "application/json",
-...adminAuth() },
-                    body: JSON.stringify({ name: "Nope" })
-                });
-                expect(res.status).toBe(404);
-            });
-        });
-
-        describe("DELETE /admin/roles/:roleId", () => {
-            it("deletes a custom role", async () => {
-                const app = createApp();
-                mockAuthRepo.getRoleById.mockResolvedValueOnce(mockRole("custom"));
-
-                const res = await app.request("/admin/roles/custom", {
-                    method: "DELETE",
-                    headers: { ...adminAuth() }
-                });
-                expect(res.status).toBe(200);
-                expect(mockAuthRepo.deleteRole).toHaveBeenCalledWith("custom");
-            });
-
-            it("prevents deletion of built-in admin role", async () => {
-                const app = createApp();
-
-                const res = await app.request("/admin/roles/admin", {
-                    method: "DELETE",
-                    headers: { ...adminAuth() }
-                });
-                expect(res.status).toBe(400);
-                const body = await res.json() as any;
-                expect(body.error.code).toBe("BUILTIN_ROLE");
-            });
-
-            it("prevents deletion of built-in editor role", async () => {
-                const app = createApp();
-
-                const res = await app.request("/admin/roles/editor", {
-                    method: "DELETE",
-                    headers: { ...adminAuth() }
-                });
-                expect(res.status).toBe(400);
-            });
-
-            it("prevents deletion of built-in viewer role", async () => {
-                const app = createApp();
-
-                const res = await app.request("/admin/roles/viewer", {
-                    method: "DELETE",
-                    headers: { ...adminAuth() }
-                });
-                expect(res.status).toBe(400);
-            });
-
-            it("returns 404 for non-existent role", async () => {
-                const app = createApp();
-                mockAuthRepo.getRoleById.mockResolvedValueOnce(null);
-
-                const res = await app.request("/admin/roles/ghost", {
-                    method: "DELETE",
-                    headers: { ...adminAuth() }
-                });
-                expect(res.status).toBe(404);
-            });
-        });
-    });
 });

package/test/backend-hooks-admin.test.ts

@@ -362,32 +362,7 @@ describe("BackendHooks — Admin Routes", () => {
         });
     });
 
-    // ── roles.afterRead ─────────────────────────────────────────────────
-    describe("roles.afterRead", () => {
-        it("filters out roles from GET /admin/roles", async () => {
-            const hooks: BackendHooks = {
-                roles: {
-                    afterRead(role) {
-                        // Hide internal roles
-                        if (role.id === "internal") return null;
-                        return role;
-                    }
-                }
-            };
-            const app = createApp(hooks);
-            mockAuthRepo.listRoles.mockResolvedValueOnce([
-                mockRole("admin", true),
-                mockRole("internal"),
-                mockRole("editor")
-            ]);
 
-            const res = await app.request("/admin/roles", { headers: { ...adminAuth() } });
-            expect(res.status).toBe(200);
-            const body = await res.json() as any;
-            expect(body.roles).toHaveLength(2);
-            expect(body.roles.map((r: any) => r.id)).toEqual(["admin", "editor"]);
-        });
-    });
 
     // ── no hooks (passthrough) ──────────────────────────────────────────
     describe("no hooks configured", () => {

package/test/custom-auth-adapter.test.ts

@@ -143,7 +143,7 @@ describe("createCustomAuthAdapter", () => {
         expect(adapter.serviceKey).toBe("sk_live_123");
     });
 
-    it("passes through userManagement and roleManagement when provided", () => {
+    it("passes through userManagement when provided", () => {
         const userMgmt = {
             getUser: jest.fn(),
             listUsers: jest.fn(),
@@ -151,27 +151,19 @@ describe("createCustomAuthAdapter", () => {
             updateUser: jest.fn(),
             deleteUser: jest.fn(),
         };
-        const roleMgmt = {
-            listRoles: jest.fn(),
-            getUserRoles: jest.fn(),
-            setUserRoles: jest.fn(),
-        };
 
         const adapter = createCustomAuthAdapter({
             verifyRequest: async () => null,
             userManagement: userMgmt as unknown as CustomAuthAdapterOptions["userManagement"],
-            roleManagement: roleMgmt as unknown as CustomAuthAdapterOptions["roleManagement"],
         });
 
         expect(adapter.userManagement).toBe(userMgmt);
-        expect(adapter.roleManagement).toBe(roleMgmt);
     });
 
-    it("omits userManagement and roleManagement when not provided", () => {
+    it("omits userManagement when not provided", () => {
         const adapter = createCustomAuthAdapter({
             verifyRequest: async () => null,
         });
         expect(adapter.userManagement).toBeUndefined();
-        expect(adapter.roleManagement).toBeUndefined();
     });
 });

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();
+    });
+});

package/dist/types/src/users/roles.d.ts

@@ -1,14 +0,0 @@
-export type Role = {
-    /**
-     * ID of the role
-     */
-    id: string;
-    /**
-     * Name of the role
-     */
-    name: string;
-    /**
-     * If this flag is true, the user can perform any action
-     */
-    isAdmin?: boolean;
-};