ts-proto 2.13.3 → 2.15.0

package/README.markdown

@@ -465,11 +465,17 @@ With `--ts_proto_opt=protoJsonFormat=false`, strict proto3 compliance is disable
 
   (Requires `nestJs=true`.)
 
+- With `--ts_proto_opt=useNestjsFqnServiceName=true`, the generated `@FooServiceControllerMethods()` decorator will pass the fully qualified service name (i.e. `package.FooService` instead of `FooService`) to the `@GrpcMethod`/`@GrpcStreamMethod` decorators of `@nestjs/microservices`.
+
+  NestJS falls back to resolving a handler by the `package.Service` segment of the gRPC method path, so the handlers are found regardless of which `package` the gRPC server was configured with, and services with the same name in different packages no longer collide. The `FOO_SERVICE_NAME` const is not affected, since `client.getService()` expects the package-relative name.
+
+  (Requires `nestJs=true`.)
+
 - With `--ts_proto_opt=nestJs=true`, the defaults will change to generate [NestJS protobuf](https://docs.nestjs.com/microservices/grpc) friendly types & service interfaces that can be used in both the client-side and server-side of NestJS protobuf implementations. See the [nestjs readme](NESTJS.markdown) for more information and implementation examples.
 
   Specifically `outputEncodeMethods`, `outputJsonMethods`, and `outputClientImpl` will all be false, `lowerCaseServiceMethods` will be true and `outputServices` will be ignored.
 
-  Note that `addGrpcMetadata`, `addNestjsRestParameter` and `returnObservable` will still be false.
+  Note that `addGrpcMetadata`, `addNestjsRestParameter`, `returnObservable` and `useNestjsFqnServiceName` will still be false.
 
 - With `--ts_proto_opt=useDate=false`, fields of type `google.protobuf.Timestamp` will not be mapped to type `Date` in the generated types. See [Timestamp](#timestamp) for more details.
 
@@ -662,6 +668,10 @@ This option allows the library to act in a compatible way with the [Wire impleme
 
 - With `--ts_proto_opt=useDuration=string`, the generated code will use the `string` type for `google.protobuf.Duration` instead of `{seconds: number, nano: number}`.
 
+- With `--ts_proto_opt=anyType=@type` (the default), `google.protobuf.Any` uses its canonical JSON form in `toJSON`/`fromJSON`: the JSON of the packed message with an added `"@type"` key, or `{"@type": ..., "value": ...}` when the packed message is a well-known type with its own JSON form, such as `google.protobuf.Duration`. The packed message type is looked up by name in the type registry, so this needs `outputTypeRegistry=true` (and the default `outputEncodeMethods=true`), and the type must be registered; otherwise `toJSON`/`fromJSON` throw. Without the type registry, `Any` keeps the `{"typeUrl": ..., "value": ...}` form, with `value` base64 encoded.
+
+  `--ts_proto_opt=anyType=typeUrl` keeps the `{"typeUrl": ..., "value": ...}` form even with the type registry. It is deprecated and may be removed in a future release.
+
 ### NestJS Support
 
 We have a great way of working together with [nestjs](https://docs.nestjs.com/microservices/grpc). `ts-proto` generates `interfaces` and `decorators` for you controller, client. For more information see the [nestjs readme](NESTJS.markdown).

package/build/src/generate-nestjs.d.ts

@@ -4,4 +4,4 @@ import SourceInfo from "./sourceInfo";
 import { Context } from "./context";
 export declare function generateNestjsServiceController(ctx: Context, fileDesc: FileDescriptorProto, sourceInfo: SourceInfo, serviceDesc: ServiceDescriptorProto): Code;
 export declare function generateNestjsServiceClient(ctx: Context, fileDesc: FileDescriptorProto, sourceInfo: SourceInfo, serviceDesc: ServiceDescriptorProto): Code;
-export declare function generateNestjsGrpcServiceMethodsDecorator(ctx: Context, serviceDesc: ServiceDescriptorProto): Code;
+export declare function generateNestjsGrpcServiceMethodsDecorator(ctx: Context, fileDesc: FileDescriptorProto, serviceDesc: ServiceDescriptorProto): Code;

package/build/src/generate-nestjs.js

@@ -118,10 +118,13 @@ function generateNestjsServiceClient(ctx, fileDesc, sourceInfo, serviceDesc) {
     chunks.push((0, ts_poet_1.code) `}`);
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n\n" });
 }
-function generateNestjsGrpcServiceMethodsDecorator(ctx, serviceDesc) {
+function generateNestjsGrpcServiceMethodsDecorator(ctx, fileDesc, serviceDesc) {
     const { options } = ctx;
     const GrpcMethod = (0, ts_poet_1.imp)("GrpcMethod@@nestjs/microservices");
     const GrpcStreamMethod = (0, ts_poet_1.imp)("GrpcStreamMethod@@nestjs/microservices");
+    const serviceName = options.useNestjsFqnServiceName
+        ? (0, utils_1.maybePrefixPackage)(fileDesc, serviceDesc.name)
+        : serviceDesc.name;
     const grpcMethods = serviceDesc.method
         .filter((m) => !m.clientStreaming)
         .map((m) => {
@@ -142,13 +145,13 @@ function generateNestjsGrpcServiceMethodsDecorator(ctx, serviceDesc) {
         const grpcMethods: string[] = [${grpcMethods.join(", ")}];
         for (const method of grpcMethods) {
           const descriptor: any = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
-          ${GrpcMethod}('${serviceDesc.name}', method)(constructor.prototype[method], method, descriptor);
+          ${GrpcMethod}('${serviceName}', method)(constructor.prototype[method], method, descriptor);
           Object.defineProperty(constructor.prototype, method, descriptor);
         }
         const grpcStreamMethods: string[] = [${grpcStreamMethods.join(", ")}];
         for (const method of grpcStreamMethods) {
           const descriptor: any = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
-          ${GrpcStreamMethod}('${serviceDesc.name}', method)(constructor.prototype[method], method, descriptor);
+          ${GrpcStreamMethod}('${serviceName}', method)(constructor.prototype[method], method, descriptor);
           Object.defineProperty(constructor.prototype, method, descriptor);
         }
       };

package/build/src/generate-type-registry.js

@@ -7,8 +7,10 @@ function generateTypeRegistry(ctx) {
     const chunks = [];
     chunks.push(generateMessageType(ctx));
     if ((0, options_1.addTypeToMessages)(ctx.options)) {
+        // With outputTypeAnnotations=optional, messages declare `$type?`, so the registry has to accept them.
+        const optional = ctx.options.outputTypeAnnotations === "optional" ? "?" : "";
         chunks.push((0, ts_poet_1.code) `
-    export type UnknownMessage = {$type: string};
+    export type UnknownMessage = {$type${optional}: string};
   `);
     }
     else {

package/build/src/main.d.ts

@@ -4,7 +4,7 @@ import { FileDescriptorProto } from "ts-proto-descriptors";
 import { Context } from "./context";
 import { Options } from "./options";
 export declare function generateFile(ctx: Context, fileDesc: FileDescriptorProto): [string, Code];
-export type Utils = ReturnType<typeof makeDeepPartial> & ReturnType<typeof makeObjectIdMethods> & ReturnType<typeof makeTimestampMethods> & ReturnType<typeof makeByteUtils> & ReturnType<typeof makeLongUtils> & ReturnType<typeof makeComparisonUtils> & ReturnType<typeof makeNiceGrpcServerStreamingMethodResult> & ReturnType<typeof makeGrpcWebErrorClass> & ReturnType<typeof makeExtensionClass> & ReturnType<typeof makeAssertionUtils> & ReturnType<typeof makeMessageFns>;
+export type Utils = ReturnType<typeof makeDeepPartial> & ReturnType<typeof makeObjectIdMethods> & ReturnType<typeof makeTimestampMethods> & ReturnType<typeof makeByteUtils> & ReturnType<typeof makeLongUtils> & ReturnType<typeof makeComparisonUtils> & ReturnType<typeof makeNiceGrpcServerStreamingMethodResult> & ReturnType<typeof makeGrpcWebErrorClass> & ReturnType<typeof makeExtensionClass> & ReturnType<typeof makeAssertionUtils> & ReturnType<typeof makeMessageFns> & ReturnType<typeof makeAnyJsonUtils>;
 /** These are runtime utility methods used by the generated code. */
 export declare function makeUtils(options: Options): Utils;
 declare function makeLongUtils(options: Options, bytes: ReturnType<typeof makeByteUtils>): {
@@ -43,6 +43,9 @@ declare function makeTimestampMethods(options: Options, longs: ReturnType<typeof
     timestampFractionRegex: ConditionalOutput;
     fromJsonTimestamp: ConditionalOutput;
 };
+declare function makeAnyJsonUtils(): {
+    anyJsonValueTypes: ConditionalOutput;
+};
 declare function makeComparisonUtils(): {
     isObject: ConditionalOutput;
     isSet: ConditionalOutput;

package/build/src/main.js

@@ -233,7 +233,7 @@ function generateFile(ctx, fileDesc) {
             // and the service controller interface
             chunks.push((0, generate_nestjs_1.generateNestjsServiceController)(ctx, fileDesc, sInfo, serviceDesc));
             // generate nestjs grpc service controller decorator
-            chunks.push((0, generate_nestjs_1.generateNestjsGrpcServiceMethodsDecorator)(ctx, serviceDesc));
+            chunks.push((0, generate_nestjs_1.generateNestjsGrpcServiceMethodsDecorator)(ctx, fileDesc, serviceDesc));
             let serviceConstName = `${(0, case_1.camelToSnake)(serviceDesc.name)}_NAME`;
             if (!serviceDesc.name.toLowerCase().endsWith("service")) {
                 serviceConstName = `${(0, case_1.camelToSnake)(serviceDesc.name)}_SERVICE_NAME`;
@@ -340,6 +340,7 @@ function makeUtils(options) {
         ...extension,
         ...makeAssertionUtils(bytes),
         ...makeMessageFns(options, deepPartial, extension),
+        ...makeAnyJsonUtils(),
     };
 }
 function makeProtobufTimestampWrapper() {
@@ -830,6 +831,31 @@ function makeTimestampMethods(options, longs, bytes) {
       `);
     return { toTimestamp, fromTimestamp, timestampFractionRegex, fromJsonTimestamp };
 }
+function makeAnyJsonUtils() {
+    // Well-known types whose JSON is not an object of their fields. Packed in an Any, that
+    // JSON goes under "value" rather than next to "@type".
+    const anyJsonValueTypes = (0, ts_poet_1.conditionalOutput)("anyJsonValueTypes", (0, ts_poet_1.code) `
+      const anyJsonValueTypes: readonly string[] = [
+        "google.protobuf.Any",
+        "google.protobuf.BoolValue",
+        "google.protobuf.BytesValue",
+        "google.protobuf.DoubleValue",
+        "google.protobuf.Duration",
+        "google.protobuf.FieldMask",
+        "google.protobuf.FloatValue",
+        "google.protobuf.Int32Value",
+        "google.protobuf.Int64Value",
+        "google.protobuf.ListValue",
+        "google.protobuf.StringValue",
+        "google.protobuf.Struct",
+        "google.protobuf.Timestamp",
+        "google.protobuf.UInt32Value",
+        "google.protobuf.UInt64Value",
+        "google.protobuf.Value",
+      ];
+    `);
+    return { anyJsonValueTypes };
+}
 function makeComparisonUtils() {
     const isObject = (0, ts_poet_1.conditionalOutput)("isObject", (0, ts_poet_1.code) `
     function isObject(value: any): boolean {
@@ -1462,7 +1488,12 @@ function generateEncode(ctx, fullName, messageDesc) {
           `);
                 }
                 else {
-                    chunks.push(listWriteSnippet);
+                    // A packed field with no elements must not be written, not even its tag and length.
+                    chunks.push((0, ts_poet_1.code) `
+            if (${messageProperty}.length !== 0) {
+              ${listWriteSnippet}
+            }
+          `);
                 }
             }
             else {
@@ -1518,7 +1549,12 @@ function generateEncode(ctx, fullName, messageDesc) {
           `);
                 }
                 else {
-                    chunks.push(listWriteSnippet);
+                    // A packed field with no elements must not be written, not even its tag and length.
+                    chunks.push((0, ts_poet_1.code) `
+            if (${messageProperty}.length !== 0) {
+              ${listWriteSnippet}
+            }
+          `);
                 }
             }
         }
@@ -1829,6 +1865,9 @@ function generateExtension(ctx, message, extension) {
 function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
     const { options, utils, currentFile } = ctx;
     const chunks = [];
+    if (fullTypeName === "google.protobuf.Any" && useCanonicalAnyJson(options)) {
+        return generateCanonicalAnyFromJson(ctx, fullName, messageDesc);
+    }
     // Handle Duration string format as a special case
     if (fullTypeName === "google.protobuf.Duration" && ctx.options.useDuration === options_1.DurationOption.STRING) {
         let parseSeconds;
@@ -2232,9 +2271,83 @@ function generateCanonicalToJson(fullName, fullProtobufTypeName, { useOptionals,
     }
     return undefined;
 }
+/** Whether `google.protobuf.Any` gets its canonical `@type` JSON form, see the `anyType` option. */
+function useCanonicalAnyJson(options) {
+    // Converting the packed message needs the type registry and its encode/decode methods. Without
+    // them, Any keeps the `{ typeUrl, value }` form even though `@type` is the default.
+    return (options.anyType === options_1.AnyTypeOption.AT_TYPE && options.outputTypeRegistry && options.outputEncodeMethods === true);
+}
+/** The `type_url` and `value` fields of `google.protobuf.Any`. */
+function anyFields(messageDesc) {
+    const typeUrl = messageDesc.field.find((field) => field.number === 1);
+    const value = messageDesc.field.find((field) => field.number === 2);
+    return [typeUrl, value];
+}
+/**
+ * The canonical JSON of an `Any` is the JSON of the packed message with an added
+ * `"@type"`, or `{"@type", "value"}` for well-known types with their own JSON form.
+ */
+function generateCanonicalAnyToJson(ctx, fullName, messageDesc) {
+    const { options, utils } = ctx;
+    const messageTypeRegistry = (0, utils_1.impFile)(options, "messageTypeRegistry@./typeRegistry");
+    const [typeUrlField, valueField] = anyFields(messageDesc);
+    const typeUrl = (0, utils_1.getPropertyAccessor)("message", (0, utils_1.getFieldName)(typeUrlField, options));
+    const value = (0, utils_1.getPropertyAccessor)("message", (0, utils_1.getFieldName)(valueField, options));
+    return (0, ts_poet_1.code) `
+    toJSON(message: ${fullName}): unknown {
+      const typeUrl = ${typeUrl} ?? "";
+      if (typeUrl === "") {
+        return {};
+      }
+      const typeName = typeUrl.slice(typeUrl.lastIndexOf("/") + 1);
+      const type = ${messageTypeRegistry}.get(typeName);
+      if (type === undefined) {
+        throw new ${utils.globalThis}.Error(\`Cannot convert google.protobuf.Any to JSON: unknown type \${typeName}\`);
+      }
+      const json = type.toJSON(type.decode(${value} ?? new Uint8Array(0)));
+      return ${utils.anyJsonValueTypes}.includes(typeName)
+        ? { "@type": typeUrl, value: json }
+        : { "@type": typeUrl, ...(json as object) };
+    }
+  `;
+}
+/** The inverse of {@link generateCanonicalAnyToJson}. */
+function generateCanonicalAnyFromJson(ctx, fullName, messageDesc) {
+    const { options, utils } = ctx;
+    const messageTypeRegistry = (0, utils_1.impFile)(options, "messageTypeRegistry@./typeRegistry");
+    const [typeUrlField, valueField] = anyFields(messageDesc);
+    const typeUrlKey = (0, utils_1.safeAccessor)((0, utils_1.getFieldName)(typeUrlField, options));
+    const valueKey = (0, utils_1.safeAccessor)((0, utils_1.getFieldName)(valueField, options));
+    const typeField = (0, options_1.addTypeToMessages)(options) ? (0, ts_poet_1.code) `$type: ${fullName}.$type,` : "";
+    const bytes = options.env === options_1.EnvOption.NODE ? (0, ts_poet_1.code) `Buffer.from(bytes)` : (0, ts_poet_1.code) `bytes`;
+    return (0, ts_poet_1.code) `
+    fromJSON(object: any): ${fullName} {
+      const typeUrl = ${utils.isSet}(object?.["@type"]) ? ${utils.globalThis}.String(object["@type"]) : "";
+      if (typeUrl === "") {
+        return { ${typeField} ${typeUrlKey}: ${(0, types_1.defaultValue)(ctx, typeUrlField)}, ${valueKey}: ${(0, types_1.defaultValue)(ctx, valueField)} };
+      }
+      const typeName = typeUrl.slice(typeUrl.lastIndexOf("/") + 1);
+      const type = ${messageTypeRegistry}.get(typeName);
+      if (type === undefined) {
+        throw new ${utils.globalThis}.Error(\`Cannot convert JSON to google.protobuf.Any: unknown type \${typeName}\`);
+      }
+      let json = object.value;
+      if (!${utils.anyJsonValueTypes}.includes(typeName)) {
+        json = { ...object };
+        delete json["@type"];
+      }
+      const bytes = type.encode(type.fromJSON(json)).finish();
+      return { ${typeField} ${typeUrlKey}: typeUrl, ${valueKey}: ${bytes} };
+    }
+  `;
+}
 function generateToJson(ctx, fullName, fullProtobufTypeName, messageDesc) {
     const { options, utils, typeMap } = ctx;
     const chunks = [];
+    if (fullProtobufTypeName === "google.protobuf.Any" && useCanonicalAnyJson(options)) {
+        chunks.push(generateCanonicalAnyToJson(ctx, fullName, messageDesc));
+        return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
+    }
     const canonicalToJson = generateCanonicalToJson(fullName, fullProtobufTypeName, options);
     if (canonicalToJson) {
         chunks.push(canonicalToJson);
@@ -2623,6 +2736,11 @@ function generateFromPartial(ctx, fullName, messageDesc) {
       `);
             currentSwitchTarget = oneofNameWithObject;
         }
+        else if ((0, types_1.isAnyValueType)(field)) {
+            // null is a valid google.protobuf.Value (NullValue), so only an absent value gets the fallback.
+            const fallback = (0, types_1.isWithinOneOf)(field) || noDefaultValue ? "undefined" : (0, types_1.defaultValue)(ctx, field);
+            chunks.push((0, ts_poet_1.code) `${messageProperty} = ${objectProperty} === undefined ? ${fallback} : ${objectProperty};`);
+        }
         else if (readSnippet(`x`).toCodeString([]) == "x") {
             // An optimized case of the else below that works when `readSnippet` returns the plain input
             const fallback = (0, types_1.isWithinOneOf)(field) || noDefaultValue ? "undefined" : (0, types_1.defaultValue)(ctx, field);

package/build/src/options.d.ts

@@ -20,6 +20,11 @@ export declare enum DurationOption {
     DURATION = "duration",
     STRING = "string"
 }
+export declare enum AnyTypeOption {
+    /** @deprecated Kept for existing users of the `{ typeUrl, value }` JSON form; may be removed in the future. */
+    TYPE_URL = "typeUrl",
+    AT_TYPE = "@type"
+}
 export declare enum EnvOption {
     NODE = "node",
     BROWSER = "browser",
@@ -75,6 +80,7 @@ export type Options = {
     addGrpcMetadata: boolean;
     metadataType: string | undefined;
     addNestjsRestParameter: boolean;
+    useNestjsFqnServiceName: boolean;
     returnObservable: boolean;
     lowerCaseServiceMethods: boolean;
     nestJs: boolean;
@@ -116,6 +122,7 @@ export type Options = {
     typePrefix: string;
     typeSuffix: string;
     useDuration: DurationOption;
+    anyType: AnyTypeOption;
 };
 export declare function defaultOptions(): Options;
 export declare function optionsFromParameter(parameter: string | undefined): Options;

package/build/src/options.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OutputSchemaOption = exports.ServiceOption = exports.OneofOption = exports.EnvOption = exports.DurationOption = exports.JsonTimestampOption = exports.DateOption = exports.LongOption = void 0;
+exports.OutputSchemaOption = exports.ServiceOption = exports.OneofOption = exports.EnvOption = exports.AnyTypeOption = exports.DurationOption = exports.JsonTimestampOption = exports.DateOption = exports.LongOption = void 0;
 exports.defaultOptions = defaultOptions;
 exports.optionsFromParameter = optionsFromParameter;
 exports.getTsPoetOpts = getTsPoetOpts;
@@ -30,6 +30,12 @@ var DurationOption;
     DurationOption["DURATION"] = "duration";
     DurationOption["STRING"] = "string";
 })(DurationOption || (exports.DurationOption = DurationOption = {}));
+var AnyTypeOption;
+(function (AnyTypeOption) {
+    /** @deprecated Kept for existing users of the `{ typeUrl, value }` JSON form; may be removed in the future. */
+    AnyTypeOption["TYPE_URL"] = "typeUrl";
+    AnyTypeOption["AT_TYPE"] = "@type";
+})(AnyTypeOption || (exports.AnyTypeOption = AnyTypeOption = {}));
 var EnvOption;
 (function (EnvOption) {
     EnvOption["NODE"] = "node";
@@ -92,6 +98,7 @@ function defaultOptions() {
         addGrpcMetadata: false,
         metadataType: undefined,
         addNestjsRestParameter: false,
+        useNestjsFqnServiceName: false,
         nestJs: false,
         env: EnvOption.BOTH,
         unrecognizedEnum: true,
@@ -129,6 +136,7 @@ function defaultOptions() {
         typePrefix: "",
         typeSuffix: "",
         useDuration: DurationOption.DURATION,
+        anyType: AnyTypeOption.AT_TYPE,
     };
 }
 const nestJsOptions = {
@@ -231,6 +239,10 @@ function optionsFromParameter(parameter) {
     if (options.nestJs) {
         options.initializeFieldsAsUndefined = false;
     }
+    else {
+        // useNestjsFqnServiceName requires nestJs=true
+        options.useNestjsFqnServiceName = false;
+    }
     if (options.outputIndex) {
         options.exportCommonSymbols = false;
     }

package/build/src/schema.js

@@ -23,11 +23,17 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
     const outputFileDescriptor = !outputSchemaOptions.includes(options_1.OutputSchemaOption.NO_FILE_DESCRIPTOR);
     const outputAsConst = outputSchemaOptions.includes(options_1.OutputSchemaOption.CONST);
     chunks.push((0, ts_poet_1.code) `
+    type ProtoMetaEnumOptions = {
+      options?: { [key: string]: any };
+      values?: { [key: string]: { [key: string]: any } };
+    };
+
     type ProtoMetaMessageOptions = {
       options?: { [key: string]: any };
       fields?: { [key: string]: { [key: string]: any } };
       oneof?: { [key: string]: { [key: string]: any } };
       nested?: { [key: string]: ProtoMetaMessageOptions };
+      enums?: { [key: string]: ProtoMetaEnumOptions };
     };
 
     export interface ProtoMetadata {
@@ -45,10 +51,7 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
           [key: string]: ProtoMetaMessageOptions;
         };
         enums?: {
-          [key: string]: {
-            options?: { [key: string]: any };
-            values?: { [key: string]: { [key: string]: any } };
-          };
+          [key: string]: ProtoMetaEnumOptions;
         };
       };
     }
@@ -119,28 +122,9 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
     });
     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((0, 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((0, ts_poet_1.code) `
-        '${Enum.name}': {
-          ${enumOptions ? (0, ts_poet_1.code) `options: ${enumOptions},` : ""}
-          values: {${(0, ts_poet_1.joinCode)(valuesOptions, { on: "," })}}
-        }
-      `);
+        const resolvedEnum = resolveEnumOptions(ctx, Enum);
+        if (resolvedEnum) {
+            enumsOptions.push(resolvedEnum);
         }
     });
     chunks.push((0, ts_poet_1.code) `
@@ -247,18 +231,55 @@ function resolveMessageOptions(ctx, message) {
             }
         });
     }
+    const enumsOptions = [];
+    (message.enumType || []).forEach((Enum) => {
+        const resolvedEnum = resolveEnumOptions(ctx, Enum);
+        if (resolvedEnum) {
+            enumsOptions.push(resolvedEnum);
+        }
+    });
     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) {
+    if (fieldsOptions.length > 0 ||
+        oneOfsOptions.length > 0 ||
+        nestedOptions.length > 0 ||
+        enumsOptions.length > 0 ||
+        messageOptions) {
         return (0, ts_poet_1.code) `
       '${message.name}': {
         ${messageOptions ? (0, ts_poet_1.code) `options: ${messageOptions},` : ""}
         ${fieldsOptions.length > 0 ? (0, ts_poet_1.code) `fields: {${(0, ts_poet_1.joinCode)(fieldsOptions, { on: "," })}},` : ""}
         ${oneOfsOptions.length > 0 ? (0, ts_poet_1.code) `oneof: {${(0, ts_poet_1.joinCode)(oneOfsOptions, { on: "," })}},` : ""}
         ${nestedOptions.length > 0 ? (0, ts_poet_1.code) `nested: {${(0, ts_poet_1.joinCode)(nestedOptions, { on: "," })}},` : ""}
+        ${enumsOptions.length > 0 ? (0, ts_poet_1.code) `enums: {${(0, ts_poet_1.joinCode)(enumsOptions, { on: "," })}},` : ""}
+      }
+    `;
+    }
+}
+function resolveEnumOptions(ctx, 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((0, 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) {
+        return (0, ts_poet_1.code) `
+      '${Enum.name}': {
+        ${enumOptions ? (0, ts_poet_1.code) `options: ${enumOptions},` : ""}
+        values: {${(0, ts_poet_1.joinCode)(valuesOptions, { on: "," })}}
       }
     `;
     }

package/package.json

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