qhttpx 1.8.0

package/dist/tests/batch.test.js

@@ -0,0 +1,117 @@
+"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 memory_1 = require("../src/database/adapters/memory");
+(0, vitest_1.describe)('Batch Engine & Query Fusion', () => {
+    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,
+            enableBatching: true
+        });
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await app.close();
+        await dbManager.disconnect();
+    });
+    (0, vitest_1.it)('should execute multiple operations in a single batch request', async () => {
+        // Define ops
+        app.op('math.add', async (params) => {
+            return params.a + params.b;
+        });
+        app.op('math.multiply', async (params) => {
+            return params.a * params.b;
+        });
+        const { port } = await app.listen(0);
+        const batch = {
+            batch: [
+                { op: 'math.add', params: { a: 5, b: 3 }, id: 1 },
+                { op: 'math.multiply', params: { a: 4, b: 2 }, id: 2 }
+            ]
+        };
+        const response = await fetch(`http://localhost:${port}/qhttpx`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(batch)
+        });
+        const data = await response.json();
+        (0, vitest_1.expect)(data.results).toHaveLength(2);
+        (0, vitest_1.expect)(data.results[0]).toEqual({ result: 8, id: 1 });
+        (0, vitest_1.expect)(data.results[1]).toEqual({ result: 8, id: 2 });
+    });
+    (0, vitest_1.it)('should fuse database queries', async () => {
+        // Setup spy on the adapter's query method to verify fusion
+        const adapter = dbManager.get('main');
+        const querySpy = vitest_1.vi.spyOn(adapter, 'query');
+        // Define an op that uses DB
+        app.op('getUser', async (params, ctx) => {
+            // Simulate simple query that matches our coalescer pattern
+            // "SELECT * FROM users WHERE id = ?"
+            if (!ctx.db)
+                throw new Error('No DB');
+            const result = await ctx.db.get().query('SELECT * FROM users WHERE id = ?', [params.id]);
+            return result;
+        });
+        const { port } = await app.listen(0);
+        // Prepare batch with 3 requests
+        const batch = {
+            batch: [
+                { op: 'getUser', params: { id: 1 }, id: 'req1' },
+                { op: 'getUser', params: { id: 2 }, id: 'req2' },
+                { op: 'getUser', params: { id: 3 }, id: 'req3' }
+            ]
+        };
+        // Mock DB response for the FUSED query
+        // The coalescer will generate: "SELECT * FROM users WHERE id IN (?, ?, ?)"
+        // We need to mock the implementation to return data that the coalescer can map back.
+        // The memory adapter handles basic queries, but does it handle "IN"?
+        // The current MemoryAdapter likely DOES NOT support SQL parsing.
+        // So we need to mock the query method to return expected data for the fused query.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        querySpy.mockImplementation(async (query) => {
+            if (typeof query === 'string' && query.includes('IN')) {
+                // This is the fused query
+                // Return dummy users
+                return [
+                    { id: 1, name: 'User 1' },
+                    { id: 2, name: 'User 2' },
+                    { id: 3, name: 'User 3' }
+                ];
+            }
+            return [];
+        });
+        const response = await fetch(`http://localhost:${port}/qhttpx`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(batch)
+        });
+        const data = await response.json();
+        // Verification
+        // 1. Check results
+        (0, vitest_1.expect)(data.results).toHaveLength(3);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (0, vitest_1.expect)(data.results.find((r) => r.id === 'req1').result).toEqual([{ id: 1, name: 'User 1' }]);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (0, vitest_1.expect)(data.results.find((r) => r.id === 'req2').result).toEqual([{ id: 2, name: 'User 2' }]);
+        // 2. Check that query was called ONCE with fused SQL
+        // The spy calls should show 1 call with "IN" and maybe others if coalescer failed?
+        // Wait, the coalescer calls the ADAPTER.
+        // Filter calls that look like the fused one
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const fusedCalls = querySpy.mock.calls.filter((args) => args[0].includes('IN'));
+        (0, vitest_1.expect)(fusedCalls.length).toBe(1);
+        const individualCalls = querySpy.mock.calls.filter(args => args[0].includes('= ?'));
+        (0, vitest_1.expect)(individualCalls.length).toBe(0); // Should be 0 if fusion worked
+    });
+});

package/dist/tests/body-parser.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const http_1 = require("http");
+const net_1 = require("net");
+const body_parser_1 = require("../src/core/body-parser");
+// Mock IncomingMessage
+class MockRequest extends http_1.IncomingMessage {
+    constructor(method, headers, body) {
+        super(new net_1.Socket());
+        this.method = method;
+        this.headers = headers;
+        if (body) {
+            this.push(body);
+            this.push(null);
+        }
+        else {
+            this.push(null);
+        }
+    }
+}
+(0, vitest_1.describe)('BodyParser', () => {
+    (0, vitest_1.it)('parses JSON body', async () => {
+        const req = new MockRequest('POST', { 'content-type': 'application/json' }, JSON.stringify({ foo: 'bar' }));
+        const parsed = await body_parser_1.BodyParser.parse(req);
+        (0, vitest_1.expect)(parsed.body).toEqual({ foo: 'bar' });
+    });
+    (0, vitest_1.it)('parses urlencoded body', async () => {
+        const req = new MockRequest('POST', { 'content-type': 'application/x-www-form-urlencoded' }, 'foo=bar&baz=123');
+        const parsed = await body_parser_1.BodyParser.parse(req);
+        (0, vitest_1.expect)(parsed.body).toEqual({ foo: 'bar', baz: '123' });
+    });
+    (0, vitest_1.it)('returns buffer for unknown content type', async () => {
+        const req = new MockRequest('POST', { 'content-type': 'application/octet-stream' }, 'hello world');
+        const parsed = await body_parser_1.BodyParser.parse(req);
+        (0, vitest_1.expect)(parsed.body).toBeInstanceOf(Buffer);
+        (0, vitest_1.expect)(parsed.body.toString()).toBe('hello world');
+    });
+    (0, vitest_1.it)('throws error when body too large', async () => {
+        const req = new MockRequest('POST', { 'content-type': 'text/plain' }, '1234567890');
+        await (0, vitest_1.expect)(body_parser_1.BodyParser.parse(req, { maxBodyBytes: 5 })).rejects.toThrow('QHTTPX_BODY_TOO_LARGE');
+    });
+    (0, vitest_1.it)('throws error for invalid JSON', async () => {
+        const req = new MockRequest('POST', { 'content-type': 'application/json' }, '{ invalid json');
+        await (0, vitest_1.expect)(body_parser_1.BodyParser.parse(req)).rejects.toThrow('QHTTPX_INVALID_JSON');
+    });
+    (0, vitest_1.it)('ignores GET requests', async () => {
+        const req = new MockRequest('GET', {});
+        const parsed = await body_parser_1.BodyParser.parse(req);
+        (0, vitest_1.expect)(parsed.body).toBeUndefined();
+    });
+});

package/dist/tests/compression-sse.test.js

@@ -0,0 +1,87 @@
+"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 src_1 = require("../src");
+const zlib_1 = __importDefault(require("zlib"));
+const http_1 = __importDefault(require("http"));
+(0, vitest_1.describe)('Compression Middleware', () => {
+    (0, vitest_1.it)('should compress JSON response with gzip', async () => {
+        const app = new src_1.QHTTPX();
+        app.use((0, src_1.createCompressionMiddleware)());
+        const bigData = { data: 'a'.repeat(10000) };
+        app.get('/gzip', (ctx) => ctx.json(bigData));
+        const { port } = await app.listen(0, '127.0.0.1');
+        // Use http.request to avoid automatic decompression by fetch
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const response = await new Promise((resolve, reject) => {
+            const req = http_1.default.request(`http://127.0.0.1:${port}/gzip`, {
+                headers: { 'Accept-Encoding': 'gzip' }
+            }, (res) => {
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(chunk));
+                res.on('end', () => resolve({ headers: res.headers, data: Buffer.concat(chunks) }));
+                res.on('error', reject);
+            });
+            req.end();
+        });
+        (0, vitest_1.expect)(response.headers['content-encoding']).toBe('gzip');
+        (0, vitest_1.expect)(response.headers['vary']).toContain('Accept-Encoding');
+        const decompressed = zlib_1.default.gunzipSync(response.data);
+        const json = JSON.parse(decompressed.toString());
+        (0, vitest_1.expect)(json).toEqual(bigData);
+        await app.close();
+    });
+    (0, vitest_1.it)('should not compress small response if threshold is high', async () => {
+        const app = new src_1.QHTTPX();
+        app.use((0, src_1.createCompressionMiddleware)({ threshold: 1000 }));
+        app.get('/small', (ctx) => {
+            ctx.json({ data: 'small' });
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await fetch(`http://127.0.0.1:${port}/small`, {
+            headers: { 'Accept-Encoding': 'gzip' },
+        });
+        (0, vitest_1.expect)(response.status).toBe(200);
+        // Should NOT have content-encoding because it's too small
+        (0, vitest_1.expect)(response.headers.get('content-encoding')).toBeNull();
+        await app.close();
+    });
+});
+(0, vitest_1.describe)('Server-Sent Events (SSE)', () => {
+    (0, vitest_1.it)('should stream events', async () => {
+        const app = new src_1.QHTTPX();
+        // app.use(createCompressionMiddleware()); // Disable compression for SSE test to debug
+        app.get('/sse', (ctx) => {
+            const stream = (0, src_1.createSSE)(ctx);
+            let count = 0;
+            const interval = setInterval(() => {
+                count++;
+                stream.send({ count }, 'ping');
+                if (count >= 3) {
+                    clearInterval(interval);
+                    stream.close();
+                }
+            }, 50);
+        });
+        const { port } = await app.listen(0, '127.0.0.1');
+        const response = await new Promise((resolve, reject) => {
+            const req = http_1.default.request(`http://127.0.0.1:${port}/sse`, (res) => {
+                let data = '';
+                res.on('data', (chunk) => {
+                    data += chunk.toString();
+                });
+                res.on('end', () => resolve(data));
+                res.on('error', reject);
+            });
+            req.end();
+        });
+        (0, vitest_1.expect)(response).toContain('event: ping');
+        (0, vitest_1.expect)(response).toContain('data: {"count":1}');
+        (0, vitest_1.expect)(response).toContain('data: {"count":2}');
+        (0, vitest_1.expect)(response).toContain('data: {"count":3}');
+        await app.close();
+    });
+});

package/dist/tests/cookies.test.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const cookies_1 = require("../src/utils/cookies");
+(0, vitest_1.describe)('Cookie Parsing', () => {
+    (0, vitest_1.it)('should parse simple cookies', () => {
+        const header = 'foo=bar; baz=qux';
+        const result = (0, cookies_1.parseCookies)(header);
+        (0, vitest_1.expect)(result).toEqual({ foo: 'bar', baz: 'qux' });
+    });
+    (0, vitest_1.it)('should handle quoted values', () => {
+        const header = 'foo="bar"; baz=qux';
+        // Basic implementation might not strip quotes if not decoding specifically for that, 
+        // but let's see standard behavior. My implementation just decodes URI component.
+        // 'foo="bar"' split by '=' -> ['foo', '"bar"']. decodeURIComponent('"bar"') -> '"bar"'.
+        const result = (0, cookies_1.parseCookies)(header);
+        (0, vitest_1.expect)(result).toEqual({ foo: '"bar"', baz: 'qux' });
+    });
+    (0, vitest_1.it)('should handle URL encoded values', () => {
+        const header = 'foo=Hello%20World';
+        const result = (0, cookies_1.parseCookies)(header);
+        (0, vitest_1.expect)(result).toEqual({ foo: 'Hello World' });
+    });
+    (0, vitest_1.it)('should handle empty header', () => {
+        (0, vitest_1.expect)((0, cookies_1.parseCookies)(undefined)).toEqual({});
+        (0, vitest_1.expect)((0, cookies_1.parseCookies)('')).toEqual({});
+    });
+    (0, vitest_1.it)('should ignore cookies without name', () => {
+        const header = '=bar; baz=qux';
+        const result = (0, cookies_1.parseCookies)(header);
+        (0, vitest_1.expect)(result).toEqual({ baz: 'qux' });
+    });
+});
+(0, vitest_1.describe)('Cookie Serialization', () => {
+    (0, vitest_1.it)('should serialize name and value', () => {
+        const result = (0, cookies_1.serializeCookie)('foo', 'bar');
+        (0, vitest_1.expect)(result).toBe('foo=bar; Path=/');
+    });
+    (0, vitest_1.it)('should encode value', () => {
+        const result = (0, cookies_1.serializeCookie)('foo', 'Hello World');
+        (0, vitest_1.expect)(result).toBe('foo=Hello%20World; Path=/');
+    });
+    (0, vitest_1.it)('should handle Max-Age', () => {
+        const result = (0, cookies_1.serializeCookie)('foo', 'bar', { maxAge: 3600 });
+        (0, vitest_1.expect)(result).toContain('Max-Age=3600');
+    });
+    (0, vitest_1.it)('should handle HttpOnly', () => {
+        const result = (0, cookies_1.serializeCookie)('foo', 'bar', { httpOnly: true });
+        (0, vitest_1.expect)(result).toContain('HttpOnly');
+    });
+    (0, vitest_1.it)('should handle Secure', () => {
+        const result = (0, cookies_1.serializeCookie)('foo', 'bar', { secure: true });
+        (0, vitest_1.expect)(result).toContain('Secure');
+    });
+    (0, vitest_1.it)('should handle SameSite', () => {
+        const result = (0, cookies_1.serializeCookie)('foo', 'bar', { sameSite: 'strict' });
+        (0, vitest_1.expect)(result).toContain('SameSite=Strict');
+    });
+    (0, vitest_1.it)('should handle Path', () => {
+        const result = (0, cookies_1.serializeCookie)('foo', 'bar', { path: '/admin' });
+        (0, vitest_1.expect)(result).toContain('Path=/admin');
+    });
+});

package/dist/tests/cors.test.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const src_1 = require("../src");
+(0, vitest_1.describe)('CORS middleware', () => {
+    let app;
+    (0, vitest_1.afterEach)(async () => {
+        if (app) {
+            await app.close();
+            app = undefined;
+        }
+    });
+    (0, vitest_1.it)('sets default CORS headers and passes through GET', async () => {
+        app = new src_1.QHTTPX();
+        app.use((0, src_1.createCorsMiddleware)());
+        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`, {
+            headers: {
+                origin: 'http://example.com',
+            },
+        });
+        (0, vitest_1.expect)(response.status).toBe(200);
+        (0, vitest_1.expect)(await response.text()).toBe('pong');
+        (0, vitest_1.expect)(response.headers.get('access-control-allow-origin')).toBe('*');
+    });
+    (0, vitest_1.it)('handles preflight OPTIONS requests', async () => {
+        app = new src_1.QHTTPX();
+        app.use((0, src_1.createCorsMiddleware)({
+            origin: ['http://example.com'],
+            methods: ['GET', 'POST'],
+            allowedHeaders: ['content-type'],
+            maxAgeSeconds: 600,
+        }));
+        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: 'OPTIONS',
+            headers: {
+                origin: 'http://example.com',
+                'access-control-request-method': 'GET',
+                'access-control-request-headers': 'content-type',
+            },
+        });
+        (0, vitest_1.expect)(response.status).toBe(204);
+        (0, vitest_1.expect)(response.headers.get('access-control-allow-origin')).toBe('http://example.com');
+        (0, vitest_1.expect)(response.headers.get('access-control-allow-methods')).toBe('GET, POST');
+        (0, vitest_1.expect)(response.headers.get('access-control-allow-headers')).toBe('content-type');
+        (0, vitest_1.expect)(response.headers.get('access-control-max-age')).toBe('600');
+    });
+});

package/dist/tests/database.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const manager_1 = require("../src/database/manager");
+const memory_1 = require("../src/database/adapters/memory");
+(0, vitest_1.describe)('Database Engine', () => {
+    let dbManager;
+    (0, vitest_1.beforeEach)(() => {
+        // Register the adapter
+        manager_1.DatabaseManager.registerAdapter('memory', memory_1.MemoryAdapter);
+        // Initialize manager
+        dbManager = new manager_1.DatabaseManager({
+            default: 'main',
+            connections: {
+                main: {
+                    type: 'memory',
+                    database: 'test_db'
+                }
+            }
+        });
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await dbManager.disconnect();
+    });
+    (0, vitest_1.it)('should connect to the default database', async () => {
+        const adapter = await dbManager.connect();
+        (0, vitest_1.expect)(adapter).toBeDefined();
+        (0, vitest_1.expect)(adapter.isConnected()).toBe(true);
+    });
+    (0, vitest_1.it)('should perform CRUD operations with MemoryAdapter', async () => {
+        const adapter = await dbManager.connect();
+        // Insert
+        const user = await adapter.query({
+            collection: 'users',
+            action: 'insert',
+            data: { name: 'John Doe', email: 'john@example.com' }
+        });
+        (0, vitest_1.expect)(user).toHaveProperty('id');
+        (0, vitest_1.expect)(user.name).toBe('John Doe');
+        // Find
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const users = await adapter.query({
+            collection: 'users',
+            action: 'find',
+            filter: { name: 'John Doe' }
+        });
+        (0, vitest_1.expect)(users).toHaveLength(1);
+        (0, vitest_1.expect)(users[0].email).toBe('john@example.com');
+        // Update
+        const updateCount = await adapter.query({
+            collection: 'users',
+            action: 'update',
+            filter: { name: 'John Doe' },
+            data: { name: 'John Updated' }
+        });
+        (0, vitest_1.expect)(updateCount).toBe(1);
+        // Verify Update
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const updatedUsers = await adapter.query({
+            collection: 'users',
+            action: 'find',
+            filter: { name: 'John Updated' }
+        });
+        (0, vitest_1.expect)(updatedUsers).toHaveLength(1);
+        // Delete
+        const deleteCount = await adapter.query({
+            collection: 'users',
+            action: 'delete',
+            filter: { name: 'John Updated' }
+        });
+        (0, vitest_1.expect)(deleteCount).toBe(1);
+        // Verify Delete
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const remainingUsers = await adapter.query({
+            collection: 'users',
+            action: 'find'
+        });
+        (0, vitest_1.expect)(remainingUsers).toHaveLength(0);
+    });
+});

package/dist/tests/dx.test.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("../src/index");
+const presets_1 = require("../src/middleware/presets");
+(0, vitest_1.describe)('Developer Experience Features', () => {
+    (0, vitest_1.describe)('Routing Ergonomics', () => {
+        (0, vitest_1.it)('supports chainable route() builder', async () => {
+            const app = new index_1.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`);
+            (0, vitest_1.expect)(await resGet.json()).toEqual({ method: 'GET', id: '123' });
+            // Test POST
+            const resPost = await fetch(`${baseUrl}/users/123`, { method: 'POST' });
+            (0, vitest_1.expect)(await resPost.json()).toEqual({ method: 'POST', id: '123' });
+            // Test PUT
+            const resPut = await fetch(`${baseUrl}/users/123`, { method: 'PUT' });
+            (0, vitest_1.expect)(await resPut.json()).toEqual({ method: 'PUT', id: '123' });
+            // Test DELETE
+            const resDelete = await fetch(`${baseUrl}/users/123`, { method: 'DELETE' });
+            (0, vitest_1.expect)(await resDelete.json()).toEqual({ method: 'DELETE', id: '123' });
+            await app.close();
+        });
+    });
+    (0, vitest_1.describe)('Simple App Helper', () => {
+        (0, vitest_1.it)('supports createHttpApp basic usage', async () => {
+            const app = (0, index_1.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}/`);
+            (0, vitest_1.expect)(response.status).toBe(200);
+            (0, vitest_1.expect)(await response.text()).toBe('Hello World!');
+            await app.close();
+        });
+    });
+    (0, vitest_1.describe)('Presets', () => {
+        (0, vitest_1.it)('createApiPreset returns middlewares', () => {
+            const middlewares = (0, presets_1.createApiPreset)();
+            // Should have CORS (1) + Security Headers (1) + Logger (1) = 3
+            (0, vitest_1.expect)(middlewares.length).toBe(3);
+        });
+        (0, vitest_1.it)('createApiPreset allows disabling logger', () => {
+            const middlewares = (0, presets_1.createApiPreset)({ logging: false });
+            // CORS + Security Headers = 2
+            (0, vitest_1.expect)(middlewares.length).toBe(2);
+        });
+        (0, vitest_1.it)('createStaticAppPreset returns middlewares with static', () => {
+            const middlewares = (0, presets_1.createStaticAppPreset)({
+                static: { root: './public' },
+            });
+            // CORS + Security Headers + Logger + Static = 4
+            (0, vitest_1.expect)(middlewares.length).toBe(4);
+        });
+    });
+});

package/dist/tests/ecosystem.test.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const server_1 = require("../src/core/server");
+// Mock External Libraries
+const mockJose = {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    jwtVerify: async (token, _secret) => {
+        if (token === 'valid_token')
+            return { payload: { sub: 'user_123', role: 'admin' } };
+        throw new Error('Invalid Token');
+    }
+};
+const mockRedis = {
+    get: async (key) => {
+        if (key === 'cache:page:home')
+            return '<html>Cached Home</html>';
+        return null;
+    },
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    set: async (key, val) => 'OK'
+};
+(0, vitest_1.describe)('SaaS Ecosystem Compatibility', () => {
+    (0, vitest_1.it)('should allow integration of 3rd party JWT libraries (e.g. jose)', async () => {
+        const app = new server_1.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 = 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' } });
+        (0, vitest_1.expect)(res1.status).toBe(200);
+        const data1 = await res1.json();
+        (0, vitest_1.expect)(data1).toEqual({ message: 'Welcome user_123', role: 'admin' });
+        // Test Invalid Token
+        const res2 = await fetch(`${url}/dashboard`, { headers: { Authorization: 'Bearer bad_token' } });
+        (0, vitest_1.expect)(res2.status).toBe(403);
+        await app.close();
+    });
+    (0, vitest_1.it)('should allow integration of 3rd party Caching (e.g. Redis)', async () => {
+        const app = new server_1.QHTTPX();
+        // 2. Create a Caching Middleware using "redis"
+        const cacheMiddleware = 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`);
+        (0, vitest_1.expect)(res1.status).toBe(200);
+        (0, vitest_1.expect)(res1.headers.get('x-cache')).toBe('HIT');
+        const text1 = await res1.text();
+        (0, vitest_1.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();
+    });
+    (0, vitest_1.it)('should allow integration of ORM/DB libraries', async () => {
+        const app = new server_1.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`);
+        (0, vitest_1.expect)(res.status).toBe(200);
+        await app.close();
+    });
+});