ts-proto 1.93.3 → 1.96.0

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+# [1.96.0](https://github.com/stephenh/ts-proto/compare/v1.95.1...v1.96.0) (2021-12-24)
+
+
+### Features
+
+* `enumsAsLiterals` option ([#450](https://github.com/stephenh/ts-proto/issues/450)) ([fcaade2](https://github.com/stephenh/ts-proto/commit/fcaade2855ae28ea3553a365556ccb92a9644d70))
+
+## [1.95.1](https://github.com/stephenh/ts-proto/compare/v1.95.0...v1.95.1) (2021-12-23)
+
+
+### Bug Fixes
+
+* Add service to the client constructor. ([#455](https://github.com/stephenh/ts-proto/issues/455)) ([8c32104](https://github.com/stephenh/ts-proto/commit/8c32104a8522cfe2febcf2338d51710021d837ff))
+
+# [1.95.0](https://github.com/stephenh/ts-proto/compare/v1.94.0...v1.95.0) (2021-12-14)
+
+
+### Features
+
+* Add useOptionals=all to enable non-field members to be optional. ([#402](https://github.com/stephenh/ts-proto/issues/402)) ([e7b70cb](https://github.com/stephenh/ts-proto/commit/e7b70cbd7b9bd43bf9e6e54e25bc48c527718317))
+
+# [1.94.0](https://github.com/stephenh/ts-proto/compare/v1.93.3...v1.94.0) (2021-12-14)
+
+
+### Features
+
+* Round numbers in toJSON. ([#444](https://github.com/stephenh/ts-proto/issues/444)) ([bd2df7b](https://github.com/stephenh/ts-proto/commit/bd2df7b7176e961955ed1dcacb3602384e13ee45))
+
 ## [1.93.3](https://github.com/stephenh/ts-proto/compare/v1.93.2...v1.93.3) (2021-12-13)
 
 

package/README.markdown

@@ -159,7 +159,7 @@ creating a class and calling the right getters/setters.
 
   (Configurable with the `useDate` parameter.)
 
-- `fromJSON`/`toJSON` support the [canonical Protobuf JS](https://developers.google.com/protocol-buffers/docs/proto3#json) format (i.e. timestamps are ISO strings)
+- `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). 
 
 # Auto-Batching / N+1 Prevention
 
@@ -348,6 +348,8 @@ Generated code will be placed in the Gradle build directory.
 
 - 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`.
+
 ### 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.:

package/build/case.js

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.camelCase = exports.capitalize = exports.camelToSnake = exports.stringToSnakeCase = exports.maybeSnakeToCamel = void 0;
+exports.camelCase = exports.capitalize = exports.camelToSnake = exports.maybeSnakeToCamel = void 0;
 function maybeSnakeToCamel(s, options) {
-    const fromStringSnakeToCamel = typeof options.snakeToCamel === 'string' && options.snakeToCamel.includes('keys');
-    const fromBooleanSnakeToCamel = options.snakeToCamel === true;
-    if ((fromBooleanSnakeToCamel || fromStringSnakeToCamel) && s.includes('_')) {
+    if (options.snakeToCamel.includes('keys') && s.includes('_')) {
         return s
             .split('_')
             .map((word, i) => {
@@ -23,10 +21,6 @@ function maybeSnakeToCamel(s, options) {
     }
 }
 exports.maybeSnakeToCamel = maybeSnakeToCamel;
-function stringToSnakeCase(s) {
-    return s.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
-}
-exports.stringToSnakeCase = stringToSnakeCase;
 function camelToSnake(s) {
     return s
         .replace(/[\w]([A-Z])/g, function (m) {

package/build/enums.js

@@ -13,17 +13,30 @@ function generateEnum(ctx, fullName, enumDesc, sourceInfo) {
     const { options } = ctx;
     const chunks = [];
     utils_1.maybeAddComment(sourceInfo, chunks, (_a = enumDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated);
-    chunks.push(ts_poet_1.code `export ${options.constEnums ? 'const ' : ''}enum ${ts_poet_1.def(fullName)} {`);
+    if (options.enumsAsLiterals) {
+        chunks.push(ts_poet_1.code `export const ${ts_poet_1.def(fullName)} = {`);
+    }
+    else {
+        chunks.push(ts_poet_1.code `export ${options.constEnums ? 'const ' : ''}enum ${ts_poet_1.def(fullName)} {`);
+    }
+    const delimiter = options.enumsAsLiterals ? ':' : '=';
     enumDesc.value.forEach((valueDesc, index) => {
         var _a;
         const info = sourceInfo.lookup(sourceInfo_1.Fields.enum.value, index);
         utils_1.maybeAddComment(info, chunks, (_a = valueDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated, `${valueDesc.name} - `);
-        chunks.push(ts_poet_1.code `${valueDesc.name} = ${options.stringEnums ? `"${valueDesc.name}"` : valueDesc.number.toString()},`);
+        chunks.push(ts_poet_1.code `${valueDesc.name} ${delimiter} ${options.stringEnums ? `"${valueDesc.name}"` : valueDesc.number.toString()},`);
     });
     if (options.unrecognizedEnum)
         chunks.push(ts_poet_1.code `
-      ${UNRECOGNIZED_ENUM_NAME} = ${options.stringEnums ? `"${UNRECOGNIZED_ENUM_NAME}"` : UNRECOGNIZED_ENUM_VALUE.toString()},`);
-    chunks.push(ts_poet_1.code `}`);
+      ${UNRECOGNIZED_ENUM_NAME} ${delimiter} ${options.stringEnums ? `"${UNRECOGNIZED_ENUM_NAME}"` : UNRECOGNIZED_ENUM_VALUE.toString()},`);
+    if (options.enumsAsLiterals) {
+        chunks.push(ts_poet_1.code `} as const`);
+        chunks.push(ts_poet_1.code `\n`);
+        chunks.push(ts_poet_1.code `export type ${ts_poet_1.def(fullName)} = typeof ${ts_poet_1.def(fullName)}[keyof typeof ${ts_poet_1.def(fullName)}]`);
+    }
+    else {
+        chunks.push(ts_poet_1.code `}`);
+    }
     if (options.outputJsonMethods || (options.stringEnums && options.outputEncodeMethods)) {
         chunks.push(ts_poet_1.code `\n`);
         chunks.push(generateEnumFromJson(ctx, fullName, enumDesc));

package/build/generate-grpc-js.js

@@ -192,6 +192,7 @@ function generateClientConstructor(fileDesc, serviceDesc) {
         credentials: ${ChannelCredentials},
         options?: Partial<${ChannelOptions}>,
       ): ${serviceDesc.name}Client;
+      service: typeof ${serviceDesc.name}Service;
     }
   `;
 }

package/build/main.js

@@ -19,6 +19,14 @@ const generate_generic_service_definition_1 = require("./generate-generic-servic
 function generateFile(ctx, fileDesc) {
     var _a;
     const { options, utils } = ctx;
+    if (options.useOptionals === false) {
+        console.warn("ts-proto: Passing useOptionals as a boolean option is deprecated and will be removed in a future version. Please pass the string 'none' instead of false.");
+        options.useOptionals = 'none';
+    }
+    else if (options.useOptionals === true) {
+        console.warn("ts-proto: Passing useOptionals as a boolean option is deprecated and will be removed in a future version. Please pass the string 'messages' instead of true.");
+        options.useOptionals = 'messages';
+    }
     // Google's protofiles are organized like Java, where package == the folder the file
     // is in, and file == a specific service within the package. I.e. you can have multiple
     // company/foo.proto and company/bar.proto files, where package would be 'company'.
@@ -388,10 +396,6 @@ function makeTimestampMethods(options, longs) {
       `);
     return { toTimestamp, fromTimestamp, fromJsonTimestamp };
 }
-// When useOptionals=true, non-scalar fields are translated into optional properties.
-function isOptionalProperty(field, options) {
-    return (options.useOptionals && types_1.isMessage(field) && !types_1.isRepeated(field)) || field.proto3Optional;
-}
 // Create the interface with properties
 function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fullTypeName) {
     var _a;
@@ -419,7 +423,7 @@ function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fu
         utils_1.maybeAddComment(info, chunks, (_a = fieldDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated);
         const name = case_1.maybeSnakeToCamel(fieldDesc.name, options);
         const type = types_1.toTypeName(ctx, messageDesc, fieldDesc);
-        const q = isOptionalProperty(fieldDesc, options) ? '?' : '';
+        const q = types_1.isOptionalProperty(fieldDesc, messageDesc.options, options) ? '?' : '';
         chunks.push(ts_poet_1.code `${name}${q}: ${type}, `);
     });
     chunks.push(ts_poet_1.code `}`);
@@ -662,6 +666,7 @@ function generateEncode(ctx, fullName, messageDesc) {
         else {
             throw new Error(`Unhandled field ${field}`);
         }
+        const isOptional = types_1.isOptionalProperty(field, messageDesc.options, options);
         if (types_1.isRepeated(field)) {
             if (types_1.isMapType(ctx, messageDesc, field)) {
                 const valueType = typeMap.get(field.typeName)[2].field[1];
@@ -673,18 +678,29 @@ function generateEncode(ctx, fullName, messageDesc) {
               }
             `
                     : writeSnippet(`{ ${maybeTypeField} key: key as any, value }`);
+                const optionalAlternative = isOptional ? ' || {}' : '';
                 chunks.push(ts_poet_1.code `
-          Object.entries(message.${fieldName}).forEach(([key, value]) => {
+          Object.entries(message.${fieldName}${optionalAlternative}).forEach(([key, value]) => {
             ${entryWriteSnippet}
           });
         `);
             }
             else if (types_1.packedType(field.type) === undefined) {
-                chunks.push(ts_poet_1.code `
+                const listWriteSnippet = ts_poet_1.code `
           for (const v of message.${fieldName}) {
             ${writeSnippet('v!')};
           }
-        `);
+        `;
+                if (isOptional) {
+                    chunks.push(ts_poet_1.code `
+            if (message.${fieldName} !== undefined && message.${fieldName}.length !== 0) {
+              ${listWriteSnippet}
+            }
+          `);
+                }
+                else {
+                    chunks.push(listWriteSnippet);
+                }
             }
             else if (types_1.isEnum(field) && options.stringEnums) {
                 // This is a lot like the `else` clause, but we wrap `fooToNumber` around it.
@@ -693,24 +709,44 @@ function generateEncode(ctx, fullName, messageDesc) {
                 // (i.e. just one tag and multiple values).
                 const tag = ((field.number << 3) | 2) >>> 0;
                 const toNumber = types_1.getEnumMethod(ctx, field.typeName, 'ToNumber');
-                chunks.push(ts_poet_1.code `
+                const listWriteSnippet = ts_poet_1.code `
           writer.uint32(${tag}).fork();
           for (const v of message.${fieldName}) {
             writer.${types_1.toReaderCall(field)}(${toNumber}(v));
           }
           writer.ldelim();
-        `);
+        `;
+                if (isOptional) {
+                    chunks.push(ts_poet_1.code `
+            if (message.${fieldName} !== undefined && message.${fieldName}.length !== 0) {
+              ${listWriteSnippet}
+            }
+          `);
+                }
+                else {
+                    chunks.push(listWriteSnippet);
+                }
             }
             else {
                 // Ideally we'd reuse `writeSnippet` but it has tagging embedded inside of it.
                 const tag = ((field.number << 3) | 2) >>> 0;
-                chunks.push(ts_poet_1.code `
+                const listWriteSnippet = ts_poet_1.code `
           writer.uint32(${tag}).fork();
           for (const v of message.${fieldName}) {
             writer.${types_1.toReaderCall(field)}(v);
           }
           writer.ldelim();
-        `);
+        `;
+                if (isOptional) {
+                    chunks.push(ts_poet_1.code `
+            if (message.${fieldName} !== undefined && message.${fieldName}.length !== 0) {
+              ${listWriteSnippet}
+            }
+          `);
+                }
+                else {
+                    chunks.push(listWriteSnippet);
+                }
             }
         }
         else if (types_1.isWithinOneOfThatShouldBeUnion(options, field)) {
@@ -738,7 +774,7 @@ function generateEncode(ctx, fullName, messageDesc) {
         }
         else if (types_1.isScalar(field) || types_1.isEnum(field)) {
             chunks.push(ts_poet_1.code `
-        if (${types_1.notDefaultCheck(ctx, field, `message.${fieldName}`)}) {
+        if (${types_1.notDefaultCheck(ctx, field, messageDesc.options, `message.${fieldName}`)}) {
           ${writeSnippet(`message.${fieldName}`)};
         }
       `);
@@ -980,6 +1016,9 @@ function generateToJson(ctx, fullName, messageDesc) {
                 else if (types_1.isLong(valueType) && options.forceLong === options_1.LongOption.LONG) {
                     return ts_poet_1.code `${from}.toString()`;
                 }
+                else if (types_1.isWholeNumber(valueType) && !(types_1.isLong(valueType) && options.forceLong === options_1.LongOption.STRING)) {
+                    return ts_poet_1.code `Math.round(${from})`;
+                }
                 else if (types_1.isScalar(valueType) || types_1.isValueType(ctx, valueType)) {
                     return ts_poet_1.code `${from}`;
                 }
@@ -1010,6 +1049,9 @@ function generateToJson(ctx, fullName, messageDesc) {
                 const v = types_1.isWithinOneOf(field) ? 'undefined' : types_1.defaultValue(ctx, field);
                 return ts_poet_1.code `(${from} || ${v}).toString()`;
             }
+            else if (types_1.isWholeNumber(field) && !(types_1.isLong(field) && options.forceLong === options_1.LongOption.STRING)) {
+                return ts_poet_1.code `Math.round(${from})`;
+            }
             else {
                 return ts_poet_1.code `${from}`;
             }

package/build/options.js

@@ -34,9 +34,9 @@ var ServiceOption;
 function defaultOptions() {
     return {
         context: false,
-        snakeToCamel: true,
+        snakeToCamel: ['json', 'keys'],
         forceLong: LongOption.NUMBER,
-        useOptionals: false,
+        useOptionals: 'none',
         useDate: DateOption.DATE,
         oneof: OneofOption.PROPERTIES,
         esModuleInterop: false,
@@ -48,6 +48,7 @@ function defaultOptions() {
         outputTypeRegistry: false,
         stringEnums: false,
         constEnums: false,
+        enumsAsLiterals: false,
         outputClientImpl: true,
         outputServices: ServiceOption.DEFAULT,
         returnObservable: false,
@@ -100,6 +101,12 @@ function optionsFromParameter(parameter) {
         // Treat useDate=false as TIMESTAMP
         options.useDate = DateOption.TIMESTAMP;
     }
+    if (options.snakeToCamel === false) {
+        options.snakeToCamel = [];
+    }
+    else if (options.snakeToCamel === true) {
+        options.snakeToCamel = ['keys', 'json'];
+    }
     return options;
 }
 exports.optionsFromParameter = optionsFromParameter;

package/build/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectBatchMethod = exports.responsePromiseOrObservable = exports.responseObservable = exports.responsePromise = exports.responseType = exports.requestType = exports.rawRequestType = exports.detectMapType = exports.toTypeName = exports.getEnumMethod = exports.messageToTypeName = exports.wrapperTypeName = exports.valueTypeName = exports.isEmptyType = exports.isLongValueType = exports.isStructTypeName = exports.isStructType = exports.isListValueTypeName = exports.isListValueType = exports.isBytesValueType = exports.isAnyValueTypeName = exports.isAnyValueType = exports.isValueType = exports.isTimestamp = exports.isMapType = exports.isLong = exports.isRepeated = exports.isWithinOneOfThatShouldBeUnion = exports.isWithinOneOf = exports.isEnum = exports.isMessage = exports.isBytes = exports.isPrimitive = exports.isScalar = exports.createTypeMap = exports.notDefaultCheck = exports.defaultValue = exports.packedType = exports.toReaderCall = exports.basicTypeName = exports.basicLongWireType = exports.basicWireType = void 0;
+exports.detectBatchMethod = exports.responsePromiseOrObservable = exports.responseObservable = exports.responsePromise = exports.responseType = exports.requestType = exports.rawRequestType = exports.detectMapType = exports.toTypeName = exports.getEnumMethod = exports.messageToTypeName = exports.wrapperTypeName = exports.valueTypeName = exports.isEmptyType = exports.isLongValueType = exports.isStructTypeName = exports.isStructType = exports.isListValueTypeName = exports.isListValueType = exports.isBytesValueType = exports.isAnyValueTypeName = exports.isAnyValueType = exports.isValueType = exports.isTimestamp = exports.isMapType = exports.isWholeNumber = exports.isLong = exports.isRepeated = exports.isWithinOneOfThatShouldBeUnion = exports.isWithinOneOf = exports.isEnum = exports.isMessage = exports.isBytes = exports.isPrimitive = exports.isOptionalProperty = exports.isScalar = exports.createTypeMap = exports.notDefaultCheck = exports.defaultValue = exports.packedType = exports.toReaderCall = exports.basicTypeName = exports.basicLongWireType = exports.basicWireType = void 0;
 const ts_proto_descriptors_1 = require("ts-proto-descriptors");
 const ts_poet_1 = require("ts-poet");
 const options_1 = require("./options");
@@ -225,8 +225,10 @@ 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, place) {
+function notDefaultCheck(ctx, field, messageOptions, place) {
     const { typeMap, options } = ctx;
+    const isOptional = isOptionalProperty(field, messageOptions, options);
+    const maybeNotUndefinedAnd = isOptional ? `${place} !== undefined && ` : '';
     switch (field.type) {
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_DOUBLE:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FLOAT:
@@ -235,7 +237,7 @@ function notDefaultCheck(ctx, field, 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 ts_poet_1.code `${place} !== 0`;
+            return ts_poet_1.code `${maybeNotUndefinedAnd} ${place} !== 0`;
         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.
@@ -245,10 +247,10 @@ function notDefaultCheck(ctx, field, place) {
             const zerothValue = enumProto.value.find((v) => v.number === 0) || enumProto.value[0];
             if (options.stringEnums) {
                 const enumType = messageToTypeName(ctx, field.typeName);
-                return ts_poet_1.code `${place} !== ${enumType}.${zerothValue.name}`;
+                return ts_poet_1.code `${maybeNotUndefinedAnd} ${place} !== ${enumType}.${zerothValue.name}`;
             }
             else {
-                return ts_poet_1.code `${place} !== ${zerothValue.number}`;
+                return ts_poet_1.code `${maybeNotUndefinedAnd} ${place} !== ${zerothValue.number}`;
             }
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT64:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED64:
@@ -256,20 +258,20 @@ function notDefaultCheck(ctx, field, 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 ts_poet_1.code `!${place}.isZero()`;
+                return ts_poet_1.code `${maybeNotUndefinedAnd} !${place}.isZero()`;
             }
             else if (options.forceLong === options_1.LongOption.STRING) {
-                return ts_poet_1.code `${place} !== "0"`;
+                return ts_poet_1.code `${maybeNotUndefinedAnd} ${place} !== "0"`;
             }
             else {
-                return ts_poet_1.code `${place} !== 0`;
+                return ts_poet_1.code `${maybeNotUndefinedAnd} ${place} !== 0`;
             }
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BOOL:
             return ts_poet_1.code `${place} === true`;
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_STRING:
-            return ts_poet_1.code `${place} !== ""`;
+            return ts_poet_1.code `${maybeNotUndefinedAnd} ${place} !== ""`;
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BYTES:
-            return ts_poet_1.code `${place}.length !== 0`;
+            return ts_poet_1.code `${maybeNotUndefinedAnd} ${place}.length !== 0`;
         default:
             throw new Error('Not implemented for the given type.');
     }
@@ -314,6 +316,18 @@ function isScalar(field) {
     return scalarTypes.includes(field.type);
 }
 exports.isScalar = isScalar;
+// When useOptionals='messages', non-scalar fields are translated into optional
+// properties. When useOptionals='all', all fields are translated into
+// optional properties, with the exception of map Entry key/values, which must
+// always be present.
+function isOptionalProperty(field, messageOptions, options) {
+    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)) ||
+        field.proto3Optional);
+}
+exports.isOptionalProperty = isOptionalProperty;
 /** This includes all scalars, enums and the [groups type](https://developers.google.com/protocol-buffers/docs/reference/java/com/google/protobuf/DescriptorProtos.FieldDescriptorProto.Type.html#TYPE_GROUP) */
 function isPrimitive(field) {
     return !isMessage(field);
@@ -347,6 +361,19 @@ function isLong(field) {
     return basicLongWireType(field.type) !== undefined;
 }
 exports.isLong = isLong;
+function isWholeNumber(field) {
+    return (field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT32 ||
+        field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_INT64 ||
+        field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT32 ||
+        field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_UINT64 ||
+        field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT32 ||
+        field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SINT64 ||
+        field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED32 ||
+        field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_FIXED64 ||
+        field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED32 ||
+        field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_SFIXED64);
+}
+exports.isWholeNumber = isWholeNumber;
 function isMapType(ctx, messageDesc, field) {
     return detectMapType(ctx, messageDesc, field) !== undefined;
 }
@@ -462,11 +489,14 @@ function messageToTypeName(ctx, protoType, typeOptions = {}) {
     // them to basic built-in types, we union the type with undefined to
     // indicate the value is optional. Exceptions:
     // - If the field is repeated, values cannot be undefined.
-    // - If useOptionals=true, all non-scalar types are already optional
-    //   properties, so there's no need for that union.
+    // - If useOptionals='messages' or useOptionals='all', all non-scalar types
+    //   are already optional properties, so there's no need for that union.
     let valueType = valueTypeName(ctx, protoType);
     if (!typeOptions.keepValueType && valueType) {
-        if (!!typeOptions.repeated || options.useOptionals) {
+        if (!!typeOptions.repeated ||
+            options.useOptionals === true ||
+            options.useOptionals === 'messages' ||
+            options.useOptionals === 'all') {
             return valueType;
         }
         return ts_poet_1.code `${valueType} | undefined`;
@@ -509,18 +539,21 @@ function toTypeName(ctx, messageDesc, field) {
         // in messageToTypeName, so no need to consider them for that here.
         return type;
     }
-    // By default (useOptionals=false, oneof=properties), non-scalar fields
+    // By default (useOptionals='none', oneof=properties), non-scalar fields
     // outside oneofs and all fields within a oneof clause need to be unioned
     // with `undefined` to indicate the value is optional.
     //
-    // When useOptionals=true, non-scalar fields are translated to optional
-    // properties, so no need for the union with `undefined` here.
+    // When useOptionals='messages' or useOptionals='all', non-scalar fields are
+    // translated to optional properties, so no need for the union with
+    // `undefined` here.
     //
     // When oneof=unions, we generate a single property for the entire `oneof`
     // clause, spelling each option out inside a large type union. No need for
     // union with `undefined` here, either.
     const { options } = ctx;
-    if ((!isWithinOneOf(field) && isMessage(field) && !options.useOptionals) ||
+    if ((!isWithinOneOf(field) &&
+        isMessage(field) &&
+        (options.useOptionals === false || options.useOptionals === 'none')) ||
         (isWithinOneOf(field) && options.oneof === options_1.OneofOption.PROPERTIES) ||
         (isWithinOneOf(field) && field.proto3Optional)) {
         return ts_poet_1.code `${type} | undefined`;

package/build/utils.js

@@ -145,14 +145,14 @@ class FormattedMethodDescriptor {
 }
 exports.FormattedMethodDescriptor = FormattedMethodDescriptor;
 function determineFieldJsonName(field, options) {
-    // By default jsonName is camelCased by the protocol compilier unless the user has
-    // set a "json_name" option on this field.
-    const fromStringSnakeToCamel = typeof options.snakeToCamel === 'string' && options.snakeToCamel.includes('json');
-    const fromBooleanSnakeToCamel = options.snakeToCamel === true;
-    if (fromBooleanSnakeToCamel || fromStringSnakeToCamel) {
+    // jsonName will be camelCased by the protocol compiler, plus can be overridden by the user,
+    // so just use that instead of our own maybeSnakeToCamel
+    if (options.snakeToCamel.includes('json')) {
         return field.jsonName;
     }
-    return case_1.stringToSnakeCase(field.name);
+    else {
+        return field.name;
+    }
 }
 exports.determineFieldJsonName = determineFieldJsonName;
 function impProto(options, module, type) {

package/package.json

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