@mingzey/typedrpc 1.0.1 → 1.0.2

package/src/connecitons/socketio.ts

@@ -0,0 +1,200 @@
+import { IdMaker, TypedEmitter } from "../utils.js";
+import { TypedRPCConnection, TypedRPCConnectionProvider } from "./basic.js";
+
+
+
+type TypedRPCConnectionSocketIOPayload = {
+    type:'request' | 'response';
+    id:string;
+    data:string;
+}
+type TypedRPCConnectionMessageEvents = {
+    receive:(data:string) => void;
+}
+class TypedRPCConnectionSocketIO extends TypedRPCConnection{
+    public msgEmitter = new TypedEmitter<TypedRPCConnectionMessageEvents>();
+    
+    private currentId = 1;
+
+    private requests:Map<string,{
+        resolve:(data:string) => void
+    }> = new Map();
+
+    constructor(private socket:{
+        id:string,
+        send:(data:string) => void;
+        close:() => boolean;
+        isClosed:() => boolean;
+    }){
+        super();
+
+        // 处理外部请求
+        this.msgEmitter.on('receive',(data) => {
+            // console.log(`[${this.socket.id}][R]:${data}`);
+            const recivePlayload:TypedRPCConnectionSocketIOPayload = JSON.parse(data);
+            if(recivePlayload.type == 'request'
+            && recivePlayload.id
+            ){
+                this.emitter.emit('request',{// 告知TypedRPCHandler有新请求
+                    data:recivePlayload.data,
+                    response:(data) => {
+                        const sendPlayout:TypedRPCConnectionSocketIOPayload = {
+                            type:'response',
+                            id:recivePlayload.id,
+                            data:data,
+                        }
+                        this.socket.send(JSON.stringify(sendPlayout));
+                    }
+                })
+            }else if(recivePlayload.type == 'response'
+            && recivePlayload.id
+            ){
+                this.requests.get(recivePlayload.id)?.resolve(recivePlayload.data);
+            }
+        })
+    }
+
+    async request(data: string): Promise<string> {
+        const requestId = `${this.currentId++}`;
+        const payload:TypedRPCConnectionSocketIOPayload = {
+            type:'request',
+            id:requestId,
+            data:data,
+        }
+
+        const requestPromise = new Promise<string>((resolve) => {
+            this.requests.set(requestId,{
+                resolve:resolve
+            })
+
+            // 发送数据
+            // console.log(`[${this.socket.id}][T]:${JSON.stringify(payload)}`);
+            this.socket.send(JSON.stringify(payload));
+        }).finally(() => {
+            this.requests.delete(requestId);
+        })
+        return await requestPromise;
+    }
+
+    getId(): string {
+        return this.socket.id;
+    }
+    close(): boolean {
+        return this.socket.close();
+    }
+
+    isClosed(): boolean {
+        return this.socket.isClosed();
+    }
+    
+}
+
+class TypedRPCConnectionProviderSocketIO extends TypedRPCConnectionProvider{
+    
+    private io:import("socket.io").Server | null = null;
+
+    async listen(config: { port: number; hostname?: string; }): Promise<boolean> {
+        const httpModule = await import("http").catch(() => null);
+        if(!httpModule){
+            throw new Error("http module not found");
+        }
+        const socketIOServerModule = await import("socket.io").catch(() => null);
+        if(!socketIOServerModule){
+            throw new Error("socket.io module not found");
+        }
+
+        const server = httpModule.createServer();
+
+
+        const io = new socketIOServerModule.Server(server,{
+            cors:{
+                origin:"*",
+                methods:["GET","POST"],
+            },
+        });
+        io.on('connection',(socket) => {
+            const connection = new TypedRPCConnectionSocketIO({
+                id:socket.id,
+                send:(data) => {
+                    socket.emit('message',data);
+                },
+                close:() => {
+                    socket.disconnect();
+                    return true;
+                },
+                isClosed:() => {
+                    return socket.disconnected;
+                },
+            });
+            this.emitter.emit('connection',connection);// 告知TypedRPCHandler有新连接
+            socket.on('message',(data) => {
+                connection.msgEmitter.emit('receive',data);
+            })
+            socket.on('close',() => {
+                connection.close();
+            })
+        })
+        this.io = io;
+        return new Promise<boolean>((resolve) => {
+            server.listen(config.port,config.hostname,() => {
+                resolve(true);
+            })
+        })
+    }
+    async close(): Promise<boolean> {
+        return new Promise<boolean>((resolve,reject) => {
+            if(!this.io){
+                return resolve(true);
+            }
+            this.io.sockets.sockets.forEach((socket) => {
+                socket.disconnect();
+            })
+            this.io.close((err) => {
+                if(err){
+                    reject(err);
+                }
+                resolve(true);
+            })
+            this.io = null;
+        })
+    }
+
+    async connect(target: string): Promise<TypedRPCConnection> {
+        const SocketIOClientModule = await import("socket.io-client").catch(() => null);
+        if(!SocketIOClientModule){
+            throw new Error("socket.io-client module not found");
+        }
+        return new Promise<TypedRPCConnection>((resolve,reject) => {
+            const socket = SocketIOClientModule.io(`ws://${target}`);
+            const connection = new TypedRPCConnectionSocketIO({
+                id:socket.id || IdMaker.makeId(),
+                send:(data) => {
+                    socket.emit('message',data);
+                },
+                close:() => {
+                    socket.disconnect();
+                    return true;
+                },
+                isClosed:() => {
+                    return socket.disconnected;
+                },
+            });
+            this.emitter.emit('connection',connection);// 告知TypedRPCHandler有新连接
+            socket.on('connect',() => {
+                resolve(connection)
+            })
+            socket.on('message',(data) => {
+                connection.msgEmitter.emit('receive',data);
+            })
+            socket.on('close',() => {
+                connection.close();
+            })
+        })
+    }
+
+}
+
+export {
+    TypedRPCConnectionSocketIO,
+    TypedRPCConnectionProviderSocketIO,
+}

package/src/connection.ts

@@ -0,0 +1,10 @@
+import { TypedRPCConnectionHTTP, TypedRPCConnectionProviderHTTP } from "./connecitons/http.js";
+
+
+const TypedRPCConnectionDefault = TypedRPCConnectionHTTP;
+const TypedRPCConnectionProviderDefault = TypedRPCConnectionProviderHTTP;
+
+export {
+    TypedRPCConnectionDefault,
+    TypedRPCConnectionProviderDefault,
+}

package/src/context.ts

@@ -0,0 +1,18 @@
+import type { TypedRPCConnection } from "./connecitons/basic.js";
+import type { TypedRPCPacket } from "./packet.js"
+
+type TypedRPCContext = {
+    connection:TypedRPCConnection,
+    inbound?:TypedRPCPacket,
+    outbound?:TypedRPCPacket,
+}
+
+export const TypedRPCContextSymbol = Symbol("TypedRPCContext");
+interface TypedRPCContextAware{
+    [TypedRPCContextSymbol]:TypedRPCContext | null,
+}
+
+export type {
+    TypedRPCContextAware,
+    TypedRPCContext,
+}

package/src/core.ts

@@ -0,0 +1,130 @@
+import type { TypedRPCConnection, TypedRPCConnectionProvider } from "./connecitons/basic.js"
+import { TypedRPCConnectionProviderDefault } from "./connection.js"
+import { TypedRPCHandler } from "./handler.js"
+import { TypedRPCPacketFactory, type TypedRPCRequestPacket, type TypedRPCResponsePacket } from "./packet.js"
+import { TypedEmitter } from "./utils.js"
+
+type TypedRPCCoreConfig = {
+    connection?:{
+        provider:TypedRPCConnectionProvider,
+    }
+}
+
+type TypedRPCCoreEvents = {
+    connection:(connection:TypedRPCConnection)=>void,
+}
+
+class TypedRPCCore{
+
+    public emitter = new TypedEmitter<TypedRPCCoreEvents>();
+    private config:TypedRPCCoreConfig;
+    public handler:TypedRPCHandler;
+
+    constructor(config:TypedRPCCoreConfig){
+        const defaultConfig:TypedRPCCoreConfig = {
+            connection:{
+                provider:new TypedRPCConnectionProviderDefault(),
+            }
+        }
+        this.config = {...defaultConfig,...config};
+        this.handler = new TypedRPCHandler();
+        this.init();
+    }
+
+    private init(){
+        const provider = this.config.connection?.provider;
+        if(provider){
+            provider.emitter.on('connection',(connection) => {
+                this.emitter.emit('connection',connection);
+            })
+        }
+        this.emitter.on('connection',(connection) => {
+            // 提供对向请求处理
+            connection.emitter.on('request',(context) => {
+                try{
+                    const requestPacket = JSON.parse(context.data);
+                    if(!TypedRPCPacketFactory.isRequestPacket(requestPacket)){
+                        return;
+                    }
+                    this.handler.handle(connection,requestPacket,(responsePacket) => {
+                        if(!responsePacket){
+                            return;
+                        }
+                        context.response(JSON.stringify(responsePacket));
+                    });
+                }catch(e){
+                    console.error(e);
+                }
+            })
+        })
+    }
+
+    get hook(){
+        return this.handler.hook.bind(this.handler);
+    }
+
+    public async request(config:{
+        connection:TypedRPCConnection,
+        serviceName:string,
+        methodName:string,
+        args:any[],
+    }):Promise<{
+        request:TypedRPCRequestPacket,
+        response:TypedRPCResponsePacket,
+    }>{
+        const requestPacket = TypedRPCPacketFactory.createRequestPacket({
+            serviceName:config.serviceName,
+            methodName:config.methodName,
+            args:config.args,
+        })
+        const responsePacket = await this.handler.request(config.connection,requestPacket).catch((e) => {
+            return TypedRPCPacketFactory.createResponsePacket({
+                requestId:requestPacket.id,
+                error:e
+            })
+        });
+        if(!TypedRPCPacketFactory.isResponsePacket(responsePacket)){
+            throw new Error(`Invalid response packet:\n${JSON.stringify(responsePacket)}`);
+        }
+        if(responsePacket.requestId != requestPacket.id){
+            throw new Error(`Invalid response packet:request id not match\n${JSON.stringify(requestPacket)}\n${JSON.stringify(responsePacket)}`);
+        }
+        return {
+            request:requestPacket,
+            response:responsePacket,
+        }
+    }
+
+    public async listen(config:{
+        port:number,
+        hostname?:string,
+    }):Promise<boolean>{
+        const provider = this.config.connection?.provider;
+        if(!provider){
+            throw new Error("Connection provider not found");
+        }
+        return provider.listen(config);
+    }
+
+    public async close():Promise<boolean>{
+        const provider = this.config.connection?.provider;
+        if(!provider){
+            throw new Error("Connection provider not found");
+        }
+        return provider.close();
+    }
+
+    public async connect(target: string):Promise<TypedRPCConnection>{
+        const provider = this.config.connection?.provider;
+        if(!provider){
+            throw new Error("Connection provider not found");
+        }
+        const connection = await provider.connect(target);
+        return connection;
+    }
+
+}
+
+export {
+    TypedRPCCore
+}

package/src/define.ts

@@ -0,0 +1,63 @@
+
+type TypedRPCAPIDefineType = Record<string, Record<string, any>>
+
+type TypedRPCDefineConfig = {
+
+    
+
+}
+
+class TypedRPCAPIDefine<T extends TypedRPCAPIDefineType> {
+
+    static TypedRPCService = Symbol('TypedRPCService');
+    static TypedRPCMethod = Symbol('TypedRPCMethod');
+    static TypedRPCMethodList = Symbol('TypedRPCMethodList');
+
+    constructor(config?:TypedRPCAPIDefineType){
+        
+    }
+
+    static method(){
+        return  function(target:any, propertyKey:string, descriptor:PropertyDescriptor){
+            descriptor.value[TypedRPCAPIDefine.TypedRPCMethod] = true;
+            if(!target[TypedRPCAPIDefine.TypedRPCService]){
+                target[TypedRPCAPIDefine.TypedRPCService] = true;
+            }
+            if(!target[TypedRPCAPIDefine.TypedRPCMethodList]){
+                target[TypedRPCAPIDefine.TypedRPCMethodList] = new Set<string>();
+            }
+            target[TypedRPCAPIDefine.TypedRPCMethodList].add(propertyKey);
+        }
+    }
+
+    static isService(target:any){
+        return target[TypedRPCAPIDefine.TypedRPCService] === true;
+    }
+
+    static isMethod(method:any){
+        // 判断是否是方法
+        if(typeof method !== 'function'){
+            return false;
+        }
+        if(method[TypedRPCAPIDefine.TypedRPCMethod] != true){
+            return false;
+        }
+        return true;
+    }
+
+    static getMethodList(service:any):string[]{
+        if(!TypedRPCAPIDefine.isService(service)){
+            return [];
+        }
+        return Array.from(service[TypedRPCAPIDefine.TypedRPCMethodList]);
+    }
+}
+
+
+export type {
+    TypedRPCAPIDefineType,
+}
+
+export {
+    TypedRPCAPIDefine,
+}

package/src/handler.ts

@@ -0,0 +1,202 @@
+
+import type { TypedRPCConnection } from "./connecitons/basic.js";
+import { TypedRPCContextSymbol, type TypedRPCContext } from "./context.js";
+import { TypedRPCPacketFactory, type TypedRPCPacket, type TypedRPCRequestPacket, type TypedRPCResponsePacket } from "./packet.js";
+import { TypedEmitter } from "./utils.js";
+
+
+// interface TypedRPCHandlerMiddleware{
+//     inbound?:(context:TypedRPCContext) => Promise<TypedRPCContext>;
+//     outbound?:(context:TypedRPCContext) => Promise<TypedRPCContext>; 
+// }
+
+class TypedRPCHandlerMiddleware{
+    async inbound(context:TypedRPCContext):Promise<TypedRPCContext>{
+        return context;
+    }
+    async outbound(context:TypedRPCContext):Promise<TypedRPCContext>{
+        return context;
+    }
+}
+
+type TypedRPCHandlerEvents = {
+    
+}
+/**
+ * 处理所有TypedRPC数据包，管理入站出站
+ */
+class TypedRPCHandler{
+
+    public emitter = new TypedEmitter<TypedRPCHandlerEvents>();
+
+    private middlewares:TypedRPCHandlerMiddleware[] = [];
+
+    private hooks:Record<string,Record<string,{
+        handler:(...args:any[])=>any,
+        bind:any,
+    }>> = {};
+
+    constructor(){
+        this.use({
+            inbound:async (context) => {
+                // Fallback 托底返回错误
+                if(context.inbound && !context.outbound){
+                    context.outbound = TypedRPCPacketFactory.createResponsePacket({
+                        requestId:context.inbound.id,
+                        error:"service not available or not found",
+                    })
+                }
+                return context;
+            },
+            outbound:async (context) => {
+                return context;
+            },
+        })
+        this.use({
+            inbound:async (context) => {
+                if(!context.inbound
+                || !TypedRPCPacketFactory.isRequestPacket(context.inbound)){
+                    return context;
+                }
+                // 如果已经有出站包，直接返回
+                if(context.outbound){
+                    return context;
+                }
+                const serviceName = context.inbound.serviceName;
+                const methodName = context.inbound.methodName;
+                const args = context.inbound.args;
+                const hook = this.hooks[serviceName]?.[methodName];
+                if(!hook){
+                    return context;
+                }
+                const result = await hook.handler.call(new Proxy(hook.bind || {},{
+                    get(target,prop){
+                        if(prop === TypedRPCContextSymbol){
+                            return context;
+                        }
+                        return Reflect.get(target,prop);
+                    }
+                }),...args);
+                const response = TypedRPCPacketFactory.createResponsePacket({
+                    requestId:context.inbound.id,
+                    result:result,
+                });
+                context.outbound = response;
+                return context;
+            },
+            outbound:async (context) => {
+                return context;
+            },
+        })
+    }
+
+    public use(middleware:TypedRPCHandlerMiddleware){
+        this.middlewares.push(middleware);
+        return this;
+    }
+
+    private async middlewareProcesser(context:TypedRPCContext,index:number,direction:'inbound'|'outbound'):Promise<TypedRPCContext>{
+        const middleware = this.middlewares[index];
+        if(!middleware){
+            return context;
+        }
+        // 执行中间件
+        if(direction == 'inbound'){
+            if(middleware.inbound){
+                context = await middleware.inbound(context);
+            }
+            index--;
+        }
+        if(direction == 'outbound'){
+            if(middleware.outbound){
+                context = await middleware.outbound(context);
+            }
+            index++;
+        }
+        return this.middlewareProcesser(context,index,direction);
+    }
+
+    public async outbound(context:TypedRPCContext):Promise<TypedRPCContext>{
+        if(this.middlewares.length <= 0){
+            return context;
+        }
+        return this.middlewareProcesser(context,0,'outbound');
+    }
+
+    public async inbound(context:TypedRPCContext):Promise<TypedRPCContext>{
+        if(this.middlewares.length <= 0){
+            return context;
+        }
+        return this.middlewareProcesser(context,this.middlewares.length - 1,'inbound');
+    }
+
+    public async request(connection:TypedRPCConnection,request:TypedRPCRequestPacket):Promise<TypedRPCPacket>{
+        let context:TypedRPCContext = {
+            connection:connection,
+            outbound:request,
+        }
+        context = await this.outbound(context);
+        if(!context.outbound){
+            throw new Error("Request failed: outbound is empty");
+        }
+        const res = await connection.request(JSON.stringify(context.outbound));
+        if(!res){
+            throw new Error("Response is empty");
+        }
+        let responseObject:any | null = null;
+        try{
+            responseObject = JSON.parse(res);
+        }catch(e){
+            throw new Error("Response is not a valid JSON string:"+res);
+        }
+        if(!TypedRPCPacketFactory.isPacket(responseObject)){
+            throw new Error("Response is not a TypedRPCPacket");
+        }
+        if(!TypedRPCPacketFactory.isResponsePacket(responseObject)){
+            throw new Error("Response is not a TypedRPCResponsePacket");
+        }
+        context.inbound = responseObject;
+        context = await this.inbound(context);
+        if(!context.inbound){
+            throw new Error("Request failed: inbound is empty");
+        }
+        return context.inbound;
+    }
+
+    public async handle(connection:TypedRPCConnection,request:TypedRPCRequestPacket,response:(packet:TypedRPCResponsePacket) => void){
+        let context:TypedRPCContext = {
+            connection:connection,
+            inbound:request,
+        }
+        context = await this.inbound(context);
+        if(!context.outbound){
+            return null
+        }
+        context = await this.outbound(context);
+        if(!context.outbound 
+        || !TypedRPCPacketFactory.isResponsePacket(context.outbound)){
+            return null;
+        }
+        response(context.outbound);
+    }
+
+    hook(serviceName:string,methodName:string,config:{
+        handler:(...args:any[])=>any,
+        bind?:any,
+    }){
+        if(!this.hooks[serviceName]){
+            this.hooks[serviceName] = {};
+        }
+        this.hooks[serviceName]![methodName] = {
+            handler:config.handler,
+            bind:config.bind,
+        };
+    }
+
+    
+}
+
+export {
+    TypedRPCHandler,
+    TypedRPCHandlerMiddleware
+}

package/src/index.ts

@@ -0,0 +1,41 @@
+import { TypedRPCClient } from './client.js';
+import { TypedRPCServer } from './server.js';
+import { TypedRPCAPIDefine } from './define.js';
+import { TypedRPCConnectionDefault, TypedRPCConnectionProviderDefault } from './connection.js';
+import { TypedRPCHandlerMiddleware } from './handler.js';
+import { TypedRPCPacketFactory } from './packet.js';
+import { TypedRPCContextSymbol, type TypedRPCContext, type TypedRPCContextAware } from './context.js';
+import { TypedRPCConnection, TypedRPCConnectionProvider } from './connecitons/basic.js';
+import { TypedRPCConnectionHTTP, TypedRPCConnectionProviderHTTP } from './connecitons/http.js';
+import { TypedRPCConnectionProviderSocket, TypedRPCConnectionSocket } from './connecitons/socket.js';
+import { TypedRPCConnectionSocketIO } from './connecitons/socketio.js';
+import { TypedRPCConnectionProviderSocketIO } from './connecitons/socketio.js';
+
+export type {
+    TypedRPCContext,
+    TypedRPCContextAware,
+}
+
+export {
+    TypedRPCClient,
+    TypedRPCServer,
+    TypedRPCAPIDefine,
+
+    TypedRPCConnection,
+    TypedRPCConnectionProvider,
+
+    TypedRPCConnectionDefault,
+    TypedRPCConnectionProviderDefault,
+    TypedRPCConnectionHTTP,
+    TypedRPCConnectionProviderHTTP,
+    TypedRPCConnectionSocket,
+    TypedRPCConnectionProviderSocket,
+    TypedRPCConnectionSocketIO,
+    TypedRPCConnectionProviderSocketIO,
+
+
+    TypedRPCHandlerMiddleware,
+    TypedRPCPacketFactory,
+
+    TypedRPCContextSymbol,
+}