@tyno/tyno 2.1.3

package/src/request/index.ts

@@ -0,0 +1,273 @@
+import type { IncomingMessage } from 'node:http';
+import { HttpError } from '../errors/index.ts';
+import { BodyParser } from './body-parser.ts';
+import { MultipartParser } from './multipart-parser.ts';
+import type { BodyParserConfig } from '../types.ts';
+import type { UploadedFile, MultipartResult } from './multipart-parser.ts';
+
+/** 用于存储自定义数据的隐藏键 */
+export const DATA_KEY: unique symbol = Symbol('request-custom-data');
+
+/**
+ * 封装 Node.js 原生 IncomingMessage。
+ * 只读属性：method, url, headers 等，不可被中间件覆盖。
+ * 自定义属性会存放到 this[DATA_KEY] 上，通过 Proxy 透明访问。
+ */
+export class Request {
+    req: IncomingMessage;
+    [DATA_KEY]: Record<string, unknown>;
+
+    /** 路由参数（由 Router 注入），如 /users/:id → { id: '123' } */
+    declare params: Record<string, string>;
+
+    private _queryCache: Record<string, string> | null = null;
+    private _bodyCache: unknown = null;
+    private _bodyParsed = false;
+    private _filesCache: MultipartResult | null = null;
+    private _filesParsed = false;
+    private _cookiesCache: Record<string, string> | null = null;
+
+    private _bodyParser: BodyParser;
+    private _multipartParser: MultipartParser;
+
+    constructor(nodeReq: IncomingMessage, config: BodyParserConfig = {}) {
+        this.req = nodeReq;
+        this[DATA_KEY] = Object.create(null);
+        this._bodyParser = new BodyParser(config);
+        this._multipartParser = new MultipartParser(config);
+    }
+
+    // ==================== 只读原生属性 ====================
+
+    /** 请求方法（GET / POST / ...） */
+    get method(): string { return this.req.method || ''; }
+    /** 请求原始 URL（含 query string） */
+    get url(): string { return this.req.url || ''; }
+    /** 请求头对象 */
+    get headers(): Record<string, string | string[] | undefined> {
+        return this.req.headers as Record<string, string | string[] | undefined>;
+    }
+    /** HTTP 协议版本，如 '1.1' / '2.0' */
+    get httpVersion(): string { return this.req.httpVersion || '1.1'; }
+
+    /** 客户端 IP（优先取 X-Forwarded-For） */
+    get ip(): string {
+        const forwarded = ((this.req.headers['x-forwarded-for'] as string) || '').split(',')[0].trim();
+        return forwarded || this.req.socket.remoteAddress || '';
+    }
+
+    /** 客户端端口 */
+    get port(): number {
+        return (this.req.socket.remotePort as number) || 0;
+    }
+
+    /** 服务器本地 IP */
+    get localAddress(): string {
+        return this.req.socket.localAddress || '';
+    }
+
+    /** 服务器本地端口 */
+    get localPort(): number {
+        return (this.req.socket.localPort as number) || 0;
+    }
+
+    /** 传输协议：'http' 或 'https' */
+    get protocol(): string {
+        return (this.req.socket as unknown as Record<string, unknown>).encrypted ? 'https' : 'http';
+    }
+
+    /** 是否为 HTTPS 安全连接 */
+    get secure(): boolean {
+        return !!(this.req.socket as unknown as Record<string, unknown>).encrypted;
+    }
+
+    /** User-Agent */
+    get userAgent(): string { return (this.req.headers['user-agent'] as string) || ''; }
+
+    /** 请求路径（不含 query string） */
+    get path(): string {
+        const url = this.req.url || '';
+        const idx = url.indexOf('?');
+        return idx === -1 ? url : url.slice(0, idx);
+    }
+
+    /** Host 头（含端口，如 localhost:4567） */
+    get host(): string { return (this.req.headers.host as string) || ''; }
+
+    /** 不含端口的 hostname */
+    get hostname(): string {
+        const host = this.host;
+        const idx = host.lastIndexOf(':');
+        return idx > 0 ? host.slice(0, idx) : host;
+    }
+
+    /** 完整 URL（含协议，如 https://example.com/path?a=1） */
+    get fullUrl(): string {
+        return `${this.protocol}://${this.host}${this.url}`;
+    }
+
+    /**
+     * 判断是否为 AJAX 请求（基于 X-Requested-With 头）
+     */
+    isAjax(): boolean {
+        return (this.header('x-requested-with') || '').toLowerCase() === 'xmlhttprequest';
+    }
+
+    /**
+     * 判断是否为 AJAX 请求（isAjax 别名）
+     */
+    isXHR(): boolean { return this.isAjax(); }
+
+    /**
+     * 判断请求是否期望 JSON 响应（基于 Accept 头）
+     */
+    wantsJSON(): boolean {
+        const accept = (this.header('accept') || '').toLowerCase();
+        return accept.includes('application/json') || accept.includes('text/json');
+    }
+
+    // ==================== Query ====================
+
+    /**
+     * 获取全部 query 参数，或取单个 key 的值。
+     *
+     * @example
+     * req.query()            // → { id: '1', name: 'Alice' }
+     * req.query('id')        // → '1'
+     * req.query('missing')   // → null
+     * req.query('missing', 'default') // → 'default'
+     */
+    query(): Record<string, string>;
+    query(key: string): string | null;
+    query(key: string, defaultValue: string): string;
+    query(key?: string, defaultValue: string | null = null): Record<string, string> | string | null {
+        if (!this._queryCache) {
+            const url = this.url || '';
+            const idx = url.indexOf('?');
+            const qs = idx !== -1 ? url.slice(idx + 1) : '';
+            this._queryCache = Object.fromEntries(new URLSearchParams(qs));
+        }
+        if (key === undefined) return this._queryCache;
+        const val = this._queryCache[key];
+        return val !== undefined ? val : defaultValue;
+    }
+
+    /** `query(key, default?)` 的别名 */
+    get(key: string, defaultValue?: string | null): string | null {
+        return this._getQueryValue(key, defaultValue);
+    }
+
+    getQuery(key: string, defaultValue?: string | null): string | null {
+        return this._getQueryValue(key, defaultValue);
+    }
+
+    /** 内部：从已缓存的 query 中取值 */
+    private _getQueryValue(key: string, defaultValue: string | null = null): string | null {
+        // 确保 cache 已填充
+        if (!this._queryCache) this.query();
+        const val = this._queryCache![key];
+        return val !== undefined ? val : defaultValue;
+    }
+
+    // ==================== Body（委托给 BodyParser / MultipartParser） ====================
+
+    /**
+     * 解析请求体。
+     * - multipart/form-data → 返回 fields 部分（文件用 files() 获取）
+     * - 其他类型 → 返回解析后的对象/字符串
+     * 结果缓存。
+     */
+    async body(): Promise<unknown> {
+        if (this._bodyParsed) return this._bodyCache;
+        const contentType = ((this.req.headers['content-type'] as string) || '').toLowerCase();
+        if (contentType.includes('multipart/form-data')) {
+            const result = await this.files();
+            this._bodyCache = result.fields;
+        } else {
+            this._bodyCache = await this._bodyParser.parse(this.req);
+        }
+        this._bodyParsed = true;
+        return this._bodyCache;
+    }
+
+    /**
+     * 解析文件上传（multipart/form-data）。
+     * 返回 { fields, files }，结果缓存。
+     * 非 multipart 请求返回 { fields: {}, files: [] }。
+     */
+    async files(): Promise<MultipartResult> {
+        if (this._filesParsed) return this._filesCache!;
+        const contentType = ((this.req.headers['content-type'] as string) || '').toLowerCase();
+        if (!contentType.includes('multipart/form-data')) {
+            this._filesCache = { fields: {}, files: [] };
+        } else {
+            this._filesCache = await this._multipartParser.parse(this.req);
+        }
+        this._filesParsed = true;
+        if (!this._bodyParsed) {
+            this._bodyCache = this._filesCache.fields;
+            this._bodyParsed = true;
+        }
+        return this._filesCache;
+    }
+
+    /** 获取单个上传文件（第一个匹配 fieldname 的文件） */
+    async file(fieldname: string): Promise<UploadedFile | null> {
+        const result = await this.files();
+        return result.files.find(f => f.fieldname === fieldname) || null;
+    }
+
+    // ==================== 便捷取值 ====================
+
+    async post(key: string, defaultValue: unknown = null): Promise<unknown> {
+        const body = await this.body();
+        if (typeof body === 'object' && body !== null) {
+            return key in body ? (body as Record<string, unknown>)[key] : defaultValue;
+        }
+        return defaultValue;
+    }
+
+    async param(key: string, defaultValue: unknown = null): Promise<unknown> {
+        const q = this.query();
+        if (key in q) return q[key];
+        return this.post(key, defaultValue);
+    }
+
+    async input(key: string, defaultValue: unknown = null, filter: ((val: unknown) => unknown) | null = null): Promise<unknown> {
+        let val = await this.param(key, defaultValue);
+        if (filter && typeof filter === 'function') val = filter(val);
+        return val;
+    }
+
+    header(name: string): string | undefined {
+        const key = name.toLowerCase();
+        for (const h in this.req.headers) {
+            if (h.toLowerCase() === key) return this.req.headers[h] as string;
+        }
+        return undefined;
+    }
+
+    get cookies(): Record<string, string> {
+        if (!this._cookiesCache) {
+            const cookieHeader = (this.req.headers['cookie'] as string) || '';
+            this._cookiesCache = Object.fromEntries(
+                cookieHeader.split(';').filter(Boolean).map(c => {
+                    const eqIdx = c.indexOf('=');
+                    const key = c.slice(0, eqIdx).trim();
+                    const rawValue = eqIdx !== -1 ? c.slice(eqIdx + 1).trim() : '';
+                    // URL 解码，解码失败则使用原始值
+                    let value = rawValue;
+                    try { value = decodeURIComponent(rawValue); } catch { /* keep raw */ }
+                    return [key, value];
+                })
+            );
+        }
+        return this._cookiesCache;
+    }
+
+    getCookie(key: string): string | null { return this.cookies[key] || null; }
+}
+
+export { BodyParser } from './body-parser.ts';
+export { MultipartParser } from './multipart-parser.ts';
+export type { UploadedFile, MultipartResult } from './multipart-parser.ts';

package/src/request/multipart-parser.ts

@@ -0,0 +1,360 @@
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import type { IncomingMessage } from 'node:http';
+import { HttpError } from '../errors/index.ts';
+import { parseLimit } from './body-parser.ts';
+import type { BodyParserConfig } from '../types.ts';
+
+/** 上传文件信息 */
+export interface UploadedFile {
+    fieldname: string;
+    filename: string;
+    mimetype: string;
+    filepath: string;
+    size: number;
+    buffer?: Buffer;
+}
+
+/** multipart 解析结果 */
+export interface MultipartResult {
+    fields: Record<string, string | string[]>;
+    files: UploadedFile[];
+}
+
+/** 内部：单个 part 的解析状态 */
+interface PartContext {
+    fieldname: string;
+    filename: string | null;
+    mimetype: string;
+    /** 小文件：buffer chunks；大文件：null（直接写磁盘） */
+    chunks: Buffer[] | null;
+    size: number;
+    /** 大文件的写入流 */
+    writeStream: fs.WriteStream | null;
+    filepath: string;
+}
+
+/**
+ * 流式 MultipartParser：边读取 chunk 边解析 multipart/form-data 请求体。
+ *
+ * 核心设计：
+ *   - 状态机驱动，不在内存中缓存完整请求体
+ *   - 文件数据通过 fs.createWriteStream 流式写入磁盘
+ *   - 小于 bufferLimit 的文件保留在内存 buffer 中
+ *   - 使用 Buffer.indexOf 快速扫描 boundary 标记
+ *   - 超限立即 destroy 连接
+ */
+export class MultipartParser {
+    private uploadLimit: number;
+    private uploadDir: string;
+    private keepExtensions: boolean;
+    private bufferLimit: number;
+
+    constructor(config: BodyParserConfig = {}) {
+        this.uploadLimit = parseLimit(config.uploadLimit ?? '10mb');
+        this.uploadDir = config.uploadDir || os.tmpdir();
+        this.keepExtensions = config.keepExtensions ?? false;
+        this.bufferLimit = parseLimit(config.uploadBufferLimit ?? '512kb');
+    }
+
+    async parse(req: IncomingMessage): Promise<MultipartResult> {
+        const contentType = (req.headers['content-type'] as string) || '';
+        const boundary = this._extractBoundary(contentType);
+        if (!boundary) throw new HttpError(400, 'Invalid multipart content-type: missing boundary');
+
+        const boundaryStr = '--' + boundary;
+        const searchBoundary = Buffer.from('\r\n' + boundaryStr);
+        const initialBoundary = Buffer.from(boundaryStr);
+        const endMarker = Buffer.from(boundaryStr + '--');
+
+        const result: MultipartResult = { fields: {}, files: [] };
+
+        let buffer = Buffer.alloc(0);
+        let totalSize = 0;
+        let headerStr = '';
+        let currentPart: PartContext | null = null;
+        let inHeaders = true;
+        let initialBoundaryFound = false;
+
+        // 处理完成后，将 field 写入 result
+        const commitField = (fieldname: string, value: string) => {
+            const existing = result.fields[fieldname];
+            if (existing === undefined) {
+                result.fields[fieldname] = value;
+            } else if (Array.isArray(existing)) {
+                existing.push(value);
+            } else {
+                result.fields[fieldname] = [existing, value];
+            }
+        };
+
+        // 创建 file part 上下文
+        const startFilePart = (fieldname: string, filename: string, mimetype: string): PartContext => {
+            const ext = this.keepExtensions && filename.includes('.') ? path.extname(filename) : '';
+            const tmpName = `tyno_${Date.now()}_${crypto.randomBytes(8).toString('hex')}${ext}`;
+            const filepath = path.join(this.uploadDir, tmpName);
+            return {
+                fieldname,
+                filename,
+                mimetype,
+                chunks: [],
+                size: 0,
+                writeStream: null,
+                filepath
+            };
+        };
+
+        // 解析 part 头，返回 { fieldname, filename, mimetype }
+        const parsePartHeaders = (headers: string): { fieldname: string; filename: string | null; mimetype: string } => {
+            const lines = headers.split('\r\n');
+            let fieldname = '';
+            let filename: string | null = null;
+            let mimetype = 'application/octet-stream';
+
+            for (const line of lines) {
+                const colonIdx = line.indexOf(':');
+                if (colonIdx === -1) continue;
+                const key = line.slice(0, colonIdx).trim().toLowerCase();
+                const value = line.slice(colonIdx + 1).trim();
+
+                if (key === 'content-disposition') {
+                    const nameMatch = /name="([^"]*)"/.exec(value);
+                    if (nameMatch) fieldname = nameMatch[1];
+                    const fileMatch = /filename="([^"]*)"/.exec(value);
+                    if (fileMatch) filename = fileMatch[1];
+                } else if (key === 'content-type') {
+                    mimetype = value;
+                }
+            }
+            return { fieldname, filename, mimetype };
+        };
+
+        // 从 buffer 中查找搜索标记，返回索引；未找到完整匹配返回 -1；部分匹配（可能跨 chunk）返回 -1
+        const findBoundary = (buf: Buffer, search: Buffer, startPos: number): number => {
+            return buf.indexOf(search, startPos);
+        };
+
+        // 开始处理流
+        for await (const rawChunk of req as AsyncIterable<Buffer>) {
+            const chunk = rawChunk as Buffer;
+            totalSize += chunk.length;
+            if (totalSize > this.uploadLimit) {
+                if (currentPart?.writeStream) {
+                    currentPart.writeStream.close();
+                    fs.promises.unlink(currentPart.filepath).catch(() => {});
+                }
+                req.destroy();
+                throw new HttpError(413, 'Upload too large');
+            }
+
+            buffer = Buffer.concat([buffer, chunk]);
+
+            // 如果正在写文件，流式处理
+            if (currentPart && currentPart.filename !== null) {
+                const part = currentPart;
+                // 在 buffer 中查找 boundary
+                const bidx = findBoundary(buffer, searchBoundary, 0);
+
+                if (bidx >= 0) {
+                    // 找到 boundary：把 boundary 前的数据写入文件
+                    if (bidx > 0) {
+                        const fileData = buffer.subarray(0, bidx);
+                        // 去掉末尾的 \r\n（如果有）
+                        let cleanLen = fileData.length;
+                        if (cleanLen >= 2 && fileData[cleanLen - 2] === 0x0d && fileData[cleanLen - 1] === 0x0a) {
+                            cleanLen -= 2;
+                        }
+                        if (cleanLen > 0) {
+                            if (part.writeStream) {
+                                part.writeStream.write(fileData.subarray(0, cleanLen));
+                            } else {
+                                part.chunks!.push(fileData.subarray(0, cleanLen));
+                                part.size += cleanLen;
+                            }
+                        }
+                    }
+
+                    // 完成文件
+                    if (part.writeStream) {
+                        part.writeStream.end();
+                        part.size = part.writeStream.bytesWritten;
+                        result.files.push({
+                            fieldname: part.fieldname,
+                            filename: part.filename || 'unknown',
+                            mimetype: part.mimetype,
+                            filepath: part.filepath,
+                            size: part.size
+                        });
+                    } else if (part.chunks && part.chunks.length > 0) {
+                        const buf = Buffer.concat(part.chunks);
+                        // 小文件仅保留在内存 buffer 中，不写磁盘
+                        result.files.push({
+                            fieldname: part.fieldname,
+                            filename: part.filename || 'unknown',
+                            mimetype: part.mimetype,
+                            filepath: part.filepath,
+                            size: buf.length,
+                            buffer: buf
+                        });
+                    }
+
+                    // 处理 boundary 之后的内容
+                    const after = buffer.subarray(bidx + searchBoundary.length);
+                    // 检查是否是结束标记
+                    if (after.length >= 2 && after[0] === 0x2d && after[1] === 0x2d) {
+                        // --boundary-- → 结束
+                        return result;
+                    }
+                    // 跳过 \r\n
+                    let dataStart = 0;
+                    if (after.length >= 2 && after[0] === 0x0d && after[1] === 0x0a) dataStart = 2;
+                    buffer = after.subarray(dataStart);
+                    currentPart = null;
+                    inHeaders = true;
+                    continue;
+                } else {
+                    // 未找到 boundary：尽量写入文件，保留尾部以防 boundary 跨 chunk
+                    const keepLen = searchBoundary.length + 4; // 保留足够检测 boundary+\r\n 的尾部
+                    if (buffer.length > keepLen) {
+                        const writeLen = buffer.length - keepLen;
+                        if (part.writeStream) {
+                            part.writeStream.write(buffer.subarray(0, writeLen));
+                        } else {
+                            part.chunks!.push(buffer.subarray(0, writeLen));
+                            part.size += writeLen;
+                            // 如果超过 bufferLimit，切换到磁盘
+                            if (part.size > this.bufferLimit && !part.writeStream) {
+                                // 将已有的 chunks 写入磁盘
+                                const ws = fs.createWriteStream(part.filepath);
+                                for (const c of part.chunks!) ws.write(c);
+                                part.writeStream = ws;
+                                part.chunks = null;
+                            }
+                        }
+                        buffer = buffer.subarray(writeLen);
+                    }
+                    continue;
+                }
+            }
+
+            // 未在处理文件：扫描 headers 和 field body
+            while (buffer.length > 0) {
+                if (!initialBoundaryFound) {
+                    // 查找初始 boundary
+                    if (buffer.length < initialBoundary.length + 2) break; // 等待更多数据
+                    if (buffer.indexOf(initialBoundary) === 0) {
+                        initialBoundaryFound = true;
+                        // 跳过 boundary 和后面的 \r\n
+                        let skip = initialBoundary.length;
+                        if (buffer.length > skip + 1 && buffer[skip] === 0x0d && buffer[skip + 1] === 0x0a) skip += 2;
+                        buffer = buffer.subarray(skip);
+                        inHeaders = true;
+                        continue;
+                    } else {
+                        // 非 multipart 数据：不应该发生
+                        throw new HttpError(400, 'Invalid multipart body: initial boundary not found');
+                    }
+                }
+
+                if (inHeaders) {
+                    // 查找 headers 结束标记 \r\n\r\n
+                    const headerEnd = buffer.indexOf('\r\n\r\n');
+                    if (headerEnd === -1) break; // 等待更多数据
+
+                    headerStr = buffer.subarray(0, headerEnd).toString();
+                    const { fieldname, filename, mimetype } = parsePartHeaders(headerStr);
+                    if (!fieldname) throw new HttpError(400, 'Missing field name in multipart part');
+
+                    // 跳过 headers 结束标记 \r\n\r\n，body 从其后开始
+                    buffer = buffer.subarray(headerEnd + 4);
+
+                    if (filename !== null) {
+                        // 文件 part
+                        currentPart = startFilePart(fieldname, filename, mimetype);
+                        inHeaders = false;
+                        break; // 文件处理在上面的文件循环中进行
+                    } else {
+                        // 字段 part：查找 boundary
+                        const bidx = findBoundary(buffer, searchBoundary, 0);
+                        if (bidx >= 0) {
+                            const fieldData = buffer.subarray(0, bidx);
+                            // 去掉末尾的 \r\n
+                            let cleanLen = fieldData.length;
+                            if (cleanLen >= 2 && fieldData[cleanLen - 2] === 0x0d && fieldData[cleanLen - 1] === 0x0a) {
+                                cleanLen -= 2;
+                            }
+                            const value = fieldData.subarray(0, cleanLen).toString();
+                            commitField(fieldname, value);
+
+                            const after = buffer.subarray(bidx + searchBoundary.length);
+                            if (after.length >= 2 && after[0] === 0x2d && after[1] === 0x2d) {
+                                return result;
+                            }
+                            let nextStart = 0;
+                            if (after.length >= 2 && after[0] === 0x0d && after[1] === 0x0a) nextStart = 2;
+                            buffer = after.subarray(nextStart);
+                            inHeaders = true;
+                            continue;
+                        } else {
+                            break; // 等待更多数据
+                        }
+                    }
+                }
+            }
+        }
+
+        // 流结束：处理未完成的部分
+        if (currentPart && currentPart.filename !== null) {
+            // 在剩余 buffer 中查找 boundary
+            const bidx = buffer.indexOf(searchBoundary);
+            let fileData: Buffer;
+            if (bidx >= 0) {
+                // 找到 boundary：提取 boundary 之前的文件数据
+                fileData = buffer.subarray(0, bidx);
+            } else {
+                // 未找到 boundary（异常情况）：使用全部数据，去掉末尾可能的 \r\n
+                fileData = buffer;
+            }
+            // 去掉末尾的 \r\n
+            let cleanLen = fileData.length;
+            if (cleanLen >= 2 && fileData[cleanLen - 2] === 0x0d && fileData[cleanLen - 1] === 0x0a) {
+                cleanLen -= 2;
+            }
+            if (cleanLen > 0) {
+                if (currentPart.writeStream) {
+                    currentPart.writeStream.write(fileData.subarray(0, cleanLen));
+                    currentPart.writeStream.end();
+                    currentPart.size = currentPart.writeStream.bytesWritten;
+                    result.files.push({
+                        fieldname: currentPart.fieldname,
+                        filename: currentPart.filename || 'unknown',
+                        mimetype: currentPart.mimetype,
+                        filepath: currentPart.filepath,
+                        size: currentPart.size
+                    });
+                } else if (currentPart.chunks) {
+                    currentPart.chunks.push(fileData.subarray(0, cleanLen));
+                    const buf = Buffer.concat(currentPart.chunks);
+                    // 小文件仅保留在内存 buffer 中，不写磁盘
+                    result.files.push({
+                        fieldname: currentPart.fieldname,
+                        filename: currentPart.filename || 'unknown',
+                        mimetype: currentPart.mimetype,
+                        filepath: currentPart.filepath,
+                        size: buf.length,
+                        buffer: buf
+                    });
+                }
+            }
+        }
+
+        return result;
+    }
+
+    private _extractBoundary(contentType: string): string | null {
+        const m = /boundary=(?:"([^"]+)"|([^;]+))/i.exec(contentType);
+        return m ? (m[1] || m[2]).trim() : null;
+    }
+}

package/src/request-global.ts

@@ -0,0 +1,31 @@
+import { requestStore } from './context.ts';
+
+/**
+ * 全局门面 Request 对象。
+ * 在任何地方直接使用 `request`，其背后会自动从 AsyncLocalStorage 获取当前请求的 Request Proxy。
+ */
+const requestProxy = new Proxy({} as Record<string, unknown>, {
+    get(_target, prop: string | symbol): unknown {
+        const req = requestStore.getStore();
+        if (!req) {
+            throw new Error(
+                'No active request context. Make sure you are inside an async middleware or the request lifecycle.'
+            );
+        }
+        return (req as unknown as Record<string | symbol, unknown>)[prop];
+    },
+    set(_target, prop: string | symbol, value: unknown): boolean {
+        const req = requestStore.getStore();
+        if (!req) throw new Error('No active request context');
+        (req as unknown as Record<string | symbol, unknown>)[prop] = value;
+        return true;
+    },
+    deleteProperty(_target, prop: string | symbol): boolean {
+        const req = requestStore.getStore();
+        if (!req) throw new Error('No active request context');
+        delete (req as unknown as Record<string | symbol, unknown>)[prop];
+        return true;
+    }
+});
+
+export default requestProxy;