@mingzey/typedrpc 1.0.2 → 1.1.1

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

package/src/handler.ts

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

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

package/src/packet.ts

@@ -1,77 +0,0 @@
-import { IdMaker } from "./utils.js";
-
-export interface TypedRPCPacket {
-    id:string;
-    type:string;
-    meta?:{[key:string]:any};// 元数据，用于传递一些额外的信息
-}
-
-export interface TypedRPCRequestPacket extends TypedRPCPacket {
-    type:'request';
-    serviceName:string;
-    methodName:string;
-    args:any[];
-}
-
-export interface TypedRPCResponsePacket extends TypedRPCPacket {
-    type:'response';
-    requestId:string;
-    result?:any;
-    error?:any;
-}
-
-
-
-export class TypedRPCPacketFactory {
-
-    static createID():string{
-        return IdMaker.makeId();
-    }
-
-    static createRequestPacket(data:{
-        serviceName:string,
-        methodName:string,
-        args:any[]
-    }):TypedRPCRequestPacket{
-        return {
-            id:TypedRPCPacketFactory.createID(),
-            type:'request',
-            serviceName:data.serviceName,
-            methodName:data.methodName,
-            args:data.args,
-        }
-    }
-
-    static createResponsePacket(data:{
-        requestId:string,
-        result?:any,
-        error?:any,
-    }):TypedRPCResponsePacket{
-        return {
-            id:TypedRPCPacketFactory.createID(),
-            type:'response',
-            requestId:data.requestId,
-            result:data.result,
-            error:data.error,
-        }
-    }
-
-    static isPacket(data:any):data is TypedRPCPacket{
-        return data && typeof data === 'object' && 'id' in data && 'type' in data;
-    }
-
-    static isRequestPacket(data:any):data is TypedRPCRequestPacket{
-        if(!TypedRPCPacketFactory.isPacket(data)){
-            return false;
-        }
-        return data.type === 'request';
-    }
-
-    static isResponsePacket(data:any):data is TypedRPCResponsePacket{
-        if(!TypedRPCPacketFactory.isPacket(data)){
-            return false;
-        }
-        return data.type === 'response';
-    }
-}
-

package/src/server.ts

@@ -1,82 +0,0 @@
-
-import { TypedRPCAPI } from "./api.js";
-import type { TypedRPCConnection, TypedRPCConnectionProvider } from "./connecitons/basic.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 TypedRPCServerConfig<T extends TypedRPCAPIDefine<any>,R extends TypedRPCAPIDefine<any>> = {
-    local?:T,
-    remote?:R,
-    connection?:{
-        provider:TypedRPCConnectionProvider,
-    }
-}
-
-type TypedRPCServerEvents = {
-    connection:(connection:TypedRPCConnection)=>void,
-}
-
-class TypedRPCServer<T extends TypedRPCAPIDefine<any>,R extends TypedRPCAPIDefine<any>> {
-
-    public emitter = new TypedEmitter<TypedRPCServerEvents>();
-    private config:TypedRPCServerConfig<T,R>;
-    public core:TypedRPCCore;
-
-    constructor(config?:TypedRPCServerConfig<T,R>){
-        const defaultConfig:TypedRPCServerConfig<T,R> = {
-            
-        }
-        this.config = {...defaultConfig,...config};
-        this.core = new TypedRPCCore(this.config);
-        this.core.emitter.on('connection',(connection) => {
-            this.emitter.emit('connection',connection);
-        })
-    }
-
-    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 listen(){
-        return this.core.listen.bind(this.core);
-    }
-
-    get close(){
-        return this.core.close.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 {
-    TypedRPCServer,
-}

package/src/test/TestCase.ts

@@ -1,6 +0,0 @@
-export abstract class TestCase{
-    abstract name():string;
-    abstract run():Promise<boolean>;
-    public async finally():Promise<void>{};
-}
-