@mingzey/typedrpc 1.0.1 → 1.0.2

package/src/test/socketio.ts

@@ -0,0 +1,96 @@
+/**
+ * 测试全双工通信实现双向调用
+ * TypedRPC的默认实现是基于http的，全双工必须实现自定义的Provider
+ * 这里使用socket.io作为Provider的底层通讯
+ */
+import { TestCase } from "./TestCase.js";
+import { TypedRPCAPIDefine, TypedRPCConnectionProviderSocketIO } from "../index.js";
+import { TypedRPCServer } from "../index.js";
+import { TypedRPCClient } from "../index.js";
+
+
+
+const ServerAPIDefine = new TypedRPCAPIDefine<{
+    math:{
+        add:(a:number,b:number) => number,
+    }
+}>
+
+const ClientAPIDefine = new TypedRPCAPIDefine<{
+    status:{
+        time:() => number,
+    }
+}>
+
+const server = new TypedRPCServer({
+    local:ServerAPIDefine,
+    remote:ClientAPIDefine,
+    connection:{
+        provider:new TypedRPCConnectionProviderSocketIO(),
+    }
+})
+
+server.hook('math','add',{
+    handler:(a,b) => {
+        return a + b;
+    }
+})
+
+const client = new TypedRPCClient({
+    local:ClientAPIDefine,
+    remote:ServerAPIDefine,
+    connection:{
+        provider:new TypedRPCConnectionProviderSocketIO(),
+    }
+})
+
+client.hook('status','time',{
+    handler:() => {
+        return Date.now();
+    }
+})
+
+export default class TestSocketIO extends TestCase{
+    name(): string {
+        return "SocketIO";
+    }
+    async run(): Promise<boolean> {
+        let requestToServer:Promise<boolean>;
+        let requestToClient:Promise<boolean>;
+
+        requestToClient = new Promise<boolean>((resolve) => {
+            server.emitter.on('connection',async (connectionToClient) => {
+                const apiToClient = server.getAPI(connectionToClient);
+                const result = await apiToClient.status.time.call();
+                if(result != null){
+                    resolve(true);
+                }else{
+                    resolve(false);
+                }
+            })
+        })
+
+        await server.listen({
+            port:3698,
+        })
+
+        requestToServer = new Promise<boolean>(async (resolve) => {
+            const connectionToServer = await client.connect("localhost:3698");
+            const apiToServer = client.getAPI(connectionToServer);
+            const result = await apiToServer.math.add.call(1,2);
+            if(result == 3){
+                resolve(true);
+            }else{
+                resolve(false);
+            }
+        })
+        
+        const resultToClient = await requestToClient;
+        const resultToServer = await requestToServer;
+        return resultToClient && resultToServer;
+    }
+    public async finally(): Promise<void> {
+        await server.close();
+    }
+}
+

package/src/test.ts

@@ -0,0 +1,35 @@
+import type { TestCase } from './test/TestCase.js';
+
+const testList = [
+    import('./test/basic.js'),
+    import('./test/context.js'),
+    import('./test/socketio.js'),
+    import('./test/authorization.js'),
+    import('./test/expressmix.js'),
+    import('./test/socket.js'),
+]
+
+async function main() {
+    for(let i of testList){
+        let exp = await i;
+        let test = new (exp.default)() as TestCase;
+        let result = await test.run().catch((e) => {
+            console.log(`Test:${test.name()} failed. ${e}`);
+            throw e;
+        })
+        await test.finally();
+        if(result){
+            console.log(`\x1b[32m[PASS]\x1b[0m ${test.name()}`);
+        }else{
+            console.log(`\x1b[31m[FAIL]\x1b[0m ${test.name()}`);
+        }
+
+    }
+}
+
+main().then(() => {
+    console.log('TypedRPC test finished.');
+}).catch((e) => {
+    console.log(`TypedRPC test failed. ${e}`);
+    throw e;
+})

package/src/utils.ts

@@ -0,0 +1,95 @@
+import type { TypedRPCAPIDefine } from "./define.js";
+import type { TypedRPCRequestPacket, TypedRPCResponsePacket } from "./packet.js";
+
+export type FunctionTypeToPromiseFunctionType<T extends (...args: any[]) => any> = 
+    T extends (...args: infer P) => Promise<infer R> ? 
+        (...args: P) => Promise<R | undefined>
+    : T extends (...args: infer P) => infer R ? 
+        (...args: P) => Promise<R | undefined>
+    : never
+;
+
+export type TypedRPCDefineToTypedRPCAPI<T extends TypedRPCAPIDefine<any>> = T extends TypedRPCAPIDefine<infer U> ? 
+    {
+        [S in keyof U]:{
+            [M in keyof U[S]]:{
+                /** 调用该方法 */
+                call:FunctionTypeToPromiseFunctionType<U[S][M]>,
+                /** 获取方法id */
+                request:(config:{
+                    args:Parameters<U[S][M]>,
+                    callback?:(result:ReturnType<U[S][M]>,req:TypedRPCRequestPacket,res:TypedRPCResponsePacket) => void,
+                    error?:(error:any,req:TypedRPCRequestPacket,res:TypedRPCResponsePacket) => void,
+                }) => string,
+                id:string,
+                /** 获取方法路径 */
+                path:string,
+            }
+        }
+    }
+: never;
+
+export type TypedRPCDefineServiceName<T extends TypedRPCAPIDefine<any>> = T extends TypedRPCAPIDefine<infer U> ? keyof U & string : never;
+export type TypedRPCDefineMethodName<T extends TypedRPCAPIDefine<any>,S extends TypedRPCDefineServiceName<T>> = T extends TypedRPCAPIDefine<infer U> ? keyof U[S] & string: never;
+export type TypedRPCDefineMethodBody<T extends TypedRPCAPIDefine<any>,S extends TypedRPCDefineServiceName<T>,M extends TypedRPCDefineMethodName<T,S>> = T extends TypedRPCAPIDefine<infer U> ? U[S][M] : never;
+export type TypedRPCDefineServiceInstance<T extends TypedRPCAPIDefine<any>,S extends TypedRPCDefineServiceName<T>> = T extends TypedRPCAPIDefine<infer U> ? U[S] : never;
+
+
+export type TypedEmitterEvents = {
+    [key:string]:(...args:any[]) => void
+}
+
+export class TypedEmitter<T extends TypedEmitterEvents> {
+
+    private record:Map<keyof T,Set<T[keyof T]>> = new Map();
+
+    on<K extends keyof T>(event:K,callback:T[K]){
+        if(!this.record.has(event)){
+            this.record.set(event,new Set());
+        }
+        this.record.get(event)!.add(callback);
+        return () => {
+            this.off(event,callback);
+        }
+    }
+
+    off<K extends keyof T>(event:K,callback:T[K]){
+        if(!this.record.has(event)){
+            return;
+        }
+        this.record.get(event)!.delete(callback);
+    }
+
+    emit<K extends keyof T>(event:K,...args:Parameters<T[K]>){
+        if(!this.record.has(event)){
+            return;
+        }
+        for(const callback of this.record.get(event)!){
+            callback(...args);
+        }
+    }
+
+    once<K extends keyof T>(event:K,callback:T[K]){
+        const wrapper = (...args:Parameters<T[K]>) => {
+            callback(...args);
+            this.off(event,wrapper as T[K]);
+        }
+        this.on(event,wrapper as T[K]);
+    }
+}
+
+export class IdMaker{
+
+    public static instance = new IdMaker();
+
+    static makeId():string{
+        return IdMaker.instance.makeId();
+    }
+
+    public makeId():string{
+        // 生成12位随机字符串
+        const suffix = Math.random().toString(36).substring(2,10);
+        const timestamp = Date.now().toString(36);
+        return `${timestamp}${suffix}`;
+    }
+}