oox 0.2.0 → 0.3.0-beta10

package/index.js

@@ -1,6 +1,168 @@
-
-const Service = require ( './service/service.class' )
-
-module.exports = {
-    Service
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.emit = exports.off = exports.once = 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");
+const module_1 = require("./modules/module");
+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.logger = app.logger, exports.on = app.on, exports.once = app.once, exports.off = app.off, exports.emit = app.emit;
+class Context extends app.Context {
+    // 请求溯源IP
+    sourceIP = '';
+    // 请求者IP
+    ip = '';
+    // 请求者名称
+    caller = 'anonymous';
+    // 请求者ID (长连接专用)
+    callerId = '';
+    // 请求者连接把柄
+    connection;
+    toJSON() {
+        const context = Object.assign({}, this);
+        delete context.connection;
+        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();
+let genTraceIdFunction = () => (0, node_crypto_1.randomUUID)();
+function setGenTraceIdFunction(fn) {
+    genTraceIdFunction = fn;
+}
+exports.setGenTraceIdFunction = setGenTraceIdFunction;
+/**
+ * 生成随机不重复id
+ */
+function genTraceId() {
+    return genTraceIdFunction();
+}
+exports.genTraceId = genTraceId;
+/**
+ * 获取链路跟踪上下文
+ */
+function genContext(context) {
+    const newContext = Object.assign(new Context(), context);
+    if (!newContext.traceId)
+        newContext.traceId = genTraceId();
+    if (!newContext.sourceIP)
+        newContext.sourceIP = newContext.ip;
+    return newContext;
+}
+exports.genContext = genContext;
+function getContext() {
+    const context = exports.asyncStore.getStore();
+    return context || genContext();
+}
+exports.getContext = getContext;
+async function serve() {
+    await exports.modules.serve();
+}
+exports.serve = serve;
+async function stop() {
+    await exports.modules.stop();
+}
+exports.stop = stop;
+class RPCKeepAliveConnection {
+    data;
+    nativeConnection = null;
+    adapter = null;
+    constructor(adapter, nativeConnection, data) {
+        this.adapter = adapter;
+        this.nativeConnection = nativeConnection;
+        if (data)
+            this.data = data;
+    }
+}
+exports.RPCKeepAliveConnection = RPCKeepAliveConnection;
+exports.keepAliveConnections = new Map();
+function getKeepAliveConnections(name) {
+    return exports.keepAliveConnections.get(name) || new Map();
+}
+exports.getKeepAliveConnections = getKeepAliveConnections;
+function getKeepAliveConnection(name, id) {
+    const connections = exports.keepAliveConnections.get(name);
+    if (!connections)
+        return null;
+    return connections.get(id);
+}
+exports.getKeepAliveConnection = getKeepAliveConnection;
+function addKeepAliveConnection(connection) {
+    const { name, id } = connection.data;
+    if (exports.keepAliveConnections.has(name)) {
+        exports.keepAliveConnections.get(name).set(id, connection);
+    }
+    else {
+        exports.keepAliveConnections.set(name, new Map([[id, connection]]));
+    }
+}
+exports.addKeepAliveConnection = addKeepAliveConnection;
+function removeKeepAliveConnection(name, id) {
+    if (name instanceof RPCKeepAliveConnection) {
+        id = name.data.id;
+        name = name.data.name;
+    }
+    if (exports.keepAliveConnections.has(name)) {
+        const group = exports.keepAliveConnections.get(name);
+        group.delete(id);
+        if (!group.size)
+            exports.keepAliveConnections.delete(name);
+    }
+}
+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();
+    }
+    let connection;
+    if (arg1 instanceof RPCKeepAliveConnection) {
+        connection = arg1;
+    }
+    else if ('string' === typeof arg1) {
+        connection = loadBalancePolicy(arg1);
+        if (!connection)
+            throw new Error(`Connection<${arg1}> not found`);
+    }
+    else
+        throw new Error(`Unknown rpc arg1<${arg1}>`);
+    return connection.adapter.rpc(connection.nativeConnection, action, params, context);
+}
+exports.rpc = rpc;

package/index.mjs

@@ -0,0 +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

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPConfig = void 0;
+const http = require("node:http");
+const node_querystring_1 = require("node:querystring");
+const utils_1 = require("./utils");
+const oox = require("../../index");
+const module_1 = require("../module");
+class HTTPConfig extends module_1.ModuleConfig {
+    // listen port
+    port = 0;
+    // service path
+    path = '/';
+    // browser cross origin
+    origin = '';
+}
+exports.HTTPConfig = HTTPConfig;
+class HTTPModule extends module_1.default {
+    name = 'http';
+    config = new HTTPConfig;
+    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;
+    }
+    /**
+     * start http service
+     */
+    async serve() {
+        await this.stop();
+        const { port } = this.config;
+        this.server = http.createServer(this.call.bind(this));
+        this.server.listen(port);
+        const address = this.server.address();
+        if (!address || 'object' !== typeof address)
+            throw new Error('Cannot read http server port');
+        this.config.port = address.port;
+    }
+    /**
+     * 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();
+                });
+            });
+    }
+    /**
+     * browser cross origin
+     */
+    cors(request, response) {
+        // origin checking
+        const origin = this.config.origin;
+        const requestOrigin = request.headers.origin;
+        if (origin && requestOrigin) {
+            if (origin === '*' || origin === requestOrigin || Array.isArray(origin) && origin.includes(requestOrigin)) {
+                response.setHeader('Access-Control-Allow-Origin', requestOrigin);
+                response.setHeader('Vary', 'Origin');
+            }
+            else {
+                response.statusCode = 403;
+                response.end();
+                return false;
+            }
+            response.setHeader('Access-Control-Max-Age', 3600);
+            response.setHeader('Access-Control-Allow-Headers', 'x-caller,content-type');
+            response.setHeader('Access-Control-Allow-Methods', '*');
+        }
+        if (request.method === 'OPTIONS') {
+            response.statusCode = 204;
+            response.end();
+            return false;
+        }
+        return true;
+    }
+    /**
+     * HTTP-RPC服务器请求监听方法
+     */
+    async call(request, response) {
+        if (request.url !== this.config.path) {
+            const error = {
+                message: 'Invalid URL',
+                stack: ''
+            };
+            Error.captureStackTrace(error);
+            return this.respond(request, response, {
+                success: false,
+                error
+            });
+        }
+        if (!this.cors(request, response))
+            return;
+        let body = Object.create(null);
+        try {
+            if ('GET' === request.method) {
+                body = (0, node_querystring_1.parse)(request.url.split('?').pop());
+            }
+            else {
+                body = await (0, utils_1.parseHTTPBody)(request);
+            }
+            if (!body || 'object' !== typeof body)
+                throw new Error('Content Invalid');
+        }
+        catch (error) {
+            return this.respond(request, response, {
+                success: false,
+                error: {
+                    message: error.message,
+                    stack: error.stack
+                }
+            });
+        }
+        // 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 = 'index', params = [] } = body;
+        const context = oox.genContext({ traceId, caller, sourceIP, ip, callerId: '' });
+        const format = await oox.call(action, params, context);
+        this.respond(request, response, format);
+    }
+    /**
+     * HTTP Response Catch
+     */
+    respond(request, response, format) {
+        let formatString = '';
+        try {
+            formatString = JSON.stringify(format);
+        }
+        catch ({ message, stack }) {
+            delete format.body;
+            format.success = false;
+            format.error = {
+                message,
+                stack
+            };
+            formatString = JSON.stringify(format);
+        }
+        response.setHeader('Content-Type', 'application/json');
+        response.setHeader('Content-Length', Buffer.byteLength(formatString));
+        response.end(formatString);
+    }
+    /**
+     * 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 (0, utils_1.httpRequest)(url, {
+            headers
+        }, JSON.stringify({ action, params }));
+        if ('string' === typeof format)
+            throw new Error(format);
+        const { error, body } = format;
+        if (error) {
+            const asyncError = new Error(error.message);
+            throw asyncError;
+        }
+        else {
+            return body;
+        }
+    }
+}
+exports.default = HTTPModule;

package/modules/http/utils.js

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

package/modules/index.js

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

package/modules/module.js

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

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;