ts-proto 1.145.0 → 1.146.0

package/README.markdown

@@ -461,7 +461,7 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=useJsonWireFormat=true`, the generated code will reflect the JSON representation of Protobuf messages.
 
-  Requires `onlyTypes=true`. Implies `useDate=string` and `stringEnums=true`. This option is to generate types that can be directly used with marshalling/unmarshalling Protobuf messages serialized as JSON.  
+  Requires `onlyTypes=true`. Implies `useDate=string` and `stringEnums=true`. This option is to generate types that can be directly used with marshalling/unmarshalling Protobuf messages serialized as JSON.
   You may also want to set `useOptionals=all`, as gRPC gateways are not required to send default value for scalar values.
 
 - With `--ts_proto_opt=useNumericEnumForJson=true`, the JSON converter (`toJSON`) will encode enum values as int, rather than a string literal.
@@ -502,6 +502,11 @@ Generated code will be placed in the Gradle build directory.
 
   by default this is enabled which would generate a type of `Box_Element_Image_Alignment`. By disabling this option the type that is generated would be `BoxElementImageAlignment`.
 
+- With `--ts_proto_opt=outputExtensions=true`, the generated code will include proto2 extensions
+
+  Extension encode/decode methods are compliant with the `outputEncodeMethods` option, and if `unknownFields=true`,
+  the `setExtension` and `getExtension` methods will be created for extendable messages, also compliant with `outputEncodeMethods` (setExtension = encode, getExtension = decode).
+
 ### NestJS Support
 
 We have a great way of working together with [nestjs](https://docs.nestjs.com/microservices/grpc). `ts-proto` generates `interfaces` and `decorators` for you controller, client. For more information see the [nestjs readme](NESTJS.markdown).

package/build/main.js

@@ -92,14 +92,26 @@ function generateFile(ctx, fileDesc) {
             if (options.outputTypeRegistry) {
                 staticMembers.push((0, ts_poet_1.code) `$type: '${fullTypeName}' as const`);
             }
+            if (options.outputExtensions) {
+                for (const extension of message.extension) {
+                    const { name, type, extensionInfo } = generateExtension(ctx, message, extension);
+                    staticMembers.push((0, ts_poet_1.code) `${name}: <${ctx.utils.Extension}<${type}>> ${extensionInfo}`);
+                }
+            }
             if (options.outputEncodeMethods) {
                 if (options.outputEncodeMethods === true ||
                     options.outputEncodeMethods === "encode-only" ||
                     options.outputEncodeMethods === "encode-no-creation") {
                     staticMembers.push(generateEncode(ctx, fullName, message));
+                    if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
+                        staticMembers.push(generateSetExtension(ctx, fullName));
+                    }
                 }
                 if (options.outputEncodeMethods === true || options.outputEncodeMethods === "decode-only") {
                     staticMembers.push(generateDecode(ctx, fullName, message));
+                    if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
+                        staticMembers.push(generateGetExtension(ctx, fullName));
+                    }
                 }
             }
             if (options.useAsyncIterable) {
@@ -144,6 +156,12 @@ function generateFile(ctx, fileDesc) {
             }
         }, options);
     }
+    if (options.outputExtensions) {
+        for (const extension of fileDesc.extension) {
+            const { name, type, extensionInfo } = generateExtension(ctx, undefined, extension);
+            chunks.push((0, ts_poet_1.code) `export const ${name}: ${ctx.utils.Extension}<${type}> = ${extensionInfo};`);
+        }
+    }
     if (options.nestJs) {
         if (fileDesc.messageType.find((message) => message.field.find(types_1.isStructType))) {
             chunks.push(makeProtobufStructWrapper(options));
@@ -256,6 +274,7 @@ function makeUtils(options) {
         ...makeComparisonUtils(),
         ...makeNiceGrpcServerStreamingMethodResult(),
         ...makeGrpcWebErrorClass(bytes),
+        ...makeExtensionClass(options),
     };
 }
 exports.makeUtils = makeUtils;
@@ -550,6 +569,22 @@ function makeGrpcWebErrorClass(bytes) {
     `);
     return { GrpcWebError };
 }
+function makeExtensionClass(options) {
+    const Reader = (0, utils_1.impFile)(options, "Reader@protobufjs/minimal");
+    const Writer = (0, utils_1.impFile)(options, "Writer@protobufjs/minimal");
+    const Extension = (0, ts_poet_1.conditionalOutput)("Extension", (0, ts_poet_1.code) `
+      export interface Extension <T> {
+        number: number;
+        tag: number;
+        singularTag?: number;
+        encode?: (message: T) => Uint8Array[];
+        decode?: (tag: number, input: Uint8Array[]) => T;
+        repeated: boolean;
+        packed: boolean;
+      }
+    `);
+    return { Extension };
+}
 // Create the interface with properties
 function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fullTypeName) {
     var _a;
@@ -661,6 +696,71 @@ function generateBaseInstanceFactory(ctx, fullName, messageDesc, fullTypeName) {
     }
   `;
 }
+function getDecodeReadSnippet(ctx, field) {
+    const { options, utils } = ctx;
+    let readSnippet;
+    if ((0, types_1.isPrimitive)(field)) {
+        readSnippet = (0, ts_poet_1.code) `reader.${(0, types_1.toReaderCall)(field)}()`;
+        if ((0, types_1.isBytes)(field)) {
+            if (options.env === options_1.EnvOption.NODE) {
+                readSnippet = (0, ts_poet_1.code) `${readSnippet} as Buffer`;
+            }
+        }
+        else if ((0, types_1.basicLongWireType)(field.type) !== undefined) {
+            if (options.forceLong === options_1.LongOption.LONG) {
+                readSnippet = (0, ts_poet_1.code) `${readSnippet} as Long`;
+            }
+            else if (options.forceLong === options_1.LongOption.STRING) {
+                readSnippet = (0, ts_poet_1.code) `${utils.longToString}(${readSnippet} as Long)`;
+            }
+            else if (options.forceLong === options_1.LongOption.BIGINT) {
+                readSnippet = (0, ts_poet_1.code) `${utils.longToBigint}(${readSnippet} as Long)`;
+            }
+            else {
+                readSnippet = (0, ts_poet_1.code) `${utils.longToNumber}(${readSnippet} as Long)`;
+            }
+        }
+        else if ((0, types_1.isEnum)(field)) {
+            if (options.stringEnums) {
+                const fromJson = (0, types_1.getEnumMethod)(ctx, field.typeName, "FromJSON");
+                readSnippet = (0, ts_poet_1.code) `${fromJson}(${readSnippet})`;
+            }
+            else {
+                readSnippet = (0, ts_poet_1.code) `${readSnippet} as any`;
+            }
+        }
+    }
+    else if ((0, types_1.isValueType)(ctx, field)) {
+        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+        const unwrap = (decodedValue) => {
+            if ((0, types_1.isListValueType)(field) || (0, types_1.isStructType)(field) || (0, types_1.isAnyValueType)(field) || (0, types_1.isFieldMaskType)(field)) {
+                return (0, ts_poet_1.code) `${type}.unwrap(${decodedValue})`;
+            }
+            return (0, ts_poet_1.code) `${decodedValue}.value`;
+        };
+        const decoder = (0, ts_poet_1.code) `${type}.decode(reader, reader.uint32())`;
+        readSnippet = (0, ts_poet_1.code) `${unwrap(decoder)}`;
+    }
+    else if ((0, types_1.isTimestamp)(field) && (options.useDate === options_1.DateOption.DATE || options.useDate === options_1.DateOption.STRING)) {
+        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+        readSnippet = (0, ts_poet_1.code) `${utils.fromTimestamp}(${type}.decode(reader, reader.uint32()))`;
+    }
+    else if ((0, types_1.isObjectId)(field) && options.useMongoObjectId) {
+        const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+        readSnippet = (0, ts_poet_1.code) `${utils.fromProtoObjectId}(${type}.decode(reader, reader.uint32()))`;
+    }
+    else if ((0, types_1.isMessage)(field)) {
+        const type = (0, types_1.basicTypeName)(ctx, field);
+        if (field.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP)
+            readSnippet = (0, ts_poet_1.code) `${type}.decode(reader)`;
+        else
+            readSnippet = (0, ts_poet_1.code) `${type}.decode(reader, reader.uint32())`;
+    }
+    else {
+        throw new Error(`Unhandled field ${field}`);
+    }
+    return readSnippet;
+}
 /** Creates a function to decode a message by loop overing the tags. */
 function generateDecode(ctx, fullName, messageDesc) {
     const { options, utils, typeMap } = ctx;
@@ -696,67 +796,7 @@ function generateDecode(ctx, fullName, messageDesc) {
         break;
     `;
         // get a generic 'reader.doSomething' bit that is specific to the basic type
-        let readSnippet;
-        if ((0, types_1.isPrimitive)(field)) {
-            readSnippet = (0, ts_poet_1.code) `reader.${(0, types_1.toReaderCall)(field)}()`;
-            if ((0, types_1.isBytes)(field)) {
-                if (options.env === options_1.EnvOption.NODE) {
-                    readSnippet = (0, ts_poet_1.code) `${readSnippet} as Buffer`;
-                }
-            }
-            else if ((0, types_1.basicLongWireType)(field.type) !== undefined) {
-                if (options.forceLong === options_1.LongOption.LONG) {
-                    readSnippet = (0, ts_poet_1.code) `${readSnippet} as Long`;
-                }
-                else if (options.forceLong === options_1.LongOption.STRING) {
-                    readSnippet = (0, ts_poet_1.code) `${utils.longToString}(${readSnippet} as Long)`;
-                }
-                else if (options.forceLong === options_1.LongOption.BIGINT) {
-                    readSnippet = (0, ts_poet_1.code) `${utils.longToBigint}(${readSnippet} as Long)`;
-                }
-                else {
-                    readSnippet = (0, ts_poet_1.code) `${utils.longToNumber}(${readSnippet} as Long)`;
-                }
-            }
-            else if ((0, types_1.isEnum)(field)) {
-                if (options.stringEnums) {
-                    const fromJson = (0, types_1.getEnumMethod)(ctx, field.typeName, "FromJSON");
-                    readSnippet = (0, ts_poet_1.code) `${fromJson}(${readSnippet})`;
-                }
-                else {
-                    readSnippet = (0, ts_poet_1.code) `${readSnippet} as any`;
-                }
-            }
-        }
-        else if ((0, types_1.isValueType)(ctx, field)) {
-            const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-            const unwrap = (decodedValue) => {
-                if ((0, types_1.isListValueType)(field) || (0, types_1.isStructType)(field) || (0, types_1.isAnyValueType)(field) || (0, types_1.isFieldMaskType)(field)) {
-                    return (0, ts_poet_1.code) `${type}.unwrap(${decodedValue})`;
-                }
-                return (0, ts_poet_1.code) `${decodedValue}.value`;
-            };
-            const decoder = (0, ts_poet_1.code) `${type}.decode(reader, reader.uint32())`;
-            readSnippet = (0, ts_poet_1.code) `${unwrap(decoder)}`;
-        }
-        else if ((0, types_1.isTimestamp)(field) && (options.useDate === options_1.DateOption.DATE || options.useDate === options_1.DateOption.STRING)) {
-            const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-            readSnippet = (0, ts_poet_1.code) `${utils.fromTimestamp}(${type}.decode(reader, reader.uint32()))`;
-        }
-        else if ((0, types_1.isObjectId)(field) && options.useMongoObjectId) {
-            const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
-            readSnippet = (0, ts_poet_1.code) `${utils.fromProtoObjectId}(${type}.decode(reader, reader.uint32()))`;
-        }
-        else if ((0, types_1.isMessage)(field)) {
-            const type = (0, types_1.basicTypeName)(ctx, field);
-            if (field.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP)
-                readSnippet = (0, ts_poet_1.code) `${type}.decode(reader)`;
-            else
-                readSnippet = (0, ts_poet_1.code) `${type}.decode(reader, reader.uint32())`;
-        }
-        else {
-            throw new Error(`Unhandled field ${field}`);
-        }
+        const readSnippet = getDecodeReadSnippet(ctx, field);
         // and then use the snippet to handle repeated fields if necessary
         const initializerNecessary = !options.initializeFieldsAsUndefined && (0, types_1.isOptionalProperty)(field, messageDesc.options, options);
         if ((0, types_1.isRepeated)(field)) {
@@ -1099,6 +1139,226 @@ function generateEncode(ctx, fullName, messageDesc) {
     chunks.push((0, ts_poet_1.code) `}`);
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
 }
+function generateSetExtension(ctx, fullName) {
+    return (0, ts_poet_1.code) `
+    setExtension <T> (message: ${fullName}, extension: ${ctx.utils.Extension}<T>, value: T): void {
+      const encoded = extension.encode!(value);
+
+      if (message._unknownFields !== undefined){
+        delete message._unknownFields[extension.tag];
+
+        if (extension.singularTag !== undefined) {
+          delete message._unknownFields[extension.singularTag];
+        }
+      }
+
+      if (encoded.length !== 0) {
+        if (message._unknownFields === undefined) {
+          message._unknownFields = {};
+        }
+
+        message._unknownFields[extension.tag] = encoded;
+      }
+    }
+  `;
+}
+function generateGetExtension(ctx, fullName) {
+    return (0, ts_poet_1.code) `
+    getExtension <T> (message: ${fullName}, extension: ${ctx.utils.Extension}<T>): T | undefined {
+      let results: T | undefined = undefined;
+
+      if (message._unknownFields === undefined) {
+        return undefined;
+      }
+
+      let list = message._unknownFields[extension.tag];
+
+      if (list !== undefined) {
+        results = extension.decode!(extension.tag, list);
+      }
+
+      if (extension.singularTag === undefined) {
+        return results;
+      }
+
+      list = message._unknownFields[extension.singularTag];
+
+      if (list !== undefined) {
+        const results2 = extension.decode!(extension.singularTag, list);
+
+        if (results !== undefined && (results as any).length !== 0) {
+          results = (results as any).concat(results2);
+        } else {
+          results = results2;
+        }
+      }
+
+      return results;
+    }
+  `;
+}
+function generateExtension(ctx, message, extension) {
+    var _a;
+    const type = (0, types_1.toTypeName)(ctx, message, extension);
+    const packedTag = (0, types_1.isRepeated)(extension) && (0, types_1.packedType)(extension.type) !== undefined ? ((extension.number << 3) | 2) >>> 0 : undefined;
+    const singularTag = ((extension.number << 3) | (0, types_1.basicWireType)(extension.type)) >>> 0;
+    const tag = packedTag !== null && packedTag !== void 0 ? packedTag : singularTag;
+    const chunks = [];
+    chunks.push((0, ts_poet_1.code) `{`);
+    chunks.push((0, ts_poet_1.code) `number: ${extension.number},`);
+    chunks.push((0, ts_poet_1.code) `tag: ${tag},`);
+    if (packedTag !== undefined)
+        chunks.push((0, ts_poet_1.code) `singularTag: ${singularTag},`);
+    chunks.push((0, ts_poet_1.code) `repeated: ${extension.label == ts_proto_descriptors_1.FieldDescriptorProto_Label.LABEL_REPEATED},`);
+    chunks.push((0, ts_poet_1.code) `packed: ${((_a = extension.options) === null || _a === void 0 ? void 0 : _a.packed) ? true : false},`);
+    const Reader = (0, utils_1.impFile)(ctx.options, "Reader@protobufjs/minimal");
+    const Writer = (0, utils_1.impFile)(ctx.options, "Writer@protobufjs/minimal");
+    if (ctx.options.outputEncodeMethods === true ||
+        ctx.options.outputEncodeMethods === "encode-only" ||
+        ctx.options.outputEncodeMethods === "encode-no-creation") {
+        chunks.push((0, ts_poet_1.code) `
+      encode: (value: ${type}): Uint8Array[] => {
+        const encoded: Uint8Array[] = [];
+    `);
+        function getEncodeSnippet(ctx, field) {
+            const { options, utils } = ctx;
+            if ((0, types_1.isEnum)(field) && options.stringEnums) {
+                const toNumber = (0, types_1.getEnumMethod)(ctx, field.typeName, "ToNumber");
+                return (place) => (0, ts_poet_1.code) `writer.${(0, types_1.toReaderCall)(field)}(${toNumber}(${place}))`;
+            }
+            else if ((0, types_1.isLong)(field) && options.forceLong === options_1.LongOption.BIGINT) {
+                return (place) => (0, ts_poet_1.code) `writer.${(0, types_1.toReaderCall)(field)}(${place}.toString())`;
+            }
+            else if ((0, types_1.isScalar)(field) || (0, types_1.isEnum)(field)) {
+                return (place) => (0, ts_poet_1.code) `writer.${(0, types_1.toReaderCall)(field)}(${place})`;
+            }
+            else if ((0, types_1.isObjectId)(field) && options.useMongoObjectId) {
+                const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+                return (place) => (0, ts_poet_1.code) `${type}.encode(${utils.toProtoObjectId}(${place}), writer.fork()).ldelim()`;
+            }
+            else if ((0, types_1.isTimestamp)(field) && (options.useDate === options_1.DateOption.DATE || options.useDate === options_1.DateOption.STRING)) {
+                const type = (0, types_1.basicTypeName)(ctx, field, { keepValueType: true });
+                return (place) => (0, ts_poet_1.code) `${type}.encode(${utils.toTimestamp}(${place}), writer.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}!}`;
+                };
+                return (place) => (0, ts_poet_1.code) `${type}.encode(${wrappedValue(place)}, writer.fork()).ldelim()`;
+            }
+            else if ((0, types_1.isMessage)(field)) {
+                const type = (0, types_1.basicTypeName)(ctx, field);
+                if (field.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP) {
+                    const endTag = ((field.number << 3) | 4) >>> 0;
+                    return (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer).uint32(${endTag})`;
+                }
+                return (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer.fork()).ldelim()`;
+            }
+            else {
+                throw new Error(`Unhandled field ${field}`);
+            }
+        }
+        const writeSnippet = getEncodeSnippet(ctx, extension);
+        if ((0, types_1.isRepeated)(extension)) {
+            if (packedTag === undefined) {
+                chunks.push((0, ts_poet_1.code) `
+          for (const v of value) {
+            const writer = ${Writer}.create();
+            ${writeSnippet("v")};
+            encoded.push(writer.finish());
+          }
+        `);
+            }
+            else {
+                const rhs = (x) => (0, types_1.isLong)(extension) && ctx.options.forceLong === options_1.LongOption.BIGINT ? `${x}.toString()` : x;
+                chunks.push((0, ts_poet_1.code) `
+          const writer = ${Writer}.create();
+          writer.fork();
+          for (const v of value) {
+            ${writeSnippet(rhs("v"))};
+          }
+          writer.ldelim();
+          encoded.push(writer.finish());
+        `);
+            }
+        }
+        else if ((0, types_1.isScalar)(extension) || (0, types_1.isEnum)(extension)) {
+            chunks.push((0, ts_poet_1.code) `
+        if (${(0, types_1.notDefaultCheck)(ctx, extension, message === null || message === void 0 ? void 0 : message.options, "value")}) {
+          const writer = ${Writer}.create();
+          ${writeSnippet("value")};
+          encoded.push(writer.finish());
+        }
+      `);
+        }
+        else {
+            chunks.push((0, ts_poet_1.code) `
+        const writer = ${Writer}.create();
+        ${writeSnippet("value")};
+        encoded.push(writer.finish());
+      `);
+        }
+        chunks.push((0, ts_poet_1.code) `
+        return encoded;
+      },
+    `);
+    }
+    if (ctx.options.outputEncodeMethods === true || ctx.options.outputEncodeMethods === "decode-only") {
+        chunks.push((0, ts_poet_1.code) `decode: (tag: number, input: Uint8Array[]): ${type} => {`);
+        // get a generic 'reader.doSomething' bit that is specific to the basic type
+        const readSnippet = getDecodeReadSnippet(ctx, extension);
+        if ((0, types_1.isRepeated)(extension)) {
+            chunks.push((0, ts_poet_1.code) `const values: ${type} = [];`);
+            // start loop over all buffers
+            chunks.push((0, ts_poet_1.code) `
+        for (var buffer of input) {
+          const reader = ${Reader}.create(buffer);
+      `);
+            if ((0, types_1.packedType)(extension.type) === undefined) {
+                chunks.push((0, ts_poet_1.code) `
+          values.push(${readSnippet});
+        `);
+            }
+            else {
+                chunks.push((0, ts_poet_1.code) `
+          if(tag == ${packedTag}){
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              values.push(${readSnippet});
+            }
+          }else{
+            values.push(${readSnippet});
+          }
+        `);
+            }
+            chunks.push((0, ts_poet_1.code) `
+          }
+
+          return values;
+        },
+      `);
+        }
+        else {
+            // pick the last entry, since it overrides all previous entries if not repeated
+            chunks.push((0, ts_poet_1.code) `
+          const reader = ${Reader}.create(input[input.length -1]);
+          return ${readSnippet};
+        },
+      `);
+        }
+    }
+    chunks.push((0, ts_poet_1.code) `}`);
+    return {
+        name: (0, case_1.maybeSnakeToCamel)(extension.name, ctx.options),
+        type,
+        extensionInfo: (0, ts_poet_1.joinCode)(chunks, { on: "\n" }),
+    };
+}
 /**
  * Creates a function to decode a message from JSON.
  *

package/build/options.js

@@ -78,6 +78,7 @@ function defaultOptions() {
         useMapType: false,
         useReadonlyTypes: false,
         useSnakeTypeName: true,
+        outputExtensions: false,
         M: {},
     };
 }

package/build/types.js

@@ -578,7 +578,7 @@ exports.getEnumMethod = getEnumMethod;
 function toTypeName(ctx, messageDesc, field) {
     let type = basicTypeName(ctx, field, { keepValueType: false });
     if (isRepeated(field)) {
-        const mapType = detectMapType(ctx, messageDesc, field);
+        const mapType = messageDesc ? detectMapType(ctx, messageDesc, field) : false;
         if (mapType) {
             const { keyType, valueType } = mapType;
             if (ctx.options.useMapType) {

package/package.json

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