bxo 0.0.5-dev.6 → 0.0.5-dev.61

package/tests/unit/utils.test.ts

@@ -0,0 +1,433 @@
+import { describe, it, expect } from 'bun:test';
+import {
+  parseQuery,
+  parseHeaders,
+  parseCookies,
+  validateData,
+  validateResponse,
+  parseRequestBody,
+  cookiesToHeaders,
+  mergeHeadersWithCookies,
+  createRedirectResponse,
+  isFileUpload,
+  getFileFromUpload,
+  getFileInfo,
+  getFileUploads,
+  getFormFields
+} from '../../src/utils';
+import { z } from 'zod';
+
+describe('Utility Functions', () => {
+  describe('parseQuery', () => {
+    it('should parse URLSearchParams correctly', () => {
+      const searchParams = new URLSearchParams('name=john&age=25&city=new%20york');
+      const result = parseQuery(searchParams);
+
+      expect(result).toEqual({
+        name: 'john',
+        age: '25',
+        city: 'new york'
+      });
+    });
+
+    it('should handle empty search params', () => {
+      const searchParams = new URLSearchParams('');
+      const result = parseQuery(searchParams);
+
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('parseHeaders', () => {
+    it('should parse Headers object correctly', () => {
+      const headers = new Headers();
+      headers.set('content-type', 'application/json');
+      headers.set('authorization', 'Bearer token123');
+
+      const result = parseHeaders(headers);
+
+      expect(result).toEqual({
+        'content-type': 'application/json',
+        'authorization': 'Bearer token123'
+      });
+    });
+  });
+
+  describe('parseCookies', () => {
+    it('should parse cookie header correctly', () => {
+      const cookieHeader = 'name=john; age=25; city=new%20york';
+      const result = parseCookies(cookieHeader);
+
+      expect(result).toEqual({
+        name: 'john',
+        age: '25',
+        city: 'new york'
+      });
+    });
+
+    it('should handle null cookie header', () => {
+      const result = parseCookies(null);
+      expect(result).toEqual({});
+    });
+
+    it('should handle empty cookie header', () => {
+      const result = parseCookies('');
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('validateData', () => {
+    it('should validate data with schema', () => {
+      const schema = z.object({
+        name: z.string(),
+        age: z.number()
+      });
+
+      const data = { name: 'john', age: 25 };
+      const result = validateData(schema, data);
+
+      expect(result).toEqual(data);
+    });
+
+    it('should return data without validation when no schema', () => {
+      const data = { name: 'john', age: 25 };
+      const result = validateData(undefined, data);
+
+      expect(result).toEqual(data);
+    });
+
+    it('should throw error for invalid data', () => {
+      const schema = z.object({
+        name: z.string(),
+        age: z.number()
+      });
+
+      const data = { name: 'john', age: 'invalid' };
+
+      expect(() => validateData(schema, data)).toThrow();
+    });
+  });
+
+  describe('validateResponse', () => {
+    it('should validate response with simple schema', () => {
+      const schema = z.object({
+        message: z.string()
+      });
+
+      const data = { message: 'success' };
+      const result = validateResponse({
+        200: schema
+      }, data, 200);
+
+      expect(result).toEqual(data);
+    });
+
+    it('should validate response with status-based schema', () => {
+      const schema = {
+        200: z.object({ message: z.string() }),
+        400: z.object({ error: z.string() })
+      };
+
+      const data = { message: 'success' };
+      const result = validateResponse(schema, data, 200);
+
+      expect(result).toEqual(data);
+    });
+
+    it('should return data without validation when no schema', () => {
+      const data = { message: 'success' };
+      const result = validateResponse(undefined, data);
+
+      expect(result).toEqual(data);
+    });
+  });
+
+  describe('cookiesToHeaders', () => {
+    it('should convert internal cookies to header strings', () => {
+      const cookies = [
+        {
+          name: 'session',
+          value: 'abc123',
+          domain: 'example.com',
+          path: '/',
+          secure: true,
+          httpOnly: true
+        }
+      ];
+
+      const result = cookiesToHeaders(cookies);
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toContain('session=abc123');
+      expect(result[0]).toContain('Domain=example.com');
+      expect(result[0]).toContain('Path=/');
+      expect(result[0]).toContain('Secure');
+      expect(result[0]).toContain('HttpOnly');
+    });
+  });
+
+  describe('mergeHeadersWithCookies', () => {
+    it('should merge headers with cookies', () => {
+      const headers = { 'content-type': 'application/json' };
+      const cookies = [
+        { name: 'session', value: 'abc123' }
+      ];
+
+      const result = mergeHeadersWithCookies(headers, cookies);
+
+      expect(result.get('content-type')).toBe('application/json');
+      expect(result.get('set-cookie')).toBe('session=abc123');
+    });
+  });
+
+  describe('createRedirectResponse', () => {
+    it('should create redirect response with default status', () => {
+      const result = createRedirectResponse('/new-location');
+
+      expect(result.status).toBe(302);
+      expect(result.headers.get('location')).toBe('/new-location');
+    });
+
+    it('should create redirect response with custom status', () => {
+      const result = createRedirectResponse('/new-location', 301);
+
+      expect(result.status).toBe(301);
+      expect(result.headers.get('location')).toBe('/new-location');
+    });
+
+    it('should include additional headers', () => {
+      const headers = { 'x-custom': 'value' };
+      const result = createRedirectResponse('/new-location', 302, headers);
+
+      expect(result.headers.get('x-custom')).toBe('value');
+    });
+  });
+
+  describe('parseRequestBody', () => {
+    it('should parse JSON body correctly', async () => {
+      const jsonData = { name: 'john', age: 25 };
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(jsonData)
+      });
+
+      const result = await parseRequestBody(request);
+      expect(result).toEqual(jsonData);
+    });
+
+    it('should parse form data with arrays correctly', async () => {
+      const formData = new FormData();
+      formData.append('app', 'zodula');
+      formData.append('model', 'zodula_User');
+      formData.append('recordIds[]', 'asdfasdfdsa');
+      formData.append('recordIds[]', 'jarupak.sri@gmail.com');
+      formData.append('fields', '*');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+
+      expect(result.app).toBe('zodula');
+      expect(result.model).toBe('zodula_User');
+      expect(Array.isArray(result.recordIds)).toBe(true);
+      expect(result.recordIds).toEqual(['asdfasdfdsa', 'jarupak.sri@gmail.com']);
+      expect(result.fields).toBe('*');
+    });
+
+    it('should handle single form field correctly', async () => {
+      const formData = new FormData();
+      formData.append('name', 'john');
+      formData.append('email', 'john@example.com');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+
+      expect(result.name).toBe('john');
+      expect(result.email).toBe('john@example.com');
+    });
+
+    it('should handle file uploads in form data', async () => {
+      const file = new File(['test content'], 'test.txt', { type: 'text/plain' });
+      const formData = new FormData();
+      formData.append('name', 'john');
+      formData.append('file', file);
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+
+      expect(result.name).toBe('john');
+      expect(result.file).toBeInstanceOf(File);
+      expect(result.file.name).toBe('test.txt');
+    });
+
+    it('should parse nested object form data correctly', async () => {
+      const formData = new FormData();
+      formData.append('test[test]', 'test');
+      formData.append('test[new]', 'new');
+      formData.append('test[hi][hi]', 'hi');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+
+      expect(result.test).toEqual({
+        test: 'test',
+        new: 'new',
+        hi: {
+          hi: 'hi'
+        }
+      });
+    });
+
+    it('should parse Axios-compatible multipart data with arrays and objects', async () => {
+      const formData = new FormData();
+      formData.append('x', '1');
+      formData.append('arr[]', '1');
+      formData.append('arr[]', '2');
+      formData.append('arr[]', '3');
+      formData.append('arr2[0]', '1');
+      formData.append('arr2[1][0]', '2');
+      formData.append('arr2[2]', '3');
+      formData.append('users[0][name]', 'Peter');
+      formData.append('users[0][surname]', 'Griffin');
+      formData.append('users[1][name]', 'Thomas');
+      formData.append('users[1][surname]', 'Anderson');
+      formData.append('obj2{}', '[{"x":1}]');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+
+      expect(result.x).toBe('1');
+      expect(result.arr).toEqual(['1', '2', '3']);
+      expect(result.arr2).toEqual(['1', ['2'], '3']);
+      expect(result.users).toEqual([
+        { name: 'Peter', surname: 'Griffin' },
+        { name: 'Thomas', surname: 'Anderson' }
+      ]);
+      expect(result.obj2).toEqual([{ x: 1 }]);
+    });
+
+    it('should handle JSON serialization with special endings', async () => {
+      const formData = new FormData();
+      formData.append('myObj{}', '{"x": 1, "s": "foo"}');
+      formData.append('settings{}', '{"theme": "dark", "notifications": true}');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+
+      expect(result.myObj).toEqual({ x: 1, s: 'foo' });
+      expect(result.settings).toEqual({ theme: 'dark', notifications: true });
+    });
+
+    it('should handle mixed array indexing styles', async () => {
+      const formData = new FormData();
+      formData.append('tags[]', 'javascript');
+      formData.append('tags[]', 'typescript');
+      formData.append('scores[0]', '100');
+      formData.append('scores[1]', '95');
+      formData.append('scores[2]', '88');
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        body: formData
+      });
+
+      const result = await parseRequestBody(request);
+
+      expect(result.tags).toEqual(['javascript', 'typescript']);
+      expect(result.scores).toEqual(['100', '95', '88']);
+    });
+  });
+
+  describe('File Upload Utilities', () => {
+    it('should identify file uploads correctly', () => {
+      const file = new File(['test'], 'test.jpg', { type: 'image/jpeg' });
+
+      expect(isFileUpload(file)).toBe(true);
+      expect(isFileUpload('not a file')).toBe(false);
+      expect(isFileUpload({ type: 'text' })).toBe(false);
+    });
+
+    it('should extract file from upload', () => {
+      const file = new File(['test'], 'test.jpg', { type: 'image/jpeg' });
+
+      const result = getFileFromUpload(file);
+      expect(result).toBe(file);
+    });
+
+    it('should return null for non-file uploads', () => {
+      const result = getFileFromUpload('not a file');
+      expect(result).toBeNull();
+    });
+
+    it('should get file info', () => {
+      const file = new File(['test'], 'test.jpg', { type: 'image/jpeg' });
+
+      const result = getFileInfo(file);
+      expect(result).toEqual({
+        name: 'test.jpg',
+        size: 4,
+        mimetype: 'image/jpeg',
+        lastModified: expect.any(Number)
+      });
+    });
+
+    it('should return null for non-file uploads when getting info', () => {
+      const result = getFileInfo('not a file');
+      expect(result).toBeNull();
+    });
+
+    it('should get all file uploads from form data', () => {
+      const file = new File(['test'], 'avatar.jpg', { type: 'image/jpeg' });
+      const formData = {
+        name: 'john',
+        avatar: file,
+        email: 'john@example.com'
+      };
+
+      const result = getFileUploads(formData);
+
+      expect(Object.keys(result)).toHaveLength(1);
+      expect(result.avatar).toBeInstanceOf(File);
+    });
+
+    it('should get all non-file fields from form data', () => {
+      const file = new File(['test'], 'avatar.jpg', { type: 'image/jpeg' });
+      const formData = {
+        name: 'john',
+        avatar: file,
+        email: 'john@example.com'
+      };
+
+      const result = getFormFields(formData);
+
+      expect(result).toEqual({
+        name: 'john',
+        email: 'john@example.com'
+      });
+    });
+  });
+});

package/example.ts

@@ -1,183 +0,0 @@
-import BXO, { z } from './index';
-import { cors, logger, auth, rateLimit, createJWT } from './plugins';
-
-// Create the app instance
-const app = new BXO();
-
-// Enable hot reload
-app.enableHotReload(['./']); // Watch current directory
-
-// Add plugins
-app
-  .use(logger({ format: 'simple' }))
-  .use(cors({ 
-    origin: ['http://localhost:3000', 'https://example.com'],
-    credentials: true 
-  }))
-  .use(rateLimit({ 
-    max: 100, 
-    window: 60, // 1 minute
-    exclude: ['/health'] 
-  }))
-  .use(auth({ 
-    type: 'jwt', 
-    secret: 'your-secret-key',
-    exclude: ['/', '/login', '/health']
-  }));
-
-// Add simplified lifecycle hooks
-app
-  .onBeforeStart(() => {
-    console.log('🔧 Preparing to start server...');
-  })
-  .onAfterStart(() => {
-    console.log('✅ Server fully started and ready!');
-  })
-  .onBeforeStop(() => {
-    console.log('🔧 Preparing to stop server...');
-  })
-  .onAfterStop(() => {
-    console.log('✅ Server fully stopped!');
-  })
-  .onBeforeRestart(() => {
-    console.log('🔧 Preparing to restart server...');
-  })
-  .onAfterRestart(() => {
-    console.log('✅ Server restart completed!');
-  })
-  .onRequest((ctx) => {
-    console.log(`📨 Processing ${ctx.request.method} ${ctx.request.url}`);
-  })
-  .onResponse((ctx, response) => {
-    console.log(`📤 Response sent for ${ctx.request.method} ${ctx.request.url}`);
-    return response;
-  })
-  .onError((ctx, error) => {
-    console.error(`💥 Error in ${ctx.request.method} ${ctx.request.url}:`, error.message);
-    return { error: 'Something went wrong', timestamp: new Date().toISOString() };
-  });
-
-// Routes exactly like your example
-app
-  // Two arguments: path, handler
-  .get('/simple', async (ctx) => {
-    return { message: 'Hello World' };
-  })
-  
-  // Three arguments: path, handler, config
-  .get('/users/:id', async (ctx) => {
-    // ctx.params.id is fully typed as string (UUID)
-    // ctx.query.include is typed as string | undefined
-    return { user: { id: ctx.params.id, include: ctx.query.include } };
-  }, {
-    params: z.object({ id: z.string().uuid() }),
-    query: z.object({ include: z.string().optional() })
-  })
-  
-  .post('/users', async (ctx) => {
-    // ctx.body is fully typed with name: string, email: string
-    return { created: ctx.body };
-  }, {
-    body: z.object({
-      name: z.string(),
-      email: z.string().email()
-    })
-  })
-
-  // Additional examples
-  .get('/health', async (ctx) => {
-    return { 
-      status: 'ok', 
-      timestamp: new Date().toISOString(),
-      server: app.getServerInfo()
-    };
-  })
-
-  .post('/login', async (ctx) => {
-    const { username, password } = ctx.body;
-    
-    // Simple auth check (in production, verify against database)
-    if (username === 'admin' && password === 'password') {
-      const token = createJWT({ username, role: 'admin' }, 'your-secret-key', 3600);
-      return { token, user: { username, role: 'admin' } };
-    }
-    
-    ctx.set.status = 401;
-    return { error: 'Invalid credentials' };
-  }, {
-    body: z.object({
-      username: z.string(),
-      password: z.string()
-    })
-  })
-
-  .get('/protected', async (ctx) => {
-    // ctx.user is available here because of auth plugin
-    return { message: 'This is protected', user: ctx.user };
-  })
-
-  // Server control endpoints
-  .post('/restart', async (ctx) => {
-    // Restart the server
-    setTimeout(() => app.restart(3000), 100);
-    return { message: 'Server restart initiated' };
-  })
-
-  .get('/status', async (ctx) => {
-    return {
-      ...app.getServerInfo(),
-      uptime: process.uptime(),
-      memory: process.memoryUsage()
-    };
-  })
-
-  .put('/users/:id', async (ctx) => {
-    return { 
-      updated: ctx.body, 
-      id: ctx.params.id,
-      version: ctx.headers['if-match']
-    };
-  }, {
-    params: z.object({ id: z.string().uuid() }),
-    body: z.object({
-      name: z.string().optional(),
-      email: z.string().email().optional()
-    }),
-    headers: z.object({
-      'if-match': z.string()
-    })
-  })
-
-  .delete('/users/:id', async (ctx) => {
-    ctx.set.status = 204;
-    return null;
-  }, {
-    params: z.object({ id: z.string().uuid() })
-  });
-
-// Start the server (with hot reload enabled)
-app.start(3000, 'localhost');
-
-console.log(`
-🦊 BXO Framework with Hot Reload
-
-✨ Features Enabled:
-- 🔄 Hot reload (edit any .ts/.js file to restart)
-- 🎣 Full lifecycle hooks (before/after pattern)
-- 🔒 JWT authentication
-- 📊 Rate limiting  
-- 🌐 CORS support
-- 📝 Request logging
-
-🧪 Try these endpoints:
-- GET  /simple
-- GET  /users/123e4567-e89b-12d3-a456-426614174000?include=profile
-- POST /users (with JSON body: {"name": "John", "email": "john@example.com"})
-- GET  /health (shows server info)
-- POST /login (with JSON body: {"username": "admin", "password": "password"})
-- GET  /protected (requires Bearer token from /login)
-- GET  /status (server statistics)
-- POST /restart (restart server programmatically)
-
-💡 Edit this file and save to see hot reload in action!
-`);