@mingzey/typedrpc 1.0.2 → 1.1.0

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>{};
-}
-

package/src/test/authorization.ts

@@ -1,197 +0,0 @@
-import { TypedRPCClient } from "../index.js";
-import type { TypedRPCContext } from "../index.js";
-import { TypedRPCAPIDefine } from "../index.js";
-import { TypedRPCHandlerMiddleware } from "../index.js";
-import { TypedRPCPacketFactory } from "../index.js";
-import { TypedRPCServer } from "../index.js";
-import { TestCase } from "./TestCase.js";
-
-interface MathServiceInterface{
-    add:(a:number,b:number) => number,
-}
-
-interface AuthServiceInterface{
-    login:(username:string,password:string) => string
-}
-
-const ServerAPIDefine = new TypedRPCAPIDefine<{
-    math:MathServiceInterface,
-    auth:AuthServiceInterface,
-}>()
-
-class MathService implements MathServiceInterface{
-    @TypedRPCAPIDefine.method()
-    add(a: number, b: number): number {
-        return a+b;
-    }
-}
-
-class AuthService implements AuthServiceInterface{
-
-    private authUsers = new Map<string,string>();
-
-    @TypedRPCAPIDefine.method()
-    login(username: string, password: string): string {
-        if(username === 'admin' && password === '123456'){
-            const token = Math.random().toString(36).substring(2);
-            this.authUsers.set(username,token);
-            return token;
-        }
-        return '';
-    }
-
-    checkToken(username:string,token:string):boolean{
-        return this.authUsers.get(username) === token;
-    }
-}
-
-class AuthMiddleware extends TypedRPCHandlerMiddleware{
-
-    private username?:string;
-    private token?:string;
-    
-    constructor(
-        private auth?:AuthService
-    ){
-        super();
-    }
-
-    /**
-     * 对外站进入的请求包进行验证
-     */
-    async inbound(context: TypedRPCContext): Promise<TypedRPCContext> {
-        if(context.inbound){
-            if(TypedRPCPacketFactory.isRequestPacket(context.inbound)){
-                const protectService = ['math'];
-                if(protectService.includes(context.inbound.serviceName)){
-                    const unauthorizedPacket = TypedRPCPacketFactory.createResponsePacket({
-                        requestId:context.inbound.id,
-                        error:"unauthorized",
-                    })
-                    // 进行验证
-                    const username = context.inbound.meta?.username;
-                    const token = context.inbound.meta?.token;
-                    if(!token || !username){
-                        context.outbound = unauthorizedPacket;
-                    }else{
-                        if(!this.auth || !this.auth.checkToken(username,token)){
-                            context.outbound = unauthorizedPacket;
-                        }
-                    }
-                    
-                }
-            }
-            // 如果入站的是响应包，判断出站是否是登录包
-            if(TypedRPCPacketFactory.isResponsePacket(context.inbound)
-            && TypedRPCPacketFactory.isRequestPacket(context.outbound)
-            && context.outbound.serviceName == 'auth'
-            && context.outbound.methodName == 'login'
-            ){
-                const username = context.outbound.args?.[0] as string;
-                const token = context.inbound.result as string;
-                this.token = token;
-                this.username = username;
-            }
-        }
-        return context;
-    }
-
-    async outbound(context: TypedRPCContext): Promise<TypedRPCContext> {
-        if(context.outbound){
-            if(TypedRPCPacketFactory.isRequestPacket(context.outbound)){
-                // 如果有token，附带token
-                if(this.token){
-                    context.outbound.meta = {
-                        username:this.username,
-                        token:this.token,
-                    }
-                }
-            }
-        }
-        return context;
-    }
-
-}
-
-class ServerApp{
-    private math = new MathService();
-    private auth = new AuthService();
-    private server = new TypedRPCServer({
-        local:ServerAPIDefine,
-    })
-
-    constructor(){
-        this.server.use(new AuthMiddleware(this.auth));
-        this.server.hookService('math',this.math);
-        this.server.hookService('auth',this.auth);
-    }
-
-    async start(){
-        return this.server.listen({
-            port:3698,
-        })
-    }
-
-    async stop(){
-        return this.server.close();
-    }
-}
-
-const serverApp = new ServerApp();
-
-
-class TestAuthorization extends TestCase{
-    name(): string {
-        return 'Authorization';
-    }
-    async run(): Promise<boolean> {
-        await serverApp.start();
-
-        const client = new TypedRPCClient({
-            remote:ServerAPIDefine,
-        })
-        client.use(new AuthMiddleware());
-        const connection = await client.connect('localhost:3698');
-        const api = client.getAPI(connection);
-
-        // 未登录调用
-        const unauthorizedResult = await new Promise((resolve) => {
-            api.math.add.request({
-                args:[1,2],
-                callback(result,req,res) {
-                    resolve(result);
-                },
-                error(error,req,res) {
-                    resolve(error);
-                },
-            })
-        })
-        if(unauthorizedResult != 'unauthorized'){
-            console.log('Unauthorized call result should be "unauthorized"');
-            return false;
-        }
-
-        // 进行登录
-        const token = await api.auth.login.call('admin','123456');
-        if(!token){
-            console.log('Login failed');
-            return false;
-        }
-
-        // 重新请求
-        const authorizedResult = await api.math.add.call(1,2);
-        if(authorizedResult != 3){
-            console.log('Authorized call result should be 3');
-            return false;
-        }
-        return true;        
-    }
-
-    public async finally(): Promise<void> {
-        await serverApp.stop();
-        return;
-    }
-
-}
-
-export default TestAuthorization;

package/src/test/basic.ts

@@ -1,44 +0,0 @@
-import { TypedRPCClient } from "../index.js";
-import { TypedRPCAPIDefine } from "../index.js";
-import { TypedRPCServer } from "../index.js";
-import { TestCase } from "./TestCase.js";
-
-const serverAPIDefine = new TypedRPCAPIDefine<{
-    math:{
-        add(a:number,b:number):number,
-    },
-}>();
-
-const server = new TypedRPCServer({
-    local:serverAPIDefine,
-});
-
-server.hook('math','add',{
-    handler:(a,b)=>a+b,
-});
-
-const client = new TypedRPCClient({
-    remote:serverAPIDefine,
-});
-
-export default class TestBasic extends TestCase{
-    name(): string {
-        return 'Basic';
-    }
-    async run(): Promise<boolean> {
-        await server.listen({
-            port:3698,
-        })
-        const connection = await client.connect("localhost:3698");
-        const api = client.getAPI(connection);
-        const result = await api.math.add.call(1,2);
-        if(result == 3){
-            return true;
-        }
-        return false;
-    }
-
-    public async finally(): Promise<void> {
-        await server.close();
-    }
-}