js-rpc2 1.0.1 → 1.0.3

package/package.json

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

package/src/lib.js

@@ -86,10 +86,10 @@ export async function buildBufferData(queue, key, iv) {
 }
 
 /**
- * @param {Uint8Array} buffer
+ * @param {Uint8Array<ArrayBuffer>} buffer
  * @param {CryptoKey} key
  * @param {Uint8Array} iv
- * @returns {Promise<[Uint8Array[],Uint8Array]>}
+ * @returns {Promise<[Uint8Array[],Uint8Array<ArrayBuffer>]>}
  */
 export async function parseBufferData(buffer, key, iv) {
     /** @type{Uint8Array[]} */
@@ -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), }
@@ -627,6 +640,7 @@ export function createRpcServerHelper(param) {
  * writable: WritableStream<Uint8Array>;
  * readable: ReadableStream<Uint8Array>;
  * apiInvoke: (fnName: string, args: object[]) => Promise<object>;
+ * reject: (error:object)=>void;
  * }} RPC_HELPER_CLIENT
  */
 
@@ -710,8 +724,18 @@ export function createRpcClientHelper(param) {
         }
     }
 
+    /**
+     * @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 }
+    let ret = { writable: decode.writable, readable: encode.readable, apiInvoke, reject }
     return ret
 }
 
@@ -790,21 +814,26 @@ export function createRpcClientHttp(param) {
     let helper = createRpcClientHelper({ rpcKey: param.rpcKey })
     let writer = helper.writable.getWriter()
     helper.readable.pipeTo(new WritableStream({
-        async write(chunk) {
-            let res = await fetch(param.url, {
+        write(chunk) {
+            fetch(param.url, {
                 method: 'POST',
                 signal: param.signal,
                 body: chunk,
-            })
-            if (param.intercept) {
-                param.intercept(res)
-            }
-            res.body.pipeTo(new WritableStream({
-                async write(chunk) {
-                    await writer.write(chunk)
+            }).then(res => {
+                if (param.intercept) {
+                    param.intercept(res)
                 }
-            })).catch((err) => console.error('createRpcClientHttp fetch error', err.message))
+                res.body.pipeThrough(processPackets()).pipeTo(new WritableStream({
+                    async write(chunk) {
+                        await writer.write(chunk)
+                    }
+                })).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

@@ -1,5 +1,5 @@
 import { test } from 'node:test'
-import { deepStrictEqual, strictEqual } from 'node:assert'
+import { deepStrictEqual, ok, strictEqual } from 'node:assert'
 import { createRpcClientHttp, createRpcClientWebSocket, sleep, Uint8Array_from } from './lib.js'
 import { createServer } from 'node:http'
 import { WebSocketServer } from 'ws'
@@ -193,6 +193,10 @@ test('测试RPC调用-KoaRouter', async () => {
         },
         void: async function (/** @type {string} */ name,/** @type {Uint8Array} */ buffer) {
             console.info('call void')
+        },
+        longTimeBlock: async function () {
+            await sleep(1000)
+            return 'finished'
         }
     }
 
@@ -251,6 +255,20 @@ test('测试RPC调用-KoaRouter', async () => {
 
         let retvoid = await client.void('asdfghjkl', buffer)
         strictEqual(retvoid, undefined)
+
+        let startTime = performance.now()
+        let [time1, time2] = await Promise.all([
+            client.longTimeBlock().then(v => {
+                console.info('longTimeBlock', v)
+                return performance.now() - startTime
+            }),
+            client.hello('欣瑶').then(v => {
+                console.info('hello', v)
+                return performance.now() - startTime
+            })
+        ])
+        ok(time1 > 1000, `time1:${time1}`)
+        ok(time2 < 10, `time2:${time2}`)
     })
     console.info('over!')
 })