oox 0.3.3 → 0.3.5

package/modules/http/index.js

@@ -1,10 +1,11 @@
 import * as http from 'node:http';
 import * as https from 'node:https';
-import { httpRequest, parseHTTPBody } from './utils.js';
+import { 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 {
+import Module from '../module.js';
+export class HTTPConfig {
+    enabled = true;
     // listen port
     port = 0;
     // service path
@@ -80,9 +81,9 @@ export default class HTTPModule extends Module {
         if (ssl.enabled) {
             const fs = await import('node:fs');
             const options = {
-                key: ssl.key ? fs.readFileSync(ssl.key) : null,
-                cert: ssl.cert ? fs.readFileSync(ssl.cert) : null,
-                ca: ssl.ca ? fs.readFileSync(ssl.ca) : null
+                key: ssl.key ? fs.readFileSync(ssl.key) : undefined,
+                cert: ssl.cert ? fs.readFileSync(ssl.cert) : undefined,
+                ca: ssl.ca ? fs.readFileSync(ssl.ca) : undefined
             };
             if (!options.key || !options.cert) {
                 throw new Error('HTTPS enabled but missing key or cert');
@@ -101,16 +102,18 @@ export default class HTTPModule extends Module {
     /**
      * stop http service
      */
-    stop() {
-        if (this.server && this.server.listening)
-            return new Promise((resolve, reject) => {
-                this.server.close(function (error) {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve();
-                });
+    async stop() {
+        const { server } = this;
+        if (!server || !server.listening)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            server.close(function (error) {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
             });
+        });
     }
     /**
      * browser cross origin
@@ -120,9 +123,14 @@ export default class HTTPModule extends Module {
         const origin = this.config.origin;
         const requestOrigin = request.headers.origin;
         if (origin && requestOrigin) {
-            if (origin === '*' ||
-                origin === requestOrigin ||
-                (Array.isArray(origin) && origin.includes(requestOrigin))) {
+            let allow = false;
+            if ('string' === typeof origin) {
+                allow = origin === '*' || new RegExp(origin).test(requestOrigin);
+            }
+            else if (Array.isArray(origin)) {
+                allow = origin.some(item => item === '*' || new RegExp(item).test(requestOrigin));
+            }
+            if (allow) {
                 response.setHeader('Access-Control-Allow-Origin', requestOrigin);
                 response.setHeader('Vary', 'Origin');
             }
@@ -132,7 +140,7 @@ export default class HTTPModule extends Module {
                 return false;
             }
             response.setHeader('Access-Control-Max-Age', 3600);
-            response.setHeader('Access-Control-Allow-Headers', 'x-caller,content-type');
+            response.setHeader('Access-Control-Allow-Headers', 'x-caller,x-token,content-type');
             response.setHeader('Access-Control-Allow-Methods', '*');
         }
         if (request.method === 'OPTIONS') {
@@ -143,9 +151,7 @@ export default class HTTPModule extends Module {
         return true;
     }
     async requestHandler(request, response) {
-        if (!this.cors(request, response))
-            return;
-        const url = new URL(request.url, `http://${request.headers.host || '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);
@@ -170,6 +176,9 @@ export default class HTTPModule extends Module {
             await this.router.handleRoute(matched.route, matched.params, req, res);
             return;
         }
+        // 内置cors仅处理RPC请求
+        if (!this.cors(request, response))
+            return;
         // 回退到RPC调用
         if (url.pathname === this.config.path) {
             await this.call(request, response);
@@ -199,6 +208,24 @@ export default class HTTPModule extends Module {
      * HTTP-RPC服务器请求监听方法
      */
     async call(request, response) {
+        // global unique id
+        const traceId = String(request.headers['x-trace-id'] || '');
+        // service name, required
+        const caller = String(request.headers['x-caller'] || 'anonymous');
+        // client ip or caller service ip
+        const ip = String(request.headers['x-real-ip'] || request.socket.remoteAddress || '');
+        // startup client ip
+        const sourceIP = String(request.headers['x-source-ip'] || request.socket.remoteAddress || '');
+        // check token
+        const token = String(request.headers['x-token'] || '');
+        const { allow, reason } = oox.checkAllow(ip, caller, token);
+        if (!allow)
+            return this.respond(request, response, {
+                success: false,
+                error: {
+                    message: reason
+                }
+            });
         let callArgs = Object.create(null);
         try {
             callArgs = await this.getCallArgsFromRequest(request);
@@ -212,14 +239,6 @@ export default class HTTPModule extends Module {
                 }
             });
         }
-        // global unique id
-        const traceId = String(request.headers['x-trace-id'] || '');
-        // service name, required
-        const caller = String(request.headers['x-caller'] || 'anonymous');
-        // client ip or caller service ip
-        const ip = String(request.headers['x-ip'] || request.socket.remoteAddress || '');
-        // startup client ip
-        const sourceIP = String(request.headers['x-real-ip'] || '');
         const { action, params = [] } = callArgs;
         const context = oox.genContext({ traceId, caller, sourceIP, ip, callerId: '' });
         const format = await oox.call(action, params, context);
@@ -237,15 +256,15 @@ export default class HTTPModule extends Module {
         try {
             returnsString = JSON.stringify(returns);
         }
-        catch ({ message, stack }) {
+        catch (error) {
             delete returns.body;
             returns.success = false;
             returns.error = {
-                message
+                message: error.message
             };
             if (oox.config.errorStack) {
                 // 返回错误调用栈信息
-                returns.error.stack = stack;
+                returns.error.stack = error.stack;
             }
             returnsString = JSON.stringify(returns);
         }
@@ -253,34 +272,4 @@ export default class HTTPModule extends Module {
         response.setHeader('Content-Length', Buffer.byteLength(returnsString));
         response.end(returnsString);
     }
-    /**
-     * HTTP RPC
-     */
-    async rpc(url, action, params, context) {
-        if (!context || !context.traceId) {
-            context = oox.getContext();
-        }
-        const { traceId, caller, sourceIP } = context;
-        const headers = {
-            'Content-Type': 'application/json',
-            'x-trace-id': String(traceId),
-        };
-        if (caller)
-            headers['x-caller'] = String(caller);
-        if (sourceIP)
-            headers['x-real-ip'] = sourceIP;
-        // headers [ 'x-ip' ] = getIPAddress ( 4 ) [ 0 ]
-        const format = await httpRequest(url, {
-            headers
-        }, JSON.stringify({ action, params }));
-        if ('string' === typeof format)
-            throw new Error(format);
-        const { success, error, body } = format;
-        if (success)
-            return body;
-        else if (error)
-            throw new Error(error.message);
-        else
-            throw new Error('[RPC] Unknown Error');
-    }
 }

package/modules/http/router.js

@@ -84,12 +84,17 @@ export default class Router {
     }
     // 添加路由
     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({
+        let routes = [];
+        if (this.routes.has(method)) {
+            routes = this.routes.get(method) || [];
+        }
+        else {
+            routes = [];
+            this.routes.set(method, routes);
+        }
+        routes.push({
             path,
             method,
             handler,

package/modules/index.js

@@ -1,86 +1,90 @@
-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);
-                }
+/**
+ * FIFO queue for modules starting
+ */
+export const queue = [];
+/**
+ * all modules map
+ */
+export const map = new Map();
+/**
+ * add module to modules queue
+ */
+export function add(module) {
+    if (!module.name || 'string' !== typeof module.name)
+        throw new Error(`Module<${module.name}> has noname`);
+    if (map.has(module.name))
+        throw new Error(`Module<${module.name}> has exists`);
+    map.set(module.name, module);
+    queue.push(module);
+}
+/**
+ * get module by name
+ */
+export function get(name) {
+    return map.get(name) || null;
+}
+export async function remove(name) {
+    const module = map.get(name);
+    if (!module)
+        return;
+    await module.stop();
+    const index = queue.indexOf(module);
+    queue.splice(index, 1);
+    map.delete(name);
+}
+/**
+ * set modules config
+ */
+export function setConfig(config) {
+    for (const module of 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({ enabled: true });
+                module.setConfig(moduleConfig);
             }
-            config[module.name] = module.getConfig();
         }
+        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();
-                }
+}
+/**
+ * serve modules
+ */
+export async function serve() {
+    try {
+        for (const module of 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();
-        }
+    catch (error) {
+        await stop();
+        throw error;
+    }
+}
+/**
+ * stop all modules
+ */
+export async function stop() {
+    for (const module of queue) {
+        await module.stop();
     }
 }
+/**
+ * all builtin modules
+ */
+export const builtins = {
+    http: new HTTP,
+    socketio: new SocketIO,
+};
+add(builtins.http);
+add(builtins.socketio);

package/modules/module.js

@@ -1,11 +1,2 @@
-export class ModuleConfig {
-    enabled = true;
-}
 export default class Module {
-    config;
-    name;
-    setConfig(config) { }
-    getConfig() { return this.config; }
-    async serve() { }
-    async stop() { }
 }

package/modules/socketio/adapter.js

@@ -1,158 +1,49 @@
 import * as SocketIOClient from 'socket.io-client';
 import * as oox from '../../index.js';
-import { OOXEvent, genWebSocketURL, isWebSocketURL } from './utils.js';
+import { OOXEvent, genWebSocketURL } 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;
+import { SampleKeepAliveConnectionAdapter } from '../../samples/index.js';
+export default class SocketIOAdapter extends SampleKeepAliveConnectionAdapter {
+    name = 'socketio';
+    OOXEvent = OOXEvent;
+    nativeEvent = { CONNECT: 'connect', DISCONNECT: 'disconnect', ERROR: 'connect_error' };
+    newConnection(identify) {
+        const { id, name } = oox.config;
         const headers = {
-            'x-ip': host,
             'x-caller': name,
             'x-caller-id': id,
         };
         let mURL;
-        if ('string' === typeof url) {
-            mURL = genWebSocketURL(url);
+        const connectionData = {
+            name: 'anonymous',
+            id: randomUUID(),
+            adapter: this.name,
+            ip: '',
+            token: ''
+        };
+        if ('string' === typeof identify) {
+            mURL = genWebSocketURL(identify);
+        }
+        else if (identify instanceof URL) {
+            mURL = identify;
+        }
+        else if (identify.url) {
+            // KeepAliveConnectionData
+            Object.assign(connectionData, identify);
+            mURL = new URL(identify.url);
+            if (identify.token) {
+                headers['x-token'] = identify.token;
+            }
         }
         else {
-            mURL = url;
+            throw new Error('identify must be string, URL, or KeepAliveConnectionData');
         }
         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();
-        });
+        const connection = new oox.KeepAliveConnection(this, socket, connectionData);
         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;
-    }
 }