qyani-web 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qyani-web",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Backend for the app",
   "main": "./dist/index.js",
   "author": "Qianrenni",
@@ -21,5 +21,6 @@
     "@types/node-forge": "^1.3.11",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3"
-  }
+  },
+  "files": ["dist", "package.json","demo","README.md","package-lock.json"]
 }

package/keys/cert.pem

@@ -1,19 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDDzCCAfegAwIBAgIBATANBgkqhkiG9w0BAQsFADBLMRIwEAYDVQQDEwlsb2Nh
-bGhvc3QxCzAJBgNVBAYTAkNOMRIwEAYDVQQKEwlRaWFucmVubmkxFDASBgNVBAsT
-C0RldmVsb3BtZW50MB4XDTI1MDUyMTAyMjAyN1oXDTI2MDUyMTAyMjAyN1owSzES
-MBAGA1UEAxMJbG9jYWxob3N0MQswCQYDVQQGEwJDTjESMBAGA1UEChMJUWlhbnJl
-bm5pMRQwEgYDVQQLEwtEZXZlbG9wbWVudDCCASIwDQYJKoZIhvcNAQEBBQADggEP
-ADCCAQoCggEBAOPPt4WzRj+yDuya3nlQjkG1ZhnVIpvzUp3YUzPd/Z4eJ9e+awVY
-+YcObS/1hm7A44IDGTjn9m08UzNm/PfFPqE2FM1ODLV0s6myBS/NBFc/G7UiKjbr
-HItznkehX+JTqm5gLu/45B4LaUtdPEmG5CYVTQa3dwypnQi4PaGMlfxmc1xzKe/K
-QDEnZ39TdTlsptSb02szYQZxHvugLKde+y82pCKg9Q/SPhb3PSJjeKg8LQTFLxmM
-lwmzUNSDDn/UzLaswcxLgs6wcEv422A7cR+tPL7PJ0T0cNJ2VySU/zH3WCSGr1Xn
-CFJnQwCtIZS0WQ/G5zUvM6PUpy21BoJaqhcCAwEAATANBgkqhkiG9w0BAQsFAAOC
-AQEARF0DvPQGHRt3waaUhFJGPNEeKrb+uCkl1c5i25SUPdcvfpa8nt6m06souMGK
-oziH6uJlt/WBwgQmVp402/nxyQhNX3SY+MBkvBZ+l3FaPKsjiotM3u3vW9K8/NXD
-/A4bKPie/TwurHSp5opRp9ITr15Jo1NRjRin0h0h9of0POgwEtbizuboU0sKM96g
-IIv4xAWJ31ww5jtuStB1saA05YiYnnqGhfJ02ShOcFTIstLYPXSi+wd858t+96pu
-A5sy9JotEJYOCGBzmQpf9tOlDHIFOvJz6inD0HOkiVtG/AjU7mlxGgAU8qbhBRZ+
-Met0g+B2/TlKNaZATdRn3jGkgQ==
------END CERTIFICATE-----

package/keys/key.pem

@@ -1,27 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEA48+3hbNGP7IO7JreeVCOQbVmGdUim/NSndhTM939nh4n175r
-BVj5hw5tL/WGbsDjggMZOOf2bTxTM2b898U+oTYUzU4MtXSzqbIFL80EVz8btSIq
-Nusci3OeR6Ff4lOqbmAu7/jkHgtpS108SYbkJhVNBrd3DKmdCLg9oYyV/GZzXHMp
-78pAMSdnf1N1OWym1JvTazNhBnEe+6Asp177LzakIqD1D9I+Fvc9ImN4qDwtBMUv
-GYyXCbNQ1IMOf9TMtqzBzEuCzrBwS/jbYDtxH608vs8nRPRw0nZXJJT/MfdYJIav
-VecIUmdDAK0hlLRZD8bnNS8zo9SnLbUGglqqFwIDAQABAoIBAARkD15RLMRIhczI
-qrYS4pMLUIWkm9n+pXPWZLrQsgqMppRGyXWdF+jNqIwZQuHlRN1Pevp4+hZz6F9K
-wmByLvlY0Kt+WsoFOaXxK57BaFktewwRiwJro1gKvp0Ufq50PLTg6gwFCOc4AsEJ
-nIJcSmRzhPxhUoxDbqaUNS06ckpJk+re1fYVgpdwmcLdSupTDDhzwa5hp8Kte83/
-Hy5Jb+5N88CA1FTltnhiH/b8ELjvUD7aC527MLjvumN0tbYG1WmRNmLsrt04Sh4a
-9Akk/Qir+WKQJ9HVnNSZzjyuMphA/cGgDc9mrsikvQxO/BJVdnBn5UhU+XyyEQIM
-eRVXEDUCgYEA9uW72s160l0YDgSSUbH1vZzrXeXFx9uc+O1aEWbTjVV5J7ln0+/T
-m4O49hxiiSx09caFRGN6dp6itXFSvuB1eydxEVteNQyXmrZ2dBrMATkicQ0bEGiR
-kN5eBXpj/E8dlUZYu2+OfSguhWawXd2S+Aust2xT9bonz5l7oTRSWasCgYEA7DXY
-ep85tU/Q0gE+50ezMd+AMp0bBGk74hDJzYxrOo+fRwSMsdl974jjWGWN4YiJ8MiT
-ywFvF4JQWM7z81QBbetAbW63o+kc2l4zgRdbm3mS/fs6nYANWbZJzVxqPgG0tIXJ
-0L8ZCcO8bykYnxp/Oah2qkiNDLtjmtt/qPcgfUUCgYA0yohxT3BMnKUxEh8rIq8V
-vQDCkgfJJRcaTr3sbJ0dYkJGkSk3Mtd/MBoTXZxgEkZr6ufB6Lddt6u4uiNkNuBH
-1fYiLPQmyat85DjNuJEYTdwkahX4WzOM008tQq8wWsZLjcAZS9AeyMGxunRJjcAI
-E475pUsKhqROilXZ8TMOgwKBgDSjx0uEYmrqj6HNT0RhcSjDIyGka1nvTb4SebaJ
-/Xd+fENqWyRjULJp8ihH8Xd6Yys6t9z8w9IcY2V3MVxfszXYwHHiw6AOmjR728R/
-/RVH4Z8iNqzU1aTRf975ImARJ0E3s4MGo0DO0xZ+tRL357Rku5U1N+HHfOoM0oVI
-FYB1AoGBALBmVXYclZuJsK3ZKjh+0UNGo41SnXkNLGaykAgXU35ljAZDonTyluJx
-jq98FwG7LqCiYdd8bGYvT5aIP8Rs7EsTqrIYjE179H/qHWqwrLxrcwdxUC42MeTr
-bX/8jsAyoez7rzC6nXkpoQ1G3kW3YoxLE72kNErnzuA6S+NciNnb
------END RSA PRIVATE KEY-----

package/src/config/type.ts

@@ -1,44 +0,0 @@
-import http from "http";
-/**
- * 文件信息
- * @param fieldname 字段名
- * @param filename  文件名
- * @param encoding  编码
- * @param mimetype  MIME类型
- * @param data      文件数据
- */
-export type FileInfo = {
-    fieldname: string;
-    filename: string;
-    encoding: string;
-    mimetype: string;
-    data: Buffer;
-};
-
-/**
- * 处理请求对象
- * @param query 查询参数
- * @param params 路由参数
- * @param body 请求体
- */
-export type ProcessRequest = {
-    query: Record<string, string|number|boolean>,
-    params: Record<string, string|number|boolean>,
-    body:{fields:Record<string, string|number|boolean>, files:FileInfo[]},
-} & http.IncomingMessage;
-
-/**
- * 中间件函数类型定义
- * @param req 请求对象
- * @param res 响应对象
- * @return 返回一个布尔值，表示是否结束请求
- */
-export type Middleware = (req: http.IncomingMessage, res: http.ServerResponse) => boolean|Promise<boolean>| undefined;
-
-/**
- * 请求处理函数类型定义
- * @param req 请求对象
- * @param res 响应对象
- * @return 返回一个布尔值，表示是否结束请求
- */
-export type Handler =  (req: http.IncomingMessage, res: http.ServerResponse) =>boolean|Promise<boolean>|undefined;

package/src/index.ts

@@ -1,252 +0,0 @@
-// app.js
-import https from 'https';
-import url from 'url';
-import GroupRoute from "./lib/group-route";
-import * as http from "http";
-import {Handler, Middleware} from "./config/type";
-
-
-export default class WebApp {
-    private routes: { method: string; url: string; chain: Middleware[] }[] = [];
-    private beforeRequestMiddleWares: Middleware[] = [];
-    private afterRequestMiddleWares: Middleware[] = [];
-
-    constructor() {}
-
-    /**
-     * 添加一个前置中间件
-     * @param middleware 中间件函数
-     * @returns 返回当前 WebApp 实例，支持链式调用
-     */
-    beforeRequest(middleware: Middleware): this {
-        if (typeof middleware !== 'function') {
-            throw new Error('Middleware must be a function');
-        }
-        if (this.beforeRequestMiddleWares.includes(middleware)) {
-            throw new Error('Middleware already exists');
-        }
-        this.beforeRequestMiddleWares.push(middleware);
-        return this;
-    }
-
-    /**
-     * 添加一个后置中间件
-     * @param middleware 中间件函数
-     * @returns 返回当前 WebApp 实例，支持链式调用
-     */
-    afterRequest(middleware: Middleware): this {
-        if (typeof middleware !== 'function') {
-            throw new Error('Middleware must be a function');
-        }
-        if (this.afterRequestMiddleWares.includes(middleware)) {
-            throw new Error('Middleware already exists');
-        }
-        this.afterRequestMiddleWares.push(middleware);
-        return this;
-    }
-
-    /**
-     * 注册一个路由
-     * @param method HTTP 方法，如 'GET', 'POST' 等
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     * @returns 返回当前 WebApp 实例，支持链式调用
-     */
-    request(method: string, url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register(method, url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 注册一个 GET 请求路由
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     * @returns 返回当前 WebApp 实例，支持链式调用
-     */
-    get(url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register('GET', url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 注册一个 POST 请求路由
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     * @returns 返回当前 WebApp 实例，支持链式调用
-     */
-    post(url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register('POST', url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 注册一个 PUT 请求路由
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     * @returns 返回当前 WebApp 实例，支持链式调用
-     */
-    put(url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register('PUT', url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 注册一个 DELETE 请求路由
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     * @returns 返回当前 WebApp 实例，支持链式调用
-     */
-    delete(url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register('DELETE', url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 注册一个路由组
-     * @param groupRoute 路由组实例
-     * @returns 返回当前 WebApp 实例，支持链式调用
-     */
-    registerGroupRoute(groupRoute: GroupRoute): this {
-        this.routes.push(...groupRoute.getRoutes());
-        return this;
-    }
-
-    /**
-     * 匹配路由参数
-     * @param routePath 路由路径
-     * @param requestPath 请求路径
-     * @returns 匹配的参数对象
-     */
-    matchRoute(routePath: string, requestPath: string): Record<string, string> | null {
-        const routeParts = routePath.split('/');
-        const requestParts = requestPath.split('/');
-
-        if (routeParts.length !== requestParts.length) return null;
-
-        const params: Record<string, string> = {};
-        for (let i = 0; i < routeParts.length; i++) {
-            if (routeParts[i] !== requestParts[i] && !routeParts[i].startsWith(':')) {
-                return null;
-            }
-            if (routeParts[i].startsWith(':')) {
-                const paramName = routeParts[i].slice(1);
-                params[paramName] = requestParts[i];
-            }
-        }
-
-        return params;
-    }
-
-    /**
-     * 处理请求
-     * @param req 请求对象
-     * @param res 请求响应对象
-     * @private
-     */
-    private async _handleRequest(req: http.IncomingMessage, res: http.ServerResponse) {
-        const parsedUrl = new url.URL(req.url ?? '', `http://${req.headers.host}`);
-        const path = parsedUrl.pathname;
-        const method = req.method;
-
-        // 标记是否结束处理
-        let handled: boolean | Promise<boolean> | undefined = false;
-        try {
-            //执行前置中间件
-            for (const mw of this.beforeRequestMiddleWares) {
-                if (handled !== true) handled = await mw(req, res);
-            }
-            if (handled) return;
-            // 查找匹配的路由
-            let matchedRoute: { method: string; url: string; chain: Middleware[] } | null = null
-            let params: Record<string, string> | null = null;
-
-            for (let route of this.routes) {
-                if (route.method === method) {
-                    params = this.matchRoute(route.url, path);
-                    if (params) {
-                        matchedRoute = route;
-                        break;
-                    }
-                }
-            }
-            if (params && matchedRoute) {
-                // 设置请求参数
-                (req as any).query = parsedUrl.searchParams;
-                (req as any).params = params;
-                for (const mw of matchedRoute.chain) {
-                    if (!handled) handled = await mw(req, res);
-                }
-            } else {
-                // 404
-                res.writeHead(404, {'Content-Type': 'application/json'});
-                res.end(JSON.stringify({error: 'Not Found'}));
-            }
-        } catch (error: unknown) {
-            // 500
-            res.writeHead(500, {'Content-Type': 'application/json'});
-            if (error instanceof Error) {
-                res.end(JSON.stringify({
-                    error: 'Internal Server Error',
-                    message: error.message,
-                }));
-                console.log(error.stack);
-            } else {
-                res.end(JSON.stringify({
-                    error: 'Internal Server Error',
-                    message: 'An unknown error occurred.',
-                }));
-            }
-        } finally {
-            //执行后置中间件
-            for (const mw of this.afterRequestMiddleWares) {
-                if (!handled) handled = await mw(req, res);
-            }
-        }
-    }
-
-    /**
-     * 启动服务器
-     * @param port 端口号
-     * @param callback 回调函数
-     * @param protocol  协议类型
-     * @param certs https证书
-     */
-    listen(port: number, callback: () => void,protocol:string = 'http',certs?:{cert:string,key:string}): void {
-        let server;
-        if (protocol !== 'https') {
-            server = http.createServer(this._handleRequest.bind(this));
-        }
-        else if (protocol === 'https' && certs) {
-            server = https.createServer(certs, this._handleRequest.bind(this));
-        }
-        else {
-            console.log('未找到证书文件，使用http协议启动');
-            server = http.createServer(this._handleRequest.bind(this));
-        }
-        server.listen(port, callback);
-    }
-
-    /**
-     * 内部方法，用于注册路由
-     * @param method HTTP 方法
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     */
-    private _register(method: string, url: string, handler: Handler, beforeRequest: Middleware[], afterRequest: Middleware[]): void {
-        // 构建完整的中间件链：beforeRequest + handler + afterRequest
-        const chain = [...beforeRequest, handler, ...afterRequest];
-        this.routes.push({method, url, chain});
-    }
-}

package/src/lib/group-route.ts

@@ -1,153 +0,0 @@
-import http from "http";
-
-/**
- * 中间件函数类型定义
- * @param req 请求对象
- * @param res 响应对象
- * @return 返回一个布尔值，表示是否结束请求
- */
-type Middleware = (req: http.IncomingMessage, res: http.ServerResponse) => boolean|Promise<boolean>| undefined;
-
-/**
- * 请求处理函数类型定义
- * @param req 请求对象
- * @param res 响应对象
- * @return 返回一个布尔值，表示是否结束请求
- */
-type Handler =  (req: http.IncomingMessage, res: http.ServerResponse) => boolean|Promise<boolean>|undefined;
-
-
-/**
- * GroupRoute 类用于组织和管理一组具有共同前缀的 HTTP 路由。
- * 支持在请求处理前后添加中间件，并支持链式调用。
- */
-export default class GroupRoute {
-    // 在请求处理前执行的中间件列表
-    private beforeRequestMiddleWares: Middleware[] = [];
-
-    // 在请求处理后执行的中间件列表
-    private afterRequestMiddleWares: Middleware[] = [];
-
-    // 注册的路由列表，包含 HTTP 方法、URL 和处理链
-    private routes: { method: string; url: string; chain: Middleware[] }[] = [];
-
-    /**
-     * 构造函数
-     * @param prefix 路由组的前缀，例如 "/api"
-     */
-    constructor(private readonly prefix: string) {}
-
-    /**
-     * 添加一个在请求处理前执行的中间件
-     * @param middleware 中间件函数
-     * @returns 返回当前 GroupRoute 实例，支持链式调用
-     */
-    beforeRequest(middleware: Middleware): this {
-        this.beforeRequestMiddleWares.push(middleware);
-        return this;
-    }
-
-    /**
-     * 添加一个在请求处理后执行的中间件
-     * @param middleware 中间件函数
-     * @returns 返回当前 GroupRoute 实例，支持链式调用
-     */
-    afterRequest(middleware: Middleware): this {
-        this.afterRequestMiddleWares.push(middleware);
-        return this;
-    }
-
-    /**
-     * 注册一个 GET 请求路由
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     * @returns 返回当前 GroupRoute 实例，支持链式调用
-     */
-    get(url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register('GET', this.prefix + url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 注册一个 POST 请求路由
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     * @returns 返回当前 GroupRoute 实例，支持链式调用
-     */
-    post(url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register('POST', this.prefix + url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 注册一个 PUT 请求路由
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     * @returns 返回当前 GroupRoute 实例，支持链式调用
-     */
-    put(url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register('PUT', this.prefix + url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 注册一个 DELETE 请求路由
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     * @returns 返回当前 GroupRoute 实例，支持链式调用
-     */
-    delete(url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register('DELETE', this.prefix + url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 通用方法，用于注册任意 HTTP 方法的路由
-     * @param method HTTP 方法，如 'GET', 'POST' 等
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     */
-    request(method: string, url: string, handler: Handler, beforeRequest: Middleware[] = [], afterRequest: Middleware[] = []): this {
-        this._register(method, url, handler, beforeRequest, afterRequest);
-        return this;
-    }
-
-    /**
-     * 内部方法，用于将路由信息注册到路由列表中
-     * @param method HTTP 方法
-     * @param url 路由路径
-     * @param handler 请求处理函数
-     * @param beforeRequest 在处理函数前执行的中间件数组
-     * @param afterRequest 在处理函数后执行的中间件数组
-     */
-    private _register(method: string, url: string, handler: Handler, beforeRequest: Middleware[], afterRequest: Middleware[]): void {
-        // 构建完整的中间件链：beforeRequestMiddleWares + beforeRequest + handler + afterRequest + afterRequestMiddleWares
-        const chain: Middleware[] = [
-            ...this.beforeRequestMiddleWares,
-            ...beforeRequest,
-            handler,
-            ...afterRequest,
-            ...this.afterRequestMiddleWares,
-        ];
-
-        this.routes.push({ method, url, chain });
-    }
-
-    /**
-     * 获取当前路由组的所有路由信息（可用于调试或注册到框架中）
-     * @returns 路由列表
-     */
-    getRoutes(): { method: string; url: string; chain: Middleware[] }[] {
-        return this.routes;
-    }
-}

package/src/lib/middleware/body-parser.ts

@@ -1,175 +0,0 @@
-// 解析 application/json
-/*
- * 解析 application/json
- * @param {string} rawBody - 待解析的 JSON 字符串
- * @returns {object} 解析后的 JSON 对象
- */
-import http from "http";
-import Bb from 'busboy'
-import {FileInfo, ProcessRequest} from "../../config/type";
-
-function parseJson(rawBody: string): {fields: Record<string, string>, files: FileInfo[]} {
-    try {
-        let result=JSON.parse(rawBody);
-        console.log("parseJson",result);
-        return {fields:result, files:[]};
-    } catch (e) {
-        throw new Error('Invalid JSON');
-    }
-}
-
-// 解析 application/x-www-form-urlencoded
- /*
- * 解析 application/x-www-form-urlencoded
- * @param {string} rawBody - 待解析的表单数据
- * @returns Record<string, string> 解析后的表单数据
-  */
-function parseForm(rawBody: string): { fields: Record<string, string>, files: FileInfo[] } {
-    const params = new URLSearchParams(rawBody);
-    const form: Record<string, string> = {};
-    for (const [key, value] of params.entries()) {
-        form[key] = value;
-    }
-    console.log("parseForm",form);
-    return { fields: form, files: []};
-}
-
-/*
- * 解析 multipart/form-data
- * @param {http.IncomingMessage} req - 请求对象
- * @returns {Promise<{fields: Record<string, string>, files: any[]}>} 解析结果
- */
-function parseMultipart(req:http.IncomingMessage) {
-    return new Promise<{fields: Record<string, string>, files: FileInfo[]}>((resolve, reject) => {
-        // const bb = import('busboy')({
-        //         headers: req.headers,
-        //         limits: {
-        //             fileSize:  10*1024*1024 ,// 最大 10MB
-        //             files:10
-        //         }
-        //                                 }
-        // );
-
-        const bb=Bb({
-            headers: req.headers,
-            limits: {
-                fileSize:  10*1024*1024 ,// 最大 10MB
-                files:10
-            }
-        })
-        const fields: Record<string, string> = {};
-        const files: FileInfo[] = [];
-
-        // 普通字段
-        bb.on('field', (name:string, value:string) => {
-            fields[name] = value;
-        });
-
-        // 文件字段
-        bb.on('file', (fieldname:string, file, info:{filename:string, mimeType:string, encoding:string}) => {
-            const { filename, mimeType, encoding } = info;
-            const chunks: Buffer[] = [];
-
-            console.log(`File [${fieldname}]: ${filename}, ${mimeType}`);
-            // ✅ 关键：监听 'limit' 事件
-            file.on('limit', () => {
-                req.unpipe(bb);
-                reject(new Error( `${filename}文件大小超出限制`));
-            });
-            file.on('data', (chunk) => {
-                chunks.push(chunk);
-            });
-
-            file.on('end', () => {
-                files.push({
-                    fieldname,
-                    filename,
-                    mimetype: mimeType,
-                    encoding,
-                    data: Buffer.concat(chunks)
-                });
-                console.log(`文件 [${fieldname}] 接收完成`);
-            });
-
-            file.on('error', (err) => {
-                reject(err);
-            });
-        });
-
-        // 完成解析
-        bb.on('finish', () => {
-            resolve({ fields, files });
-        });
-
-        // 错误处理
-        bb.on('error', (err) => {
-            reject(err);
-        });
-        // 文件数量超出限制
-        bb.on('filesLimit', () => {
-            req.unpipe(bb);
-            reject(new Error('文件数量超过限制'));
-        });
-
-        // 字段数量超出限制
-        bb.on('fieldsLimit', () => {
-            req.unpipe(bb);
-            reject(new Error('字段数量超过限制'));
-        });
-
-        // 管道输入
-        req.pipe(bb);
-    });
-}
-
-// 映射 Content-Type 到对应的解析函数
-const parserType=[   'application/json','application/x-www-form-urlencoded','multipart/form-data']
-
-/**
- * 解析请求体
- * @param req http.IncomingMessage 请求对象
- * @param res http.ServerResponse 响应对象
- * @returns {Promise<boolean>} 是否结束处理
- */
-export async function  bodyParser(req:http.IncomingMessage, res:http.ServerResponse) {
-
-    const contentType = req.headers['content-type'] || '';
-
-    (req as ProcessRequest).body=await new Promise<{ fields: Record<string, string>, files: FileInfo[] }>((resolve, reject) => {
-        const matchedType = parserType.find(type => type===contentType)
-
-        if (!matchedType) {
-            return resolve({fields:{}, files:[]});
-        }
-
-        if (matchedType === 'multipart/form-data') {
-            parseMultipart(req)
-                .then(data => resolve(data))
-                .catch(err => reject(err));
-        } else {
-
-            // 处理其他类型
-            let body: Buffer[] = [];
-            req.on('data', chunk => {
-                body.push(chunk);
-            });
-
-            req.on('end', () => {
-                const rawBody = Buffer.concat(body).toString();
-                try {
-                    const result = contentType==='application/json'?parseJson(rawBody):parseForm(rawBody);
-                    resolve(result);
-                } catch (e) {
-                    reject(e);
-                }
-            });
-
-            req.on('error', (err) => {
-                reject(err);
-            });
-        }
-
-    });
-
-    return false; // 继续执行下一个中间件
-}

package/src/lib/middleware/cors.ts

@@ -1,64 +0,0 @@
-// middlewares/cors.js
-/*
- * 跨域中间件配置项
- */
-import http from "http";
-
-type CorsOptions = {
-  origin?: string | string[];//允许的源
-  methods?: string[];//允许的方法
-  allowedHeaders?: string[];//允许的请求头
-  credentials?: boolean;//允许携带cookie
-};
-/*
- * 跨域中间件
- * @param options 跨域配置项
- * @returns 中间件函数
- */
-export  function cors(options: CorsOptions = {}) {
-    const {
-        origin = '*',
-        methods = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
-        allowedHeaders = ['Content-Type', 'Authorization'],
-        credentials = false,
-    } = options;
-
-    return function corsMiddleware(req: http.IncomingMessage, res: http.ServerResponse) {
-        const requestOrigin = req.headers.origin;
-
-        if (requestOrigin) {
-            let allowThisOrigin = false;
-
-            if (origin === '*') {
-                allowThisOrigin = true;
-            } else if (Array.isArray(origin)) {
-                allowThisOrigin = origin.some(host => host === requestOrigin);
-            }
-
-            if (allowThisOrigin) {
-                // 设置 CORS 响应头
-                res.setHeader('Access-Control-Allow-Origin', requestOrigin);
-
-                if (credentials) {
-                    res.setHeader('Access-Control-Allow-Credentials', 'true');
-                }
-                res.setHeader('Access-Control-Allow-Methods', methods.join(', '));
-                res.setHeader('Access-Control-Allow-Headers', allowedHeaders.join(', '));
-
-                // 处理 OPTIONS 预检请求
-                if (req.method === 'OPTIONS') {
-                    res.writeHead(204); // No Content
-                    res.end();
-                    return true; // 已处理
-                }
-            } else {
-                console.warn(`Blocked request from disallowed origin: ${requestOrigin}`);
-                res.writeHead(403, { 'Content-Type': 'text/plain' });
-                res.end('Forbidden');
-                return true;
-            }
-        }
-
-        return false; // 继续后续处理
-    };
-}

package/src/lib/middleware/logger.ts

@@ -1,95 +0,0 @@
-// middleware/logger.js
-
-/*
- * 获取当前时间
- * @return {string} 格式化后的时间字符串
- */
-import http from "http";
-import {Middleware} from "../../config/type";
-
-export function formatLocalTime(){
-    const date=new Date();
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const day = String(date.getDate()).padStart(2, '0');
-    const hours = String(date.getHours()).padStart(2, '0');
-    const minutes = String(date.getMinutes()).padStart(2, '0');
-    const seconds = String(date.getSeconds()).padStart(2, '0');
-
-    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
-}
-
-/*
- * 请求日志记录
- * @param {http.IncomingMessage} req 请求对象
- * @param {http.ServerResponse} res 响应对象
- * @return {boolean} 默认返回 false，表示继续执行后续逻辑
- */
-export const requestLogger = (req:http.IncomingMessage, res:http.ServerResponse) => {
-    const method = req.method;
-    const url = req.url;
-    const timestamp = formatLocalTime();
-
-    console.log(`[${timestamp}] ${req.headers.origin||''} request ${method} ${url} `);
-    return false; // 继续执行后续逻辑
-};
-
-/*
- * 响应日志记录
- * @param {http.IncomingMessage} req 请求对象
- * @param {http.ServerResponse} res 响应对象
- * @return {boolean} 默认返回 false，表示继续执行后续逻辑
- */
-export const responseLogger = (req:http.IncomingMessage, res:http.ServerResponse) => {
-    const startTime = process.hrtime();
-    // 保存原始 end 方法
-    const originalEnd = res.end;
-
-    // 覆盖 res.end 方法以捕获响应结束
-    res.end = function (this: typeof res, chunk?: any, encoding?: BufferEncoding | (() => void), callback?: () => void): typeof res {
-        const [seconds, nanoseconds] = process.hrtime(startTime);
-        const durationMs = Math.round(seconds * 1000 + nanoseconds / 1e6);
-
-        const statusCode = res.statusCode || 500;
-        const timestamp = formatLocalTime();
-
-        console.log(
-            `[${timestamp}] ${req.headers.origin||''} response ${req.method} ${req.url} ${statusCode} ${durationMs}ms`
-        );
-
-        return originalEnd.call(this, chunk, encoding as BufferEncoding, callback);
-    };
-    return false; // 继续执行后续逻辑
-};
-
-// function errorLoggerInjection(app){
-//     if (!app)
-//         throw new Error('app is required');
-//     // 所有路由注册前自动包装 handler
-//     app.routes = app.routes.map(route => ({
-//         ...route,
-//         handler: wrapHandler(route.handler)
-//     }));
-// }
-//
-// function wrapHandler(handler:Middleware) {
-//     return (req, res) => {
-//         Promise.resolve()
-//             .then(() => handler(req, res))
-//             .catch(error => {
-//                 const timestamp = formatLocalTime();
-//                 const method = req.method;
-//                 const url = req.url;
-//                 console.error(`[${timestamp}] ERROR ${method} ${url}`);
-//                 console.error('Error Stack:',error.stack);
-//                 if(!res.headersSent){
-//                     res.writeHead(500, { 'Content-Type': 'application/json' });
-//                 }
-//                 res.end(JSON.stringify({
-//                     error: 'Internal Server Error',
-//                     message: error.message
-//                 }));
-//             });
-//     };
-// }
-console.log('logger.js loaded')

package/src/lib/middleware/static-resources.ts

@@ -1,94 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import http from "http";
-/*
- * 解析文件类型
- * @param extension 文件扩展名
- * @returns string 文件类型
- */
-function getContentType(extname: string): string {
-    const map: Record<string, string>= {
-        '.html': 'text/html',
-        '.js': 'text/javascript',
-        '.css': 'text/css',
-        '.json': 'application/json',
-        '.png': 'image/png',
-        '.jpg': 'image/jpeg',
-        '.gif': 'image/gif',
-        '.svg': 'image/svg+xml',
-        '.txt': 'text/plain',
-        '.woff': 'font/woff',
-        '.woff2': 'font/woff2',
-        '.ttf': 'font/ttf',
-        '.eot': 'application/vnd.ms-fontobject',
-        '.mp3': 'audio/mpeg',
-        '.mp4': 'video/mp4',
-        '.wav': 'audio/wav',
-        '.pdf': 'application/pdf',
-        '.zip': 'application/zip',
-        '.doc': 'application/msword',
-        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-        '.xls': 'application/vnd.ms-excel',
-        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-        '.ppt': 'application/vnd.ms-powerpoint',
-        '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-        '.webp': 'image/webp'
-    };
-    return map[extname] || 'application/octet-stream';
-}
-
-
-/*
- * 静态资源配置项
- * @param prefix URL 前缀
- * @param rootDir 静态资源根目录
- */
-type StaticResourcesOptions = {
-    prefix?: string;
-    rootDir?: string;
-};
-/*
- * 静态资源中间件
- * @param options 配置项
- * @returns 返回一个中间件函数
- */
-export const staticResources = function (options: StaticResourcesOptions = {}){
-    const { prefix = '/public', // URL 前缀
-        rootDir = path.join(process.cwd(), prefix) // 默认 public 目录
-    } = options;
-    console.log('静态资源中间件已启动...', rootDir);
-    return async function (req: http.IncomingMessage, res: http.ServerResponse) {
-        const parsedUrl = new URL(req.url?? '', `http://${req.headers.host}`);
-        const pathname = parsedUrl.pathname;
-        // 检查是否匹配前缀
-        if (!pathname.startsWith(prefix)) {
-            return false; // 继续后续中间件
-        }
-        // 构建实际文件路径
-        const filePath = pathname.replace(prefix, '');
-        const fullPath = path.join(rootDir, filePath);
-        try {
-            const stats = await fs.promises.stat(fullPath);
-            if (!stats.isFile()) {
-                res.writeHead(404, { 'Content-Type': 'text/plain' });
-                res.end('Not Found');
-                return true; // 中断中间件链
-            }
-            const extname = path.extname(fullPath).toLowerCase();
-            const contentType = getContentType(extname);
-            res.writeHead(200, { 'Content-Type': contentType });
-            fs.createReadStream(fullPath).pipe(res);
-            return true; // 已响应，中断后续流程
-        }
-        catch (err:unknown) {
-            res.writeHead(404, { 'Content-Type': 'text/plain' });
-            res.end('Not Found');
-            if(err instanceof Error){
-                console.error('静态资源访问错误:', err.message);
-            }
-
-
-            return true; // 中断流程
-        }
-    };
-};

package/src/lib/middleware/validate.ts

@@ -1,169 +0,0 @@
-import { formatLocalTime } from './logger.js';
-import http from "http";
-import {ProcessRequest} from "../../config/type";
-
-/**
- * 字段验证规则类型定义
- */
-type ValidationRule = {
-    required?: boolean;  // 是否必填
-    optional?: boolean;  // 是否可选(与required互斥)
-    type?: 'string' | 'number' | 'boolean';  // 期望的类型
-    min?: number;        // 最小长度(仅字符串)
-    max?: number;        // 最大长度(仅字符串)
-    format?: 'email';    // 格式验证(目前只支持email)
-};
-
-/**
- * 验证配置类型定义
- * 可以对body、query、params分别设置验证规则
- */
-type ValidationOptions = {
-    [section: string]: Record<string, ValidationRule>;
-};
-
-/**
- * 获取字段值
- * @param section body部分
- * @param field 字段名
- * @param req   请求体
- * @returns 返回字段值
- */
-function getValue(section: string, field: string, req: ProcessRequest):string|null|number|boolean{
-    let value= null;
-    switch (section) {
-        case 'query':
-            value = req.query[field];
-            break;
-        case 'params':
-            value = req.params[field];
-            break;
-        case 'body':
-            value = req.body.fields[field];
-            break;
-        default:
-            break;
-    }
-    return value;
-}
-
-/**
- *
- */
-
-function setValue(section: string, field: string, value: number|boolean|string, req: ProcessRequest): void{
-    switch (section) {
-        case 'body':
-            req.body.fields[field] = value;
-            break;
-        case 'query':
-            req.query[field] = value;
-            break;
-        case 'params':
-            req.params[field] = value;
-            break;
-        default:
-            break;
-    }
-}
-/**
- * 参数验证中间件工厂函数
- * @param options 验证配置
- * @returns 返回一个中间件函数
- */
-export const  validation = (options: ValidationOptions) => {
-    return (req:http.IncomingMessage, res:http.ServerResponse) => {
-        const request=req as ProcessRequest;
-        const errors: string[] = [];
-        // 遍历每个需要校验的部分（body、query、params）
-        for (const [section, fields] of Object.entries(options)) {
-            let data= null;
-            switch (section){
-                case 'query':
-                    data = request.query;
-                    break;
-                case 'body':
-                    data = request.body.fields;
-                    break;
-                case 'params':
-                    data = request.params;
-                    break;
-                default:
-                    errors.push(`Invalid section: ${section}`);
-                    return;
-            }
-
-
-            if (!data) {
-                errors.push(`Invalid request section: ${section}`)
-                break;
-            }
-
-            // 遍历每个字段规则
-            for (const [field, rules] of Object.entries(fields)) {
-
-                let value= getValue(section, field, request);
-
-
-                // 判断是否为必填字段
-                if (rules.required === true && value === null) {
-                    errors.push(`"${field}" is required in ${section}`);
-                    continue;
-                }
-
-                // 如果是可选字段且未提供，则跳过后续检查
-                if (rules.optional === true && value === null) {
-                    continue;
-                }
-                // ======【关键改进】自动类型转换（仅 query / params）======
-                if ((section === 'query' || section === 'params') && value !== null) {
-                    if (rules.type === 'number') {
-                        const num = parseFloat(typeof value === "string" ? value :'error');
-                        if (!isNaN(num)) {
-                            setValue(section, field, num, request) // 写回原始对象
-                        }else{
-                            errors.push(`"${field}" must be a number in ${section} your's is ${value}`);
-                        }
-                    } else if (rules.type === 'boolean') {
-                        if (value === 'true') {
-                            setValue(section, field, true, request)
-                        } else if (value === 'false') {
-                            setValue(section, field, false, request);
-                        }else{
-                            errors.push(`"${field}" must be a boolean in ${section}`);
-                        }
-                    }
-                }
-
-                // 字符串长度校验
-                if (typeof value === 'string') {
-                    if (rules.min !== undefined && value.length < rules.min) {
-                        errors.push(`"${field}" must be at least ${rules.min} characters long`);
-                    }
-                    if (rules.max !== undefined && value.length > rules.max) {
-                        errors.push(`"${field}" must be at most ${rules.max} characters long`);
-                    }
-                }
-
-                // 格式校验（如 email）
-                if (rules.format === 'email'&& value !== null) {
-                    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-                    if (!emailRegex.test(typeof value === "string" ? value :'error')) {
-                        errors.push(`"${field}" must be a valid email address`);
-                    }
-                }
-            }
-        }
-
-        // 如果有错误，返回错误
-        if (errors.length > 0) {
-            res.writeHead(400, { 'Content-Type': 'application/json' })
-            res.end(JSON.stringify({ message: '参数校验失败', errors }))
-            console.log(`[${formatLocalTime()}] 参数校验失败: ${errors.join(', ')}`)
-            return true
-        }
-
-        // 否则继续下一个中间件
-        return false
-    };
-};

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "esModuleInterop": true,
-    "strict": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "moduleResolution": "node",
-    "resolveJsonModule": true,
-    "skipLibCheck": false,
-    "allowJs": true,
-  },
-  "include": ["src/**/*"]
-}