js-rpc2 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-rpc2",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "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[]} */
@@ -627,6 +627,10 @@ 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>>;
+ * }
  * }} RPC_HELPER_CLIENT
  */
 
@@ -710,8 +714,15 @@ 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 }
+    }
+
     /** @type{RPC_HELPER_CLIENT} */
-    let ret = { writable: decode.writable, readable: encode.readable, apiInvoke }
+    let ret = { writable: decode.writable, readable: encode.readable, apiInvoke, transform }
     return ret
 }
 
@@ -790,20 +801,23 @@ 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))
+                let transform = helper.transform()
+                res.body.pipeTo(transform.witeable).catch(e => console.error(e))
+                transform.readable.pipeTo(new WritableStream({
+                    async write(chunk) {
+                        await writer.write(chunk)
+                    }
+                })).catch((e) => console.error(e))
+            }).catch(e => console.error(e))
         }
     })).catch((err) => console.error('createRpcClientHttp', err.message))
     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!')
 })