oox 0.3.1 → 0.3.2

package/modules/http/index.js

@@ -1,6 +1,7 @@
 import * as http from 'node:http';
 import * as https from 'node:https';
 import { httpRequest, parseHTTPBody } from './utils.js';
+import Router from './router.js';
 import * as oox from '../../index.js';
 import Module, { ModuleConfig } from '../module.js';
 export class HTTPConfig extends ModuleConfig {
@@ -26,12 +27,38 @@ export default class HTTPModule extends Module {
     name = 'http';
     config = new HTTPConfig;
     server = null;
+    router = new Router();
     getUrl() {
         const { host } = oox.config;
         const { port, path } = this.config;
         const protocol = this.config.ssl.enabled ? `https:` : `http:`;
         return `${protocol}//${host}:${port}${path}`;
     }
+    // 注册GET路由
+    get(path, ...args) {
+        this.router.get(path, ...args);
+        return this;
+    }
+    // 注册POST路由
+    post(path, ...args) {
+        this.router.post(path, ...args);
+        return this;
+    }
+    // 注册PUT路由
+    put(path, ...args) {
+        this.router.put(path, ...args);
+        return this;
+    }
+    // 注册DELETE路由
+    delete(path, ...args) {
+        this.router.delete(path, ...args);
+        return this;
+    }
+    // 注册全局中间件
+    use(middleware) {
+        this.router.use(middleware);
+        return this;
+    }
     setConfig(config) {
         Object.assign(this.config, config);
         if (!config.hasOwnProperty('port')) {
@@ -118,7 +145,32 @@ export default class HTTPModule extends Module {
     async requestHandler(request, response) {
         if (!this.cors(request, response))
             return;
-        const url = new URL(request.url, request.headers.origin || 'http://localhost');
+        const url = new URL(request.url, `http://${request.headers.host || 'localhost'}`);
+        const method = request.method || 'GET';
+        // 尝试匹配路由
+        const matched = this.router.match(method, url.pathname);
+        if (matched) {
+            const req = this.router.createRequestObject(request, url);
+            const res = this.router.createResponseObject(response);
+            // 解析请求体
+            if (request.method !== 'GET' && request.method !== 'HEAD') {
+                try {
+                    req.body = await parseHTTPBody(request);
+                }
+                catch (error) {
+                    return this.respond(request, response, {
+                        success: false,
+                        error: {
+                            message: error.message,
+                            stack: error.stack
+                        }
+                    });
+                }
+            }
+            await this.router.handleRoute(matched.route, matched.params, req, res);
+            return;
+        }
+        // 回退到RPC调用
         if (url.pathname === this.config.path) {
             await this.call(request, response);
         }

package/modules/http/router.js

@@ -0,0 +1,205 @@
+export default class Router {
+    routes = new Map();
+    globalMiddleware = [];
+    // 注册GET路由
+    get(path, ...args) {
+        const { handler, middleware } = this.parseRouteArgs(args);
+        this.addRoute('GET', path, handler, middleware);
+    }
+    // 注册POST路由
+    post(path, ...args) {
+        const { handler, middleware } = this.parseRouteArgs(args);
+        this.addRoute('POST', path, handler, middleware);
+    }
+    // 注册PUT路由
+    put(path, ...args) {
+        const { handler, middleware } = this.parseRouteArgs(args);
+        this.addRoute('PUT', path, handler, middleware);
+    }
+    // 注册DELETE路由
+    delete(path, ...args) {
+        const { handler, middleware } = this.parseRouteArgs(args);
+        this.addRoute('DELETE', path, handler, middleware);
+    }
+    // 解析路由参数，支持多种传入方式
+    parseRouteArgs(args) {
+        let handler;
+        let middleware = [];
+        if (args.length === 0) {
+            throw new Error('No handler provided for route');
+        }
+        // 方式1: [handler] 或 [middlewareArray, handler]
+        if (args.length === 1) {
+            if (typeof args[0] === 'function') {
+                handler = args[0];
+            }
+            else {
+                throw new Error('Invalid route handler');
+            }
+        }
+        // 方式2: [handler, middlewareArray] 或 [middleware1, middleware2, handler] 或 [middlewareArray, handler]
+        else {
+            // 检查最后一个参数是否是函数（处理器）
+            if (typeof args[args.length - 1] === 'function') {
+                handler = args[args.length - 1];
+                // 前面的所有都是中间件
+                const middleArgs = args.slice(0, -1);
+                // 展平中间件数组
+                for (const arg of middleArgs) {
+                    if (Array.isArray(arg)) {
+                        middleware.push(...arg);
+                    }
+                    else if (typeof arg === 'function') {
+                        middleware.push(arg);
+                    }
+                }
+            }
+            // 检查第一个参数是否是函数
+            else if (typeof args[0] === 'function') {
+                handler = args[0];
+                // 后面的是中间件
+                const middleArgs = args.slice(1);
+                for (const arg of middleArgs) {
+                    if (Array.isArray(arg)) {
+                        middleware.push(...arg);
+                    }
+                    else if (typeof arg === 'function') {
+                        middleware.push(arg);
+                    }
+                }
+            }
+            else {
+                throw new Error('Invalid route arguments');
+            }
+        }
+        return { handler, middleware };
+    }
+    // 注册全局中间件
+    use(middleware) {
+        this.globalMiddleware.push(middleware);
+    }
+    // 注册特定路径的中间件
+    usePath(path, middleware) {
+        // 实现路径级中间件
+    }
+    // 添加路由
+    addRoute(method, path, handler, middleware = []) {
+        if (!this.routes.has(method)) {
+            this.routes.set(method, []);
+        }
+        // 编译路径为正则表达式，支持路径参数
+        const { regex, paramNames } = this.compilePath(path);
+        this.routes.get(method).push({
+            path,
+            method,
+            handler,
+            middleware,
+            regex,
+            paramNames
+        });
+    }
+    // 编译路径为正则表达式
+    compilePath(path) {
+        const paramNames = [];
+        const regexPattern = path
+            .replace(/:([^/]+)/g, (_, paramName) => {
+            paramNames.push(paramName);
+            return '([^/]+)';
+        })
+            .replace(/\//g, '\\/')
+            .replace(/\*/g, '.*');
+        return {
+            regex: new RegExp(`^${regexPattern}$`),
+            paramNames
+        };
+    }
+    // 匹配路由
+    match(method, path) {
+        const routes = this.routes.get(method) || [];
+        for (const route of routes) {
+            const match = path.match(route.regex);
+            if (match) {
+                const params = {};
+                route.paramNames.forEach((paramName, index) => {
+                    params[paramName] = match[index + 1];
+                });
+                return { route, params };
+            }
+        }
+        return null;
+    }
+    // 创建请求对象
+    createRequestObject(originalRequest, url) {
+        return {
+            originalRequest,
+            url,
+            method: originalRequest.method || 'GET',
+            path: url.pathname,
+            query: Object.fromEntries(url.searchParams),
+            params: {},
+            headers: originalRequest.headers,
+            body: null
+        };
+    }
+    // 创建响应对象
+    createResponseObject(originalResponse) {
+        let statusCode = 200;
+        return {
+            originalResponse,
+            status(code) {
+                statusCode = code;
+                return this;
+            },
+            json(data) {
+                const jsonString = JSON.stringify(data);
+                this.originalResponse.statusCode = statusCode;
+                this.originalResponse.setHeader('Content-Type', 'application/json');
+                this.originalResponse.setHeader('Content-Length', Buffer.byteLength(jsonString));
+                this.originalResponse.end(jsonString);
+            },
+            send(data) {
+                const dataString = typeof data === 'string' ? data : JSON.stringify(data);
+                this.originalResponse.statusCode = statusCode;
+                this.originalResponse.setHeader('Content-Type', 'text/plain');
+                this.originalResponse.setHeader('Content-Length', Buffer.byteLength(dataString));
+                this.originalResponse.end(dataString);
+            },
+            end(data) {
+                this.originalResponse.statusCode = statusCode;
+                this.originalResponse.end(data);
+            }
+        };
+    }
+    // 执行中间件
+    async executeMiddleware(middleware, req, res) {
+        for (const fn of middleware) {
+            let nextCalled = false;
+            const next = () => { nextCalled = true; };
+            const result = fn(req, res, next);
+            if (result instanceof Promise) {
+                await result;
+            }
+            if (!nextCalled) {
+                return false; // 中间件已结束响应
+            }
+        }
+        return true; // 所有中间件都已执行
+    }
+    // 处理路由请求
+    async handleRoute(route, params, req, res) {
+        req.params = params;
+        // 执行全局中间件
+        const globalMiddlewareContinue = await this.executeMiddleware(this.globalMiddleware, req, res);
+        if (!globalMiddlewareContinue)
+            return;
+        // 执行路由中间件
+        const routeMiddlewareContinue = await this.executeMiddleware(route.middleware, req, res);
+        if (!routeMiddlewareContinue)
+            return;
+        // 执行路由处理函数
+        const result = route.handler(req, res);
+        if (result instanceof Promise) {
+            await result;
+        }
+    }
+}

package/modules/http/utils.js

@@ -29,11 +29,12 @@ export async function parseHTTPBody(request) {
     // application/json; charset=utf-8
     if (contentType)
         contentType = contentType.split(';')[0].trim();
-    const contentSize = request.headers['content-length'];
-    if (!contentSize)
+    const contentLength = request.headers['content-length'];
+    if (!contentLength || contentLength === '0')
         return null;
-    const buffer = await stream2buffer(request, +contentSize || 0);
-    if (contentSize && buffer.length !== +contentSize)
+    const contentSize = +contentLength;
+    const buffer = await stream2buffer(request, contentSize);
+    if (buffer.length !== contentSize)
         throw new Error('Content-Length Incorrect');
     switch (contentType) {
         case 'application/json':

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oox",
-    "version": "0.3.1",
+    "version": "0.3.2",
     "description": "OOX Service Engine",
     "keywords": [
         "http",

package/types/modules/http/index.d.ts

@@ -1,4 +1,5 @@
 import * as http from 'node:http';
+import Router, { Middleware } from './router.js';
 import * as oox from '../../index.js';
 import Module, { ModuleConfig } from '../module.js';
 export declare class HTTPConfig extends ModuleConfig {
@@ -16,7 +17,13 @@ export default class HTTPModule extends Module {
     name: string;
     config: HTTPConfig;
     server: http.Server;
+    router: Router;
     getUrl(): string;
+    get(path: string, ...args: any[]): this;
+    post(path: string, ...args: any[]): this;
+    put(path: string, ...args: any[]): this;
+    delete(path: string, ...args: any[]): this;
+    use(middleware: Middleware): this;
     setConfig(config: HTTPConfig): void;
     getConfig(): HTTPConfig;
     /**

package/types/modules/http/router.d.ts

@@ -0,0 +1,49 @@
+import * as http from 'node:http';
+export type RouteHandler = (req: Request, res: Response) => Promise<any> | any;
+export type Middleware = (req: Request, res: Response, next: () => void) => Promise<any> | any;
+export interface Route {
+    path: string;
+    method: string;
+    handler: RouteHandler;
+    middleware: Middleware[];
+    regex: RegExp;
+    paramNames: string[];
+}
+export interface Request {
+    originalRequest: http.IncomingMessage;
+    url: URL;
+    method: string;
+    path: string;
+    query: Record<string, string>;
+    params: Record<string, string>;
+    headers: Record<string, string>;
+    body: any;
+}
+export interface Response {
+    originalResponse: http.ServerResponse;
+    status(code: number): Response;
+    json(data: any): void;
+    send(data: any): void;
+    end(data?: any): void;
+}
+export default class Router {
+    private routes;
+    private globalMiddleware;
+    get(path: string, ...args: any[]): void;
+    post(path: string, ...args: any[]): void;
+    put(path: string, ...args: any[]): void;
+    delete(path: string, ...args: any[]): void;
+    private parseRouteArgs;
+    use(middleware: Middleware): void;
+    usePath(path: string, middleware: Middleware): void;
+    private addRoute;
+    private compilePath;
+    match(method: string, path: string): {
+        route: Route;
+        params: Record<string, string>;
+    } | null;
+    createRequestObject(originalRequest: http.IncomingMessage, url: URL): Request;
+    createResponseObject(originalResponse: http.ServerResponse): Response;
+    private executeMiddleware;
+    handleRoute(route: Route, params: Record<string, string>, req: Request, res: Response): Promise<void>;
+}