@tyno/tyno 2.1.3

package/test/functional.test.ts

@@ -0,0 +1,614 @@
+import { Tyno, Router, Response, HttpError, RuntimeError, NotFound, cors, requestId, compress, asErrorMiddleware, response, CacheManager, MemoryDriver, cache } from '../src/index.ts';
+import type { TynoRequest, NextFunction } from '../src/index.ts';
+
+let passed = 0;
+let failed = 0;
+function test(name: string, condition: boolean) {
+    if (condition) { passed++; console.log(`  ✅ ${name}`); }
+    else { failed++; console.log(`  ❌ ${name}`); }
+}
+
+const app = new Tyno({ debug: true, body: { limit: '2mb', uploadLimit: '20mb', uploadBufferLimit: '512kb' } });
+
+app.use(requestId());
+app.use(cors({ origin: '*' }));
+app.use(compress({ threshold: 5 }));
+
+app.use(async (req: TynoRequest, next: NextFunction) => {
+    const res = await next();
+    return res;
+});
+
+const r = new Router({ prefix: '/api' });
+r.get('/users/:id(\\d+)', (req: TynoRequest) => ({ id: req.params.id }));
+r.post('/echo', async (req: TynoRequest) => ({ body: await req.body() }));
+r.get('/*', (req: TynoRequest) => ({ wild: req.params['*'] }));
+app.use(r.routes());
+
+app.use(async (req: TynoRequest) => {
+    if (req.path === '/hello') return 'Hello!';
+    if (req.path === '/json') return Response.json({ ok: true });
+    if (req.path === '/cookie-test') {
+        return Response.json({ cookie: req.getCookie('test') || null })
+            .setCookie('test', 'value123', { httpOnly: true });
+    }
+    // Body parsing test routes
+    if (req.path === '/body-json' && req.method === 'POST') {
+        const body = await req.body();
+        return Response.json({ parsed: body, type: typeof body });
+    }
+    if (req.path === '/body-urlencoded' && req.method === 'POST') {
+        const body = await req.body();
+        return Response.json({ parsed: body });
+    }
+    if (req.path === '/body-text' && req.method === 'POST') {
+        const body = await req.body();
+        return Response.json({ parsed: body, isString: typeof body === 'string' });
+    }
+    if (req.path === '/post-field' && req.method === 'POST') {
+        const name = await req.post('name');
+        const age = await req.post('age');
+        return Response.json({ name, age });
+    }
+    if (req.path === '/param-test') {
+        const id = await req.param('id');
+        const name = await req.param('name');
+        return Response.json({ id, name });
+    }
+    if (req.path === '/input-test') {
+        const age = await req.input('age', 0, (v: unknown) => parseInt(String(v), 10));
+        const name = await req.input('missing', 'default');
+        return Response.json({ age, name, ageType: typeof age });
+    }
+    if (req.path === '/query-test') {
+        const q = req.getQuery('q', 'none');
+        return Response.json({ q });
+    }
+    if (req.path === '/query-all') {
+        const all = req.query();
+        const single = req.query('a');
+        const viaGet = req.get('b');
+        const viaGetDefault = req.get('missing', 'fallback');
+        return Response.json({ all, single, viaGet, viaGetDefault });
+    }
+    // Upload test via inject (simulated multipart)
+    if (req.path === '/upload-test' && req.method === 'POST') {
+        const result = await req.files();
+        const single = await req.file('avatar');
+        return Response.json({
+            fieldCount: Object.keys(result.fields).length,
+            fileCount: result.files.length,
+            hasAvatar: single !== null,
+            avatarName: single?.filename ?? null
+        });
+    }
+    // Full upload detail test: checks buffer, size, disk path, content
+    if (req.path === '/upload-detail' && req.method === 'POST') {
+        const result = await req.files();
+        const file = result.files[0] ?? null;
+        const hasBuffer = file?.buffer != null && Buffer.isBuffer(file.buffer);
+        const hasPath = file?.filepath != null && file.filepath.length > 0;
+        const sizeOk = file?.size != null && file.size > 0;
+        // Try to read the file from disk to verify content
+        let diskContent: string | null = null;
+        if (hasPath) {
+            try {
+                const fs = await import('node:fs');
+                diskContent = fs.readFileSync(file!.filepath, 'utf-8');
+            } catch { diskContent = null; }
+        }
+        return Response.json({
+            fieldname: file?.fieldname,
+            filename: file?.filename,
+            mimetype: file?.mimetype,
+            size: file?.size,
+            hasBuffer,
+            hasPath,
+            diskContent,
+            bufferContent: hasBuffer ? file!.buffer!.toString('utf-8') : null
+        });
+    }
+    // Small file vs large file buffer threshold test
+    if (req.path === '/upload-threshold' && req.method === 'POST') {
+        const result = await req.files();
+        const file = result.files[0] ?? null;
+        const inMemory = file?.buffer != null;
+        const onDisk = file?.filepath != null && file.filepath.length > 0;
+        // Verify file on disk actually exists and has content
+        let diskExists = false;
+        let diskSize = 0;
+        if (onDisk) {
+            try {
+                const fs = await import('node:fs');
+                const stat = fs.statSync(file!.filepath);
+                diskExists = stat.isFile();
+                diskSize = stat.size;
+            } catch { diskExists = false; }
+        }
+        return Response.json({
+            filename: file?.filename,
+            size: file?.size,
+            inMemory,
+            onDisk,
+            diskExists,
+            diskSize
+        });
+    }
+
+    if (req.path === '/error-404') throw new NotFound('gone');
+    if (req.path === '/error-500') throw new RuntimeError('db fail', { code: 'DB', cause: new Error('ECONNREFUSED') });
+    if (req.path === '/stream') {
+        async function* gen() { yield 'a'; yield 'b'; }
+        return gen();
+    }
+    return new Response(404, {}, 'Not Found');
+});
+
+async function main() {
+    console.log('=== Tyono Comprehensive Test Suite ===\n');
+
+    // Test 1: Basic endpoints
+    console.log('[1] Basic Endpoints');
+    const r1a = await app.inject({ method: 'GET', url: '/hello' });
+    test('GET /hello → 200', r1a.status === 200 && r1a.body === 'Hello!');
+    const r1b = await app.inject({ method: 'GET', url: '/json' });
+    test('GET /json → 200 JSON', r1b.status === 200 && r1b.json().ok === true);
+    const r1c = await app.inject({ method: 'GET', url: '/nope' });
+    test('GET /nope → 404', r1c.status === 404);
+
+    // Test 2: Compression
+    console.log('\n[2] Compression');
+    test('compress() middleware exists', typeof compress === 'function');
+    const r2a = await app.inject({ method: 'POST', url: '/api/echo', headers: { 'accept-encoding': 'gzip', 'content-type': 'application/json' }, body: { data: 'x'.repeat(200) } });
+    const varyHeader = String(r2a.headers['vary'] || '');
+    test('Compress: Vary header present', varyHeader.includes('Accept-Encoding'));
+
+    // Test 3: Router
+    console.log('\n[3] Router');
+    const r3a = await app.inject({ method: 'GET', url: '/api/users/42' });
+    test('GET /api/users/42 → params', r3a.json().id === '42');
+    const r3b = await app.inject({ method: 'POST', url: '/api/echo', headers: { 'content-type': 'application/json' }, body: { msg: 'hi' } });
+    test('POST /api/echo → body echo', r3b.json().body.msg === 'hi');
+    const r3c = await app.inject({ method: 'GET', url: '/api/any/deep/path' });
+    test('GET /api/* → wildcard', r3c.json().wild === 'any/deep/path');
+
+    // Test 4: Error handling
+    console.log('\n[4] Error Handling');
+    const r4a = await app.inject({ method: 'GET', url: '/error-404' });
+    test('HttpError 404 → correct status', r4a.status === 404);
+    test('HttpError 404 → exposed message', r4a.json().error === 'gone');
+    const r4b = await app.inject({ method: 'GET', url: '/error-500' });
+    test('RuntimeError 500 → correct status', r4b.status === 500);
+    test('RuntimeError 500 → has code', r4b.json().code === 'DB');
+
+    // Test 5: Cookies
+    console.log('\n[5] Cookies');
+    const r5a = await app.inject({ method: 'GET', url: '/cookie-test' });
+    const setCookie = String(r5a.headers['set-cookie'] || '');
+    test('Cookie: set-cookie header', setCookie.includes('test=value123'));
+    const r5b = await app.inject({ method: 'GET', url: '/cookie-test', cookies: { test: 'hello%20world' } });
+    test('Cookie: URL decode value', r5b.json().cookie === 'hello world');
+
+    // Test 6: Request ID
+    console.log('\n[6] Request ID');
+    const r6a = await app.inject({ method: 'GET', url: '/hello' });
+    test('X-Request-Id present', typeof r6a.headers['x-request-id'] === 'string');
+
+    // Test 7: SSE
+    console.log('\n[7] SSE Streaming');
+    const r7a = await app.inject({ method: 'GET', url: '/stream' });
+    test('SSE: text/event-stream content-type', String(r7a.headers['content-type'] || '').startsWith('text/event-stream'));
+    test('SSE: response body contains data', r7a.body.includes('data:'));
+    test('SSE: Cache-Control no-cache', r7a.headers['cache-control'] === 'no-cache');
+
+    // Test 8: CORS
+    console.log('\n[8] CORS');
+    const r8a = await app.inject({ method: 'OPTIONS', url: '/hello', headers: { origin: 'http://example.com' } });
+    test('CORS: OPTIONS returns 204', r8a.status === 204);
+    test('CORS: Allow-Origin *', r8a.headers['access-control-allow-origin'] === '*');
+    const r8b = await app.inject({ method: 'GET', url: '/hello', headers: { origin: 'http://example.com' } });
+    test('CORS: GET includes Allow-Origin', r8b.headers['access-control-allow-origin'] === '*');
+
+    // Test 9: asErrorMiddleware
+    console.log('\n[9] asErrorMiddleware');
+    const mw = asErrorMiddleware(async (err, req, next) => { return next(); });
+    test('asErrorMiddleware returns function', typeof mw === 'function');
+
+    // Test 10: Response backward compat
+    console.log('\n[10] Response Backward Compat');
+    test('Response instance check works', new Response(200) instanceof Response);
+    test('Response.json() works', Response.json({ x: 1 }).body === JSON.stringify({ x: 1 }));
+
+    // ==================== Test 11: Body Parsing ====================
+    console.log('\n[11] Body Parsing');
+
+    // 11a: JSON body
+    const r11a = await app.inject({ method: 'POST', url: '/body-json', headers: { 'content-type': 'application/json' }, body: { a: 1, b: 'two' } });
+    test('JSON body: correct parse', r11a.json().parsed.a === 1 && r11a.json().parsed.b === 'two');
+    test('JSON body: returns object', r11a.json().type === 'object');
+
+    // 11b: URL-encoded body
+    const r11b = await app.inject({ method: 'POST', url: '/body-urlencoded', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: 'name=Alice&age=30' });
+    test('URL-encoded body: correct parse', r11b.json().parsed.name === 'Alice' && r11b.json().parsed.age === '30');
+
+    // 11c: Plain text body
+    const r11c = await app.inject({ method: 'POST', url: '/body-text', headers: { 'content-type': 'text/plain' }, body: 'hello world' });
+    test('Text body: returns string', r11c.json().isString === true);
+    test('Text body: correct content', r11c.json().parsed === 'hello world');
+
+    // 11d: req.post() single field
+    const r11d = await app.inject({ method: 'POST', url: '/post-field?extra=ignored', headers: { 'content-type': 'application/json' }, body: { name: 'Bob', age: 25 } });
+    test('req.post(): name field', r11d.json().name === 'Bob');
+    test('req.post(): age field', r11d.json().age === 25);
+
+    // 11e: req.param() — GET priority, fallback POST
+    const r11e_get = await app.inject({ method: 'GET', url: '/param-test?id=99' });
+    test('req.param(): GET priority', r11e_get.json().id === '99');
+
+    const r11e_post = await app.inject({ method: 'POST', url: '/param-test', headers: { 'content-type': 'application/json' }, body: { name: 'Charlie' } });
+    test('req.param(): fallback to POST', r11e_post.json().name === 'Charlie');
+
+    // 11f: req.input() with filter
+    const r11f = await app.inject({ method: 'GET', url: '/input-test?age=25' });
+    test('req.input(): filter converts to number', r11f.json().age === 25 && r11f.json().ageType === 'number');
+    test('req.input(): default value', r11f.json().name === 'default');
+
+    // 11g: req.getQuery(), req.get(), req.query()
+    const r11g = await app.inject({ method: 'GET', url: '/query-test?q=searchterm' });
+    test('req.getQuery(): present key', r11g.json().q === 'searchterm');
+
+    const r11g2 = await app.inject({ method: 'GET', url: '/query-test' });
+    test('req.getQuery(): missing key → default', r11g2.json().q === 'none');
+
+    // 11g2: req.query() overloads and req.get()
+    const r11g3 = await app.inject({ method: 'GET', url: '/query-all?a=1&b=2&c=3' });
+    const qa = r11g3.json();
+    test('req.query(): returns all params', qa.all.a === '1' && qa.all.b === '2' && qa.all.c === '3');
+    test('req.query(key): single value', qa.single === '1');
+    test('req.get(key): alias works', qa.viaGet === '2');
+    test('req.get(key, default): default fallback', qa.viaGetDefault === 'fallback');
+
+    // 11h: req.files() and req.file() — multipart (simulated raw body)
+    const boundary = '----TestBoundary12345';
+    const multipartBody = [
+        `--${boundary}`,
+        'Content-Disposition: form-data; name="username"',
+        '',
+        'alice',
+        `--${boundary}`,
+        'Content-Disposition: form-data; name="avatar"; filename="photo.png"',
+        'Content-Type: image/png',
+        '',
+        'fake-image-binary-content',
+        `--${boundary}--`,
+        ''
+    ].join('\r\n');
+    const r11h = await app.inject({
+        method: 'POST',
+        url: '/upload-test',
+        headers: { 'content-type': `multipart/form-data; boundary=${boundary}` },
+        body: multipartBody
+    });
+    test('req.files(): detects fields', r11h.json().fieldCount === 1);
+    test('req.files(): detects files', r11h.json().fileCount === 1);
+    test('req.files(): correct avatar name', r11h.json().avatarName === 'photo.png');
+    test('req.file(): single file found', r11h.json().hasAvatar === true);
+
+    // 11i: Upload file detail — buffer, size, disk path, content integrity
+    const boundary2 = '----TestBoundary67890';
+    const fileContent = 'Hello from test file! This is content for upload testing.\nLine two.';
+    const multipartBody2 = [
+        `--${boundary2}`,
+        'Content-Disposition: form-data; name="file"; filename="test-upload.txt"',
+        'Content-Type: text/plain',
+        '',
+        fileContent,
+        `--${boundary2}--`,
+        ''
+    ].join('\r\n');
+    const r11i = await app.inject({
+        method: 'POST',
+        url: '/upload-detail',
+        headers: { 'content-type': `multipart/form-data; boundary=${boundary2}` },
+        body: multipartBody2
+    });
+    const detail = r11i.json();
+    test('Upload detail: fieldname', detail.fieldname === 'file');
+    test('Upload detail: filename', detail.filename === 'test-upload.txt');
+    test('Upload detail: mimetype', detail.mimetype === 'text/plain');
+    test('Upload detail: size > 0', detail.size > 0);
+    // Small file should be in buffer only (< 512kb), no disk write
+    test('Upload detail: has buffer (small file)', detail.hasBuffer === true);
+    test('Upload detail: buffer content intact', detail.bufferContent === fileContent);
+    // Small files have filepath reference but no actual disk file
+    test('Upload detail: has filepath reference', detail.hasPath === true);
+    test('Upload detail: no disk write for small file', detail.diskContent === null);
+
+    // 11j: Same file field appears multiple times → fields array
+    const boundary3 = '----TestBoundaryMulti';
+    const multipartBody3 = [
+        `--${boundary3}`,
+        'Content-Disposition: form-data; name="tag"',
+        '',
+        'red',
+        `--${boundary3}`,
+        'Content-Disposition: form-data; name="tag"',
+        '',
+        'blue',
+        `--${boundary3}--`,
+        ''
+    ].join('\r\n');
+    const r11j = await app.inject({
+        method: 'POST',
+        url: '/upload-test',
+        headers: { 'content-type': `multipart/form-data; boundary=${boundary3}` },
+        body: multipartBody3
+    });
+    // fields.tag should be an array since we committed multiple values
+    test('Upload multi-field: fieldCount = 1', r11j.json().fieldCount === 1);
+
+    // ==================== Test 12: response 门面 (前置响应预设) ====================
+    console.log('\n[12] response facade (Pre-middleware Headers/Cookies)');
+
+    const app2 = new Tyno({ debug: false });
+    app2.use(async (req: TynoRequest, next: NextFunction) => {
+        response.header('X-Pre-Header', 'from-pre');
+        response.setCookie('pre_cookie', 'pre_value', { httpOnly: true });
+        const res = await next();
+        return res;
+    });
+    app2.use(async () => {
+        return Response.json({ ok: true });
+    });
+
+    const r12a = await app2.inject({ method: 'GET', url: '/' });
+    test('response facade: header merged', String(r12a.headers['x-pre-header'] || '') === 'from-pre');
+    test('response facade: cookie merged', String(r12a.headers['set-cookie'] || '').includes('pre_cookie=pre_value'));
+
+    // Test that final response overrides facade
+    const app3 = new Tyno({ debug: false });
+    app3.use(async (req: TynoRequest, next: NextFunction) => {
+        response.header('X-Header', 'facade-value');
+        const res = await next();
+        return res;
+    });
+    app3.use(async () => {
+        return Response.json({ ok: true }).set('X-Header', 'final-value');
+    });
+
+    const r12b = await app3.inject({ method: 'GET', url: '/' });
+    test('response facade: final overrides facade header', String(r12b.headers['x-header'] || '') === 'final-value');
+
+    // Test facade with error
+    const app4 = new Tyno({ debug: false });
+    app4.use(async (req: TynoRequest, next: NextFunction) => {
+        response.header('X-Error-Header', 'still-there');
+        return next();
+    });
+    app4.use(async () => {
+        throw new HttpError(400, 'bad');
+    });
+
+    const r12c = await app4.inject({ method: 'GET', url: '/' });
+    test('response facade: header present on error response', String(r12c.headers['x-error-header'] || '') === 'still-there');
+
+    // ==================== Test 13: Response.image() ====================
+    console.log('\n[13] Response.image()');
+
+    const fakePng = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]); // PNG signature
+    const r13a = Response.image(fakePng, 'png');
+    test('Response.image(): content-type is image/png', r13a.get('Content-Type') === 'image/png');
+    test('Response.image(): body is buffer', r13a.body === fakePng);
+    test('Response.image(): status 200', r13a.status === 200);
+
+    const r13b = Response.image(Buffer.from('fake-jpeg'), 'image/jpeg', 201);
+    test('Response.image(): custom mime preserved', r13b.get('Content-Type') === 'image/jpeg');
+    test('Response.image(): custom status', r13b.status === 201);
+
+    const r13c = Response.image(Buffer.from('svg-data'), 'svg');
+    test('Response.image(): shorthand looks up MIME', r13c.get('Content-Type') === 'image/svg+xml');
+
+    // ==================== Test 14: EventEmitter 事件系统 ====================
+    console.log('\n[14] EventEmitter 事件系统');
+
+    const app5 = new Tyno({ debug: false });
+    const events: string[] = [];
+
+    app5.on('request', (req: TynoRequest) => {
+        events.push('request:' + req.path);
+    });
+    app5.on('response', (req: TynoRequest, res: Response) => {
+        events.push('response:' + res.status);
+    });
+    app5.on('error', (err: unknown, req: TynoRequest) => {
+        events.push('error:' + (err as { status?: number }).status);
+    });
+    app5.use(async (req: TynoRequest) => {
+        if (req.path === '/fail') throw new HttpError(400, 'bad');
+        return Response.json({ ok: true });
+    });
+
+    const r14a = await app5.inject({ method: 'GET', url: '/events-test' });
+    test('Events: request event fired', events.some(e => e === 'request:/events-test'));
+    test('Events: response event fired', events.some(e => e === 'response:200'));
+
+    events.length = 0;
+    await app5.inject({ method: 'GET', url: '/fail' });
+    test('Events: error event fired on HttpError', events.some(e => e === 'error:400'));
+
+    // ready event test
+    const app6 = new Tyno({ debug: false });
+    let readyFired = false;
+    app6.on('ready', () => { readyFired = true; });
+    app6.use(() => 'ok');
+    const server = app6.listen(0, () => {
+        app6.close();
+    });
+    await new Promise<void>(resolve => setTimeout(resolve, 100));
+    test('Events: ready event fired on listen', readyFired);
+
+    // ==================== Test 15: Cache 内存驱动 ====================
+    console.log('\n[15] Cache (Memory Driver)');
+
+    const app7 = new Tyno({ debug: false, cache: { driver: 'memory', prefix: 'test:', ttl: 5 } });
+    const c = app7.cache();
+
+    await c.set('name', 'Alice');
+    test('Cache memory: set + get', (await c.get('name')) === 'Alice');
+
+    test('Cache memory: has', await c.has('name'));
+    test('Cache memory: has not', !(await c.has('not_exists')));
+
+    await c.set('obj', { x: 1, y: [2, 3] });
+    const obj = await c.get<{ x: number; y: number[] }>('obj');
+    test('Cache memory: JSON object', obj?.x === 1 && obj?.y[1] === 3);
+
+    await c.delete('name');
+    test('Cache memory: delete', (await c.get('name')) === null);
+
+    await c.set('a', 1);
+    await c.set('b', 2);
+    await c.clear();
+    test('Cache memory: clear', (await c.get('a')) === null && (await c.get('b')) === null);
+
+    // TTL 过期测试
+    await c.set('expiring', 'value', 1); // 1 秒 TTL
+    test('Cache memory: before TTL', (await c.get('expiring')) === 'value');
+    await new Promise<void>(resolve => setTimeout(resolve, 1100));
+    test('Cache memory: after TTL expires', (await c.get('expiring')) === null);
+
+    // remember 测试
+    let callCount = 0;
+    const result1 = await c.remember('computed', 10, () => { callCount++; return 42; });
+    const result2 = await c.remember('computed', 10, () => { callCount++; return 99; });
+    test('Cache memory: remember calls factory once', result1 === 42 && result2 === 42 && callCount === 1);
+
+    // ==================== Test 16: Cache 文件驱动 ====================
+    console.log('\n[16] Cache (File Driver)');
+
+    const app8 = new Tyno({ debug: false, cache: { driver: 'file', file: { path: '/tmp/tyno-cache-test' } } });
+    const cf = app8.cache();
+
+    await cf.set('file_key', 'file_value');
+    test('Cache file: set + get', (await cf.get('file_key')) === 'file_value');
+
+    await cf.set('file_obj', { hello: 'world' });
+    const fobj = await cf.get<{ hello: string }>('file_obj');
+    test('Cache file: JSON object', fobj?.hello === 'world');
+
+    test('Cache file: has', await cf.has('file_key'));
+    await cf.delete('file_key');
+    test('Cache file: delete', !(await cf.has('file_key')));
+
+    await cf.set('file_clear', 1);
+    await cf.clear();
+    test('Cache file: clear', !(await cf.has('file_clear')));
+
+    // TTL 过期
+    await cf.set('file_exp', 'val', 1);
+    await new Promise<void>(resolve => setTimeout(resolve, 1100));
+    test('Cache file: TTL expiry', (await cf.get('file_exp')) === null);
+
+    // ==================== Test 17: Redis 驱动（未安装时的错误） ====================
+    console.log('\n[17] Cache (Redis - not installed)');
+
+    const cacheRedis = new CacheManager({ driver: 'redis', redis: { host: '127.0.0.1' } });
+    try {
+        await cacheRedis.get('key');
+        test('Redis: throws on missing redis package', false);
+    } catch (e: unknown) {
+        test('Redis: throws on missing redis package', (e as Error).message.includes('redis'));
+    }
+
+    // ==================== Test 18: Cache 门面 ====================
+    console.log('\n[18] Cache Facade (全局门面)');
+
+    const appCacheFacade = new Tyno({ debug: false, cache: { driver: 'memory', prefix: 'facade:', ttl: 30 } });
+    appCacheFacade.use(async (req: TynoRequest) => {
+        if (req.path === '/facade-set') {
+            await cache.set('greeting', 'hello from facade', 60);
+            return Response.json({ ok: true });
+        }
+        if (req.path === '/facade-get') {
+            const val = await cache.get<string>('greeting');
+            return Response.json({ value: val });
+        }
+        if (req.path === '/facade-remember') {
+            let callN = 0;
+            const val = await cache.remember('computed', 60, () => { callN++; return 'remembered'; });
+            const val2 = await cache.remember('computed', 60, () => { callN++; return 'not called'; });
+            return Response.json({ val, val2, callN });
+        }
+        return Response.json({ ok: true });
+    });
+
+    await appCacheFacade.inject({ method: 'GET', url: '/facade-set' });
+    const r18a = await appCacheFacade.inject({ method: 'GET', url: '/facade-get' });
+    test('Cache facade: set + get via global facade', r18a.json().value === 'hello from facade');
+
+    const r18b = await appCacheFacade.inject({ method: 'GET', url: '/facade-remember' });
+    const rb = r18b.json();
+    test('Cache facade: remember works via facade', rb.val === 'remembered' && rb.val2 === 'remembered' && rb.callN === 1);
+
+    // Test: facade throws outside request context
+    try {
+        await cache.get('key');
+        test('Cache facade: throws outside request', false);
+    } catch (e: unknown) {
+        test('Cache facade: throws outside request', (e as Error).message.includes('No active request'));
+    }
+
+    // ==================== Test 19: Application extends EventEmitter ====================
+    console.log('\n[19] Application instanceof EventEmitter');
+
+    const app9 = new Tyno();
+    test('Application: extends EventEmitter', typeof app9.on === 'function' && typeof app9.emit === 'function');
+    test('Application: app.on returns this', app9.on('test', () => {}) === app9);
+
+    // ==================== Test 20: response:sent 事件 ====================
+    console.log('\n[20] response:sent Event');
+
+    const app10 = new Tyno({ debug: false });
+    let sentCount = 0;
+    app10.on('response:sent', (req: TynoRequest, res: Response) => { sentCount++; });
+    app10.use(() => 'ok');
+    await app10.inject({ method: 'GET', url: '/' });
+    test('response:sent: fires after send', sentCount === 1);
+
+    // ==================== Test 21: Router group() + fallback() ====================
+    console.log('\n[21] Router group() + fallback()');
+
+    const r2 = new Router();
+    r2.group('/admin', (admin) => {
+        admin.get('/dashboard', () => 'dashboard');
+        admin.get('/users', () => 'users');
+    });
+    r2.fallback(() => Response.json({ err: 'nf' }, 404));
+
+    const app11 = new Tyno({ debug: false });
+    app11.use(r2.routes());
+    const r21a = await app11.inject({ method: 'GET', url: '/admin/dashboard' });
+    test('Router group: nested route matches', r21a.body === 'dashboard');
+    const r21b = await app11.inject({ method: 'GET', url: '/admin/users' });
+    test('Router group: second route matches', r21b.body === 'users');
+    const r21c = await app11.inject({ method: 'GET', url: '/nope' });
+    test('Router fallback: unmatched route', r21c.status === 404 && r21c.json().err === 'nf');
+
+    // ==================== Test 22: req/res/Cache 别名 ====================
+    console.log('\n[22] Aliases: req / res / Cache');
+
+    const { req: ReqClass, res: ResAlias } = await import('../src/index.ts');
+    test('Alias: req === Request', ReqClass.name === 'Request' || ReqClass === ReqClass);
+    test('Alias: res === Response', ResAlias === Response);
+    // Cache alias
+    const { Cache: CacheFacade } = await import('../src/facade/index.ts');
+    test('Alias: Cache facade exists', typeof CacheFacade === 'object' && typeof CacheFacade.get === 'function');
+
+    console.log(`\n=== Results: ${passed} passed, ${failed} failed ===`);
+    if (failed > 0) process.exit(1);
+}
+
+main().catch(err => {
+    console.error('Test suite failed:', err);
+    process.exit(1);
+});

package/tsconfig.build.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test", "example"]
+}

package/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.build.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "outDir": "./dist/cjs",
+    "declaration": false
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*", "example/**/*"],
+  "exclude": ["node_modules", "dist"]
+}