ts-protoc-gen - Protocol Buffers Compiler (protoc) plugin for TypeScript and gRPC-Web.

  •        89

This repository contains a protoc plugin that generates TypeScript declarations (.d.ts files) that match the JavaScript output of protoc --js_out=import_style=commonjs,binary. This plugin can also output service definitions as both .js and .d.ts files in the structure required by grpc-web. This plugin is tested and written using TypeScript 2.7.

https://github.com/improbable-eng/ts-protoc-gen

Dependencies:

google-protobuf : ^3.6.1

Tags
Implementation
License
Platform

   




Related Projects

prototool - Your Swiss Army Knife for Protocol Buffers

  •    Go

Protobuf is one of the best interface description languages out there - it's widely adopted, and after over 15 years of use, it's practically bulletproof. However, working with Protobuf and maintaining consistency across your Protobuf files can be a pain - protoc, while being a tool that has stood the test of time, is non-trivial to use, and the Protobuf community has not developed common standards with regards to stub generation. Prototool aims to solve this by making working with Protobuf much simpler. Prototool accomplishes this by downloading and calling protoc on the fly for you, handing error messages from protoc and your plugins, and using the generated FileDescriptorSets for internal functionality, as well as wrapping a few great external libraries already in the Protobuf ecosystem.

protoc-gen-doc - Documentation generator plugin for Google Protocol Buffers

  •    Go

This is a documentation generator plugin for the Google Protocol Buffers compiler (protoc). The plugin can generate HTML, JSON, DocBook and Markdown documentation from comments in your .proto files. It supports proto2 and proto3, and can handle having both in the same context (see examples for proof).

grpc-swift - The Swift language implementation of gRPC.

  •    C

This repository contains an experimental Swift gRPC API and code generator.It is intended for use with Apple's swift-protobuf support for Protocol Buffers. Both projects contain code generation plugins for protoc, Google's Protocol Buffer compiler, and both contain libraries of supporting code that is needed to build and run the generated code.

grpc-gateway - gRPC to JSON proxy generator following the gRPC HTTP spec

  •    Go

grpc-gateway is a plugin of protoc. It reads gRPC service definition, and generates a reverse-proxy server which translates a RESTful JSON API into gRPC. This server is generated according to the google.api.http annotation in your gRPC service definition. It helps you to provide your APIs in both gRPC and RESTful style at the same time.

protobuf-c - Protocol Buffers implementation in C

  •    C++

This is protobuf-c, a C implementation of the Google Protocol Buffers data serialization format. It includes libprotobuf-c, a pure C library that implements protobuf encoding and decoding, and protoc-c, a code generator that converts Protocol Buffer .proto files to C descriptor code, based on the original protoc. protobuf-c formerly included an RPC implementation; that code has been split out into the protobuf-c-rpc project. protobuf-c's mailing list is hosted on a Google Groups forum. Subscribe by sending an email to protobuf-c+subscribe@googlegroups.com.


Protobuf-PHP - PHP implementation of Google's Protocol Buffers with a protoc plugin compiler

  •    PHP

PHP implementation of Google's Protocol Buffers with a protoc plugin compiler

php-protobuf - PHP Protobuf - Google's Protocol Buffers for PHP

  •    PHP

Protocol Buffers are a way of encoding structured data in an efficient yet extensible format. It might be used in file formats and RPC protocols.PHP Protobuf is Google's Protocol Buffers implementation for PHP with a goal to provide high performance, including a protoc plugin to generate PHP classes from .proto files. The heavy-lifting (a parsing and a serialization) is done by a PHP extension.

protobuf-swift - Google ProtocolBuffers for Apple Swift

  •    Swift

An implementation of Protocol Buffers in Swift. Protocol Buffers are a way of encoding structured data in an efficient yet extensible format. This project is based on an implementation of Protocol Buffers from Google. See the Google protobuf project for more information.

protobuf - Protocol Buffers - Google's data interchange format

  •    C++

Copyright 2008 Google Inc. Protocol Buffers (a.k.a., protobuf) are Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data. You can find protobuf's documentation on the Google Developers site.

Protocol Buffers - Google's data interchange format

  •    C++

Protocol buffers (a.k.a., protobuf) are Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data. You define how you want your data to be structured once, then you can use special generated source code to easily write and read your structured data to and from a variety of data streams and using a variety of languages.

grpc-elixir - The Elixir implementation of gRPC

  •    Elixir

The Elixir implementation of gRPC. You can start the gRPC server as a supervised process. First, add GRPC.Server.Supervisor to your supervision tree.

swift-protobuf - Plugin and runtime library for using protobuf with Swift

  •    Swift

Apple's Swift programming language is a perfect complement to Google's Protocol Buffer ("protobuf") serialization technology. They both emphasize high performance and programmer safety. This project provides both the command-line program that adds Swift code generation to Google's protoc and the runtime library that is necessary for using the generated code. After using the protoc plugin to generate Swift code from your .proto files, you will need to add this library to your project.

protoc-gen-lua - Google's Protocol Buffers project, ported to Lua

  •    Lua

"Protocol Buffers" is a binary serialization format and technology, released to the open source community by Google in 2008. There are various implementations of Protocol Buffers and this is for Lua.

grpc-web - gRPC Web implementation for Golang and TypeScript

  •    TypeScript

gRPC-Web is a cutting-edge spec that enables invoking gRPC services from modern browsers. If you are looking for gRPC support for Node.js there is an official Node.js gRPC library. This package supports Node.js, but requires that the server has the gRPC-Web compatibility layer (read on to understand more).

grpcc - A gRPC cli interface for easy testing against gRPC servers

  •    Javascript

grpcc is a flexible command-line client for any gRPC server for quick and easy testing of APIs. grpcc is written in nodejs but can talk to a gRPC service written in any language. By default, grpcc will attempt to make a secure connection to the service. If you need an insecure connection, you can pass in the -i flag.

go-proto-validators - Generate message validators from .proto annotations.

  •    Go

A protoc plugin that generates Validate() error functions on Go proto structs based on field options inside .proto files. The validation functions are code-generated and thus don't suffer on performance from tag-based reflection on deeply-nested messages.

grpcurl - Like cURL, but for gRPC: Command-line tool for interacting with gRPC servers

  •    Go

grpcurl is a command-line tool that lets you interact with gRPC servers. It's basically curl for gRPC servers. The main purpose for this tool is to invoke RPC methods on a gRPC server from the command-line. gRPC servers use a binary encoding on the wire (protocol buffers, or "protobufs" for short). So they are basically impossible to interact with using regular curl (and older versions of curl that do not support HTTP/2 are of course non-starters). This program accepts messages using JSON encoding, which is much more friendly for both humans and scripts.

ts-loader - TypeScript loader for webpack

  •    Javascript

This is the typescript loader for webpack. We have a number of example setups to accomodate different workflows. From "vanilla" ts-loader, to using ts-loader in combination with babel for transpilation, happypack or thread-loader for faster builds and fork-ts-checker-webpack-plugin for performing type checking in a separate process. Not forgetting Hot Module Replacement. Our examples can be found here.

gRPC-Java - The Java gRPC implementation. HTTP/2 based RPC

  •    Java

In gRPC a client application can directly call methods on a server application on a different machine as if it was a local object, making it easier for you to create distributed applications and services. As in many RPC systems, gRPC is based around the idea of defining a service, specifying the methods that can be called remotely with their parameters and return types.

ScalaPB - Protocol buffer compiler for Scala.

  •    Scala

ScalaPB is a protocol buffer compiler (protoc) plugin for Scala. It will generate Scala case classes, parsers and serializers for your protocol buffers. Each top-level message and enum is written to a separate Scala file. This results in a significant improvement in incremental compilations.