RPC Library

import { rpc } from'@esengine/rpc';
// Define protocol (shared between client and server)
export const chatProtocol = rpc.define({
api: {
// Request-response APIs
login: rpc.api<{ username:string }, { userId:string; token:string }>(),
sendMessage: rpc.api<{ text:string }, { messageId:string }>(),
},
msg: {
// One-way messages (publish-subscribe)
newMessage: rpc.msg<{ from:string; text:string; time:number }>(),
userJoined: rpc.msg<{ username:string }>(),
userLeft: rpc.msg<{ username:string }>(),
},
});
exporttype ChatProtocol =typeof chatProtocol;

import { RpcClient } from'@esengine/rpc/client';
import { chatProtocol } from'./protocol';
// Create client
const client = newRpcClient(chatProtocol, 'ws://localhost:3000', {
onConnect: () =>console.log('Connected'),
onDisconnect: (reason) =>console.log('Disconnected:', reason),
onError: (error) =>console.error('Error:', error),
});
// Connect to server
await client.connect();
// Call API (type-safe)
const { userId, token } = await client.call('login', { username: 'player1' });
console.log('Logged in:', userId);
// Listen to messages (type-safe)
client.on('newMessage', (data)=> {
console.log(`${data.from}: ${data.text}`);
});
// Send message
await client.call('sendMessage', { text: 'Hello!' });

import { serve } from'@esengine/rpc/server';
import { chatProtocol } from'./protocol';
// Create server (API handlers defined in config)
const server = serve(chatProtocol, {
port: 3000,
onStart: (port) =>console.log(`Server started: ws://localhost:${port}`),
api: {
login: async (input, conn) => {
const userId = generateUserId();
const token = generateToken();
// Broadcast user joined
server.broadcast('userJoined', { username: input.username });
return { userId, token };
},
sendMessage: async (input, conn) => {
const messageId = generateMessageId();
// Broadcast new message
server.broadcast('newMessage', {
from: conn.id,
text: input.text,
time: Date.now(),
});
return { messageId };
},
},
});
// Start server
await server.start();

const protocol = rpc.define({
api: {
// API: Request-response pattern, client initiates, server handles and returns
methodName: rpc.api<InputType, OutputType>(),
},
msg: {
// Message: Publish-subscribe pattern, either side can send, other side listens
messageName: rpc.msg<DataType>(),
},
});

import { json, msgpack } from'@esengine/rpc/codec';
// JSON (default, human-readable)
const client = newRpcClient(protocol, url, {
codec: json(),
});
// MessagePack (binary, more efficient)
const client = newRpcClient(protocol, url, {
codec: msgpack(),
});