@therms/rpc-server

@therms/rpc-server

A Remote Procedure Call framework for Javascript Node.js written in TS.

The goals of this RPC framework:

✅ Provide a simple endpoint for clients to make RPC calls

• Provide clients the ability to connect and subscribe to real-time updates via WebSockets
• Provide a simple distributed server network of RPC handlers with minimal configuration
• Provide debugging & telemetry on all server info, statistics, status and processes via endpoint
• Provide automatic RPC handler API docs for client developers (via telemetry data)
• Can optionally serve a telemetry client (html site)

npm i @therms/rpc-gatewayServer

Gateway Server (Node.js)

A "gateway server" is an entry-point server. In a distributed cluster of RPC servers, gateway servers are used to provide a transport, HTTP or WebSocket, for clients (ie: browser, mobile app) to make RPC calls.

HTTP

A basic server that responds on HTTP to requests:

const { RPCServer } = require('@therms/rpc-server')

const server = new RPCServer({
  gatewayServer: {
    http: { bind: 'localhost', port: 9876 },
    displayName: 'rpc-gateway-1',
  },
});

server.registerHandler({ procedure: 'login' }, async (request) => {
  if (
    request.args.email === '[e-mail]' &&
    request.args.password === 'secret'
  ) {
    return new CallResponseDTO({
      code: 200,
      data: { user: { name: 'Test' } },
      success: true,
    });
  } else {
    return new CallResponseDTO({
      code: 403,
      message: 'Auth failed',
      success: false,
    });
  }
});

server.start();

The RPC gateway server will now be available for RPC clients to make HTTP requests at:

POST http://localhost:9876/ body = { procedure: 'test' }

WebSocket

RPC clients can also connect to a RPC gateway server via WebSocket:

const server = new RPCServer({
  gatewayServer: {
    websocket: { bind: 'localhost', port: 9876 },
    displayName: 'rpc-gateway-1',
  },
});

Handler Server

A handler server is used in a distributed configuration to provide procedure handlers to handle a specific RPC. Handler servers sit usually behind the firewall and their only communication method with other servers is via message broker. Our example uses RabbitMQ as the message broker.

Note: If a gateway server is running and you expect the gateway server to manage calls to a handler server then the gateway server must be provided with messageBroker.amqpURI string so it can connect to the same message broker to communicate with the handler servers.

const { RPCServer } = require('@therms/rpc-server')

const server = new RPCServer({
  messageBroker: {
    amqpURI: 'http://my-rabbit-mq-host.com'
  }
});

server.registerHandler({ procedure: 'get-some-data', scope: 'some-specific-scope' }, async (request) => {
    const data = [...] // do some data fetching...
  
    return new CallResponseDTO({
      code: 200,
      data,
      success: true,
    });
});

server.start();

Serve Telemetry Data

The server instance can optionally be configured to collect telemetry information from other servers in the network and serve that data from an endpoint.

new RPCServer({
  gatewayServer: {
    displayName: 'rpc-gateway-1',
    telemetry: {
      port: 3000,
    },
  },
});

Telemetry data can be fetched via the /telemetry endpoint, ie: GET http://localhost:3000/telemetry

Serve Telemetry Client (HTML Site)

You can optionally serve a static site (proxy) to view telemetry data via a HTML site. Our example uses the @therms/rpc-telemetry-client package that is deployed as an NPM package.

Anyone can create their own telemetry client template

new RPCServer({
  gatewayServer: {
    displayName: 'rpc-gateway-1',
    telemetry: {
      port: 3000,
      staticSiteUrl:
        'https://unpkg.com/@therms/rpc-telemetry-client@latest/build/index.html',
    },
  },
});

This configuration serves the staticSiteUrl (by proxy) at http:localhost:3000/