oox 0.3.0-beta9 → 0.3.2

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

@@ -1,73 +1,75 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.httpRequest = exports.parseHTTPBody = exports.stream2buffer = void 0;
-const http = require("node:http");
-/**
- * Stream => Buffer
- */
-function stream2buffer(stream, totalLength = 0) {
-    return new Promise(function (resolve, reject) {
-        let buffers = [];
-        stream.on('error', reject);
-        if (totalLength) {
-            stream.on('data', function (data) { buffers.push(data); });
-        }
-        else {
-            stream.on('data', function (data) {
-                buffers.push(data);
-                totalLength += data.length;
-            });
-        }
-        stream.on('end', function () { resolve(Buffer.concat(buffers, totalLength)); });
-    });
-}
-exports.stream2buffer = stream2buffer;
-/**
- * Request => JSONObject
- */
-async function parseHTTPBody(request) {
-    if (request.method === 'GET')
-        return null;
-    let contentType = request.headers['content-type'];
-    // application/json; charset=utf-8
-    if (contentType)
-        contentType = contentType.split(';')[0].trim();
-    const contentSize = request.headers['content-length'];
-    const buffer = await stream2buffer(request, +contentSize || 0);
-    if (contentSize && buffer.length !== +contentSize)
-        throw new Error('Content-Length Incorrect');
-    const bodyString = buffer.toString();
-    if ('application/json' === contentType) {
-        return JSON.parse(bodyString);
-    }
-    else {
-        return bodyString;
-    }
-}
-exports.parseHTTPBody = parseHTTPBody;
-/**
- * http request
- */
-function httpRequest(url, options, body) {
-    return new Promise(function (resolve, reject) {
-        const request = http.request(url, options, async function (response) {
-            try {
-                const result = await parseHTTPBody(response);
-                resolve(result);
-            }
-            catch (error) {
-                const decoration = new Error(`${response.statusCode} - ${error.message}`);
-                reject(decoration);
-            }
-        });
-        request.on('error', reject);
-        if (body) {
-            request.method = 'POST';
-            request.setHeader('Content-Type', 'application/json');
-            request.setHeader('Content-Length', Buffer.byteLength(body));
-            request.write(body);
-        }
-        request.end();
-    });
-}
-exports.httpRequest = httpRequest;
+import * as http from 'node:http';
+import * as https from 'node:https';
+/**
+ * Stream => Buffer
+ */
+export function stream2buffer(stream, totalLength = 0) {
+    return new Promise(function (resolve, reject) {
+        let buffers = [];
+        stream.on('error', reject);
+        if (totalLength) {
+            stream.on('data', function (data) { buffers.push(data); });
+        }
+        else {
+            stream.on('data', function (data) {
+                buffers.push(data);
+                totalLength += data.length;
+            });
+        }
+        stream.on('end', function () { resolve(Buffer.concat(buffers, totalLength)); });
+    });
+}
+/**
+ * Request => JSONObject
+ */
+export async function parseHTTPBody(request) {
+    if (request.method === 'GET')
+        return null;
+    let contentType = request.headers['content-type'];
+    // application/json; charset=utf-8
+    if (contentType)
+        contentType = contentType.split(';')[0].trim();
+    const contentLength = request.headers['content-length'];
+    if (!contentLength || contentLength === '0')
+        return null;
+    const contentSize = +contentLength;
+    const buffer = await stream2buffer(request, contentSize);
+    if (buffer.length !== contentSize)
+        throw new Error('Content-Length Incorrect');
+    switch (contentType) {
+        case 'application/json':
+            return JSON.parse(buffer.toString());
+        case 'text/plain':
+            return buffer.toString();
+        default:
+            return buffer;
+    }
+}
+/**
+ * http request
+ */
+export function httpRequest(url, options, body) {
+    return new Promise(function (resolve, reject) {
+        const urlObj = typeof url === 'string' ? new URL(url) : url;
+        const protocol = urlObj.protocol;
+        const client = protocol === 'https:' ? https : http;
+        const request = client.request(url, options, async function (response) {
+            try {
+                const result = await parseHTTPBody(response);
+                resolve(result);
+            }
+            catch (error) {
+                const decoration = new Error(`${response.statusCode} - ${error.message}`);
+                reject(decoration);
+            }
+        });
+        request.on('error', reject);
+        if (body) {
+            request.method = 'POST';
+            request.setHeader('Content-Type', 'application/json');
+            request.setHeader('Content-Length', Buffer.byteLength(body));
+            request.write(body);
+        }
+        request.end();
+    });
+}

package/modules/index.js

@@ -1,88 +1,86 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const module_1 = require("./module");
-const http_1 = require("./http");
-const socketio_1 = require("./socketio");
-class Modules extends module_1.default {
-    /**
-     * the module unique name
-     */
-    name = 'oox:modules';
-    /**
-     * FIFO queue for modules starting
-     */
-    #queue = [];
-    /**
-     * all modules map
-     */
-    #map = new Map();
-    /**
-     * all builtin modules
-     */
-    builtins = {
-        http: new http_1.default,
-        socketio: new socketio_1.default,
-    };
-    constructor() {
-        super();
-        this.add(this.builtins.http);
-        this.add(this.builtins.socketio);
-    }
-    add(module) {
-        if (!module.name || 'string' !== typeof module.name)
-            throw new Error(`Module<${module.name}> has noname`);
-        if (this.#map.has(module.name))
-            throw new Error(`Module<${module.name}> has exists`);
-        this.#map.set(module.name, module);
-        this.#queue.push(module);
-        return this;
-    }
-    get(name) {
-        return this.#map.get(name);
-    }
-    async remove(name) {
-        const module = this.get(name);
-        if (!module)
-            return;
-        await module.stop();
-        const index = this.#queue.indexOf(module);
-        this.#queue.splice(index, 1);
-        this.#map.delete(name);
-    }
-    setConfig(config) {
-        for (const module of this.#queue) {
-            if (module.name in config) {
-                const moduleConfig = config[module.name];
-                if (moduleConfig) {
-                    module.setConfig(moduleConfig);
-                }
-                else {
-                    module.setConfig({ disabled: true });
-                }
-            }
-            else {
-                module.setConfig({});
-            }
-            config[module.name] = module.getConfig();
-        }
-    }
-    async serve() {
-        try {
-            for (const module of this.#queue) {
-                if (!module.getConfig().disabled) {
-                    await module.serve();
-                }
-            }
-        }
-        catch (error) {
-            await this.stop();
-            throw error;
-        }
-    }
-    async stop() {
-        for (const module of this.#queue) {
-            await module.stop();
-        }
-    }
-}
-exports.default = Modules;
+import Module from './module.js';
+import HTTP from './http/index.js';
+import SocketIO from './socketio/index.js';
+export default class Modules extends Module {
+    /**
+     * the module unique name
+     */
+    name = 'oox:modules';
+    /**
+     * FIFO queue for modules starting
+     */
+    #queue = [];
+    /**
+     * all modules map
+     */
+    #map = new Map();
+    /**
+     * all builtin modules
+     */
+    builtins = {
+        http: new HTTP,
+        socketio: new SocketIO,
+    };
+    constructor() {
+        super();
+        this.add(this.builtins.http);
+        this.add(this.builtins.socketio);
+    }
+    add(module) {
+        if (!module.name || 'string' !== typeof module.name)
+            throw new Error(`Module<${module.name}> has noname`);
+        if (this.#map.has(module.name))
+            throw new Error(`Module<${module.name}> has exists`);
+        this.#map.set(module.name, module);
+        this.#queue.push(module);
+        return this;
+    }
+    get(name) {
+        return this.#map.get(name);
+    }
+    async remove(name) {
+        const module = this.get(name);
+        if (!module)
+            return;
+        await module.stop();
+        const index = this.#queue.indexOf(module);
+        this.#queue.splice(index, 1);
+        this.#map.delete(name);
+    }
+    setConfig(config) {
+        for (const module of this.#queue) {
+            if (module.name in config) {
+                const moduleConfig = config[module.name];
+                if ('boolean' === typeof moduleConfig) {
+                    // eg: http=yes/no
+                    module.setConfig({ enabled: moduleConfig });
+                }
+                else {
+                    module.setConfig(moduleConfig);
+                }
+            }
+            else {
+                module.setConfig({ enabled: true });
+            }
+            config[module.name] = module.getConfig();
+        }
+    }
+    async serve() {
+        try {
+            for (const module of this.#queue) {
+                if (module.getConfig().enabled) {
+                    await module.serve();
+                }
+            }
+        }
+        catch (error) {
+            await this.stop();
+            throw error;
+        }
+    }
+    async stop() {
+        for (const module of this.#queue) {
+            await module.stop();
+        }
+    }
+}

package/modules/module.js

@@ -1,16 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleConfig = void 0;
-class ModuleConfig {
-    disabled = false;
-}
-exports.ModuleConfig = ModuleConfig;
-class Module {
-    config;
-    name;
-    setConfig(config) { }
-    getConfig() { return this.config; }
-    async serve() { }
-    async stop() { }
-}
-exports.default = Module;
+export class ModuleConfig {
+    enabled = true;
+}
+export default class Module {
+    config;
+    name;
+    setConfig(config) { }
+    getConfig() { return this.config; }
+    async serve() { }
+    async stop() { }
+}