ts-proto 2.21.0 → 2.22.0

package/README.markdown

@@ -39,6 +39,7 @@ Any tips or tricks for others on the migration would also be appreciated!
 - [Highlights](#highlights)
 - [Auto-Batching / N+1 Prevention](#auto-batching--n1-prevention)
 - [Usage](#usage)
+  - [Options file](#options-file)
   - [Supported options](#supported-options)
   - [NestJS Support](#nestjs-support)
   - [Watch Mode](#watch-mode)
@@ -309,6 +310,22 @@ protobuf {
 
 Generated code will be placed in the Gradle build directory.
 
+### Options file
+
+If you pass many options, you can put them in a JSON file and pass its path with `--ts_proto_opt=optionsFile=<path>`, e.g. `--ts_proto_opt=optionsFile=ts-proto.json` with a `ts-proto.json` of:
+
+```json
+{
+  "esModuleInterop": true,
+  "forceLong": "bigint",
+  "outputServices": ["nice-grpc", "generic-definitions"],
+  "useDate": "string",
+  "Mgoogle/protobuf/empty.proto": "./google3/protobuf/empty"
+}
+```
+
+The keys and values are the same as the `--ts_proto_opt` options below, and options that can be passed multiple times (like `outputServices`) are given as arrays. The path is relative to the directory that `protoc` is run from, and any options also passed as `--ts_proto_opt`s take precedence over the ones in the file. Since the plugin reads the file itself, this needs a local `protoc-gen-ts_proto`, i.e. it doesn't work with the remote Buf Registry plugin.
+
 ### Supported options
 
 - With `--ts_proto_opt=globalThisPolyfill=true`, ts-proto will include a polyfill for globalThis.

package/build/src/main.js

@@ -1932,7 +1932,11 @@ function valueTypeFromJson(ctx, field, from) {
         return (0, ts_poet_1.code) `BigInt(${from})`;
     }
     else if ((0, types_1.isBytesValueType)(field)) {
-        return (0, ts_poet_1.code) `new ${(0, case_1.capitalize)(valueType.toCodeString([]))}(${from})`;
+        // BytesValue is a base64 string in JSON, like a plain `bytes` field.
+        if (options.env === options_1.EnvOption.NODE) {
+            return (0, ts_poet_1.code) `Buffer.from(${ctx.utils.bytesFromBase64}(${from}))`;
+        }
+        return (0, ts_poet_1.code) `${ctx.utils.bytesFromBase64}(${from})`;
     }
     else {
         return (0, ts_poet_1.code) `${(0, case_1.capitalize)(valueType.toCodeString([]))}(${from})`;
@@ -2555,7 +2559,7 @@ function generateToJson(ctx, fullName, fullProtobufTypeName, messageDesc) {
             else if ((0, types_1.isMessage)(field) && !(0, types_1.isValueType)(ctx, field) && !(0, types_1.isMapType)(ctx, messageDesc, field)) {
                 return (0, ts_poet_1.code) `${(0, types_1.getMessageMethod)(ctx, field.typeName, "toJSON")}(${from})`;
             }
-            else if ((0, types_1.isBytes)(field)) {
+            else if ((0, types_1.isBytes)(field) || (0, types_1.isBytesValueType)(field)) {
                 return (0, ts_poet_1.code) `${utils.base64FromBytes}(${from})`;
             }
             else if (isLongValueTypeAsObject(options, field)) {

package/build/src/options.js

@@ -5,6 +5,7 @@ exports.defaultOptions = defaultOptions;
 exports.optionsFromParameter = optionsFromParameter;
 exports.getTsPoetOpts = getTsPoetOpts;
 exports.addTypeToMessages = addTypeToMessages;
+const fs_1 = require("fs");
 var LongOption;
 (function (LongOption) {
     LongOption["NUMBER"] = "number";
@@ -156,7 +157,7 @@ const nestJsOptions = {
 function optionsFromParameter(parameter) {
     const options = defaultOptions();
     if (parameter) {
-        const parsed = parseParameter(parameter);
+        const parsed = withOptionsFile(parseParameter(parameter));
         if (parsed.nestJs) {
             Object.assign(options, nestJsOptions);
         }
@@ -323,6 +324,62 @@ function parseParameter(parameter) {
 function parseParamValue(value) {
     return value === "true" ? true : value === "false" ? false : value;
 }
+// Merges the options from an `optionsFile=<path>` JSON file, if one was given, into the
+// options parsed from the protoc parameter, which take precedence over the file's values.
+function withOptionsFile(parsed) {
+    const { optionsFile, ...params } = parsed;
+    if (optionsFile === undefined) {
+        return parsed;
+    }
+    if (typeof optionsFile !== "string" || optionsFile === "") {
+        throw new Error(`optionsFile must be set to a single file path, but got '${optionsFile}'`);
+    }
+    const fromFile = readOptionsFile(optionsFile);
+    return { ...fromFile, ...params, M: { ...fromFile.M, ...params.M } };
+}
+// Reads a JSON object of options, e.g. `{ "useDate": "string", "outputServices": ["grpc-js", "generic-definitions"] }`,
+// and returns the same values that `parseParameter` would for the equivalent protoc parameters.
+function readOptionsFile(path) {
+    let json;
+    try {
+        json = JSON.parse((0, fs_1.readFileSync)(path, "utf-8"));
+    }
+    catch (e) {
+        throw new Error(`Could not read optionsFile '${path}': ${e.message}`);
+    }
+    if (typeof json !== "object" || json === null || Array.isArray(json)) {
+        throw new Error(`optionsFile '${path}' must contain a JSON object of options`);
+    }
+    const options = { M: {} };
+    for (const [key, value] of Object.entries(json)) {
+        if (key === "optionsFile") {
+            throw new Error(`optionsFile '${path}' can't set optionsFile`);
+        }
+        else if (key.charAt(0) === "M") {
+            if (typeof value !== "string") {
+                throw new Error(`optionsFile '${path}' must set ${key} to a string, but got ${JSON.stringify(value)}`);
+            }
+            options.M[key.substring(1)] = value;
+        }
+        else if (isOptionValue(value)) {
+            options[key] = normalizeOptionValue(value);
+        }
+        else if (Array.isArray(value) && value.length > 0 && value.every(isOptionValue)) {
+            // A single-element array is the same as passing the option once
+            options[key] = value.length === 1 ? normalizeOptionValue(value[0]) : value.map(normalizeOptionValue);
+        }
+        else {
+            throw new Error(`optionsFile '${path}' must set ${key} to a string, number, boolean, or non-empty array of them, but got ${JSON.stringify(value)}`);
+        }
+    }
+    return options;
+}
+function isOptionValue(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function normalizeOptionValue(value) {
+    return parseParamValue(String(value));
+}
 function getTsPoetOpts(options, tsProtoVersion, protocVersion, fileName) {
     const { importSuffix, esModuleInterop } = options;
     const pbjs = "protobufjs/minimal" + importSuffix;

package/package.json

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