qhttpx 1.8.0

package/dist/tests/features.test.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../src/index");
+const logger_1 = require("../src/core/logger");
+const client_1 = require("../src/client");
+(0, vitest_1.describe)('Logger', () => {
+    (0, vitest_1.it)('should initialize with pino', () => {
+        const logger = new logger_1.Logger({ level: 'info' });
+        (0, vitest_1.expect)(logger).toBeDefined();
+        // Check if methods exist (can't easily mock internal pino without spy)
+        (0, vitest_1.expect)(typeof logger.info).toBe('function');
+        (0, vitest_1.expect)(typeof logger.error).toBe('function');
+    });
+    (0, vitest_1.it)('should be integrated into QHTTPX', () => {
+        const app = new index_1.QHTTPX();
+        (0, vitest_1.expect)(app.logger).toBeDefined();
+        (0, vitest_1.expect)(app.logger instanceof logger_1.Logger).toBe(true);
+    });
+});
+(0, vitest_1.describe)('RPC Client', () => {
+    (0, vitest_1.it)('should construct correct URLs and methods', async () => {
+        // We mock fetch globally
+        const originalFetch = global.fetch;
+        global.fetch = async (url, options) => {
+            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 = (0, client_1.hc)('http://localhost:3000');
+            const res1 = await client.api.users[':id'].$get({ param: { id: '123' } });
+            const data1 = await res1.json();
+            (0, vitest_1.expect)(data1.url).toBe('http://localhost:3000/api/users/123');
+            (0, vitest_1.expect)(data1.method).toBe('GET');
+            const res2 = await client.auth.login.$post({ json: { username: 'test' } });
+            const data2 = await res2.json();
+            (0, vitest_1.expect)(data2.url).toBe('http://localhost:3000/auth/login');
+            (0, vitest_1.expect)(data2.method).toBe('POST');
+        }
+        finally {
+            global.fetch = originalFetch;
+        }
+    });
+});

package/dist/tests/fusion.test.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const server_1 = require("../src/core/server");
+(0, vitest_1.describe)('Request Fusion Engine', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app)
+            await app.close();
+    });
+    (0, vitest_1.it)('should coalesce simultaneous requests to the same endpoint', async () => {
+        app = new server_1.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
+        (0, vitest_1.expect)(results[0]).toEqual({ count: 1 });
+        (0, vitest_1.expect)(results[1]).toEqual({ count: 1 });
+        (0, vitest_1.expect)(results[2]).toEqual({ count: 1 });
+        // Handler should have run only once
+        (0, vitest_1.expect)(executionCount).toBe(1);
+    });
+    (0, vitest_1.it)('should NOT coalesce requests with different query params', async () => {
+        app = new server_1.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]);
+        (0, vitest_1.expect)(results[0].q).toBe('a');
+        (0, vitest_1.expect)(results[1].q).toBe('b');
+        // Should run twice because keys are different
+        (0, vitest_1.expect)(executionCount).toBe(2);
+    });
+    (0, vitest_1.it)('should use cache window to coalesce burst traffic', async () => {
+        // 50ms window
+        app = new server_1.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());
+        (0, vitest_1.expect)(r1.count).toBe(1);
+        // Request 2 (immediate, within window)
+        const r2 = await fetch(url).then(r => r.json());
+        (0, vitest_1.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());
+        (0, vitest_1.expect)(r3.count).toBe(2); // New execution
+    });
+    (0, vitest_1.it)('should respect vary headers (Authorization)', async () => {
+        app = new server_1.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]);
+        (0, vitest_1.expect)(results[0].user).toBe('UserA');
+        (0, vitest_1.expect)(results[1].user).toBe('UserB');
+        (0, vitest_1.expect)(executionCount).toBe(2);
+    });
+});

package/dist/tests/http-basic.test.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../src/index");
+(0, vitest_1.describe)('QHTTPX minimal HTTP runtime', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app) {
+            await app.close();
+            app = undefined;
+        }
+    });
+    (0, vitest_1.it)('handles GET / and returns JSON', async () => {
+        app = new index_1.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}/`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const json = (await response.json());
+        (0, vitest_1.expect)(json.message).toBe('Hello from QHTTPX');
+    });
+    (0, vitest_1.it)('returns 404 for unknown route', async () => {
+        app = new index_1.QHTTPX();
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/unknown`);
+        (0, vitest_1.expect)(response.status).toBe(404);
+    });
+    (0, vitest_1.it)('supports params and query parsing', async () => {
+        app = new index_1.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`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const json = (await response.json());
+        (0, vitest_1.expect)(json.id).toBe('123');
+        (0, vitest_1.expect)(json.q).toBe('test');
+    });
+    (0, vitest_1.it)('parses JSON body for POST', async () => {
+        app = new index_1.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' }),
+        });
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const json = (await response.json());
+        (0, vitest_1.expect)(json.body.hello).toBe('world');
+    });
+    (0, vitest_1.it)('returns 400 for invalid JSON body', async () => {
+        app = new index_1.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',
+        });
+        (0, vitest_1.expect)(response.status).toBe(400);
+        const text = await response.text();
+        (0, vitest_1.expect)(text).toBe('Invalid JSON');
+    });
+    (0, vitest_1.it)('enforces maxBodyBytes with 413 status', async () => {
+        app = new index_1.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' }),
+        });
+        (0, vitest_1.expect)(response.status).toBe(413);
+        const text = await response.text();
+        (0, vitest_1.expect)(text).toBe('Payload Too Large');
+    });
+    (0, vitest_1.it)('enforces maxConcurrency with 503 overload', async () => {
+        app = new index_1.QHTTPX({ maxConcurrency: 1 });
+        app.get('/slow', async (ctx) => {
+            await new Promise((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();
+        (0, vitest_1.expect)(statuses).toEqual([200, 503]);
+    });
+    (0, vitest_1.it)('applies request timeout with 504 status', async () => {
+        app = new index_1.QHTTPX({ requestTimeoutMs: 20 });
+        app.get('/timeout', async (ctx) => {
+            await new Promise((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`);
+        (0, vitest_1.expect)(response.status).toBe(504);
+    });
+});

package/dist/tests/logger.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)('Logger middleware', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app) {
+            await app.close();
+            app = undefined;
+        }
+    });
+    (0, vitest_1.it)('logs basic request information to sink', async () => {
+        const sink = vitest_1.vi.fn();
+        app = new src_1.QHTTPX();
+        app.use((0, src_1.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`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(await response.text()).toBe('ok');
+        (0, vitest_1.expect)(sink).toHaveBeenCalledTimes(1);
+        const entry = sink.mock.calls[0][0];
+        (0, vitest_1.expect)(entry.method).toBe('GET');
+        (0, vitest_1.expect)(entry.path).toBe('/hello');
+        (0, vitest_1.expect)(entry.status).toBe(200);
+        (0, vitest_1.expect)(entry.durationMs).toBeGreaterThanOrEqual(0);
+    });
+});

package/dist/tests/middleware.test.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../src/index");
+(0, vitest_1.describe)('QHTTPX middleware pipeline', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app) {
+            await app.close();
+            app = undefined;
+        }
+    });
+    (0, vitest_1.it)('runs middleware in order with await next()', async () => {
+        app = new index_1.QHTTPX();
+        const calls = [];
+        app.use(async (ctx, next) => {
+            calls.push('m1-before');
+            await next();
+            calls.push('m1-after');
+        });
+        app.use(async (ctx, next) => {
+            calls.push('m2-before');
+            await next();
+            calls.push('m2-after');
+        });
+        app.get('/', (ctx) => {
+            calls.push('handler');
+            ctx.send('ok');
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(calls).toEqual([
+            'm1-before',
+            'm2-before',
+            'handler',
+            'm2-after',
+            'm1-after',
+        ]);
+    });
+    (0, vitest_1.it)('allows middleware to modify response headers', async () => {
+        app = new index_1.QHTTPX();
+        app.use((ctx, next) => {
+            ctx.res.setHeader('x-powered-by', 'qhttpx');
+            return next();
+        });
+        app.get('/', (ctx) => {
+            ctx.send('ok');
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const header = response.headers.get('x-powered-by');
+        (0, vitest_1.expect)(header).toBe('qhttpx');
+    });
+    (0, vitest_1.it)('supports auth middleware that short-circuits unauthorized requests', async () => {
+        app = new index_1.QHTTPX();
+        app.use((ctx, next) => {
+            const auth = ctx.req.headers['authorization'];
+            if (auth !== 'Bearer secret') {
+                ctx.res.statusCode = 401;
+                ctx.res.end('Unauthorized');
+                return;
+            }
+            return next();
+        });
+        app.get('/secure', (ctx) => {
+            ctx.send('ok');
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const unauthorized = await fetch(`http://127.0.0.1:${port}/secure`);
+        (0, vitest_1.expect)(unauthorized.status).toBe(401);
+        const unauthorizedText = await unauthorized.text();
+        (0, vitest_1.expect)(unauthorizedText).toBe('Unauthorized');
+        const authorized = await fetch(`http://127.0.0.1:${port}/secure`, {
+            headers: {
+                authorization: 'Bearer secret',
+            },
+        });
+        (0, vitest_1.expect)(authorized.status).toBe(200);
+        const body = await authorized.text();
+        (0, vitest_1.expect)(body).toBe('ok');
+    });
+    (0, vitest_1.it)('supports error-handling middleware that converts errors to JSON', async () => {
+        app = new index_1.QHTTPX();
+        app.use(async (ctx, next) => {
+            try {
+                await next();
+            }
+            catch (err) {
+                ctx.res.statusCode = 500;
+                ctx.res.setHeader('content-type', 'application/json; charset=utf-8');
+                ctx.res.end(JSON.stringify({
+                    error: 'internal',
+                    message: err instanceof Error ? err.message : 'unknown',
+                }));
+            }
+        });
+        app.get('/boom', () => {
+            throw new Error('boom');
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/boom`);
+        (0, vitest_1.expect)(response.status).toBe(500);
+        const json = (await response.json());
+        (0, vitest_1.expect)(json.error).toBe('internal');
+        (0, vitest_1.expect)(json.message).toBe('boom');
+    });
+});

package/dist/tests/observability.test.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../src/index");
+(0, vitest_1.describe)('QHTTPX observability and health', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app) {
+            await app.close();
+            app = undefined;
+        }
+    });
+    (0, vitest_1.it)('exposes a health endpoint with basic info', async () => {
+        app = new index_1.QHTTPX();
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/__qhttpx/health`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const json = (await response.json());
+        (0, vitest_1.expect)(json.status).toBe('ok');
+        (0, vitest_1.expect)(typeof json.name).toBe('string');
+        (0, vitest_1.expect)(typeof json.version).toBe('string');
+        (0, vitest_1.expect)(json.workers).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)('exposes metrics for handled requests', async () => {
+        app = new index_1.QHTTPX();
+        app.get('/ping', (ctx) => {
+            ctx.send('pong');
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        await fetch(`http://127.0.0.1:${port}/ping`);
+        await fetch(`http://127.0.0.1:${port}/ping`);
+        const response = await fetch(`http://127.0.0.1:${port}/__qhttpx/metrics`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const json = (await response.json());
+        (0, vitest_1.expect)(json.totalRequests).toBeGreaterThanOrEqual(2);
+        (0, vitest_1.expect)(json.inFlightRequests).toBeGreaterThanOrEqual(0);
+        (0, vitest_1.expect)(json.latency.p50 === null || json.latency.p50 >= 0).toBe(true);
+        (0, vitest_1.expect)(json.memory.rssBytes).toBeGreaterThan(0);
+        (0, vitest_1.expect)(json.memory.heapUsedBytes).toBeGreaterThan(0);
+        (0, vitest_1.expect)(json.workers).toBeGreaterThan(0);
+    });
+    (0, vitest_1.it)('propagates and generates x-request-id headers', async () => {
+        app = new index_1.QHTTPX();
+        app.get('/ping', (ctx) => {
+            ctx.send('pong');
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const first = await fetch(`http://127.0.0.1:${port}/ping`);
+        const firstId = first.headers.get('x-request-id');
+        (0, vitest_1.expect)(firstId === null || firstId.length > 0).toBe(true);
+        const second = await fetch(`http://127.0.0.1:${port}/ping`, {
+            headers: {
+                'x-request-id': 'custom-id-123',
+            },
+        });
+        const secondId = second.headers.get('x-request-id');
+        (0, vitest_1.expect)(secondId).toBe('custom-id-123');
+    });
+});

package/dist/tests/openapi.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const server_1 = require("../src/core/server");
+(0, vitest_1.describe)('OpenAPI Generator', () => {
+    (0, vitest_1.it)('should generate valid OpenAPI spec from routes', () => {
+        const app = new server_1.QHTTPX();
+        const userSchema = {
+            params: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' }
+                }
+            },
+            body: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    age: { type: 'number', min: 18 }
+                }
+            },
+            response: {
+                type: 'object',
+                properties: {
+                    success: { type: 'boolean' }
+                }
+            }
+        };
+        app.post('/users/:id', {
+            schema: userSchema,
+            handler: (ctx) => { ctx.json({ success: true }); }
+        });
+        app.get('/health', (ctx) => { ctx.send('ok'); });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const spec = app.getOpenAPI({
+            info: {
+                title: 'Test API',
+                version: '1.0.0'
+            }
+        });
+        // Check basic structure
+        (0, vitest_1.expect)(spec.openapi).toBe('3.0.0');
+        (0, vitest_1.expect)(spec.info.title).toBe('Test API');
+        // Check Path normalization
+        (0, vitest_1.expect)(spec.paths['/users/{id}']).toBeDefined();
+        (0, vitest_1.expect)(spec.paths['/health']).toBeDefined();
+        // Check Operation
+        const postUser = spec.paths['/users/{id}'].post;
+        (0, vitest_1.expect)(postUser).toBeDefined();
+        // Check Params
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const pathParam = postUser.parameters.find((p) => p.name === 'id');
+        (0, vitest_1.expect)(pathParam).toBeDefined();
+        (0, vitest_1.expect)(pathParam.in).toBe('path');
+        (0, vitest_1.expect)(pathParam.required).toBe(true);
+        // Check Request Body
+        const bodySchema = postUser.requestBody.content['application/json'].schema;
+        (0, vitest_1.expect)(bodySchema.properties.name.type).toBe('string');
+        (0, vitest_1.expect)(bodySchema.properties.age.minimum).toBe(18);
+        // Check Response
+        const responseSchema = postUser.responses['200'].content['application/json'].schema;
+        (0, vitest_1.expect)(responseSchema.properties.success.type).toBe('boolean');
+    });
+});

package/dist/tests/plugin.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const server_1 = require("../src/core/server");
+(0, vitest_1.describe)('Plugin System', () => {
+    (0, vitest_1.it)('should register a simple plugin', async () => {
+        const app = new server_1.QHTTPX();
+        let pluginRun = false;
+        const myPlugin = async (scope) => {
+            pluginRun = true;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            scope.get('/ping', (ctx) => ctx.json({ pong: true }));
+        };
+        await app.register(myPlugin);
+        (0, vitest_1.expect)(pluginRun).toBe(true);
+        const { port } = await app.listen(0);
+        const res = await fetch(`http://localhost:${port}/ping`);
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual({ pong: true });
+    });
+    (0, vitest_1.it)('should handle prefixes', async () => {
+        const app = new server_1.QHTTPX();
+        const apiPlugin = async (scope) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            scope.get('/users', (ctx) => ctx.json({ users: [] }));
+        };
+        // Register with prefix /v1
+        await app.register(apiPlugin, { prefix: '/v1' });
+        const { port } = await app.listen(0);
+        // /v1/users should exist
+        const res = await fetch(`http://localhost:${port}/v1/users`);
+        (0, vitest_1.expect)(res.status).toBe(200);
+        // /users should NOT exist
+        const res404 = await fetch(`http://localhost:${port}/users`);
+        (0, vitest_1.expect)(res404.status).toBe(404);
+    });
+    (0, vitest_1.it)('should handle nested plugins with concatenated prefixes', async () => {
+        const app = new server_1.QHTTPX();
+        const usersPlugin = async (scope) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            scope.get('/list', (ctx) => ctx.json({ list: true }));
+        };
+        const v1Plugin = async (scope) => {
+            // Register nested plugin under /users
+            await scope.register(usersPlugin, { prefix: '/users' });
+        };
+        // Register v1 under /api
+        await app.register(v1Plugin, { prefix: '/api' });
+        const { port } = await app.listen(0);
+        // Result should be /api/users/list
+        const res = await fetch(`http://localhost:${port}/api/users/list`);
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual({ list: true });
+    });
+    (0, vitest_1.it)('should pass options to plugins', async () => {
+        const app = new server_1.QHTTPX();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let receivedOpts;
+        const configPlugin = async (scope, opts) => {
+            receivedOpts = opts;
+        };
+        await app.register(configPlugin, { prefix: '/a', secret: '123' });
+        (0, vitest_1.expect)(receivedOpts).toEqual({ prefix: '/a', secret: '123' });
+    });
+});

package/dist/tests/plugins.test.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const server_1 = require("../src/core/server");
+const testing_1 = require("../src/testing");
+(0, vitest_1.describe)('Plugin System', () => {
+    (0, vitest_1.it)('should register a simple plugin', async () => {
+        const app = new server_1.QHTTPX();
+        const myPlugin = (s) => {
+            const scope = s;
+            scope.get('/plugin', (ctx) => {
+                ctx.json({ message: 'Hello from Plugin' });
+            });
+        };
+        await app.register(myPlugin);
+        const client = (0, testing_1.createTestClient)(app);
+        const res = await client.get('/plugin');
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual({ message: 'Hello from Plugin' });
+        await client.stop();
+    });
+    (0, vitest_1.it)('should support scoped prefixes', async () => {
+        const app = new server_1.QHTTPX();
+        const v1Plugin = (s) => {
+            const scope = s;
+            scope.get('/users', (ctx) => {
+                ctx.json({ version: 'v1' });
+            });
+        };
+        await app.register(v1Plugin, { prefix: '/v1' });
+        const client = (0, testing_1.createTestClient)(app);
+        const res = await client.get('/v1/users');
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual({ version: 'v1' });
+        await client.stop();
+    });
+    (0, vitest_1.it)('should support nested plugins', async () => {
+        const app = new server_1.QHTTPX();
+        const usersPlugin = (s) => {
+            const scope = s;
+            scope.get('/list', (ctx) => {
+                ctx.json({ users: [] });
+            });
+        };
+        const apiPlugin = async (s) => {
+            const scope = s;
+            await scope.register(usersPlugin, { prefix: '/users' });
+        };
+        await app.register(apiPlugin, { prefix: '/api' });
+        const client = (0, testing_1.createTestClient)(app);
+        const res = await client.get('/api/users/list');
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual({ users: [] });
+        await client.stop();
+    });
+    (0, vitest_1.it)('should support plugin options', async () => {
+        const app = new server_1.QHTTPX();
+        const authPlugin = (s, options) => {
+            const scope = s;
+            scope.get('/secret', (ctx) => {
+                ctx.json({ secret: options.secret });
+            });
+        };
+        await app.register(authPlugin, { secret: 'super-secret' });
+        const client = (0, testing_1.createTestClient)(app);
+        const res = await client.get('/secret');
+        (0, vitest_1.expect)(res.status).toBe(200);
+        (0, vitest_1.expect)(await res.json()).toEqual({ secret: 'super-secret' });
+        await client.stop();
+    });
+});