@mingzey/typedrpc 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,228 @@
+# TypedRPC
+
+TypeScript-based RPC framework with support for multiple connection types including HTTP, Socket, and SocketIO.
+
+## Features
+
+- **Type-Safe RPC calls** - Leverage TypeScript's type system for end-to-end type safety
+- **Multiple connection types** - Support for HTTP, Socket, and SocketIO connections, or custom connection providers
+- **Middleware support** - Extensible middleware system for request/response handling
+- **Context-aware** - Built-in context system for passing data between handlers
+- **Bidirectional communication** - Support for two-way RPC calls between client and server, capability depends on connection type
+- **Easy to use** - Simple API for defining services and methods
+
+## Installation
+
+```bash
+npm install typedrpc
+```
+
+## Basic Usage
+
+### Server Setup
+
+```typescript
+import { TypedRPCServer, TypedRPCAPIDefine } from 'typedrpc';
+
+// Define your API interface
+const ServerAPIDefine = new TypedRPCAPIDefine<{
+  // Service layer - Define your services here or use interface inheritance
+    math:{
+      // Method layer - Define your methods here
+        add(a:number,b:number):number,
+    },
+}>();
+
+// Create server instance
+const server = new TypedRPCServer({
+    // let typescript infer the type from ServerAPIDefine
+    local:ServerAPIDefine,
+    // Connection layer - use your connection provider here
+    // connection:{
+    //     provider:new TypedRPCConnectionProviderHTTP(),
+    // }
+});
+
+// Hook service methods
+server.hook('math','add',{
+    handler:(a,b)=>a+b,
+});
+
+// Start listening
+server.listen({
+    port:3698,
+})
+```
+
+### Client Setup
+
+```typescript
+import { TypedRPCClient, TypedRPCAPIDefine } from 'typedrpc';
+// Reuse or import the same API definition
+const ServerAPIDefine = new TypedRPCAPIDefine<{
+  math:{
+      add(a:number,b:number):number,
+  },
+}>();
+
+// Create client instance
+const client = new TypedRPCClient({
+    // let typescript infer the type from ServerAPIDefine
+    remote:ServerAPIDefine,
+});
+
+// Connect to server
+const connection = await client.connect("localhost:3698");
+
+// Get API instance
+const api = client.getAPI(connection);
+
+// Make RPC calls
+const result = await api.math.add.call(1,2); // Returns 3
+```
+
+## Connection Types
+
+TypedRPC supports multiple connection types:
+
+1. **HTTP** - RESTful HTTP API
+2. **Socket** - Raw socket connections
+3. **SocketIO** - Socket.IO connections
+4. **Custom** - User-defined connection providers, see abstract class `TypedRPCConnectionProvider`
+
+```typescript
+new TypedRPCServer({
+    local:ServerAPIDefine,
+    connection:{
+        provider:new TypedRPCConnectionProviderHTTP(),
+        // provider:new TypedRPCConnectionProviderSocket(),
+        // provider:new TypedRPCConnectionProviderSocketIO(),
+        // provider:implaement your own connection provider
+    }
+})
+```
+
+## API Documentation
+
+### Server API
+
+- `new TypedRPCServer(config)` - Create a new server instance
+- `server.hook(serviceName, methodName, config)` - Hook a single method
+- `server.hookService(serviceName, instance)` - Hook an entire service
+- `server.use(middleware)` - Add middleware
+- `server.listen()` - Start listening for connections
+- `server.close()` - Close the server
+
+### Client API
+
+- `new TypedRPCClient(config)` - Create a new client instance
+- `client.connect()` - Connect to the server
+- `client.getAPI(connection)` - Get API instance for a connection
+- `client.use(middleware)` - Add middleware
+
+## Middleware Usage
+
+TypedRPC supports middleware for both servers and clients:
+
+```typescript
+class MyMiddleware extends TypedRPCHandlerMiddleware{
+
+    async inbound(context: TypedRPCContext): Promise<TypedRPCContext> {
+      // Do something when inbound packet
+      return context;
+    }
+
+    async outbound(context: TypedRPCContext): Promise<TypedRPCContext> {
+      // Do something when outbound packet
+      return context;
+    }
+
+}
+```
+
+## Context Usage
+
+TypedRPC provides a built-in context system that allows you to access request context in your service methods. This is particularly useful for accessing connection information, authentication data, or other request-specific data.
+
+### Example: Using Context in Services
+
+```typescript
+// Server-side code
+import { TypedRPCServer, TypedRPCAPIDefine, TypedRPCContextSymbol, type TypedRPCContext, type TypedRPCContextAware } from 'typedrpc';
+
+// Define service interface
+interface MathServiceInterface {
+    add(a: number, b: number):number;
+}
+
+// Create API definition
+const serverAPIDefine = new TypedRPCAPIDefine<{
+    math: MathServiceInterface,
+}>();
+
+// Create server instance
+const server = new TypedRPCServer({
+    local: serverAPIDefine,
+});
+
+// Implement service with context awareness
+class MathService implements MathServiceInterface, TypedRPCContextAware {
+    // Inject context using TypedRPCContextSymbol
+    [TypedRPCContextSymbol]: TypedRPCContext | null = null;
+
+    // For safety, must use @TypedRPCAPIDefine.method() to mark method as RPC method in service usage
+    @TypedRPCAPIDefine.method()
+    add(a: number, b: number): number {
+        // Access context
+        const context = this[TypedRPCContextSymbol];
+        if (!context) {
+            throw new Error('Context is not available');
+        }
+        
+        // Use context information (e.g., connection details, authentication)
+        console.log('Request received from:', context.connection);
+        
+        return a + b;
+    }
+}
+
+// Hook service to server, only methods marked with @TypedRPCAPIDefine.method() will be hooked
+server.hookService('math', new MathService());
+
+// Start server
+server.listen({
+    port: 3698,
+});
+```
+
+```typescript
+// Client-side code
+import { TypedRPCClient, TypedRPCAPIDefine } from 'typedrpc';
+
+// Reuse API definition
+const serverAPIDefine = new TypedRPCAPIDefine<{
+    math: MathServiceInterface,
+}>();
+
+// Create client
+const client = new TypedRPCClient({
+    remote: serverAPIDefine,
+});
+
+// Connect and make RPC call
+const connection = await client.connect("localhost:3698");
+const api = client.getAPI(connection);
+const result = await api.math.add.call(1, 2); // Returns 3
+```
+
+## More Usage
+
+see `./test/*.ts` for more usage.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License - see the [LICENSE](https://github.com/TypedRPC/TypedRPC/blob/main/LICENSE) file for details.

package/README.zh-CN.md

@@ -0,0 +1,228 @@
+# TypedRPC
+
+基于 TypeScript 的 RPC 框架，支持多种连接类型，包括 HTTP、Socket 和 SocketIO。
+
+## 特性
+
+- **类型安全的 RPC 调用** - 利用 TypeScript 的类型系统实现端到端的类型安全
+- **多种连接类型** - 支持 HTTP、Socket 和 SocketIO 连接，或自定义`TypedRPCConnectionProvider`
+- **中间件支持** - 可扩展的中间件系统，用于请求/响应处理
+- **上下文感知** - 内置上下文系统，用于在处理程序之间传递数据
+- **双向通信** - 支持客户端和服务器之间的双向 RPC 调用，能力取决于连接类型
+- **易于使用** - 用于定义服务和方法的简单 API
+
+## 安装
+
+```bash
+npm install typedrpc
+```
+
+## 基本使用
+
+### 服务器设置
+
+```typescript
+import { TypedRPCServer, TypedRPCAPIDefine } from 'typedrpc';
+
+// 定义 API 接口
+const ServerAPIDefine = new TypedRPCAPIDefine<{
+  // 服务层 - 在此处定义服务或使用接口继承
+    math:{
+      // 方法层 - 在此处定义方法
+        add(a:number,b:number):number,
+    },
+}>();
+
+// 创建服务器实例
+const server = new TypedRPCServer({
+    // 让 TypeScript 从 ServerAPIDefine 推断类型
+    local:ServerAPIDefine,
+    // 连接层 - 在此处使用TypedRPCConnectionProvider的实现类
+    // connection:{
+    //     provider:new TypedRPCConnectionProviderHTTP(),
+    // }
+});
+
+// 挂钩服务方法
+server.hook('math','add',{
+    handler:(a,b)=>a+b,
+});
+
+// 开始监听
+server.listen({
+    port:3698,
+})
+```
+
+### 客户端设置
+
+```typescript
+import { TypedRPCClient, TypedRPCAPIDefine } from 'typedrpc';
+// 重用或导入相同的 API 定义
+const ServerAPIDefine = new TypedRPCAPIDefine<{
+  math:{
+      add(a:number,b:number):number,
+  },
+}>();
+
+// 创建客户端实例
+const client = new TypedRPCClient({
+    // 让 TypeScript 从 ServerAPIDefine 推断类型
+    remote:ServerAPIDefine,
+});
+
+// 连接到服务器
+const connection = await client.connect("localhost:3698");
+
+// 获取 API 实例
+const api = client.getAPI(connection);
+
+// 进行 RPC 调用
+const result = await api.math.add.call(1,2); // 返回 3
+```
+
+## 连接类型
+
+TypedRPC 支持多种连接类型：
+
+1. **HTTP** - RESTful HTTP API
+2. **Socket** - 原始套接字连接
+3. **SocketIO** - Socket.IO 连接
+4. **自定义** - 用户定义的连接提供者，参见抽象类 `TypedRPCConnectionProvider`
+
+```typescript
+new TypedRPCServer({
+    local:ServerAPIDefine,
+    connection:{
+        provider:new TypedRPCConnectionProviderHTTP(),
+        // provider:new TypedRPCConnectionProviderSocket(),
+        // provider:new TypedRPCConnectionProviderSocketIO(),
+        // provider:实现您自己的TypedRPCConnectionProvider的子类
+    }
+})
+```
+
+## API 文档
+
+### 服务器 API
+
+- `new TypedRPCServer(config)` - 创建新的服务器实例
+- `server.hook(serviceName, methodName, config)` - 挂钩单个方法
+- `server.hookService(serviceName, instance)` - 挂钩整个服务
+- `server.use(middleware)` - 添加中间件
+- `server.listen()` - 开始监听连接
+- `server.close()` - 关闭服务器
+
+### 客户端 API
+
+- `new TypedRPCClient(config)` - 创建新的客户端实例
+- `client.connect()` - 连接到服务器
+- `client.getAPI(connection)` - 获取连接的 API 实例
+- `client.use(middleware)` - 添加中间件
+
+## 中间件使用
+
+TypedRPC 支持服务器和客户端的中间件：
+
+```typescript
+class MyMiddleware extends TypedRPCHandlerMiddleware{
+
+    async inbound(context: TypedRPCContext): Promise<TypedRPCContext> {
+      // 处理入站数据包时执行操作
+      return context;
+    }
+
+    async outbound(context: TypedRPCContext): Promise<TypedRPCContext> {
+      // 处理出站数据包时执行操作
+      return context;
+    }
+
+}
+```
+
+## 上下文使用
+
+TypedRPC 提供内置的上下文系统，允许您在服务方法中访问请求上下文。这对于访问连接信息、认证数据或其他请求特定数据特别有用。
+
+### 示例：在服务中使用上下文
+
+```typescript
+// 服务器端代码
+import { TypedRPCServer, TypedRPCAPIDefine, TypedRPCContextSymbol, type TypedRPCContext, type TypedRPCContextAware } from 'typedrpc';
+
+// 定义服务接口
+interface MathServiceInterface {
+    add(a: number, b: number):number;
+}
+
+// 创建 API 定义
+const serverAPIDefine = new TypedRPCAPIDefine<{
+    math: MathServiceInterface,
+}>();
+
+// 创建服务器实例
+const server = new TypedRPCServer({
+    local: serverAPIDefine,
+});
+
+// 实现具有上下文感知的服务
+class MathService implements MathServiceInterface, TypedRPCContextAware {
+    // 使用 TypedRPCContextSymbol 注入上下文
+    [TypedRPCContextSymbol]: TypedRPCContext | null = null;
+
+    // 为安全起见，必须使用 @TypedRPCAPIDefine.method() 将方法标记为服务使用中的 RPC 方法
+    @TypedRPCAPIDefine.method()
+    add(a: number, b: number): number {
+        // 访问上下文
+        const context = this[TypedRPCContextSymbol];
+        if (!context) {
+            throw new Error('上下文不可用');
+        }
+        
+        // 使用上下文信息（例如，连接详情、认证）
+        console.log('请求来自:', context.connection);
+        
+        return a + b;
+    }
+}
+
+// 将服务挂钩到服务器，只有标记有 @TypedRPCAPIDefine.method() 的方法会被挂钩
+server.hookService('math', new MathService());
+
+// 启动服务器
+server.listen({
+    port: 3698,
+});
+```
+
+```typescript
+// 客户端代码
+import { TypedRPCClient, TypedRPCAPIDefine } from 'typedrpc';
+
+// 重用 API 定义
+const serverAPIDefine = new TypedRPCAPIDefine<{
+    math: MathServiceInterface,
+}>();
+
+// 创建客户端
+const client = new TypedRPCClient({
+    remote: serverAPIDefine,
+});
+
+// 连接并进行 RPC 调用
+const connection = await client.connect("localhost:3698");
+const api = client.getAPI(connection);
+const result = await api.math.add.call(1, 2); // 返回 3
+```
+
+## 更多使用
+
+请参阅 `./test/*.ts` 获取更多使用示例。
+
+## 贡献
+
+欢迎贡献！请随时提交 Pull Request。
+
+## 许可证
+
+MIT 许可证 - 详情请参阅 [LICENSE](https://github.com/TypedRPC/TypedRPC/blob/main/LICENSE) 文件。

package/dist/api.d.ts

@@ -0,0 +1,16 @@
+import type { TypeRPCAPIDefine } from "./define.js";
+import type { TypeRPCRequestPacket, TypeRPCResponsePacket } from "./packet.js";
+import type { TypeRPCDefineToTypeRPCAPI } from "./utils.js";
+declare class TypeRPCAPI<T extends TypeRPCAPIDefine<any>> {
+    constructor();
+    interface(callback: (context: {
+        serviceName: string;
+        methodName: string;
+        args: any[];
+    }) => Promise<{
+        request: TypeRPCRequestPacket;
+        response: TypeRPCResponsePacket;
+    }>): TypeRPCDefineToTypeRPCAPI<T>;
+}
+export { TypeRPCAPI };
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAG5D,cAAM,UAAU,CAAC,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC;;IAK5C,SAAS,CAAC,QAAQ,EAAC,CAAC,OAAO,EAAC;QACxB,WAAW,EAAC,MAAM,CAAC;QAAA,UAAU,EAAC,MAAM,CAAC;QAAA,IAAI,EAAC,GAAG,EAAE,CAAA;KAClD,KAAK,OAAO,CAAC;QACV,OAAO,EAAC,oBAAoB,CAAC;QAC7B,QAAQ,EAAC,qBAAqB,CAAC;KAClC,CAAC,GAAE,yBAAyB,CAAC,CAAC,CAAC;CAmDnC;AAGD,OAAO,EACH,UAAU,EACb,CAAA"}

package/dist/api.js

@@ -0,0 +1,52 @@
+class TypeRPCAPI {
+    constructor() {
+    }
+    interface(callback) {
+        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) => {
+                                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) => {
+                                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
+                        };
+                    }
+                });
+            }
+        });
+    }
+}
+export { TypeRPCAPI };
+//# sourceMappingURL=api.js.map

package/dist/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAKA,MAAM,UAAU;IACZ;IAEA,CAAC;IAED,SAAS,CAAC,QAKR;QACE,OAAO,IAAI,KAAK,CAAC,EAAE,EAAE;YACjB,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ;gBAC7B,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;oBAClC,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;gBACtD,CAAC;gBACD,OAAO,IAAI,KAAK,CAAC,EAAE,EAAE;oBACjB,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ;wBAC5B,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;4BACjC,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;wBACrD,CAAC;wBAED,MAAM,IAAI,GAAG,GAAG,WAAW,IAAI,UAAU,EAAE,CAAC;wBAC5C,MAAM,EAAE,GAAG,GAAG,WAAW,IAAI,UAAU,EAAE,CAAC;wBAE1C,OAAO;4BACH,IAAI,EAAE,KAAK,EAAE,GAAG,IAAW,EAAE,EAAE;gCAC3B,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC;oCAC1B,WAAW,EAAC,WAAW;oCACvB,UAAU,EAAC,UAAU;oCACrB,IAAI,EAAC,IAAI;iCACZ,CAAC,CAAC;gCACH,IAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC;oCACtB,MAAM,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;gCAChC,CAAC;gCACD,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;4BAClC,CAAC;4BACD,OAAO,EAAC,KAAK,EAAE,MAId,EAAE,EAAE;gCACD,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC;oCAC1B,WAAW,EAAC,WAAW;oCACvB,UAAU,EAAC,UAAU;oCACrB,IAAI,EAAC,MAAM,CAAC,IAAI,IAAI,EAAE;iCACzB,CAAC,CAAC;gCACH,IAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,CAAC;oCACtB,MAAM,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAC,MAAM,CAAC,OAAO,EAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gCACzE,CAAC;qCAAI,CAAC;oCACF,MAAM,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAC,MAAM,CAAC,OAAO,EAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gCAC7E,CAAC;4BACL,CAAC;4BACD,EAAE;4BACF,IAAI;yBACP,CAAC;oBACN,CAAC;iBACJ,CAAC,CAAC;YACP,CAAC;SACJ,CAAiC,CAAC;IACvC,CAAC;CACJ;AAGD,OAAO,EACH,UAAU,EACb,CAAA"}

package/dist/client.d.ts

@@ -0,0 +1,28 @@
+import type { TypeRPCConnection, TypeRPCConnectionProvider } from "./connecitons/basic.js";
+import { TypeRPCCore } from "./core.js";
+import { TypeRPCAPIDefine } from "./define.js";
+import { TypedEmitter, type TypeRPCDefineMethodBody, type TypeRPCDefineMethodName, type TypeRPCDefineServiceInstance, type TypeRPCDefineServiceName, type TypeRPCDefineToTypeRPCAPI } from "./utils.js";
+type TypeRPCClientConfig<T extends TypeRPCAPIDefine<any>, R extends TypeRPCAPIDefine<any>> = {
+    local?: T;
+    remote?: R;
+    connection?: {
+        provider: TypeRPCConnectionProvider;
+    };
+};
+type TypeRPCClientEvents = {};
+declare class TypeRPCClient<T extends TypeRPCAPIDefine<any>, R extends TypeRPCAPIDefine<any>> {
+    emitter: TypedEmitter<TypeRPCClientEvents>;
+    private config;
+    core: TypeRPCCore;
+    constructor(config?: TypeRPCClientConfig<T, R>);
+    hook<S extends TypeRPCDefineServiceName<T>, M extends TypeRPCDefineMethodName<T, S>>(serviceName: S, methodName: M, config: {
+        handler: TypeRPCDefineMethodBody<T, S, M>;
+        bind?: any;
+    }): void;
+    hookService<S extends TypeRPCDefineServiceName<T>>(serviceName: S, instance: TypeRPCDefineServiceInstance<T, S>): void;
+    get use(): (middleware: import("./handler.js").TypeRPCHandlerMiddleware) => import("./handler.js").TypeRPCHandler;
+    get connect(): (target: string) => Promise<TypeRPCConnection>;
+    getAPI(connection: TypeRPCConnection): TypeRPCDefineToTypeRPCAPI<R>;
+}
+export { TypeRPCClient, };
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAE3F,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,EAAE,YAAY,EAAE,KAAK,uBAAuB,EAAE,KAAK,uBAAuB,EAAE,KAAK,4BAA4B,EAAE,KAAK,wBAAwB,EAAE,KAAK,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAExM,KAAK,mBAAmB,CAAC,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC,EAAC,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC,IAAI;IACxF,KAAK,CAAC,EAAC,CAAC,CAAC;IACT,MAAM,CAAC,EAAC,CAAC,CAAC;IACV,UAAU,CAAC,EAAC;QACR,QAAQ,EAAC,yBAAyB,CAAC;KACtC,CAAA;CACJ,CAAA;AAED,KAAK,mBAAmB,GAAG,EAE1B,CAAA;AAED,cAAM,aAAa,CAAC,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC,EAAC,CAAC,SAAS,gBAAgB,CAAC,GAAG,CAAC;IAExE,OAAO,oCAA2C;IACzD,OAAO,CAAC,MAAM,CAA0B;IACjC,IAAI,EAAC,WAAW,CAAC;gBAEZ,MAAM,CAAC,EAAC,mBAAmB,CAAC,CAAC,EAAC,CAAC,CAAC;IAU5C,IAAI,CAAC,CAAC,SAAS,wBAAwB,CAAC,CAAC,CAAC,EAAC,CAAC,SAAS,uBAAuB,CAAC,CAAC,EAAC,CAAC,CAAC,EAAE,WAAW,EAAC,CAAC,EAAC,UAAU,EAAC,CAAC,EAAC,MAAM,EAAC;QACjH,OAAO,EAAC,uBAAuB,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC,CAAC;QACvC,IAAI,CAAC,EAAC,GAAG,CAAC;KACb;IAID,WAAW,CAAC,CAAC,SAAS,wBAAwB,CAAC,CAAC,CAAC,EAAE,WAAW,EAAC,CAAC,EAAC,QAAQ,EAAC,4BAA4B,CAAC,CAAC,EAAC,CAAC,CAAC;IAU3G,IAAI,GAAG,2GAEN;IAED,IAAI,OAAO,mDAEV;IAED,MAAM,CAAC,UAAU,EAAC,iBAAiB,GAAE,yBAAyB,CAAC,CAAC,CAAC;CAWpE;AAED,OAAO,EACH,aAAa,GAChB,CAAA"}

package/dist/client.js

@@ -0,0 +1,50 @@
+import { TypeRPCAPI } from "./api.js";
+import { TypeRPCConnectionProviderDefault } from "./connection.js";
+import { TypeRPCCore } from "./core.js";
+import { TypeRPCAPIDefine } from "./define.js";
+import { TypedEmitter } from "./utils.js";
+class TypeRPCClient {
+    emitter = new TypedEmitter();
+    config;
+    core;
+    constructor(config) {
+        const defaultConfig = {
+            connection: {
+                provider: new TypeRPCConnectionProviderDefault(),
+            }
+        };
+        this.config = { ...defaultConfig, ...config };
+        this.core = new TypeRPCCore(this.config);
+    }
+    hook(serviceName, methodName, config) {
+        return this.core.hook(serviceName, methodName, config);
+    }
+    hookService(serviceName, instance) {
+        const methodList = TypeRPCAPIDefine.getMethodList(instance);
+        for (let methodName of methodList) {
+            this.hook(serviceName, methodName, {
+                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) {
+        const api = new TypeRPCAPI();
+        return api.interface(async (context) => {
+            return await this.core.request({
+                connection,
+                serviceName: context.serviceName,
+                methodName: context.methodName,
+                args: context.args,
+            });
+        });
+    }
+}
+export { TypeRPCClient, };
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,OAAO,EAAE,gCAAgC,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,OAAO,EAAE,YAAY,EAAgK,MAAM,YAAY,CAAC;AAcxM,MAAM,aAAa;IAER,OAAO,GAAG,IAAI,YAAY,EAAuB,CAAC;IACjD,MAAM,CAA0B;IACjC,IAAI,CAAa;IAExB,YAAY,MAAgC;QACxC,MAAM,aAAa,GAA4B;YAC3C,UAAU,EAAC;gBACP,QAAQ,EAAC,IAAI,gCAAgC,EAAE;aAClD;SACJ,CAAA;QACD,IAAI,CAAC,MAAM,GAAG,EAAC,GAAG,aAAa,EAAC,GAAG,MAAM,EAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED,IAAI,CAA+E,WAAa,EAAC,UAAY,EAAC,MAG7G;QACG,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAC,UAAU,EAAC,MAAM,CAAC,CAAC;IACzD,CAAC;IAED,WAAW,CAAwC,WAAa,EAAC,QAA0C;QACvG,MAAM,UAAU,GAAG,gBAAgB,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;QAC5D,KAAI,IAAI,UAAU,IAAI,UAAU,EAAC,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAC,UAA0C,EAAC;gBAC7D,OAAO,EAAC,QAAQ,CAAC,UAAU,CAAC;gBAC5B,IAAI,EAAC,QAAQ;aAChB,CAAC,CAAA;QACN,CAAC;IACL,CAAC;IAED,IAAI,GAAG;QACH,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACzD,CAAC;IAED,IAAI,OAAO;QACP,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;IAED,MAAM,CAAC,UAA4B;QAC/B,MAAM,GAAG,GAAG,IAAI,UAAU,EAAK,CAAC;QAChC,OAAO,GAAG,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;YACnC,OAAO,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;gBAC3B,UAAU;gBACV,WAAW,EAAC,OAAO,CAAC,WAAW;gBAC/B,UAAU,EAAC,OAAO,CAAC,UAAU;gBAC7B,IAAI,EAAC,OAAO,CAAC,IAAI;aACpB,CAAC,CAAA;QACN,CAAC,CAAC,CAAA;IACN,CAAC;CACJ;AAED,OAAO,EACH,aAAa,GAChB,CAAA"}

package/dist/connecitons/basic.d.ts

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