@mingzey/typedrpc 1.0.2 → 1.1.0

package/src/connecitons/socket.ts

@@ -1,247 +0,0 @@
-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,
-}

package/src/connecitons/socketio.ts

@@ -1,200 +0,0 @@
-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

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

package/src/context.ts

@@ -1,18 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

@@ -1,63 +0,0 @@
-
-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,
-}