ts-proto 1.112.1 → 1.114.0

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [1.114.0](https://github.com/stephenh/ts-proto/compare/v1.113.0...v1.114.0) (2022-05-27)
+
+
+### Features
+
+* Official Buf Plugin ([#573](https://github.com/stephenh/ts-proto/issues/573)) ([e6272c4](https://github.com/stephenh/ts-proto/commit/e6272c487f73ff96afb4146a7998a892c4b43f14))
+
+# [1.113.0](https://github.com/stephenh/ts-proto/compare/v1.112.2...v1.113.0) (2022-05-27)
+
+
+### Features
+
+* add options to schema output ([#437](https://github.com/stephenh/ts-proto/issues/437)) ([e8e4e39](https://github.com/stephenh/ts-proto/commit/e8e4e3937292e07280f5154b584e60124118f093))
+
+## [1.112.2](https://github.com/stephenh/ts-proto/compare/v1.112.1...v1.112.2) (2022-05-18)
+
+
+### Bug Fixes
+
+* enum type returns 'UNRECOGNIZED' or '-1' in xxxToJSON/xxxToNumber ([#566](https://github.com/stephenh/ts-proto/issues/566)) ([19911a1](https://github.com/stephenh/ts-proto/commit/19911a1c62e3fe5c8a0eb0a795489340512898da))
+
 ## [1.112.1](https://github.com/stephenh/ts-proto/compare/v1.112.0...v1.112.1) (2022-05-06)
 
 

package/README.markdown

@@ -13,17 +13,17 @@
   - [Table of contents](#table-of-contents)
 - [Overview](#overview)
 - [QuickStart](#quickstart)
-    - [Buf](#buf)
+  - [Buf](#buf)
 - [Goals](#goals)
 - [Example Types](#example-types)
 - [Highlights](#highlights)
 - [Auto-Batching / N+1 Prevention](#auto-batching--n1-prevention)
 - [Usage](#usage)
-    - [Supported options](#supported-options)
-    - [Only Types](#only-types)
-    - [NestJS Support](#nestjs-support)
-    - [Watch Mode](#watch-mode)
-    - [Basic gRPC implementation](#basic-grpc-implementation)
+  - [Supported options](#supported-options)
+  - [Only Types](#only-types)
+  - [NestJS Support](#nestjs-support)
+  - [Watch Mode](#watch-mode)
+  - [Basic gRPC implementation](#basic-grpc-implementation)
 - [Sponsors](#sponsors)
 - [Development](#development)
 - [Assumptions](#assumptions)
@@ -97,7 +97,16 @@ plugins:
     out: ../gen/ts
     strategy: all
     path: ../node_modules/ts-proto/protoc-gen-ts_proto
-```    
+```
+
+You can also use the official plugin published to the Buf Registry.
+
+```yaml
+version: v1
+plugins:
+  - remote: buf.build/roundrock-io/plugins/ts-proto
+    out: ../gen/ts
+```
 
 # Goals
 
@@ -174,7 +183,7 @@ creating a class and calling the right getters/setters.
 
   (Configurable with the `useDate` parameter.)
 
-- `fromJSON`/`toJSON` use the [proto3 canonical JSON encoding format](https://developers.google.com/protocol-buffers/docs/proto3#json) (e.g. timestamps are ISO strings), unlike [`protobufjs`](https://github.com/protobufjs/protobuf.js/issues/1304). 
+- `fromJSON`/`toJSON` use the [proto3 canonical JSON encoding format](https://developers.google.com/protocol-buffers/docs/proto3#json) (e.g. timestamps are ISO strings), unlike [`protobufjs`](https://github.com/protobufjs/protobuf.js/issues/1304).
 
 - ObjectIds can be mapped as `mongodb.ObjectId`
 
@@ -220,7 +229,7 @@ protoc --plugin=node_modules/ts-proto/protoc-gen-ts_proto ./batching.proto -I.
 
 `ts-proto` can also be invoked with [Gradle](https://gradle.org) using the [protobuf-gradle-plugin](https://github.com/google/protobuf-gradle-plugin):
 
-``` groovy
+```groovy
 protobuf {
     plugins {
         // `ts` can be replaced by any unused plugin name, e.g. `tsproto`
@@ -366,19 +375,19 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=metadataType=Foo@./some-file`, ts-proto add a generic (framework-agnostic) metadata field to the generic service definition.
 
-- With `--ts_proto_opt=outputServices=generic-definitions,outputServices=default`, ts-proto will output both generic definitions and interfaces.  This is useful if you want to rely on the interfaces, but also have some reflection capabilities at runtime.
+- With `--ts_proto_opt=outputServices=generic-definitions,outputServices=default`, ts-proto will output both generic definitions and interfaces. This is useful if you want to rely on the interfaces, but also have some reflection capabilities at runtime.
 
 - With `--ts_proto_opt=outputServices=false`, or `=none`, ts-proto will output NO service definitions.
 
 - With `--ts_proto_opt=emitImportedFiles=false`, ts-proto will not emit `google/protobuf/*` files unless you explicit add files to `protoc` like this
-`protoc --plugin=./node_modules/.bin/protoc-gen-ts_proto my_message.proto google/protobuf/duration.proto`
+  `protoc --plugin=./node_modules/.bin/protoc-gen-ts_proto my_message.proto google/protobuf/duration.proto`
 
-- With `--ts_proto_opt=fileSuffix=<SUFFIX>`, ts-proto will emit generated files using the specified suffix. A `helloworld.proto` file with `fileSuffix=.pb` would be generated as `helloworld.pb.ts`. This is common behavior in other protoc plugins and provides a way to quickly glob all the generated files. 
+- With `--ts_proto_opt=fileSuffix=<SUFFIX>`, ts-proto will emit generated files using the specified suffix. A `helloworld.proto` file with `fileSuffix=.pb` would be generated as `helloworld.pb.ts`. This is common behavior in other protoc plugins and provides a way to quickly glob all the generated files.
 
 - With `--ts_proto_opt=enumsAsLiterals=true`, the generated enum types will be enum-ish object with `as const`.
 
 - With `--ts_proto_opt=useExactTypes=false`, the generated `fromPartial` method will not use Exact types.
-  
+
   The default behavior is `useExactTypes=true`, which makes `fromPartial` use Exact type for its argument to make TypeScript reject any unknown properties.
 
 - With `--ts_proto_opt=unknownFields=true`, all unknown fields will be parsed and output as arrays of buffers.
@@ -396,6 +405,7 @@ Generated code will be placed in the Gradle build directory.
   Note that, as indicated, this means Object.keys will not include set-by-default fields, so if you have code that iterates over messages keys in a generic fashion, it will have to also iterate over keys inherited from the prototype.
 
 ### Only Types
+
 If you're looking for `ts-proto` to generate only types for your Protobuf types then passing all three of `outputEncodeMethods`, `outputJsonMethods`, and `outputClientImpl` as `false` is probably what you want, i.e.:
 
 `--ts_proto_opt=onlyTypes=true`.
@@ -417,7 +427,7 @@ If you want to run `ts-proto` on every change of a proto file, you'll need to us
 
 `ts-proto` is RPC framework agnostic - how you transmit your data to and from
 your data source is up to you. The generated client implementations all expect
-a `rpc` parameter, which type is defined like this: 
+a `rpc` parameter, which type is defined like this:
 
 ```ts
 interface Rpc {
@@ -425,7 +435,7 @@ interface Rpc {
 }
 ```
 
-If you're working with gRPC, a simple implementation could look like this: 
+If you're working with gRPC, a simple implementation could look like this:
 
 ```ts
 type RpcImpl = (service: string, method: string, data: Uint8Array) => Promise<Uint8Array>;
@@ -455,14 +465,14 @@ const sendRequest: RpcImpl = (service, method, data) => {
   });
 };
 
-const rpc: Rpc = { request: sendRequest }
+const rpc: Rpc = { request: sendRequest };
 ```
 
 # Sponsors
 
 Kudos to our sponsors:
 
-* [ngrok](https://ngrok.com) funded ts-proto's initial grpc-web support.
+- [ngrok](https://ngrok.com) funded ts-proto's initial grpc-web support.
 
 If you need ts-proto customizations or priority support for your company, you can ping me at [via email](mailto:stephen.haberman@gmail.com).
 
@@ -481,9 +491,10 @@ The commands below assume you have **Docker** installed. To use a **local** copy
 - Run `yarn install` to install the dependencies.
 - Run `yarn build:test` or `yarn build:test:local` to generate the test files.
   > _This runs the following commands:_
-  >  - `proto2bin` — Converts integration test `.proto` files to `.bin`.
-  >  - `bin2ts` — Runs `ts-proto` on the `.bin` files to generate  `.ts`  files.
-  >  - `proto2pbjs` — Generates a reference implementation using `pbjs` for testing compatibility.
+  >
+  > - `proto2bin` — Converts integration test `.proto` files to `.bin`.
+  > - `bin2ts` — Runs `ts-proto` on the `.bin` files to generate `.ts` files.
+  > - `proto2pbjs` — Generates a reference implementation using `pbjs` for testing compatibility.
 - Run `yarn test`
 
 **Workflow**
@@ -494,8 +505,8 @@ The commands below assume you have **Docker** installed. To use a **local** copy
     _Since the proto files were not changed, you only need to regenerate the typescript files._
   - Run `yarn test` to verify the typescript files are compatible with the reference implementation, and pass other tests.
 - Updating or adding `.proto` files in the integration directory:
-  - Run `yarn watch` to automatically regenerate test files when proto files change. 
-    - Or run `yarn build:test` to regenerate all integration test files. 
+  - Run `yarn watch` to automatically regenerate test files when proto files change.
+    - Or run `yarn build:test` to regenerate all integration test files.
   - Run `yarn test` to retest.
 
 **Contributing**
@@ -503,7 +514,7 @@ The commands below assume you have **Docker** installed. To use a **local** copy
 - Run `yarn build:test` and `yarn test` to make sure everything works.
 - Run `yarn prettier` to format the typescript files.
 - Commit the changes:
-  - Also include the generated `.bin` files for the tests where you added or modified `.proto` files.  
+  - Also include the generated `.bin` files for the tests where you added or modified `.proto` files.
     > These are checked into git so that the test suite can run without having to invoke the `protoc` build chain.
   - Also include the generated `.ts` files.
 - Create a pull request
@@ -594,7 +605,7 @@ Foo.encode({ bar: '' }); // => { }, writes an empty Foo object, in protobuf bina
 Reading JSON will also initialize the default values. Since senders may either omit unset fields, or set them to the default value, use `fromJSON` to normalize the input.
 
 ```typescript
-Foo.fromJSON({ }); // => { bar: '' }
+Foo.fromJSON({}); // => { bar: '' }
 Foo.fromJSON({ bar: '' }); // => { bar: '' }
 Foo.fromJSON({ bar: 'baz' }); // => { bar: 'baz' }
 ```
@@ -603,7 +614,7 @@ When writing JSON, `ts-proto` currently does **not** normalize message when conv
 
 ```typescript
 // Current ts-proto behavior
-Foo.toJSON({ }); // => { }
+Foo.toJSON({}); // => { }
 Foo.toJSON({ bar: undefined }); // => { }
 Foo.toJSON({ bar: '' }); // => { bar: '' } - note: this is the default value, but it's not omitted
 Foo.toJSON({ bar: 'baz' }); // => { bar: 'baz' }
@@ -611,13 +622,13 @@ Foo.toJSON({ bar: 'baz' }); // => { bar: 'baz' }
 
 ```typescript
 // Possible future behavior, where ts-proto would normalize message
-Foo.toJSON({ }); // => { }
+Foo.toJSON({}); // => { }
 Foo.toJSON({ bar: undefined }); // => { }
 Foo.toJSON({ bar: '' }); // => { } - note: omitting the default value, as expected
 Foo.toJSON({ bar: 'baz' }); // => { bar: 'baz' }
 ```
 
--  Please open an issue if you need this behavior.
+- Please open an issue if you need this behavior.
 
 # Well-Known Types
 
@@ -626,25 +637,24 @@ Their interpretation is defined by the Protobuf specification, and libraries are
 
 `ts-proto` currently automatically converts these messages to their corresponding native types.
 
- * [google.protobuf.BoolValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#boolvalue) &lrarr; `boolean`
- * [google.protobuf.BytesValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#bytesvalue) &lrarr; `Uint8Array`
- * [google.protobuf.DoubleValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#doublevalue) &lrarr; `number`
- * [google.protobuf.FieldMask](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask) &lrarr; `string[]`
- * [google.protobuf.FloatValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#floatvalue) &lrarr; `number`
- * [google.protobuf.Int32Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#int32value) &lrarr; `number`
- * [google.protobuf.Int64Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#int64value) &lrarr; `number`
- * [google.protobuf.ListValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#listvalue) &lrarr; `any[]`
- * [google.protobuf.UInt32Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#uint32value) &lrarr; `number`
- * [google.protobuf.UInt64Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#uint64value) &lrarr; `number`
- * [google.protobuf.StringValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#stringvalue) &lrarr; `string`
- * [google.protobuf.Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#value)  &lrarr; `any` (i.e. `number | string | boolean | null | array | object`)
- * [google.protobuf.Struct](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct) &lrarr; `{ [key: string]: any }`
+- [google.protobuf.BoolValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#boolvalue) &lrarr; `boolean`
+- [google.protobuf.BytesValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#bytesvalue) &lrarr; `Uint8Array`
+- [google.protobuf.DoubleValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#doublevalue) &lrarr; `number`
+- [google.protobuf.FieldMask](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#fieldmask) &lrarr; `string[]`
+- [google.protobuf.FloatValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#floatvalue) &lrarr; `number`
+- [google.protobuf.Int32Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#int32value) &lrarr; `number`
+- [google.protobuf.Int64Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#int64value) &lrarr; `number`
+- [google.protobuf.ListValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#listvalue) &lrarr; `any[]`
+- [google.protobuf.UInt32Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#uint32value) &lrarr; `number`
+- [google.protobuf.UInt64Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#uint64value) &lrarr; `number`
+- [google.protobuf.StringValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#stringvalue) &lrarr; `string`
+- [google.protobuf.Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#value) &lrarr; `any` (i.e. `number | string | boolean | null | array | object`)
+- [google.protobuf.Struct](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#struct) &lrarr; `{ [key: string]: any }`
 
 ## Wrapper Types
 
 Wrapper Types are messages containing a single primitive field, and can be imported in `.proto` files with `import "google/protobuf/wrappers.proto"`.
 
-
 Since these are _messages_, their default value is `undefined`, allowing you to distinguish unset primitives from their default values, when using Wrapper Types.
 `ts-proto` generates these fields as `<primitive> | undefined`.
 
@@ -671,13 +681,13 @@ interface ExampleMessage {
 When encoding a message the primitive value is converted back to its corresponding wrapper type:
 
 ```typescript
-ExampleMessage.encode({ name: 'foo' }) // => { name: { value: 'foo' } }, in binary
+ExampleMessage.encode({ name: 'foo' }); // => { name: { value: 'foo' } }, in binary
 ```
 
 When calling toJSON, the value is not converted, because wrapper types are idiomatic in JSON.
 
 ```typescript
-ExampleMessage.toJSON({ name: 'foo' }) // => { name: 'foo' }
+ExampleMessage.toJSON({ name: 'foo' }); // => { name: 'foo' }
 ```
 
 ## JSON Types (Struct Types)
@@ -687,7 +697,7 @@ For this reason, Protobuf offers several additional types to represent arbitrary
 
 These are called Struct Types, and can be imported in `.proto` files with `import "google/protobuf/struct.proto"`.
 
-- [google.protobuf.Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#Value) &lrarr; `any`  
+- [google.protobuf.Value](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#Value) &lrarr; `any`
   - This is the most general type, and can represent any JSON value (i.e. `number | string | boolean | null | array | object`).
 - [google.protobuf.ListValue](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf#ListValue) &lrarr; `any[]`
   - To represent a JSON array
@@ -717,8 +727,9 @@ interface ExampleMessage {
 ```
 
 Encoding a JSON value embedded in a message, converts it to a Struct Type:
+
 ```typescript
-ExampleMessage.encode({ anything: { "name": "hello" } })
+ExampleMessage.encode({ anything: { name: 'hello' } });
 /* Outputs the following structure, encoded in protobuf binary format:
 {
   anything: Value {
@@ -735,7 +746,7 @@ ExampleMessage.encode({ anything: { "name": "hello" } })
  }
 }*/
 
-ExampleMessage.encode({ anything: true })
+ExampleMessage.encode({ anything: true });
 /* Outputs the following structure encoded in protobuf binary format:
 {
   anything: Value {

package/build/enums.js

@@ -43,11 +43,11 @@ function generateEnum(ctx, fullName, enumDesc, sourceInfo) {
     }
     if (options.outputJsonMethods) {
         chunks.push(ts_poet_1.code `\n`);
-        chunks.push(generateEnumToJson(fullName, enumDesc));
+        chunks.push(generateEnumToJson(ctx, fullName, enumDesc));
     }
     if (options.stringEnums && options.outputEncodeMethods) {
         chunks.push(ts_poet_1.code `\n`);
-        chunks.push(generateEnumToNumber(fullName, enumDesc));
+        chunks.push(generateEnumToNumber(ctx, fullName, enumDesc));
     }
     return ts_poet_1.joinCode(chunks, { on: '\n' });
 }
@@ -87,7 +87,8 @@ function generateEnumFromJson(ctx, fullName, enumDesc) {
 }
 exports.generateEnumFromJson = generateEnumFromJson;
 /** Generates a function with a big switch statement to encode our enum -> JSON. */
-function generateEnumToJson(fullName, enumDesc) {
+function generateEnumToJson(ctx, fullName, enumDesc) {
+    const { options, utils } = ctx;
     const chunks = [];
     const functionName = case_1.camelCase(fullName) + 'ToJSON';
     chunks.push(ts_poet_1.code `export function ${ts_poet_1.def(functionName)}(object: ${fullName}): string {`);
@@ -95,14 +96,28 @@ function generateEnumToJson(fullName, enumDesc) {
     for (const valueDesc of enumDesc.value) {
         chunks.push(ts_poet_1.code `case ${fullName}.${valueDesc.name}: return "${valueDesc.name}";`);
     }
-    chunks.push(ts_poet_1.code `default: return "UNKNOWN";`);
+    if (options.unrecognizedEnum) {
+        chunks.push(ts_poet_1.code `
+      case ${fullName}.${UNRECOGNIZED_ENUM_NAME}:
+      default:
+        return "${UNRECOGNIZED_ENUM_NAME}";
+    `);
+    }
+    else {
+        // We use globalThis to avoid conflicts on protobuf types named `Error`.
+        chunks.push(ts_poet_1.code `
+      default:
+        throw new ${utils.globalThis}.Error("Unrecognized enum value " + object + " for enum ${fullName}");
+    `);
+    }
     chunks.push(ts_poet_1.code `}`);
     chunks.push(ts_poet_1.code `}`);
     return ts_poet_1.joinCode(chunks, { on: '\n' });
 }
 exports.generateEnumToJson = generateEnumToJson;
 /** Generates a function with a big switch statement to encode our string enum -> int value. */
-function generateEnumToNumber(fullName, enumDesc) {
+function generateEnumToNumber(ctx, fullName, enumDesc) {
+    const { options, utils } = ctx;
     const chunks = [];
     const functionName = case_1.camelCase(fullName) + 'ToNumber';
     chunks.push(ts_poet_1.code `export function ${ts_poet_1.def(functionName)}(object: ${fullName}): number {`);
@@ -110,7 +125,20 @@ function generateEnumToNumber(fullName, enumDesc) {
     for (const valueDesc of enumDesc.value) {
         chunks.push(ts_poet_1.code `case ${fullName}.${valueDesc.name}: return ${valueDesc.number};`);
     }
-    chunks.push(ts_poet_1.code `default: return 0;`);
+    if (options.unrecognizedEnum) {
+        chunks.push(ts_poet_1.code `
+      case ${fullName}.${UNRECOGNIZED_ENUM_NAME}:
+      default:
+        return ${UNRECOGNIZED_ENUM_VALUE};
+    `);
+    }
+    else {
+        // We use globalThis to avoid conflicts on protobuf types named `Error`.
+        chunks.push(ts_poet_1.code `
+      default:
+        throw new ${utils.globalThis}.Error("Unrecognized enum value " + object + " for enum ${fullName}");
+    `);
+    }
     chunks.push(ts_poet_1.code `}`);
     chunks.push(ts_poet_1.code `}`);
     return ts_poet_1.joinCode(chunks, { on: '\n' });

package/build/main.js

@@ -453,7 +453,7 @@ function makeNiceGrpcServerStreamingMethodResult() {
     const NiceGrpcServerStreamingMethodResult = ts_poet_1.conditionalOutput('ServerStreamingMethodResult', ts_poet_1.code `
       export type ServerStreamingMethodResult<Response> = {
         [Symbol.asyncIterator](): AsyncIterator<Response, void>;
-      };  
+      };
     `);
     return { NiceGrpcServerStreamingMethodResult };
 }
@@ -1004,7 +1004,8 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                             return ts_poet_1.code `Long.fromValue(${from} as Long | string)`;
                         }
                         else if (types_1.isEnum(valueField)) {
-                            return ts_poet_1.code `${from} as ${valueType}`;
+                            const fromJson = types_1.getEnumMethod(ctx, valueField.typeName, 'FromJSON');
+                            return ts_poet_1.code `${fromJson}(${from})`;
                         }
                         else {
                             const cstr = case_1.capitalize(valueType.toCodeString());

package/build/schema.js

@@ -5,16 +5,50 @@ const ts_proto_descriptors_1 = require("ts-proto-descriptors");
 const ts_poet_1 = require("ts-poet");
 const visit_1 = require("./visit");
 const utils_1 = require("./utils");
+const types_1 = require("./types");
+const minimal_1 = require("protobufjs/minimal");
 const fileDescriptorProto = ts_poet_1.imp('FileDescriptorProto@ts-proto-descriptors');
+const extensionCache = {};
 function generateSchema(ctx, fileDesc, sourceInfo) {
     var _a;
     const { options } = ctx;
     const chunks = [];
+    fileDesc.extension.forEach((extension) => {
+        if (!(extension.extendee in extensionCache)) {
+            extensionCache[extension.extendee] = {};
+        }
+        extensionCache[extension.extendee][extension.number] = extension;
+    });
     chunks.push(ts_poet_1.code `
+    type ProtoMetaMessageOptions = {
+      options?: { [key: string]: any };
+      fields?: { [key: string]: { [key: string]: any } };
+      oneof?: { [key: string]: { [key: string]: any } };
+      nested?: { [key: string]: ProtoMetaMessageOptions };
+    };
+
     export interface ProtoMetadata {
       fileDescriptor: ${fileDescriptorProto};
       references: { [key: string]: any };
       dependencies?: ProtoMetadata[];
+      options?: {
+        options?: { [key: string]: any };
+        services?: {
+          [key: string]: {
+            options?: { [key: string]: any };
+            methods?: { [key: string]: { [key: string]: any } };
+          }
+        };
+        messages?: {
+          [key: string]: ProtoMetaMessageOptions;
+        };
+        enums?: {
+          [key: string]: {
+            options?: { [key: string]: any };
+            values?: { [key: string]: { [key: string]: any } };
+          };
+        };
+      };
     }
   `);
     const references = [];
@@ -42,13 +76,167 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
     descriptor.sourceCodeInfo = {
         location: ((_a = descriptor.sourceCodeInfo) === null || _a === void 0 ? void 0 : _a.location.filter((loc) => loc['leadingComments'] || loc['trailingComments'])) || [],
     };
+    let fileOptions;
+    if (fileDesc.options) {
+        fileOptions = encodedOptionsToOptions(ctx, '.google.protobuf.FileOptions', fileDesc.options['_unknownFields']);
+        delete fileDesc.options['_unknownFields'];
+    }
+    const messagesOptions = [];
+    (fileDesc.messageType || []).forEach((message) => {
+        const resolvedMessage = resolveMessageOptions(ctx, message);
+        if (resolvedMessage) {
+            messagesOptions.push(resolvedMessage);
+        }
+    });
+    const servicesOptions = [];
+    (fileDesc.service || []).forEach((service) => {
+        const methodsOptions = [];
+        service.method.forEach((method) => {
+            if (method.options) {
+                const methodOptions = encodedOptionsToOptions(ctx, '.google.protobuf.MethodOptions', method.options['_unknownFields']);
+                delete method.options['_unknownFields'];
+                if (methodOptions) {
+                    methodsOptions.push(ts_poet_1.code `'${method.name}': ${methodOptions}`);
+                }
+            }
+        });
+        let serviceOptions;
+        if (service.options) {
+            serviceOptions = encodedOptionsToOptions(ctx, '.google.protobuf.ServiceOptions', service.options['_unknownFields']);
+            delete service.options['_unknownFields'];
+        }
+        if (methodsOptions.length > 0 || serviceOptions) {
+            servicesOptions.push(ts_poet_1.code `
+        '${service.name}': {
+          options: ${serviceOptions},
+          methods: {${ts_poet_1.joinCode(methodsOptions, { on: ',' })}}
+        }
+      `);
+        }
+    });
+    const enumsOptions = [];
+    (fileDesc.enumType || []).forEach((Enum) => {
+        const valuesOptions = [];
+        Enum.value.forEach((value) => {
+            if (value.options) {
+                const valueOptions = encodedOptionsToOptions(ctx, '.google.protobuf.EnumValueOptions', value.options['_unknownFields']);
+                delete value.options['_unknownFields'];
+                if (valueOptions) {
+                    valuesOptions.push(ts_poet_1.code `'${value.name}': ${valueOptions}`);
+                }
+            }
+        });
+        let enumOptions;
+        if (Enum.options) {
+            enumOptions = encodedOptionsToOptions(ctx, '.google.protobuf.EnumOptions', Enum.options['_unknownFields']);
+            delete Enum.options['_unknownFields'];
+        }
+        if (valuesOptions.length > 0 || enumOptions) {
+            enumsOptions.push(ts_poet_1.code `
+        '${Enum.name}': {
+          options: ${enumOptions},
+          values: {${ts_poet_1.joinCode(valuesOptions, { on: ',' })}}
+        }
+      `);
+        }
+    });
     chunks.push(ts_poet_1.code `
     export const ${ts_poet_1.def('protoMetadata')}: ProtoMetadata = {
       fileDescriptor: ${fileDescriptorProto}.fromPartial(${descriptor}),
       references: { ${ts_poet_1.joinCode(references, { on: ',' })} },
       dependencies: [${ts_poet_1.joinCode(dependencies, { on: ',' })}],
+      ${fileOptions || messagesOptions.length > 0 || servicesOptions.length > 0 || enumsOptions.length > 0
+        ? ts_poet_1.code `options: {
+          ${fileOptions ? ts_poet_1.code `options: ${fileOptions},` : ''}
+          ${messagesOptions.length > 0 ? ts_poet_1.code `messages: {${ts_poet_1.joinCode(messagesOptions, { on: ',' })}},` : ''}
+          ${servicesOptions.length > 0 ? ts_poet_1.code `services: {${ts_poet_1.joinCode(servicesOptions, { on: ',' })}},` : ''}
+          ${enumsOptions.length > 0 ? ts_poet_1.code `enums: {${ts_poet_1.joinCode(enumsOptions, { on: ',' })}}` : ''}
+        }`
+        : ''}
     }
   `);
     return chunks;
 }
 exports.generateSchema = generateSchema;
+function getExtensionValue(ctx, extension, data) {
+    if (extension.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE) {
+        const typeName = types_1.basicTypeName(ctx, extension);
+        const resultBuffer = Buffer.concat(data.map((d) => {
+            // Skip length byte
+            const reader = new minimal_1.Reader(d);
+            reader.uint32();
+            return reader.buf.slice(reader.pos);
+        }));
+        const result = resultBuffer.toString('base64');
+        return ts_poet_1.code `'${extension.name}': ${typeName}.decode(Buffer.from('${result}', 'base64'))`;
+    }
+    else {
+        const reader = new minimal_1.Reader(data[0]);
+        let value = reader[types_1.toReaderCall(extension)]();
+        if (typeof value === 'string') {
+            value = ts_poet_1.code `"${value}"`;
+        }
+        return ts_poet_1.code `'${extension.name}': ${value}`;
+    }
+}
+/** Takes the protoc's input of options as proto-encoded messages, and turns them into embedded-able-in-source-code representations. */
+function encodedOptionsToOptions(ctx, extendee, encodedOptions) {
+    if (!encodedOptions) {
+        return undefined;
+    }
+    const resultOptions = [];
+    for (const [key, value] of Object.entries(encodedOptions)) {
+        const extension = extensionCache[extendee][parseInt(key, 10) >>> 3];
+        resultOptions.push(getExtensionValue(ctx, extension, value));
+    }
+    if (resultOptions.length == 0) {
+        return undefined;
+    }
+    return ts_poet_1.code `{${ts_poet_1.joinCode(resultOptions, { on: ',' })}}`;
+}
+function resolveMessageOptions(ctx, message) {
+    const fieldsOptions = [];
+    message.field.forEach((field) => {
+        if (field.options) {
+            const fieldOptions = encodedOptionsToOptions(ctx, '.google.protobuf.FieldOptions', field.options['_unknownFields']);
+            delete field.options['_unknownFields'];
+            if (fieldOptions) {
+                fieldsOptions.push(ts_poet_1.code `'${field.name}': ${fieldOptions}`);
+            }
+        }
+    });
+    const oneOfsOptions = [];
+    message.oneofDecl.forEach((oneOf) => {
+        if (oneOf.options) {
+            const oneOfOptions = encodedOptionsToOptions(ctx, '.google.protobuf.OneofOptions', oneOf.options['_unknownFields']);
+            delete oneOf.options['_unknownFields'];
+            if (oneOfOptions) {
+                oneOfsOptions.push(ts_poet_1.code `'${oneOf.name}': ${oneOfOptions}`);
+            }
+        }
+    });
+    let nestedOptions = [];
+    if (message.nestedType && message.nestedType.length > 0) {
+        message.nestedType.forEach((nested) => {
+            const resolvedMessage = resolveMessageOptions(ctx, nested);
+            if (resolvedMessage) {
+                nestedOptions.push(resolvedMessage);
+            }
+        });
+    }
+    let messageOptions;
+    if (message.options) {
+        messageOptions = encodedOptionsToOptions(ctx, '.google.protobuf.MessageOptions', message.options['_unknownFields']);
+        delete message.options['_unknownFields'];
+    }
+    if (fieldsOptions.length > 0 || oneOfsOptions.length > 0 || nestedOptions.length > 0 || messageOptions) {
+        return ts_poet_1.code `
+      '${message.name}': {
+        ${messageOptions ? ts_poet_1.code `options: ${messageOptions},` : ''}
+        ${fieldsOptions.length > 0 ? ts_poet_1.code `fields: {${ts_poet_1.joinCode(fieldsOptions, { on: ',' })}},` : ''}
+        ${oneOfsOptions.length > 0 ? ts_poet_1.code `oneof: {${ts_poet_1.joinCode(oneOfsOptions, { on: ',' })}},` : ''}
+        ${nestedOptions.length > 0 ? ts_poet_1.code `nested: {${ts_poet_1.joinCode(nestedOptions, { on: ',' })}},` : ''}
+      }
+    `;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "1.112.1",
+  "version": "1.114.0",
   "description": "",
   "main": "build/plugin.js",
   "repository": "github:stephenh/ts-proto",