ts-proto 1.142.1 → 1.144.0

package/build/main.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.contextTypeVar = exports.makeUtils = exports.generateFile = void 0;
 const ts_poet_1 = require("ts-poet");
+const ts_proto_descriptors_1 = require("ts-proto-descriptors");
 const types_1 = require("./types");
 const sourceInfo_1 = require("./sourceInfo");
 const utils_1 = require("./utils");
@@ -579,6 +580,9 @@ function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fu
         const q = (0, types_1.isOptionalProperty)(fieldDesc, messageDesc.options, options) ? "?" : "";
         chunks.push((0, ts_poet_1.code) `${maybeReadonly(options)}${name}${q}: ${type}, `);
     });
+    if (ctx.options.unknownFields) {
+        chunks.push((0, ts_poet_1.code) `_unknownFields?: {[key: number]: Uint8Array[]},`);
+    }
     chunks.push((0, ts_poet_1.code) `}`);
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
 }
@@ -648,6 +652,9 @@ function generateBaseInstanceFactory(ctx, fullName, messageDesc, fullTypeName) {
     if (ctx.options.outputTypeRegistry) {
         fields.unshift((0, ts_poet_1.code) `$type: '${fullTypeName}'`);
     }
+    if (ctx.options.unknownFields && ctx.options.initializeFieldsAsUndefined) {
+        fields.push((0, ts_poet_1.code) `_unknownFields: {}`);
+    }
     return (0, ts_poet_1.code) `
     function createBase${fullName}(): ${fullName} {
       return { ${(0, ts_poet_1.joinCode)(fields, { on: "," })} };
@@ -673,9 +680,6 @@ function generateDecode(ctx, fullName, messageDesc) {
       let end = length === undefined ? reader.len : reader.pos + length;
   `);
     chunks.push((0, ts_poet_1.code) `const message = ${createBase}${maybeAsAny(options)};`);
-    if (options.unknownFields) {
-        chunks.push((0, ts_poet_1.code) `(message as any)._unknownFields = {}`);
-    }
     // start the tag loop
     chunks.push((0, ts_poet_1.code) `
     while (reader.pos < end) {
@@ -686,6 +690,11 @@ function generateDecode(ctx, fullName, messageDesc) {
     messageDesc.field.forEach((field) => {
         const fieldName = (0, case_1.maybeSnakeToCamel)(field.name, options);
         chunks.push((0, ts_poet_1.code) `case ${field.number}:`);
+        const tag = ((field.number << 3) | (0, types_1.basicWireType)(field.type)) >>> 0;
+        const tagCheck = (0, ts_poet_1.code) `
+      if(tag != ${tag})
+        break;
+    `;
         // get a generic 'reader.doSomething' bit that is specific to the basic type
         let readSnippet;
         if ((0, types_1.isPrimitive)(field)) {
@@ -740,12 +749,16 @@ function generateDecode(ctx, fullName, messageDesc) {
         }
         else if ((0, types_1.isMessage)(field)) {
             const type = (0, types_1.basicTypeName)(ctx, field);
-            readSnippet = (0, ts_poet_1.code) `${type}.decode(reader, reader.uint32())`;
+            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}`);
         }
         // 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)) {
             const maybeNonNullAssertion = ctx.options.useOptionals === "all" ? "!" : "";
             if ((0, types_1.isMapType)(ctx, messageDesc, field)) {
@@ -754,56 +767,107 @@ function generateDecode(ctx, fullName, messageDesc) {
                 const valueSetterSnippet = ctx.options.useMapType
                     ? `message.${fieldName}${maybeNonNullAssertion}.set(${varName}.key, ${varName}.value)`
                     : `message.${fieldName}${maybeNonNullAssertion}[${varName}.key] = ${varName}.value`;
+                const initializerSnippet = initializerNecessary
+                    ? `
+            if(message.${fieldName} === undefined)
+              message.${fieldName} = ${ctx.options.useMapType ? "new Map()" : "{}"};
+            `
+                    : "";
                 chunks.push((0, ts_poet_1.code) `
+          ${tagCheck}
           const ${varName} = ${readSnippet};
           if (${varName}.value !== undefined) {
+            ${initializerSnippet}
             ${valueSetterSnippet};
           }
         `);
             }
-            else if ((0, types_1.packedType)(field.type) === undefined) {
-                chunks.push((0, ts_poet_1.code) `message.${fieldName}${maybeNonNullAssertion}.push(${readSnippet});`);
-            }
             else {
-                chunks.push((0, ts_poet_1.code) `
-          if ((tag & 7) === 2) {
-            const end2 = reader.uint32() + reader.pos;
-            while (reader.pos < end2) {
+                const initializerSnippet = initializerNecessary
+                    ? `if(message.${fieldName} === undefined)
+              message.${fieldName} = [];`
+                    : "";
+                if ((0, types_1.packedType)(field.type) === undefined) {
+                    chunks.push((0, ts_poet_1.code) `
+            ${tagCheck}
+            ${initializerSnippet}
+            message.${fieldName}${maybeNonNullAssertion}.push(${readSnippet});
+          `);
+                }
+                else {
+                    const packedTag = ((field.number << 3) | 2) >>> 0;
+                    chunks.push((0, ts_poet_1.code) `
+            if(tag == ${tag}){
+              ${initializerSnippet}
               message.${fieldName}${maybeNonNullAssertion}.push(${readSnippet});
+              continue;
+            }
+
+            if(tag == ${packedTag}){
+              ${initializerSnippet}
+              const end2 = reader.uint32() + reader.pos;
+              while (reader.pos < end2) {
+                message.${fieldName}${maybeNonNullAssertion}.push(${readSnippet});
+              }
+
+              continue;
             }
-          } else {
-            message.${fieldName}${maybeNonNullAssertion}.push(${readSnippet});
-          }
-        `);
+
+            break;
+          `);
+                }
             }
         }
         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) `message.${oneofName} = { $case: '${fieldName}', ${fieldName}: ${readSnippet} };`);
+            chunks.push((0, ts_poet_1.code) `
+        ${tagCheck}
+        message.${oneofName} = { $case: '${fieldName}', ${fieldName}: ${readSnippet} };
+      `);
         }
         else {
-            chunks.push((0, ts_poet_1.code) `message.${fieldName} = ${readSnippet};`);
+            chunks.push((0, ts_poet_1.code) `
+        ${tagCheck}
+        message.${fieldName} = ${readSnippet};
+      `);
         }
-        chunks.push((0, ts_poet_1.code) `break;`);
+        if (!(0, types_1.isRepeated)(field) || (0, types_1.packedType)(field.type) === undefined)
+            chunks.push((0, ts_poet_1.code) `continue;`);
     });
+    chunks.push((0, ts_poet_1.code) `}`);
+    chunks.push((0, ts_poet_1.code) `
+      if((tag & 7) == 4 || tag == 0)
+        break;
+  `);
     if (options.unknownFields) {
+        let unknownFieldsInitializerSnippet = "";
+        let maybeNonNullAssertion = options.initializeFieldsAsUndefined ? "!" : "";
+        if (!options.initializeFieldsAsUndefined) {
+            unknownFieldsInitializerSnippet = `
+        if(message._unknownFields === undefined)
+          message._unknownFields = {};
+      `;
+        }
         chunks.push((0, ts_poet_1.code) `
-      default:
-        const startPos = reader.pos;
-        reader.skipType(tag & 7);
-        (message as any)._unknownFields[tag] = [...((message as any)._unknownFields[tag] || []), reader.buf.slice(startPos, reader.pos)];
-        break;
+      const startPos = reader.pos;
+      reader.skipType(tag & 7);
+      const buf = reader.buf.slice(startPos, reader.pos);
+
+      ${unknownFieldsInitializerSnippet}
+      const list = message._unknownFields${maybeNonNullAssertion}[tag];
+
+      if(list === undefined)
+        message._unknownFields${maybeNonNullAssertion}[tag] = [buf];
+      else
+        list.push(buf);
     `);
     }
     else {
         chunks.push((0, ts_poet_1.code) `
-      default:
         reader.skipType(tag & 7);
-        break;
     `);
     }
-    // and then wrap up the switch/while/return
-    chunks.push((0, ts_poet_1.code) `}`);
+    // and then wrap up the while/return
     chunks.push((0, ts_poet_1.code) `}`);
     chunks.push((0, ts_poet_1.code) `return message;`);
     chunks.push((0, ts_poet_1.code) `}`);
@@ -848,8 +912,12 @@ function getEncodeWriteSnippet(ctx, field) {
         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);
+        if (field.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP) {
+            const startTag = ((field.number << 3) | 3) >>> 0, endTag = ((field.number << 3) | 4) >>> 0;
+            return (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer.uint32(${startTag})).uint32(${endTag})`;
+        }
+        const tag = ((field.number << 3) | 2) >>> 0;
         return (place) => (0, ts_poet_1.code) `${type}.encode(${place}, writer.uint32(${tag}).fork()).ldelim()`;
     }
     else {
@@ -978,8 +1046,8 @@ function generateEncode(ctx, fullName, messageDesc) {
                 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}`)}; 
+                    chunks.push((0, ts_poet_1.code) `case "${oneOfFieldName}":
+            ${writeSnippet(`message.${oneofName}.${oneOfFieldName}`)};
             break;`);
                 }
                 chunks.push((0, ts_poet_1.code) `}`);
@@ -1012,12 +1080,12 @@ function generateEncode(ctx, fullName, messageDesc) {
         }
     });
     if (options.unknownFields) {
-        chunks.push((0, ts_poet_1.code) `if ('_unknownFields' in message) {
-      const msgUnknownFields: any = (message as any)['_unknownFields']
-      for (const key of Object.keys(msgUnknownFields)) {
-        const values = msgUnknownFields[key] as Uint8Array[];
+        chunks.push((0, ts_poet_1.code) `if (message._unknownFields !== undefined) {
+      for (const key in message._unknownFields) {
+        const values = message._unknownFields[key];
+        const tag = parseInt(key, 10);
         for (const value of values) {
-          writer.uint32(parseInt(key, 10));
+          writer.uint32(tag);
           (writer as any)['_push'](
             (val: Uint8Array, buf: Buffer, pos: number) => buf.set(val, pos),
             value.length,

package/build/types.js

@@ -34,7 +34,10 @@ function basicWireType(type) {
             return 0;
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_STRING:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_BYTES:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE:
             return 2;
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP:
+            return 3;
         default:
             throw new Error("Invalid type " + type);
     }
@@ -85,6 +88,7 @@ function basicTypeName(ctx, field, typeOptions = {}) {
                 return (0, ts_poet_1.code) `Uint8Array`;
             }
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP:
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_ENUM:
             return messageToTypeName(ctx, field.typeName, { ...typeOptions, repeated: isRepeated(field) });
         default:
@@ -225,6 +229,7 @@ function defaultValue(ctx, field) {
                 return "new Uint8Array()";
             }
         case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE:
+        case ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP:
         default:
             return "undefined";
     }
@@ -350,7 +355,7 @@ function isBytes(field) {
 }
 exports.isBytes = isBytes;
 function isMessage(field) {
-    return field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE;
+    return field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE || field.type === ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_GROUP;
 }
 exports.isMessage = isMessage;
 function isEnum(field) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "1.142.1",
+  "version": "1.144.0",
   "description": "",
   "main": "build/plugin.js",
   "repository": "github:stephenh/ts-proto",
@@ -33,7 +33,7 @@
     "@improbable-eng/grpc-web": "^0.14.0",
     "@improbable-eng/grpc-web-node-http-transport": "^0.14.0",
     "@nestjs/common": "^8.2.2",
-    "@nestjs/core": "^8.2.2",
+    "@nestjs/core": "^9.0.5",
     "@nestjs/microservices": "^8.2.2",
     "@semantic-release/changelog": "^5.0.1",
     "@semantic-release/commit-analyzer": "^8.0.1",