ts-proto 1.159.3 → 1.161.0

package/README.markdown

@@ -14,15 +14,15 @@
   - [Buf](#buf)
   - [ESM](#esm)
 - [Goals](#goals)
+  - [Non-Goals](#non-goals)
 - [Example Types](#example-types)
 - [Highlights](#highlights)
 - [Auto-Batching / N+1 Prevention](#auto-batching--n1-prevention)
 - [Usage](#usage)
-  - [Supported options](#supported-options)
-  - [Only Types](#only-types)
-  - [NestJS Support](#nestjs-support)
-  - [Watch Mode](#watch-mode)
-  - [Basic gRPC implementation](#basic-grpc-implementation)
+    - [Supported options](#supported-options)
+    - [NestJS Support](#nestjs-support)
+    - [Watch Mode](#watch-mode)
+    - [Basic gRPC implementation](#basic-grpc-implementation)
 - [Sponsors](#sponsors)
 - [Development](#development)
 - [Assumptions](#assumptions)
@@ -354,7 +354,15 @@ Generated code will be placed in the Gradle build directory.
 
   See the "OneOf Handling" section.
 
-- With `--ts_proto_opt=unrecognizedEnum=false` enums will not contain an `UNRECOGNIZED` key with value of -1.
+- With `--ts_proto_opt=unrecognizedEnumName=<NAME>` enums will contain a key `<NAME>` with value of the `unrecognizedEnumValue` option.
+
+  Defaults to `UNRECOGNIZED`.
+
+- With `--ts_proto_opt=unrecognizedEnumValue=<NUMBER>` enums will contain a key provided by the `unrecognizedEnumName` option with value of `<NUMBER>`.
+
+  Defaults to `-1`.
+
+- With `--ts_proto_opt=unrecognizedEnum=false` enums will not contain an unrecognized enum key and value as provided by the `unrecognizedEnumName` and `unrecognizedEnumValue` options.
 
 - With `--ts_proto_opt=removeEnumPrefix=true` generated enums will have the enum name removed from members.
 

package/build/enums.js

@@ -5,13 +5,12 @@ const ts_poet_1 = require("ts-poet");
 const utils_1 = require("./utils");
 const case_1 = require("./case");
 const sourceInfo_1 = require("./sourceInfo");
-const UNRECOGNIZED_ENUM_NAME = "UNRECOGNIZED";
-const UNRECOGNIZED_ENUM_VALUE = -1;
 // Output the `enum { Foo, A = 0, B = 1 }`
 function generateEnum(ctx, fullName, enumDesc, sourceInfo) {
     var _a;
     const { options } = ctx;
     const chunks = [];
+    let unrecognizedEnum = { present: false };
     (0, utils_1.maybeAddComment)(sourceInfo, chunks, (_a = enumDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated);
     if (options.enumsAsLiterals) {
         chunks.push((0, ts_poet_1.code) `export const ${(0, ts_poet_1.def)(fullName)} = {`);
@@ -25,12 +24,16 @@ function generateEnum(ctx, fullName, enumDesc, sourceInfo) {
         const info = sourceInfo.lookup(sourceInfo_1.Fields.enum.value, index);
         const valueName = getValueName(ctx, fullName, valueDesc);
         const memberName = getMemberName(ctx, enumDesc, valueDesc);
+        if (valueDesc.number === options.unrecognizedEnumValue) {
+            unrecognizedEnum = { present: true, name: memberName };
+        }
         (0, utils_1.maybeAddComment)(info, chunks, (_a = valueDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated, `${memberName} - `);
         chunks.push((0, ts_poet_1.code) `${memberName} ${delimiter} ${options.stringEnums ? `"${valueName}"` : valueDesc.number.toString()},`);
     });
-    if (options.unrecognizedEnum)
+    if (options.unrecognizedEnum && !unrecognizedEnum.present) {
         chunks.push((0, ts_poet_1.code) `
-      ${UNRECOGNIZED_ENUM_NAME} ${delimiter} ${options.stringEnums ? `"${UNRECOGNIZED_ENUM_NAME}"` : UNRECOGNIZED_ENUM_VALUE.toString()},`);
+      ${options.unrecognizedEnumName} ${delimiter} ${options.stringEnums ? `"${options.unrecognizedEnumName}"` : options.unrecognizedEnumValue.toString()},`);
+    }
     if (options.enumsAsLiterals) {
         chunks.push((0, ts_poet_1.code) `} as const`);
         chunks.push((0, ts_poet_1.code) `\n`);
@@ -43,21 +46,21 @@ function generateEnum(ctx, fullName, enumDesc, sourceInfo) {
         options.outputJsonMethods === "from-only" ||
         (options.stringEnums && options.outputEncodeMethods)) {
         chunks.push((0, ts_poet_1.code) `\n`);
-        chunks.push(generateEnumFromJson(ctx, fullName, enumDesc));
+        chunks.push(generateEnumFromJson(ctx, fullName, enumDesc, unrecognizedEnum));
     }
     if (options.outputJsonMethods === true || options.outputJsonMethods === "to-only") {
         chunks.push((0, ts_poet_1.code) `\n`);
-        chunks.push(generateEnumToJson(ctx, fullName, enumDesc));
+        chunks.push(generateEnumToJson(ctx, fullName, enumDesc, unrecognizedEnum));
     }
     if (options.stringEnums && options.outputEncodeMethods) {
         chunks.push((0, ts_poet_1.code) `\n`);
-        chunks.push(generateEnumToNumber(ctx, fullName, enumDesc));
+        chunks.push(generateEnumToNumber(ctx, fullName, enumDesc, unrecognizedEnum));
     }
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
 }
 exports.generateEnum = generateEnum;
 /** Generates a function with a big switch statement to decode JSON -> our enum. */
-function generateEnumFromJson(ctx, fullName, enumDesc) {
+function generateEnumFromJson(ctx, fullName, enumDesc, unrecognizedEnum) {
     const { options, utils } = ctx;
     const chunks = [];
     const functionName = (0, case_1.uncapitalize)(fullName) + "FromJSON";
@@ -73,12 +76,20 @@ function generateEnumFromJson(ctx, fullName, enumDesc) {
     `);
     }
     if (options.unrecognizedEnum) {
-        chunks.push((0, ts_poet_1.code) `
-      case ${UNRECOGNIZED_ENUM_VALUE}:
-      case "${UNRECOGNIZED_ENUM_NAME}":
-      default:
-        return ${fullName}.${UNRECOGNIZED_ENUM_NAME};
-    `);
+        if (!unrecognizedEnum.present) {
+            chunks.push((0, ts_poet_1.code) `
+        case ${options.unrecognizedEnumValue}:
+        case "${options.unrecognizedEnumName}":
+        default:
+          return ${fullName}.${options.unrecognizedEnumName};
+      `);
+        }
+        else {
+            chunks.push((0, ts_poet_1.code) `
+        default:
+          return ${fullName}.${unrecognizedEnum.name};
+      `);
+        }
     }
     else {
         // We use globalThis to avoid conflicts on protobuf types named `Error`.
@@ -93,7 +104,7 @@ function generateEnumFromJson(ctx, fullName, enumDesc) {
 }
 exports.generateEnumFromJson = generateEnumFromJson;
 /** Generates a function with a big switch statement to encode our enum -> JSON. */
-function generateEnumToJson(ctx, fullName, enumDesc) {
+function generateEnumToJson(ctx, fullName, enumDesc, unrecognizedEnum) {
     const { options, utils } = ctx;
     const chunks = [];
     const functionName = (0, case_1.uncapitalize)(fullName) + "ToJSON";
@@ -111,18 +122,32 @@ function generateEnumToJson(ctx, fullName, enumDesc) {
         }
     }
     if (options.unrecognizedEnum) {
-        chunks.push((0, ts_poet_1.code) `
-      case ${fullName}.${UNRECOGNIZED_ENUM_NAME}:`);
-        if (ctx.options.useNumericEnumForJson) {
+        if (!unrecognizedEnum.present) {
             chunks.push((0, ts_poet_1.code) `
-      default:
-        return ${UNRECOGNIZED_ENUM_VALUE};
-    `);
+        case ${fullName}.${options.unrecognizedEnumName}:`);
+            if (ctx.options.useNumericEnumForJson) {
+                chunks.push((0, ts_poet_1.code) `
+        default:
+          return ${options.unrecognizedEnumValue};
+      `);
+            }
+            else {
+                chunks.push((0, ts_poet_1.code) `
+        default:
+          return "${options.unrecognizedEnumName}";
+      `);
+            }
+        }
+        else if (ctx.options.useNumericEnumForJson) {
+            chunks.push((0, ts_poet_1.code) `
+        default:
+          return ${options.unrecognizedEnumValue};
+      `);
         }
         else {
             chunks.push((0, ts_poet_1.code) `
       default:
-        return "${UNRECOGNIZED_ENUM_NAME}";
+        return "${unrecognizedEnum.name}";
     `);
         }
     }
@@ -139,7 +164,7 @@ function generateEnumToJson(ctx, fullName, enumDesc) {
 }
 exports.generateEnumToJson = generateEnumToJson;
 /** Generates a function with a big switch statement to encode our string enum -> int value. */
-function generateEnumToNumber(ctx, fullName, enumDesc) {
+function generateEnumToNumber(ctx, fullName, enumDesc, unrecognizedEnum) {
     const { options, utils } = ctx;
     const chunks = [];
     const functionName = (0, case_1.uncapitalize)(fullName) + "ToNumber";
@@ -149,11 +174,19 @@ function generateEnumToNumber(ctx, fullName, enumDesc) {
         chunks.push((0, ts_poet_1.code) `case ${fullName}.${getMemberName(ctx, enumDesc, valueDesc)}: return ${valueDesc.number};`);
     }
     if (options.unrecognizedEnum) {
-        chunks.push((0, ts_poet_1.code) `
-      case ${fullName}.${UNRECOGNIZED_ENUM_NAME}:
-      default:
-        return ${UNRECOGNIZED_ENUM_VALUE};
-    `);
+        if (!unrecognizedEnum.present) {
+            chunks.push((0, ts_poet_1.code) `
+        case ${fullName}.${options.unrecognizedEnumName}:
+        default:
+          return ${options.unrecognizedEnumValue};
+      `);
+        }
+        else {
+            chunks.push((0, ts_poet_1.code) `
+        default:
+          return ${options.unrecognizedEnumValue};
+      `);
+        }
     }
     else {
         // We use globalThis to avoid conflicts on protobuf types named `Error`.

package/build/main.js

@@ -943,7 +943,24 @@ function getEncodeWriteSnippet(ctx, field) {
     }
     else if ((0, types_1.isLong)(field) && options.forceLong === options_1.LongOption.BIGINT) {
         const tag = ((field.number << 3) | (0, types_1.basicWireType)(field.type)) >>> 0;
-        return (place) => (0, ts_poet_1.code) `writer.uint32(${tag}).${(0, types_1.toReaderCall)(field)}(${place}.toString())`;
+        const fieldType = (0, types_1.toReaderCall)(field);
+        switch (fieldType) {
+            case "int64":
+            case "sint64":
+            case "sfixed64":
+                return (place) => (0, ts_poet_1.code) `if (BigInt.asIntN(64, ${place}) !== ${place}) {
+          throw new Error('value provided for field ${place} of type ${fieldType} too large');
+        }
+        writer.uint32(${tag}).${(0, types_1.toReaderCall)(field)}(${place}.toString())`;
+            case "uint64":
+            case "fixed64":
+                return (place) => (0, ts_poet_1.code) `if (BigInt.asUintN(64, ${place}) !== ${place}) {
+          throw new Error('value provided for field ${place} of type ${fieldType} too large');
+        }
+        writer.uint32(${tag}).${(0, types_1.toReaderCall)(field)}(${place}.toString())`;
+            default:
+                throw new Error(`unexpected BigInt type: ${fieldType}`);
+        }
     }
     else if ((0, types_1.isScalar)(field) || (0, types_1.isEnum)(field)) {
         const tag = ((field.number << 3) | (0, types_1.basicWireType)(field.type)) >>> 0;
@@ -1080,13 +1097,47 @@ function generateEncode(ctx, fullName, messageDesc) {
                 // Ideally we'd reuse `writeSnippet` but it has tagging embedded inside of it.
                 const tag = ((field.number << 3) | 2) >>> 0;
                 const rhs = (x) => ((0, types_1.isLong)(field) && options.forceLong === options_1.LongOption.BIGINT ? `${x}.toString()` : x);
-                const listWriteSnippet = (0, ts_poet_1.code) `
+                let listWriteSnippet = (0, ts_poet_1.code) `
           writer.uint32(${tag}).fork();
           for (const v of message.${fieldName}) {
             writer.${(0, types_1.toReaderCall)(field)}(${rhs("v")});
           }
           writer.ldelim();
         `;
+                if ((0, types_1.isLong)(field) && options.forceLong === options_1.LongOption.BIGINT) {
+                    const fieldType = (0, types_1.toReaderCall)(field);
+                    switch (fieldType) {
+                        case "int64":
+                        case "sint64":
+                        case "sfixed64":
+                            listWriteSnippet = (0, ts_poet_1.code) `
+                writer.uint32(${tag}).fork();
+                for (const v of message.${fieldName}) {
+                  if (BigInt.asIntN(64, v) !== v) {
+                    throw new Error('a value provided in array field ${fieldName} of type ${fieldType} is too large');
+                  }
+                  writer.${(0, types_1.toReaderCall)(field)}(${rhs("v")});
+                }
+                writer.ldelim();
+              `;
+                            break;
+                        case "uint64":
+                        case "fixed64":
+                            listWriteSnippet = (0, ts_poet_1.code) `
+                writer.uint32(${tag}).fork();
+                for (const v of message.${fieldName}) {
+                  if (BigInt.asUintN(64, v) !== v) {
+                    throw new Error('a value provided in array field ${fieldName} of type ${fieldType} is too large');
+                  }                
+                  writer.${(0, types_1.toReaderCall)(field)}(${rhs("v")});
+                }
+                writer.ldelim();
+              `;
+                            break;
+                        default:
+                            throw new Error(`unexpected BigInt type: ${fieldType}`);
+                    }
+                }
                 if (isOptional) {
                     chunks.push((0, ts_poet_1.code) `
             if (message.${fieldName} !== undefined && message.${fieldName}.length !== 0) {

package/build/options.js

@@ -66,6 +66,8 @@ function defaultOptions() {
         nestJs: false,
         env: EnvOption.BOTH,
         unrecognizedEnum: true,
+        unrecognizedEnumName: "UNRECOGNIZED",
+        unrecognizedEnumValue: -1,
         exportCommonSymbols: true,
         outputSchema: false,
         onlyTypes: false,
@@ -172,6 +174,10 @@ function optionsFromParameter(parameter) {
     if (options.outputIndex) {
         options.exportCommonSymbols = false;
     }
+    if (options.unrecognizedEnumValue) {
+        // Make sure to cast number options to an actual number
+        options.unrecognizedEnumValue = Number(options.unrecognizedEnumValue);
+    }
     return options;
 }
 exports.optionsFromParameter = optionsFromParameter;

package/package.json

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