js-rpc2 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-rpc2",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "js web websocket http rpc",
   "main": "index.js",
   "type": "module",

package/src/lib.js

@@ -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,14 +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(e => {
-        console.error(e)
-    })
+    })).catch(console.error)
 
     /** @type{RPC_HELPER_SERVER} */
     let ret = { writable: decode.writable, readable: encode.readable }
@@ -764,6 +784,7 @@ export function createRpcClientHelper(param) {
  * url:string;
  * rpcKey:string;
  * signal:AbortSignal;
+ * intercept?:(e:Event)=>void;
  * }} param
  */
 export function createRpcClientWebSocket(param) {
@@ -799,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,12 +58,13 @@ 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 })
+        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)