Idea: RPC system

[stelcheck]

Note: will flesh out a complete pseudo-code in upcoming weeks.

Based on messages definition, allow for a request/reply type of API.

1. Should not interfere with messages (e.g. how will harmonize with MessageType.parse?)
2. Should provide a very lightweight encapsulation
3. Network-agnostic: for instance, I should be able to make RPC calls go from the server to the client
4. Timeouts should be possible (e.g timing out requests)

shared/messages/index.ts

// [...]

export enum ServiceIds {
  ServerService
}

// Todo: export decorator?

shared/messages/services/ServerService.ts

import { ServiceIds, Service } from '../'
import MessageRPCService, { RPCResponse } from 'megadata/classes/MessageRPCService'

@Service(ServiceIds.ServerService)
abstract class ServerService extends MessageRPCService {
  public SomeCall(message: MessageType): ReturnMessage;
}

[stelcheck]

Or maybe...

server

// Todo: AutoloadRpc?
@Service(ServerService, Server)
class extends MessageEmitter {
  @RPC(ServerService.Something)
  public SomeCall(message: MessageType): RPCResponse<ReturnMessage> {
    // ...
  }
}

client

const serverService = new RPCService(ServerService)
const returnMessage = await serverService.SomeCall(message) // can throw on error messages!

[yovanoc]

I'm interested in doing this but I have some questions first :
What is the main goal of this?
Can I have more information about what is exactly wanted or some pseudo-code?
Thanks

[stelcheck]

This one will likely be hard to get done before #12 is done, but the idea is: there are some case where you may want the client and server to be in lockstep, e.g. send a message, wait for a reply (or at least for the server to confirm some processing has been completed).