oox 0.3.1 → 0.3.3

package/bin/argv.js

@@ -1,3 +1,5 @@
+import * as FS from 'node:fs';
+import * as PATH from 'node:path';
 export function getAllEnvArgs() {
     const args = process.argv.slice(2);
     const env = {};
@@ -9,7 +11,14 @@ export function getAllEnvArgs() {
             env[arg.slice(1)] = true;
         }
         else if (!arg.includes('=')) {
-            env[arg] = true;
+            // index.js
+            const path = PATH.resolve(process.cwd(), arg);
+            if (FS.existsSync(path)) {
+                continue;
+            }
+            else {
+                env[arg] = true;
+            }
         }
         else {
             const index = arg.indexOf('=');

package/bin/configurer.js

@@ -19,6 +19,7 @@ function mergeFlatEnv(env) {
                 tmpEnv = tmpEnv[subKey];
             }
             tmpEnv[valueKey] = env[key];
+            delete env[key];
         }
     }
 }
@@ -32,12 +33,13 @@ async function readEnvFile(filePath) {
         else {
             const finalPath = path.resolve(filePath).replace(/\\/g, '/');
             env = await import(`file://${finalPath}`);
+            env = env.default || env;
         }
     }
     else {
         throw new Error('Env file not found: ' + filePath);
     }
-    return env.default || env;
+    return env;
 }
 export async function buildConfig(mergeEnv) {
     const env = Object.create(null);

package/bin/register.js

@@ -1,25 +1,11 @@
 import chalk from 'chalk';
 import * as oox from '../index.js';
-import { default as SocketIOModule } from '../modules/socketio/index.js';
 const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-function urlFormatter(url) {
-    let _url = SocketIOModule.genWebSocketUrl(url);
-    const urlObject = new URL(_url);
-    if (urlObject.pathname === '/' && !url.endsWith('/'))
-        _url += '/socket.io';
-    return _url;
-}
 async function connect(url, prevError = null) {
-    const socketio = oox.modules.get('socketio');
-    const { host } = oox.config;
-    const { port, path } = socketio.config;
-    const urlObject = new URL(url);
-    // check if url is self
-    if (urlObject.host === host && urlObject.port === String(port))
-        return;
+    const adapter = oox.rpcKeepAliveConnectionAdapters.get(oox.config.registryAdapter);
     try {
-        const socket = await socketio.connect(url);
-        onConnection(socket, url);
+        const connection = await adapter.open(url);
+        onConnection(connection, url);
     }
     catch (error) {
         if (!prevError)
@@ -28,19 +14,19 @@ async function connect(url, prevError = null) {
         connect(url, error);
     }
 }
-async function onConnection(socket, url) {
-    const { name } = socket.data;
-    socket.once('disconnect', async () => {
-        console.log(chalk.red('[Registry]'), `Service<${name}>`, chalk.underline.red(`${url}`), 'disconnected.');
+async function onConnection(connection, url) {
+    const { name } = connection.data;
+    connection.once('disconnect', async () => {
+        console.log(chalk.red('[Registry]'), `Service<${name}>`, chalk.underline.red(`${connection.data.url || url}`), 'disconnected.');
         await delay(1000);
         connect(url);
     });
-    console.log(chalk.green('[Registry]'), `Service<${name}>`, chalk.underline.green(`${url}`), 'connected.');
+    console.log(chalk.green('[Registry]'), `Service<${name}>`, chalk.underline.green(`${connection.data.url || url}`), 'connected.');
 }
 export async function registry(urls) {
     if ('string' === typeof urls)
         urls = [urls];
     for (const url of urls) {
-        connect(urlFormatter(url));
+        connect(url);
     }
 }

package/bin/starter.js

@@ -53,9 +53,9 @@ export async function startup() {
     console.log();
     console.log('Service', chalk.bold(`${oox.config.name}`), 'running.');
     if (http.config.enabled)
-        console.log('  at', chalk.underline.green(http.getUrl()));
+        console.log('  at', chalk.underline.green(http.getURL()));
     if (socketio.config.enabled)
-        console.log('  at', chalk.underline.green(socketio.getUrl()));
+        console.log('  at', chalk.underline.green(socketio.getURL()));
     console.log();
     // 服务注册
     if (config.registry)

package/index.js

@@ -3,6 +3,8 @@ import * as app from './app.js';
 import { getIPAddress } from './utils.js';
 import Module, { ModuleConfig } from './modules/module.js';
 import Modules from './modules/index.js';
+import { RPCKeepAliveConnection, rpcKeepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections } from './rpc-keepalive-connection.js';
+export { RPCKeepAliveConnection, rpcKeepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections };
 export { Module, ModuleConfig };
 export const modules = new Modules;
 export const { asyncStore, setMethods, getMethods, kvMethods, sourceKVMethods, call, execute, logger, on, once, off, emit, } = app;
@@ -24,6 +26,8 @@ export class Context extends app.Context {
     }
 }
 export class Config {
+    // 服务ID
+    id = randomUUID();
     // 服务名称
     name = 'local';
     // 服务列表路径
@@ -45,6 +49,10 @@ export class Config {
     origin = '';
     // 默认返回错误调用栈信息信息
     errorStack = true;
+    // 服务注册列表
+    registry = [];
+    // 服务注册适配器
+    registryAdapter = 'socketio';
 }
 export const config = new Config();
 let genTraceIdFunction = () => randomUUID();
@@ -78,55 +86,26 @@ export async function serve() {
 export async function stop() {
     await modules.stop();
 }
-export class RPCKeepAliveConnection {
-    data;
-    nativeConnection = null;
-    adapter = null;
-    constructor(adapter, nativeConnection, data) {
-        this.adapter = adapter;
-        this.nativeConnection = nativeConnection;
-        if (data)
-            this.data = data;
-    }
-}
-export const keepAliveConnections = new Map();
-export function getKeepAliveConnections(name) {
-    return keepAliveConnections.get(name) || new Map();
-}
-export function getKeepAliveConnection(name, id) {
-    const connections = keepAliveConnections.get(name);
-    if (!connections)
-        return null;
-    return connections.get(id);
-}
 export function addKeepAliveConnection(connection) {
-    const { name, id } = connection.data;
-    if (keepAliveConnections.has(name)) {
-        keepAliveConnections.get(name).set(id, connection);
-    }
-    else {
-        keepAliveConnections.set(name, new Map([[id, connection]]));
-    }
+    keepAliveConnections.add(connection);
 }
-export function removeKeepAliveConnection(name, id) {
-    if (name instanceof RPCKeepAliveConnection) {
-        id = name.data.id;
-        name = name.data.name;
+export function removeKeepAliveConnection(arg1, arg2) {
+    if (typeof arg1 === 'string') {
+        keepAliveConnections.remove(arg1, arg2);
+        enabledKeepAliveConnections.remove(arg1, arg2);
     }
-    if (keepAliveConnections.has(name)) {
-        const group = keepAliveConnections.get(name);
-        group.delete(id);
-        if (!group.size)
-            keepAliveConnections.delete(name);
+    else {
+        keepAliveConnections.remove(arg1);
+        enabledKeepAliveConnections.remove(arg1);
     }
 }
 /**
- * random connection select for default load balance policy
- * @param name service name
- * @returns selected connection
- */
+* random connection select for default load balance policy
+* @param name service name
+* @returns selected connection
+*/
 let loadBalancePolicy = (name) => {
-    const connections = keepAliveConnections.get(name);
+    const connections = enabledKeepAliveConnections.getConnectionsOfService(name);
     if (!connections || !connections.size)
         return null;
     const arrayConnections = Array.from(connections.values());
@@ -151,5 +130,5 @@ export async function rpc(arg1, action, params, context) {
     }
     else
         throw new Error(`Unknown rpc arg1<${arg1}>`);
-    return connection.adapter.rpc(connection.nativeConnection, action, params, context);
+    return connection.adapter.rpc(connection, action, params, context);
 }

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,11 +27,37 @@ export default class HTTPModule extends Module {
     name = 'http';
     config = new HTTPConfig;
     server = null;
-    getUrl() {
+    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}`;
+        return new URL(`${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);
@@ -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/modules/socketio/adapter.js

@@ -0,0 +1,158 @@
+import * as SocketIOClient from 'socket.io-client';
+import * as oox from '../../index.js';
+import { OOXEvent, genWebSocketURL, isWebSocketURL } from './utils.js';
+import { randomUUID } from 'node:crypto';
+export default class SocketIOAdapter {
+    /**
+     * 客户端发送连接列表
+     * @param datas
+     */
+    [OOXEvent.SYNC_CONNECTIONS](datas) {
+        for (const data of datas) {
+            if (data.name === oox.config.name)
+                continue;
+            if (!data.url || !isWebSocketURL(data.url))
+                continue;
+            const has = oox.keepAliveConnections.has(data.name, data.id);
+            if (has)
+                continue;
+            this.open(data.url).catch((error) => console.error(error));
+        }
+    }
+    bindClientConnectionEvents(connection) {
+        const socket = connection.nativeConnection;
+        socket.on(OOXEvent.CONNECTED, ({ id, name }) => {
+            connection.updateIdAndName(id, name);
+            connection.enabled = true;
+            socket.emit(OOXEvent.SYNC_CONNECTIONS, this[OOXEvent.SYNC_CONNECTIONS].bind(this));
+        });
+        socket.on(OOXEvent.DISABLED, () => {
+            connection.enabled = false;
+        });
+        socket.on('disconnect', (reason) => {
+            connection.emit('disconnect');
+            oox.removeKeepAliveConnection(connection);
+            socket.removeAllListeners();
+            socket.disconnect();
+        });
+        socket.on('connect', () => {
+            connection.emit('connect');
+        });
+        socket.on('connect_error', (error) => {
+            connection.emit('error', error);
+            oox.removeKeepAliveConnection(connection);
+            socket.removeAllListeners();
+            socket.disconnect();
+        });
+    }
+    newConnection(url) {
+        const { id, host, name } = oox.config;
+        const headers = {
+            'x-ip': host,
+            'x-caller': name,
+            'x-caller-id': id,
+        };
+        let mURL;
+        if ('string' === typeof url) {
+            mURL = genWebSocketURL(url);
+        }
+        else {
+            mURL = url;
+        }
+        const socket = SocketIOClient.io(mURL.origin, {
+            extraHeaders: headers,
+            path: mURL.pathname,
+            autoConnect: false,
+        });
+        const data = {
+            name: 'anonymous',
+            id: randomUUID(),
+            host: mURL.host,
+            url: mURL
+        };
+        const connection = new oox.RPCKeepAliveConnection(this, socket, data);
+        return connection;
+    }
+    async open(url) {
+        const connection = this.newConnection(url);
+        oox.addKeepAliveConnection(connection);
+        this.bindClientConnectionEvents(connection);
+        this.bindCall(connection);
+        await new Promise((resolve, reject) => {
+            connection.once('enabled', resolve);
+            connection.once('error', reject);
+            connection.once('disconnect', () => {
+                reject(new Error('disconnect'));
+            });
+            connection.nativeConnection.connect();
+        });
+        return connection;
+    }
+    async close(connection) {
+        connection.nativeConnection.disconnect();
+        return Promise.resolve();
+    }
+    /**
+     * socketio emit
+     */
+    async emit(socket, event, params) {
+        if (!socket.connected)
+            throw new Error('Socket not connected');
+        return await new Promise((resolve, reject) => {
+            const onError = (reason) => {
+                const message = 'string' === typeof reason ? reason : reason instanceof Error ? reason.message : 'connect error';
+                reject(new Error(message));
+            };
+            // RPC 执行时中断连接
+            socket.once('disconnect', onError);
+            socket.emit(event, ...params, (returns) => {
+                socket.offAny(onError);
+                resolve(returns);
+            });
+        });
+    }
+    /**
+     * RPC
+     */
+    async rpc(connection, action, params, context) {
+        if (!context)
+            context = oox.getContext();
+        const { success, error, body } = await this.emit(connection.nativeConnection, 'call', [action, params, context]);
+        if (success)
+            return body;
+        else if (error)
+            throw new Error(error.message);
+        else
+            throw new Error('[RPC] Unknown Error');
+    }
+    /**
+     * 绑定 call 事件
+     * @param connection
+     */
+    bindCall(connection) {
+        const { id, name, host } = connection.data;
+        const connectionContext = {
+            sourceIP: '',
+            ip: host,
+            caller: name,
+            callerId: id,
+            connection
+        };
+        connection.nativeConnection.on('call', async (action, params, context, callback) => {
+            if ('object' !== typeof context)
+                context = oox.genContext(connectionContext);
+            else
+                context = oox.genContext(Object.assign(context, connectionContext));
+            this.call(action, params, context, callback);
+        });
+    }
+    async call(action, params, context, callback) {
+        const returns = await oox.call(action, params, context);
+        if (returns.error && !oox.config.errorStack) {
+            // 不返回错误调用栈信息
+            delete returns.error.stack;
+        }
+        'function' === typeof callback && callback(returns);
+        return returns;
+    }
+}