qyani-web 1.0.2 → 1.0.3

package/demo/index.js

@@ -0,0 +1,18 @@
+// index.js
+import WebApp from '../dist/index.js'
+import {requestLogger} from "../dist/lib/middleware/logger.js";
+const app=new WebApp();
+app.beforeRequest(requestLogger)
+const port = 80;
+// 捕获未处理的异常
+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 http://localhost:${port}`);
+});

package/dist/index.js

@@ -1,16 +1,240 @@
-// 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}`);
-});
+// app.js
+import https from 'https';
+import url from 'url';
+import * as http from "http";
+export default 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 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 req 请求对象
+     * @param res 请求响应对象
+     * @private
+     */
+    async _handleRequest(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);
+            }
+        }
+    }
+    /**
+     * 启动服务器
+     * @param port 端口号
+     * @param callback 回调函数
+     * @param protocol  协议类型
+     * @param certs https证书
+     */
+    listen(port, callback, protocol = 'http', certs) {
+        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 在处理函数后执行的中间件数组
+     */
+    _register(method, url, handler, beforeRequest, afterRequest) {
+        // 构建完整的中间件链：beforeRequest + handler + afterRequest
+        const chain = [...beforeRequest, handler, ...afterRequest];
+        this.routes.push({ method, url, chain });
+    }
+}

package/dist/lib/{GroupRoute.js → group-route.js}

@@ -2,7 +2,7 @@
  * GroupRoute 类用于组织和管理一组具有共同前缀的 HTTP 路由。
  * 支持在请求处理前后添加中间件，并支持链式调用。
  */
-export class GroupRoute {
+export default class GroupRoute {
     /**
      * 构造函数
      * @param prefix 路由组的前缀，例如 "/api"

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "qyani-web",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Backend for the app",
-  "main": "index.js",
+  "main": "./dist/index.js",
   "author": "Qianrenni",
   "license": "MIT",
   "keywords": ["backend", "node","framework"],

package/src/index.ts

@@ -1,20 +1,252 @@
-// 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}`);
-});
+// 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/{GroupRoute.ts → group-route.ts}

@@ -21,7 +21,7 @@ type Handler =  (req: http.IncomingMessage, res: http.ServerResponse) => boolean
  * GroupRoute 类用于组织和管理一组具有共同前缀的 HTTP 路由。
  * 支持在请求处理前后添加中间件，并支持链式调用。
  */
-export class GroupRoute {
+export default class GroupRoute {
     // 在请求处理前执行的中间件列表
     private beforeRequestMiddleWares: Middleware[] = [];
 

package/dist/controllers/index.js

@@ -1,74 +0,0 @@
-"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;
-};