ts-proto 1.138.0 → 1.140.0

package/README.markdown

@@ -352,6 +352,10 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=unrecognizedEnum=false` enums will not contain an `UNRECOGNIZED` key with value of -1.
 
+- With `--ts_proto_opt=removeEnumPrefix=true` generated enums will have the enum name removed from members.
+
+  `FooBar.FOO_BAR_BAZ = "FOO_BAR_BAZ"` will generate `FooBar.BAZ = "FOO_BAR_BAZ"`
+
 - With `--ts_proto_opt=lowerCaseServiceMethods=true`, the method names of service methods will be lowered/camel-case, i.e. `service.findFoo` instead of `service.FindFoo`.
 
 - With `--ts_proto_opt=snakeToCamel=false`, fields will be kept snake case in both the message keys and the `toJSON` / `fromJSON` methods.
@@ -400,7 +404,7 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=nestJs=true`, the defaults will change to generate [NestJS protobuf](https://docs.nestjs.com/microservices/grpc) friendly types & service interfaces that can be used in both the client-side and server-side of NestJS protobuf implementations. See the [nestjs readme](NESTJS.markdown) for more information and implementation examples.
 
-  Specifically `outputEncodeMethods`, `outputJsonMethods`, and `outputClientImpl` will all be false, and `lowerCaseServiceMethods` will be true.
+  Specifically `outputEncodeMethods`, `outputJsonMethods`, and `outputClientImpl` will all be false, `lowerCaseServiceMethods` will be true and `outputServices` will be ignored.
 
   Note that `addGrpcMetadata`, `addNestjsRestParameter` and `returnObservable` will still be false.
 

package/build/enums.js

@@ -23,8 +23,10 @@ function generateEnum(ctx, fullName, enumDesc, sourceInfo) {
     enumDesc.value.forEach((valueDesc, index) => {
         var _a;
         const info = sourceInfo.lookup(sourceInfo_1.Fields.enum.value, index);
-        (0, utils_1.maybeAddComment)(info, chunks, (_a = valueDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated, `${valueDesc.name} - `);
-        chunks.push((0, ts_poet_1.code) `${valueDesc.name} ${delimiter} ${options.stringEnums ? `"${valueDesc.name}"` : valueDesc.number.toString()},`);
+        const valueName = getValueName(ctx, fullName, valueDesc);
+        const memberName = getMemberName(ctx, fullName, valueDesc);
+        (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)
         chunks.push((0, ts_poet_1.code) `
@@ -60,10 +62,12 @@ function generateEnumFromJson(ctx, fullName, enumDesc) {
     chunks.push((0, ts_poet_1.code) `export function ${(0, ts_poet_1.def)(functionName)}(object: any): ${fullName} {`);
     chunks.push((0, ts_poet_1.code) `switch (object) {`);
     for (const valueDesc of enumDesc.value) {
+        const memberName = getMemberName(ctx, fullName, valueDesc);
+        const valueName = getValueName(ctx, fullName, valueDesc);
         chunks.push((0, ts_poet_1.code) `
       case ${valueDesc.number}:
-      case "${valueDesc.name}":
-        return ${fullName}.${valueDesc.name};
+      case "${valueName}":
+        return ${fullName}.${memberName};
     `);
     }
     if (options.unrecognizedEnum) {
@@ -95,10 +99,13 @@ function generateEnumToJson(ctx, fullName, enumDesc) {
     chunks.push((0, ts_poet_1.code) `switch (object) {`);
     for (const valueDesc of enumDesc.value) {
         if (ctx.options.useNumericEnumForJson) {
-            chunks.push((0, ts_poet_1.code) `case ${fullName}.${valueDesc.name}: return ${valueDesc.number};`);
+            const memberName = getMemberName(ctx, fullName, valueDesc);
+            chunks.push((0, ts_poet_1.code) `case ${fullName}.${memberName}: return ${valueDesc.number};`);
         }
         else {
-            chunks.push((0, ts_poet_1.code) `case ${fullName}.${valueDesc.name}: return "${valueDesc.name}";`);
+            const memberName = getMemberName(ctx, fullName, valueDesc);
+            const valueName = getValueName(ctx, fullName, valueDesc);
+            chunks.push((0, ts_poet_1.code) `case ${fullName}.${memberName}: return "${valueName}";`);
         }
     }
     if (options.unrecognizedEnum) {
@@ -137,7 +144,7 @@ function generateEnumToNumber(ctx, fullName, enumDesc) {
     chunks.push((0, ts_poet_1.code) `export function ${(0, ts_poet_1.def)(functionName)}(object: ${fullName}): number {`);
     chunks.push((0, ts_poet_1.code) `switch (object) {`);
     for (const valueDesc of enumDesc.value) {
-        chunks.push((0, ts_poet_1.code) `case ${fullName}.${valueDesc.name}: return ${valueDesc.number};`);
+        chunks.push((0, ts_poet_1.code) `case ${fullName}.${getMemberName(ctx, fullName, valueDesc)}: return ${valueDesc.number};`);
     }
     if (options.unrecognizedEnum) {
         chunks.push((0, ts_poet_1.code) `
@@ -158,3 +165,12 @@ function generateEnumToNumber(ctx, fullName, enumDesc) {
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
 }
 exports.generateEnumToNumber = generateEnumToNumber;
+function getMemberName(ctx, fullName, valueDesc) {
+    if (ctx.options.removeEnumPrefix) {
+        return valueDesc.name.replace(`${(0, case_1.camelToSnake)(fullName)}_`, "");
+    }
+    return valueDesc.name;
+}
+function getValueName(ctx, fullName, valueDesc) {
+    return valueDesc.name;
+}

package/build/generate-grpc-web.js

@@ -39,6 +39,8 @@ exports.generateGrpcClientImpl = generateGrpcClientImpl;
 /** Creates the RPC methods that client code actually calls. */
 function generateRpcMethod(ctx, serviceDesc, methodDesc) {
     (0, utils_1.assertInstanceOf)(methodDesc, utils_1.FormattedMethodDescriptor);
+    const { options } = ctx;
+    const { useAbortSignal } = options;
     const requestMessage = (0, types_1.rawRequestType)(ctx, methodDesc);
     const inputType = (0, types_1.requestType)(ctx, methodDesc, true);
     const returns = (0, types_1.responsePromiseOrObservable)(ctx, methodDesc);
@@ -47,6 +49,7 @@ function generateRpcMethod(ctx, serviceDesc, methodDesc) {
     ${methodDesc.formattedName}(
       request: ${inputType},
       metadata?: grpc.Metadata,
+      ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
     ): ${returns} {
       throw new Error('ts-proto does not yet support client streaming!');
     }
@@ -57,10 +60,12 @@ function generateRpcMethod(ctx, serviceDesc, methodDesc) {
     ${methodDesc.formattedName}(
       request: ${inputType},
       metadata?: grpc.Metadata,
+      ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
     ): ${returns} {
       return this.rpc.${method}(
         ${methodDescName(serviceDesc, methodDesc)},
         ${requestMessage}.fromPartial(request),
+        ${useAbortSignal ? "abortSignal," : ""}
         metadata,
       );
     }
@@ -145,6 +150,8 @@ exports.addGrpcWebMisc = addGrpcWebMisc;
 /** Makes an `Rpc` interface to decouple from the low-level grpc-web `grpc.invoke and grpc.unary`/etc. methods. */
 function generateGrpcWebRpcType(ctx, returnObservable, hasStreamingMethods) {
     const chunks = [];
+    const { options } = ctx;
+    const { useAbortSignal } = options;
     chunks.push((0, ts_poet_1.code) `interface Rpc {`);
     const wrapper = returnObservable ? (0, types_1.observableType)(ctx) : "Promise";
     chunks.push((0, ts_poet_1.code) `
@@ -152,6 +159,7 @@ function generateGrpcWebRpcType(ctx, returnObservable, hasStreamingMethods) {
       methodDesc: T,
       request: any,
       metadata: grpc.Metadata | undefined,
+      ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
     ): ${wrapper}<any>;
   `);
     if (hasStreamingMethods) {
@@ -160,6 +168,7 @@ function generateGrpcWebRpcType(ctx, returnObservable, hasStreamingMethods) {
         methodDesc: T,
         request: any,
         metadata: grpc.Metadata | undefined,
+        ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
       ): ${(0, types_1.observableType)(ctx)}<any>;
     `);
     }
@@ -201,11 +210,23 @@ function generateGrpcWebImpl(ctx, returnObservable, hasStreamingMethods) {
     return (0, ts_poet_1.joinCode)(chunks, { trim: false });
 }
 function createPromiseUnaryMethod(ctx) {
+    const { options } = ctx;
+    const { useAbortSignal } = options;
+    const maybeAbortSignal = useAbortSignal
+        ? `
+      const abortHandler = () => {
+        client.close();
+        reject(new Error("Aborted"));
+      }
+
+      if (abortSignal) abortSignal.addEventListener("abort", abortHandler);`
+        : "";
     return (0, ts_poet_1.code) `
     unary<T extends UnaryMethodDefinitionish>(
       methodDesc: T,
       _request: any,
-      metadata: grpc.Metadata | undefined
+      metadata: grpc.Metadata | undefined,
+      ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
     ): Promise<any> {
       const request = { ..._request, ...methodDesc.requestType };
       const maybeCombinedMetadata =
@@ -213,7 +234,7 @@ function createPromiseUnaryMethod(ctx) {
           ? new ${BrowserHeaders}({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
           : metadata || this.options.metadata;
       return new Promise((resolve, reject) => {
-      ${grpc}.unary(methodDesc, {
+        ${useAbortSignal ? `const client =` : ""} ${grpc}.unary(methodDesc, {
           request,
           host: this.host,
           metadata: maybeCombinedMetadata,
@@ -228,16 +249,29 @@ function createPromiseUnaryMethod(ctx) {
             }
           },
         });
+
+        ${maybeAbortSignal}
       });
     }
   `;
 }
 function createObservableUnaryMethod(ctx) {
+    const { options } = ctx;
+    const { useAbortSignal } = options;
+    const maybeAbortSignal = useAbortSignal
+        ? `
+      const abortHandler = () => {
+        observer.error("Aborted");
+        client.close();
+      };
+      if (abortSignal) abortSignal.addEventListener("abort", abortHandler);`
+        : "";
     return (0, ts_poet_1.code) `
     unary<T extends UnaryMethodDefinitionish>(
       methodDesc: T,
       _request: any,
-      metadata: grpc.Metadata | undefined
+      metadata: grpc.Metadata | undefined,
+      ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
     ): ${(0, types_1.observableType)(ctx)}<any> {
       const request = { ..._request, ...methodDesc.requestType };
       const maybeCombinedMetadata =
@@ -245,7 +279,7 @@ function createObservableUnaryMethod(ctx) {
           ? new ${BrowserHeaders}({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
           : metadata || this.options.metadata;
       return new Observable(observer => {
-        ${grpc}.unary(methodDesc, {
+        ${useAbortSignal ? `const client =` : ""} ${grpc}.unary(methodDesc, {
           request,
           host: this.host,
           metadata: maybeCombinedMetadata,
@@ -261,16 +295,31 @@ function createObservableUnaryMethod(ctx) {
             }
           },
         });
+
+
+      ${maybeAbortSignal}
+
       }).pipe(${take}(1));
     } 
   `;
 }
 function createInvokeMethod(ctx) {
+    const { options } = ctx;
+    const { useAbortSignal } = options;
+    const maybeAbortSignal = useAbortSignal
+        ? `
+      const abortHandler = () => {
+        observer.error("Aborted");
+        client.close();
+      };
+      if (abortSignal) abortSignal.addEventListener("abort", abortHandler);`
+        : "";
     return (0, ts_poet_1.code) `
     invoke<T extends UnaryMethodDefinitionish>(
       methodDesc: T,
       _request: any,
-      metadata: grpc.Metadata | undefined
+      metadata: grpc.Metadata | undefined,
+      ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
     ): ${(0, types_1.observableType)(ctx)}<any> {
       const upStreamCodes = this.options.upStreamRetryCodes || [];
       const DEFAULT_TIMEOUT_TIME: number = 3_000;
@@ -301,7 +350,11 @@ function createInvokeMethod(ctx) {
               }
             },
           });
-          observer.add(() => client.close());
+          observer.add(() => {
+            if (!observer.closed) return client.close()
+          });
+
+          ${maybeAbortSignal}
         });
         upStream();
       }).pipe(${share}());

package/build/generate-services.js

@@ -39,9 +39,6 @@ function generateService(ctx, fileDesc, sourceInfo, serviceDesc) {
         const partialInput = options.outputClientImpl === "grpc-web";
         const inputType = (0, types_1.requestType)(ctx, methodDesc, partialInput);
         params.push((0, ts_poet_1.code) `request: ${inputType}`);
-        if (options.useAbortSignal) {
-            params.push((0, ts_poet_1.code) `abortSignal?: AbortSignal`);
-        }
         // Use metadata as last argument for interface only configuration
         if (options.outputClientImpl === "grpc-web") {
             // We have to use grpc.Metadata where grpc will come from @improbable-eng
@@ -56,6 +53,9 @@ function generateService(ctx, fileDesc, sourceInfo, serviceDesc) {
             const Metadata = (0, ts_poet_1.imp)(options.metadataType);
             params.push((0, ts_poet_1.code) `metadata?: ${Metadata}`);
         }
+        if (options.useAbortSignal) {
+            params.push((0, ts_poet_1.code) `abortSignal?: AbortSignal`);
+        }
         if (options.addNestjsRestParameter) {
             params.push((0, ts_poet_1.code) `...rest: any`);
         }

package/build/generate-struct-wrappers.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnwrapShallow = exports.generateWrapShallow = exports.generateUnwrapDeep = exports.generateWrapDeep = exports.isWrapperType = void 0;
+const ts_poet_1 = require("ts-poet");
+const types_1 = require("./types");
+const options_1 = require("./options");
+/** Whether we need to generate `.wrap` and `.unwrap` methods for the given type. */
+function isWrapperType(fullProtoTypeName) {
+    return ((0, types_1.isStructTypeName)(fullProtoTypeName) ||
+        (0, types_1.isAnyValueTypeName)(fullProtoTypeName) ||
+        (0, types_1.isListValueTypeName)(fullProtoTypeName) ||
+        (0, types_1.isFieldMaskTypeName)(fullProtoTypeName));
+}
+exports.isWrapperType = isWrapperType;
+/**
+ * Converts ts-proto's idiomatic Struct/Value/ListValue representation to the proto messages.
+ *
+ * We do this deeply b/c NestJS does not invoke wrappers recursively.
+ */
+function generateWrapDeep(ctx, fullProtoTypeName, fieldNames) {
+    const chunks = [];
+    if ((0, types_1.isStructTypeName)(fullProtoTypeName)) {
+        let setStatement = "struct.fields[key] = Value.wrap(object[key]);";
+        if (ctx.options.useMapType) {
+            setStatement = "struct.fields.set(key, Value.wrap(object[key]));";
+        }
+        chunks.push((0, ts_poet_1.code) `wrap(object: {[key: string]: any} | undefined): Struct {
+      const struct = createBaseStruct();
+      if (object !== undefined) {
+        Object.keys(object).forEach(key => {
+          ${setStatement}
+        });
+      }
+      return struct;
+    }`);
+    }
+    if ((0, types_1.isAnyValueTypeName)(fullProtoTypeName)) {
+        // Turn ts-proto representation --> proto representation
+        chunks.push((0, ts_poet_1.code) `wrap(value: any): Value {
+      const result = {} as any;
+      if (value === null) {
+        result.${fieldNames.nullValue} = NullValue.NULL_VALUE;
+      } else if (typeof value === 'boolean') {
+        result.${fieldNames.boolValue} = value;
+      } else if (typeof value === 'number') {
+        result.${fieldNames.numberValue} = value;
+      } else if (typeof value === 'string') {
+        result.${fieldNames.stringValue} = value;
+      } else if (Array.isArray(value)) {
+        result.${fieldNames.listValue} = ListValue.wrap(value);
+      } else if (typeof value === 'object') {
+        result.${fieldNames.structValue} = Struct.wrap(value);
+      } else if (typeof value !== 'undefined') {
+        throw new Error('Unsupported any value type: ' + typeof value);
+      }
+      return result;
+    }`);
+    }
+    if ((0, types_1.isListValueTypeName)(fullProtoTypeName)) {
+        const maybeReadyOnly = ctx.options.useReadonlyTypes ? "Readonly" : "";
+        chunks.push((0, ts_poet_1.code) `wrap(array: ${maybeReadyOnly}Array<any> | undefined): ListValue {
+      const result = createBaseListValue()${maybeAsAny(ctx.options)};
+      result.values = (array ?? []).map(Value.wrap);
+      return result;
+    }`);
+    }
+    if ((0, types_1.isFieldMaskTypeName)(fullProtoTypeName)) {
+        chunks.push((0, ts_poet_1.code) `wrap(paths: ${maybeReadonly(ctx.options)} string[]): FieldMask {
+      const result = createBaseFieldMask()${maybeAsAny(ctx.options)};
+      result.paths = paths;
+      return result;
+    }`);
+    }
+    return chunks;
+}
+exports.generateWrapDeep = generateWrapDeep;
+/**
+ * Converts proto's Struct/Value?listValue messages to ts-proto's idiomatic representation.
+ *
+ * We do this deeply b/c NestJS does not invoke wrappers recursively.
+ */
+function generateUnwrapDeep(ctx, fullProtoTypeName, fieldNames) {
+    const chunks = [];
+    if ((0, types_1.isStructTypeName)(fullProtoTypeName)) {
+        if (ctx.options.useMapType) {
+            chunks.push((0, ts_poet_1.code) `unwrap(message: Struct): {[key: string]: any} {
+        const object: { [key: string]: any } = {};
+        [...message.fields.keys()].forEach((key) => {
+          object[key] = Value.unwrap(message.fields.get(key));
+        });
+        return object;
+      }`);
+        }
+        else {
+            chunks.push((0, ts_poet_1.code) `unwrap(message: Struct): {[key: string]: any} {
+        const object: { [key: string]: any } = {};
+        if (message.fields) {
+          Object.keys(message.fields).forEach(key => {
+            object[key] = Value.unwrap(message.fields[key]);
+          });
+        }
+        return object;
+      }`);
+        }
+    }
+    if ((0, types_1.isAnyValueTypeName)(fullProtoTypeName)) {
+        // We check hasOwnProperty because the incoming `message` has been serde-ing
+        // by the NestJS/protobufjs runtime, and so has a base class with default values
+        // that throw off the simpler checks we do in generateUnwrapShallow
+        chunks.push((0, ts_poet_1.code) `unwrap(message: any): string | number | boolean | Object | null | Array<any> | undefined {
+      if (message?.hasOwnProperty('${fieldNames.stringValue}') && message.${fieldNames.stringValue} !== undefined) {
+        return message.${fieldNames.stringValue};
+      } else if (message?.hasOwnProperty('${fieldNames.numberValue}') && message?.${fieldNames.numberValue} !== undefined) {
+        return message.${fieldNames.numberValue};
+      } else if (message?.hasOwnProperty('${fieldNames.boolValue}') && message?.${fieldNames.boolValue} !== undefined) {
+        return message.${fieldNames.boolValue};
+      } else if (message?.hasOwnProperty('${fieldNames.structValue}') && message?.${fieldNames.structValue} !== undefined) {
+        return Struct.unwrap(message.${fieldNames.structValue} as any);
+      } else if (message?.hasOwnProperty('${fieldNames.listValue}') && message?.${fieldNames.listValue} !== undefined) {
+        return ListValue.unwrap(message.${fieldNames.listValue});
+      } else if (message?.hasOwnProperty('${fieldNames.nullValue}') && message?.${fieldNames.nullValue} !== undefined) {
+        return null;
+      }
+      return undefined;
+    }`);
+    }
+    if ((0, types_1.isListValueTypeName)(fullProtoTypeName)) {
+        chunks.push((0, ts_poet_1.code) `unwrap(message: ${ctx.options.useReadonlyTypes ? "any" : "ListValue"}): Array<any> {
+      if (message?.hasOwnProperty('values') && Array.isArray(message.values)) {
+        return message.values.map(Value.unwrap);
+      } else {
+        return message as any;
+      }
+    }`);
+    }
+    if ((0, types_1.isFieldMaskTypeName)(fullProtoTypeName)) {
+        chunks.push((0, ts_poet_1.code) `unwrap(message: ${ctx.options.useReadonlyTypes ? "any" : "FieldMask"}): string[] {
+      return message.paths;
+    }`);
+    }
+    return chunks;
+}
+exports.generateUnwrapDeep = generateUnwrapDeep;
+/**
+ * Converts ts-proto's idiomatic Struct/Value/ListValue representation to the proto messages.
+ *
+ * We do this shallow's b/c ts-proto's encode methods handle the recursion.
+ */
+function generateWrapShallow(ctx, fullProtoTypeName, fieldNames) {
+    const chunks = [];
+    if ((0, types_1.isStructTypeName)(fullProtoTypeName)) {
+        let setStatement = "struct.fields[key] = object[key];";
+        if (ctx.options.useMapType) {
+            setStatement = "struct.fields.set(key, object[key]);";
+        }
+        chunks.push((0, ts_poet_1.code) `wrap(object: {[key: string]: any} | undefined): Struct {
+      const struct = createBaseStruct();
+      if (object !== undefined) {
+        Object.keys(object).forEach(key => {
+          ${setStatement}
+        });
+      }
+      return struct;
+    }`);
+    }
+    if ((0, types_1.isAnyValueTypeName)(fullProtoTypeName)) {
+        if (ctx.options.oneof === options_1.OneofOption.UNIONS) {
+            chunks.push((0, ts_poet_1.code) `wrap(value: any): Value {
+        const result = createBaseValue()${maybeAsAny(ctx.options)};
+        if (value === null) {
+          result.kind = {$case: '${fieldNames.nullValue}', ${fieldNames.nullValue}: NullValue.NULL_VALUE};
+        } else if (typeof value === 'boolean') {
+          result.kind = {$case: '${fieldNames.boolValue}', ${fieldNames.boolValue}: value};
+        } else if (typeof value === 'number') {
+          result.kind = {$case: '${fieldNames.numberValue}', ${fieldNames.numberValue}: value};
+        } else if (typeof value === 'string') {
+          result.kind = {$case: '${fieldNames.stringValue}', ${fieldNames.stringValue}: value};
+        } else if (Array.isArray(value)) {
+          result.kind = {$case: '${fieldNames.listValue}', ${fieldNames.listValue}: value};
+        } else if (typeof value === 'object') {
+          result.kind = {$case: '${fieldNames.structValue}', ${fieldNames.structValue}: value};
+        } else if (typeof value !== 'undefined') {
+          throw new Error('Unsupported any value type: ' + typeof value);
+        }
+        return result;
+    }`);
+        }
+        else {
+            chunks.push((0, ts_poet_1.code) `wrap(value: any): Value {
+        const result = createBaseValue()${maybeAsAny(ctx.options)};
+        if (value === null) {
+          result.${fieldNames.nullValue} = NullValue.NULL_VALUE;
+        } else if (typeof value === 'boolean') {
+          result.${fieldNames.boolValue} = value;
+        } else if (typeof value === 'number') {
+          result.${fieldNames.numberValue} = value;
+        } else if (typeof value === 'string') {
+          result.${fieldNames.stringValue} = value;
+        } else if (Array.isArray(value)) {
+          result.${fieldNames.listValue} = value;
+        } else if (typeof value === 'object') {
+          result.${fieldNames.structValue} = value;
+        } else if (typeof value !== 'undefined') {
+          throw new Error('Unsupported any value type: ' + typeof value);
+        }
+        return result;
+      }`);
+        }
+    }
+    if ((0, types_1.isListValueTypeName)(fullProtoTypeName)) {
+        const maybeReadyOnly = ctx.options.useReadonlyTypes ? "Readonly" : "";
+        chunks.push((0, ts_poet_1.code) `wrap(array: ${maybeReadyOnly}Array<any> | undefined): ListValue {
+      const result = createBaseListValue()${maybeAsAny(ctx.options)};
+      result.values = array ?? [];
+      return result;
+    }`);
+    }
+    if ((0, types_1.isFieldMaskTypeName)(fullProtoTypeName)) {
+        chunks.push((0, ts_poet_1.code) `wrap(paths: ${maybeReadonly(ctx.options)} string[]): FieldMask {
+      const result = createBaseFieldMask()${maybeAsAny(ctx.options)};
+      result.paths = paths;
+      return result;
+    }`);
+    }
+    return chunks;
+}
+exports.generateWrapShallow = generateWrapShallow;
+/**
+ * Converts proto's Struct/Value?listValue messages to ts-proto's idiomatic representation.
+ *
+ * We do this shallowly b/c ts-proto's decode methods handle recursion.
+ */
+function generateUnwrapShallow(ctx, fullProtoTypeName, fieldNames) {
+    const chunks = [];
+    if ((0, types_1.isStructTypeName)(fullProtoTypeName)) {
+        if (ctx.options.useMapType) {
+            chunks.push((0, ts_poet_1.code) `unwrap(message: Struct): {[key: string]: any} {
+        const object: { [key: string]: any } = {};
+        [...message.fields.keys()].forEach((key) => {
+          object[key] = message.fields.get(key);
+        });
+        return object;
+      }`);
+        }
+        else {
+            chunks.push((0, ts_poet_1.code) `unwrap(message: Struct): {[key: string]: any} {
+        const object: { [key: string]: any } = {};
+        if (message.fields) {
+          Object.keys(message.fields).forEach(key => {
+            object[key] = message.fields[key];
+          });
+        }
+        return object;
+      }`);
+        }
+    }
+    if ((0, types_1.isAnyValueTypeName)(fullProtoTypeName)) {
+        if (ctx.options.oneof === options_1.OneofOption.UNIONS) {
+            chunks.push((0, ts_poet_1.code) `unwrap(message: Value): string | number | boolean | Object | null | Array<any> | undefined {
+        if (message.kind?.$case === '${fieldNames.nullValue}') {
+          return null;
+        } else if (message.kind?.$case === '${fieldNames.numberValue}') {
+          return message.kind?.${fieldNames.numberValue};
+        } else if (message.kind?.$case === '${fieldNames.stringValue}') {
+          return message.kind?.${fieldNames.stringValue};
+        } else if (message.kind?.$case === '${fieldNames.boolValue}') {
+          return message.kind?.${fieldNames.boolValue};
+        } else if (message.kind?.$case === '${fieldNames.structValue}') {
+          return message.kind?.${fieldNames.structValue};
+        } else if (message.kind?.$case === '${fieldNames.listValue}') {
+          return message.kind?.${fieldNames.listValue};
+        } else {
+          return undefined;
+        }
+      }`);
+        }
+        else {
+            chunks.push((0, ts_poet_1.code) `unwrap(message: any): string | number | boolean | Object | null | Array<any> | undefined {
+        if (message.${fieldNames.stringValue} !== undefined) {
+          return message.${fieldNames.stringValue};
+        } else if (message?.${fieldNames.numberValue} !== undefined) {
+          return message.${fieldNames.numberValue};
+        } else if (message?.${fieldNames.boolValue} !== undefined) {
+          return message.${fieldNames.boolValue};
+        } else if (message?.${fieldNames.structValue} !== undefined) {
+          return message.${fieldNames.structValue} as any;
+        } else if (message?.${fieldNames.listValue} !== undefined) {
+          return message.${fieldNames.listValue};
+        } else if (message?.${fieldNames.nullValue} !== undefined) {
+          return null;
+        }
+        return undefined;
+      }`);
+        }
+    }
+    if ((0, types_1.isListValueTypeName)(fullProtoTypeName)) {
+        chunks.push((0, ts_poet_1.code) `unwrap(message: ${ctx.options.useReadonlyTypes ? "any" : "ListValue"}): Array<any> {
+      if (message?.hasOwnProperty('values') && Array.isArray(message.values)) {
+        return message.values;
+      } else {
+        return message as any;
+      }
+    }`);
+    }
+    if ((0, types_1.isFieldMaskTypeName)(fullProtoTypeName)) {
+        chunks.push((0, ts_poet_1.code) `unwrap(message: ${ctx.options.useReadonlyTypes ? "any" : "FieldMask"}): string[] {
+      return message.paths;
+    }`);
+    }
+    return chunks;
+}
+exports.generateUnwrapShallow = generateUnwrapShallow;
+function maybeReadonly(options) {
+    return options.useReadonlyTypes ? "readonly " : "";
+}
+function maybeAsAny(options) {
+    return options.useReadonlyTypes ? " as any" : "";
+}

package/build/main.js

@@ -18,6 +18,7 @@ const ConditionalOutput_1 = require("ts-poet/build/ConditionalOutput");
 const generate_grpc_js_1 = require("./generate-grpc-js");
 const generate_generic_service_definition_1 = require("./generate-generic-service-definition");
 const generate_nice_grpc_1 = require("./generate-nice-grpc");
+const generate_struct_wrappers_1 = require("./generate-struct-wrappers");
 function generateFile(ctx, fileDesc) {
     var _a;
     const { options, utils } = ctx;
@@ -72,11 +73,18 @@ function generateFile(ctx, fileDesc) {
             chunks.push(makeProtobufTimestampWrapper());
         }
     }
-    if (options.outputEncodeMethods || options.outputJsonMethods || options.outputTypeRegistry) {
+    // We add `nestJs` here because enough though it doesn't use our encode/decode methods
+    // for most/vanilla messages, we do generate static wrap/unwrap methods for the special
+    // Struct/Value/wrapper types and use the `wrappers[...]` to have NestJS know about them.
+    if (options.outputEncodeMethods || options.outputJsonMethods || options.outputTypeRegistry || options.nestJs) {
         // then add the encoder/decoder/base instance
         (0, visit_1.visit)(fileDesc, sourceInfo, (fullName, message, _sInfo, fullProtoTypeName) => {
             const fullTypeName = (0, utils_1.maybePrefixPackage)(fileDesc, fullProtoTypeName);
-            chunks.push(generateBaseInstanceFactory(ctx, fullName, message, fullTypeName));
+            const outputWrapAndUnwrap = (0, generate_struct_wrappers_1.isWrapperType)(fullTypeName);
+            // Only decode, fromPartial, and wrap use the createBase method
+            if (options.outputEncodeMethods || options.outputPartialMethods || outputWrapAndUnwrap) {
+                chunks.push(generateBaseInstanceFactory(ctx, fullName, message, fullTypeName));
+            }
             const staticMembers = [];
             if (options.outputTypeRegistry) {
                 staticMembers.push((0, ts_poet_1.code) `$type: '${fullTypeName}' as const`);
@@ -104,13 +112,21 @@ function generateFile(ctx, fileDesc) {
                 structValue: (0, case_1.maybeSnakeToCamel)("struct_value", ctx.options),
                 listValue: (0, case_1.maybeSnakeToCamel)("list_value", ctx.options),
             };
-            staticMembers.push(...generateWrap(ctx, fullTypeName, structFieldNames));
-            staticMembers.push(...generateUnwrap(ctx, fullTypeName, structFieldNames));
-            chunks.push((0, ts_poet_1.code) `
-          export const ${(0, ts_poet_1.def)(fullName)} = {
-            ${(0, ts_poet_1.joinCode)(staticMembers, { on: ",\n\n" })}
-          };
-        `);
+            if (options.nestJs) {
+                staticMembers.push(...(0, generate_struct_wrappers_1.generateWrapDeep)(ctx, fullTypeName, structFieldNames));
+                staticMembers.push(...(0, generate_struct_wrappers_1.generateUnwrapDeep)(ctx, fullTypeName, structFieldNames));
+            }
+            else {
+                staticMembers.push(...(0, generate_struct_wrappers_1.generateWrapShallow)(ctx, fullTypeName, structFieldNames));
+                staticMembers.push(...(0, generate_struct_wrappers_1.generateUnwrapShallow)(ctx, fullTypeName, structFieldNames));
+            }
+            if (staticMembers.length > 0) {
+                chunks.push((0, ts_poet_1.code) `
+            export const ${(0, ts_poet_1.def)(fullName)} = {
+              ${(0, ts_poet_1.joinCode)(staticMembers, { on: ",\n\n" })}
+            };
+          `);
+            }
             if (options.outputTypeRegistry) {
                 const messageTypeRegistry = (0, utils_1.impFile)(options, "messageTypeRegistry@./typeRegistry");
                 chunks.push((0, ts_poet_1.code) `
@@ -119,6 +135,11 @@ function generateFile(ctx, fileDesc) {
             }
         }, options);
     }
+    if (options.nestJs) {
+        if (fileDesc.messageType.find((message) => message.field.find(types_1.isStructType))) {
+            chunks.push(makeProtobufStructWrapper(options));
+        }
+    }
     let hasServerStreamingMethods = false;
     let hasStreamingMethods = false;
     (0, visit_1.visitServices)(fileDesc, sourceInfo, (serviceDesc, sInfo) => {
@@ -244,6 +265,15 @@ function makeProtobufTimestampWrapper() {
         },
       } as any;`;
 }
+function makeProtobufStructWrapper(options) {
+    const wrappers = (0, ts_poet_1.imp)("wrappers@protobufjs");
+    const Struct = (0, utils_1.impProto)(options, "google/protobuf/struct", "Struct");
+    return (0, ts_poet_1.code) `
+    ${wrappers}['.google.protobuf.Struct'] = {
+      fromObject: ${Struct}.wrap,
+      toObject: ${Struct}.unwrap,
+    } as any;`;
+}
 function makeLongUtils(options, bytes) {
     // Regardless of which `forceLong` config option we're using, we always use
     // the `long` library to either represent or at least sanity-check 64-bit values
@@ -771,6 +801,53 @@ function generateDecode(ctx, fullName, messageDesc) {
     chunks.push((0, ts_poet_1.code) `}`);
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
 }
+/** Returns a generic writer.doSomething based on the basic type */
+function getEncodeWriteSnippet(ctx, field) {
+    const { options, utils } = ctx;
+    if ((0, types_1.isEnum)(field) && options.stringEnums) {
+        const tag = ((field.number << 3) | (0, types_1.basicWireType)(field.type)) >>> 0;
+        const toNumber = (0, types_1.getEnumMethod)(ctx, field.typeName, "ToNumber");
+        return (place) => (0, ts_poet_1.code) `writer.uint32(${tag}).${(0, types_1.toReaderCall)(field)}(${toNumber}(${place}))`;
+    }
+    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())`;
+    }
+    else if ((0, types_1.isScalar)(field) || (0, types_1.isEnum)(field)) {
+        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})`;
+    }
+    else if ((0, types_1.isObjectId)(field) && options.useMongoObjectId) {
+        const tag = ((field.number << 3) | 2) >>> 0;
+        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+        return (place) => (0, ts_poet_1.code) `${type}.encode(${utils.toProtoObjectId}(${place}), writer.uint32(${tag}).fork()).ldelim()`;
+    }
+    else if ((0, types_1.isTimestamp)(field) && (options.useDate === options_1.DateOption.DATE || options.useDate === options_1.DateOption.STRING)) {
+        const tag = ((field.number << 3) | 2) >>> 0;
+        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+        return (place) => (0, ts_poet_1.code) `${type}.encode(${utils.toTimestamp}(${place}), writer.uint32(${tag}).fork()).ldelim()`;
+    }
+    else if ((0, types_1.isValueType)(ctx, field)) {
+        const maybeTypeField = options.outputTypeRegistry ? `$type: '${field.typeName.slice(1)}',` : "";
+        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+        const wrappedValue = (place) => {
+            if ((0, types_1.isAnyValueType)(field) || (0, types_1.isListValueType)(field) || (0, types_1.isStructType)(field) || (0, types_1.isFieldMaskType)(field)) {
+                return (0, ts_poet_1.code) `${type}.wrap(${place})`;
+            }
+            return (0, ts_poet_1.code) `{${maybeTypeField} value: ${place}!}`;
+        };
+        const tag = ((field.number << 3) | 2) >>> 0;
+        return (place) => (0, ts_poet_1.code) `${type}.encode(${wrappedValue(place)}, writer.uint32(${tag}).fork()).ldelim()`;
+    }
+    else if ((0, types_1.isMessage)(field)) {
+        const tag = ((field.number << 3) | 2) >>> 0;
+        const type = (0, types_1.basicTypeName)(ctx, field);
+        return (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer.uint32(${tag}).fork()).ldelim()`;
+    }
+    else {
+        throw new Error(`Unhandled field ${field}`);
+    }
+}
 /** Creates a function to encode a message by loop overing the tags. */
 function generateEncode(ctx, fullName, messageDesc) {
     const { options, utils, typeMap } = ctx;
@@ -783,54 +860,15 @@ function generateEncode(ctx, fullName, messageDesc) {
       writer: ${Writer} = ${Writer}.create(),
     ): ${Writer} {
   `);
+    const processedOneofs = new Set();
+    const oneOfFieldsDict = messageDesc.field
+        .filter((field) => (0, types_1.isWithinOneOfThatShouldBeUnion)(options, field))
+        .reduce((result, field) => ((result[field.oneofIndex] || (result[field.oneofIndex] = [])).push(field), result), {});
     // then add a case for each field
     messageDesc.field.forEach((field) => {
         const fieldName = (0, case_1.maybeSnakeToCamel)(field.name, options);
         // get a generic writer.doSomething based on the basic type
-        let writeSnippet;
-        if ((0, types_1.isEnum)(field) && options.stringEnums) {
-            const tag = ((field.number << 3) | (0, types_1.basicWireType)(field.type)) >>> 0;
-            const toNumber = (0, types_1.getEnumMethod)(ctx, field.typeName, "ToNumber");
-            writeSnippet = (place) => (0, ts_poet_1.code) `writer.uint32(${tag}).${(0, types_1.toReaderCall)(field)}(${toNumber}(${place}))`;
-        }
-        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;
-            writeSnippet = (place) => (0, ts_poet_1.code) `writer.uint32(${tag}).${(0, types_1.toReaderCall)(field)}(${place}.toString())`;
-        }
-        else if ((0, types_1.isScalar)(field) || (0, types_1.isEnum)(field)) {
-            const tag = ((field.number << 3) | (0, types_1.basicWireType)(field.type)) >>> 0;
-            writeSnippet = (place) => (0, ts_poet_1.code) `writer.uint32(${tag}).${(0, types_1.toReaderCall)(field)}(${place})`;
-        }
-        else if ((0, types_1.isObjectId)(field) && options.useMongoObjectId) {
-            const tag = ((field.number << 3) | 2) >>> 0;
-            const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-            writeSnippet = (place) => (0, ts_poet_1.code) `${type}.encode(${utils.toProtoObjectId}(${place}), writer.uint32(${tag}).fork()).ldelim()`;
-        }
-        else if ((0, types_1.isTimestamp)(field) && (options.useDate === options_1.DateOption.DATE || options.useDate === options_1.DateOption.STRING)) {
-            const tag = ((field.number << 3) | 2) >>> 0;
-            const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-            writeSnippet = (place) => (0, ts_poet_1.code) `${type}.encode(${utils.toTimestamp}(${place}), writer.uint32(${tag}).fork()).ldelim()`;
-        }
-        else if ((0, types_1.isValueType)(ctx, field)) {
-            const maybeTypeField = options.outputTypeRegistry ? `$type: '${field.typeName.slice(1)}',` : "";
-            const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-            const wrappedValue = (place) => {
-                if ((0, types_1.isAnyValueType)(field) || (0, types_1.isListValueType)(field) || (0, types_1.isStructType)(field) || (0, types_1.isFieldMaskType)(field)) {
-                    return (0, ts_poet_1.code) `${type}.wrap(${place})`;
-                }
-                return (0, ts_poet_1.code) `{${maybeTypeField} value: ${place}!}`;
-            };
-            const tag = ((field.number << 3) | 2) >>> 0;
-            writeSnippet = (place) => (0, ts_poet_1.code) `${type}.encode(${wrappedValue(place)}, writer.uint32(${tag}).fork()).ldelim()`;
-        }
-        else if ((0, types_1.isMessage)(field)) {
-            const tag = ((field.number << 3) | 2) >>> 0;
-            const type = (0, types_1.basicTypeName)(ctx, field);
-            writeSnippet = (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer.uint32(${tag}).fork()).ldelim()`;
-        }
-        else {
-            throw new Error(`Unhandled field ${field}`);
-        }
+        const writeSnippet = getEncodeWriteSnippet(ctx, field);
         const isOptional = (0, types_1.isOptionalProperty)(field, messageDesc.options, options);
         if ((0, types_1.isRepeated)(field)) {
             if ((0, types_1.isMapType)(ctx, messageDesc, field)) {
@@ -925,12 +963,19 @@ function generateEncode(ctx, fullName, messageDesc) {
             }
         }
         else if ((0, types_1.isWithinOneOfThatShouldBeUnion)(options, field)) {
-            let oneofName = (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[field.oneofIndex].name, options);
-            chunks.push((0, ts_poet_1.code) `
-        if (message.${oneofName}?.$case === '${fieldName}') {
-          ${writeSnippet(`message.${oneofName}.${fieldName}`)};
-        }
-      `);
+            if (!processedOneofs.has(field.oneofIndex)) {
+                processedOneofs.add(field.oneofIndex);
+                const oneofName = (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[field.oneofIndex].name, options);
+                chunks.push((0, ts_poet_1.code) `switch (message.${oneofName}?.$case) {`);
+                for (const oneOfField of oneOfFieldsDict[field.oneofIndex]) {
+                    const writeSnippet = getEncodeWriteSnippet(ctx, oneOfField);
+                    const oneOfFieldName = (0, case_1.maybeSnakeToCamel)(oneOfField.name, ctx.options);
+                    chunks.push((0, ts_poet_1.code) `case "${oneOfFieldName}": 
+            ${writeSnippet(`message.${oneofName}.${oneOfFieldName}`)}; 
+            break;`);
+                }
+                chunks.push((0, ts_poet_1.code) `}`);
+            }
         }
         else if ((0, types_1.isWithinOneOf)(field)) {
             // Oneofs don't have a default value check b/c they need to denote which-oneof presence
@@ -1553,164 +1598,6 @@ function generateFromPartial(ctx, fullName, messageDesc) {
     chunks.push((0, ts_poet_1.code) `}`);
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
 }
-function generateWrap(ctx, fullProtoTypeName, fieldNames) {
-    const chunks = [];
-    if ((0, types_1.isStructTypeName)(fullProtoTypeName)) {
-        let setStatement = "struct.fields[key] = object[key];";
-        if (ctx.options.useMapType) {
-            setStatement = "struct.fields.set(key, object[key]);";
-        }
-        chunks.push((0, ts_poet_1.code) `wrap(object: {[key: string]: any} | undefined): Struct {
-      const struct = createBaseStruct();
-      if (object !== undefined) {
-        Object.keys(object).forEach(key => {
-          ${setStatement}
-        });
-      }
-      return struct;
-    }`);
-    }
-    if ((0, types_1.isAnyValueTypeName)(fullProtoTypeName)) {
-        if (ctx.options.oneof === options_1.OneofOption.UNIONS) {
-            chunks.push((0, ts_poet_1.code) `wrap(value: any): Value {
-        const result = createBaseValue()${maybeAsAny(ctx.options)};
-
-        if (value === null) {
-          result.kind = {$case: '${fieldNames.nullValue}', ${fieldNames.nullValue}: NullValue.NULL_VALUE};
-        } else if (typeof value === 'boolean') {
-          result.kind = {$case: '${fieldNames.boolValue}', ${fieldNames.boolValue}: value};
-        } else if (typeof value === 'number') {
-          result.kind = {$case: '${fieldNames.numberValue}', ${fieldNames.numberValue}: value};
-        } else if (typeof value === 'string') {
-          result.kind = {$case: '${fieldNames.stringValue}', ${fieldNames.stringValue}: value};
-        } else if (Array.isArray(value)) {
-          result.kind = {$case: '${fieldNames.listValue}', ${fieldNames.listValue}: value};
-        } else if (typeof value === 'object') {
-          result.kind = {$case: '${fieldNames.structValue}', ${fieldNames.structValue}: value};
-        } else if (typeof value !== 'undefined') {
-          throw new Error('Unsupported any value type: ' + typeof value);
-        }
-
-        return result;
-    }`);
-        }
-        else {
-            chunks.push((0, ts_poet_1.code) `wrap(value: any): Value {
-        const result = createBaseValue()${maybeAsAny(ctx.options)};
-
-        if (value === null) {
-          result.${fieldNames.nullValue} = NullValue.NULL_VALUE;
-        } else if (typeof value === 'boolean') {
-          result.${fieldNames.boolValue} = value;
-        } else if (typeof value === 'number') {
-          result.${fieldNames.numberValue} = value;
-        } else if (typeof value === 'string') {
-          result.${fieldNames.stringValue} = value;
-        } else if (Array.isArray(value)) {
-          result.${fieldNames.listValue} = value;
-        } else if (typeof value === 'object') {
-          result.${fieldNames.structValue} = value;
-        } else if (typeof value !== 'undefined') {
-          throw new Error('Unsupported any value type: ' + typeof value);
-        }
-
-        return result;
-    }`);
-        }
-    }
-    if ((0, types_1.isListValueTypeName)(fullProtoTypeName)) {
-        chunks.push((0, ts_poet_1.code) `wrap(value: ${ctx.options.useReadonlyTypes ? "ReadonlyArray<any>" : "Array<any>"} | undefined): ListValue {
-      const result = createBaseListValue()${maybeAsAny(ctx.options)};
-
-      result.values = value ?? [];
-
-      return result;
-    }`);
-    }
-    if ((0, types_1.isFieldMaskTypeName)(fullProtoTypeName)) {
-        chunks.push((0, ts_poet_1.code) `wrap(paths: ${maybeReadonly(ctx.options)} string[]): FieldMask {
-      const result = createBaseFieldMask()${maybeAsAny(ctx.options)};
-
-      result.paths = paths;
-
-      return result;
-    }`);
-    }
-    return chunks;
-}
-function generateUnwrap(ctx, fullProtoTypeName, fieldNames) {
-    const chunks = [];
-    if ((0, types_1.isStructTypeName)(fullProtoTypeName)) {
-        if (ctx.options.useMapType) {
-            chunks.push((0, ts_poet_1.code) `unwrap(message: Struct): {[key: string]: any} {
-        const object: { [key: string]: any } = {};
-        [...message.fields.keys()].forEach((key) => {
-          object[key] = message.fields.get(key);
-        });
-        return object;
-      }`);
-        }
-        else {
-            chunks.push((0, ts_poet_1.code) `unwrap(message: Struct): {[key: string]: any} {
-        const object: { [key: string]: any } = {};
-        Object.keys(message.fields).forEach(key => {
-          object[key] = message.fields[key];     
-        });
-        return object;
-      }`);
-        }
-    }
-    if ((0, types_1.isAnyValueTypeName)(fullProtoTypeName)) {
-        if (ctx.options.oneof === options_1.OneofOption.UNIONS) {
-            chunks.push((0, ts_poet_1.code) `unwrap(message: Value): string | number | boolean | Object | null | Array<any> | undefined {
-        if (message.kind?.$case === '${fieldNames.nullValue}') {
-          return null;
-        } else if (message.kind?.$case === '${fieldNames.numberValue}') {
-          return message.kind?.${fieldNames.numberValue};
-        } else if (message.kind?.$case === '${fieldNames.stringValue}') {
-          return message.kind?.${fieldNames.stringValue};
-        } else if (message.kind?.$case === '${fieldNames.boolValue}') {
-          return message.kind?.${fieldNames.boolValue};
-        } else if (message.kind?.$case === '${fieldNames.structValue}') {
-          return message.kind?.${fieldNames.structValue};
-        } else if (message.kind?.$case === '${fieldNames.listValue}') {
-          return message.kind?.${fieldNames.listValue};
-        } else {
-          return undefined;
-        }
-      }`);
-        }
-        else {
-            chunks.push((0, ts_poet_1.code) `unwrap(message: Value): string | number | boolean | Object | null | Array<any> | undefined {
-        if (message?.${fieldNames.stringValue} !== undefined) {
-          return message.${fieldNames.stringValue};
-        } else if (message?.${fieldNames.numberValue} !== undefined) {
-          return message.${fieldNames.numberValue};
-        } else if (message?.${fieldNames.boolValue} !== undefined) {
-          return message.${fieldNames.boolValue};
-        } else if (message?.${fieldNames.structValue} !== undefined) {
-          return message.${fieldNames.structValue};
-        } else if (message?.${fieldNames.listValue} !== undefined) {
-            return message.${fieldNames.listValue};
-        } else if (message?.${fieldNames.nullValue} !== undefined) {
-          return null;
-        }
-        return undefined;
-      }`);
-        }
-    }
-    if ((0, types_1.isListValueTypeName)(fullProtoTypeName)) {
-        chunks.push((0, ts_poet_1.code) `unwrap(message: ${ctx.options.useReadonlyTypes ? "any" : "ListValue"}): Array<any> {
-      return message.values;
-    }`);
-    }
-    if ((0, types_1.isFieldMaskTypeName)(fullProtoTypeName)) {
-        chunks.push((0, ts_poet_1.code) `unwrap(message: ${ctx.options.useReadonlyTypes ? "any" : "FieldMask"}): string[] {
-      return message.paths;
-    }`);
-    }
-    return chunks;
-}
 exports.contextTypeVar = "Context extends DataLoaders";
 function maybeCastToNumber(ctx, messageDesc, field, variableName) {
     const { keyType } = (0, types_1.detectMapType)(ctx, messageDesc, field);

package/build/options.js

@@ -52,6 +52,7 @@ function defaultOptions() {
         outputTypeRegistry: false,
         stringEnums: false,
         constEnums: false,
+        removeEnumPrefix: false,
         enumsAsLiterals: false,
         outputClientImpl: true,
         outputServices: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "1.138.0",
+  "version": "1.140.0",
   "description": "",
   "main": "build/plugin.js",
   "repository": "github:stephenh/ts-proto",
@@ -28,8 +28,8 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "@grpc/grpc-js": "^1.2.12",
-    "@grpc/proto-loader": "^0.5.6",
+    "@grpc/grpc-js": "^1.3.0",
+    "@grpc/proto-loader": "^0.6.0",
     "@improbable-eng/grpc-web": "^0.14.0",
     "@improbable-eng/grpc-web-node-http-transport": "^0.14.0",
     "@nestjs/common": "^8.2.2",