grpc-code-generator

A code generator for gRPC/protobuf .proto files. Contains templates for generating Typescript definitions for the plain callback/streams based API for grpc-node and protobuf message types.

Running

$ yarn/npm run grpc-code-generator [options] path/to/main.proto [path/to/another.proto]

Options can be specified on the command line or in a config file. If both are present, the command line options take precedence.

Options:

-o  --out <out_dir>

    Output directory (default: src-gen/)

-I  --proto_path <include_dir>     
	
    Root path for resolving imports (may be specified multiple times, default: current working dir)

-t  --templates <template1> [<template2> …]

    Path to template modules used for generating code (default: builtin templates)

-c  --config <file>

    Path to JSON config file.

Config file

{
	"out": "<out_dir>",
	"proto_paths": [
		"<dir1>",
		"<dir2>"
	],
	"files": [
		"path/to/main.proto",
		"path/to/another.proto",
	]
}

Generated files

File	Content
/<package>/index.d.ts	Interfaces for message types
/<package>/<ServiceName>/grpc-node.d.ts	Client/server typings with standard grpc-node interface
/message-base.d.ts	Base message type with constructor
/grpc.d.ts	Object with constructor functions for messages and service descriptions (what grpc.load() returns)

Usage

Parametrize your grpc-node's load() function with the generated type description:

import { load } from 'grpc';
// Service type description for grpc.load()
import Description from './gen/grpc';

const grpc = load<Description>('src/tests/proto/test.proto');

Server side usage:

class TestService implements TestService {
	unaryCall(call: ServerUnaryCall<Request>, callback: sendUnaryData<Response>): void {
		callback(null, new grpc.Response());
	}

	streamResponse(call: ServerWriteableStream<Request>): void {
		for (let i = 0; i < request.count; i++) {
			call.write(new grpc.Response());
		}
		call.end();
	}

	streamRequest(call: ServerReadableStream<Request>, callback: sendUnaryData<Response>): void {
		call
			.on('data', (data: Request) => {
				/* */
			})
			.on('error', (error) => {
				/* */
			})
			.on('end', () => {
				callback(null, new grpc.Response());
			});
	}

	streamBidi(call: ServerDuplexStream<Request, Response>): void {
		call
			.on('data', (data: Request) => {
				call.write(new grpc.Response());
			})
			.on('error', (error) => {
				/* */
			})
			.on('end', () => {
				call.end();
			});
	}
}

const server = new Server();

server.addService(grpc.TestService.service, new TestService());
server.bind('0.0.0.0:3000', ServerCredentials.createInsecure());
server.start();

Client side usage:

import { credentials } from 'grpc';
// message types
import { Request, Response } from './gen';
// adapter types
import { Client } from './gen/TestService/grpc-node';

const client = new grpc.TestService('0.0.0.0:3000', credentials.createInsecure());

// unary request
client.unaryCall(new grpc.Request({ mode: 'normal' }), (err, response) => {
	/* */
});

// streaming response
const stream1 = client.streamResponse(new grpc.Request())
	.on('data', (response) => {
		/* */
	})
	.on('error', (error) => {
		/* */
	})
	.on('end', () => {
		/* */
	});

// streaming request
const requestStream = client.streamRequest(cb);
for (let i = 0; i < 10; i++) {
	requestStream.write(new grpc.Request({ mode: 'normal' }));
}
requestStream.end();

const stream = client.streamBidi()
	.on('data', (response) => {
		/* */
	})
	.on('error', (error) => {
		/* */
	})
	.on('end', () => {
		/* */
	});

for (let i = 0; i < 10; i++) {
	stream.write(new grpc.Request({ mode: 'normal' }));
}
// wait for responses, then
stream.end();

Development

Getting the sources

$ git clone https://github.com/anfema/grpc-code-generator.git
# or
$ git clone git@github.com:anfema/grpc-code-generator.git

Install dependencies & build project

$ yarn
#or 
$ npm

Tasks:

• Build once: $ yarn/npm run build
• Build, watch files: $ yarn/npm run dev
• Remove generated files: $ yarn/npm run clean