js-rpc2 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-rpc2",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "js web websocket http rpc",
   "main": "index.js",
   "type": "module",
@@ -26,7 +26,7 @@
   "author": "yuanliwei",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^22.9.4",
+    "@types/node": "^22.13.14",
     "koa": "^2.15.3",
     "koa-router": "^13.0.1",
     "ws": "^8.18.0"

package/src/lib.js

@@ -88,11 +88,11 @@ export async function buildBufferData(queue, key, iv) {
 /**
  * @param {Uint8Array<ArrayBuffer>} buffer
  * @param {CryptoKey} key
- * @param {Uint8Array} iv
- * @returns {Promise<[Uint8Array[],Uint8Array<ArrayBuffer>]>}
+ * @param {Uint8Array<ArrayBuffer>} iv
+ * @returns {Promise<[Uint8Array<ArrayBuffer>[],Uint8Array<ArrayBuffer>]>}
  */
 export async function parseBufferData(buffer, key, iv) {
-    /** @type{Uint8Array[]} */
+    /** @type{Uint8Array<ArrayBuffer>[]} */
     let queue = []
     let offset = 0
     let remain = new Uint8Array(0)
@@ -310,7 +310,7 @@ export async function encrypt(data, key, iv) {
 }
 
 /**
- * @param {Uint8Array} data 
+ * @param {Uint8Array<ArrayBuffer>} data 
  * @param {CryptoKey} key 
  * @param {Uint8Array} iv 
  * @returns 
@@ -574,7 +574,7 @@ export async function rpcRunServerDecodeBuffer(extension, writer, buffer) {
         box = {
             id: dataId,
             type: RPC_TYPE_ERROR,
-            data: buildRpcItemData([`Error:${error.message}\n${error.stack}`]),
+            data: buildRpcItemData([error.message, error.stack]),
         }
     }
     await writer.write(buildRpcData(box))
@@ -593,7 +593,11 @@ export function createRPCProxy(apiInvoke) {
             }
             proxy = new Proxy(Function, {
                 async apply(_target, _thisArg, argArray) {
-                    return await apiInvoke(String(p), argArray)
+                    try {
+                        return await apiInvoke(String(p), argArray)
+                    } catch (error) {
+                        throw new Error(error.message, { cause: error })
+                    }
                 }
             })
             map.set(p, proxy)
@@ -628,7 +632,9 @@ export function createRpcServerHelper(param) {
         async close() {
             await writer.close()
         }
-    }))
+    })).catch(e => {
+        console.error(e)
+    })
 
     /** @type{RPC_HELPER_SERVER} */
     let ret = { writable: decode.writable, readable: encode.readable }
@@ -644,6 +650,20 @@ export function createRpcServerHelper(param) {
  * }} RPC_HELPER_CLIENT
  */
 
+class RPCError extends Error {
+    /**
+     * @param {string} message
+     * @param {string} stack
+     * @param {ErrorOptions} [option]
+     */
+    constructor(message, stack, option) {
+        super(message, option)
+        if (stack) {
+            this.stack = stack
+        }
+    }
+}
+
 /**
  * @param {{ rpcKey: string; }} param
  */
@@ -666,7 +686,7 @@ export function createRpcClientHelper(param) {
                 if (callbackFunctionMap.has(data.id)) {
                     let o = callbackFunctionMap.get(data.id)
                     if (data.type == RPC_TYPE_ERROR) {
-                        o.promise.reject(new Error(items.at(0).data))
+                        o.promise.reject(new RPCError(items.at(0).data, items.at(1).data))
                     }
                     if (data.type == RPC_TYPE_RETURN) {
                         callbackFunctionMap.delete(data.id)

package/src/lib.test.js

@@ -282,4 +282,48 @@ export async function runWithAbortController(func) {
         await func(ac)
         await sleep(1000)
     } finally { ac.abort() }
-}
+}
+
+
+test('error-stack', async () => {
+    // node --test-name-pattern="^error-stack$" src/lib.test.js
+
+    // server
+    const app = new Koa()
+    const router = new Router()
+    app.use(router.routes())
+    app.use(router.allowedMethods())
+    let server = createServer(app.callback()).listen(9000)
+
+    class RpcApi {
+        async hello() {
+            new URL('/')
+        }
+    }
+
+    const extension = new RpcApi()
+
+    createRpcServerKoaRouter({
+        path: '/rpc/abc',
+        router: router,
+        extension: extension,
+    })
+
+
+    // client
+
+    /** @type{RpcApi} */
+    const rpc = createRpcClientHttp({
+        // url: `/rpc/abc`,                      // in same site html page
+        url: `http://127.0.0.1:9000/rpc/abc`, // others
+    })
+
+    try {
+        let ret = await rpc.hello()
+        console.info(ret)
+    } catch (error) {
+        console.error(error)
+    }
+    server.close()
+
+})

package/src/server.js

@@ -64,13 +64,17 @@ export function createRpcServerWebSocket(param) {
 export function createRpcServerKoaRouter(param) {
     param.router.post(param.path, async (ctx) => {
         let helper = createRpcServerHelper({ rpcKey: param.rpcKey, extension: param.extension })
-        await Readable.toWeb(ctx.req).pipeTo(helper.writable)
+        /** @type{ReadableStream} */
+        let a = Readable.toWeb(ctx.req)
+        await a.pipeTo(helper.writable)
         ctx.status = 200
         ctx.response.set({
             'Connection': 'keep-alive',
             'Cache-Control': 'no-cache',
             'Content-Type': 'application/octet-stream'
         })
-        ctx.body = Readable.fromWeb(helper.readable)
+        /** @type{object} */
+        let b = helper.readable
+        ctx.body = Readable.fromWeb(b)
     })
 }