oox 0.3.2 → 0.3.4

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/cli.js

@@ -27,23 +27,26 @@ if (execFilename.endsWith('oox') || fileURLToPath(import.meta.url) === execFilen
         console.log();
         console.log('  oox entry.js port=8080');
         console.log();
-        console.log('  oox app/entry/index.js group=app/ env=envs/entry.js ignore=core');
+        console.log('  oox entry.js group=app/ registry=:6000');
+        console.log('  oox app/entry/index.js group=app/ env=envs/prod.js ignore=core');
         console.log();
         console.log(chalk.bold('Params:'));
         const params = [
-            ['  default-env  [ file ]  ', '.js or .json file, merge to oox.config'],
-            ['  env          [ file ]  ', '.js or .json file, merge to oox.config', chalk.bold('(after default-env)')],
-            ['  port         [ int  ]  ', 'set', chalk.bold('0'), 'for random port, or any integer > 0'],
-            ['  group        [ dir  ]  ', 'service group directory, all LocalCall transform to RPC'],
-            ['  ignore       [ name ]  ', 'set a name for LocalCall do not transform to RPC, support string | array<string>'],
-            ['  http         [ json ]  ', 'HTTP server options, support flat name, ex: http.path=/api'],
-            ['  socketio     [ json ]  ', 'SocketIO server options, support flat name'],
-            ['  registry     [ urls ]  ', 'registry service url, support string | array<string>'],
-            ['  origin       [ urls ]  ', 'set', chalk.bold('*'), 'allow any connections <Access-Control-Allow-Origin>'],
-            ['  errorStack  [ bool ]  ', 'set no to hidden error stack return'],
-            ['  ...                    ', 'set params as', chalk.bold('foo=bar') + ',', 'usage as', chalk.bold('oox.config.foo')]
+            ['default-env', 'file', '.js or .json file, merge to oox.config'],
+            ['env', 'file', `${chalk.bold.red('default-env')}.js or .json file, merge to oox.config, ${chalk.bold('(after default-env)')}`],
+            ['port', 'int', `default is ${chalk.bold('0')}, for random port, or any integer > 0`],
+            ['group', 'dir', 'service group directory, all LocalCall transform to RPC'],
+            ['ignore', 'name', 'set a name for LocalCall do not transform to RPC, support string | array<string>'],
+            ['http', 'json', 'HTTP server options, support flat name, ex: http.path=/api'],
+            ['socketio', 'json', 'SocketIO server options, support flat name'],
+            ['isRegistry', 'bool', `default is ${chalk.bold.red('true')}, set no to disable service registry`],
+            ['registryAdapter', 'name', 'set service registry adapter name'],
+            ['registry', 'urls', 'registry service url, support string | array<string>'],
+            ['origin', 'urls', `set ${chalk.bold('*')}, allow any connections <Access-Control-Allow-Origin>`],
+            ['errorStack', 'bool', 'set no to hidden error stack return'],
         ];
-        params.forEach(row => console.log(...row, '\n'));
+        console.log(mergeCommandParams(params));
+        console.log('  ...', 'set params as', chalk.bold('foo=bar') + ',', 'usage as', chalk.bold('oox.config.foo'));
         console.log();
     }
     if (isStartup) {
@@ -55,3 +58,27 @@ if (execFilename.endsWith('oox') || fileURLToPath(import.meta.url) === execFilen
         await startup();
     }
 }
+function mergeCommandParams(params) {
+    let result = '';
+    const perLinePrefix = ' '.repeat(2);
+    const nameMaxLength = 12;
+    const typeMaxLength = 6;
+    for (const param of params) {
+        const name = param[0];
+        const type = param[1];
+        const desc = param.slice(2).join(' ');
+        result += perLinePrefix + name;
+        if (name.length > nameMaxLength) {
+            result += '\n' + perLinePrefix;
+            result += ' '.repeat(nameMaxLength);
+        }
+        else {
+            result += ' '.repeat(nameMaxLength - name.length);
+        }
+        result += '[' + type + ']';
+        result += ' '.repeat(typeMaxLength - type.length);
+        result += desc;
+        result += '\n';
+    }
+    return result;
+}

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.keepAliveConnectionAdapters.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

@@ -1,11 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import * as app from './app.js';
 import { getIPAddress } from './utils.js';
+import * as registry from './registry.js';
 import Module, { ModuleConfig } from './modules/module.js';
-import Modules from './modules/index.js';
-export { Module, ModuleConfig };
-export const modules = new Modules;
-export const { asyncStore, setMethods, getMethods, kvMethods, sourceKVMethods, call, execute, logger, on, once, off, emit, } = app;
+import { KeepAliveConnection, keepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections } from './keepalive-connection.js';
 export class Context extends app.Context {
     // 请求溯源IP
     sourceIP = '';
@@ -24,6 +22,8 @@ export class Context extends app.Context {
     }
 }
 export class Config {
+    // 服务ID
+    id = randomUUID();
     // 服务名称
     name = 'local';
     // 服务列表路径
@@ -45,6 +45,12 @@ export class Config {
     origin = '';
     // 默认返回错误调用栈信息信息
     errorStack = true;
+    // 是否开启服务注册功能
+    isRegistry = true;
+    // 服务注册列表
+    registry = [];
+    // 服务注册适配器
+    registryAdapter = 'socketio';
 }
 export const config = new Config();
 let genTraceIdFunction = () => randomUUID();
@@ -78,55 +84,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());
@@ -141,7 +118,7 @@ export async function rpc(arg1, action, params, context) {
         context = getContext();
     }
     let connection;
-    if (arg1 instanceof RPCKeepAliveConnection) {
+    if (arg1 instanceof KeepAliveConnection) {
         connection = arg1;
     }
     else if ('string' === typeof arg1) {
@@ -151,5 +128,12 @@ 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);
 }
+export { KeepAliveConnection, keepAliveConnectionAdapters, keepAliveConnections, enabledKeepAliveConnections };
+export { Module, ModuleConfig };
+export { registry };
+export const { asyncStore, setMethods, getMethods, kvMethods, sourceKVMethods, call, execute, logger, on, once, off, emit, } = app;
+// 放在最后导入，解决循环依赖问题
+import Modules from './modules/index.js';
+export const modules = new Modules;

package/keepalive-connection.js

@@ -0,0 +1,96 @@
+import EventEmitter from 'node:events';
+export class KeepAliveConnection extends EventEmitter {
+    // 连接是否可用
+    #enabled = false;
+    data;
+    nativeConnection;
+    adapter;
+    constructor(adapter, nativeConnection, data) {
+        super();
+        this.adapter = adapter;
+        this.nativeConnection = nativeConnection;
+        this.data = Object.assign(data, {
+            adapter: adapter.name,
+        });
+    }
+    /**
+     * 设置连接是否可用，并自动触发enabled或disabled事件
+     * @param enabled 是否可用
+     */
+    set enabled(enabled) {
+        if (enabled !== this.#enabled) {
+            this.#enabled = enabled;
+            this.emit(enabled ? 'enabled' : 'disabled');
+            if (enabled) {
+                enabledKeepAliveConnections.add(this);
+            }
+            else {
+                enabledKeepAliveConnections.remove(this);
+            }
+        }
+    }
+    get enabled() {
+        return this.#enabled;
+    }
+    /**
+     * enable & mount connection
+     * @param params
+     * @returns
+     */
+    ready(params) {
+        // 连接已就绪，不允许重复就绪
+        if (this.enabled)
+            return;
+        const { id, name } = params;
+        keepAliveConnections.remove(this);
+        // 更新连接数据
+        this.data.id = id;
+        this.data.name = name;
+        keepAliveConnections.add(this);
+        this.enabled = true;
+    }
+}
+export class KeepAliveConnectionStore {
+    #map = new Map();
+    entries() {
+        return this.#map.entries();
+    }
+    getConnectionsOfService(name) {
+        return this.#map.get(name) || new Map();
+    }
+    has(name, id) {
+        const connections = this.#map.get(name);
+        if (!connections)
+            return false;
+        return connections.has(id);
+    }
+    get(name, id) {
+        const connections = this.#map.get(name);
+        if (!connections)
+            return null;
+        return connections.get(id) || null;
+    }
+    add(connection) {
+        const { name, id } = connection.data;
+        const connections = this.#map.get(name);
+        if (connections) {
+            connections.set(id, connection);
+        }
+        else {
+            this.#map.set(name, new Map([[id, connection]]));
+        }
+    }
+    remove(name, id) {
+        if (name instanceof KeepAliveConnection) {
+            id = name.data.id;
+            name = name.data.name;
+        }
+        const connections = this.#map.get(name);
+        if (connections && id !== undefined) {
+            connections.delete(id);
+        }
+    }
+}
+export const keepAliveConnectionAdapters = new Map();
+export const keepAliveConnections = new KeepAliveConnectionStore();
+export const enabledKeepAliveConnections = new KeepAliveConnectionStore();

package/modules/http/index.js

@@ -28,11 +28,11 @@ export default class HTTPModule extends Module {
     config = new HTTPConfig;
     server = null;
     router = new Router();
-    getUrl() {
+    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) {

package/modules/socketio/adapter.js

@@ -0,0 +1,37 @@
+import * as SocketIOClient from 'socket.io-client';
+import * as oox from '../../index.js';
+import { OOXEvent, genWebSocketURL } from './utils.js';
+import { randomUUID } from 'node:crypto';
+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(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 connection = new oox.KeepAliveConnection(this, socket, {
+            name: 'anonymous',
+            id: randomUUID(),
+            host: mURL.host,
+            url: mURL
+        });
+        return connection;
+    }
+}

package/modules/socketio/index.js

@@ -1,11 +1,7 @@
-import * as path from 'node:path';
-import SocketIOClient from './client.js';
+import * as PATH from 'node:path';
 import * as oox from '../../index.js';
-import { RPCKeepAliveConnection, removeKeepAliveConnection, addKeepAliveConnection, getKeepAliveConnections } from '../../index.js';
-import { sockets } from './socket.js';
-export { sockets };
-export default class SocketIOModule extends SocketIOClient {
-    sockets = sockets;
+import SocketINServer from './server.js';
+export default class SocketIOModule extends SocketINServer {
     async serve() {
         await this.stop();
         const _http = oox.modules.builtins.http;
@@ -18,154 +14,10 @@ export default class SocketIOModule extends SocketIOClient {
         // http 模块未被禁用
         isShareServer &&= httpConfig.enabled;
         if (isShareServer) {
-            config.path = path.posix.join(httpConfig.path, config.path);
+            config.path = PATH.posix.join(httpConfig.path, config.path);
             this.server = _http.server;
             this.config.ssl = _http.config.ssl;
         }
         await super.serve();
     }
-    onSyncConnection(socket) {
-        const mSockets = Array.from(sockets.values())
-            .filter(s => s !== socket &&
-            s.data.name !== socket.data.name &&
-            /^wss?:\/\/.+$/.test(s.data.id));
-        return mSockets.map(s => s.data);
-    }
-    serverOnDisconnect(socket, reason) {
-        super.serverOnDisconnect(socket, reason);
-        removeKeepAliveConnection(socket.data.name, socket.data.id);
-    }
-    clientOnDisconnect(socket, reason) {
-        super.clientOnDisconnect(socket, reason);
-        removeKeepAliveConnection(socket.data.name, socket.data.id);
-    }
-    /**
-     *
-     * @param socket 是由哪个通道发送过来的
-     * @param connectionDatas
-     */
-    clientOnSyncConnection(socket, connectionDatas) {
-        for (const data of connectionDatas)
-            if (!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 = sockets.get(id);
-        if (!socket) {
-            const connections = getKeepAliveConnections(id);
-            if (!connections || !connections.size)
-                throw new Error(`Unknown service identify<${id}>`);
-            id = connections.keys().next().value;
-            socket = 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 RPCKeepAliveConnection(this, id, socket.data);
-        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);
-        if (!oox.config.errorStack && returns.error) {
-            // 不返回错误调用栈信息
-            delete returns.error.stack;
-        }
-        '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, event, 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(event, ...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 { success, error, body } = await this.emit(url, 'call', [action, params, context]);
-        if (success)
-            return body;
-        else if (error)
-            throw new Error(error.message);
-        else
-            throw new Error('[RPC] Unknown Error');
-    }
 }