qhttpx 1.8.0

package/dist/tests/rate-limit.test.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const server_1 = require("../src/core/server");
+const rate_limit_1 = require("../src/middleware/rate-limit");
+(0, vitest_1.describe)('Aegis Rate Limiter', () => {
+    let app;
+    let port;
+    (0, vitest_1.beforeEach)(async () => {
+        app = new server_1.QHTTPX();
+    });
+    (0, vitest_1.afterEach)(() => {
+        // Cleanup if needed
+    });
+    (0, vitest_1.it)('should block requests exceeding the limit', async () => {
+        app.use((0, rate_limit_1.rateLimit)({
+            windowMs: 1000,
+            max: 2, // Allow 2 requests
+            message: { error: 'Blocked' }
+        }));
+        app.get('/', (ctx) => ctx.json({ ok: true }));
+        const { port: p } = await app.listen(0);
+        port = p;
+        const url = `http://localhost:${port}`;
+        // 1st request (OK)
+        const r1 = await fetch(url);
+        (0, vitest_1.expect)(r1.status).toBe(200);
+        (0, vitest_1.expect)(r1.headers.get('x-ratelimit-remaining')).toBe('1');
+        // 2nd request (OK)
+        const r2 = await fetch(url);
+        (0, vitest_1.expect)(r2.status).toBe(200);
+        (0, vitest_1.expect)(r2.headers.get('x-ratelimit-remaining')).toBe('0');
+        // 3rd request (Blocked)
+        const r3 = await fetch(url);
+        (0, vitest_1.expect)(r3.status).toBe(429);
+        (0, vitest_1.expect)(await r3.json()).toEqual({ error: 'Blocked' });
+        (0, vitest_1.expect)(r3.headers.get('retry-after')).toBeDefined();
+    });
+    (0, vitest_1.it)('should reset after window expires', async () => {
+        app.use((0, rate_limit_1.rateLimit)({
+            windowMs: 100, // Short window
+            max: 1
+        }));
+        app.get('/', (ctx) => ctx.json({ ok: true }));
+        const { port: p } = await app.listen(0);
+        const url = `http://localhost:${p}`;
+        // 1st (OK)
+        await fetch(url);
+        // 2nd (Blocked)
+        const r2 = await fetch(url);
+        (0, vitest_1.expect)(r2.status).toBe(429);
+        // Wait for window
+        await new Promise(r => setTimeout(r, 150));
+        // 3rd (OK)
+        const r3 = await fetch(url);
+        (0, vitest_1.expect)(r3.status).toBe(200);
+    });
+    (0, vitest_1.it)('should support custom key generators (e.g. per API key)', async () => {
+        app.use((0, rate_limit_1.rateLimit)({
+            windowMs: 1000,
+            max: 1,
+            keyGenerator: (ctx) => ctx.req.headers['x-api-key'] || 'anon'
+        }));
+        app.get('/', (ctx) => ctx.json({ ok: true }));
+        const { port: p } = await app.listen(0);
+        const url = `http://localhost:${p}`;
+        // User A (OK)
+        const r1 = await fetch(url, { headers: { 'x-api-key': 'userA' } });
+        (0, vitest_1.expect)(r1.status).toBe(200);
+        // User B (OK - different key)
+        const r2 = await fetch(url, { headers: { 'x-api-key': 'userB' } });
+        (0, vitest_1.expect)(r2.status).toBe(200);
+        // User A Again (Blocked)
+        const r3 = await fetch(url, { headers: { 'x-api-key': 'userA' } });
+        (0, vitest_1.expect)(r3.status).toBe(429);
+    });
+});

package/dist/tests/resources.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const resources_1 = require("../src/core/resources");
+const index_1 = require("../src/index");
+(0, vitest_1.describe)('Resource helpers', () => {
+    (0, vitest_1.it)('calculates worker count for fixed numbers', () => {
+        (0, vitest_1.expect)((0, resources_1.calculateWorkerCount)(1)).toBe(1);
+        (0, vitest_1.expect)((0, resources_1.calculateWorkerCount)(4)).toBe(4);
+        (0, vitest_1.expect)((0, resources_1.calculateWorkerCount)(0)).toBe(1);
+        (0, vitest_1.expect)((0, resources_1.calculateWorkerCount)(-5)).toBe(1);
+    });
+    (0, vitest_1.it)('detects memory overload based on thresholds', () => {
+        (0, vitest_1.expect)((0, resources_1.isResourceOverloaded)({ rssBytes: 2000 }, {
+            maxRssBytes: 1000,
+        })).toBe(true);
+        (0, vitest_1.expect)((0, resources_1.isResourceOverloaded)({ rssBytes: 500 }, {
+            maxRssBytes: 1000,
+        })).toBe(false);
+    });
+});
+(0, vitest_1.describe)('QHTTPX resource-aware behavior', () => {
+    (0, vitest_1.it)('returns 503 when memory usage exceeds maxMemoryBytes', async () => {
+        const originalMemoryUsage = process.memoryUsage;
+        const fakeMemoryUsage = vitest_1.vi.fn(() => ({
+            ...originalMemoryUsage(),
+            rss: 10000000000,
+        }));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        process.memoryUsage = fakeMemoryUsage;
+        const app = new index_1.QHTTPX({
+            maxMemoryBytes: 1000000,
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        app.get('/', (ctx) => {
+            ctx.send('ok');
+        });
+        const response = await fetch(`http://127.0.0.1:${port}/`);
+        (0, vitest_1.expect)(response.status).toBe(503);
+        await app.close();
+        process.memoryUsage =
+            originalMemoryUsage;
+    });
+});

package/dist/tests/scheduler.test.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const scheduler_1 = require("../src/core/scheduler");
+(0, vitest_1.describe)('Scheduler', () => {
+    (0, vitest_1.it)('runs tasks within concurrency limit', async () => {
+        const scheduler = new scheduler_1.Scheduler({ maxConcurrency: 4 });
+        const order = [];
+        await Promise.all([
+            scheduler.run(async () => {
+                order.push(1);
+            }, {}),
+            scheduler.run(async () => {
+                order.push(2);
+            }, {}),
+        ]);
+        (0, vitest_1.expect)(order.sort()).toEqual([1, 2]);
+        (0, vitest_1.expect)(scheduler.getCurrentInFlight()).toBe(0);
+    });
+    (0, vitest_1.it)('calls onOverloaded when limit is reached', async () => {
+        const scheduler = new scheduler_1.Scheduler({ maxConcurrency: 1 });
+        const overloaded = vitest_1.vi.fn();
+        let resolveFirst;
+        const firstTask = scheduler.run(() => new Promise((resolve) => {
+            resolveFirst = resolve;
+        }), {});
+        await scheduler.run(async () => { }, { onOverloaded: overloaded });
+        (0, vitest_1.expect)(overloaded).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(scheduler.getCurrentInFlight()).toBe(1);
+        resolveFirst?.();
+        await firstTask;
+        (0, vitest_1.expect)(scheduler.getCurrentInFlight()).toBe(0);
+    });
+    (0, vitest_1.it)('invokes timeout callback when task exceeds timeout', async () => {
+        const scheduler = new scheduler_1.Scheduler({ maxConcurrency: 1 });
+        const onTimeout = vitest_1.vi.fn();
+        await scheduler.run(() => new Promise((resolve) => {
+            setTimeout(resolve, 50);
+        }), {
+            timeoutMs: 10,
+            onTimeout,
+        });
+        (0, vitest_1.expect)(onTimeout).toHaveBeenCalledTimes(1);
+        (0, vitest_1.expect)(scheduler.getCurrentInFlight()).toBe(0);
+    });
+});

package/dist/tests/schema-routes.test.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../src/index");
+(0, vitest_1.describe)('Schema-based Routes', () => {
+    let app;
+    let port;
+    (0, vitest_1.beforeAll)(async () => {
+        app = new index_1.QHTTPX({
+            performanceMode: 'ultra'
+        });
+        const UserSchema = {
+            type: 'object',
+            properties: {
+                id: { type: 'integer' },
+                name: { type: 'string' },
+                email: { type: 'string' }
+            },
+            required: ['id', 'name']
+        };
+        app.get('/user', {
+            schema: UserSchema,
+            handler(ctx) {
+                ctx.json({
+                    id: 1,
+                    name: 'John Doe',
+                    email: 'john@example.com',
+                    extra: 'should be ignored'
+                });
+            }
+        });
+        app.get('/no-schema', (ctx) => {
+            ctx.json({ foo: 'bar', run: ctx.state.middlewareRun });
+        });
+        app.use(async (ctx, next) => {
+            ctx.state.middlewareRun = true;
+            await next();
+        });
+        app.get('/middleware-check', (ctx) => {
+            ctx.json({ run: ctx.state.middlewareRun });
+        });
+        const result = await app.listen(0);
+        port = result.port;
+    });
+    (0, vitest_1.afterAll)(async () => {
+        await app.close();
+    });
+    (0, vitest_1.it)('should serialize using the provided schema', async () => {
+        const response = await fetch(`http://localhost:${port}/user`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const body = await response.json();
+        (0, vitest_1.expect)(body).toEqual({
+            id: 1,
+            name: 'John Doe',
+            email: 'john@example.com'
+        });
+        // 'extra' should be missing
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (0, vitest_1.expect)(body.extra).toBeUndefined();
+    });
+    (0, vitest_1.it)('should work without schema', async () => {
+        const response = await fetch(`http://localhost:${port}/no-schema`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const body = await response.json();
+        (0, vitest_1.expect)(body).toEqual({ foo: 'bar' });
+        // Middleware was added AFTER this route, so it should NOT run
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (0, vitest_1.expect)(body.run).toBeUndefined();
+    });
+    (0, vitest_1.it)('should run middlewares', async () => {
+        const response = await fetch(`http://localhost:${port}/middleware-check`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        const body = await response.json();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (0, vitest_1.expect)(body.run).toBe(true);
+    });
+});

package/dist/tests/security.test.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)('Security and rate limiting middleware', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app) {
+            await app.close();
+            app = undefined;
+        }
+    });
+    (0, vitest_1.it)('applies default security headers', async () => {
+        app = new src_1.QHTTPX();
+        app.use((0, src_1.createSecurityHeadersMiddleware)());
+        app.get('/ping', (ctx) => {
+            ctx.send('pong');
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/ping`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(await response.text()).toBe('pong');
+        (0, vitest_1.expect)(response.headers.get('content-security-policy')).toBe("default-src 'self'");
+        (0, vitest_1.expect)(response.headers.get('referrer-policy')).toBe('no-referrer');
+        (0, vitest_1.expect)(response.headers.get('x-frame-options')).toBe('SAMEORIGIN');
+        (0, vitest_1.expect)(response.headers.get('x-content-type-options')).toBe('nosniff');
+        (0, vitest_1.expect)(response.headers.get('x-xss-protection')).toBe('1; mode=block');
+    });
+    (0, vitest_1.it)('allows overriding and disabling specific headers', async () => {
+        app = new src_1.QHTTPX();
+        app.use((0, src_1.createSecurityHeadersMiddleware)({
+            contentSecurityPolicy: "default-src 'self' https://cdn.example.com",
+            referrerPolicy: 'strict-origin-when-cross-origin',
+            xFrameOptions: null,
+            strictTransportSecurity: 'max-age=31536000; includeSubDomains',
+        }));
+        app.get('/ping', (ctx) => {
+            ctx.send('pong');
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/ping`);
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(response.headers.get('content-security-policy')).toBe("default-src 'self' https://cdn.example.com");
+        (0, vitest_1.expect)(response.headers.get('referrer-policy')).toBe('strict-origin-when-cross-origin');
+        (0, vitest_1.expect)(response.headers.get('x-frame-options')).toBeNull();
+        (0, vitest_1.expect)(response.headers.get('strict-transport-security')).toBe('max-age=31536000; includeSubDomains');
+    });
+    (0, vitest_1.it)('provides secure defaults preset combining CORS and headers', async () => {
+        app = new src_1.QHTTPX();
+        const middlewares = (0, src_1.createSecureDefaults)();
+        for (const mw of middlewares) {
+            app.use(mw);
+        }
+        app.get('/ping', (ctx) => {
+            ctx.send('pong');
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/ping`, {
+            method: 'GET',
+            headers: {
+                origin: 'http://example.com',
+            },
+        });
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(response.headers.get('access-control-allow-origin')).toBe('*');
+        (0, vitest_1.expect)(response.headers.get('content-security-policy')).toBe("default-src 'self'");
+    });
+    (0, vitest_1.it)('applies in-memory rate limiting per remote address', async () => {
+        app = new src_1.QHTTPX();
+        app.use((0, src_1.createRateLimitMiddleware)({
+            maxRequests: 1,
+            windowMs: 1000,
+        }));
+        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 second = await fetch(`http://127.0.0.1:${port}/ping`);
+        (0, vitest_1.expect)(first.status).toBe(200);
+        (0, vitest_1.expect)(second.status).toBe(429);
+    });
+});

package/dist/tests/server-db.test.js

@@ -0,0 +1,72 @@
+"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 server_1 = require("../src/core/server");
+const manager_1 = require("../src/database/manager");
+const memory_1 = require("../src/database/adapters/memory");
+const http_1 = __importDefault(require("http"));
+(0, vitest_1.describe)('Server Database Integration', () => {
+    let app;
+    let dbManager;
+    (0, vitest_1.beforeEach)(async () => {
+        manager_1.DatabaseManager.registerAdapter('memory', memory_1.MemoryAdapter);
+        dbManager = new manager_1.DatabaseManager({
+            default: 'main',
+            connections: {
+                main: {
+                    type: 'memory',
+                    database: 'test_db'
+                }
+            }
+        });
+        await dbManager.connect();
+        app = new server_1.QHTTPX({
+            database: dbManager
+        });
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await app.close();
+        await dbManager.disconnect();
+    });
+    (0, vitest_1.it)('should expose database manager in context', async () => {
+        return new Promise(async (resolve, reject) => {
+            app.get('/db-test', (ctx) => {
+                try {
+                    (0, vitest_1.expect)(ctx.db).toBeDefined();
+                    (0, vitest_1.expect)(ctx.db).toBe(dbManager);
+                    (0, vitest_1.expect)(ctx.db?.get('main').isConnected()).toBe(true);
+                    ctx.json({ status: 'ok' });
+                }
+                catch (error) {
+                    // If expect fails, we need to make sure the test fails
+                    // But throwing here might be caught by the server error handler
+                    // So we set a flag or just let it fail naturally if vitest handles async exceptions
+                    // For now, let's reject the promise
+                    reject(error);
+                }
+            });
+            try {
+                const { port } = await app.listen(0);
+                const req = http_1.default.get(`http://localhost:${port}/db-test`, (res) => {
+                    if (res.statusCode !== 200) {
+                        reject(new Error(`Status code: ${res.statusCode}`));
+                        return;
+                    }
+                    res.on('data', () => { });
+                    res.on('end', () => {
+                        resolve();
+                    });
+                });
+                req.on('error', (err) => {
+                    reject(err);
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    });
+});

package/dist/tests/smoke.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../src/index");
+(0, vitest_1.describe)('qhttpx smoke', () => {
+    (0, vitest_1.it)('constructs a QHTTPX instance', () => {
+        const app = new index_1.QHTTPX();
+        (0, vitest_1.expect)(app).toBeInstanceOf(index_1.QHTTPX);
+    });
+});

package/dist/tests/sqlite-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");
+const manager_1 = require("../src/database/manager");
+const sqlite_1 = require("../src/database/adapters/sqlite");
+(0, vitest_1.describe)('SQLite Query Fusion', () => {
+    let app;
+    let dbManager;
+    (0, vitest_1.beforeEach)(async () => {
+        // Register SQLite adapter
+        manager_1.DatabaseManager.registerAdapter('sqlite', sqlite_1.SQLiteAdapter);
+        // Use in-memory SQLite DB
+        dbManager = new manager_1.DatabaseManager({
+            default: 'main',
+            connections: {
+                main: { type: 'sqlite', database: ':memory:' }
+            }
+        });
+        await dbManager.connect();
+        // Setup schema and data
+        const adapter = dbManager.get('main');
+        await adapter.query('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)');
+        await adapter.query("INSERT INTO users (id, name) VALUES (1, 'Alice')");
+        await adapter.query("INSERT INTO users (id, name) VALUES (2, 'Bob')");
+        await adapter.query("INSERT INTO users (id, name) VALUES (3, 'Charlie')");
+        app = new server_1.QHTTPX({
+            database: dbManager,
+            enableBatching: true
+        });
+    });
+    (0, vitest_1.afterEach)(async () => {
+        if (app)
+            await app.close();
+        if (dbManager)
+            await dbManager.disconnect();
+    });
+    (0, vitest_1.it)('should fuse SELECT queries with SQLite', async () => {
+        // Wrap the adapter to spy on queries
+        const realAdapter = dbManager.get('main');
+        const originalQuery = realAdapter.query.bind(realAdapter);
+        const queries = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        realAdapter.query = async (sql, params) => {
+            queries.push(sql);
+            return originalQuery(sql, params);
+        };
+        app.op('getUser', async (params, ctx) => {
+            // This matches the coalescer pattern: "SELECT ... WHERE id = ?"
+            if (!ctx.db)
+                throw new Error('No DB');
+            const rows = await ctx.db.get().query('SELECT * FROM users WHERE id = ?', [params.id]);
+            return rows[0];
+        });
+        const { port } = await app.listen(0);
+        const batch = {
+            batch: [
+                { op: 'getUser', params: { id: 1 }, id: 1 },
+                { op: 'getUser', params: { id: 2 }, id: 2 },
+                { op: 'getUser', params: { id: 3 }, id: 3 }
+            ]
+        };
+        const response = await fetch(`http://localhost:${port}/qhttpx`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(batch)
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const data = await response.json();
+        // Verify results
+        (0, vitest_1.expect)(data.results).toHaveLength(3);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const r1 = data.results.find((r) => r.id === 1);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const r2 = data.results.find((r) => r.id === 2);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const r3 = data.results.find((r) => r.id === 3);
+        (0, vitest_1.expect)(r1.result).toEqual({ id: 1, name: 'Alice' });
+        (0, vitest_1.expect)(r2.result).toEqual({ id: 2, name: 'Bob' });
+        (0, vitest_1.expect)(r3.result).toEqual({ id: 3, name: 'Charlie' });
+        // Verify FUSION
+        const selectQueries = queries.filter(q => q.trim().toUpperCase().startsWith('SELECT'));
+        // It should contain an IN clause
+        const fusedQuery = selectQueries.find(q => q.includes('IN ('));
+        (0, vitest_1.expect)(fusedQuery).toBeDefined();
+        // Ensure we didn't run 3 individual queries
+        // The spy catches the FUSED query, but NOT the individual ones if they were fused.
+        // If fusion FAILED, we would see 3 queries with "= ?"
+        const individualQueries = selectQueries.filter(q => q.includes('= ?'));
+        (0, vitest_1.expect)(individualQueries).toHaveLength(0);
+    });
+});

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.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');
+    });
+});