js-rpc2 2.3.0 → 2.3.2

package/package.json

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

package/src/lib.js

@@ -1,7 +1,7 @@
 import { Packr } from 'msgpackr'
 
 /**
- * @import { CALLBACK_ITEM, ExtensionApi, RPC_DATA, RPC_DATA_ARG_ITEM } from "./types.js"
+ * @import { CALLBACK_ITEM, RPC_DATA, RPC_DATA_ARG_ITEM } from "./types.js"
  */
 
 const JS_RPC_WITH_CRYPTO = true
@@ -407,8 +407,7 @@ export function buildRpcItemData(items) {
 }
 
 /**
- * @template T
- * @param {ExtensionApi<T>} extension
+ * @param {object} extension
  * @param {WritableStreamDefaultWriter<Uint8Array<ArrayBuffer>>} writer
  * @param {Uint8Array<ArrayBuffer>} buffer
  * @param {(msg:string)=>void} logger
@@ -501,13 +500,11 @@ export function createRPCProxy(apiInvoke) {
  */
 
 /**
- * @template T
  * @param {{ 
  * rpcKey: string; 
- * extension: ExtensionApi<T>;
+ * extension: object;
  * logger?: (msg:string)=>void; 
  * async?: boolean; 
- * context?:any;
  * }} param
  */
 export function createRpcServerHelper(param) {
@@ -517,8 +514,6 @@ export function createRpcServerHelper(param) {
     let writer = encode.writable.getWriter()
     decode.readable.pipeTo(new WritableStream({
         async write(buffer) {
-            let asyncLocalStorage = param.extension.asyncLocalStorage
-            asyncLocalStorage?.enterWith(param.context)
             if (param.async) {
                 rpcRunServerDecodeBuffer(param.extension, writer, buffer, param.logger).catch(console.error)
             } else {
@@ -763,11 +758,55 @@ export function createRpcClientHttp(param) {
 }
 
 /**
- * @template T
+ * @param {{
+ * url:string;
+ * rpcKey?:string;
+ * signal?:AbortSignal;
+ * intercept?:(res:Response)=>void;
+ * }} param
+ */
+export function _testCreateRpcClientHttp(param) {
+    let helper = createRpcClientHelper({ rpcKey: param.rpcKey })
+    let writer = helper.writable.getWriter()
+    helper.readable.pipeTo(new WritableStream({
+        write(chunk) {
+            fetch(param.url, {
+                method: 'POST',
+                signal: param.signal,
+                // @ts-ignore
+                duplex: 'half',
+                body: new ReadableStream({
+                    async pull(controller) {
+                        controller.enqueue(chunk.slice(0, 10))
+                        await sleep(1000)
+                        controller.enqueue(chunk.slice(10))
+                        controller.close()
+                    }
+                }),
+            }).then(res => {
+                if (param.intercept) {
+                    param.intercept(res)
+                }
+                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) => helper.reject(err))
+    return createRPCProxy(helper.apiInvoke)
+}
+
+/**
  * @param {{
  * port:MessagePort;
  * rpcKey:string;
- * extension: ExtensionApi<T>; 
+ * extension: object;
  * logger?:(msg:string)=>void;
  * }} param 
  */
@@ -789,11 +828,10 @@ export function createRpcServerMessagePort(param) {
 
 /**
  * @import {Electron} from './types.js'
- * @template T
  * @param {{
  * port:Electron.MessagePortMain;
  * rpcKey:string;
- * extension: ExtensionApi<T>; 
+ * extension: object; 
  * logger?:(msg:string)=>void;
  * }} param 
  */
@@ -835,34 +873,36 @@ export function createRpcClientMessagePort(param) {
 
 /**
  * @param {string} text 
- * @returns 
  */
 export function base64decode(text) {
-    const _tidyB64 = (/** @type {string} */ s) => s.replace(/[^A-Za-z0-9\+\/]/g, '')
-    const _unURI = (/** @type {string} */ a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == '-' ? '+' : '/'))
-    text = _unURI(text)
-    return new Uint8Array(globalThis.atob(text).split('').map(c => c.charCodeAt(0)))
+    const binaryString = atob(text)
+    const len = binaryString.length
+    const bytes = new Uint8Array(len)
+    for (let i = 0; i < len; i++) {
+        bytes[i] = binaryString.charCodeAt(i)
+    }
+    return bytes
 }
 
 /**
  * @param {Uint8Array<ArrayBuffer>} buffer 
- * @returns 
  */
-export function base64encode(buffer, urlsafe = false) {
-    let b64 = globalThis.btoa(String.fromCharCode(...new Uint8Array(buffer)))
-    if (urlsafe) {
-        b64 = b64.replace(/=/g, '').replace(/[+\/]/g, (m0) => m0 == '+' ? '-' : '_')
+export function base64encode(buffer) {
+    const CHUNK_SZ = 0x8000
+    const chars = []
+    for (let i = 0; i < buffer.length; i += CHUNK_SZ) {
+        const chunk = buffer.subarray(i, i + CHUNK_SZ)
+        chars.push(String.fromCharCode.apply(null, chunk))
     }
-    return b64
+    return btoa(chars.join(''))
 }
 
 /**
  * @import {chrome as Chrome} from './types.js'
- * @template T
  * @param {{
  * chrome:Chrome;
  * key: string;
- * extension: ExtensionApi<T>
+ * extension: {messageSender:Chrome.runtime.MessageSender;};
  * logger?:(msg:string)=>void;
  * }} param 
  */
@@ -872,6 +912,7 @@ export function createRpcServerChromeExtensions(param) {
     chrome.runtime.onMessage.addListener(async (request, sender, sendResponse) => {
         if (request.action === param.key) {
             let tabId = sender.tab?.id
+            param.extension.messageSender = sender
             let { keyServer, keyClient } = request.data
             let helper = createRpcServerHelper({
                 rpcKey: '', extension: param.extension, async: true, logger: param.logger,

package/src/lib.test.js

@@ -1,6 +1,6 @@
 import { test } from 'node:test'
 import { deepStrictEqual, fail, ok, strictEqual } from 'node:assert'
-import { createRpcClientHttp, createRpcClientWebSocket, sleep, Uint8Array_from } from './lib.js'
+import { _testCreateRpcClientHttp, createRpcClientHttp, createRpcClientWebSocket, sleep, Uint8Array_from } from './lib.js'
 import { createServer } from 'node:http'
 import { WebSocketServer } from 'ws'
 import Koa from 'koa'
@@ -292,6 +292,9 @@ test('测试RPC调用-KoaRouter-AsyncLocalStorage', async () => {
         hello: async function (/** @type {string} */ name) {
             let ctx = this.asyncLocalStorage.getStore()
             strictEqual(ctx.path, '/abc')
+            await sleep(100)
+            ctx = this.asyncLocalStorage.getStore()
+            strictEqual(ctx.path, '/abc')
             return `hello ${name}`
         },
     }
@@ -320,7 +323,7 @@ test('测试RPC调用-KoaRouter-AsyncLocalStorage', async () => {
         await sleep(100)
 
         /** @type{typeof extension} */
-        let client = createRpcClientHttp({
+        let client = _testCreateRpcClientHttp({
             url: `http://127.0.0.1:9000/abc`,
             rpcKey: 'abc',
             signal: ac.signal,

package/src/server.js

@@ -3,8 +3,8 @@ import { createRpcServerHelper } from "./lib.js"
 import { AsyncLocalStorage } from "node:async_hooks"
 
 /**
+ * @import { IncomingMessage } from "node:http"
  * @import {WebSocketServer} from 'ws'
- * @import {ExtensionApi} from './types.js'
  */
 
 export { createRpcServerHelper }
@@ -19,14 +19,13 @@ export { createRpcServerHelper }
  * path: string; 
  * wss: WebSocketServer; 
  * rpcKey:string;
- * extension: ExtensionApi<T>; 
+ * extension: {asyncLocalStorage:AsyncLocalStorage<IncomingMessage>;}; 
  * logger?:(msg:string)=>void;
  * }} param
  */
 export function createRpcServerWebSocket(param) {
-    if (!param.extension.asyncLocalStorage) {
-        param.extension.asyncLocalStorage = new AsyncLocalStorage()
-    }
+    let asyncLocalStorage = param.extension.asyncLocalStorage
+    if (!asyncLocalStorage) { asyncLocalStorage = new AsyncLocalStorage() }
     param.wss.on('connection', (ws, request) => {
         let url = request.url
         if (url != param.path) {
@@ -47,6 +46,7 @@ export function createRpcServerWebSocket(param) {
             if (writer.desiredSize <= 0) {
                 ws.pause()
             }
+            asyncLocalStorage.enterWith(request)
             await writer.write(buffer)
             ws.resume()
         })
@@ -60,23 +60,27 @@ export function createRpcServerWebSocket(param) {
 }
 
 /**
- * @template T
  * @param {{
  * path: string; 
  * router: Router<any, {}>; 
  * rpcKey?:string;
  * logger?:(msg:string)=>void;
- * extension: ExtensionApi<T>; 
+ * extension: {asyncLocalStorage:AsyncLocalStorage;}; 
  * }} param 
  */
 export function createRpcServerKoaRouter(param) {
-    if (!param.extension.asyncLocalStorage) {
-        param.extension.asyncLocalStorage = new AsyncLocalStorage()
-    }
+    let asyncLocalStorage = param.extension.asyncLocalStorage
+    if (!asyncLocalStorage) { asyncLocalStorage = new AsyncLocalStorage() }
     param.router.post(param.path, async (ctx) => {
-        let helper = createRpcServerHelper({ rpcKey: param.rpcKey, extension: param.extension, logger: param.logger, context: ctx })
+        asyncLocalStorage.enterWith(ctx)
+        let helper = createRpcServerHelper({ rpcKey: param.rpcKey, extension: param.extension, logger: param.logger })
         let a = Readable.toWeb(ctx.req)
-        await a.pipeTo(helper.writable)
+        await a.pipeThrough(new TransformStream({
+            async transform(chunk, controller) {
+                asyncLocalStorage.enterWith(ctx)
+                controller.enqueue(chunk)
+            }
+        })).pipeTo(helper.writable)
         ctx.status = 200
         ctx.response.set({
             'Connection': 'keep-alive',

package/src/types.ts

@@ -1,8 +1,3 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-
-export type ExtensionApi<T> = { asyncLocalStorage?: AsyncLocalStorage<T> } & object;
-
-
 export type RPC_TYPE_CALL = 0xdf68f4cb
 export type RPC_TYPE_RETURN = 0x68b17581
 export type RPC_TYPE_CALLBACK = 0x8d65e5cc