@rebasepro/server-core 0.4.0 → 0.6.0

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

@@ -32,13 +32,25 @@ function createMockDriver(): jest.Mocked<DataDriver> {
 }
 
 const mockCollections: EntityCollection[] = [
-    { slug: "products", name: "Products", singularName: "Product", properties: {} } as any,
-    { slug: "orders", name: "Orders", singularName: "Order", properties: {} } as any
+    { slug: "products",
+name: "Products",
+singularName: "Product",
+properties: {} } as any,
+    { slug: "orders",
+name: "Orders",
+singularName: "Order",
+properties: {} } as any
 ];
 
 function createApp(mockDriver: jest.Mocked<DataDriver>, hooks?: DataHooks) {
     const app = new Hono();
     app.onError(errorHandler);
+    // RestApiGenerator.getScopedDriver reads from c.get("driver") which is
+    // normally set by auth middleware. Replicate that here for tests.
+    app.use("/api/*", async (c, next) => {
+        c.set("driver", mockDriver);
+        await next();
+    });
     const generator = new RestApiGenerator(mockCollections, mockDriver, hooks);
     app.route("/api", generator.generateRoutes());
     return app;
@@ -62,7 +74,8 @@ describe("DataHooks — REST API", () => {
                 afterRead(slug, entity) {
                     // Mask price for non-premium entities
                     if (slug === "products") {
-                        return { ...entity, price: "***" };
+                        return { ...entity,
+price: "***" };
                     }
                     return entity;
                 }
@@ -70,8 +83,14 @@ describe("DataHooks — REST API", () => {
             const app = createApp(mockDriver, hooks);
 
             mockDriver.fetchCollection.mockResolvedValue([
-                { id: "p1", path: "products", values: { name: "Widget", price: 99 } } as any,
-                { id: "p2", path: "products", values: { name: "Gadget", price: 199 } } as any
+                { id: "p1",
+path: "products",
+values: { name: "Widget",
+price: 99 } } as any,
+                { id: "p2",
+path: "products",
+values: { name: "Gadget",
+price: 199 } } as any
             ]);
             mockDriver.countEntities!.mockResolvedValue(2);
 
@@ -97,9 +116,18 @@ describe("DataHooks — REST API", () => {
             const app = createApp(mockDriver, hooks);
 
             mockDriver.fetchCollection.mockResolvedValue([
-                { id: "p1", path: "products", values: { name: "Published", status: "active" } } as any,
-                { id: "p2", path: "products", values: { name: "Draft", status: "draft" } } as any,
-                { id: "p3", path: "products", values: { name: "Also Published", status: "active" } } as any
+                { id: "p1",
+path: "products",
+values: { name: "Published",
+status: "active" } } as any,
+                { id: "p2",
+path: "products",
+values: { name: "Draft",
+status: "draft" } } as any,
+                { id: "p3",
+path: "products",
+values: { name: "Also Published",
+status: "active" } } as any
             ]);
             mockDriver.countEntities!.mockResolvedValue(3);
 
@@ -112,13 +140,16 @@ describe("DataHooks — REST API", () => {
         it("transforms single entity GET response", async () => {
             const hooks: DataHooks = {
                 afterRead(slug, entity) {
-                    return { ...entity, _readAt: "2024-01-01" };
+                    return { ...entity,
+_readAt: "2024-01-01" };
                 }
             };
             const app = createApp(mockDriver, hooks);
 
             mockDriver.fetchEntity.mockResolvedValue(
-                { id: "p1", path: "products", values: { name: "Widget" } } as any
+                { id: "p1",
+path: "products",
+values: { name: "Widget" } } as any
             );
 
             const res = await app.request("/api/products/p1");
@@ -139,7 +170,9 @@ describe("DataHooks — REST API", () => {
             const app = createApp(mockDriver, hooks);
 
             mockDriver.fetchEntity.mockResolvedValue(
-                { id: "hidden", path: "products", values: { name: "Secret" } } as any
+                { id: "hidden",
+path: "products",
+values: { name: "Secret" } } as any
             );
 
             const res = await app.request("/api/products/hidden");
@@ -150,7 +183,8 @@ describe("DataHooks — REST API", () => {
             const hooks: DataHooks = {
                 afterRead(slug, entity) {
                     if (slug === "products") {
-                        return { ...entity, hooked: true };
+                        return { ...entity,
+hooked: true };
                     }
                     return entity;
                 }
@@ -159,7 +193,9 @@ describe("DataHooks — REST API", () => {
 
             // Products should be hooked
             mockDriver.fetchEntity.mockResolvedValueOnce(
-                { id: "p1", path: "products", values: { name: "Widget" } } as any
+                { id: "p1",
+path: "products",
+values: { name: "Widget" } } as any
             );
             const prodRes = await app.request("/api/products/p1");
             const prodBody = await prodRes.json() as any;
@@ -167,7 +203,9 @@ describe("DataHooks — REST API", () => {
 
             // Orders should NOT be hooked
             mockDriver.fetchEntity.mockResolvedValueOnce(
-                { id: "o1", path: "orders", values: { total: 42 } } as any
+                { id: "o1",
+path: "orders",
+values: { total: 42 } } as any
             );
             const orderRes = await app.request("/api/orders/o1");
             const orderBody = await orderRes.json() as any;
@@ -180,13 +218,17 @@ describe("DataHooks — REST API", () => {
         it("transforms values before POST (create)", async () => {
             const hooks: DataHooks = {
                 beforeSave(slug, values, entityId) {
-                    return { ...values, slug: values.name?.toString().toLowerCase().replace(/\s+/g, "-") };
+                    return { ...values,
+slug: values.name?.toString().toLowerCase().replace(/\s+/g, "-") };
                 }
             };
             const app = createApp(mockDriver, hooks);
 
             mockDriver.saveEntity.mockResolvedValue(
-                { id: "new-1", path: "products", values: { name: "Cool Widget", slug: "cool-widget" } } as any
+                { id: "new-1",
+path: "products",
+values: { name: "Cool Widget",
+slug: "cool-widget" } } as any
             );
 
             const res = await app.request("/api/products", {
@@ -207,14 +249,20 @@ describe("DataHooks — REST API", () => {
             const hooks: DataHooks = {
                 beforeSave(slug, values, entityId) {
                     // Add an updatedBy field
-                    return { ...values, updatedBy: "hook" };
+                    return { ...values,
+updatedBy: "hook" };
                 }
             };
             const app = createApp(mockDriver, hooks);
 
-            mockDriver.fetchEntity.mockResolvedValue({ id: "p1", path: "products", values: {} } as any);
+            mockDriver.fetchEntity.mockResolvedValue({ id: "p1",
+path: "products",
+values: {} } as any);
             mockDriver.saveEntity.mockResolvedValue(
-                { id: "p1", path: "products", values: { name: "Updated", updatedBy: "hook" } } as any
+                { id: "p1",
+path: "products",
+values: { name: "Updated",
+updatedBy: "hook" } } as any
             );
 
             const res = await app.request("/api/products/p1", {
@@ -238,7 +286,9 @@ describe("DataHooks — REST API", () => {
 
             // POST
             mockDriver.saveEntity.mockResolvedValueOnce(
-                { id: "new-1", path: "products", values: { name: "A" } } as any
+                { id: "new-1",
+path: "products",
+values: { name: "A" } } as any
             );
             await app.request("/api/products", {
                 method: "POST",
@@ -248,9 +298,13 @@ describe("DataHooks — REST API", () => {
             expect(beforeSaveSpy.mock.calls[0][2]).toBeUndefined(); // entityId
 
             // PUT
-            mockDriver.fetchEntity.mockResolvedValueOnce({ id: "p1", path: "products", values: {} } as any);
+            mockDriver.fetchEntity.mockResolvedValueOnce({ id: "p1",
+path: "products",
+values: {} } as any);
             mockDriver.saveEntity.mockResolvedValueOnce(
-                { id: "p1", path: "products", values: { name: "B" } } as any
+                { id: "p1",
+path: "products",
+values: { name: "B" } } as any
             );
             await app.request("/api/products/p1", {
                 method: "PUT",
@@ -289,7 +343,9 @@ describe("DataHooks — REST API", () => {
             const app = createApp(mockDriver, hooks);
 
             mockDriver.saveEntity.mockResolvedValue(
-                { id: "new-1", path: "products", values: { name: "Widget" } } as any
+                { id: "new-1",
+path: "products",
+values: { name: "Widget" } } as any
             );
 
             const res = await app.request("/api/products", {
@@ -303,7 +359,8 @@ describe("DataHooks — REST API", () => {
             expect(afterSaveSpy).toHaveBeenCalledTimes(1);
             expect(afterSaveSpy).toHaveBeenCalledWith(
                 "products",
-                expect.objectContaining({ id: "new-1", name: "Widget" }),
+                expect.objectContaining({ id: "new-1",
+name: "Widget" }),
                 expect.objectContaining({ method: "POST" })
             );
         });
@@ -313,9 +370,13 @@ describe("DataHooks — REST API", () => {
             const hooks: DataHooks = { afterSave: afterSaveSpy };
             const app = createApp(mockDriver, hooks);
 
-            mockDriver.fetchEntity.mockResolvedValue({ id: "p1", path: "products", values: {} } as any);
+            mockDriver.fetchEntity.mockResolvedValue({ id: "p1",
+path: "products",
+values: {} } as any);
             mockDriver.saveEntity.mockResolvedValue(
-                { id: "p1", path: "products", values: { name: "Updated" } } as any
+                { id: "p1",
+path: "products",
+values: { name: "Updated" } } as any
             );
 
             await app.request("/api/products/p1", {
@@ -346,7 +407,9 @@ describe("DataHooks — REST API", () => {
             const app = createApp(mockDriver, hooks);
 
             mockDriver.fetchEntity.mockResolvedValue(
-                { id: "protected", path: "products", values: {} } as any
+                { id: "protected",
+path: "products",
+values: {} } as any
             );
 
             const res = await app.request("/api/products/protected", { method: "DELETE" });
@@ -359,7 +422,9 @@ describe("DataHooks — REST API", () => {
             const hooks: DataHooks = { beforeDelete: beforeDeleteSpy };
             const app = createApp(mockDriver, hooks);
 
-            const existingEntity = { id: "p1", path: "products", values: {} } as any;
+            const existingEntity = { id: "p1",
+path: "products",
+values: {} } as any;
             mockDriver.fetchEntity.mockResolvedValue(existingEntity);
             mockDriver.deleteEntity.mockResolvedValue();
 
@@ -376,7 +441,9 @@ describe("DataHooks — REST API", () => {
             const hooks: DataHooks = { afterDelete: afterDeleteSpy };
             const app = createApp(mockDriver, hooks);
 
-            mockDriver.fetchEntity.mockResolvedValue({ id: "p1", path: "products", values: {} } as any);
+            mockDriver.fetchEntity.mockResolvedValue({ id: "p1",
+path: "products",
+values: {} } as any);
             mockDriver.deleteEntity.mockResolvedValue();
 
             await app.request("/api/products/p1", { method: "DELETE" });
@@ -393,7 +460,9 @@ describe("DataHooks — REST API", () => {
         it("returns data unchanged when no hooks are provided", async () => {
             const app = createApp(mockDriver); // no hooks
             mockDriver.fetchCollection.mockResolvedValue([
-                { id: "p1", path: "products", values: { name: "Widget" } } as any
+                { id: "p1",
+path: "products",
+values: { name: "Widget" } } as any
             ]);
             mockDriver.countEntities!.mockResolvedValue(1);
 

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

@@ -7,20 +7,20 @@ const TEST_USER: AuthenticatedUser = {
     displayName: "Test User",
     roles: ["editor"],
     isAdmin: false,
-    rawToken: "tok_abc",
+    rawToken: "tok_abc"
 };
 
 const ADMIN_USER: AuthenticatedUser = {
     uid: "admin-1",
     email: "admin@example.com",
     roles: ["admin"],
-    isAdmin: true,
+    isAdmin: true
 };
 
 describe("createCustomAuthAdapter", () => {
     it("sets the adapter id to 'custom'", () => {
         const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
+            verifyRequest: async () => null
         });
         expect(adapter.id).toBe("custom");
     });
@@ -29,7 +29,7 @@ describe("createCustomAuthAdapter", () => {
         const verifyRequest = jest.fn(async () => TEST_USER);
         const adapter = createCustomAuthAdapter({ verifyRequest });
         const req = new Request("http://localhost/api", {
-            headers: { Authorization: "Bearer test-token" },
+            headers: { Authorization: "Bearer test-token" }
         });
         const result = await adapter.verifyRequest(req);
         expect(verifyRequest).toHaveBeenCalledWith(req);
@@ -38,7 +38,7 @@ describe("createCustomAuthAdapter", () => {
 
     it("returns null from verifyRequest when the user function returns null", async () => {
         const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
+            verifyRequest: async () => null
         });
         const result = await adapter.verifyRequest(new Request("http://localhost/"));
         expect(result).toBeNull();
@@ -68,7 +68,7 @@ describe("createCustomAuthAdapter", () => {
 
     it("returns null from fallback verifyToken for invalid token", async () => {
         const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
+            verifyRequest: async () => null
         });
         const result = await adapter.verifyToken!("bad-token");
         expect(result).toBeNull();
@@ -84,7 +84,7 @@ describe("createCustomAuthAdapter", () => {
         const verifyRequest = jest.fn(async () => null);
         const adapter = createCustomAuthAdapter({
             verifyRequest,
-            verifyToken: customVerifyToken,
+            verifyToken: customVerifyToken
         });
 
         const result = await adapter.verifyToken!("direct-token");
@@ -97,7 +97,7 @@ describe("createCustomAuthAdapter", () => {
     it("returns null from user-provided verifyToken for unknown token", async () => {
         const adapter = createCustomAuthAdapter({
             verifyRequest: async () => null,
-            verifyToken: async () => null,
+            verifyToken: async () => null
         });
         const result = await adapter.verifyToken!("unknown");
         expect(result).toBeNull();
@@ -107,7 +107,7 @@ describe("createCustomAuthAdapter", () => {
 
     it("returns default capabilities when none are overridden", async () => {
         const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
+            verifyRequest: async () => null
         });
         const caps = await adapter.getCapabilities!();
         expect(caps).toEqual({
@@ -118,14 +118,15 @@ describe("createCustomAuthAdapter", () => {
             sessionManagement: false,
             profileUpdate: false,
             emailVerification: false,
-            enabledProviders: [],
+            enabledProviders: []
         });
     });
 
     it("merges user-provided capabilities with defaults", async () => {
         const adapter = createCustomAuthAdapter({
             verifyRequest: async () => null,
-            capabilities: { emailPasswordLogin: true, registration: true },
+            capabilities: { emailPasswordLogin: true,
+registration: true }
         });
         const caps = await adapter.getCapabilities!();
         expect(caps.emailPasswordLogin).toBe(true);
@@ -138,7 +139,7 @@ describe("createCustomAuthAdapter", () => {
     it("passes through serviceKey", () => {
         const adapter = createCustomAuthAdapter({
             verifyRequest: async () => null,
-            serviceKey: "sk_live_123",
+            serviceKey: "sk_live_123"
         });
         expect(adapter.serviceKey).toBe("sk_live_123");
     });
@@ -149,12 +150,12 @@ describe("createCustomAuthAdapter", () => {
             listUsers: jest.fn(),
             createUser: jest.fn(),
             updateUser: jest.fn(),
-            deleteUser: jest.fn(),
+            deleteUser: jest.fn()
         };
 
         const adapter = createCustomAuthAdapter({
             verifyRequest: async () => null,
-            userManagement: userMgmt as unknown as CustomAuthAdapterOptions["userManagement"],
+            userManagement: userMgmt as unknown as CustomAuthAdapterOptions["userManagement"]
         });
 
         expect(adapter.userManagement).toBe(userMgmt);
@@ -162,7 +163,7 @@ describe("createCustomAuthAdapter", () => {
 
     it("omits userManagement when not provided", () => {
         const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
+            verifyRequest: async () => null
         });
         expect(adapter.userManagement).toBeUndefined();
     });

package/test/email-templates.test.ts

@@ -6,7 +6,8 @@ import {
 } from "../src/email/templates";
 
 describe("getPasswordResetTemplate", () => {
-    const user = { email: "john@example.com", displayName: "John Doe" };
+    const user = { email: "john@example.com",
+displayName: "John Doe" };
     const resetUrl = "https://example.com/reset?token=abc123";
 
     it("returns subject, html, and text", () => {
@@ -43,7 +44,8 @@ describe("getPasswordResetTemplate", () => {
     });
 
     it("falls back to email prefix when displayName is null", () => {
-        const userNoName = { email: "jane@example.com", displayName: null };
+        const userNoName = { email: "jane@example.com",
+displayName: null };
         const result = getPasswordResetTemplate(resetUrl, userNoName);
         expect(result.html).toContain("jane");
         expect(result.text).toContain("jane");
@@ -58,7 +60,8 @@ describe("getPasswordResetTemplate", () => {
 });
 
 describe("getEmailVerificationTemplate", () => {
-    const user = { email: "alice@example.com", displayName: "Alice" };
+    const user = { email: "alice@example.com",
+displayName: "Alice" };
     const verifyUrl = "https://example.com/verify?token=xyz789";
 
     it("returns subject, html, and text", () => {
@@ -96,7 +99,8 @@ describe("getEmailVerificationTemplate", () => {
 });
 
 describe("getUserInvitationTemplate", () => {
-    const user = { email: "bob@example.com", displayName: "Bob" };
+    const user = { email: "bob@example.com",
+displayName: "Bob" };
     const setPasswordUrl = "https://example.com/set-password?token=def456";
 
     it("returns subject, html, and text", () => {
@@ -129,7 +133,8 @@ describe("getUserInvitationTemplate", () => {
 });
 
 describe("getWelcomeEmailTemplate", () => {
-    const user = { email: "dave@example.com", displayName: "Dave" };
+    const user = { email: "dave@example.com",
+displayName: "Dave" };
 
     it("returns subject, html, and text", () => {
         const result = getWelcomeEmailTemplate(user);

package/test/env.test.ts

@@ -38,7 +38,7 @@ describe("env configuration and localhost validation", () => {
         process.env.JWT_SECRET = "12345678901234567890123456789012";
         process.env.FRONTEND_URL = "https://my-app.com";
 
-        expect(() => loadEnv()).toThrowError(/postgresql:\/\/localhost:5432\/rebase/);
+        expect(() => loadEnv()).toThrow(/postgresql:\/\/localhost:5432\/rebase/);
     });
 
     it("should fail validation in production if DATABASE_URL contains 127.0.0.1", () => {
@@ -47,7 +47,7 @@ describe("env configuration and localhost validation", () => {
         process.env.JWT_SECRET = "12345678901234567890123456789012";
         process.env.FRONTEND_URL = "https://my-app.com";
 
-        expect(() => loadEnv()).toThrowError(/postgresql:\/\/127\.0\.0\.1:5432\/rebase/);
+        expect(() => loadEnv()).toThrow(/postgresql:\/\/127\.0\.0\.1:5432\/rebase/);
     });
 
     it("should fail validation in production if DATABASE_URL contains an IPv6 loopback [::1]", () => {
@@ -56,7 +56,7 @@ describe("env configuration and localhost validation", () => {
         process.env.JWT_SECRET = "12345678901234567890123456789012";
         process.env.FRONTEND_URL = "https://my-app.com";
 
-        expect(() => loadEnv()).toThrowError(/postgresql:\/\/\[::1\]:5432\/rebase/);
+        expect(() => loadEnv()).toThrow(/postgresql:\/\/\[::1\]:5432\/rebase/);
     });
 
     it("should fail validation in production if DATABASE_URL contains a loopback in the 127.x.x.x range", () => {
@@ -65,7 +65,7 @@ describe("env configuration and localhost validation", () => {
         process.env.JWT_SECRET = "12345678901234567890123456789012";
         process.env.FRONTEND_URL = "https://my-app.com";
 
-        expect(() => loadEnv()).toThrowError(/postgresql:\/\/127\.0\.0\.2:5432\/rebase/);
+        expect(() => loadEnv()).toThrow(/postgresql:\/\/127\.0\.0\.2:5432\/rebase/);
     });
 
     it("should succeed validation in production with a non-localhost DATABASE_URL", () => {
@@ -113,11 +113,11 @@ describe("env configuration and localhost validation", () => {
 
         const extension = {
             extend: z.object({
-                EXTERNAL_SERVICE_URL: z.string().url(),
-            }),
+                EXTERNAL_SERVICE_URL: z.string().url()
+            })
         };
 
-        expect(() => loadEnv(extension)).toThrowError(/https:\/\/localhost:8080\/api/);
+        expect(() => loadEnv(extension)).toThrow(/https:\/\/localhost:8080\/api/);
     });
 
     it("should validate and block plain host string matching localhost", () => {
@@ -129,10 +129,10 @@ describe("env configuration and localhost validation", () => {
 
         const extension = {
             extend: z.object({
-                DB_HOST: z.string(),
-            }),
+                DB_HOST: z.string()
+            })
         };
 
-        expect(() => loadEnv(extension)).toThrowError(/localhost/);
+        expect(() => loadEnv(extension)).toThrow(/localhost/);
     });
 });

package/test/function-loader.test.ts

@@ -62,7 +62,8 @@ describe("Function Loader & Routes", () => {
     afterAll(() => {
         // Clean up temp directory
         if (tempDir && fs.existsSync(tempDir)) {
-            fs.rmSync(tempDir, { recursive: true, force: true });
+            fs.rmSync(tempDir, { recursive: true,
+force: true });
         }
     });
 
@@ -101,12 +102,14 @@ describe("Function Loader & Routes", () => {
             // 1. Verify GET / lists loaded functions
             const listRes = await routes.request("/");
             expect(listRes.status).toBe(200);
-            
+
             const listData = await listRes.json();
             expect(listData).toEqual({
                 functions: [
-                    { name: "valid-app", endpoint: "/functions/valid-app" },
-                    { name: "valid-factory", endpoint: "/functions/valid-factory" }
+                    { name: "valid-app",
+endpoint: "/functions/valid-app" },
+                    { name: "valid-factory",
+endpoint: "/functions/valid-factory" }
                 ]
             });