qyani-web 1.0.0 → 1.0.2

package/dist/config/type.js

@@ -0,0 +1 @@
+export {};

package/dist/controllers/index.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * 首页
+ * @param req
+ * @param res
+ */
+export const index = (req, res) => {
+    const request = req;
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+        message: 'Welcome to Qianrenni\'s WebApp FrameWork',
+        query: Object.fromEntries(request.query ?? {}),
+        params: request.params ?? {}
+    }));
+    return true;
+};
+/**
+ * 用户详情
+ * @param req
+ * @param res
+ */
+export const userDetail = (req, res) => {
+    const request = req;
+    // 确保 query 存在并转换为 Record 类型
+    const queryParams = request.query
+        ? Object.entries(request.query)
+        : {};
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+        id: request.params?.id,
+        query: queryParams
+    }));
+    return true;
+};
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// 替换 __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 确保 public 目录存在
+const PUBLIC_DIR = path.join(__dirname, '../public');
+fs.access(PUBLIC_DIR)
+    .then(() => { })
+    .catch(async () => {
+    await fs.mkdir(PUBLIC_DIR, { recursive: true }); // 添加 recursive 避免多级目录问题
+});
+/**
+ * 上传文件
+ * @param req
+ * @param res
+ */
+export const uploadFiles = async (req, res) => {
+    const request = req;
+    const data = request.body;
+    const savedFiles = [];
+    const keys = Object.keys(data?.fields);
+    if (data?.files) {
+        for (const file of data.files) {
+            const filePath = path.join(PUBLIC_DIR, file.filename);
+            await fs.writeFile(filePath, file.data);
+            savedFiles.push(file.filename);
+            console.log(`文件已保存至: ${filePath}`);
+        }
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+        status: 'success',
+        message: `${savedFiles.length} 个文件 ${keys.length} 参数上传成功`,
+        files: data?.files?.map(f => f.filename),
+        fields: keys
+    }));
+    return true;
+};

package/dist/index.js

@@ -0,0 +1,16 @@
+// index.js
+import('./routes/index.js');
+import app from './lib/app.js';
+const port = 443;
+// 捕获未处理的异常
+process.on('uncaughtException', (err) => {
+    console.error('[FATAL] Uncaught Exception:', err);
+    setTimeout(() => process.exit(1), 1000); // 安全退出
+});
+process.on('unhandledRejection', (reason, promise) => {
+    console.error('[WARNING] Unhandled Rejection at:', reason, 'Promise', promise);
+    setTimeout(() => process.exit(1), 1000);
+});
+app.listen(port, () => {
+    console.log(`Server running on https://localhost:${port}`);
+});

package/dist/lib/GroupRoute.js

@@ -0,0 +1,123 @@
+/**
+ * GroupRoute 类用于组织和管理一组具有共同前缀的 HTTP 路由。
+ * 支持在请求处理前后添加中间件，并支持链式调用。
+ */
+export class GroupRoute {
+    /**
+     * 构造函数
+     * @param prefix 路由组的前缀，例如 "/api"
+     */
+    constructor(prefix) {
+        this.prefix = prefix;
+        // 在请求处理前执行的中间件列表
+        this.beforeRequestMiddleWares = [];
+        // 在请求处理后执行的中间件列表
+        this.afterRequestMiddleWares = [];
+        // 注册的路由列表，包含 HTTP 方法、URL 和处理链
+        this.routes = [];
+    }
+    /**
+     * 添加一个在请求处理前执行的中间件
+     * @param middleware 中间件函数
+     * @returns 返回当前 GroupRoute 实例，支持链式调用
+     */
+    beforeRequest(middleware) {
+        this.beforeRequestMiddleWares.push(middleware);
+        return this;
+    }
+    /**
+     * 添加一个在请求处理后执行的中间件
+     * @param middleware 中间件函数
+     * @returns 返回当前 GroupRoute 实例，支持链式调用
+     */
+    afterRequest(middleware) {
+        this.afterRequestMiddleWares.push(middleware);
+        return this;
+    }
+    /**
+     * 注册一个 GET 请求路由
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     * @returns 返回当前 GroupRoute 实例，支持链式调用
+     */
+    get(url, handler, beforeRequest = [], afterRequest = []) {
+        this._register('GET', this.prefix + url, handler, beforeRequest, afterRequest);
+        return this;
+    }
+    /**
+     * 注册一个 POST 请求路由
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     * @returns 返回当前 GroupRoute 实例，支持链式调用
+     */
+    post(url, handler, beforeRequest = [], afterRequest = []) {
+        this._register('POST', this.prefix + url, handler, beforeRequest, afterRequest);
+        return this;
+    }
+    /**
+     * 注册一个 PUT 请求路由
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     * @returns 返回当前 GroupRoute 实例，支持链式调用
+     */
+    put(url, handler, beforeRequest = [], afterRequest = []) {
+        this._register('PUT', this.prefix + url, handler, beforeRequest, afterRequest);
+        return this;
+    }
+    /**
+     * 注册一个 DELETE 请求路由
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     * @returns 返回当前 GroupRoute 实例，支持链式调用
+     */
+    delete(url, handler, beforeRequest = [], afterRequest = []) {
+        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, url, handler, beforeRequest = [], afterRequest = []) {
+        this._register(method, url, handler, beforeRequest, afterRequest);
+        return this;
+    }
+    /**
+     * 内部方法，用于将路由信息注册到路由列表中
+     * @param method HTTP 方法
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     */
+    _register(method, url, handler, beforeRequest, afterRequest) {
+        // 构建完整的中间件链：beforeRequestMiddleWares + beforeRequest + handler + afterRequest + afterRequestMiddleWares
+        const chain = [
+            ...this.beforeRequestMiddleWares,
+            ...beforeRequest,
+            handler,
+            ...afterRequest,
+            ...this.afterRequestMiddleWares,
+        ];
+        this.routes.push({ method, url, chain });
+    }
+    /**
+     * 获取当前路由组的所有路由信息（可用于调试或注册到框架中）
+     * @returns 路由列表
+     */
+    getRoutes() {
+        return this.routes;
+    }
+}

package/dist/lib/app.js

@@ -0,0 +1,222 @@
+// app.js
+import https from 'https';
+import url from 'url';
+import certs from '../utils/certs.js';
+class WebApp {
+    constructor() {
+        this.routes = [];
+        this.beforeRequestMiddleWares = [];
+        this.afterRequestMiddleWares = [];
+    }
+    /**
+     * 添加一个前置中间件
+     * @param middleware 中间件函数
+     * @returns 返回当前 WebApp 实例，支持链式调用
+     */
+    beforeRequest(middleware) {
+        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) {
+        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, url, handler, beforeRequest = [], afterRequest = []) {
+        this._register(method, url, handler, beforeRequest, afterRequest);
+        return this;
+    }
+    /**
+     * 注册一个 GET 请求路由
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     * @returns 返回当前 WebApp 实例，支持链式调用
+     */
+    get(url, handler, beforeRequest = [], afterRequest = []) {
+        this._register('GET', url, handler, beforeRequest, afterRequest);
+        return this;
+    }
+    /**
+     * 注册一个 POST 请求路由
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     * @returns 返回当前 WebApp 实例，支持链式调用
+     */
+    post(url, handler, beforeRequest = [], afterRequest = []) {
+        this._register('POST', url, handler, beforeRequest, afterRequest);
+        return this;
+    }
+    /**
+     * 注册一个 PUT 请求路由
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     * @returns 返回当前 WebApp 实例，支持链式调用
+     */
+    put(url, handler, beforeRequest = [], afterRequest = []) {
+        this._register('PUT', url, handler, beforeRequest, afterRequest);
+        return this;
+    }
+    /**
+     * 注册一个 DELETE 请求路由
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     * @returns 返回当前 WebApp 实例，支持链式调用
+     */
+    delete(url, handler, beforeRequest = [], afterRequest = []) {
+        this._register('DELETE', url, handler, beforeRequest, afterRequest);
+        return this;
+    }
+    /**
+     * 内部方法，用于注册路由
+     * @param method HTTP 方法
+     * @param url 路由路径
+     * @param handler 请求处理函数
+     * @param beforeRequest 在处理函数前执行的中间件数组
+     * @param afterRequest 在处理函数后执行的中间件数组
+     */
+    _register(method, url, handler, beforeRequest, afterRequest) {
+        // 构建完整的中间件链：beforeRequest + handler + afterRequest
+        const chain = [...beforeRequest, handler, ...afterRequest];
+        this.routes.push({ method, url, chain });
+    }
+    /**
+     * 注册一个路由组
+     * @param groupRoute 路由组实例
+     * @returns 返回当前 WebApp 实例，支持链式调用
+     */
+    registerGroupRoute(groupRoute) {
+        this.routes.push(...groupRoute.getRoutes());
+        return this;
+    }
+    /**
+     * 匹配路由参数
+     * @param routePath 路由路径
+     * @param requestPath 请求路径
+     * @returns 匹配的参数对象
+     */
+    matchRoute(routePath, requestPath) {
+        const routeParts = routePath.split('/');
+        const requestParts = requestPath.split('/');
+        if (routeParts.length !== requestParts.length)
+            return null;
+        const params = {};
+        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 port 端口号
+     * @param callback 回调函数
+     */
+    listen(port, callback) {
+        const server = https.createServer(certs, async (req, res) => {
+            const parsedUrl = new url.URL(req.url ?? '', `http://${req.headers.host}`);
+            const path = parsedUrl.pathname;
+            const method = req.method;
+            // 标记是否结束处理
+            let handled = false;
+            try {
+                //执行前置中间件
+                for (const mw of this.beforeRequestMiddleWares) {
+                    if (handled !== true)
+                        handled = await mw(req, res);
+                }
+                if (handled)
+                    return;
+                // 查找匹配的路由
+                let matchedRoute = null;
+                let params = 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.query = parsedUrl.searchParams;
+                    req.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) {
+                // 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);
+                }
+            }
+        });
+        server.listen(port, callback);
+    }
+}
+export default new WebApp();

package/dist/lib/middleware/body-parser.js

@@ -0,0 +1,146 @@
+import Bb from 'busboy';
+function parseJson(rawBody) {
+    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) {
+    const params = new URLSearchParams(rawBody);
+    const form = {};
+    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) {
+    return new Promise((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 = {};
+        const files = [];
+        // 普通字段
+        bb.on('field', (name, value) => {
+            fields[name] = value;
+        });
+        // 文件字段
+        bb.on('file', (fieldname, file, info) => {
+            const { filename, mimeType, encoding } = info;
+            const chunks = [];
+            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, res) {
+    const contentType = req.headers['content-type'] || '';
+    req.body = await new Promise((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 = [];
+            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/dist/lib/middleware/cors.js

@@ -0,0 +1,42 @@
+/*
+ * 跨域中间件
+ * @param options 跨域配置项
+ * @returns 中间件函数
+ */
+export function cors(options = {}) {
+    const { origin = '*', methods = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'], allowedHeaders = ['Content-Type', 'Authorization'], credentials = false, } = options;
+    return function corsMiddleware(req, res) {
+        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/dist/lib/middleware/logger.js

@@ -0,0 +1,76 @@
+// middleware/logger.js
+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, res) => {
+    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, res) => {
+    const startTime = process.hrtime();
+    // 保存原始 end 方法
+    const originalEnd = res.end;
+    // 覆盖 res.end 方法以捕获响应结束
+    res.end = function (chunk, encoding, callback) {
+        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, 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/dist/lib/middleware/static-resources.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import path from 'path';
+/*
+ * 解析文件类型
+ * @param extension 文件扩展名
+ * @returns string 文件类型
+ */
+function getContentType(extname) {
+    const map = {
+        '.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 options 配置项
+ * @returns 返回一个中间件函数
+ */
+export const staticResources = function (options = {}) {
+    const { prefix = '/public', // URL 前缀
+    rootDir = path.join(process.cwd(), prefix) // 默认 public 目录
+     } = options;
+    console.log('静态资源中间件已启动...', rootDir);
+    return async function (req, res) {
+        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) {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('Not Found');
+            if (err instanceof Error) {
+                console.error('静态资源访问错误:', err.message);
+            }
+            return true; // 中断流程
+        }
+    };
+};

package/dist/lib/middleware/validate.js

@@ -0,0 +1,137 @@
+import { formatLocalTime } from './logger.js';
+/**
+ * 获取字段值
+ * @param section body部分
+ * @param field 字段名
+ * @param req   请求体
+ * @returns 返回字段值
+ */
+function getValue(section, field, req) {
+    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, field, value, req) {
+    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) => {
+    return (req, res) => {
+        const request = req;
+        const errors = [];
+        // 遍历每个需要校验的部分（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/dist/routes/index.js

@@ -0,0 +1,43 @@
+// routes/index.js
+import app from '../lib/app.js';
+import { index, uploadFiles, userDetail } from '../controllers/index.js';
+import { requestLogger, responseLogger } from '../lib/middleware/logger.js';
+import { validation } from '../lib/middleware/validate.js';
+import { staticResources } from '../lib/middleware/static-resources.js';
+import { cors } from '../lib/middleware/cors.js';
+import { bodyParser } from '../lib/middleware/body-parser.js';
+app.beforeRequest(requestLogger);
+app.beforeRequest(staticResources());
+app.beforeRequest(cors({
+    origin: ['http://localhost:300', 'https://www.bilibili.com'],
+    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization'],
+    credentials: true // 如果需要跨域带 cookie，设为 true
+}));
+app.beforeRequest(bodyParser);
+app.beforeRequest(responseLogger);
+app.get('/', index);
+app.get('/user/:id', userDetail, [validation({
+        params: {
+            id: {
+                type: 'number',
+                required: true
+            }
+        }
+    })]);
+app.post('/uploadFiles', uploadFiles);
+import { GroupRoute } from '../lib/GroupRoute.js';
+const groupRouter = new GroupRoute('/route1');
+app.registerGroupRoute(groupRouter);
+console.log('Routes loaded.');
+//
+// app.use(loggerMiddleware);             // 日志记录
+// app.use(corsMiddleware);              // CORS 控制
+// app.use(bodyLimitMiddleware);         // 请求体大小限制
+// app.use(bodyParserMiddleware);        // 请求体解析
+// app.use(authMiddleware);              // 身份认证
+// app.use(validationMiddleware);        // 参数校验
+// app.use(staticMiddleware);            // 静态资源服务
+// app.use(router);                      // 路由分发
+// app.use(errorLoggerMiddleware);       // 错误日志记录
+// app.use(errorHandlerMiddleware);      // 错误统一处理

package/dist/utils/certs.js

@@ -0,0 +1,11 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from "url";
+// 获取当前模块文件路径
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export default {
+    cert: readFileSync(path.join(__dirname, '../../keys/cert.pem')),
+    key: readFileSync(path.join(__dirname, '../../keys/key.pem'))
+};
+console.log('certs loaded');

package/dist/utils/tsl.js

@@ -0,0 +1,45 @@
+"use strict";
+// const forge = import('node-forge');
+// const fs = import('fs');
+//
+// // 生成密钥对
+// const keys = forge.pki.rsa.generateKeyPair(2048);
+//
+// // 创建证书
+// const cert = forge.pki.createCertificate();
+// cert.publicKey = keys.publicKey;
+// cert.serialNumber = '01';
+// cert.validity.notBefore = new Date();
+// cert.validity.notAfter = new Date();
+// cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
+//
+// // 设置主题和颁发者信息
+// const attrs = [{
+//     name: 'commonName',
+//     value: 'localhost'
+// }, {
+//     name: 'countryName',
+//     value: 'CN'
+// }, {
+//     name: 'organizationName',
+//     value: 'Qianrenni'
+// }, {
+//     name: 'organizationalUnitName',
+//     value: 'Development'
+// }];
+//
+// cert.setSubject(attrs);
+// cert.setIssuer(attrs); // 通常自签名证书 issuer == subject
+// cert.sign(keys.privateKey, forge.md.sha256.create()); // ✅ 正确的方法
+//
+// // 转换为 PEM 格式
+// const pem = {
+//     key: forge.pki.privateKeyToPem(keys.privateKey),
+//     cert: forge.pki.certificateToPem(cert)
+// };
+//
+// // 写入文件
+// fs.writeFileSync('key.pem', pem.key);
+// fs.writeFileSync('cert.pem', pem.cert);
+//
+// console.log('✅ 私钥和证书已生成：key.pem 和 cert.pem');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qyani-web",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Backend for the app",
   "main": "index.js",
   "author": "Qianrenni",

package/src/lib/app.ts

@@ -7,7 +7,7 @@ import * as http from "http";
 import {Handler, Middleware} from "../config/type";
 
 
-class WebApp {
+ class WebApp {
     private routes: { method: string; url: string; chain: Middleware[] }[]= [];
     private beforeRequestMiddleWares: Middleware[]= [];
     private afterRequestMiddleWares: Middleware[]= [];
@@ -228,5 +228,4 @@ class WebApp {
     }
 }
 
-const app= new WebApp();
-export default app;
+export default new WebApp();