feat: update version to 1.1.0 in package.json

Reviewed-on: #1

__tests__/e2e/rpc-context.test.ts

@@ -0,0 +1,41 @@
+import { getRPCContext, RPCContextKey } from "@/core/RPCContext";
+import { RPCHandler, RPCSession } from "@/index"
+import { getRandomAvailablePort } from "@/utils/utils";
+
+describe('rpc-context.test', () => {
+    test('context.session', async () => {
+        const accessed = new WeakMap<RPCSession, string>();
+        const provider = {
+            login(name: string) {
+                const context = getRPCContext(this);
+                if (!context) {
+                    throw new Error('context is null');
+                }
+
+                accessed.set(context.session, name);
+                return name;
+            },
+            me() {
+                const context = getRPCContext(this);
+                if (!context) {
+                    throw new Error('context is null');
+                }
+
+                return accessed.get(context.session) || 'unknown user';
+            },
+        }
+
+        const server = new RPCHandler();
+        const client = new RPCHandler();
+
+        server.setProvider(provider);
+        const port = await getRandomAvailablePort();
+        await server.listen({ port });
+
+        const session = await client.connect({ url: `http://localhost:${port}` });
+        const api = session.getAPI<typeof provider>();
+        const clientname = 'clientname';
+        await expect(api.login(clientname)).resolves.toBe(clientname);
+        await expect(api.me()).resolves.toBe(clientname);
+    })
+})

__tests__/e2e/rpc-disconnected.test.ts

@@ -33,8 +33,11 @@ describe('Rpc disconnected test', () => {
                 errorCode: RPCErrorCode.CONNECTION_DISCONNECTED
             })
         );
-        await expect(callPromise).rejects.toBeInstanceOf(RPCError);
-        await expect(callPromise).rejects
-            .toHaveProperty('errorCode', RPCErrorCode.CONNECTION_DISCONNECTED);
+        await expect(callPromise).rejects.toMatchObject(
+            expect.objectContaining({
+                constructor: RPCError,
+                errorCode: RPCErrorCode.CONNECTION_DISCONNECTED
+            })
+        );
     })
 })

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonecn/typesrpc",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "A lightweight, type-safe RPC framework for TypeScript with deep nested API support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/core/RPCContext.ts

@@ -0,0 +1,27 @@
+import { isObject } from "@/utils/utils";
+import { RPCSession } from "./RPCSession";
+
+export interface RPCContext {
+    session: RPCSession;
+}
+
+export const RPCContextFlag = Symbol();
+export const RPCContextKey = '__rpc_context';
+
+export class RPCContextConstractor {
+    public [RPCContextKey] = RPCContextFlag;
+    constructor(public session: RPCSession) { }
+}
+
+export const getRPCContext = (self: unknown): RPCContext | null => {
+    if (!isObject(self)) {
+        return null;
+    }
+
+    const rpcContext = self[RPCContextKey];
+    if (!isObject(rpcContext) || rpcContext[RPCContextKey] !== RPCContextFlag) {
+        return null;
+    }
+
+    return rpcContext as unknown as RPCContext;
+}

src/core/RPCSession.ts

@@ -9,6 +9,7 @@ import { makeCallPacket, makeCallResponsePacket, parseCallPacket, parseCallRespo
 import { RPCPacket } from "./RPCPacket";
 import { EventEmitter } from "@/utils/EventEmitter";
 import { createHookRunner } from "./RPCPlugin";
+import { RPCContextConstractor, RPCContextKey } from "./RPCContext";
 
 function getProviderFunction(provider: RPCProvider, fnPath: string):
     [(...args: any[]) => Promise<any>, object] | null {
@@ -372,7 +373,14 @@ export class RPCSession {
         }
 
         try {
-            const result = await fn.bind(fnThis)(...args);
+            const result = await fn.bind(new Proxy(fnThis, {
+                get(target, p, receiver) {
+                    if (p === RPCContextKey) {
+                        return new RPCContextConstractor(instance);
+                    }
+                    return Reflect.get(target, p, receiver);
+                },
+            }))(...args);
             return makeResponse({
                 status: 'success',
                 requestPacket: packet,

src/index.ts

@@ -12,6 +12,10 @@ export { SocketConnection } from "./core/SocketConnection";
 export { SocketServer } from "./core/SocketServer";
 export { EventEmitter } from "./utils/EventEmitter";
 
+export { AbstractRPCPlugin, createHookRunner } from './core/RPCPlugin';
+export type { RPCPlugin, RPCPluginHooks, RPCPluginHooksCtx } from './core/RPCPlugin';
+export { getRPCContext } from './core/RPCContext';
+
 export { injectSocketClient } from "./core/SocketClient";
 export { injectSocketServer } from "./core/SocketServer";
 import { injectSocketIOImplements } from "./implements/socket.io";