Skip to content

Call GRPC services (even streams!) from the browser over any two-way socket to Node and soon Go.

License

Notifications You must be signed in to change notification settings

paralin/grpc-bus

Repository files navigation

GRPC Bus codecov Build Status npm version dependencies Status devDependencies Status

NOTE: Development on grpc-bus is currently suspended as I have transitioned to Go from Node in all of my projects. If you want to adopt the project, let me know!

GRPC-bus is a mechanism to call GRPC services from the browser using a Node.JS server as a proxy. The link between the browser and Node.JS is defined by the user, but could be something like a WebSocket.

The server and client are expected to share the same / similar protobuf tree. For example, the same result should come from the following code on both the client and server:

builder.Build("mynamespace.MyType");

In this way the client can implement the ProtoBuf.JS RPC interfaces in the browser. Then, the grpc-bus package does the following:

  • Keep track of connections to desired remote servers
  • Make service calls on behalf of the client
  • Keep track of streaming calls and pipe these back to the client accordingly.

Thus, we can call GRPC servers from the browser via a Node.JS websocket stream.

Example

A full example can be found in the end-to-end tests under ./src/index.spec.ts.

First, create your client, and give it a way to communicate with the server:

var protoTree = ProtobufJS.load('...');
var grpcBus = require('grpc-bus');
// MySendFunction takes a message object.
// This message should be passed to handleMessage on the server.
var client = new grpcBus.Client(protoTree, mySendFunction);
var tree = client.buildTree();
tree.MyService('localhost:3000').then(function(service) {
  service.MyMethod({hello: 'world'}, function(err, resp) {
    console.log(resp);
    service.end();
  });
});

You should always call service.end() when you are done with a service handle, so the server knows it's safe to dispose it.

You'll notice that inside the then block the API is exactly the same as the Node GRPC api.

Internals

A client must first be instantiated. The client object has to be given a function to send a message to the server, and should be called when the server sends a message to it. In this way, the user can implement their own transport, for example, websockets.

Next, the client can instantiate a service object, similar to the GRPC Node API. This returns a promise, resolved with a service handle with stubs for the methods on the service. The server will de-duplicate and re-use multiple service objects internally.

The client can then make calls against the remote service with the same API as the GRPC Node implementation.

When the client is done with a service object, it should dispose it. When all service objects are disposed, the server will disconnect from the service and forget the credentials used.

About

Call GRPC services (even streams!) from the browser over any two-way socket to Node and soon Go.

Resources

License

Stars

Watchers

Forks

Packages

No packages published