js-rpc2 1.2.3 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-rpc2",
-  "version": "1.2.3",
+  "version": "2.0.0",
   "description": "js web websocket http rpc",
   "main": "index.js",
   "type": "module",
@@ -30,5 +30,8 @@
     "@types/node": "^22.13.14",
     "koa": "^2.15.3",
     "ws": "^8.18.0"
+  },
+  "dependencies": {
+    "msgpackr": "^1.11.5"
   }
 }

package/src/lib.js

@@ -1,19 +1,14 @@
+import { Packr } from 'msgpackr'
+
 /**
- * @import { ExtensionApi } from "./types.js"
+ * @import { CALLBACK_ITEM, ExtensionApi, RPC_DATA, RPC_DATA_ARG_ITEM } from "./types.js"
  */
 
 const JS_RPC_WITH_CRYPTO = true
 
 export const sleep = (/** @type {number} */ timeout) => new Promise((resolve) => setTimeout(resolve, timeout))
 
-
-/**
- * @typedef {{
- * promise: Promise<any>;
- * resolve: (value: any | null) => void;
- * reject: (reason: any | null) => void;
- * }} PromiseResolvers
- */
+const packr = new Packr({ structuredClone: true, useBigIntExtension: true, moreTypes: true, copyBuffers: true, })
 
 export function Promise_withResolvers() {
     /** @type{(value?:object)=>void} */
@@ -355,127 +350,29 @@ export async function timeWaitRetryLoop(signal, callback) {
 
 export const RPC_TYPE_CALL = 0xdf68f4cb
 export const RPC_TYPE_RETURN = 0x68b17581
-export const RPC_TYPE_RETURN_ARRAY = 0xceddbf64
 export const RPC_TYPE_CALLBACK = 0x8d65e5cc
 export const RPC_TYPE_ERROR = 0xa07c0f84
 
-/**
- * @typedef {RPC_TYPE_CALL
- * |RPC_TYPE_RETURN
- * |RPC_TYPE_RETURN_ARRAY
- * |RPC_TYPE_CALLBACK
- * |RPC_TYPE_ERROR} RPC_TYPES
- */
-
-/**
- * @typedef {{
- * id:number;
- * type:RPC_TYPES;
- * promise?:PromiseResolvers;
- * callback?:(...data:object)=>void;
- * }} CALLBACK_ITEM
- */
-
-/**
- * @typedef {{type:RPC_DATA_ARG_TYPE;data:object}} RPC_DATA_ARG_ITEM
- * @typedef {{
- * id:number;
- * type:RPC_TYPES;
- * data:{type:RPC_DATA_ARG_TYPE;data:object}[];
- * }} RPC_DATA
- */
-
-export const RPC_DATA_ARG_TYPE_OBJECT = 0xa7f68c
+export const RPC_DATA_ARG_TYPE_OTHERS = 0xa7f68c
 export const RPC_DATA_ARG_TYPE_FUNCTION = 0x7ff45f
-export const RPC_DATA_ARG_TYPE_UINT8ARRAY = 0xedb218
-export const RPC_DATA_ARG_TYPE_UNDEFINED = 0x7f77fe
-export const RPC_DATA_ARG_TYPE_NULL = 0x5794f9
 
 /**
- * @typedef {RPC_DATA_ARG_TYPE_OBJECT
- * |RPC_DATA_ARG_TYPE_FUNCTION
- * |RPC_DATA_ARG_TYPE_UINT8ARRAY
- * |RPC_DATA_ARG_TYPE_UNDEFINED
- * |RPC_DATA_ARG_TYPE_NULL} RPC_DATA_ARG_TYPE
+ * @typedef {RPC_DATA_ARG_TYPE_OTHERS|RPC_DATA_ARG_TYPE_FUNCTION} RPC_DATA_ARG_TYPE
  */
 
 /**
  * @param {RPC_DATA} box
  */
 export function buildRpcData(box) {
-    let buffers = [
-        buildBufferNumberUInt32LE(box.id),
-        buildBufferNumberUInt32LE(box.type),
-        buildBufferNumberUInt32LE(box.data.length),
-    ]
-    for (const o of box.data) {
-        if (o.type == RPC_DATA_ARG_TYPE_UINT8ARRAY) {
-            buffers.push(buildBufferNumberUInt32LE(o.type))
-            buffers.push(buildBufferNumberUInt32LE(o.data.length))
-            buffers.push(o.data)
-        }
-        if (o.type == RPC_DATA_ARG_TYPE_FUNCTION) {
-            buffers.push(buildBufferNumberUInt32LE(o.type))
-            buffers.push(buildBufferSizeString(o.data))
-        }
-        if (o.type == RPC_DATA_ARG_TYPE_OBJECT) {
-            buffers.push(buildBufferNumberUInt32LE(o.type))
-            buffers.push(buildBufferSizeString(JSON.stringify(o.data)))
-        }
-        if (o.type == RPC_DATA_ARG_TYPE_UNDEFINED) {
-            buffers.push(buildBufferNumberUInt32LE(o.type))
-        }
-        if (o.type == RPC_DATA_ARG_TYPE_NULL) {
-            buffers.push(buildBufferNumberUInt32LE(o.type))
-        }
-    }
-    return Uint8Array_concat(buffers)
+    return Uint8Array.from(packr.pack(box))
 }
 
 /**
  * @param {Uint8Array} buffer
  */
 export function parseRpcData(buffer) {
-    let offset = 0
-    let id = readUInt32LE(buffer, offset)
-    offset += 4
-    /** @type{*} */
-    let type = readUInt32LE(buffer, offset)
-    offset += 4
-    let dataLength = readUInt32LE(buffer, offset)
-    offset += 4
-    /** @type{RPC_DATA_ARG_ITEM[]} */
-    let args = []
-    for (let i = 0; i < dataLength; i++) {
-        let type = readUInt32LE(buffer, offset)
-        offset += 4
-        if (type == RPC_DATA_ARG_TYPE_UINT8ARRAY) {
-            let size = readUInt32LE(buffer, offset)
-            offset += 4
-            let data = buffer.slice(offset, offset + size)
-            offset += size
-            args.push({ type: type, data })
-        }
-        if (type == RPC_DATA_ARG_TYPE_FUNCTION) {
-            let o = readBufferSizeString(buffer, offset)
-            offset += o.size
-            args.push({ type: type, data: o.string })
-        }
-        if (type == RPC_DATA_ARG_TYPE_OBJECT) {
-            let o = readBufferSizeString(buffer, offset)
-            offset += o.size
-            let data = o.string
-            args.push({ type: type, data: JSON.parse(data) })
-        }
-        if (type == RPC_DATA_ARG_TYPE_UNDEFINED) {
-            args.push({ type: type, data: undefined })
-        }
-        if (type == RPC_DATA_ARG_TYPE_NULL) {
-            args.push({ type: type, data: null })
-        }
-    }
     /** @type{RPC_DATA} */
-    let box = { id, type, data: args }
+    let box = packr.unpack(buffer)
     return box
 }
 
@@ -489,55 +386,18 @@ export function buildRpcItemData(items) {
         /** @type{RPC_DATA_ARG_TYPE} */
         let type = null
         let data = null
-        if (item === undefined) {
-            type = RPC_DATA_ARG_TYPE_UNDEFINED
-            data = item
-        } else if (item === null) {
-            type = RPC_DATA_ARG_TYPE_NULL
-            data = item
-        } else if (item instanceof Uint8Array) {
-            type = RPC_DATA_ARG_TYPE_UINT8ARRAY
-            data = item
-        } else if (typeof item == 'function') {
+        if (typeof item == 'function') {
             type = RPC_DATA_ARG_TYPE_FUNCTION
             data = item()
         } else {
-            type = RPC_DATA_ARG_TYPE_OBJECT
-            data = JSON.stringify(item)
+            type = RPC_DATA_ARG_TYPE_OTHERS
+            data = item
         }
         arr.push({ type, data })
     }
     return arr
 }
 
-/**
- * @param {RPC_DATA_ARG_ITEM[]} array
- */
-export function parseRpcItemData(array) {
-    /** @type{RPC_DATA_ARG_ITEM[]} */
-    let items = []
-    for (let i = 0; i < array.length; i++) {
-        const o = array[i]
-        if (o.type == RPC_DATA_ARG_TYPE_FUNCTION) {
-            o.data = o.data
-        }
-        if (o.type == RPC_DATA_ARG_TYPE_NULL) {
-            o.data = null
-        }
-        if (o.type == RPC_DATA_ARG_TYPE_UNDEFINED) {
-            o.data = undefined
-        }
-        if (o.type == RPC_DATA_ARG_TYPE_UINT8ARRAY) {
-            o.data = o.data
-        }
-        if (o.type == RPC_DATA_ARG_TYPE_OBJECT) {
-            o.data = JSON.parse(o.data)
-        }
-        items.push(o)
-    }
-    return items
-}
-
 /**
  * @template T
  * @param {ExtensionApi<T>} extension
@@ -555,7 +415,7 @@ export async function rpcRunServerDecodeBuffer(extension, writer, buffer, logger
     try {
         let o = parseRpcData(buffer)
         dataId = o.id
-        let items = parseRpcItemData(o.data)
+        let items = o.data
         fnName = items.at(0).data
         let args = items.slice(1)
         for (let i = 0; i < args.length; i++) {
@@ -576,11 +436,7 @@ export async function rpcRunServerDecodeBuffer(extension, writer, buffer, logger
             }
         }
         let ret = await extension[fnName](...params)
-        if (Array.isArray(ret)) {
-            box = { id: o.id, type: RPC_TYPE_RETURN_ARRAY, data: buildRpcItemData(ret), }
-        } else {
-            box = { id: o.id, type: RPC_TYPE_RETURN, data: buildRpcItemData([ret]), }
-        }
+        box = { id: o.id, type: RPC_TYPE_RETURN, data: ret, }
     } catch (error) {
         console.error('rpcRunServerDecodeBuffer', fnName, params.map(o => {
             if (typeof o == 'function') { return 'function' }
@@ -589,7 +445,7 @@ export async function rpcRunServerDecodeBuffer(extension, writer, buffer, logger
         box = {
             id: dataId,
             type: RPC_TYPE_ERROR,
-            data: buildRpcItemData([error.message, error.stack]),
+            data: { message: error.message, stack: error.stack },
         }
     }
     if (logger) {
@@ -618,7 +474,7 @@ export function createRPCProxy(apiInvoke) {
                     try {
                         return await apiInvoke(String(p), argArray)
                     } catch (error) {
-                        throw new Error(error.message, { cause: error })
+                        throw new RPCError(error.message, null, { cause: error })
                     }
                 }
             })
@@ -712,22 +568,20 @@ export function createRpcClientHelper(param) {
         async write(buffer) {
             try {
                 let data = parseRpcData(buffer)
-                let items = parseRpcItemData(data.data)
+                let items = data.data
                 if (callbackFunctionMap.has(data.id)) {
                     let o = callbackFunctionMap.get(data.id)
                     if (data.type == RPC_TYPE_ERROR) {
-                        o.promise.reject(new RPCError(items.at(0).data, items.at(1).data))
+                        let error = data.data
+                        o.promise.reject(new RPCError(error.message, error.stack))
                     }
                     if (data.type == RPC_TYPE_RETURN) {
                         callbackFunctionMap.delete(data.id)
-                        o.promise.resolve(items.at(0).data)
-                    }
-                    if (data.type == RPC_TYPE_RETURN_ARRAY) {
-                        callbackFunctionMap.delete(data.id)
-                        o.promise.resolve(items.map(o => o.data))
+                        o.promise.resolve(data.data)
                     }
                     if (data.type == RPC_TYPE_CALLBACK) {
-                        o.callback(...items.map(o => o.data))
+                        let args = items.map((/** @type {{ data: any; }} */ o) => o.data)
+                        o.callback.apply(o, args)
                     }
                 }
             } catch (error) {

package/src/lib.test.js

@@ -1,5 +1,5 @@
 import { test } from 'node:test'
-import { deepStrictEqual, ok, strictEqual } from 'node:assert'
+import { deepStrictEqual, fail, ok, strictEqual } from 'node:assert'
 import { createRpcClientHttp, createRpcClientWebSocket, sleep, Uint8Array_from } from './lib.js'
 import { createServer } from 'node:http'
 import { WebSocketServer } from 'ws'
@@ -9,6 +9,7 @@ import { createRpcServerKoaRouter, createRpcServerWebSocket } from './server.js'
 import { AsyncLocalStorage } from 'node:async_hooks'
 import { Readable, Transform } from 'node:stream'
 import { pipeline } from 'node:stream/promises'
+import { Packr } from 'msgpackr'
 
 test('basic', async () => {
     // node --test-name-pattern="^basic$" src/lib.test.js
@@ -354,7 +355,9 @@ test('error-stack', async () => {
     const router = new Router()
     app.use(router.routes())
     app.use(router.allowedMethods())
-    let server = createServer(app.callback()).listen(9000)
+    let server = createServer(app.callback()).listen(9001)
+    using s = new DisposableStack()
+    s.adopt(0, () => { server.close() })
 
     class RpcApi {
         asyncLocalStorage = new AsyncLocalStorage()
@@ -377,16 +380,17 @@ test('error-stack', async () => {
     /** @type{RpcApi} */
     const rpc = createRpcClientHttp({
         // url: `/rpc/abc`,                      // in same site html page
-        url: `http://127.0.0.1:9000/rpc/abc`, // others
+        url: `http://127.0.0.1:9001/rpc/abc`, // others
     })
 
     try {
         let ret = await rpc.hello()
         console.info(ret)
+        fail('boom')
     } catch (error) {
         console.error(error)
+        ok(error.cause.stack.includes('at RpcApi.hello'))
     }
-    server.close()
 
 })
 
@@ -467,4 +471,116 @@ test('async-local-storage-stream', async () => {
     await sleep(100)
 
     await Promise.all([p1.promise])
+})
+
+test('msgpackr', async () => {
+    // node --test-name-pattern="^msgpackr$" src/lib.test.js
+    let value = {
+        int: 99,
+        float: 0.3,
+        bigint: 3000n,
+        string: "string",
+        bool: true,
+        date: new Date('2000-01-02 03:04:05.678'),
+        uint8array: Uint8Array.from([12, 34, 56, 78]),
+        object: { a: 1, b: 2 },
+        array: [1, 2, 3, 'a', 'b', 'c'],
+        map: new Map(),
+        set: new Set(),
+
+        // 补充更多类型
+        null: null,
+        undefined: undefined,
+        emptyString: "",
+        zero: 0,
+        negativeInt: -42,
+        negativeFloat: -3.14,
+        infinity: Infinity,
+        negativeInfinity: -Infinity,
+        nan: NaN,
+
+        // 大数字测试
+        largeInt: 9007199254740991, // Number.MAX_SAFE_INTEGER
+        veryLargeBigInt: 123456789012345678901234567890n,
+
+        // 字符串测试
+        unicodeString: "Hello 世界 🌍",
+        specialChars: "特殊字符: \n\t\r\\\"'",
+
+        // 数组测试
+        emptyArray: [],
+        nestedArray: [1, [2, 3], [4, [5, 6]]],
+        mixedTypeArray: [1, "string", true, null, { x: 1 }],
+
+        // 对象测试
+        emptyObject: {},
+        nestedObject: {
+            level1: {
+                level2: {
+                    value: "deep"
+                }
+            }
+        },
+        objectWithSpecialKeys: {
+            "": "empty key",
+            "123": "numeric key",
+            "key with spaces": "value"
+        },
+
+        // Map 和 Set 扩展测试
+        // @ts-ignore
+        mapWithMixedTypes: new Map([
+            ['string', 'value'],
+            [123, 'number key'],
+            [true, 'boolean key'],
+            [null, 'null key'],
+            [{ nested: 'key' }, 'object key']
+        ]),
+        setWithMixedValues: new Set([1, 'string', true, null, undefined]),
+        emptyMap: new Map(),
+        emptySet: new Set(),
+
+        // TypedArray 测试
+        int8Array: new Int8Array([-128, -1, 0, 1, 127]),
+        int16Array: new Int16Array([-32768, -1, 0, 1, 32767]),
+        int32Array: new Int32Array([-2147483648, -1, 0, 1, 2147483647]),
+        uint8ClampedArray: new Uint8ClampedArray([0, 127, 255]),
+        float32Array: new Float32Array([1.1, 2.2, 3.3]),
+        float64Array: new Float64Array([1.111111111111111, 2.222222222222222]),
+
+        // ArrayBuffer 测试
+        arrayBuffer: new ArrayBuffer(8),
+
+        // 其他特殊对象
+        regexp: /test\/pattern/gi,
+        error: new Error("test error"),
+
+        // 嵌套复杂结构
+        complexNested: {
+            arrayWithObjects: [
+                { id: 1, data: new Map([['a', 1]]) },
+                { id: 2, data: new Set([1, 2, 3]) }
+            ],
+            mapWithComplexValues: new Map([
+                ['nested', {
+                    array: [1, 2, new Set([4, 5])]
+                }]
+            ])
+        }
+    }
+
+    // 初始化一些 ArrayBuffer 数据
+    const bufferView = new Uint8Array(value.arrayBuffer)
+    for (let i = 0; i < bufferView.length; i++) {
+        bufferView[i] = i
+    }
+
+    let packr = new Packr({ structuredClone: true, useBigIntExtension: true, moreTypes: true, copyBuffers: true, })
+    let serializedAsBuffer = packr.pack(value)
+    let data = packr.unpack(serializedAsBuffer)
+
+    strictEqual(data.error.message, value.error.message)
+    delete data['error']
+    delete value['error']
+    deepStrictEqual(data, value)
 })

package/src/types.ts

@@ -1,3 +1,49 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 
 export type ExtensionApi<T> = { asyncLocalStorage: AsyncLocalStorage<T> } & object;
+
+
+export type RPC_TYPE_CALL = 0xdf68f4cb
+export type RPC_TYPE_RETURN = 0x68b17581
+export type RPC_TYPE_CALLBACK = 0x8d65e5cc
+export type RPC_TYPE_ERROR = 0xa07c0f84
+
+export type RPC_DATA_ARG_TYPE_OTHERS = 0xa7f68c
+export type RPC_DATA_ARG_TYPE_FUNCTION = 0x7ff45f
+
+
+export type RPC_TYPES = RPC_TYPE_CALL |
+    RPC_TYPE_RETURN |
+    RPC_TYPE_CALLBACK |
+    RPC_TYPE_ERROR;
+
+
+export type PromiseResolvers = {
+    promise: Promise<any>;
+    resolve: (value: any | null) => void;
+    reject: (reason: any | null) => void;
+};
+
+export type CALLBACK_ITEM = {
+    id: number;
+    type: RPC_TYPES;
+    promise?: PromiseResolvers;
+    callback?: (...data: object[]) => void;
+};
+
+export type RPC_DATA_ARG_ITEM = { type: RPC_DATA_ARG_TYPE; data: object; };
+export type RPC_DATA = {
+    id: number;
+    type: RPC_TYPE_CALL | RPC_TYPE_CALLBACK;
+    data: { type: RPC_DATA_ARG_TYPE; data: any; }[];
+} | {
+    id: number;
+    type: RPC_TYPE_RETURN;
+    data: any;
+} | {
+    id: number;
+    type: RPC_TYPE_ERROR;
+    data: { message: string, stack: string };
+};
+
+export type RPC_DATA_ARG_TYPE = RPC_DATA_ARG_TYPE_OTHERS | RPC_DATA_ARG_TYPE_FUNCTION;