npm - qhttpx - Versions diffs - 1.8.0 - Mend

qhttpx 1.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (197) hide show

package/.eslintrc.json +22 -0
package/.github/workflows/ci.yml +32 -0
package/.github/workflows/npm-publish.yml +37 -0
package/.github/workflows/release.yml +21 -0
package/.prettierrc +7 -0
package/CHANGELOG.md +145 -0
package/LICENSE +21 -0
package/README.md +343 -0
package/dist/package.json +61 -0
package/dist/src/benchmarks/compare-frameworks.js +119 -0
package/dist/src/benchmarks/quantam-users.js +56 -0
package/dist/src/benchmarks/simple-json.js +58 -0
package/dist/src/benchmarks/ultra-mode.js +122 -0
package/dist/src/cli/index.js +200 -0
package/dist/src/client/index.js +72 -0
package/dist/src/core/batch.js +97 -0
package/dist/src/core/body-parser.js +121 -0
package/dist/src/core/buffer-pool.js +70 -0
package/dist/src/core/config.js +50 -0
package/dist/src/core/fusion.js +183 -0
package/dist/src/core/logger.js +49 -0
package/dist/src/core/metrics.js +111 -0
package/dist/src/core/resources.js +25 -0
package/dist/src/core/scheduler.js +85 -0
package/dist/src/core/scope.js +68 -0
package/dist/src/core/serializer.js +44 -0
package/dist/src/core/server.js +905 -0
package/dist/src/core/stream.js +71 -0
package/dist/src/core/tasks.js +87 -0
package/dist/src/core/types.js +19 -0
package/dist/src/core/websocket.js +86 -0
package/dist/src/core/worker-queue.js +73 -0
package/dist/src/database/adapters/memory.js +90 -0
package/dist/src/database/adapters/mongo.js +141 -0
package/dist/src/database/adapters/postgres.js +111 -0
package/dist/src/database/adapters/sqlite.js +42 -0
package/dist/src/database/coalescer.js +134 -0
package/dist/src/database/manager.js +87 -0
package/dist/src/database/types.js +2 -0
package/dist/src/index.js +61 -0
package/dist/src/middleware/compression.js +133 -0
package/dist/src/middleware/cors.js +66 -0
package/dist/src/middleware/presets.js +33 -0
package/dist/src/middleware/rate-limit.js +77 -0
package/dist/src/middleware/security.js +69 -0
package/dist/src/middleware/static.js +191 -0
package/dist/src/openapi/generator.js +149 -0
package/dist/src/router/radix-router.js +89 -0
package/dist/src/router/radix-tree.js +81 -0
package/dist/src/router/router.js +146 -0
package/dist/src/testing/index.js +84 -0
package/dist/src/utils/cookies.js +59 -0
package/dist/src/utils/logger.js +45 -0
package/dist/src/utils/signals.js +31 -0
package/dist/src/utils/sse.js +32 -0
package/dist/src/validation/index.js +19 -0
package/dist/src/validation/simple.js +102 -0
package/dist/src/validation/types.js +12 -0
package/dist/src/validation/zod.js +18 -0
package/dist/src/views/index.js +17 -0
package/dist/src/views/types.js +2 -0
package/dist/tests/adapters.test.js +106 -0
package/dist/tests/batch.test.js +117 -0
package/dist/tests/body-parser.test.js +52 -0
package/dist/tests/compression-sse.test.js +87 -0
package/dist/tests/cookies.test.js +63 -0
package/dist/tests/cors.test.js +55 -0
package/dist/tests/database.test.js +80 -0
package/dist/tests/dx.test.js +64 -0
package/dist/tests/ecosystem.test.js +133 -0
package/dist/tests/features.test.js +47 -0
package/dist/tests/fusion.test.js +92 -0
package/dist/tests/http-basic.test.js +124 -0
package/dist/tests/logger.test.js +33 -0
package/dist/tests/middleware.test.js +109 -0
package/dist/tests/observability.test.js +59 -0
package/dist/tests/openapi.test.js +64 -0
package/dist/tests/plugin.test.js +65 -0
package/dist/tests/plugins.test.js +71 -0
package/dist/tests/rate-limit.test.js +77 -0
package/dist/tests/resources.test.js +44 -0
package/dist/tests/scheduler.test.js +46 -0
package/dist/tests/schema-routes.test.js +77 -0
package/dist/tests/security.test.js +83 -0
package/dist/tests/server-db.test.js +72 -0
package/dist/tests/smoke.test.js +10 -0
package/dist/tests/sqlite-fusion.test.js +92 -0
package/dist/tests/static.test.js +102 -0
package/dist/tests/stream.test.js +44 -0
package/dist/tests/task-metrics.test.js +53 -0
package/dist/tests/tasks.test.js +62 -0
package/dist/tests/testing.test.js +47 -0
package/dist/tests/validation.test.js +107 -0
package/dist/tests/websocket.test.js +146 -0
package/dist/vitest.config.js +9 -0
package/docs/AEGIS.md +76 -0
package/docs/BENCHMARKS.md +36 -0
package/docs/CAPABILITIES.md +70 -0
package/docs/CLI.md +43 -0
package/docs/DATABASE.md +142 -0
package/docs/ECOSYSTEM.md +146 -0
package/docs/NEXT_STEPS.md +99 -0
package/docs/OPENAPI.md +99 -0
package/docs/PLUGINS.md +59 -0
package/docs/REAL_WORLD_EXAMPLES.md +109 -0
package/docs/ROADMAP.md +366 -0
package/docs/VALIDATION.md +136 -0
package/eslint.config.cjs +26 -0
package/examples/api-server.ts +254 -0
package/package.json +61 -0
package/src/benchmarks/compare-frameworks.ts +149 -0
package/src/benchmarks/quantam-users.ts +70 -0
package/src/benchmarks/simple-json.ts +71 -0
package/src/benchmarks/ultra-mode.ts +159 -0
package/src/cli/index.ts +214 -0
package/src/client/index.ts +93 -0
package/src/core/batch.ts +110 -0
package/src/core/body-parser.ts +151 -0
package/src/core/buffer-pool.ts +96 -0
package/src/core/config.ts +60 -0
package/src/core/fusion.ts +210 -0
package/src/core/logger.ts +70 -0
package/src/core/metrics.ts +166 -0
package/src/core/resources.ts +38 -0
package/src/core/scheduler.ts +126 -0
package/src/core/scope.ts +87 -0
package/src/core/serializer.ts +41 -0
package/src/core/server.ts +1113 -0
package/src/core/stream.ts +111 -0
package/src/core/tasks.ts +138 -0
package/src/core/types.ts +178 -0
package/src/core/websocket.ts +112 -0
package/src/core/worker-queue.ts +90 -0
package/src/database/adapters/memory.ts +99 -0
package/src/database/adapters/mongo.ts +116 -0
package/src/database/adapters/postgres.ts +86 -0
package/src/database/adapters/sqlite.ts +44 -0
package/src/database/coalescer.ts +153 -0
package/src/database/manager.ts +97 -0
package/src/database/types.ts +24 -0
package/src/index.ts +42 -0
package/src/middleware/compression.ts +147 -0
package/src/middleware/cors.ts +98 -0
package/src/middleware/presets.ts +50 -0
package/src/middleware/rate-limit.ts +106 -0
package/src/middleware/security.ts +109 -0
package/src/middleware/static.ts +216 -0
package/src/openapi/generator.ts +167 -0
package/src/router/radix-router.ts +119 -0
package/src/router/radix-tree.ts +106 -0
package/src/router/router.ts +190 -0
package/src/testing/index.ts +104 -0
package/src/utils/cookies.ts +67 -0
package/src/utils/logger.ts +59 -0
package/src/utils/signals.ts +45 -0
package/src/utils/sse.ts +41 -0
package/src/validation/index.ts +3 -0
package/src/validation/simple.ts +93 -0
package/src/validation/types.ts +38 -0
package/src/validation/zod.ts +14 -0
package/src/views/index.ts +1 -0
package/src/views/types.ts +4 -0
package/tests/adapters.test.ts +120 -0
package/tests/batch.test.ts +139 -0
package/tests/body-parser.test.ts +83 -0
package/tests/compression-sse.test.ts +98 -0
package/tests/cookies.test.ts +74 -0
package/tests/cors.test.ts +79 -0
package/tests/database.test.ts +90 -0
package/tests/dx.test.ts +78 -0
package/tests/ecosystem.test.ts +156 -0
package/tests/features.test.ts +51 -0
package/tests/fusion.test.ts +121 -0
package/tests/http-basic.test.ts +161 -0
package/tests/logger.test.ts +48 -0
package/tests/middleware.test.ts +137 -0
package/tests/observability.test.ts +91 -0
package/tests/openapi.test.ts +74 -0
package/tests/plugin.test.ts +85 -0
package/tests/plugins.test.ts +93 -0
package/tests/rate-limit.test.ts +97 -0
package/tests/resources.test.ts +64 -0
package/tests/scheduler.test.ts +71 -0
package/tests/schema-routes.test.ts +89 -0
package/tests/security.test.ts +128 -0
package/tests/server-db.test.ts +72 -0
package/tests/smoke.test.ts +9 -0
package/tests/sqlite-fusion.test.ts +106 -0
package/tests/static.test.ts +111 -0
package/tests/stream.test.ts +58 -0
package/tests/task-metrics.test.ts +78 -0
package/tests/tasks.test.ts +90 -0
package/tests/testing.test.ts +53 -0
package/tests/validation.test.ts +126 -0
package/tests/websocket.test.ts +132 -0
package/tsconfig.json +16 -0
package/vitest.config.ts +9 -0

package/tests/dx.test.ts ADDED Viewed

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import { QHTTPX, createHttpApp } from '../src/index';
+import { createApiPreset, createStaticAppPreset } from '../src/middleware/presets';
+describe('Developer Experience Features', () => {
+  describe('Routing Ergonomics', () => {
+    it('supports chainable route() builder', async () => {
+      const app = new QHTTPX();
+      app.route('/users/:id')
+        .get((ctx) => ctx.json({ method: 'GET', id: ctx.params.id }))
+        .post((ctx) => ctx.json({ method: 'POST', id: ctx.params.id }))
+        .put((ctx) => ctx.json({ method: 'PUT', id: ctx.params.id }))
+        .delete((ctx) => ctx.json({ method: 'DELETE', id: ctx.params.id }));
+      const { port } = await app.listen(0, '127.0.0.1');
+      const baseUrl = `http://127.0.0.1:${port}`;
+      // Test GET
+      const resGet = await fetch(`${baseUrl}/users/123`);
+      expect(await resGet.json()).toEqual({ method: 'GET', id: '123' });
+      // Test POST
+      const resPost = await fetch(`${baseUrl}/users/123`, { method: 'POST' });
+      expect(await resPost.json()).toEqual({ method: 'POST', id: '123' });
+      // Test PUT
+      const resPut = await fetch(`${baseUrl}/users/123`, { method: 'PUT' });
+      expect(await resPut.json()).toEqual({ method: 'PUT', id: '123' });
+      // Test DELETE
+      const resDelete = await fetch(`${baseUrl}/users/123`, { method: 'DELETE' });
+      expect(await resDelete.json()).toEqual({ method: 'DELETE', id: '123' });
+      await app.close();
+    });
+  });
+  describe('Simple App Helper', () => {
+    it('supports createHttpApp basic usage', async () => {
+      const app = createHttpApp();
+      app.get('/', (ctx) => {
+        ctx.send('Hello World!');
+      });
+      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);
+      expect(await response.text()).toBe('Hello World!');
+      await app.close();
+    });
+  });
+  describe('Presets', () => {
+    it('createApiPreset returns middlewares', () => {
+      const middlewares = createApiPreset();
+      // Should have CORS (1) + Security Headers (1) + Logger (1) = 3
+      expect(middlewares.length).toBe(3);
+    });
+    it('createApiPreset allows disabling logger', () => {
+      const middlewares = createApiPreset({ logging: false });
+      // CORS + Security Headers = 2
+      expect(middlewares.length).toBe(2);
+    });
+    it('createStaticAppPreset returns middlewares with static', () => {
+      const middlewares = createStaticAppPreset({
+        static: { root: './public' },
+      });
+      // CORS + Security Headers + Logger + Static = 4
+      expect(middlewares.length).toBe(4);
+    });
+  });
+});

package/tests/ecosystem.test.ts ADDED Viewed

@@ -0,0 +1,156 @@
+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 ADDED Viewed

@@ -0,0 +1,51 @@
+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 ADDED Viewed

@@ -0,0 +1,121 @@
+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 ADDED Viewed

@@ -0,0 +1,161 @@
+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 ADDED Viewed

@@ -0,0 +1,48 @@
+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);
+  });
+});