ts-proto 2.13.3 → 2.14.0

package/README.markdown

@@ -662,6 +662,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-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

@@ -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",
@@ -116,6 +121,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";
@@ -129,6 +135,7 @@ function defaultOptions() {
         typePrefix: "",
         typeSuffix: "",
         useDuration: DurationOption.DURATION,
+        anyType: AnyTypeOption.AT_TYPE,
     };
 }
 const nestJsOptions = {

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.14.0",
   "description": "",
   "main": "build/src/plugin.js",
   "repository": "github:stephenh/ts-proto",