js-rpc2 1.0.2 → 1.0.4

package/package.json

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

package/src/lib.js

@@ -120,6 +120,19 @@ export async function parseBufferData(buffer, key, iv) {
     return [queue, remain]
 }
 
+export function processPackets() {
+    let last = new Uint8Array(0)
+    return new TransformStream({
+        async transform(chunk, controller) {
+            let [queueReceive, remain] = await parseBufferData(Uint8Array_concat([last, chunk]), null, null)
+            last = remain
+            if (queueReceive.length > 0) {
+                let buffer = await buildBufferData(queueReceive, null, null)
+                controller.enqueue(buffer)
+            }
+        }
+    })
+}
 
 /**
  * @param {Uint8Array} buffer
@@ -360,26 +373,26 @@ export const RPC_TYPE_ERROR = 0xa07c0f84
  */
 
 /**
- * @typedef {{type:RPC_DATA_AGR_TYPE;data:object}} RPC_DATA_ARG_ITEM
+ * @typedef {{type:RPC_DATA_ARG_TYPE;data:object}} RPC_DATA_ARG_ITEM
  * @typedef {{
  * id:number;
  * type:RPC_TYPES;
- * data:{type:RPC_DATA_AGR_TYPE;data:object}[];
+ * data:{type:RPC_DATA_ARG_TYPE;data:object}[];
  * }} RPC_DATA
  */
 
-export const RPC_DATA_AGR_TYPE_OBJECT = 0xa7f68c
-export const RPC_DATA_AGR_TYPE_FUNCTION = 0x7ff45f
-export const RPC_DATA_AGR_TYPE_UINT8ARRAY = 0xedb218
-export const RPC_DATA_AGR_TYPE_UNDEFINED = 0x7f77fe
-export const RPC_DATA_AGR_TYPE_NULL = 0x5794f9
+export const RPC_DATA_ARG_TYPE_OBJECT = 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_AGR_TYPE_OBJECT
- * |RPC_DATA_AGR_TYPE_FUNCTION
- * |RPC_DATA_AGR_TYPE_UINT8ARRAY
- * |RPC_DATA_AGR_TYPE_UNDEFINED
- * |RPC_DATA_AGR_TYPE_NULL} RPC_DATA_AGR_TYPE
+ * @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
  */
 
 /**
@@ -392,23 +405,23 @@ export function buildRpcData(box) {
         buildBufferNumberUInt32LE(box.data.length),
     ]
     for (const o of box.data) {
-        if (o.type == RPC_DATA_AGR_TYPE_UINT8ARRAY) {
+        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_AGR_TYPE_FUNCTION) {
+        if (o.type == RPC_DATA_ARG_TYPE_FUNCTION) {
             buffers.push(buildBufferNumberUInt32LE(o.type))
             buffers.push(buildBufferSizeString(o.data))
         }
-        if (o.type == RPC_DATA_AGR_TYPE_OBJECT) {
+        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_AGR_TYPE_UNDEFINED) {
+        if (o.type == RPC_DATA_ARG_TYPE_UNDEFINED) {
             buffers.push(buildBufferNumberUInt32LE(o.type))
         }
-        if (o.type == RPC_DATA_AGR_TYPE_NULL) {
+        if (o.type == RPC_DATA_ARG_TYPE_NULL) {
             buffers.push(buildBufferNumberUInt32LE(o.type))
         }
     }
@@ -432,28 +445,28 @@ export function parseRpcData(buffer) {
     for (let i = 0; i < dataLength; i++) {
         let type = readUInt32LE(buffer, offset)
         offset += 4
-        if (type == RPC_DATA_AGR_TYPE_UINT8ARRAY) {
+        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_AGR_TYPE_FUNCTION) {
+        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_AGR_TYPE_OBJECT) {
+        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_AGR_TYPE_UNDEFINED) {
+        if (type == RPC_DATA_ARG_TYPE_UNDEFINED) {
             args.push({ type: type, data: undefined })
         }
-        if (type == RPC_DATA_AGR_TYPE_NULL) {
+        if (type == RPC_DATA_ARG_TYPE_NULL) {
             args.push({ type: type, data: null })
         }
     }
@@ -469,23 +482,23 @@ export function buildRpcItemData(items) {
     /** @type{RPC_DATA_ARG_ITEM[]} */
     let arr = []
     for (const item of items) {
-        /** @type{RPC_DATA_AGR_TYPE} */
+        /** @type{RPC_DATA_ARG_TYPE} */
         let type = null
         let data = null
         if (item === undefined) {
-            type = RPC_DATA_AGR_TYPE_UNDEFINED
+            type = RPC_DATA_ARG_TYPE_UNDEFINED
             data = item
         } else if (item === null) {
-            type = RPC_DATA_AGR_TYPE_NULL
+            type = RPC_DATA_ARG_TYPE_NULL
             data = item
         } else if (item instanceof Uint8Array) {
-            type = RPC_DATA_AGR_TYPE_UINT8ARRAY
+            type = RPC_DATA_ARG_TYPE_UINT8ARRAY
             data = item
         } else if (typeof item == 'function') {
-            type = RPC_DATA_AGR_TYPE_FUNCTION
+            type = RPC_DATA_ARG_TYPE_FUNCTION
             data = item()
         } else {
-            type = RPC_DATA_AGR_TYPE_OBJECT
+            type = RPC_DATA_ARG_TYPE_OBJECT
             data = JSON.stringify(item)
         }
         arr.push({ type, data })
@@ -501,19 +514,19 @@ export function parseRpcItemData(array) {
     let items = []
     for (let i = 0; i < array.length; i++) {
         const o = array[i]
-        if (o.type == RPC_DATA_AGR_TYPE_FUNCTION) {
+        if (o.type == RPC_DATA_ARG_TYPE_FUNCTION) {
             o.data = o.data
         }
-        if (o.type == RPC_DATA_AGR_TYPE_NULL) {
+        if (o.type == RPC_DATA_ARG_TYPE_NULL) {
             o.data = null
         }
-        if (o.type == RPC_DATA_AGR_TYPE_UNDEFINED) {
+        if (o.type == RPC_DATA_ARG_TYPE_UNDEFINED) {
             o.data = undefined
         }
-        if (o.type == RPC_DATA_AGR_TYPE_UINT8ARRAY) {
+        if (o.type == RPC_DATA_ARG_TYPE_UINT8ARRAY) {
             o.data = o.data
         }
-        if (o.type == RPC_DATA_AGR_TYPE_OBJECT) {
+        if (o.type == RPC_DATA_ARG_TYPE_OBJECT) {
             o.data = JSON.parse(o.data)
         }
         items.push(o)
@@ -539,7 +552,7 @@ export async function rpcRunServerDecodeBuffer(extension, writer, buffer) {
         let params = []
         for (let i = 0; i < args.length; i++) {
             const p = args[i]
-            if (p.type == RPC_DATA_AGR_TYPE_FUNCTION) {
+            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), }
@@ -561,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))
@@ -580,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)
@@ -627,13 +644,24 @@ export function createRpcServerHelper(param) {
  * writable: WritableStream<Uint8Array>;
  * readable: ReadableStream<Uint8Array>;
  * apiInvoke: (fnName: string, args: object[]) => Promise<object>;
- * transform:()=>{
- *   readable: ReadableStream<Uint8Array<ArrayBufferLike>>;
- *   witeable: WritableStream<Uint8Array<ArrayBufferLike>>;
- * }
+ * reject: (error:object)=>void;
  * }} 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
  */
@@ -656,7 +684,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)
@@ -714,15 +742,18 @@ export function createRpcClientHelper(param) {
         }
     }
 
-    function transform() {
-        let decode = createDecodeStream(rpc_key_iv)
-        let encode = createEncodeStream(rpc_key_iv)
-        decode.readable.pipeTo(encode.writable)
-        return { readable: encode.readable, witeable: decode.writable }
+    /**
+     * @param {object} error
+     */
+    function reject(error) {
+        callbackFunctionMap.forEach((o) => {
+            o.promise?.reject(error)
+        })
+        callbackFunctionMap.clear()
     }
 
     /** @type{RPC_HELPER_CLIENT} */
-    let ret = { writable: decode.writable, readable: encode.readable, apiInvoke, transform }
+    let ret = { writable: decode.writable, readable: encode.readable, apiInvoke, reject }
     return ret
 }
 
@@ -810,15 +841,17 @@ export function createRpcClientHttp(param) {
                 if (param.intercept) {
                     param.intercept(res)
                 }
-                let transform = helper.transform()
-                res.body.pipeTo(transform.witeable).catch(e => console.error(e))
-                transform.readable.pipeTo(new WritableStream({
+                res.body.pipeThrough(processPackets()).pipeTo(new WritableStream({
                     async write(chunk) {
                         await writer.write(chunk)
                     }
-                })).catch((e) => console.error(e))
-            }).catch(e => console.error(e))
+                })).catch((e) => {
+                    helper.reject(e)
+                })
+            }).catch(e => {
+                helper.reject(e)
+            })
         }
-    })).catch((err) => console.error('createRpcClientHttp', err.message))
+    })).catch((err) => helper.reject(err))
     return createRPCProxy(helper.apiInvoke)
 }

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()
+
+})