@mingzey/typedrpc 1.0.2 → 1.1.1

package/src/connecitons/http.ts

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

@@ -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,
-}