qhttpx 1.8.0

package/tests/adapters.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PostgresAdapter } from '../src/database/adapters/postgres';
+import { MongoAdapter } from '../src/database/adapters/mongo';
+
+// Define mocks
+const pgPoolQuery = vi.fn(() => Promise.resolve({ rows: [], command: 'SELECT' }));
+const pgConnect = vi.fn(() => Promise.resolve({ release: vi.fn() }));
+const pgEnd = vi.fn();
+
+vi.mock('pg', () => {
+  const Pool = function() {
+    return {
+      connect: pgConnect,
+      query: pgPoolQuery,
+      end: pgEnd,
+      on: vi.fn(),
+      ended: false
+    };
+  };
+  return {
+    default: { Pool },
+    Pool
+  };
+});
+
+const mongoFind = vi.fn(() => ({ 
+  toArray: vi.fn(() => Promise.resolve([])),
+  limit: vi.fn(),
+  skip: vi.fn()
+}));
+const mongoConnect = vi.fn(() => Promise.resolve());
+const mongoClose = vi.fn();
+
+vi.mock('mongodb', () => {
+  const MongoClient = function() {
+    return {
+      connect: mongoConnect,
+      db: vi.fn(() => ({
+        collection: vi.fn(() => ({
+          find: mongoFind,
+          findOne: vi.fn(),
+          insertOne: vi.fn(),
+          // add other methods as needed
+          updateOne: vi.fn(),
+          updateMany: vi.fn(),
+          deleteOne: vi.fn(),
+          deleteMany: vi.fn(),
+          aggregate: vi.fn(() => ({ toArray: vi.fn(() => Promise.resolve([])) }))
+        }))
+      })),
+      close: mongoClose
+    };
+  };
+  return {
+    default: { MongoClient },
+    MongoClient
+  };
+});
+
+describe('Database Adapters', () => {
+  
+  describe('PostgresAdapter', () => {
+    let adapter: PostgresAdapter;
+
+    beforeEach(() => {
+      adapter = new PostgresAdapter({ type: 'postgres', database: 'test' });
+      vi.clearAllMocks();
+    });
+
+    it('should connect and disconnect', async () => {
+      await adapter.connect();
+      expect(pgConnect).toHaveBeenCalled();
+      expect(adapter.isConnected()).toBe(true);
+      
+      await adapter.disconnect();
+      expect(pgEnd).toHaveBeenCalled();
+      // Since our mock object is static in the factory, we can't easily check 'pool' null state 
+      // via the mock, but we can check the adapter state if it relies on the pool property.
+      // The adapter sets this.pool = null.
+      expect(adapter.isConnected()).toBe(false);
+    });
+
+    it('should execute query', async () => {
+      await adapter.connect();
+      await adapter.query('SELECT * FROM users');
+      expect(pgPoolQuery).toHaveBeenCalledWith('SELECT * FROM users', undefined);
+    });
+  });
+
+  describe('MongoAdapter', () => {
+    let adapter: MongoAdapter;
+
+    beforeEach(() => {
+      adapter = new MongoAdapter({ type: 'mongo', url: 'mongodb://localhost' });
+      vi.clearAllMocks();
+    });
+
+    it('should connect and disconnect', async () => {
+      await adapter.connect();
+      expect(mongoConnect).toHaveBeenCalled();
+      expect(adapter.isConnected()).toBe(true);
+      
+      await adapter.disconnect();
+      expect(mongoClose).toHaveBeenCalled();
+      expect(adapter.isConnected()).toBe(false);
+    });
+
+    it('should execute find query via object syntax', async () => {
+      await adapter.connect();
+      await adapter.query({ collection: 'users', action: 'find', filter: { id: 1 } });
+      expect(mongoFind).toHaveBeenCalledWith({ id: 1 });
+    });
+
+    it('should execute find query via string syntax', async () => {
+      await adapter.connect();
+      await adapter.query('users.find', [{ id: 1 }]);
+      expect(mongoFind).toHaveBeenCalledWith({ id: 1 });
+    });
+  });
+});

package/tests/batch.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { QHTTPX } from '../src/core/server';
+import { DatabaseManager } from '../src/database/manager';
+import { MemoryAdapter } from '../src/database/adapters/memory';
+
+describe('Batch Engine & Query Fusion', () => {
+  let app: QHTTPX;
+  let dbManager: DatabaseManager;
+
+  beforeEach(async () => {
+    DatabaseManager.registerAdapter('memory', MemoryAdapter);
+    
+    dbManager = new DatabaseManager({
+      default: 'main',
+      connections: {
+        main: { type: 'memory', database: 'test_db' }
+      }
+    });
+
+    await dbManager.connect();
+
+    app = new QHTTPX({ 
+      database: dbManager,
+      enableBatching: true 
+    });
+  });
+
+  afterEach(async () => {
+    await app.close();
+    await dbManager.disconnect();
+  });
+
+  it('should execute multiple operations in a single batch request', async () => {
+    // Define ops
+    app.op('math.add', async (params) => {
+      return params.a + params.b;
+    });
+
+    app.op('math.multiply', async (params) => {
+      return params.a * params.b;
+    });
+
+    const { port } = await app.listen(0);
+
+    const batch = {
+      batch: [
+        { op: 'math.add', params: { a: 5, b: 3 }, id: 1 },
+        { op: 'math.multiply', params: { a: 4, b: 2 }, id: 2 }
+      ]
+    };
+
+    const response = await fetch(`http://localhost:${port}/qhttpx`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(batch)
+    });
+
+    const data = await response.json();
+    
+    expect(data.results).toHaveLength(2);
+    expect(data.results[0]).toEqual({ result: 8, id: 1 });
+    expect(data.results[1]).toEqual({ result: 8, id: 2 });
+  });
+
+  it('should fuse database queries', async () => {
+    // Setup spy on the adapter's query method to verify fusion
+    const adapter = dbManager.get('main');
+    const querySpy = vi.spyOn(adapter, 'query');
+
+    // Define an op that uses DB
+    app.op('getUser', async (params, ctx) => {
+      // Simulate simple query that matches our coalescer pattern
+      // "SELECT * FROM users WHERE id = ?"
+      if (!ctx.db) throw new Error('No DB');
+      const result = await ctx.db.get().query('SELECT * FROM users WHERE id = ?', [params.id]);
+      return result;
+    });
+
+    const { port } = await app.listen(0);
+
+    // Prepare batch with 3 requests
+    const batch = {
+      batch: [
+        { op: 'getUser', params: { id: 1 }, id: 'req1' },
+        { op: 'getUser', params: { id: 2 }, id: 'req2' },
+        { op: 'getUser', params: { id: 3 }, id: 'req3' }
+      ]
+    };
+
+    // Mock DB response for the FUSED query
+    // The coalescer will generate: "SELECT * FROM users WHERE id IN (?, ?, ?)"
+    // We need to mock the implementation to return data that the coalescer can map back.
+    // The memory adapter handles basic queries, but does it handle "IN"?
+    // The current MemoryAdapter likely DOES NOT support SQL parsing.
+    // So we need to mock the query method to return expected data for the fused query.
+    
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    querySpy.mockImplementation(async (query: any) => {
+        if (typeof query === 'string' && query.includes('IN')) {
+            // This is the fused query
+            // Return dummy users
+            return [
+                { id: 1, name: 'User 1' },
+                { id: 2, name: 'User 2' },
+                { id: 3, name: 'User 3' }
+            ];
+        }
+        return [];
+    });
+
+    const response = await fetch(`http://localhost:${port}/qhttpx`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(batch)
+    });
+
+    const data = await response.json();
+
+    // Verification
+    // 1. Check results
+    expect(data.results).toHaveLength(3);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(data.results.find((r: any) => r.id === 'req1').result).toEqual([{ id: 1, name: 'User 1' }]);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(data.results.find((r: any) => r.id === 'req2').result).toEqual([{ id: 2, name: 'User 2' }]);
+    
+    // 2. Check that query was called ONCE with fused SQL
+    // The spy calls should show 1 call with "IN" and maybe others if coalescer failed?
+    // Wait, the coalescer calls the ADAPTER.
+    
+    // Filter calls that look like the fused one
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const fusedCalls = querySpy.mock.calls.filter((args: any) => (args[0] as string).includes('IN'));
+    expect(fusedCalls.length).toBe(1);
+    
+    const individualCalls = querySpy.mock.calls.filter(args => (args[0] as string).includes('= ?'));
+    expect(individualCalls.length).toBe(0); // Should be 0 if fusion worked
+  });
+});

package/tests/body-parser.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+import { IncomingMessage } from 'http';
+import { Socket } from 'net';
+import { BodyParser } from '../src/core/body-parser';
+
+// Mock IncomingMessage
+class MockRequest extends IncomingMessage {
+  constructor(method: string, headers: Record<string, string>, body?: string | Buffer) {
+    super(new Socket());
+    this.method = method;
+    this.headers = headers;
+    if (body) {
+      this.push(body);
+      this.push(null);
+    } else {
+      this.push(null);
+    }
+  }
+}
+
+describe('BodyParser', () => {
+  it('parses JSON body', async () => {
+    const req = new MockRequest(
+      'POST',
+      { 'content-type': 'application/json' },
+      JSON.stringify({ foo: 'bar' })
+    );
+
+    const parsed = await BodyParser.parse(req);
+    expect(parsed.body).toEqual({ foo: 'bar' });
+  });
+
+  it('parses urlencoded body', async () => {
+    const req = new MockRequest(
+      'POST',
+      { 'content-type': 'application/x-www-form-urlencoded' },
+      'foo=bar&baz=123'
+    );
+
+    const parsed = await BodyParser.parse(req);
+    expect(parsed.body).toEqual({ foo: 'bar', baz: '123' });
+  });
+
+  it('returns buffer for unknown content type', async () => {
+    const req = new MockRequest(
+      'POST',
+      { 'content-type': 'application/octet-stream' },
+      'hello world'
+    );
+
+    const parsed = await BodyParser.parse(req);
+    expect(parsed.body).toBeInstanceOf(Buffer);
+    expect((parsed.body as Buffer).toString()).toBe('hello world');
+  });
+
+  it('throws error when body too large', async () => {
+    const req = new MockRequest(
+      'POST',
+      { 'content-type': 'text/plain' },
+      '1234567890'
+    );
+
+    await expect(
+      BodyParser.parse(req, { maxBodyBytes: 5 })
+    ).rejects.toThrow('QHTTPX_BODY_TOO_LARGE');
+  });
+
+  it('throws error for invalid JSON', async () => {
+    const req = new MockRequest(
+      'POST',
+      { 'content-type': 'application/json' },
+      '{ invalid json'
+    );
+
+    await expect(BodyParser.parse(req)).rejects.toThrow('QHTTPX_INVALID_JSON');
+  });
+
+  it('ignores GET requests', async () => {
+    const req = new MockRequest('GET', {});
+    const parsed = await BodyParser.parse(req);
+    expect(parsed.body).toBeUndefined();
+  });
+});

package/tests/compression-sse.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from 'vitest';
+import { QHTTPX, createCompressionMiddleware, createSSE } from '../src';
+import zlib from 'zlib';
+import http from 'http';
+
+describe('Compression Middleware', () => {
+  it('should compress JSON response with gzip', async () => {
+    const app = new QHTTPX();
+    app.use(createCompressionMiddleware());
+    const bigData = { data: 'a'.repeat(10000) };
+    app.get('/gzip', (ctx) => ctx.json(bigData));
+    const { port } = await app.listen(0, '127.0.0.1');
+    
+    // Use http.request to avoid automatic decompression by fetch
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const response = await new Promise<{ headers: any, data: Buffer }>((resolve, reject) => {
+      const req = http.request(`http://127.0.0.1:${port}/gzip`, {
+        headers: { 'Accept-Encoding': 'gzip' }
+      }, (res) => {
+        const chunks: Buffer[] = [];
+        res.on('data', (chunk) => chunks.push(chunk));
+        res.on('end', () => resolve({ headers: res.headers, data: Buffer.concat(chunks) }));
+        res.on('error', reject);
+      });
+      req.end();
+    });
+
+    expect(response.headers['content-encoding']).toBe('gzip');
+    expect(response.headers['vary']).toContain('Accept-Encoding');
+
+    const decompressed = zlib.gunzipSync(response.data);
+    const json = JSON.parse(decompressed.toString());
+
+    expect(json).toEqual(bigData);
+    await app.close();
+  });
+
+  it('should not compress small response if threshold is high', async () => {
+    const app = new QHTTPX();
+    app.use(createCompressionMiddleware({ threshold: 1000 }));
+
+    app.get('/small', (ctx) => {
+      ctx.json({ data: 'small' });
+    });
+
+    const { port } = await app.listen(0, '127.0.0.1');
+
+    const response = await fetch(`http://127.0.0.1:${port}/small`, {
+      headers: { 'Accept-Encoding': 'gzip' },
+    });
+
+    expect(response.status).toBe(200);
+    // Should NOT have content-encoding because it's too small
+    expect(response.headers.get('content-encoding')).toBeNull();
+
+    await app.close();
+  });
+});
+
+describe('Server-Sent Events (SSE)', () => {
+  it('should stream events', async () => {
+    const app = new QHTTPX();
+    // app.use(createCompressionMiddleware()); // Disable compression for SSE test to debug
+    app.get('/sse', (ctx) => {
+      const stream = createSSE(ctx);
+      let count = 0;
+      const interval = setInterval(() => {
+        count++;
+        stream.send({ count }, 'ping');
+        if (count >= 3) {
+          clearInterval(interval);
+          stream.close();
+        }
+      }, 50);
+    });
+
+    const { port } = await app.listen(0, '127.0.0.1');
+
+    const response = await new Promise<string>((resolve, reject) => {
+      const req = http.request(`http://127.0.0.1:${port}/sse`, (res) => {
+        let data = '';
+        res.on('data', (chunk) => {
+          data += chunk.toString();
+        });
+        res.on('end', () => resolve(data));
+        res.on('error', reject);
+      });
+      req.end();
+    });
+
+    expect(response).toContain('event: ping');
+    expect(response).toContain('data: {"count":1}');
+    expect(response).toContain('data: {"count":2}');
+    expect(response).toContain('data: {"count":3}');
+
+    await app.close();
+  });
+});

package/tests/cookies.test.ts

@@ -0,0 +1,74 @@
+
+import { describe, it, expect } from 'vitest';
+import { parseCookies, serializeCookie } from '../src/utils/cookies';
+
+describe('Cookie Parsing', () => {
+  it('should parse simple cookies', () => {
+    const header = 'foo=bar; baz=qux';
+    const result = parseCookies(header);
+    expect(result).toEqual({ foo: 'bar', baz: 'qux' });
+  });
+
+  it('should handle quoted values', () => {
+    const header = 'foo="bar"; baz=qux';
+    // Basic implementation might not strip quotes if not decoding specifically for that, 
+    // but let's see standard behavior. My implementation just decodes URI component.
+    // 'foo="bar"' split by '=' -> ['foo', '"bar"']. decodeURIComponent('"bar"') -> '"bar"'.
+    const result = parseCookies(header);
+    expect(result).toEqual({ foo: '"bar"', baz: 'qux' });
+  });
+
+  it('should handle URL encoded values', () => {
+    const header = 'foo=Hello%20World';
+    const result = parseCookies(header);
+    expect(result).toEqual({ foo: 'Hello World' });
+  });
+
+  it('should handle empty header', () => {
+    expect(parseCookies(undefined)).toEqual({});
+    expect(parseCookies('')).toEqual({});
+  });
+
+  it('should ignore cookies without name', () => {
+    const header = '=bar; baz=qux';
+    const result = parseCookies(header);
+    expect(result).toEqual({ baz: 'qux' });
+  });
+});
+
+describe('Cookie Serialization', () => {
+  it('should serialize name and value', () => {
+    const result = serializeCookie('foo', 'bar');
+    expect(result).toBe('foo=bar; Path=/');
+  });
+
+  it('should encode value', () => {
+    const result = serializeCookie('foo', 'Hello World');
+    expect(result).toBe('foo=Hello%20World; Path=/');
+  });
+
+  it('should handle Max-Age', () => {
+    const result = serializeCookie('foo', 'bar', { maxAge: 3600 });
+    expect(result).toContain('Max-Age=3600');
+  });
+
+  it('should handle HttpOnly', () => {
+    const result = serializeCookie('foo', 'bar', { httpOnly: true });
+    expect(result).toContain('HttpOnly');
+  });
+
+  it('should handle Secure', () => {
+    const result = serializeCookie('foo', 'bar', { secure: true });
+    expect(result).toContain('Secure');
+  });
+
+  it('should handle SameSite', () => {
+    const result = serializeCookie('foo', 'bar', { sameSite: 'strict' });
+    expect(result).toContain('SameSite=Strict');
+  });
+
+  it('should handle Path', () => {
+    const result = serializeCookie('foo', 'bar', { path: '/admin' });
+    expect(result).toContain('Path=/admin');
+  });
+});

package/tests/cors.test.ts

@@ -0,0 +1,79 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { QHTTPX, createCorsMiddleware } from '../src';
+
+describe('CORS middleware', () => {
+  let app: QHTTPX | undefined;
+
+  afterEach(async () => {
+    if (app) {
+      await app.close();
+      app = undefined;
+    }
+  });
+
+  it('sets default CORS headers and passes through GET', async () => {
+    app = new QHTTPX();
+
+    app.use(createCorsMiddleware());
+
+    app.get('/ping', (ctx) => {
+      ctx.send('pong');
+    });
+
+    const { port } = await app.listen(0, '127.0.0.1');
+
+    const response = await fetch(`http://127.0.0.1:${port}/ping`, {
+      headers: {
+        origin: 'http://example.com',
+      },
+    });
+
+    expect(response.status).toBe(200);
+    expect(await response.text()).toBe('pong');
+    expect(response.headers.get('access-control-allow-origin')).toBe('*');
+  });
+
+  it('handles preflight OPTIONS requests', async () => {
+    app = new QHTTPX();
+
+    app.use(
+      createCorsMiddleware({
+        origin: ['http://example.com'],
+        methods: ['GET', 'POST'],
+        allowedHeaders: ['content-type'],
+        maxAgeSeconds: 600,
+      }),
+    );
+
+    app.get('/ping', (ctx) => {
+      ctx.send('pong');
+    });
+
+    const { port } = await app.listen(0, '127.0.0.1');
+
+    const response = await fetch(
+      `http://127.0.0.1:${port}/ping`,
+      {
+        method: 'OPTIONS',
+        headers: {
+          origin: 'http://example.com',
+          'access-control-request-method': 'GET',
+          'access-control-request-headers': 'content-type',
+        },
+      },
+    );
+
+    expect(response.status).toBe(204);
+    expect(response.headers.get('access-control-allow-origin')).toBe(
+      'http://example.com',
+    );
+    expect(response.headers.get('access-control-allow-methods')).toBe(
+      'GET, POST',
+    );
+    expect(response.headers.get('access-control-allow-headers')).toBe(
+      'content-type',
+    );
+    expect(response.headers.get('access-control-max-age')).toBe('600');
+  });
+});
+

package/tests/database.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { DatabaseManager } from '../src/database/manager';
+import { MemoryAdapter } from '../src/database/adapters/memory';
+
+describe('Database Engine', () => {
+  let dbManager: DatabaseManager;
+
+  beforeEach(() => {
+    // Register the adapter
+    DatabaseManager.registerAdapter('memory', MemoryAdapter);
+
+    // Initialize manager
+    dbManager = new DatabaseManager({
+      default: 'main',
+      connections: {
+        main: {
+          type: 'memory',
+          database: 'test_db'
+        }
+      }
+    });
+  });
+
+  afterEach(async () => {
+    await dbManager.disconnect();
+  });
+
+  it('should connect to the default database', async () => {
+    const adapter = await dbManager.connect();
+    expect(adapter).toBeDefined();
+    expect(adapter.isConnected()).toBe(true);
+  });
+
+  it('should perform CRUD operations with MemoryAdapter', async () => {
+    const adapter = await dbManager.connect();
+    
+    // Insert
+    const user = await adapter.query({
+      collection: 'users',
+      action: 'insert',
+      data: { name: 'John Doe', email: 'john@example.com' }
+    });
+    expect(user).toHaveProperty('id');
+    expect(user.name).toBe('John Doe');
+
+    // Find
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const users = await adapter.query<any[]>({
+      collection: 'users',
+      action: 'find',
+      filter: { name: 'John Doe' }
+    });
+    expect(users).toHaveLength(1);
+    expect(users[0].email).toBe('john@example.com');
+
+    // Update
+    const updateCount = await adapter.query({
+      collection: 'users',
+      action: 'update',
+      filter: { name: 'John Doe' },
+      data: { name: 'John Updated' }
+    });
+    expect(updateCount).toBe(1);
+
+    // Verify Update
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const updatedUsers = await adapter.query<any[]>({
+      collection: 'users',
+      action: 'find',
+      filter: { name: 'John Updated' }
+    });
+    expect(updatedUsers).toHaveLength(1);
+
+    // Delete
+    const deleteCount = await adapter.query({
+      collection: 'users',
+      action: 'delete',
+      filter: { name: 'John Updated' }
+    });
+    expect(deleteCount).toBe(1);
+
+    // Verify Delete
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const remainingUsers = await adapter.query<any[]>({
+      collection: 'users',
+      action: 'find'
+    });
+    expect(remainingUsers).toHaveLength(0);
+  });
+});