wenay-common2 1.0.33 → 1.0.36

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.d.ts

@@ -15,6 +15,7 @@ export declare function createRpcServerAuto2<T extends object>({ socket, object:
     onProtocolDetect?: (protocol: 'v2' | 'legacy') => void;
 }): {
     getProtocol: () => ClientProtocol;
-    getSchema: () => any;
+    getLegacySchema: () => any;
+    getResolved: () => any;
 };
 export {};

package/lib/Common/rcp/createRpcServerAutoWithProtocolDetection.js

@@ -6,7 +6,9 @@ const listen_socket_1 = require("./listen-socket");
 const rpc_server_1 = require("./rpc-server");
 const rpc_protocol_1 = require("./rpc-protocol");
 const old_ommonsServerMini_1 = require("./old\u0421ommonsServerMini");
-function createRpcServerAuto_({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits }) {
+const rpc_dynamic_1 = require("./rpc-dynamic");
+const rpc_limits_1 = require("./rpc-limits");
+function createRpcServerAuto({ socket, object: target, socketKey: key, debug, hooks, disconnectListen, limits }) {
     const cache = new WeakMap();
     function getListenSocket(parent, disconnectListen) {
         let result = cache.get(parent);
@@ -44,14 +46,21 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
         return getListenSocket(obj);
     }
     function transformTree(obj) {
-        if (obj == null || typeof obj !== 'object')
-            return obj;
-        const transformed = resolveTransform(obj);
-        if (transformed !== obj)
-            return transformed;
+        let current = obj;
+        if (!(0, rpc_dynamic_1.isNoStrict)(current)) {
+            current = resolveTransform(current);
+        }
+        if (current == null || typeof current !== 'object' || (0, rpc_dynamic_1.isNoStrict)(current))
+            return current;
         const out = {};
-        for (const k of Object.keys(obj)) {
-            const v = obj[k];
+        for (const k of Object.keys(current)) {
+            if (!(0, rpc_limits_1.isSafeKey)(k))
+                continue;
+            const v = current[k];
+            if ((0, rpc_dynamic_1.isNoStrict)(v)) {
+                out[k] = v;
+                continue;
+            }
             out[k] = typeof v === 'function' ? v : (v != null && typeof v === 'object') ? transformTree(v) : v;
         }
         return out;
@@ -59,35 +68,49 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
     function serialize(obj) {
         const out = {};
         for (const k of Object.keys(obj)) {
+            if (!(0, rpc_limits_1.isSafeKey)(k))
+                continue;
             const v = obj[k];
-            if (v == null)
-                out[k] = 'null';
-            else if (typeof v === 'function')
-                out[k] = 'func';
-            else if (typeof v === 'object')
-                out[k] = serialize(v);
-            else
-                out[k] = 'unknown';
+            switch (true) {
+                case v == null:
+                    out[k] = 'null';
+                    break;
+                case (0, rpc_dynamic_1.isNoStrict)(v):
+                    out[k] = 'dynamic';
+                    break;
+                case typeof v === 'function':
+                    out[k] = 'func';
+                    break;
+                case typeof v === 'object':
+                    out[k] = serialize(v);
+                    break;
+                default:
+                    out[k] = 'unknown';
+                    break;
+            }
         }
         return out;
     }
     const resolved = transformTree(target);
-    const strictSchema = serialize(resolved);
+    const legacySchema = serialize(resolved);
     let protocol = null;
     let v2Handler = null;
     let legacyHandler = null;
+    function isLegacyStrictRequest(msg) {
+        return msg === '___STRICTLY';
+    }
     function isLegacyMessage(msg) {
         return (typeof msg === 'object' &&
             msg !== null &&
             !Array.isArray(msg) &&
-            typeof msg.mapId === 'number' &&
-            (msg.data !== undefined || msg.error !== undefined));
-    }
-    function isLegacyStrictRequest(msg) {
-        return msg === '___STRICTLY';
+            typeof msg.mapId === 'number');
     }
     function isV2Message(msg) {
-        return (Array.isArray(msg) && (msg[0] === rpc_protocol_1.Pkt.CALL || msg[0] === rpc_protocol_1.Pkt.PIPE)) || msg === rpc_protocol_1.Pkt.STRICT;
+        if (msg === rpc_protocol_1.Pkt.STRICT)
+            return true;
+        if (Array.isArray(msg) && (msg[0] === rpc_protocol_1.Pkt.CALL || msg[0] === rpc_protocol_1.Pkt.PIPE))
+            return true;
+        return false;
     }
     function initLegacy() {
         if (legacyHandler)
@@ -97,7 +120,11 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
             sendMessage: (msg) => socket.emit(key, msg),
             api: ({ onMessage }) => { onMessageCb = onMessage; },
         }, resolved);
-        legacyHandler = (msg) => onMessageCb?.(msg);
+        legacyHandler = (msg) => {
+            if (!onMessageCb)
+                return;
+            onMessageCb(msg);
+        };
     }
     function initV2() {
         if (v2Handler)
@@ -108,64 +135,72 @@ function createRpcServerAuto2({ socket, object: target, socketKey: key, debug =
             on: (e, cb) => { if (e === key)
                 onMsgCb = cb; },
         };
-        if (debug) {
-            const origOn = innerSocket.on.bind(innerSocket);
-            innerSocket.on = (e, cb) => origOn(e, (d) => { console.log('[RPC IN]', typeof d === 'object' ? JSON.stringify(d) : d); cb(d); });
-        }
         (0, rpc_server_1.createRpcServer)({
             socket: innerSocket,
             object: target,
             socketKey: key,
-            debug: false,
+            debug,
             limits,
             hooks: {
                 ...hooks,
                 resolveTransform,
             },
         });
-        v2Handler = (msg) => onMsgCb?.(msg);
+        v2Handler = (msg) => {
+            if (!onMsgCb)
+                return;
+            onMsgCb(msg);
+        };
     }
     socket.on(key, (msg) => {
         if (debug) {
-            console.log('[RPC-AUTO2]', typeof msg === 'object' ? JSON.stringify(msg) : msg);
+            console.log('[RPC-AUTO2 IN]', typeof msg === 'object' ? JSON.stringify(msg) : msg);
         }
-        if (protocol === null) {
+        if (protocol === 'legacy') {
             if (isLegacyStrictRequest(msg)) {
-                protocol = 'legacy';
-                onProtocolDetect?.('legacy');
-                socket.emit(key, { STRICTLY: strictSchema });
-                initLegacy();
-                return;
-            }
-            if (isLegacyMessage(msg)) {
-                protocol = 'legacy';
-                onProtocolDetect?.('legacy');
-                initLegacy();
-                legacyHandler(msg);
-                return;
-            }
-            if (isV2Message(msg)) {
-                protocol = 'v2';
-                onProtocolDetect?.('v2');
-                initV2();
-                v2Handler(msg);
+                socket.emit(key, { STRICTLY: legacySchema });
                 return;
             }
+            legacyHandler(msg);
             return;
         }
-        if (protocol === 'legacy') {
-            if (isLegacyStrictRequest(msg)) {
-                socket.emit(key, { STRICTLY: strictSchema });
-                return;
-            }
+        if (protocol === 'v2') {
+            v2Handler(msg);
+            return;
+        }
+        if (isLegacyStrictRequest(msg)) {
+            protocol = 'legacy';
+            if (debug)
+                console.log('[RPC-AUTO2] Protocol detected: legacy (___STRICTLY)');
+            onProtocolDetect?.('legacy');
+            initLegacy();
+            socket.emit(key, { STRICTLY: legacySchema });
+            return;
+        }
+        if (isLegacyMessage(msg)) {
+            protocol = 'legacy';
+            if (debug)
+                console.log('[RPC-AUTO2] Protocol detected: legacy (mapId message)');
+            onProtocolDetect?.('legacy');
+            initLegacy();
             legacyHandler(msg);
+            return;
         }
-        else {
+        if (isV2Message(msg)) {
+            protocol = 'v2';
+            if (debug)
+                console.log('[RPC-AUTO2] Protocol detected: v2');
+            onProtocolDetect?.('v2');
+            initV2();
             v2Handler(msg);
+            return;
         }
+        if (debug)
+            console.warn('[RPC-AUTO2] Unknown message format, ignoring:', msg);
     });
     return {
         getProtocol: () => protocol,
-        getSchema: () => strictSchema,
+        getLegacySchema: () => legacySchema,
+        getResolved: () => resolved,
     };
 }

package/lib/Common/rcp/rpc-client.js

@@ -14,6 +14,11 @@ function createClient(socket, key, opts) {
     let strictData = {};
     let strictWaiters = [];
     let debug = false;
+    const unpackResult = (v) => {
+        if (!v)
+            return v;
+        return v;
+    };
     socket.on(key, (msg) => {
         if (!Array.isArray(msg))
             return;
@@ -28,7 +33,7 @@ function createClient(socket, key, opts) {
                     callbacks.delete(cbId);
                     pool.release(cbId);
                 }
-                msg[3] ? req.fail(msg[3]) : req.ok(msg[2]);
+                msg[3] ? req.fail(msg[3]) : req.ok(unpackResult(msg[2]));
                 break;
             }
             case rpc_protocol_1.Pkt.CB: {

package/lib/Common/rcp/rpc-clientHub.js

@@ -23,12 +23,18 @@ function createRpcClientHub(createSocket, schemaBuilder) {
             const targetSocketKey = schema[key].socketKey || key;
             const client = (0, rpc_client_1.createRpcClient)({ socketKey: targetSocketKey, socket });
             facade[key] = client;
-            if (client && typeof client.initStrict === "function") {
-                client.initStrict();
+        }
+        function hi() {
+            for (const key in schema) {
+                const client = facade[key];
+                if (client && typeof client.initStrict === "function") {
+                    client.initStrict();
+                }
             }
         }
         socket?.on("connect", () => {
             connectCount++;
+            hi();
             onConnectCb?.(connectCount);
             if (resolveFunc) {
                 const a = resolveFunc;

package/lib/Common/rcp/rpc-server.js

@@ -186,13 +186,13 @@ function createServer(socket, key, target, hooks, limits) {
                     current = await current;
                 }
                 if (wait)
-                    send([rpc_protocol_1.Pkt.RESP, reqId, current]);
+                    send([rpc_protocol_1.Pkt.RESP, reqId, (0, rpc_walk_1.packResult)(current)]);
             }
             else {
                 const args = (0, rpc_walk_1.unpack)(rawArgsOrSteps, (cbId, cbArgs) => send([rpc_protocol_1.Pkt.CB, cbId, cbArgs]), (cbId) => send([rpc_protocol_1.Pkt.CB_END, cbId]), lim);
                 const res = await fn.apply(ctx, args);
                 if (wait)
-                    send([rpc_protocol_1.Pkt.RESP, reqId, res]);
+                    send([rpc_protocol_1.Pkt.RESP, reqId, (0, rpc_walk_1.packResult)(res)]);
             }
         }
         catch (e) {

package/lib/Common/rcp/rpc-walk.d.ts

@@ -2,7 +2,9 @@ import { idPool } from "../id-pool";
 import { type RpcLimits } from "./rpc-limits";
 export declare function walk(val: any, onLeaf: (v: any) => any, lim?: Required<RpcLimits>, depth?: number): any;
 export declare function pack(args: any[], pool: idPool, cbStore: Map<number, Function>, cbIds: number[]): any[];
+export declare function packResult(value: any): any;
 export declare function rpcEndCallback(fn: Function): void;
 export declare function unpack(args: any[], sender: (id: number, a: any[]) => void, onEnd: (id: number) => void, lim?: Required<RpcLimits>): any[];
+export declare function unpackResult(value: any, lim?: Required<RpcLimits>): any;
 export declare const errToObj: (e: any) => any;
 export declare const resolveCA: (path: string[], args: any[]) => [string[], any[]];

package/lib/Common/rcp/rpc-walk.js

@@ -3,10 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveCA = exports.errToObj = void 0;
 exports.walk = walk;
 exports.pack = pack;
+exports.packResult = packResult;
 exports.rpcEndCallback = rpcEndCallback;
 exports.unpack = unpack;
+exports.unpackResult = unpackResult;
 const rpc_limits_1 = require("./rpc-limits");
 const FN_MARKER = "$_f";
+const DATE_MARKER = "$_d";
+const MAP_MARKER = "$_m";
+const SET_MARKER = "$_s";
+const REGEXP_MARKER = "$_r";
+const BIGINT_MARKER = "$_b";
+const ALL_MARKERS = new Set([FN_MARKER, DATE_MARKER, MAP_MARKER, SET_MARKER, REGEXP_MARKER, BIGINT_MARKER]);
+const DESERIALIZERS = {
+    [DATE_MARKER]: (v) => new Date(v),
+    [MAP_MARKER]: (v) => new Map(v),
+    [SET_MARKER]: (v) => new Set(v),
+    [REGEXP_MARKER]: (v) => new RegExp(v.source, v.flags),
+    [BIGINT_MARKER]: (v) => BigInt(v),
+};
+const SERIALIZERS = [
+    (v) => v instanceof Date ? [DATE_MARKER, v.valueOf()] : null,
+    (v) => v instanceof Map ? [MAP_MARKER, Array.from(v.entries())] : null,
+    (v) => v instanceof Set ? [SET_MARKER, Array.from(v.values())] : null,
+    (v) => v instanceof RegExp ? [REGEXP_MARKER, { source: v.source, flags: v.flags }] : null,
+    (v) => typeof v === "bigint" ? [BIGINT_MARKER, v.toString()] : null,
+];
 function walk(val, onLeaf, lim, depth = 0) {
     if (lim) {
         if (depth > lim.maxDepth)
@@ -16,7 +38,7 @@ function walk(val, onLeaf, lim, depth = 0) {
     }
     if (val == null || typeof val !== "object")
         return onLeaf(val);
-    if (val[FN_MARKER] !== undefined)
+    if (ALL_MARKERS.has(Object.keys(val)[0]))
         return onLeaf(val);
     if (Array.isArray(val)) {
         if (lim && val.length > lim.maxArrayLen)
@@ -32,6 +54,26 @@ function walk(val, onLeaf, lim, depth = 0) {
             o[k] = walk(val[k], onLeaf, lim, depth + 1);
     return o;
 }
+function deserializeLeaf(leaf, onCallback) {
+    if (leaf == null || typeof leaf !== "object")
+        return leaf;
+    const key = Object.keys(leaf)[0];
+    if (!key)
+        return leaf;
+    if (key === FN_MARKER) {
+        return onCallback?.(leaf[FN_MARKER]) ?? leaf;
+    }
+    const deserialize = DESERIALIZERS[key];
+    return deserialize ? deserialize(leaf[key]) : leaf;
+}
+function serializeLeaf(leaf) {
+    for (const serializer of SERIALIZERS) {
+        const result = serializer(leaf);
+        if (result)
+            return { [result[0]]: result[1] };
+    }
+    return leaf;
+}
 function pack(args, pool, cbStore, cbIds) {
     return args.map(v => walk(v, leaf => {
         if (typeof leaf == "function") {
@@ -40,9 +82,12 @@ function pack(args, pool, cbStore, cbIds) {
             cbIds.push(id);
             return { [FN_MARKER]: id };
         }
-        return leaf;
+        return serializeLeaf(leaf);
     }));
 }
+function packResult(value) {
+    return walk(value, leaf => serializeLeaf(leaf));
+}
 const _stopRegistry = new WeakMap();
 function rpcEndCallback(fn) {
     _stopRegistry.get(fn)?.();
@@ -66,9 +111,12 @@ function unpack(args, sender, onEnd, lim) {
             _stopRegistry.set(wrapper, () => onEnd(id));
             return wrapper;
         }
-        return leaf;
+        return deserializeLeaf(leaf);
     }, lim));
 }
+function unpackResult(value, lim) {
+    return walk(value, leaf => deserializeLeaf(leaf), lim);
+}
 const errToObj = (e) => e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : e;
 exports.errToObj = errToObj;
 const resolveCA = (path, args) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common2",
-  "version": "1.0.33",
+  "version": "1.0.36",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",