qhttpx 1.8.5 → 1.8.12

package/tests/dx.test.ts

@@ -1,130 +0,0 @@
-
-import { describe, it, expect } from 'vitest';
-import { createHttpApp } from '../src/index';
-import { app as singletonApp } from '../src/index';
-
-describe('Developer Experience (DX) Features', () => {
-  it('supports destructured context in route handlers', async () => {
-    const app = createHttpApp();
-    
-    app.get('/destructure', ({ json, path, query }) => {
-      json({ path, query, status: 'ok' });
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-    
-    try {
-      const response = await fetch(`http://127.0.0.1:${port}/destructure?foo=bar`);
-      expect(response.status).toBe(200);
-      const body = await response.json();
-      expect(body).toEqual({ 
-        path: '/destructure', 
-        query: { foo: 'bar' },
-        status: 'ok' 
-      });
-    } finally {
-      await app.close();
-    }
-  });
-
-  it('supports destructured context in onError handler', async () => {
-    const app = createHttpApp();
-    
-    app.get('/error', () => {
-      throw new Error('Boom');
-    });
-
-    app.onError(({ error, json }) => {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      json({ error: (error as any).message, handled: true }, 500);
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-    
-    try {
-      const response = await fetch(`http://127.0.0.1:${port}/error`);
-      expect(response.status).toBe(500);
-      const body = await response.json();
-      expect(body).toEqual({ error: 'Boom', handled: true });
-    } finally {
-      await app.close();
-    }
-  });
-
-  it('supports notFound alias', async () => {
-    const app = createHttpApp();
-    
-    app.notFound(({ json }) => {
-      json({ error: 'Not Found Custom' }, 404);
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-    
-    try {
-      const response = await fetch(`http://127.0.0.1:${port}/missing`);
-      expect(response.status).toBe(404);
-      const body = await response.json();
-      expect(body).toEqual({ error: 'Not Found Custom' });
-    } finally {
-      await app.close();
-    }
-  });
-
-  it('exports a singleton app instance', () => {
-    expect(singletonApp).toBeDefined();
-    expect(typeof singletonApp.get).toBe('function');
-    expect(typeof singletonApp.listen).toBe('function');
-  });
-
-  it('supports destructured next in middleware', async () => {
-    const app = createHttpApp();
-    const calls: string[] = [];
-
-    // Middleware with destructuring: ({ next })
-    app.use(async ({ next, req }) => {
-      calls.push('start');
-      calls.push(req.method!); // Verify req is accessible
-      if (next) await next();
-      calls.push('end');
-    });
-
-    app.get('/', ({ json }) => {
-      calls.push('handler');
-      json({ ok: true });
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-    
-    try {
-      await fetch(`http://127.0.0.1:${port}/`);
-      expect(calls).toEqual(['start', 'GET', 'handler', 'end']);
-    } finally {
-      await app.close();
-    }
-  });
-
-  it('supports typed files in context', async () => {
-    // This is primarily a type check, but we can simulate a file structure
-    const app = createHttpApp();
-    
-    app.post('/upload', ({ files, json }) => {
-      // Simulate type access
-      if (files && files['avatar']) {
-        const avatar = Array.isArray(files['avatar']) ? files['avatar'][0] : files['avatar'];
-        json({ filename: avatar.filename, size: avatar.size });
-      } else {
-        json({ error: 'no file' }, 400);
-      }
-    });
-
-    // Mocking the context directly to test logic without full multipart request (BodyParser is tested elsewhere)
-    // But we can create a "fake" request if we used the internal methods, 
-    // here we just want to ensure the code compiles and runs if files are present.
-    // Let's do a full test with createTestClient if possible, or just skip full multipart integration test
-    // since we updated the types.
-    // For now, let's just ensure the server runs.
-    
-    await app.listen(0, '127.0.0.1');
-    await app.close();
-  });
-});

package/tests/ecosystem.test.ts

@@ -1,156 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { QHTTPX } from '../src/core/server';
-import { QHTTPXMiddleware } from '../src/core/types';
-
-// Mock External Libraries
-const mockJose = {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  jwtVerify: async (token: string, _secret: unknown) => {
-    if (token === 'valid_token') return { payload: { sub: 'user_123', role: 'admin' } };
-    throw new Error('Invalid Token');
-  }
-};
-
-const mockRedis = {
-  get: async (key: string) => {
-    if (key === 'cache:page:home') return '<html>Cached Home</html>';
-    return null;
-  },
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  set: async (key: string, val: string) => 'OK'
-};
-
-describe('SaaS Ecosystem Compatibility', () => {
-  
-  it('should allow integration of 3rd party JWT libraries (e.g. jose)', async () => {
-    const app = new QHTTPX();
-    const secret = 'super-secret';
-    // const token = await new SignJWT({ 'urn:example:claim': true })
-    //   .setProtectedHeader({ alg: 'HS256' })
-    //   .setIssuedAt()
-    //   .setExpirationTime('2h')
-    //   .sign(new TextEncoder().encode(secret));
-
-    // 1. Create a custom Authentication Middleware using "jose"
-    const authMiddleware: QHTTPXMiddleware = async (ctx, next) => {
-      const authHeader = ctx.req.headers['authorization'];
-      if (!authHeader) {
-        ctx.res.statusCode = 401;
-        ctx.res.end('Unauthorized');
-        return;
-      }
-
-      try {
-        const token = authHeader.split(' ')[1];
-        const { payload } = await mockJose.jwtVerify(token, secret);
-        
-        // Store user in ctx.state (Standard Pattern)
-        ctx.state.user = payload;
-        await next();
-      } catch {
-        ctx.res.statusCode = 403;
-        ctx.res.end('Forbidden');
-      }
-    };
-
-    app.use(authMiddleware);
-
-    // Protected Route
-    app.get('/dashboard', async (ctx) => {
-      // Access the user injected by middleware
-      const user = ctx.state.user;
-      ctx.json({ message: `Welcome ${user.sub}`, role: user.role });
-    });
-
-    const { port } = await app.listen(0);
-    const url = `http://localhost:${port}`;
-
-    // Test Valid Token
-    const res1 = await fetch(`${url}/dashboard`, { headers: { Authorization: 'Bearer valid_token' } });
-    expect(res1.status).toBe(200);
-    const data1 = await res1.json();
-    expect(data1).toEqual({ message: 'Welcome user_123', role: 'admin' });
-
-    // Test Invalid Token
-    const res2 = await fetch(`${url}/dashboard`, { headers: { Authorization: 'Bearer bad_token' } });
-    expect(res2.status).toBe(403);
-
-    await app.close();
-  });
-
-  it('should allow integration of 3rd party Caching (e.g. Redis)', async () => {
-    const app = new QHTTPX();
-
-    // 2. Create a Caching Middleware using "redis"
-    const cacheMiddleware: QHTTPXMiddleware = async (ctx, next) => {
-      const key = `cache:page:${ctx.url.pathname.replace('/', '')}`;
-      const cached = await mockRedis.get(key);
-
-      if (cached) {
-        ctx.res.setHeader('X-Cache', 'HIT');
-        ctx.res.end(cached);
-        return;
-      }
-
-      ctx.res.setHeader('X-Cache', 'MISS');
-      await next();
-    };
-
-    app.use(cacheMiddleware);
-
-    app.get('/home', async (ctx) => {
-      ctx.html('<html>Fresh Home</html>');
-    });
-
-    const { port } = await app.listen(0);
-    const url = `http://localhost:${port}`;
-
-    // Test Cache Hit (Mocked)
-    const res1 = await fetch(`${url}/home`);
-    expect(res1.status).toBe(200);
-    expect(res1.headers.get('x-cache')).toBe('HIT');
-    const text1 = await res1.text();
-    expect(text1).toBe('<html>Cached Home</html>');
-
-    // Test Cache Miss (Mocked for other route)
-    // Note: In a real app we'd need to intercept res.end to write to redis, 
-    // but for this capability check, reading is enough proof.
-    
-    await app.close();
-  });
-
-  it('should allow integration of ORM/DB libraries', async () => {
-    const app = new QHTTPX();
-
-    // Mock TypeORM/Prisma usage
-    const db = {
-      users: {
-        findMany: async () => [{ id: 1, name: 'Alice' }],
-      },
-    };
-
-    // Middleware to attach DB to context
-    app.use(async (ctx, next) => {
-      // We can attach to ctx.state or extend ctx type if we want
-      ctx.state.db = db;
-      await next();
-    });
-
-    app.get('/users', async (ctx) => {
-      try {
-        const users = await ctx.state.db.users.findMany();
-        ctx.res.end(JSON.stringify(users));
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      } catch (err) {
-        ctx.res.statusCode = 500;
-        ctx.res.end('DB Error');
-      }
-    });
-
-    const { port } = await app.listen(0);
-    const url = `http://localhost:${port}`;
-    const res = await fetch(`${url}/users`);
-    expect(res.status).toBe(200);
-    await app.close();
-  });
-});

package/tests/features.test.ts

@@ -1,51 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { QHTTPX } from '../src/index';
-import { Logger } from '../src/core/logger';
-import { hc } from '../src/client';
-
-describe('Logger', () => {
-  it('should initialize with pino', () => {
-    const logger = new Logger({ level: 'info' });
-    expect(logger).toBeDefined();
-    // Check if methods exist (can't easily mock internal pino without spy)
-    expect(typeof logger.info).toBe('function');
-    expect(typeof logger.error).toBe('function');
-  });
-
-  it('should be integrated into QHTTPX', () => {
-    const app = new QHTTPX();
-    expect(app.logger).toBeDefined();
-    expect(app.logger instanceof Logger).toBe(true);
-  });
-});
-
-describe('RPC Client', () => {
-  it('should construct correct URLs and methods', async () => {
-     // We mock fetch globally
-     const originalFetch = global.fetch;
-     global.fetch = async (url: RequestInfo | URL, options?: RequestInit) => {
-       return new Response(JSON.stringify({ url, method: options?.method }), {
-         status: 200,
-         headers: { 'Content-Type': 'application/json' },
-       });
-     };
-
-     try {
-       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-       const client = hc<any>('http://localhost:3000');
-      
-      const res1 = await client.api.users[':id'].$get({ param: { id: '123' } });
-      const data1 = await res1.json();
-      expect(data1.url).toBe('http://localhost:3000/api/users/123');
-      expect(data1.method).toBe('GET');
-
-      const res2 = await client.auth.login.$post({ json: { username: 'test' } });
-      const data2 = await res2.json();
-      expect(data2.url).toBe('http://localhost:3000/auth/login');
-      expect(data2.method).toBe('POST');
-
-    } finally {
-      global.fetch = originalFetch;
-    }
-  });
-});

package/tests/fusion.test.ts

@@ -1,121 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { QHTTPX } from '../src/core/server';
-
-describe('Request Fusion Engine', () => {
-  let app: QHTTPX;
-
-  afterEach(async () => {
-    if (app) await app.close();
-  });
-
-  it('should coalesce simultaneous requests to the same endpoint', async () => {
-    app = new QHTTPX({ enableRequestFusion: true });
-    
-    let executionCount = 0;
-    
-    // Simulate a slow handler
-    app.get('/slow', async (ctx) => {
-      executionCount++;
-      await new Promise(resolve => setTimeout(resolve, 300));
-      ctx.json({ count: executionCount });
-    });
-
-    const { port } = await app.listen(0);
-    const url = `http://localhost:${port}/slow`;
-
-    // Fire 3 requests simultaneously
-    const p1 = fetch(url).then(r => r.json());
-    const p2 = fetch(url).then(r => r.json());
-    const p3 = fetch(url).then(r => r.json());
-
-    const results = await Promise.all([p1, p2, p3]);
-
-    // All should get the same result
-    expect(results[0]).toEqual({ count: 1 });
-    expect(results[1]).toEqual({ count: 1 });
-    expect(results[2]).toEqual({ count: 1 });
-
-    // Handler should have run only once
-    expect(executionCount).toBe(1);
-  });
-
-  it('should NOT coalesce requests with different query params', async () => {
-    app = new QHTTPX({ enableRequestFusion: true });
-    
-    let executionCount = 0;
-    
-    app.get('/echo', async (ctx) => {
-      executionCount++;
-      await new Promise(resolve => setTimeout(resolve, 20));
-      ctx.json({ q: ctx.query.q, count: executionCount });
-    });
-
-    const { port } = await app.listen(0);
-
-    const p1 = fetch(`http://localhost:${port}/echo?q=a`).then(r => r.json());
-    const p2 = fetch(`http://localhost:${port}/echo?q=b`).then(r => r.json());
-
-    const results = await Promise.all([p1, p2]);
-
-    expect(results[0].q).toBe('a');
-    expect(results[1].q).toBe('b');
-    
-    // Should run twice because keys are different
-    expect(executionCount).toBe(2);
-  });
-
-  it('should use cache window to coalesce burst traffic', async () => {
-    // 50ms window
-    app = new QHTTPX({ 
-      enableRequestFusion: { windowMs: 50 } 
-    });
-    
-    let executionCount = 0;
-    
-    app.get('/burst', async (ctx) => {
-      executionCount++;
-      // Fast handler
-      ctx.json({ count: executionCount });
-    });
-
-    const { port } = await app.listen(0);
-    const url = `http://localhost:${port}/burst`;
-
-    // Request 1
-    const r1 = await fetch(url).then(r => r.json());
-    expect(r1.count).toBe(1);
-
-    // Request 2 (immediate, within window)
-    const r2 = await fetch(url).then(r => r.json());
-    expect(r2.count).toBe(1); // Should be cached
-
-    // Request 3 (wait 100ms, outside window)
-    await new Promise(resolve => setTimeout(resolve, 100));
-    const r3 = await fetch(url).then(r => r.json());
-    expect(r3.count).toBe(2); // New execution
-  });
-
-  it('should respect vary headers (Authorization)', async () => {
-    app = new QHTTPX({ enableRequestFusion: true });
-    
-    let executionCount = 0;
-    
-    app.get('/auth', async (ctx) => {
-      executionCount++;
-      await new Promise(resolve => setTimeout(resolve, 20));
-      ctx.json({ user: ctx.req.headers['authorization'], count: executionCount });
-    });
-
-    const { port } = await app.listen(0);
-    const url = `http://localhost:${port}/auth`;
-
-    const p1 = fetch(url, { headers: { 'Authorization': 'UserA' } }).then(r => r.json());
-    const p2 = fetch(url, { headers: { 'Authorization': 'UserB' } }).then(r => r.json());
-
-    const results = await Promise.all([p1, p2]);
-
-    expect(results[0].user).toBe('UserA');
-    expect(results[1].user).toBe('UserB');
-    expect(executionCount).toBe(2);
-  });
-});

package/tests/http-basic.test.ts

@@ -1,161 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { QHTTPX } from '../src/index';
-
-describe('QHTTPX minimal HTTP runtime', () => {
-  let app: QHTTPX | undefined;
-
-  afterEach(async () => {
-    if (app) {
-      await app.close();
-      app = undefined;
-    }
-  });
-
-  it('handles GET / and returns JSON', async () => {
-    app = new QHTTPX();
-
-    app.get('/', (ctx) => {
-      ctx.json({ message: 'Hello from QHTTPX' });
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-
-    const response = await fetch(`http://127.0.0.1:${port}/`);
-    expect(response.status).toBe(200);
-    const json = (await response.json()) as { message: string };
-    expect(json.message).toBe('Hello from QHTTPX');
-  });
-
-  it('returns 404 for unknown route', async () => {
-    app = new QHTTPX();
-
-    const { port } = await app.listen(0, '127.0.0.1');
-
-    const response = await fetch(`http://127.0.0.1:${port}/unknown`);
-    expect(response.status).toBe(404);
-  });
-
-  it('supports params and query parsing', async () => {
-    app = new QHTTPX();
-
-    app.get('/users/:id', (ctx) => {
-      ctx.json({
-        id: ctx.params.id,
-        q: ctx.query.q,
-      });
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-
-    const response = await fetch(`http://127.0.0.1:${port}/users/123?q=test`);
-    expect(response.status).toBe(200);
-    const json = (await response.json()) as { id: string; q: string };
-    expect(json.id).toBe('123');
-    expect(json.q).toBe('test');
-  });
-
-  it('parses JSON body for POST', async () => {
-    app = new QHTTPX();
-
-    app.post('/echo', (ctx) => {
-      ctx.json({ body: ctx.body });
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-
-    const response = await fetch(`http://127.0.0.1:${port}/echo`, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-      },
-      body: JSON.stringify({ hello: 'world' }),
-    });
-
-    expect(response.status).toBe(200);
-    const json = (await response.json()) as { body: { hello: string } };
-    expect(json.body.hello).toBe('world');
-  });
-
-  it('returns 400 for invalid JSON body', async () => {
-    app = new QHTTPX();
-
-    const { port } = await app.listen(0, '127.0.0.1');
-
-    app.post('/echo', (ctx) => {
-      ctx.json({ body: ctx.body });
-    });
-
-    const response = await fetch(`http://127.0.0.1:${port}/echo`, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-      },
-      body: '{ invalid',
-    });
-
-    expect(response.status).toBe(400);
-    const text = await response.text();
-    expect(text).toBe('Invalid JSON');
-  });
-
-  it('enforces maxBodyBytes with 413 status', async () => {
-    app = new QHTTPX({ maxBodyBytes: 8 });
-
-    app.post('/echo', (ctx) => {
-      ctx.json({ body: ctx.body });
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-
-    const response = await fetch(`http://127.0.0.1:${port}/echo`, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-      },
-      body: JSON.stringify({ hello: 'world' }),
-    });
-
-    expect(response.status).toBe(413);
-    const text = await response.text();
-    expect(text).toBe('Payload Too Large');
-  });
-
-  it('enforces maxConcurrency with 503 overload', async () => {
-    app = new QHTTPX({ maxConcurrency: 1 });
-
-    app.get('/slow', async (ctx) => {
-      await new Promise<void>((resolve) => {
-        setTimeout(resolve, 100);
-      });
-      ctx.json({ ok: true });
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-
-    const url = `http://127.0.0.1:${port}/slow`;
-
-    const first = fetch(url);
-    const second = fetch(url);
-
-    const [firstRes, secondRes] = await Promise.all([first, second]);
-
-    const statuses = [firstRes.status, secondRes.status].sort();
-    expect(statuses).toEqual([200, 503]);
-  });
-
-  it('applies request timeout with 504 status', async () => {
-    app = new QHTTPX({ requestTimeoutMs: 20 });
-
-    app.get('/timeout', async (ctx) => {
-      await new Promise<void>((resolve) => {
-        setTimeout(resolve, 100);
-      });
-      ctx.json({ ok: true });
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-
-    const response = await fetch(`http://127.0.0.1:${port}/timeout`);
-    expect(response.status).toBe(504);
-  });
-});

package/tests/logger.test.ts

@@ -1,48 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { QHTTPX, createLoggerMiddleware } from '../src';
-
-describe('Logger middleware', () => {
-  let app: QHTTPX | undefined;
-
-  afterEach(async () => {
-    if (app) {
-      await app.close();
-      app = undefined;
-    }
-  });
-
-  it('logs basic request information to sink', async () => {
-    const sink = vi.fn();
-
-    app = new QHTTPX();
-    app.use(
-      createLoggerMiddleware({
-        sink,
-      }),
-    );
-
-    app.get('/hello', (ctx) => {
-      ctx.send('ok');
-    });
-
-    const { port } = await app.listen(0, '127.0.0.1');
-
-    const response = await fetch(`http://127.0.0.1:${port}/hello`);
-
-    expect(response.status).toBe(200);
-    expect(await response.text()).toBe('ok');
-
-    expect(sink).toHaveBeenCalledTimes(1);
-    const entry = sink.mock.calls[0][0] as {
-      method: string;
-      path: string;
-      status: number;
-      durationMs: number;
-    };
-    expect(entry.method).toBe('GET');
-    expect(entry.path).toBe('/hello');
-    expect(entry.status).toBe(200);
-    expect(entry.durationMs).toBeGreaterThanOrEqual(0);
-  });
-});
-