qyani-web 1.0.0

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

@@ -0,0 +1,175 @@
+// 解析 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

@@ -0,0 +1,64 @@
+// 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

@@ -0,0 +1,95 @@
+// 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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,169 @@
+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/src/public/html/index.html

@@ -0,0 +1,11 @@
+<!-- public/index.html -->
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <title>Static Page</title>
+</head>
+<body>
+<h1>Hello from static file!</h1>
+</body>
+</html>

package/src/routes/index.ts

@@ -0,0 +1,51 @@
+// 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/src/utils/certs.ts

@@ -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');