qhttpx 1.9.2 → 1.9.3

package/dist/tests/static.test.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+// import http from 'http';
+const server_1 = require("../src/core/server");
+const static_1 = require("../src/middleware/static");
+const TEST_DIR = path_1.default.join(__dirname, 'fixtures');
+const TEST_FILE = path_1.default.join(TEST_DIR, 'test.txt');
+const TEST_CONTENT = 'Hello World! This is a test file for QHTTPX static middleware.';
+(0, vitest_1.describe)('static middleware', () => {
+    let app;
+    let serverUrl;
+    (0, vitest_1.beforeAll)(async () => {
+        // Create fixtures
+        if (!fs_1.default.existsSync(TEST_DIR))
+            fs_1.default.mkdirSync(TEST_DIR);
+        fs_1.default.writeFileSync(TEST_FILE, TEST_CONTENT);
+        app = new server_1.QHTTPX();
+        app.use((0, static_1.createStaticMiddleware)({ root: TEST_DIR }));
+        const { port } = await app.listen(0, '127.0.0.1');
+        serverUrl = `http://127.0.0.1:${port}`;
+    });
+    (0, vitest_1.afterAll)(async () => {
+        await app.close();
+        // Cleanup
+        if (fs_1.default.existsSync(TEST_FILE))
+            fs_1.default.unlinkSync(TEST_FILE);
+        if (fs_1.default.existsSync(TEST_DIR))
+            fs_1.default.rmdirSync(TEST_DIR);
+    });
+    (0, vitest_1.it)('should serve a static file', async () => {
+        const response = await fetch(`${serverUrl}/test.txt`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(response.headers.get('content-type')).toContain('text/plain');
+        const text = await response.text();
+        (0, vitest_1.expect)(text).toBe(TEST_CONTENT);
+    });
+    (0, vitest_1.it)('should support HEAD requests', async () => {
+        const response = await fetch(`${serverUrl}/test.txt`, { method: 'HEAD' });
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(response.headers.get('content-type')).toContain('text/plain');
+        (0, vitest_1.expect)(response.headers.get('content-length')).toBe(TEST_CONTENT.length.toString());
+        const text = await response.text();
+        (0, vitest_1.expect)(text).toBe('');
+    });
+    (0, vitest_1.it)('should support Range requests (first byte)', async () => {
+        const response = await fetch(`${serverUrl}/test.txt`, {
+            headers: { Range: 'bytes=0-0' }
+        });
+        (0, vitest_1.expect)(response.status).toBe(206);
+        (0, vitest_1.expect)(response.headers.get('content-range')).toBe(`bytes 0-0/${TEST_CONTENT.length}`);
+        (0, vitest_1.expect)(response.headers.get('content-length')).toBe('1');
+        const text = await response.text();
+        (0, vitest_1.expect)(text).toBe('H');
+    });
+    (0, vitest_1.it)('should support Range requests (partial)', async () => {
+        const response = await fetch(`${serverUrl}/test.txt`, {
+            headers: { Range: 'bytes=0-4' }
+        });
+        (0, vitest_1.expect)(response.status).toBe(206);
+        (0, vitest_1.expect)(response.headers.get('content-range')).toBe(`bytes 0-4/${TEST_CONTENT.length}`);
+        (0, vitest_1.expect)(response.headers.get('content-length')).toBe('5');
+        const text = await response.text();
+        (0, vitest_1.expect)(text).toBe('Hello');
+    });
+    (0, vitest_1.it)('should return 416 for invalid Range', async () => {
+        const response = await fetch(`${serverUrl}/test.txt`, {
+            headers: { Range: 'bytes=1000-2000' }
+        });
+        (0, vitest_1.expect)(response.status).toBe(416);
+        (0, vitest_1.expect)(response.headers.get('content-range')).toBe(`bytes */${TEST_CONTENT.length}`);
+    });
+    (0, vitest_1.it)('should support ETag caching (304 Not Modified)', async () => {
+        const response1 = await fetch(`${serverUrl}/test.txt`);
+        const etag = response1.headers.get('etag');
+        (0, vitest_1.expect)(etag).toBeTruthy();
+        const response2 = await fetch(`${serverUrl}/test.txt`, {
+            headers: { 'If-None-Match': etag }
+        });
+        (0, vitest_1.expect)(response2.status).toBe(304);
+        const text = await response2.text();
+        (0, vitest_1.expect)(text).toBe('');
+    });
+    (0, vitest_1.it)('should support Last-Modified caching (304 Not Modified)', async () => {
+        const response1 = await fetch(`${serverUrl}/test.txt`);
+        const lastModified = response1.headers.get('last-modified');
+        (0, vitest_1.expect)(lastModified).toBeTruthy();
+        const response2 = await fetch(`${serverUrl}/test.txt`, {
+            headers: { 'If-Modified-Since': lastModified }
+        });
+        (0, vitest_1.expect)(response2.status).toBe(304);
+    });
+    (0, vitest_1.it)('should return 404 for non-existent file', async () => {
+        const response = await fetch(`${serverUrl}/does-not-exist.txt`);
+        (0, vitest_1.expect)(response.status).toBe(404);
+    });
+});

package/dist/tests/stream.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/stream.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("stream");
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)('Streaming helpers', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app) {
+            await app.close();
+            app = undefined;
+        }
+    });
+    (0, vitest_1.it)('sends a simple SSE event', async () => {
+        app = new src_1.QHTTPX({ requestTimeoutMs: 5000 });
+        app.get('/sse', (ctx) => {
+            const sse = (0, src_1.createSseStream)(ctx);
+            sse.send({ message: 'hello' });
+            sse.close();
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/sse`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(response.headers.get('content-type')).toContain('text/event-stream');
+        const text = await response.text();
+        (0, vitest_1.expect)(text.trim()).toBe('data: {"message":"hello"}');
+    });
+    (0, vitest_1.it)('streams data from a readable', async () => {
+        app = new src_1.QHTTPX();
+        app.get('/stream', async (ctx) => {
+            const readable = stream_1.Readable.from(['hello', ' ', 'world']);
+            await (0, src_1.sendStream)(ctx, readable, {
+                contentType: 'text/plain; charset=utf-8',
+                status: 200,
+            });
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/stream`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(response.headers.get('content-type')).toContain('text/plain');
+        const text = await response.text();
+        (0, vitest_1.expect)(text).toBe('hello world');
+    });
+});

package/dist/tests/task-metrics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/task-metrics.test.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../src/index");
+(0, vitest_1.describe)('Task Metrics', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app) {
+            await app.close();
+            app = undefined;
+        }
+    });
+    (0, vitest_1.it)('exposes task metrics in /__qhttpx/metrics', async () => {
+        app = new index_1.QHTTPX();
+        // Register a simple task
+        app.task('simple-task', async () => {
+            // do nothing
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        // Enqueue the task a few times
+        await app.enqueue('simple-task', {});
+        await app.enqueue('simple-task', {});
+        // Allow some time for async tasks to complete
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        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.tasks).toBeDefined();
+        (0, vitest_1.expect)(json.tasks.registeredTasks).toBe(1);
+        (0, vitest_1.expect)(json.tasks.totalEnqueued).toBe(2);
+        (0, vitest_1.expect)(json.tasks.totalCompleted).toBe(2);
+        (0, vitest_1.expect)(json.tasks.totalFailed).toBe(0);
+        (0, vitest_1.expect)(json.tasks.totalOverloaded).toBe(0);
+    });
+    (0, vitest_1.it)('counts failed tasks', async () => {
+        app = new index_1.QHTTPX();
+        app.task('failing-task', async () => {
+            throw new Error('Task failed');
+        }, { maxRetries: 1 }); // 1 retry
+        const { port } = await app.listen(0, '127.0.0.1');
+        try {
+            await app.enqueue('failing-task', {});
+        }
+        catch {
+        }
+        // Allow time for retry and failure
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        const response = await fetch(`http://127.0.0.1:${port}/__qhttpx/metrics`);
+        const json = (await response.json());
+        (0, vitest_1.expect)(json.tasks.totalFailed).toBe(1);
+        (0, vitest_1.expect)(json.tasks.totalRetried).toBe(1); // 1 retry attempt
+    });
+});

package/dist/tests/tasks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/tasks.test.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../src/index");
+(0, vitest_1.describe)('Task engine', () => {
+    (0, vitest_1.it)('registers and executes a task', async () => {
+        const app = new index_1.QHTTPX();
+        const seen = [];
+        app.task('echo', async (payload) => {
+            seen.push(payload);
+        });
+        await app.enqueue('echo', { hello: 'world' });
+        (0, vitest_1.expect)(seen).toHaveLength(1);
+        (0, vitest_1.expect)(seen[0]).toEqual({ hello: 'world' });
+    });
+    (0, vitest_1.it)('retries failing tasks according to maxRetries', async () => {
+        const app = new index_1.QHTTPX();
+        const spy = vitest_1.vi.fn();
+        let attempts = 0;
+        app.task('sometimes-fails', () => {
+            spy();
+            attempts += 1;
+            if (attempts < 3) {
+                throw new Error('fail');
+            }
+        }, { maxRetries: 5 });
+        await app.enqueue('sometimes-fails', null);
+        (0, vitest_1.expect)(spy).toHaveBeenCalledTimes(3);
+    });
+    (0, vitest_1.it)('propagates errors after exceeding retries', async () => {
+        const app = new index_1.QHTTPX();
+        app.task('always-fails', () => {
+            throw new Error('boom');
+        }, { maxRetries: 1 });
+        await (0, vitest_1.expect)(app.enqueue('always-fails', null)).rejects.toThrow('boom');
+    });
+    (0, vitest_1.it)('integrates with HTTP route that enqueues a job', async () => {
+        const app = new index_1.QHTTPX();
+        const seen = [];
+        app.task('job', async (payload) => {
+            seen.push(payload);
+        });
+        app.post('/enqueue', async (ctx) => {
+            const body = ctx.body;
+            await app.enqueue('job', body.value);
+            ctx.json({ ok: true });
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/enqueue`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({ value: 'hello' }),
+        });
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const json = (await response.json());
+        (0, vitest_1.expect)(json.ok).toBe(true);
+        (0, vitest_1.expect)(seen).toEqual(['hello']);
+        await app.close();
+    });
+});

package/dist/tests/testing.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/testing.test.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)('Testing utilities', () => {
+    (0, vitest_1.it)('creates a test client and handles requests', async () => {
+        const app = new src_1.QHTTPX();
+        app.get('/hello', (ctx) => {
+            ctx.json({ message: 'world' });
+        });
+        app.post('/echo', (ctx) => {
+            ctx.json(ctx.body);
+        });
+        const client = (0, src_1.createTestClient)(app);
+        try {
+            const res1 = await client.get('/hello');
+            (0, vitest_1.expect)(res1.status).toBe(200);
+            (0, vitest_1.expect)(await res1.json()).toEqual({ message: 'world' });
+            const res2 = await client.post('/echo', { foo: 'bar' });
+            (0, vitest_1.expect)(res2.status).toBe(200);
+            (0, vitest_1.expect)(await res2.json()).toEqual({ foo: 'bar' });
+        }
+        finally {
+            await client.stop();
+        }
+    });
+    (0, vitest_1.it)('handles custom headers and raw body', async () => {
+        const app = new src_1.QHTTPX();
+        app.post('/raw', (ctx) => {
+            ctx.send(ctx.req.headers['x-custom']);
+        });
+        const client = (0, src_1.createTestClient)(app);
+        try {
+            const res = await client.post('/raw', 'raw-body', {
+                headers: {
+                    'x-custom': 'custom-value',
+                    'content-type': 'text/plain',
+                },
+            });
+            (0, vitest_1.expect)(res.status).toBe(200);
+            (0, vitest_1.expect)(await res.text()).toBe('custom-value');
+        }
+        finally {
+            await client.stop();
+        }
+    });
+});

package/dist/tests/validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/validation.test.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const server_1 = require("../src/core/server");
+(0, vitest_1.describe)('Validation System', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app)
+            await app.close();
+    });
+    (0, vitest_1.it)('should validate request body and return 400 on failure', async () => {
+        app = new server_1.QHTTPX();
+        const schema = {
+            body: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', min: 3 },
+                    age: { type: 'number', min: 18 }
+                }
+            }
+        };
+        app.post('/user', {
+            schema,
+            handler: (ctx) => {
+                ctx.json({ status: 'ok', body: ctx.body });
+            }
+        });
+        const { port } = await app.listen(0);
+        // Invalid request (age too low)
+        const res1 = await fetch(`http://localhost:${port}/user`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'Alice', age: 10 })
+        });
+        (0, vitest_1.expect)(res1.status).toBe(400);
+        const data1 = await res1.json();
+        (0, vitest_1.expect)(data1.error).toBe('Validation Error');
+        (0, vitest_1.expect)(data1.details).toContain('age');
+        // Valid request
+        const res2 = await fetch(`http://localhost:${port}/user`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'Alice', age: 20 })
+        });
+        (0, vitest_1.expect)(res2.status).toBe(200);
+        const data2 = await res2.json();
+        (0, vitest_1.expect)(data2.body).toEqual({ name: 'Alice', age: 20 });
+    });
+    (0, vitest_1.it)('should validate and coerce query parameters', async () => {
+        app = new server_1.QHTTPX();
+        const schema = {
+            query: {
+                type: 'object',
+                properties: {
+                    page: { type: 'number', min: 1 },
+                    sort: { type: 'string', enum: ['asc', 'desc'] }
+                }
+            }
+        };
+        app.get('/items', {
+            schema,
+            handler: (ctx) => {
+                // ctx.query should have numbers now
+                ctx.json({
+                    page: ctx.query.page,
+                    pageType: typeof ctx.query.page,
+                    sort: ctx.query.sort
+                });
+            }
+        });
+        const { port } = await app.listen(0);
+        // Valid query
+        const res1 = await fetch(`http://localhost:${port}/items?page=5&sort=desc`);
+        (0, vitest_1.expect)(res1.status).toBe(200);
+        const data1 = await res1.json();
+        (0, vitest_1.expect)(data1.page).toBe(5);
+        (0, vitest_1.expect)(data1.pageType).toBe('number'); // Coercion worked
+        (0, vitest_1.expect)(data1.sort).toBe('desc');
+        // Invalid query
+        const res2 = await fetch(`http://localhost:${port}/items?page=0&sort=foo`);
+        (0, vitest_1.expect)(res2.status).toBe(400);
+    });
+    (0, vitest_1.it)('should support legacy response schema (no validation)', async () => {
+        app = new server_1.QHTTPX();
+        // Legacy schema: just a JSON schema at root
+        const schema = {
+            type: 'object',
+            properties: {
+                hello: { type: 'string' }
+            }
+        };
+        app.get('/legacy', {
+            schema,
+            handler: (ctx) => {
+                // If validation ran, it might fail because ctx.body is undefined or not matching
+                // But here we check if it IGNORES validation and uses it for serialization
+                ctx.json({ hello: 'world', extra: 'hidden' });
+            }
+        });
+        const { port } = await app.listen(0);
+        const res = await fetch(`http://localhost:${port}/legacy`);
+        (0, vitest_1.expect)(res.status).toBe(200);
+        const data = await res.json();
+        (0, vitest_1.expect)(data.hello).toBe('world');
+        (0, vitest_1.expect)(data.extra).toBeUndefined(); // fast-json-stringify filters extra fields
+    });
+});

package/dist/tests/websocket.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/websocket.test.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const net = __importStar(require("net"));
+const ws_1 = __importDefault(require("ws"));
+const src_1 = require("../src");
+(0, vitest_1.describe)('WebSocket upgrade', () => {
+    (0, vitest_1.it)('handles websocket upgrade for registered path', async () => {
+        const app = new src_1.QHTTPX();
+        let upgraded = false;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        app.upgrade('/ws', (ws, req) => {
+            upgraded = true;
+            ws.close();
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const ws = new ws_1.default(`ws://127.0.0.1:${port}/ws`);
+        await new Promise((resolve, reject) => {
+            ws.on('open', () => {
+                resolve();
+            });
+            ws.on('error', (err) => {
+                reject(err);
+            });
+        });
+        (0, vitest_1.expect)(upgraded).toBe(true);
+        ws.close();
+        await app.close();
+    });
+    (0, vitest_1.it)('destroys socket when no upgrade handler is registered for path', async () => {
+        const app = new src_1.QHTTPX();
+        const { port } = await app.listen(0, '127.0.0.1');
+        const socket = net.createConnection({ port, host: '127.0.0.1' });
+        const done = new Promise((resolve) => {
+            let finished = false;
+            const finish = () => {
+                if (!finished) {
+                    finished = true;
+                    resolve();
+                }
+            };
+            socket.on('end', finish);
+            socket.on('close', finish);
+            socket.on('error', () => {
+                finish();
+            });
+            setTimeout(finish, 500);
+        });
+        const requestLines = [
+            'GET /no-ws HTTP/1.1',
+            'Host: 127.0.0.1',
+            'Upgrade: websocket',
+            'Connection: Upgrade',
+            '',
+            '',
+        ];
+        socket.write(requestLines.join('\r\n'));
+        await done;
+        await app.close();
+    });
+    (0, vitest_1.it)('supports rooms and broadcasting', async () => {
+        const app = new src_1.QHTTPX();
+        app.upgrade('/chat', (ws, req) => {
+            const url = new URL(req.url || '', 'http://localhost');
+            const room = url.searchParams.get('room');
+            if (room) {
+                ws.join(room);
+            }
+        });
+        app.post('/broadcast', (ctx) => {
+            const { room, message } = ctx.body;
+            app.websocket.to(room).emit(message);
+            ctx.json({ success: true });
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const baseUrl = `ws://127.0.0.1:${port}/chat`;
+        // Client A in room1
+        const wsA = new ws_1.default(`${baseUrl}?room=room1`);
+        const msgsA = [];
+        wsA.on('message', (data) => msgsA.push(data.toString()));
+        // Client B in room1
+        const wsB = new ws_1.default(`${baseUrl}?room=room1`);
+        const msgsB = [];
+        wsB.on('message', (data) => msgsB.push(data.toString()));
+        // Client C in room2
+        const wsC = new ws_1.default(`${baseUrl}?room=room2`);
+        const msgsC = [];
+        wsC.on('message', (data) => msgsC.push(data.toString()));
+        await Promise.all([
+            new Promise((resolve) => wsA.on('open', () => resolve())),
+            new Promise((resolve) => wsB.on('open', () => resolve())),
+            new Promise((resolve) => wsC.on('open', () => resolve())),
+        ]);
+        // Broadcast to room1
+        // We need to make a POST request.
+        // Since we are inside test, we can use fetch or http.request.
+        // Or just use app.websocket directly if we can access it?
+        // We can access app.websocket directly here since we have app instance.
+        app.websocket.to('room1').emit('hello room1');
+        // Wait a bit for messages
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        (0, vitest_1.expect)(msgsA).toContain('hello room1');
+        (0, vitest_1.expect)(msgsB).toContain('hello room1');
+        (0, vitest_1.expect)(msgsC).not.toContain('hello room1');
+        wsA.close();
+        wsB.close();
+        wsC.close();
+        await app.close();
+    });
+});

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("vitest/config");
+exports.default = (0, config_1.defineConfig)({
+    test: {
+        include: ['tests/**/*.test.ts'],
+        exclude: ['dist/**', 'node_modules/**'],
+    },
+});

package/docs/FUSION.md

@@ -66,3 +66,22 @@ For even higher performance, Fusion includes a "Micro-TTL" mechanism. Even after
 
 - **Idempotency**: Fusion is safest for `GET` requests. QHTTPX automatically disables Fusion for `POST`, `PUT`, `DELETE`, and `PATCH` by default to prevent side-effect duplication issues, though this can be overridden if you know what you are doing.
 - **Personalized Content**: Be careful with endpoints that return user-specific data (like "My Profile"). If the response depends on the `Authorization` header, ensure that header is part of the Fusion Key (or disable Fusion for that route).
+
+## Observability
+
+You can verify Request Fusion effectiveness using the built-in metrics endpoint.
+
+GET `/__qhttpx/metrics`
+
+Response:
+```json
+{
+  "totalRequests": 10000,
+  "fusion": {
+    "totalFused": 9999,      // Requests served by Leader/Cache
+    "totalProcessed": 1      // Actual handler executions
+  }
+}
+```
+
+This confirms that out of 10,000 requests, only 1 actually hit your database/handler!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qhttpx",
-  "version": "1.9.2",
+  "version": "1.9.3",
   "gypfile": false,
   "description": "The Ultra-Fast HTTP Framework for Node.js",
   "main": "dist/src/index.js",
@@ -31,6 +31,7 @@
   },
   "scripts": {
     "prebuild": "node -e \"try{require('child_process').execSync('prebuildify --napi --strip', {stdio: 'ignore'})}catch(e){}\"",
+    "prepublishOnly": "npm run build",
     "build": "tsc -p tsconfig.json",
     "lint": "eslint src tests --ext .ts",
     "test": "vitest run",