@mingzey/typedrpc 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingzey/typedrpc",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "TypeScript-based RPC framework with support for multiple connection types including HTTP, Socket, and SocketIO or custom",
   "author": "MingZeY <1552904342@qq.com>",
   "keywords": [
@@ -9,7 +9,8 @@
   ],
   "license": "MIT",
   "files": [
-    "dist/**/*"
+    "dist/**/*",
+    "src/**/*"
   ],
   "main": "dist/index.js",
   "type": "module",

package/src/api.ts

@@ -0,0 +1,72 @@
+import type { TypedRPCAPIDefine } from "./define.js";
+import type { TypedRPCRequestPacket, TypedRPCResponsePacket } from "./packet.js";
+import type { TypedRPCDefineToTypedRPCAPI } from "./utils.js";
+
+
+class TypedRPCAPI<T extends TypedRPCAPIDefine<any>>{
+    constructor(){
+        
+    }
+
+    interface(callback:(context:{
+        serviceName:string,methodName:string,args:any[]
+    }) => Promise<{
+        request:TypedRPCRequestPacket,
+        response:TypedRPCResponsePacket,
+    }>):TypedRPCDefineToTypedRPCAPI<T>{
+        return new Proxy({}, {
+            get(target, serviceName, receiver) {
+                if (typeof serviceName !== 'string') {
+                    return Reflect.get(target, serviceName, receiver);
+                }
+                return new Proxy({}, {
+                    get(target, methodName, receiver) {
+                        if (typeof methodName !== 'string') {
+                            return Reflect.get(target, methodName, receiver);
+                        }
+                        
+                        const path = `${serviceName}.${methodName}`;
+                        const id = `${serviceName}.${methodName}`;
+                        
+                        return {
+                            call: async (...args: any[]) => {
+                                const result = await callback({
+                                    serviceName:serviceName,
+                                    methodName:methodName,
+                                    args:args,
+                                });
+                                if(result.response.error){
+                                    throw result.response.error;
+                                }
+                                return result.response.result;
+                            },
+                            request:async (config:{
+                                args?:any[],
+                                callback?:(result:any,req:TypedRPCRequestPacket,res:TypedRPCResponsePacket) => void,
+                                error?:(error:any,req:TypedRPCRequestPacket,res:TypedRPCResponsePacket) => void,
+                            }) => {
+                                const result = await callback({
+                                    serviceName:serviceName,
+                                    methodName:methodName,
+                                    args:config.args || [],
+                                });
+                                if(result.response.error){
+                                    config.error?.(result.response.error,result.request,result.response);
+                                }else{
+                                    config.callback?.(result.response.result,result.request,result.response);
+                                }
+                            },
+                            id,
+                            path
+                        };
+                    }
+                });
+            }
+        }) as TypedRPCDefineToTypedRPCAPI<T>;
+    }
+}
+
+
+export {
+    TypedRPCAPI
+}

package/src/client.ts

@@ -0,0 +1,77 @@
+import { TypedRPCAPI } from "./api.js";
+import type { TypedRPCConnection, TypedRPCConnectionProvider } from "./connecitons/basic.js";
+import { TypedRPCConnectionProviderDefault } from "./connection.js";
+import { TypedRPCCore } from "./core.js";
+import { TypedRPCAPIDefine } from "./define.js";
+
+import { TypedEmitter, type TypedRPCDefineMethodBody, type TypedRPCDefineMethodName, type TypedRPCDefineServiceInstance, type TypedRPCDefineServiceName, type TypedRPCDefineToTypedRPCAPI } from "./utils.js";
+
+type TypedRPCClientConfig<T extends TypedRPCAPIDefine<any>,R extends TypedRPCAPIDefine<any>> = {
+    local?:T,
+    remote?:R,
+    connection?:{
+        provider:TypedRPCConnectionProvider,
+    }
+}
+
+type TypedRPCClientEvents = {
+    // connection:(connection:TypedRPCConnection)=>void,
+}
+
+class TypedRPCClient<T extends TypedRPCAPIDefine<any>,R extends TypedRPCAPIDefine<any>> {
+
+    public emitter = new TypedEmitter<TypedRPCClientEvents>();
+    private config:TypedRPCClientConfig<T,R>;
+    public core:TypedRPCCore;
+
+    constructor(config?:TypedRPCClientConfig<T,R>){
+        const defaultConfig:TypedRPCClientConfig<T,R> = {
+            connection:{
+                provider:new TypedRPCConnectionProviderDefault(),
+            }
+        }
+        this.config = {...defaultConfig,...config};
+        this.core = new TypedRPCCore(this.config);
+    }
+
+    hook<S extends TypedRPCDefineServiceName<T>,M extends TypedRPCDefineMethodName<T,S>>(serviceName:S,methodName:M,config:{
+        handler:TypedRPCDefineMethodBody<T,S,M>,
+        bind?:any,
+    }){
+        return this.core.hook(serviceName,methodName,config);
+    }
+
+    hookService<S extends TypedRPCDefineServiceName<T>>(serviceName:S,instance:TypedRPCDefineServiceInstance<T,S>){
+        const methodList = TypedRPCAPIDefine.getMethodList(instance);
+        for(let methodName of methodList){
+            this.hook(serviceName,methodName as TypedRPCDefineMethodName<T,S>,{
+                handler:instance[methodName],
+                bind:instance,
+            })
+        }
+    }
+
+    get use(){
+        return this.core.handler.use.bind(this.core.handler);
+    }
+
+    get connect(){
+        return this.core.connect.bind(this.core);
+    }
+
+    getAPI(connection:TypedRPCConnection):TypedRPCDefineToTypedRPCAPI<R>{
+        const api = new TypedRPCAPI<R>();
+        return api.interface(async (context) => {
+            return await this.core.request({
+                connection,
+                serviceName:context.serviceName,
+                methodName:context.methodName,
+                args:context.args,
+            })
+        })
+    }
+}
+
+export {
+    TypedRPCClient,
+}

package/src/connecitons/basic.ts

@@ -0,0 +1,49 @@
+import { TypedEmitter } from "../utils.js";
+
+type TypedRPCConnectionEvents = {
+    /** 有新的请求进入时，应该由Provider调起 */
+    request:(context:{
+        data:string,
+        response:(data:string) => void,
+    }) => void;
+}
+abstract class TypedRPCConnection{
+    public emitter = new TypedEmitter<TypedRPCConnectionEvents>();
+    abstract request(data:string):Promise<string>;
+    /** 获取连接的id */
+    abstract getId():string;
+    /** 关闭连接 */
+    abstract close():boolean;
+    /** 是否关闭 */
+    abstract isClosed():boolean;
+}
+
+type TypedRPCConnectionProviderEvents = {
+    /** 新的连接建立时 */
+    connection:(connection:TypedRPCConnection) => void,
+}
+abstract class TypedRPCConnectionProvider{
+    public emitter = new TypedEmitter<TypedRPCConnectionProviderEvents>();
+    /**
+     * Server用，用于监听一个端口
+     */
+    abstract listen(config:{
+        port:number,
+        hostname?:string,
+    }):Promise<boolean>;
+
+    /**
+     * Server用，用于关闭监听的端口
+     */
+    abstract close():Promise<boolean>;
+
+    /**
+     * Client用，用于建立一个连接
+     */
+    abstract connect(target:string):Promise<TypedRPCConnection>;
+}
+
+export {
+    TypedRPCConnection,
+    TypedRPCConnectionProvider,
+}

package/src/connecitons/http.ts

@@ -0,0 +1,184 @@
+
+import { IdMaker } from "../utils.js";
+import { TypedRPCConnection, TypedRPCConnectionProvider } from "./basic.js";
+
+
+/** 基于http的connection和provider */
+class TypedRPCConnectionHTTP extends TypedRPCConnection{
+
+    private id:string;
+    private closed:boolean = false;
+
+    constructor(private config:{
+        side:'client'|'server',
+        target?:string,
+    }){
+        super();
+        this.id = this.makeId();
+    }
+
+    private makeId(){
+        return IdMaker.makeId();
+    }
+
+    async request(data: string): Promise<string> {
+        if(this.config.side == 'server'){
+            throw new Error("The server connection cannot send RPC requests because the current connection is not bidirectional");
+        }
+        if(!this.config.target){
+            throw new Error("Client connection must have target");
+        }
+        // 发起请求
+        const response = await fetch(`http://${this.config.target}`,{
+            method:'POST',
+            body:data,
+            headers:{
+                // 必须指定typedrpc为1，否则服务器会认为这是一个普通的POST请求
+                typedrpc:'1',
+            }
+        }).then((res) => {
+            return res.text();
+        })
+        return response;
+    }
+
+    getId(): string {
+        return this.id;
+    }
+
+    close(): boolean {
+        this.closed = true;
+        return true;// http connection 关闭时，直接返回true
+    }
+
+    isClosed(): boolean {
+        return this.closed;
+    }
+    
+}
+
+type TypedRPCConnectionProviderHTTPServer = import('http').Server;
+
+type TypedRPCConnectionProviderHTTPConfig = {
+    server?:TypedRPCConnectionProviderHTTPServer,
+}
+
+type TypedRPCConnectionProviderHTTPMiddleware = (req:any,res:any) => void;
+
+class TypedRPCConnectionProviderHTTP extends TypedRPCConnectionProvider{
+
+    public config:TypedRPCConnectionProviderHTTPConfig;
+    public server:TypedRPCConnectionProviderHTTPServer | null = null;
+    private middlewares:TypedRPCConnectionProviderHTTPMiddleware[] = [];
+
+    constructor(config?:TypedRPCConnectionProviderHTTPConfig){
+        super();
+        const defaultConfig:TypedRPCConnectionProviderHTTPConfig = {
+            
+        }
+        this.config = {...defaultConfig,...config};
+        this.server = this.config.server || null;
+        if(this.server){
+            this.initServer(this.server);
+        }
+    }
+
+    public use(middleware:TypedRPCConnectionProviderHTTPMiddleware){
+        this.middlewares.push(middleware);
+    }
+
+    private initServer(server:TypedRPCConnectionProviderHTTPServer){
+        server.on('request',(req,res) => {
+            // 如果请求是不是POST，直接忽略
+            // 如果请求头没有typedrpc=1，直接忽略
+            if(req.method !== 'POST'
+            || req.headers['typedrpc'] !== '1'
+            ){
+                // 调用中间件
+                this.middlewares.forEach((middleware) => {
+                    middleware(req,res);
+                })
+                return;
+            }
+
+            let data = '';
+            req.on('data',(chunk) => {
+                data += chunk.toString();
+            })
+            req.on('end',() => {
+                // 创建一个connection
+                const connection = new TypedRPCConnectionHTTP({
+                    side:'server',
+                });
+                this.emitter.emit('connection',connection);
+                connection.emitter.emit('request',{
+                    data:data,
+                    response:(data) => {
+                        res.end(data);
+                        connection.close();
+                    }
+                })
+            })
+        })
+    }
+
+    private async createServer():Promise<TypedRPCConnectionProviderHTTPServer>{
+        const httpSupport = await import("http").catch(() => null);
+        if(!httpSupport){
+            throw new Error("http module not found");
+        }
+        return httpSupport.default.createServer();
+    }
+
+    async listen(config:{
+        port:number,
+        host?:string,
+    }): Promise<boolean> {
+        if(!this.server){
+            this.server = await this.createServer();
+            this.initServer(this.server);
+        }
+        
+        return new Promise<boolean>((resolve) => {
+            if(!this.server){
+                throw new Error("Listen before server created");
+            }
+            this.server.listen({
+                port:config.port,
+                host:config.host,
+            },() => {
+                resolve(true);
+            });
+        })
+
+    }
+    
+    close(): Promise<boolean> {
+        return new Promise<boolean>((resolve,reject) => {
+            if(!this.server){
+                return true;
+            }
+            this.server.close((err) => {
+                if(err){
+                    reject(err);
+                }
+                resolve(true);
+            })
+            this.server = null;
+        })
+    }
+
+    async connect(target: string): Promise<TypedRPCConnectionHTTP> {
+        const connection = new TypedRPCConnectionHTTP({
+            side:'client',
+            target,
+        });
+        this.emitter.emit('connection',connection);
+        return connection;
+    }
+}
+
+export {
+    TypedRPCConnectionHTTP,
+    TypedRPCConnectionProviderHTTP,
+}

package/src/connecitons/socket.ts

@@ -0,0 +1,247 @@
+import { IdMaker, TypedEmitter } from '../utils.js';
+import { TypedRPCConnection, TypedRPCConnectionProvider } from './basic.js';
+
+type TypedRPCConnectionSocketPayload = {
+    type: 'request' | 'response',
+    id: string,
+    data: string,
+}
+
+type TypedRPCConnectionMessageEvents = {
+    receive: (data: string) => void,
+}
+class TypedRPCConnectionSocket 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) => {
+            const recivePlayload: TypedRPCConnectionSocketPayload = JSON.parse(data);
+            if (recivePlayload.type == 'request'
+                && recivePlayload.id
+            ) {
+                this.emitter.emit('request', {// 告知TypedRPCHandler有新请求
+                    data: recivePlayload.data,
+                    response: (data) => {
+                        const sendPlayout: TypedRPCConnectionSocketPayload = {
+                            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: TypedRPCConnectionSocketPayload = {
+            type: 'request',
+            id: requestId,
+            data: data,
+        }
+
+        const requestPromise = new Promise<string>((resolve) => {
+            this.requests.set(requestId, {
+                resolve: resolve
+            })
+
+            // 发送数据
+            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 TypedRPCConnectionProviderSocket extends TypedRPCConnectionProvider {
+
+    private server: import('net').Server | undefined;
+    private sockets: Set<import('net').Socket> = new Set();
+
+    async listen(config: { port: number; hostname?: string; }): Promise<boolean> {
+        const net = await import('net').catch(() => null);
+        if(!net){
+            throw new Error("net module not found");
+        }
+        const server = net.createServer((socket) => {
+            this.sockets.add(socket);
+            const connection = new TypedRPCConnectionSocket({
+                id: IdMaker.makeId(),
+                send: (data) => {
+                    const buffer = Buffer.from(data);
+                    const length = Buffer.alloc(4);
+                    length.writeUInt32BE(buffer.length, 0);
+                    socket.write(length);
+                    socket.write(buffer);
+                },
+                close: () => {
+                    socket.end();
+                    return true;
+                },
+                isClosed: () => {
+                    return socket.destroyed;
+                },
+            })
+            this.emitter.emit('connection', connection);
+
+            let buffer = Buffer.alloc(0);
+            let expectedLength: number | null = null;
+            socket.on('data', (chunk) => {
+                buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+                while (buffer.length >= 4) {
+                    if (expectedLength === null) {
+                        // 读取消息长度
+                        expectedLength = buffer.readUInt32BE(0);
+                        buffer = Buffer.from(buffer.subarray(4));
+                    }
+
+                    if (buffer.length >= expectedLength) {
+                        // 读取完整消息
+                        const message = buffer.subarray(0, expectedLength).toString();
+                        buffer = Buffer.from(buffer.subarray(expectedLength));
+                        expectedLength = null;
+
+                        // 处理消息
+                        connection.msgEmitter.emit('receive', message);
+                    } else {
+                        break;
+                    }
+                }
+            });
+            socket.on('end', () => {
+                connection.close();
+            })
+            socket.on('close', () => {
+                this.sockets.delete(socket);
+            })
+        })
+        this.server = server;
+        return new Promise((resolve) => {
+            server.listen(config.port, config.hostname, () => {
+                resolve(true);
+            });
+        })
+    }
+
+
+    async close(): Promise<boolean> {
+        return new Promise<boolean>((resolve, reject) => {
+            if (!this.server) {
+                return resolve(true);
+            }
+            // 关闭服务器，停止所有连接
+            this.server.close(() => {
+                resolve(true);
+            });
+            this.server = undefined;
+            // 关闭所有已建立的连接
+            for (const socket of this.sockets) {
+                socket.end();
+            }
+            this.sockets.clear();
+        })
+    }
+
+
+
+    connect(target: string): Promise<TypedRPCConnection> {
+        return new Promise<TypedRPCConnection>(async (resolve, reject) => {
+            const net = await import('net').catch(() => null);
+            if(!net){
+                reject(new Error("net module not found"));
+                return;
+            }
+            const socket = new net.Socket();
+            const [host, port] = target.split(':');
+            if (!host || !port
+                || !Number.isInteger(Number(port))
+            ) {
+                reject(new Error('target format error'));
+                return;
+            }
+            const connection = new TypedRPCConnectionSocket({
+                id: IdMaker.makeId(),
+                send: (data) => {
+                    const buffer = Buffer.from(data);
+                    const length = Buffer.alloc(4);
+                    length.writeUInt32BE(buffer.length, 0);
+                    socket.write(length);
+                    socket.write(buffer);
+                },
+                close: () => {
+                    socket.end();
+                    return true;
+                },
+                isClosed: () => {
+                    return socket.destroyed;
+                }
+            })
+            this.emitter.emit('connection', connection);
+            socket.on('connect', () => {
+                resolve(connection);
+            })
+            let buffer = Buffer.alloc(0);
+            let expectedLength: number | null = null;
+            socket.on('data', (chunk) => {
+                buffer = Buffer.concat([buffer, Buffer.from(chunk)]);
+                while (buffer.length >= 4) {
+                    if (expectedLength === null) {
+                        // 读取消息长度
+                        expectedLength = buffer.readUInt32BE(0);
+                        buffer = Buffer.from(buffer.subarray(4));
+                    }
+
+                    if (buffer.length >= expectedLength) {
+                        // 读取完整消息
+                        const message = buffer.subarray(0, expectedLength).toString();
+                        buffer = Buffer.from(buffer.subarray(expectedLength));
+                        expectedLength = null;
+
+                        // 处理消息
+                        connection.msgEmitter.emit('receive', message);
+                    } else {
+                        break;
+                    }
+                }
+            });
+            socket.on('close', () => {
+                connection.close();
+            })
+            socket.connect(Number(port), host);
+        })
+    }
+
+}
+
+export {
+    TypedRPCConnectionSocket,
+    TypedRPCConnectionProviderSocket,
+}