js-rpc2 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-rpc2",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "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 
@@ -538,25 +538,32 @@ export function parseRpcItemData(array) {
  * @param {object} extension
  * @param {WritableStreamDefaultWriter<Uint8Array>} writer
  * @param {Uint8Array} buffer
+ * @param {(msg:string)=>void} [logger]
  */
-export async function rpcRunServerDecodeBuffer(extension, writer, buffer) {
+export async function rpcRunServerDecodeBuffer(extension, writer, buffer, logger) {
     /** @type{RPC_DATA} */
     let box = null
     let dataId = 0
+    let fnName = null
+    let params = []
+    let time = Date.now()
     try {
         let o = parseRpcData(buffer)
         dataId = o.id
         let items = parseRpcItemData(o.data)
-        let fnName = items.at(0).data
+        fnName = items.at(0).data
         let args = items.slice(1)
-        let params = []
         for (let i = 0; i < args.length; i++) {
             const p = args[i]
             if (p.type == RPC_DATA_ARG_TYPE_FUNCTION) {
                 const callback = async (/** @type {any[]} */ ...args) => {
                     /** @type{RPC_DATA} */
                     let box = { id: p.data, type: RPC_TYPE_CALLBACK, data: buildRpcItemData(args), }
-                    await writer.write(buildRpcData(box))
+                    try {
+                        await writer.write(buildRpcData(box))
+                    } catch (error) {
+                        throw new Error(`rpc callback writer.write()`, { cause: error })
+                    }
                 }
                 params.push(callback)
             } else {
@@ -570,13 +577,22 @@ export async function rpcRunServerDecodeBuffer(extension, writer, buffer) {
             box = { id: o.id, type: RPC_TYPE_RETURN, data: buildRpcItemData([ret]), }
         }
     } catch (error) {
-        console.error(error)
+        console.error('rpcRunServerDecodeBuffer', fnName, params.map(o => {
+            if (typeof o == 'function') { return 'function' }
+            return o
+        }), error)
         box = {
             id: dataId,
             type: RPC_TYPE_ERROR,
             data: buildRpcItemData([error.message, error.stack]),
         }
     }
+    if (logger) {
+        logger(`time: ${Date.now() - time}ms ${fnName}(${params.map(o => {
+            if (typeof o == 'function') { return Function }
+            return o
+        }).join(', ')})`)
+    }
     await writer.write(buildRpcData(box))
 }
 
@@ -618,6 +634,8 @@ export function createRPCProxy(apiInvoke) {
  * @param {{ 
  * rpcKey: string; 
  * extension: object; 
+ * logger?: (msg:string)=>void; 
+ * async?: boolean; 
  * }} param
  */
 export function createRpcServerHelper(param) {
@@ -627,12 +645,16 @@ export function createRpcServerHelper(param) {
     let writer = encode.writable.getWriter()
     decode.readable.pipeTo(new WritableStream({
         async write(buffer) {
-            await rpcRunServerDecodeBuffer(param.extension, writer, buffer)
+            if (param.async) {
+                rpcRunServerDecodeBuffer(param.extension, writer, buffer, param.logger).catch(console.error)
+            } else {
+                await rpcRunServerDecodeBuffer(param.extension, writer, buffer, param.logger)
+            }
         },
         async close() {
             await writer.close()
         }
-    }))
+    })).catch(console.error)
 
     /** @type{RPC_HELPER_SERVER} */
     let ret = { writable: decode.writable, readable: encode.readable }
@@ -762,6 +784,7 @@ export function createRpcClientHelper(param) {
  * url:string;
  * rpcKey:string;
  * signal:AbortSignal;
+ * intercept?:(e:Event)=>void;
  * }} param
  */
 export function createRpcClientWebSocket(param) {
@@ -797,6 +820,9 @@ export function createRpcClientWebSocket(param) {
             signal.resolve()
         })
         ws.addEventListener('error', (e) => {
+            if (param.intercept) {
+                param.intercept(e)
+            }
             console.error('createRpcClientWebSocket createWebSocket ws error', e)
             promise.resolve()
         })

package/src/server.js

@@ -25,7 +25,7 @@ export function createRpcServerWebSocket(param) {
         if (url != param.path) {
             return
         }
-        let helper = createRpcServerHelper({ rpcKey: param.rpcKey, extension: param.extension })
+        let helper = createRpcServerHelper({ rpcKey: param.rpcKey, extension: param.extension, async: true, })
         let writer = helper.writable.getWriter()
         helper.readable.pipeTo(new WritableStream({
             async write(chunk) {
@@ -58,19 +58,24 @@ export function createRpcServerWebSocket(param) {
  * path: string; 
  * router: Router<any, {}>; 
  * rpcKey?:string;
+ * logger?:(msg:string)=>void;
  * extension: Object; 
  * }} 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)
+        let helper = createRpcServerHelper({ rpcKey: param.rpcKey, extension: param.extension, logger: param.logger })
+        /** @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)
     })
 }