ts-proto 1.167.9 → 1.169.0

package/README.markdown

@@ -432,7 +432,7 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=outputSchema=true`, meta typings will be generated that can later be used in other code generators.
 
-- With `--ts_proto_opt=outputTypeAnnotations=true`, each message will be given a `$type` field containing its fully-qualified name. You can use `--ts_proto_opt=outputTypeAnnotations=static-only` to omit it from the `interface` declaration.
+- With `--ts_proto_opt=outputTypeAnnotations=true`, each message will be given a `$type` field containing its fully-qualified name. You can use `--ts_proto_opt=outputTypeAnnotations=static-only` to omit it from the `interface` declaration, or `--ts_proto_opt=outputTypeAnnotations=optional` to make it an optional property on the `interface` definition. The latter option may be useful if you want to use the `$type` field for runtime type checking on responses from a server.
 
 - With `--ts_proto_opt=outputTypeRegistry=true`, the type registry will be generated that can be used to resolve message types by fully-qualified name. Also, each message will be given a `$type` field containing its fully-qualified name.
 
@@ -496,6 +496,10 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=initializeFieldsAsUndefined=false`, all optional field initializers will be omited from the generated base instances.
 
+- With `--ts_proto_opt=disableProto2Optionals=true`, all optional fields on proto2 files will not be set to be optional. Please note that this flag is primarily for preserving ts-proto's legacy handling of proto2 files, to avoid breaking changes, and as a result, it is not intended to be used moving forward.
+
+- With `--ts_proto_opt=disableProto2DefaultValues=true`, all fields in proto2 files that specify a default value will not actually use that default value. Please note that this flag is primarily for preserving ts-proto's legacy handling of proto2 files, to avoid breaking changes, and as a result, it is not intended to be used moving forward.
+
 - With `--ts_proto_opt=Mgoogle/protobuf/empty.proto=./google3/protobuf/empty`, ('M' means 'importMapping', similar to [protoc-gen-go](https://developers.google.com/protocol-buffers/docs/reference/go-generated#package)), the generated code import path for `./google/protobuf/empty.ts` will reflect the overridden value:
 
   - `Mfoo/bar.proto=@myorg/some-lib` will map `foo/bar.proto` imports into `import ... from '@myorg/some-lib'`.

package/build/context.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileContext = void 0;
+function createFileContext(file) {
+    return { isProto3Syntax: file.syntax === "proto3" };
+}
+exports.createFileContext = createFileContext;

package/build/main.js

@@ -672,13 +672,13 @@ function makeAssertionUtils(bytes) {
 // Create the interface with properties
 function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fullTypeName) {
     var _a;
-    const { options } = ctx;
+    const { options, currentFile } = ctx;
     const chunks = [];
     (0, utils_1.maybeAddComment)(options, sourceInfo, chunks, (_a = messageDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated);
     // interface name should be defined to avoid import collisions
     chunks.push((0, ts_poet_1.code) `export interface ${(0, ts_poet_1.def)(fullName)} {`);
     if ((0, options_1.addTypeToMessages)(options)) {
-        chunks.push((0, ts_poet_1.code) `$type: '${fullTypeName}',`);
+        chunks.push((0, ts_poet_1.code) `$type${options.outputTypeAnnotations === "optional" ? "?" : ""}: '${fullTypeName}',`);
     }
     // When oneof=unions, we generate a single property with an ADT per `oneof` clause.
     const processedOneofs = new Set();
@@ -695,7 +695,7 @@ function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fu
         const info = sourceInfo.lookup(sourceInfo_1.Fields.message.field, index);
         (0, utils_1.maybeAddComment)(options, info, chunks, (_a = fieldDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated);
         const fieldKey = (0, utils_1.safeAccessor)((0, utils_1.getFieldName)(fieldDesc, options));
-        const isOptional = (0, types_1.isOptionalProperty)(fieldDesc, messageDesc.options, options);
+        const isOptional = (0, types_1.isOptionalProperty)(fieldDesc, messageDesc.options, options, currentFile.isProto3Syntax);
         const type = (0, types_1.toTypeName)(ctx, messageDesc, fieldDesc, isOptional);
         chunks.push((0, ts_poet_1.code) `${maybeReadonly(options)}${fieldKey}${isOptional ? "?" : ""}: ${type}, `);
     });
@@ -739,7 +739,7 @@ function generateOneofProperty(ctx, messageDesc, oneofIndex, sourceInfo) {
 }
 // Create a function that constructs 'base' instance with default values for decode to use as a prototype
 function generateBaseInstanceFactory(ctx, fullName, messageDesc, fullTypeName) {
-    const { options } = ctx;
+    const { options, currentFile } = ctx;
     const fields = [];
     // When oneof=unions, we generate a single property with an ADT per `oneof` clause.
     const processedOneofs = new Set();
@@ -755,7 +755,8 @@ function generateBaseInstanceFactory(ctx, fullName, messageDesc, fullTypeName) {
             }
             continue;
         }
-        if (!options.initializeFieldsAsUndefined && (0, types_1.isOptionalProperty)(field, messageDesc.options, options)) {
+        if (!options.initializeFieldsAsUndefined &&
+            (0, types_1.isOptionalProperty)(field, messageDesc.options, options, currentFile.isProto3Syntax)) {
             continue;
         }
         const fieldKey = (0, utils_1.safeAccessor)((0, utils_1.getFieldName)(field, options));
@@ -854,7 +855,7 @@ function getDecodeReadSnippet(ctx, field) {
 }
 /** Creates a function to decode a message by loop overing the tags. */
 function generateDecode(ctx, fullName, messageDesc) {
-    const { options, utils, typeMap } = ctx;
+    const { options, currentFile } = ctx;
     const chunks = [];
     let createBase = (0, ts_poet_1.code) `createBase${fullName}()`;
     if (options.usePrototypeForDefaults) {
@@ -891,7 +892,8 @@ function generateDecode(ctx, fullName, messageDesc) {
         // get a generic 'reader.doSomething' bit that is specific to the basic type
         const readSnippet = getDecodeReadSnippet(ctx, field);
         // and then use the snippet to handle repeated fields if necessary
-        const initializerNecessary = !options.initializeFieldsAsUndefined && (0, types_1.isOptionalProperty)(field, messageDesc.options, options);
+        const initializerNecessary = !options.initializeFieldsAsUndefined &&
+            (0, types_1.isOptionalProperty)(field, messageDesc.options, options, currentFile.isProto3Syntax);
         if ((0, types_1.isRepeated)(field)) {
             const maybeNonNullAssertion = ctx.options.useOptionals === "all" ? "!" : "";
             const mapType = (0, types_1.detectMapType)(ctx, messageDesc, field);
@@ -1094,7 +1096,7 @@ function getEncodeWriteSnippet(ctx, field) {
 }
 /** Creates a function to encode a message by loop overing the tags. */
 function generateEncode(ctx, fullName, messageDesc) {
-    const { options, utils, typeMap } = ctx;
+    const { options, utils, typeMap, currentFile } = ctx;
     const chunks = [];
     const Writer = (0, utils_1.impFile)(ctx.options, "Writer@protobufjs/minimal");
     // create the basic function declaration
@@ -1114,7 +1116,7 @@ function generateEncode(ctx, fullName, messageDesc) {
         const messageProperty = (0, utils_1.getPropertyAccessor)("message", fieldName);
         // get a generic writer.doSomething based on the basic type
         const writeSnippet = getEncodeWriteSnippet(ctx, field);
-        const isOptional = (0, types_1.isOptionalProperty)(field, messageDesc.options, options);
+        const isOptional = (0, types_1.isOptionalProperty)(field, messageDesc.options, options, currentFile.isProto3Syntax);
         if ((0, types_1.isRepeated)(field)) {
             if ((0, types_1.isMapType)(ctx, messageDesc, field)) {
                 const valueType = typeMap.get(field.typeName)[2].field[1];
@@ -1534,7 +1536,7 @@ function generateExtension(ctx, message, extension) {
  * a few special cases for https://developers.google.com/protocol-buffers/docs/proto3#json.
  * */
 function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
-    const { options, utils, typeMap } = ctx;
+    const { options, utils, currentFile } = ctx;
     const chunks = [];
     // create the basic function declaration
     chunks.push((0, ts_poet_1.code) `
@@ -1684,7 +1686,8 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                 throw new Error(`Unhandled field ${field}`);
             }
         };
-        const noDefaultValue = !options.initializeFieldsAsUndefined && (0, types_1.isOptionalProperty)(field, messageDesc.options, options);
+        const noDefaultValue = !options.initializeFieldsAsUndefined &&
+            (0, types_1.isOptionalProperty)(field, messageDesc.options, options, currentFile.isProto3Syntax);
         // and then use the snippet to handle repeated fields if necessary
         if ((_a = canonicalFromJson[fullTypeName]) === null || _a === void 0 ? void 0 : _a[fieldName]) {
             chunks.push((0, ts_poet_1.code) `${fieldName}: ${canonicalFromJson[fullTypeName][fieldName]("object")},`);
@@ -2071,7 +2074,7 @@ function generateFromPartial(ctx, fullName, messageDesc) {
                 throw new Error(`Unhandled field ${field}`);
             }
         };
-        const noDefaultValue = !options.initializeFieldsAsUndefined && (0, types_1.isOptionalProperty)(field, messageDesc.options, options);
+        const noDefaultValue = !options.initializeFieldsAsUndefined && (0, types_1.isOptionalProperty)(field, messageDesc.options, options, true);
         // and then use the snippet to handle repeated fields if necessary
         if ((0, types_1.isRepeated)(field)) {
             if ((0, types_1.isMapType)(ctx, messageDesc, field)) {

package/build/options.js

@@ -98,6 +98,8 @@ function defaultOptions() {
         rpcAfterResponse: false,
         rpcErrorHandler: false,
         comments: true,
+        disableProto2Optionals: false,
+        disableProto2DefaultValues: false,
     };
 }
 exports.defaultOptions = defaultOptions;

package/build/plugin.js

@@ -5,6 +5,7 @@ const util_1 = require("util");
 const utils_1 = require("./utils");
 const main_1 = require("./main");
 const types_1 = require("./types");
+const context_1 = require("./context");
 const options_1 = require("./options");
 const generate_type_registry_1 = require("./generate-type-registry");
 // this would be the plugin called by the protoc compiler
@@ -40,7 +41,7 @@ async function main() {
         filesToGenerate = (0, utils_1.protoFilesToGenerate)(request).filter((file) => !options.M[file.name]);
     }
     const files = await Promise.all(filesToGenerate.map(async (file) => {
-        const [path, code] = (0, main_1.generateFile)(ctx, file);
+        const [path, code] = (0, main_1.generateFile)({ ...ctx, currentFile: (0, context_1.createFileContext)(file) }, file);
         const content = code.toString({ ...(0, options_1.getTsPoetOpts)(options), path });
         return { name: path, content };
     }));

package/build/types.js

@@ -165,7 +165,9 @@ function packedType(type) {
 }
 exports.packedType = packedType;
 function defaultValue(ctx, field) {
-    const { typeMap, options, utils } = ctx;
+    const { typeMap, options, utils, currentFile } = ctx;
+    const useDefaultValue = !currentFile.isProto3Syntax && !options.disableProto2DefaultValues && field.defaultValue;
+    const numbericDefaultVal = useDefaultValue ? field.defaultValue : 0;
     switch (field.type) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_DOUBLE:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FLOAT:
@@ -174,7 +176,7 @@ function defaultValue(ctx, field) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT32:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED32:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED32:
-            return 0;
+            return numbericDefaultVal;
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_ENUM:
             // proto3 enforces enums starting at 0, however proto2 does not, so we have
             // to probe and see if zero is an allowed value. If it's not, pick the first one.
@@ -182,54 +184,54 @@ function defaultValue(ctx, field) {
             // and I believe the semantics of those in the proto2 world are generally undefined.
             const typeInfo = typeMap.get(field.typeName);
             const enumProto = typeInfo[2];
-            const zerothValue = enumProto.value.find((v) => v.number === 0) || enumProto.value[0];
+            const defaultEnum = enumProto.value.find((v) => (useDefaultValue ? v.name === field.defaultValue : v.number === 0)) ||
+                enumProto.value[0];
             if (options.stringEnums) {
                 const enumType = messageToTypeName(ctx, field.typeName);
-                return (0, ts_poet_1.code) `${enumType}.${(0, enums_1.getMemberName)(ctx, enumProto, zerothValue)}`;
+                return (0, ts_poet_1.code) `${enumType}.${(0, enums_1.getMemberName)(ctx, enumProto, defaultEnum)}`;
             }
             else {
-                return zerothValue.number;
+                return defaultEnum.number;
             }
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED64:
             if (options.forceLong === options_1.LongOption.LONG) {
-                return (0, ts_poet_1.code) `${utils.Long}.UZERO`;
+                return (0, ts_poet_1.code) `${utils.Long}.${useDefaultValue ? "fromNumber" : "UZERO"}${useDefaultValue ? `(${numbericDefaultVal})` : ""}`;
             }
             else if (options.forceLong === options_1.LongOption.STRING) {
-                return '"0"';
+                return `"${numbericDefaultVal}"`;
             }
             else if (options.forceLong === options_1.LongOption.BIGINT) {
-                return 'BigInt("0")';
+                return `BigInt("${numbericDefaultVal}")`;
             }
             else {
-                return 0;
+                return numbericDefaultVal;
             }
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED64:
             if (options.forceLong === options_1.LongOption.LONG) {
-                return (0, ts_poet_1.code) `${utils.Long}.ZERO`;
+                return (0, ts_poet_1.code) `${utils.Long}.${useDefaultValue ? "fromNumber" : "ZERO"}${useDefaultValue ? `(${numbericDefaultVal})` : ""}`;
             }
             else if (options.forceLong === options_1.LongOption.STRING) {
-                return '"0"';
+                return `"${numbericDefaultVal}"`;
             }
             else if (options.forceLong === options_1.LongOption.BIGINT) {
-                return 'BigInt("0")';
+                return `BigInt("${numbericDefaultVal}")`;
             }
             else {
-                return 0;
+                return numbericDefaultVal;
             }
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BOOL:
-            return false;
+            return useDefaultValue ? field.defaultValue : false;
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_STRING:
-            return '""';
+            return useDefaultValue ? `"${field.defaultValue}"` : '""';
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BYTES:
+            // todo(proto2): need to look into all the possible default values for the bytes type, and handle each one
             if (options.env === options_1.EnvOption.NODE) {
                 return "Buffer.alloc(0)";
             }
-            else {
-                return "new Uint8Array(0)";
-            }
+            return "new Uint8Array(0)";
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP:
         default:
@@ -239,8 +241,8 @@ function defaultValue(ctx, field) {
 exports.defaultValue = defaultValue;
 /** Creates code that checks that the field is not the default value. Supports scalars and enums. */
 function notDefaultCheck(ctx, field, messageOptions, place) {
-    const { typeMap, options } = ctx;
-    const isOptional = isOptionalProperty(field, messageOptions, options);
+    const { typeMap, options, currentFile } = ctx;
+    const isOptional = isOptionalProperty(field, messageOptions, options, currentFile.isProto3Syntax);
     const maybeNotUndefinedAnd = isOptional ? `${place} !== undefined && ` : "";
     switch (field.type) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_DOUBLE:
@@ -250,7 +252,9 @@ function notDefaultCheck(ctx, field, messageOptions, place) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT32:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED32:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED32:
-            return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== 0`;
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BOOL:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_STRING:
+            return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== ${defaultValue(ctx, field)}`;
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_ENUM:
             // proto3 enforces enums starting at 0, however proto2 does not, so we have
             // to probe and see if zero is an allowed value. If it's not, pick the first one.
@@ -258,14 +262,14 @@ function notDefaultCheck(ctx, field, messageOptions, place) {
             // and I believe the semantics of those in the proto2 world are generally undefined.
             const typeInfo = typeMap.get(field.typeName);
             const enumProto = typeInfo[2];
-            const zerothValue = enumProto.value.find((v) => v.number === 0) || enumProto.value[0];
+            const defaultEnum = enumProto.value.find((v) => v.number === defaultValue(ctx, field)) || enumProto.value[0];
             if (options.stringEnums) {
                 const enumType = messageToTypeName(ctx, field.typeName);
-                const enumValue = (0, enums_1.getMemberName)(ctx, enumProto, zerothValue);
+                const enumValue = (0, enums_1.getMemberName)(ctx, enumProto, defaultEnum);
                 return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== ${enumType}.${enumValue}`;
             }
             else {
-                return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== ${zerothValue.number}`;
+                return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== ${defaultEnum.number}`;
             }
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED64:
@@ -273,22 +277,13 @@ function notDefaultCheck(ctx, field, messageOptions, place) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED64:
             if (options.forceLong === options_1.LongOption.LONG) {
-                return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} !${place}.isZero()`;
-            }
-            else if (options.forceLong === options_1.LongOption.STRING) {
-                return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== "0"`;
-            }
-            else if (options.forceLong === options_1.LongOption.BIGINT) {
-                return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== BigInt("0")`;
+                return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} !${place}.equals(${defaultValue(ctx, field)})`;
             }
             else {
-                return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== 0`;
+                return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== ${defaultValue(ctx, field)}`;
             }
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BOOL:
-            return (0, ts_poet_1.code) `${place} === true`;
-        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_STRING:
-            return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place} !== ""`;
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BYTES:
+            // todo(proto2): need to look into all the possible default values for the bytes type, and handle each one
             return (0, ts_poet_1.code) `${maybeNotUndefinedAnd} ${place}.length !== 0`;
         default:
             throw new Error("Not implemented for the given type.");
@@ -339,11 +334,16 @@ exports.isScalar = isScalar;
 // optional properties, with the exception of map Entry key/values, which must
 // always be present.
 // OneOf fields are always optional, whenever oneof=unions option not in use.
-function isOptionalProperty(field, messageOptions, options) {
+function isOptionalProperty(field, messageOptions, options, isProto3Syntax) {
     const optionalMessages = options.useOptionals === true || options.useOptionals === "messages" || options.useOptionals === "all";
     const optionalAll = options.useOptionals === "all";
     return ((optionalMessages && isMessage(field) && !isRepeated(field)) ||
         (optionalAll && !(messageOptions === null || messageOptions === void 0 ? void 0 : messageOptions.mapEntry)) ||
+        // file is proto2, we have enabled proto2 optionals, and the field itself is optional
+        (!isProto3Syntax &&
+            field.label === ts_proto_descriptors_1.FieldDescriptorProto_Label.LABEL_OPTIONAL &&
+            !(messageOptions === null || messageOptions === void 0 ? void 0 : messageOptions.mapEntry) &&
+            !options.disableProto2Optionals) ||
         // don't bother verifying that oneof is not union. union oneofs generate their own properties.
         isWithinOneOf(field) ||
         field.proto3Optional);

package/package.json

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