oox 0.3.0-beta5 → 0.3.0-beta8

package/app.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execute = exports.call = exports.on = exports.getMethods = exports.setMethods = exports.sourceKVMethods = exports.kvMethods = exports.eventHub = exports.asyncStore = exports.Context = void 0;
+exports.execute = exports.call = exports.on = exports.getMethods = exports.setMethods = exports.sourceKVMethods = exports.kvMethods = exports.eventHub = exports.asyncStore = exports.Context = exports.logger = void 0;
 const node_events_1 = require("node:events");
 const node_async_hooks_1 = require("node:async_hooks");
 const utils_1 = require("./utils");
+exports.logger = require("./logger");
 class Context {
     // 请求溯源ID
     traceId = '';
@@ -124,18 +125,6 @@ async function execute(action, params, context) {
     // ============================= PROXY END =============================
     // make sure target action execute after all proxies
     if (target) {
-        /*
-        const sourceMethod = wrappedActions.get ( action )
-
-        const middlewareNames = actionMiddlewares.get ( sourceMethod )
-
-        if ( middlewareNames && middlewareNames.length ) for ( const name of middlewareNames ) {
-
-            const middleware = middlewares.get ( name )
-
-            await middleware ( action, params, context )
-        }
-        */
         return await target(...params);
     }
 }

package/bin/configurer.js

@@ -25,17 +25,30 @@ function mergeFlatEnv(env) {
         }
     }
 }
-function configure() {
-    let env = Object.create(null);
-    const defaultEnvPath = argv.getEnvArg('default-env');
-    if (defaultEnvPath && fs.existsSync(defaultEnvPath)) {
-        Object.assign(env, require(path.resolve(defaultEnvPath)));
+async function readEnvFile(filePath) {
+    let env = {};
+    if (filePath && fs.existsSync(filePath)) {
+        if (filePath.endsWith('.json')) {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            env = JSON.parse(raw);
+        }
+        else {
+            const finalPath = path.resolve(filePath).replace(/\\/g, '/');
+            env = await eval(`import('file://${finalPath}')`);
+        }
     }
-    const envPath = argv.getEnvArg('env');
-    if (envPath && fs.existsSync(envPath)) {
-        Object.assign(env, require(path.resolve(envPath)));
+    else {
+        throw new Error('Env file not found: ' + filePath);
     }
-    Object.assign(env, argv.getAllEnvArgs());
+    return env.default || env;
+}
+async function configure() {
+    const env = Object.create(null);
+    const defaultEnvPath = argv.getEnvArg('default-env');
+    const targetEnvPath = argv.getEnvArg('env');
+    const defaultEnv = defaultEnvPath ? await readEnvFile(defaultEnvPath) : {};
+    const targetEnv = targetEnvPath ? await readEnvFile(targetEnvPath) : {};
+    Object.assign(env, defaultEnv, targetEnv, argv.getAllEnvArgs());
     mergeFlatEnv(env);
     if ('string' === typeof env.ignore)
         env.ignore = env.ignore.split(',');

package/bin/loader.mjs

@@ -0,0 +1,279 @@
+
+import path from 'node:path'
+
+import os from 'node:os'
+
+import fs from 'node:fs'
+
+import { get as httpGet } from 'node:http'
+
+import { get as httpsGet } from 'node:https'
+
+import oox from '../index.mjs'
+
+
+
+function generateRPCProxyScript ( name, attributes = [ ] ) {
+
+    let attrExports = ''
+
+    for ( const attr of attributes ) {
+    
+        attrExports += `\nexport const ${attr} = proxyer.${attr}\n`
+    }
+    
+    const script = `
+import oox from 'oox'
+function RPC_${name} ( ) { }
+function dotCall ( name, action ) {
+	
+	return new Proxy ( RPC_${name}, {
+
+        get ( target, key ) {
+
+			return dotCall ( name, action ? action + '.' + key : key )
+		},
+		
+		has ( target, key ) { return true },
+		
+		apply ( target, thisArg, args ) {
+
+            return oox.rpc ( name, action, args )
+		}
+	} )
+}
+const proxyer = dotCall ( '${name}', '' )
+export default proxyer
+${attrExports}
+`
+
+    return script
+}
+
+
+
+function generateRPCProxyURL ( name, attributes ) {
+    
+    let searchText = ''
+
+    if ( attributes.length ) {
+
+        const search = new URLSearchParams ( )
+
+        for ( const attr of attributes ) {
+    
+            search.append ( 'attr', attr )
+        }
+
+        searchText = '?' + search.toString ( )
+    }
+
+    return `oox://rpc/${name}.mjs${searchText}`
+}
+
+
+
+function isWebURL ( url ) {
+
+    return url && ( url.startsWith ( 'https://' ) || url.startsWith ( 'http://' ) )
+}
+
+
+
+function isOOXURL ( url ) {
+
+    return url && url.startsWith ( 'oox://' )
+}
+
+
+
+/**
+ * make ESModule support dynamic <export *> attributes import
+ * @param {string} importerSpecifier the import url
+ * @param {string} specifier parentURL
+ * @returns {string[]}
+ */
+function getImportAttributes ( importerSpecifier, specifier ) {
+
+    const attributes = [ ]
+
+    const contents = fs.readFileSync ( importerSpecifier, 'utf-8' )
+
+    // import * as xxx from "xxx"
+    const mergeImport = contents.match ( new RegExp ( `import.+\\*\\s*as\\s+(\\w+)\\s+from\\s*["']${specifier}["']` ) )
+
+    if ( mergeImport ) {
+
+        const mergeName = mergeImport [ 1 ]
+
+        const attributesIterator = contents.matchAll ( new RegExp ( `${mergeName}\\s*\\.\\s*(\\w+)`, 'g' ) )
+
+        for ( const caseItem of attributesIterator ) {
+
+            attributes.push ( caseItem [ 1 ] )
+        }
+    }
+
+    // import { a, b, c } from 'xxx'
+    const attributeImport = contents.match ( new RegExp ( `import.+{(.+)}\\s*from\\s*["']${specifier}["']` ) )
+
+    if ( attributeImport ) {
+
+        const definedAttributes = attributeImport [ 1 ].split ( ',' ).map ( v => v.trim ( ) ).filter ( v => !v.startsWith ( 'default' ) )
+        
+        attributes.push ( ...definedAttributes )
+    }
+
+    return Array.from ( new Set ( attributes ) )
+}
+
+
+
+/**
+ * @param {string} specifier
+ * @param {{
+ *   conditions: string[],
+ *   parentURL: string | undefined,
+ * }} context
+ * @param {Function} defaultResolve
+ * @returns {Promise<{ url: string }>}
+ */
+export async function resolve ( specifier, context, defaultResolve ) {
+
+    const defaultSpecifer = specifier
+
+    const { parentURL } = context
+
+    // HTTP & HTTPS
+    if ( isWebURL ( specifier ) ) {
+
+        return { url: specifier }
+    } else if ( isWebURL ( parentURL ) && ( specifier.startsWith ( '.' ) || specifier.startsWith ( '/' ) ) ) {
+
+        return { url: new URL ( specifier, parentURL ).href }
+    }
+
+    // OOX special alias for web package
+    if ( specifier === 'oox' ) {
+
+        return {
+            url: 'file://' + path.resolve ( './node_modules/oox/index.mjs' )
+        }
+    }
+
+    const { entryFile } = oox.config
+
+    // Relative specifier concat to absolute path
+    if ( specifier.startsWith ( '.' ) && parentURL ) {
+
+        specifier = path.posix.join ( path.dirname ( parentURL.replace ( 'file://', '' ) ), specifier )
+    }
+
+    // Windows pathname remove root sep
+    if ( os.platform ( ) === 'win32' && specifier.startsWith ( '/' ) ) {
+
+        specifier = specifier.replace ( '/', '' )
+    }
+
+    // OOX RPC Proxy URL generation
+    if ( !specifier.endsWith ( entryFile.path ) && entryFile.group && specifier.startsWith ( entryFile.group ) ) {
+
+        const subSpecifier = specifier.slice ( entryFile.group.length )
+
+        const matchResult = subSpecifier.match ( /^\/?([\w-]+)(\/index)?(\.m?js)?$/ )
+
+        if ( matchResult ) {
+
+            const importerSpecifier = parentURL.replace ( os.platform ( ) === 'win32' ? /file:\/+/ : 'file://', '' )
+            
+            const attributes = getImportAttributes ( importerSpecifier, defaultSpecifer )
+
+            return { url: generateRPCProxyURL ( matchResult [ 1 ], attributes ) }
+        }
+    }
+
+    // restore Windows specifier protocol
+    if ( os.platform ( ) === 'win32' && specifier.includes ( '/' ) && !specifier.startsWith ( 'file://' ) ) {
+
+        specifier = 'file://' + specifier
+    }
+
+    return defaultResolve ( specifier, context, defaultResolve )
+}
+
+
+
+/**
+ * @param {string} url
+ * @param {{
+ *   format: string,
+ * }} context If resolve settled with a `format`, that value is included here.
+ * @param {Function} defaultLoad
+ * @returns {Promise<{
+ *   format: string,
+ *   source: string | ArrayBuffer | SharedArrayBuffer | Uint8Array,
+ * }>}
+ */
+export async function load ( url, context, defaultLoad ) {
+
+    if ( isWebURL ( url ) || isOOXURL ( url ) ) {
+
+        return getSource ( url, context, defaultLoad )
+    }
+
+    return defaultLoad ( url, context, defaultLoad )
+}
+
+
+
+export function getFormat ( url, context, defaultGetFormat ) {
+
+    if ( isWebURL ( url ) || isOOXURL ( url ) ) {
+
+        return {
+            format: 'module'
+        }
+    }
+
+    return defaultGetFormat ( url, context, defaultGetFormat )
+}
+
+
+
+export function getSource ( url, context, defaultGetSource ) {
+
+    if ( isWebURL ( url ) ) {
+
+        const getMethod = url.startsWith ( 'https://' ) ? httpsGet : httpGet
+
+        return new Promise ( ( resolve, reject ) => getMethod ( url, res => {
+            let source = ''
+            res
+            .on ( 'data', chunk => source += chunk )
+            .on ( 'end', () => resolve ( { format: 'module', source } ) )
+        } ).on ( 'error', reject ) )
+    } else if ( isOOXURL ( url ) ) {
+
+        const mURL = new URL ( url )
+
+        if ( mURL.host === 'rpc' ) {
+
+            const regexp = /\/([\w-]+)\.mjs$/
+
+            const matchResult = mURL.pathname.match ( regexp )
+
+            // read all import attributes
+            const attributes = mURL.searchParams.getAll ( 'attr' )
+        
+            const source = generateRPCProxyScript ( matchResult [ 1 ], attributes )
+
+            return { format: 'module', source }
+        }
+    }
+  
+    return defaultGetSource ( url, context, defaultGetSource )
+}
+
+
+
+process.on ( 'unhandledRejection', console.error )

package/bin/starter.js

@@ -7,10 +7,6 @@ const oox = require("../index");
 const proxyer_1 = require("./proxyer");
 const configurer_1 = require("./configurer");
 const register_1 = require("./register");
-const module_socketio_1 = require("@oox/module-socketio");
-// preload modules
-const socketio = new module_socketio_1.default();
-oox.modules.add(socketio);
 function getEntryFile(env) {
     const args = process.argv.slice(2);
     var [entryFilename] = args.filter(arg => !arg.includes('=') && arg.endsWith('.js'));
@@ -24,17 +20,22 @@ function getEntryFile(env) {
     var name = filename === 'index.js' && groupFullDirectory !== fullDirectory ? directory : filename.split('.js')[0];
     return { name, path: fullPath, group: groupFullDirectory };
 }
-function loadEntry(name, entryPath) {
+async function loadEntry(name, entryPath) {
     oox.config.name = name;
-    const methods = require(entryPath);
-    oox.setMethods(methods);
+    // Typescript 4.7.3, not supported import() expression
+    const methods = await eval(`import('file://${entryPath.replace(/\\/g, '/')}')`);
+    oox.setMethods(methods.default || methods);
 }
 async function startup() {
     // 加载环境变量
-    const env = (0, configurer_1.configure)();
+    const env = await (0, configurer_1.configure)();
     Object.assign(oox.config, env);
     // 获取服务入口地址
     const entryFile = getEntryFile(env);
+    oox.config.entryFile = {
+        path: entryFile.path.replace(/\\/g, '/'),
+        group: entryFile.group.replace(/\\/g, '/'),
+    };
     // 代理<服务间调用>
     if (env.group) {
         const excludes = [entryFile.name];
@@ -43,28 +44,10 @@ async function startup() {
         (0, proxyer_1.proxyGroup)(entryFile.group, excludes);
     }
     // 加载服务
-    loadEntry(entryFile.name, entryFile.path);
-    // 服务配置
-    if (!env.port && !env.http && !env.socketio)
-        env.port = 0;
-    const httpConfig = oox.modules.builtins.http.config, socketioConfig = socketio.config;
-    if ('number' === typeof env.port) {
-        httpConfig.port = socketioConfig.port = env.port;
-    }
-    if (env.origin)
-        httpConfig.origin = env.origin;
-    if ('http' in env) {
-        if (env.http)
-            Object.assign(httpConfig, env.http);
-        else
-            httpConfig.disabled = true;
-    }
-    if ('socketio' in env) {
-        if (env.socketio)
-            Object.assign(socketioConfig, env.socketio);
-        else
-            socketioConfig.disabled = true;
-    }
+    await loadEntry(entryFile.name, entryFile.path);
+    // 模块配置
+    oox.modules.setConfig(oox.config);
+    const { http: { config: httpConfig }, socketio: { config: socketioConfig } } = oox.modules.builtins;
     // 服务启动
     await oox.serve();
     console.log();

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = exports.removeKeepAliveConnection = exports.addKeepAliveConnection = exports.getKeepAliveConnection = exports.getKeepAliveConnections = exports.keepAliveConnections = exports.RPCKeepAliveConnection = exports.stop = exports.serve = exports.getContext = exports.genContext = exports.genTraceId = exports.setGenTraceIdFunction = exports.getConfig = exports.config = exports.Config = exports.Context = exports.on = exports.execute = exports.call = exports.sourceKVMethods = exports.kvMethods = exports.getMethods = exports.setMethods = exports.asyncStore = exports.modules = exports.ModuleConfig = exports.Module = void 0;
+exports.rpc = exports.setLoadBalancePolicy = exports.removeKeepAliveConnection = exports.addKeepAliveConnection = exports.getKeepAliveConnection = exports.getKeepAliveConnections = exports.keepAliveConnections = exports.RPCKeepAliveConnection = exports.stop = exports.serve = exports.getContext = exports.genContext = exports.genTraceId = exports.setGenTraceIdFunction = exports.config = exports.Config = exports.Context = exports.on = exports.logger = exports.execute = exports.call = exports.sourceKVMethods = exports.kvMethods = exports.getMethods = exports.setMethods = exports.asyncStore = exports.modules = exports.ModuleConfig = exports.Module = void 0;
 const node_crypto_1 = require("node:crypto");
 const app = require("./app");
 const utils_1 = require("./utils");
@@ -9,7 +9,7 @@ exports.Module = module_1.default;
 Object.defineProperty(exports, "ModuleConfig", { enumerable: true, get: function () { return module_1.ModuleConfig; } });
 const modules_1 = require("./modules");
 exports.modules = new modules_1.default;
-exports.asyncStore = app.asyncStore, exports.setMethods = app.setMethods, exports.getMethods = app.getMethods, exports.kvMethods = app.kvMethods, exports.sourceKVMethods = app.sourceKVMethods, exports.call = app.call, exports.execute = app.execute, exports.on = app.on;
+exports.asyncStore = app.asyncStore, exports.setMethods = app.setMethods, exports.getMethods = app.getMethods, exports.kvMethods = app.kvMethods, exports.sourceKVMethods = app.sourceKVMethods, exports.call = app.call, exports.execute = app.execute, exports.logger = app.logger, exports.on = app.on;
 class Context extends app.Context {
     // 请求溯源IP
     sourceIP = '';
@@ -24,21 +24,29 @@ class Context extends app.Context {
     toJSON() {
         const context = Object.assign({}, this);
         delete context.connection;
-        return JSON.stringify(context);
+        return context;
     }
 }
 exports.Context = Context;
 class Config {
     // 服务名称
     name = 'local';
+    // 启动文件
+    entryFile = {
+        // 启动文件路径
+        path: '',
+        // 服务列表路径
+        group: '',
+    };
     // 主机地址
     host = (0, utils_1.getIPAddress)(4)[0];
+    // 默认监听端口
+    port = 0;
+    // 默认跨域设置
+    origin = '';
 }
 exports.Config = Config;
 exports.config = new Config();
-function getConfig() {
-}
-exports.getConfig = getConfig;
 let genTraceIdFunction = () => (0, node_crypto_1.randomUUID)();
 function setGenTraceIdFunction(fn) {
     genTraceIdFunction = fn;
@@ -123,6 +131,23 @@ function removeKeepAliveConnection(name, id) {
     }
 }
 exports.removeKeepAliveConnection = removeKeepAliveConnection;
+/**
+ * random connection select for default load balance policy
+ * @param name service name
+ * @returns selected connection
+ */
+let loadBalancePolicy = (name) => {
+    const connections = exports.keepAliveConnections.get(name);
+    if (!connections || !connections.size)
+        return null;
+    const arrayConnections = Array.from(connections.values());
+    const index = Math.floor(Math.random() * arrayConnections.length);
+    return arrayConnections[index];
+};
+function setLoadBalancePolicy(policy) {
+    loadBalancePolicy = policy;
+}
+exports.setLoadBalancePolicy = setLoadBalancePolicy;
 async function rpc(arg1, action, params, context) {
     if (!context || !context.traceId) {
         context = getContext();
@@ -132,10 +157,9 @@ async function rpc(arg1, action, params, context) {
         connection = arg1;
     }
     else if ('string' === typeof arg1) {
-        const connections = exports.keepAliveConnections.get(arg1);
-        if (!connections || !connections.size)
+        connection = loadBalancePolicy(arg1);
+        if (!connection)
             throw new Error(`Connection<${arg1}> not found`);
-        connection = connections.values().next().value;
     }
     else
         throw new Error(`Unknown rpc arg1<${arg1}>`);

package/index.mjs

@@ -1,4 +1,5 @@
 
 import * as oox from './index.js'
 
+export * from './index.js'
 export default oox

package/logger.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trace = exports.error = exports.warn = exports.info = void 0;
+const app_1 = require("./app");
+function info(...msgs) {
+    const context = app_1.asyncStore.getStore();
+    if (context)
+        app_1.eventHub.emit('log', context, 'info', msgs);
+    else
+        console.info('[INFO]', ...msgs);
+}
+exports.info = info;
+function warn(...msgs) {
+    const context = app_1.asyncStore.getStore();
+    if (context)
+        app_1.eventHub.emit('log', context, 'warn', msgs);
+    else
+        console.warn('[WARN]', ...msgs);
+}
+exports.warn = warn;
+function error(...msgs) {
+    const context = app_1.asyncStore.getStore();
+    if (context)
+        app_1.eventHub.emit('log', context, 'error', msgs);
+    else
+        console.error('[ERROR]', ...msgs);
+}
+exports.error = error;
+function trace(name) {
+    const context = app_1.asyncStore.getStore();
+    const trace = { stack: '' };
+    Error.captureStackTrace(trace);
+    const stack = trace.stack
+        .replace(/.*\n.*logger.js.*\n/, name || 'Untitle\n');
+    if (context)
+        app_1.eventHub.emit('log', context, 'trace', stack);
+    else
+        console.log('[TRACE]', stack);
+}
+exports.trace = trace;

package/modules/http/index.js

@@ -20,6 +20,12 @@ class HTTPModule extends module_1.default {
     server = null;
     setConfig(config) {
         Object.assign(this.config, config);
+        if (!config.hasOwnProperty('port')) {
+            this.config.port = oox.config.port;
+        }
+        if (!config.hasOwnProperty('origin')) {
+            this.config.origin = oox.config.origin;
+        }
     }
     getConfig() {
         return this.config;

package/modules/index.js

@@ -2,6 +2,7 @@
 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
@@ -20,10 +21,12 @@ class Modules extends module_1.default {
      */
     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)
@@ -57,6 +60,10 @@ class Modules extends module_1.default {
                     module.setConfig({ disabled: true });
                 }
             }
+            else {
+                module.setConfig({});
+            }
+            config[module.name] = module.getConfig();
         }
     }
     async serve() {

package/modules/socketio/client.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SocketIOClient = require("socket.io-client");
+const socket_1 = require("./socket");
+const server_1 = require("./server");
+const oox = require("../../index");
+class SocketIOCore extends server_1.default {
+    /**
+     * connect to <SocketIO RPC> service
+     */
+    async connect(url) {
+        let socket = socket_1.sockets.get(url);
+        // 已经连接的直接返回
+        if (socket) {
+            try {
+                await this.clientWaitConnection(socket);
+            }
+            catch (error) {
+                this.clientOnSocketDisconnect(socket, error.message);
+                throw error;
+            }
+            return socket;
+        }
+        const headers = {
+            'x-caller': oox.config.name
+        };
+        const { host } = oox.config;
+        const { port, path } = this.config;
+        headers['x-ip'] = host;
+        headers['x-caller-id'] = `ws://${host}:${port}${path}`;
+        // create socket handler
+        const mURL = new URL(url);
+        socket = SocketIOClient.io(mURL.origin, {
+            extraHeaders: headers,
+            path: mURL.pathname
+        });
+        socket.data = { name: 'anonymous', connected: false, id: url, host: mURL.host };
+        socket_1.sockets.set(url, socket);
+        try {
+            await this.clientWaitConnection(socket);
+        }
+        catch (error) {
+            this.clientOnSocketDisconnect(socket, error);
+            throw error;
+        }
+        return socket;
+    }
+    /**
+     * 客户端Socket连接事件
+     */
+    clientOnSocketConnection(socket) {
+        socket.data.connected = true;
+        socket.once('disconnect', reason => this.clientOnSocketDisconnect(socket, reason));
+        this.clientOnConnection(socket);
+    }
+    clientOnDisconnect(socket, reason) { }
+    clientOnConnection(socket) { }
+    /**
+     * 客户端Socket断开事件
+     * @param {Socket} socket
+     */
+    clientOnSocketDisconnect(socket, reason) {
+        socket.data.connected = false;
+        socket.disconnect();
+        socket_1.sockets.delete(socket.data.id);
+        this.clientOnDisconnect(socket, reason);
+    }
+    /**
+     * 等待socket连接
+     */
+    async clientWaitConnection(socket) {
+        if (socket.data.connected)
+            return;
+        if (socket.connect)
+            socket.connect();
+        try {
+            await new Promise((resolve, reject) => {
+                const onError = (reason) => {
+                    socket.offAny(onError);
+                    const message = 'string' === typeof reason ? reason : reason instanceof Error ? reason.message : 'connect error';
+                    reject(new Error(message));
+                };
+                socket.once('disconnect', onError);
+                socket.once('connect_error', onError);
+                socket.once('connect_timeout', onError);
+                socket.once('reconnect_error', onError);
+                socket.once('reconnect_failed', onError);
+                socket.once('oox_connected', ({ name }) => {
+                    socket.offAny(onError);
+                    socket.data.name = name;
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+        this.clientOnSocketConnection(socket);
+    }
+}
+exports.default = SocketIOCore;

package/modules/socketio/index.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sockets = void 0;
+const path = require("node:path");
+const client_1 = require("./client");
+const oox = require("../../index");
+const index_1 = require("../../index");
+const socket_1 = require("./socket");
+Object.defineProperty(exports, "sockets", { enumerable: true, get: function () { return socket_1.sockets; } });
+class SocketIOModule extends client_1.default {
+    sockets = socket_1.sockets;
+    async serve() {
+        await this.stop();
+        const _http = oox.modules.builtins.http;
+        const httpConfig = _http.getConfig(), config = this.getConfig();
+        let isShareServer = false;
+        // 都没设置端口
+        isShareServer = !httpConfig.port && !config.port;
+        // 都设置相同端口
+        isShareServer = isShareServer || httpConfig.port === config.port;
+        // http 模块未被禁用
+        isShareServer = isShareServer && !httpConfig.disabled;
+        if (isShareServer) {
+            config.path = path.posix.join(httpConfig.path, config.path);
+            this.server = _http.server;
+        }
+        await super.serve();
+    }
+    onSyncConnection(socket) {
+        const mSockets = Array.from(socket_1.sockets.values())
+            .filter(s => s !== socket &&
+            s.data.name !== socket.data.name &&
+            s.data.id.startsWith('ws://'));
+        return mSockets.map(s => s.data);
+    }
+    serverOnDisconnect(socket, reason) {
+        super.serverOnDisconnect(socket, reason);
+        (0, index_1.removeKeepAliveConnection)(socket.data.name, socket.data.id);
+    }
+    clientOnDisconnect(socket, reason) {
+        super.clientOnDisconnect(socket, reason);
+        (0, index_1.removeKeepAliveConnection)(socket.data.name, socket.data.id);
+    }
+    /**
+     *
+     * @param socket 是由哪个通道发送过来的
+     * @param connectionDatas
+     */
+    clientOnSyncConnection(socket, connectionDatas) {
+        for (const data of connectionDatas)
+            if (!socket_1.sockets.has(data.id))
+                this.connect(data.id).catch((error) => console.error(error));
+    }
+    onFetchActions(socket, search) {
+        const data = [];
+        for (const key of oox.kvMethods.keys())
+            if (!key.endsWith('_proxy') && key.includes(search))
+                data.push(key);
+        return data;
+    }
+    fetchActions(id, search = '') {
+        let socket = socket_1.sockets.get(id);
+        if (!socket) {
+            const connections = (0, index_1.getKeepAliveConnections)(id);
+            if (!connections || !connections.size)
+                throw new Error(`Unknown service identify<${id}>`);
+            id = connections.keys().next().value;
+            socket = socket_1.sockets.get(id);
+        }
+        if (!socket)
+            throw new Error(`Unknown service identify<${id}>`);
+        return this.emit(socket.data.id, 'fetchActions', [search]);
+    }
+    onConnection(socket) {
+        const { id, name, host } = socket.data;
+        const connection = new index_1.RPCKeepAliveConnection(this, id, socket.data);
+        (0, index_1.addKeepAliveConnection)(connection);
+        const connectionContext = {
+            sourceIP: '',
+            ip: host,
+            caller: name,
+            callerId: id,
+            connection
+        };
+        socket.on('fetchActions', async (search, fn) => {
+            if ('function' !== typeof fn)
+                return;
+            const data = await this.onFetchActions(socket, search);
+            fn(data);
+        });
+        socket.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);
+        });
+    }
+    /**
+     *
+     * @param {Socket} socket
+     */
+    serverOnConnection(socket) {
+        super.serverOnConnection(socket);
+        socket.setMaxListeners(0);
+        socket.on('syncConnection', async (fn) => {
+            if ('function' !== typeof fn)
+                return;
+            const data = this.onSyncConnection(socket);
+            fn(data);
+        });
+        this.onConnection(socket);
+    }
+    async call(action, params, context, callback) {
+        const returns = await oox.call(action, params, context);
+        'function' === typeof callback && callback(returns);
+        return returns;
+    }
+    clientOnConnection(socket) {
+        super.clientOnConnection(socket);
+        socket.emit('syncConnection', (socketDatas) => this.clientOnSyncConnection(socket, socketDatas));
+        this.onConnection(socket);
+    }
+    /**
+     * socketio emit
+     */
+    async emit(url, action, params) {
+        let socket = null;
+        try {
+            socket = await this.connect(url);
+        }
+        catch (error) {
+            // try again
+            socket = await this.connect(url);
+        }
+        try {
+            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(action, ...params, (returns) => {
+                    socket.off('disconnect', onError);
+                    resolve(returns);
+                });
+            });
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+    /**
+     * RPC
+     */
+    async rpc(url, action, params, context) {
+        if (!context || !context.traceId) {
+            context = oox.getContext();
+        }
+        const { error, body } = await this.emit(url, 'call', [action, params, context]);
+        if (error)
+            throw new Error(error.message);
+        else
+            return body;
+    }
+}
+exports.default = SocketIOModule;

package/modules/socketio/server.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketIOConfig = void 0;
+const http = require("node:http");
+const socket_io_1 = require("socket.io");
+const oox = require("../../index");
+const index_1 = require("../../index");
+const socket_1 = require("./socket");
+class SocketIOConfig extends index_1.ModuleConfig {
+    // listen port
+    port = 0;
+    // service path
+    path = '/socket.io';
+    // browser cross origin
+    origin = '';
+}
+exports.SocketIOConfig = SocketIOConfig;
+class SocketIOServer extends index_1.Module {
+    name = 'socketio';
+    config = new SocketIOConfig;
+    /**
+     * means this.server created by myself<SocketIOServer>
+     */
+    #isSelfServer = false;
+    server = null;
+    socketServer = null;
+    setConfig(config) {
+        Object.assign(this.config, config);
+        if (!config.hasOwnProperty('port')) {
+            this.config.port = oox.config.port;
+        }
+        if (!config.hasOwnProperty('origin')) {
+            this.config.origin = oox.config.origin;
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+    async serve() {
+        await this.stop();
+        const port = this.config.port;
+        const isSelfServer = this.#isSelfServer = this.server ? true : false;
+        const server = this.server = isSelfServer ? this.server :
+            http.createServer((request, response) => response.end('No HTTP Gateway'));
+        if (!server.listening)
+            server.listen(port);
+        const address = server.address();
+        if (!address || 'object' !== typeof address)
+            throw new Error('Cannot read socket.io server port');
+        this.config.port = address.port;
+        this.createSocketIOServer();
+    }
+    async stop() {
+        if (this.socketServer)
+            await new Promise((resolve, reject) => this.socketServer.close(error => error ? reject(error) : resolve()));
+        if (this.#isSelfServer)
+            await new Promise((resolve, reject) => this.server.close(error => error ? reject(error) : resolve()));
+    }
+    genSocketIOServerOptions() {
+        const options = {
+            /**
+             * name of the path to capture
+             * @default "/socket.io"
+             */
+            path: this.config.path,
+            /**
+             * how many ms before a client without namespace is closed
+             * @default 45000
+             */
+            connectTimeout: 5000,
+            /**
+             * how many ms without a pong packet to consider the connection closed
+             * @default 5000
+             */
+            pingTimeout: 2000,
+            /**
+             * how many ms before sending a new ping packet
+             * @default 25000
+             */
+            pingInterval: 10000,
+            /**
+             * how many bytes or characters a message can be, before closing the session (to avoid DoS).
+             * @default 1e5 (100 KB)
+             */
+            maxHttpBufferSize: 1e5
+        };
+        const { origin } = this.config;
+        if (origin)
+            options.cors = { origin };
+        return options;
+    }
+    createSocketIOServer() {
+        const socketServer = this.socketServer = new socket_io_1.Server(this.server, this.genSocketIOServerOptions());
+        socketServer.on('connection', async (socket) => {
+            try {
+                this.serverOnSocketConnection(socket);
+            }
+            catch (error) {
+                socket.send(error.message).disconnect(true);
+            }
+        });
+    }
+    /**
+     * 服务端Socket连接事件
+     */
+    serverOnSocketConnection(socket) {
+        const headers = socket.handshake.headers;
+        const callerId = String(headers['x-caller-id'] || '') || socket.id;
+        // 已经存在相同的连接
+        if (socket_1.sockets.has(callerId))
+            throw new Error('Connection Exists');
+        // client ip or caller service ip
+        const ip = String(headers['x-real-ip'] || headers['x-ip'] || socket.handshake.address);
+        // service name
+        const caller = String(headers['x-caller'] || 'anonymous');
+        socket.data = { connected: true, host: ip, name: caller, id: callerId };
+        // 保存 callerId 与 socket 对应关系
+        socket_1.sockets.set(callerId, socket);
+        socket.on('disconnect', reason => this.serverOnSocketDisconnect(socket, reason));
+        socket.emit('oox_connected', { name: oox.config.name });
+        this.serverOnConnection(socket);
+    }
+    serverOnConnection(socket) { }
+    /**
+     * 服务端Socket断开事件
+     * @param {Socket} socket
+     * @param {Error} reason
+     */
+    serverOnSocketDisconnect(socket, reason) {
+        socket.data.connected = false;
+        socket_1.sockets.delete(socket.data.id);
+        this.serverOnDisconnect(socket, reason);
+    }
+    serverOnDisconnect(socket, reason) { }
+}
+exports.default = SocketIOServer;

package/modules/socketio/socket.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sockets = void 0;
+exports.sockets = new Map();

package/package.json

@@ -1,12 +1,13 @@
 {
     "name": "oox",
-    "version": "0.3.0-beta5",
+    "version": "0.3.0-beta8",
     "description": "Graceful NodeJS distributed application solution",
     "keywords": [
         "http",
         "websocket",
         "socket.io",
         "rpc",
+        "framework",
         "microservice",
         "distributed",
         "tracing"
@@ -15,9 +16,11 @@
     "main": "index.js",
     "types": "types/index.d.ts",
     "exports": {
-        "require": "./index.js",
-        "import": "./index.mjs",
-        "types": "./types/index.d.ts"
+        ".": {
+            "import": "./index.mjs",
+            "require": "./index.js"
+        },
+        "./loader": "./bin/loader.mjs"
     },
     "bin": {
         "oox": "bin/cli.js"
@@ -26,8 +29,9 @@
     "homepage": "https://github.com/lipingruan/oox",
     "license": "MIT",
     "dependencies": {
-        "@oox/module-socketio": "^0.0.3",
-        "chalk": "^4.1.0"
+        "chalk": "^4.1.0",
+        "socket.io": "^4.4.0",
+        "socket.io-client": "^4.4.0"
     },
     "engines": {
         "node": ">=12.0.0"

package/types/app.d.ts

@@ -2,6 +2,7 @@
 /// <reference types="node" />
 import { EventEmitter } from 'node:events';
 import { AsyncLocalStorage } from 'node:async_hooks';
+export * as logger from './logger';
 export interface ReturnsBody {
     traceId: string;
     success: boolean;
@@ -12,6 +13,7 @@ export interface ReturnsBody {
     };
 }
 export declare class Context {
+    [x: string]: any;
     traceId?: string;
 }
 export declare const asyncStore: AsyncLocalStorage<Context>;
@@ -26,6 +28,7 @@ export declare function getMethods(): any;
 export declare function on(event: 'request', listener: (action: string, params: any[], context: Context) => void): void;
 export declare function on(event: 'success', listener: (action: string, params: any[], context: Context, result: ReturnsBody) => void): void;
 export declare function on(event: 'fail', listener: (action: string, params: any[], context: Context, error: Error) => void): void;
+export declare function on(event: 'log', listener: (context: Context, tag: string, msgs: any[]) => void): void;
 /**
  * Call an Function on RPC server
  * @param action

package/types/bin/configurer.d.ts

@@ -1 +1 @@
-export declare function configure(): any;
+export declare function configure(): Promise<any>;

package/types/index.d.ts

@@ -5,22 +5,27 @@ import Modules from './modules';
 export { ReturnsBody } from './app';
 export { Module, ModuleConfig };
 export declare const modules: Modules;
-export declare const asyncStore: import("async_hooks").AsyncLocalStorage<app.Context>, setMethods: typeof app.setMethods, getMethods: typeof app.getMethods, kvMethods: Map<string, Function>, sourceKVMethods: Map<string, Function>, call: typeof app.call, execute: typeof app.execute, on: typeof app.on;
+export declare const asyncStore: import("async_hooks").AsyncLocalStorage<app.Context>, setMethods: typeof app.setMethods, getMethods: typeof app.getMethods, kvMethods: Map<string, Function>, sourceKVMethods: Map<string, Function>, call: typeof app.call, execute: typeof app.execute, logger: typeof app.logger, on: typeof app.on;
 export declare class Context extends app.Context {
     sourceIP: string;
     ip: string;
     caller: string;
     callerId: string;
     connection?: RPCKeepAliveConnection;
-    toJSON?(): string;
+    toJSON?(): {} & this;
 }
 export declare class Config {
     [x: string]: any;
     name: string;
+    entryFile: {
+        path: string;
+        group: string;
+    };
     host: string;
+    port: number;
+    origin: string;
 }
 export declare const config: Config;
-export declare function getConfig(): void;
 export declare function setGenTraceIdFunction(fn: () => string): void;
 /**
  * 生成随机不重复id
@@ -66,5 +71,6 @@ export declare function getKeepAliveConnection(name: string, id: string): RPCKee
 export declare function addKeepAliveConnection(connection: RPCKeepAliveConnection): void;
 export declare function removeKeepAliveConnection(connection: RPCKeepAliveConnection): void;
 export declare function removeKeepAliveConnection(name: string, id: string): void;
+export declare function setLoadBalancePolicy(policy: (name: string) => RPCKeepAliveConnection): void;
 export declare function rpc(appName: string, action: string, params: any[], context?: Context): Promise<any>;
 export declare function rpc(connection: RPCKeepAliveConnection, action: string, params: any[], context?: Context): Promise<any>;

package/types/logger.d.ts

@@ -0,0 +1,4 @@
+export declare function info(...msgs: any[]): void;
+export declare function warn(...msgs: any[]): void;
+export declare function error(...msgs: any[]): void;
+export declare function trace(name?: string): void;

package/types/modules/index.d.ts

@@ -1,5 +1,6 @@
 import Module from './module';
 import HTTP from './http';
+import SocketIO from './socketio';
 export default class Modules extends Module {
     #private;
     /**
@@ -11,6 +12,7 @@ export default class Modules extends Module {
      */
     builtins: {
         http: HTTP;
+        socketio: SocketIO;
     };
     constructor();
     add(module: Module): this;

package/types/modules/socketio/client.d.ts

@@ -0,0 +1,23 @@
+import { ClientSocket as Socket } from './socket';
+import SocketIOServer from './server';
+export default class SocketIOCore extends SocketIOServer {
+    /**
+     * connect to <SocketIO RPC> service
+     */
+    connect(url: string): Promise<Socket>;
+    /**
+     * 客户端Socket连接事件
+     */
+    clientOnSocketConnection(socket: Socket): void;
+    clientOnDisconnect(socket: Socket, reason: any): void;
+    clientOnConnection(socket: Socket): void;
+    /**
+     * 客户端Socket断开事件
+     * @param {Socket} socket
+     */
+    clientOnSocketDisconnect(socket: Socket, reason: any): void;
+    /**
+     * 等待socket连接
+     */
+    clientWaitConnection(socket: Socket): Promise<void>;
+}

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

@@ -0,0 +1,37 @@
+import SocketIOClient from './client';
+import * as oox from '../../index';
+import { RPCKeepAliveConnectionData, RPCConnectionAdapter } from '../../index';
+import { Socket, sockets, ServerSocket, ClientSocket } from './socket';
+export { Socket, sockets };
+export default class SocketIOModule extends SocketIOClient implements RPCConnectionAdapter {
+    sockets: Map<string, Socket>;
+    serve(): Promise<void>;
+    onSyncConnection(socket: Socket): oox.RPCKeepAliveConnectionData[];
+    serverOnDisconnect(socket: ServerSocket, reason: string): void;
+    clientOnDisconnect(socket: ClientSocket, reason: any): void;
+    /**
+     *
+     * @param socket 是由哪个通道发送过来的
+     * @param connectionDatas
+     */
+    clientOnSyncConnection(socket: Socket, connectionDatas: RPCKeepAliveConnectionData[]): void;
+    onFetchActions(socket: Socket, search: string): string[];
+    fetchActions(url: string, search?: string): Promise<RPCKeepAliveConnectionData[]>;
+    fetchActions(name: string, search?: string): Promise<RPCKeepAliveConnectionData[]>;
+    onConnection(socket: Socket): void;
+    /**
+     *
+     * @param {Socket} socket
+     */
+    serverOnConnection(socket: ServerSocket): void;
+    call(action: string, params: any[], context: oox.Context, callback?: (returns: any) => void): Promise<oox.ReturnsBody>;
+    clientOnConnection(socket: ClientSocket): void;
+    /**
+     * socketio emit
+     */
+    emit(url: string, action: string, params: any[]): Promise<unknown>;
+    /**
+     * RPC
+     */
+    rpc(url: string, action: string, params: [], context?: oox.Context): Promise<any>;
+}

package/types/modules/socketio/server.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import * as http from 'node:http';
+import { Server, ServerOptions } from 'socket.io';
+import { Module, ModuleConfig } from '../../index';
+import { ServerSocket as Socket } from './socket';
+export declare class SocketIOConfig extends ModuleConfig {
+    port: number;
+    path: string;
+    origin: string;
+}
+export default class SocketIOServer extends Module {
+    #private;
+    name: string;
+    config: SocketIOConfig;
+    server: http.Server;
+    socketServer: Server;
+    setConfig(config: SocketIOConfig): void;
+    getConfig(): SocketIOConfig;
+    serve(): Promise<void>;
+    stop(): Promise<void>;
+    genSocketIOServerOptions(): Partial<ServerOptions>;
+    createSocketIOServer(): void;
+    /**
+     * 服务端Socket连接事件
+     */
+    serverOnSocketConnection(socket: Socket): void;
+    serverOnConnection(socket: Socket): void;
+    /**
+     * 服务端Socket断开事件
+     * @param {Socket} socket
+     * @param {Error} reason
+     */
+    serverOnSocketDisconnect(socket: Socket, reason: string): void;
+    serverOnDisconnect(socket: Socket, reason: string): void;
+}

package/types/modules/socketio/socket.d.ts

@@ -0,0 +1,11 @@
+import { Socket as _ServerSocket } from 'socket.io';
+import { Socket as _ClientSocket } from 'socket.io-client';
+import { RPCKeepAliveConnectionData } from '../../index';
+export interface ServerSocket extends _ServerSocket {
+    data: RPCKeepAliveConnectionData;
+}
+export interface ClientSocket extends _ClientSocket {
+    data: RPCKeepAliveConnectionData;
+}
+export declare type Socket = ServerSocket | ClientSocket;
+export declare const sockets: Map<string, Socket>;