ts-proto 2.1.0 → 2.2.1

package/README.markdown

@@ -118,7 +118,7 @@ plugins:
     path: ../node_modules/ts-proto/protoc-gen-ts_proto
 ```
 
-To prevent `buf push` from reading irrelevent `.proto` files, configure `buf.yaml` like so:
+To prevent `buf push` from reading irrelevant `.proto` files, configure `buf.yaml` like so:
 
 ```yaml
 build:
@@ -150,7 +150,7 @@ In terms of the code that `ts-proto` generates, the general goals are:
 
 - Idiomatic TypeScript/ES6 types
   - `ts-proto` is a clean break from either the built-in Google/Java-esque JS code of `protoc` or the "make `.d.ts` files the `*.js` comments" approach of `protobufjs`
-  - (Techically the `protobufjs/minimal` package is used for actually reading/writing bytes.)
+  - (Technically the `protobufjs/minimal` package is used for actually reading/writing bytes.)
 - TypeScript-first output
 - Interfaces over classes
   - As much as possible, types are just interfaces, so you can work with messages just like regular hashes/data structures.
@@ -248,7 +248,7 @@ creating a class and calling the right getters/setters.
 
 (Note: this is currently only supported by the Twirp clients.)
 
-If you're using ts-proto's clients to call backend micro-services, similar to the N+1 problem in SQL applications, it is easy for micro-service clients to (when serving an individual request) inadvertantly trigger multiple separate RPC calls for "get book 1", "get book 2", "get book 3", that should really be batched into a single "get books [1, 2, 3]" (assuming the backend supports a batch-oriented RPC method).
+If you're using ts-proto's clients to call backend micro-services, similar to the N+1 problem in SQL applications, it is easy for micro-service clients to (when serving an individual request) inadvertently trigger multiple separate RPC calls for "get book 1", "get book 2", "get book 3", that should really be batched into a single "get books [1, 2, 3]" (assuming the backend supports a batch-oriented RPC method).
 
 ts-proto can help with this, and essentially auto-batch your individual "get book" calls into batched "get books" calls.
 
@@ -262,7 +262,7 @@ For ts-proto to do this, you need to implement your service's RPC methods with t
 
 When ts-proto recognizes methods of this pattern, it will automatically create a "non-batch" version of `<OperationName>` for the client, i.e. `client.Get<OperationName>`, that takes a single id and returns a single result.
 
-This provides the client code with the illusion that it can make individual `Get<OperationName>` calls (which is generally preferrable/easier when implementing the client's business logic), but the actual implementation that ts-proto provides will end up making `Batch<OperationName>` calls to the backend service.
+This provides the client code with the illusion that it can make individual `Get<OperationName>` calls (which is generally preferable/easier when implementing the client's business logic), but the actual implementation that ts-proto provides will end up making `Batch<OperationName>` calls to the backend service.
 
 You also need to enable the `useContext=true` build-time parameter, which gives all client methods a Go-style `ctx` parameter, with a `getDataLoaders` method that lets ts-proto cache/resolve request-scoped [DataLoaders](https://github.com/graphql/dataloader), which provide the fundamental auto-batch detection/flushing behavior.
 
@@ -325,7 +325,7 @@ Generated code will be placed in the Gradle build directory.
 
   The default behavior is `forceLong=number`, which will internally still use the `long` library to encode/decode values on the wire (so you will still see a `util.Long = Long` line in your output), but will convert the `long` values to `number` automatically for you. Note that a runtime error is thrown if, while doing this conversion, a 64-bit value is larger than can be correctly stored as a `number`.
 
-- With `--ts_proto_opt=useJsTypeOverride`, 64-bit numbers will be ouput as the [FieldOption.JSType](https://protobuf.dev/reference/java/api-docs/com/google/protobuf/DescriptorProtos.FieldOptions.JSType) specified on the field. This takes precendence over the `forceLong` option provided.
+- With `--ts_proto_opt=useJsTypeOverride`, 64-bit numbers will be output as the [FieldOption.JSType](https://protobuf.dev/reference/java/api-docs/com/google/protobuf/DescriptorProtos.FieldOptions.JSType) specified on the field. This takes precedence over the `forceLong` option provided.
 
 - With `--ts_proto_opt=esModuleInterop=true` changes output to be `esModuleInterop` compliant.
 
@@ -438,7 +438,7 @@ Generated code will be placed in the Gradle build directory.
 
   (Requires `nestJs=true`.)
 
-- With`--ts_proto_opt=addNestjsRestParameter=true`, the last argument of service methods will be an rest parameter with type any. This way you can use custom decorators you could normally use in nestjs.
+- With`--ts_proto_opt=addNestjsRestParameter=true`, the last argument of service methods will be a rest parameter with type any. This way you can use custom decorators you could normally use in nestjs.
 
   (Requires `nestJs=true`.)
 
@@ -476,11 +476,11 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=outputServices=false`, or `=none`, ts-proto will output NO service definitions.
 
-- With `--ts_proto_opt=rpcBeforeRequest=true`, ts-proto will add a function definition to the Rpc interface definition with the signature: `beforeRequest(service: string, message: string, request: <RequestType>)`. It will will also automatically set `outputServices=default`. Each of the Service's methods will call `beforeRequest` before performing it's request.
+- With `--ts_proto_opt=rpcBeforeRequest=true`, ts-proto will add a function definition to the Rpc interface definition with the signature: `beforeRequest(service: string, message: string, request: <RequestType>)`. It will also automatically set `outputServices=default`. Each of the Service's methods will call `beforeRequest` before performing its request.
 
-- With `--ts_proto_opt=rpcAfterResponse=true`, ts-proto will add a function definition to the Rpc interface definition with the signature: `afterResponse(service: string, message: string, response: <ResponseType>)`. It will will also automatically set `outputServices=default`. Each of the Service's methods will call `afterResponse` before returning the response.
+- With `--ts_proto_opt=rpcAfterResponse=true`, ts-proto will add a function definition to the Rpc interface definition with the signature: `afterResponse(service: string, message: string, response: <ResponseType>)`. It will also automatically set `outputServices=default`. Each of the Service's methods will call `afterResponse` before returning the response.
 
-- With `--ts_proto_opt=rpcErrorHandler=true`, ts-proto will add a function definition to the Rpc interface definition with the signature: `handleError(service: string, message: string, error: Error)`. It will will also automatically set `outputServices=default`.
+- With `--ts_proto_opt=rpcErrorHandler=true`, ts-proto will add a function definition to the Rpc interface definition with the signature: `handleError(service: string, message: string, error: Error)`. It will also automatically set `outputServices=default`.
 
 - With `--ts_proto_opt=useAbortSignal=true`, the generated services will accept an `AbortSignal` to cancel RPC calls.
 
@@ -522,7 +522,7 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=useNumericEnumForJson=true`, the JSON converter (`toJSON`) will encode enum values as int, rather than a string literal.
 
-- With `--ts_proto_opt=initializeFieldsAsUndefined=false`, all optional field initializers will be omited from the generated base instances.
+- With `--ts_proto_opt=initializeFieldsAsUndefined=false`, all optional field initializers will be omitted from the generated base instances.
 
 - With `--ts_proto_opt=disableProto2Optionals=true`, all optional fields on proto2 files will not be set to be optional. Please note that this flag is primarily for preserving ts-proto's legacy handling of proto2 files, to avoid breaking changes, and as a result, it is not intended to be used moving forward.
 
@@ -533,14 +533,14 @@ Generated code will be placed in the Gradle build directory.
   - `Mfoo/bar.proto=@myorg/some-lib` will map `foo/bar.proto` imports into `import ... from '@myorg/some-lib'`.
   - `Mfoo/bar.proto=./some/local/lib` will map `foo/bar.proto` imports into `import ... from './some/local/lib'`.
   - `Mfoo/bar.proto=some-modules/some-lib` will map `foo/bar.proto` imports into `import ... from 'some-module/some-lib'`.
-  - **Note**: Uses are accummulated, so multiple values are expected in the form of `--ts_proto_opt=M... --ts_proto_opt=M...` (one `ts_proto_opt` per mapping).
+  - **Note**: Uses are accumulated, so multiple values are expected in the form of `--ts_proto_opt=M... --ts_proto_opt=M...` (one `ts_proto_opt` per mapping).
   - **Note**: Proto files that match mapped imports **will not be generated**.
 
 - With `--ts_proto_opt=useMapType=true`, the generated code for protobuf `map<key_type, value_type>` will become `Map<key_type, value_type>` that uses JavaScript Map type.
 
   The default behavior is `useMapType=false`, which makes it generate the code for protobuf `map<key_type, value_type` with the key-value pair like `{[key: key_type]: value_type}`.
 
-- With `--ts_proto_opt=useReadonlyTypes=true`, the generated types will be declared as immutable using typescript's `readonly` modifer.
+- With `--ts_proto_opt=useReadonlyTypes=true`, the generated types will be declared as immutable using typescript's `readonly` modifier.
 
 - With `--ts_proto_opt=useSnakeTypeName=false` will remove snake casing from types.
 
@@ -633,7 +633,7 @@ export interface User {
 }
 ```
 
-- With `--ts_proto_opt=noDefaultsForOptionals=true`, `undefined` primitive values will not be defaulted as per the protobuf spec. Additionally unlike the standard behavior, when a field is set to it's standard default value, it *will* be encoded allowing it to be sent over the wire and distinguished from undefined values. For example if a message does not set a boolean value, ordinarily this would be defaulted to `false` which is different to it being undefined.
+- With `--ts_proto_opt=noDefaultsForOptionals=true`, `undefined` primitive values will not be defaulted as per the protobuf spec. Additionally unlike the standard behavior, when a field is set to its standard default value, it *will* be encoded allowing it to be sent over the wire and distinguished from undefined values. For example if a message does not set a boolean value, ordinarily this would be defaulted to `false` which is different to it being undefined.
 
 This option allows the library to act in a compatible way with the [Wire implementation](https://square.github.io/wire/) maintained and used by Square/Block. Note: this option should only be used in combination with other client/server code generated using Wire or ts-proto with this option enabled.
 

package/build/src/generate-services.js

@@ -225,7 +225,7 @@ function generateServiceClientImpl(ctx, fileDesc, serviceDesc) {
     chunks.push((0, ts_poet_1.code) `}`);
     // Create a method for each FooService method
     for (const methodDesc of serviceDesc.method) {
-        // See if this this fuzzy matches to a batchable method
+        // See if this fuzzy matches to a batchable method
         if (options.context) {
             const batchMethod = (0, types_1.detectBatchMethod)(ctx, fileDesc, serviceDesc, methodDesc);
             if (batchMethod) {

package/build/src/main.d.ts

@@ -4,7 +4,7 @@ import { FileDescriptorProto } from "ts-proto-descriptors";
 import { Context } from "./context";
 import { Options } from "./options";
 export declare function generateFile(ctx: Context, fileDesc: FileDescriptorProto): [string, Code];
-export type Utils = ReturnType<typeof makeDeepPartial> & ReturnType<typeof makeObjectIdMethods> & ReturnType<typeof makeTimestampMethods> & ReturnType<typeof makeByteUtils> & ReturnType<typeof makeLongUtils> & ReturnType<typeof makeComparisonUtils> & ReturnType<typeof makeNiceGrpcServerStreamingMethodResult> & ReturnType<typeof makeGrpcWebErrorClass> & ReturnType<typeof makeExtensionClass> & ReturnType<typeof makeAssertionUtils>;
+export type Utils = ReturnType<typeof makeDeepPartial> & ReturnType<typeof makeObjectIdMethods> & ReturnType<typeof makeTimestampMethods> & ReturnType<typeof makeByteUtils> & ReturnType<typeof makeLongUtils> & ReturnType<typeof makeComparisonUtils> & ReturnType<typeof makeNiceGrpcServerStreamingMethodResult> & ReturnType<typeof makeGrpcWebErrorClass> & ReturnType<typeof makeExtensionClass> & ReturnType<typeof makeAssertionUtils> & ReturnType<typeof makeMessageFns>;
 /** These are runtime utility methods used by the generated code. */
 export declare function makeUtils(options: Options): Utils;
 declare function makeLongUtils(options: Options, bytes: ReturnType<typeof makeByteUtils>): {
@@ -22,6 +22,15 @@ declare function makeDeepPartial(options: Options, longs: ReturnType<typeof make
     DeepPartial: ConditionalOutput;
     Exact: ConditionalOutput;
 };
+declare function makeMessageFns(options: Options, deepPartial: ReturnType<typeof makeDeepPartial>, extension: ReturnType<typeof makeExtensionClass>): {
+    MessageFns: ConditionalOutput;
+    ExtensionFns: ConditionalOutput;
+    ExtensionHolder: ConditionalOutput;
+    StructWrapperFns: ConditionalOutput;
+    AnyValueWrapperFns: ConditionalOutput;
+    ListValueWrapperFns: ConditionalOutput;
+    FieldMaskWrapperFns: ConditionalOutput;
+};
 declare function makeObjectIdMethods(): {
     fromJsonObjectId: ConditionalOutput;
     fromProtoObjectId: ConditionalOutput;

package/build/src/main.js

@@ -96,7 +96,8 @@ function generateFile(ctx, fileDesc) {
                 chunks.push(generateBaseInstanceFactory(ctx, fullName, message, fullTypeName));
             }
             const staticMembers = [];
-            if (options.outputTypeAnnotations || options.outputTypeRegistry) {
+            const hasTypeMember = options.outputTypeAnnotations || options.outputTypeRegistry;
+            if (hasTypeMember) {
                 staticMembers.push((0, ts_poet_1.code) `$type: '${fullTypeName}' as const`);
             }
             if (options.outputExtensions) {
@@ -153,8 +154,37 @@ function generateFile(ctx, fileDesc) {
                 staticMembers.push(...(0, generate_struct_wrappers_1.generateUnwrapShallow)(ctx, fullTypeName, structFieldNames));
             }
             if (staticMembers.length > 0) {
+                const messageFnsTypeParameters = [fullName, hasTypeMember && `'${fullTypeName}'`]
+                    .filter((p) => !!p)
+                    .join(", ");
+                const interfaces = [(0, ts_poet_1.code) `${utils.MessageFns}<${messageFnsTypeParameters}>`];
+                if (options.outputEncodeMethods &&
+                    options.outputExtensions &&
+                    options.unknownFields &&
+                    message.extensionRange.length) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.ExtensionFns}<${fullName}>`);
+                }
+                if ((0, types_1.isStructTypeName)(fullTypeName)) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.StructWrapperFns}`);
+                }
+                else if ((0, types_1.isAnyValueTypeName)(fullTypeName)) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.AnyValueWrapperFns}`);
+                }
+                else if ((0, types_1.isListValueTypeName)(fullTypeName)) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.ListValueWrapperFns}`);
+                }
+                else if ((0, types_1.isFieldMaskTypeName)(fullTypeName)) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.FieldMaskWrapperFns}`);
+                }
+                if (options.outputExtensions) {
+                    for (const extension of message.extension) {
+                        const name = (0, case_1.maybeSnakeToCamel)(extension.name, ctx.options);
+                        const type = (0, types_1.toTypeName)(ctx, message, extension);
+                        interfaces.push((0, ts_poet_1.code) `${utils.ExtensionHolder}<"${name}", ${type}>`);
+                    }
+                }
                 chunks.push((0, ts_poet_1.code) `
-            export const ${(0, ts_poet_1.def)(fullName)} = {
+            export const ${(0, ts_poet_1.def)(fullName)}: ${(0, ts_poet_1.joinCode)(interfaces, { on: " & " })} = {
               ${(0, ts_poet_1.joinCode)(staticMembers, { on: ",\n\n" })}
             };
           `);
@@ -281,17 +311,20 @@ function generateFile(ctx, fileDesc) {
 function makeUtils(options) {
     const bytes = makeByteUtils(options);
     const longs = makeLongUtils(options, bytes);
+    const deepPartial = makeDeepPartial(options, longs);
+    const extension = makeExtensionClass(options);
     return {
         ...bytes,
-        ...makeDeepPartial(options, longs),
+        ...deepPartial,
         ...makeObjectIdMethods(),
         ...makeTimestampMethods(options, longs, bytes),
         ...longs,
         ...makeComparisonUtils(),
         ...makeNiceGrpcServerStreamingMethodResult(options),
         ...makeGrpcWebErrorClass(bytes),
-        ...makeExtensionClass(options),
+        ...extension,
         ...makeAssertionUtils(bytes),
+        ...makeMessageFns(options, deepPartial, extension),
     };
 }
 function makeProtobufTimestampWrapper() {
@@ -461,6 +494,121 @@ function makeDeepPartial(options, longs) {
     `);
     return { Builtin, DeepPartial, Exact };
 }
+function makeMessageFns(options, deepPartial, extension) {
+    const BinaryWriter = (0, ts_poet_1.imp)("BinaryWriter@@bufbuild/protobuf/wire");
+    const BinaryReader = (0, ts_poet_1.imp)("BinaryReader@@bufbuild/protobuf/wire");
+    const { Exact, DeepPartial } = deepPartial;
+    const { Extension } = extension;
+    const commonStaticMembers = [];
+    const extensionStaticMembers = [];
+    const hasTypeMember = options.outputTypeAnnotations || options.outputTypeRegistry;
+    if (hasTypeMember) {
+        commonStaticMembers.push((0, ts_poet_1.code) `readonly $type: V;`);
+    }
+    if (options.outputEncodeMethods) {
+        if (options.outputEncodeMethods === true ||
+            options.outputEncodeMethods === "encode-only" ||
+            options.outputEncodeMethods === "encode-no-creation") {
+            commonStaticMembers.push((0, ts_poet_1.code) `
+        encode(message: T, writer?: ${BinaryWriter}): ${BinaryWriter};
+      `);
+            if (options.outputExtensions && options.unknownFields) {
+                extensionStaticMembers.push((0, ts_poet_1.code) `
+          setExtension<E>(message: T, extension: ${Extension}<E>, value: E): void;
+        `);
+            }
+        }
+        if (options.outputEncodeMethods === true || options.outputEncodeMethods === "decode-only") {
+            commonStaticMembers.push((0, ts_poet_1.code) `
+        decode(input: ${BinaryReader} | Uint8Array, length?: number): T;
+      `);
+            if (options.outputExtensions && options.unknownFields) {
+                extensionStaticMembers.push((0, ts_poet_1.code) `
+          getExtension<E>(message: T, extension: ${Extension}<E>): E | undefined;
+        `);
+            }
+        }
+    }
+    if (options.useAsyncIterable) {
+        commonStaticMembers.push((0, ts_poet_1.code) `
+      encodeTransform(
+        source: AsyncIterable<T | T[]> | Iterable<T | T[]>
+      ): AsyncIterable<Uint8Array>;
+    `);
+        commonStaticMembers.push((0, ts_poet_1.code) `
+      decodeTransform(
+        source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>
+      ): AsyncIterable<T>;
+    `);
+    }
+    if (options.outputJsonMethods) {
+        if (options.outputJsonMethods === true || options.outputJsonMethods === "from-only") {
+            commonStaticMembers.push((0, ts_poet_1.code) `fromJSON(object: any): T;`);
+        }
+        if (options.outputJsonMethods === true || options.outputJsonMethods === "to-only") {
+            commonStaticMembers.push((0, ts_poet_1.code) `toJSON(message: T): unknown;`);
+        }
+    }
+    if (options.outputPartialMethods) {
+        if (options.useExactTypes) {
+            commonStaticMembers.push((0, ts_poet_1.code) `create<I extends ${Exact}<${DeepPartial}<T>, I>>(base?: I): T;`);
+            commonStaticMembers.push((0, ts_poet_1.code) `fromPartial<I extends ${Exact}<${DeepPartial}<T>, I>>(object: I): T;`);
+        }
+        else {
+            commonStaticMembers.push((0, ts_poet_1.code) `create(base?: DeepPartial<T>): T;`);
+            commonStaticMembers.push((0, ts_poet_1.code) `fromPartial(object: DeepPartial<T>): T;`);
+        }
+    }
+    const maybeExport = options.exportCommonSymbols ? "export" : "";
+    const MessageFns = (0, ts_poet_1.conditionalOutput)("MessageFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface MessageFns<T${hasTypeMember ? ", V extends string" : ""}> {
+        ${(0, ts_poet_1.joinCode)(commonStaticMembers, { on: "\n" })}
+      }
+    `);
+    const ExtensionFns = (0, ts_poet_1.conditionalOutput)("ExtensionFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface ExtensionFns<T> {
+        ${(0, ts_poet_1.joinCode)(extensionStaticMembers, { on: "\n" })}
+      }
+    `);
+    const ExtensionHolder = (0, ts_poet_1.conditionalOutput)("ExtensionHolder", (0, ts_poet_1.code) `
+      ${maybeExport} type ExtensionHolder<T extends string, V> = {
+        [key in T]: Extension<V>;
+      }
+    `);
+    const StructWrapperFns = (0, ts_poet_1.conditionalOutput)("StructWrapperFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface StructWrapperFns {
+        wrap(object: {[key: string]: any} | undefined): Struct;
+        unwrap(message: Struct): {[key: string]: any};
+      }
+    `);
+    const AnyValueWrapperFns = (0, ts_poet_1.conditionalOutput)("AnyValueWrapperFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface AnyValueWrapperFns {
+        wrap(value: any): Value;
+        unwrap(message: any): string | number | boolean | Object | null | Array<any> | undefined;
+      }
+    `);
+    const ListValueWrapperFns = (0, ts_poet_1.conditionalOutput)("ListValueWrapperFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface ListValueWrapperFns {
+        wrap(array: ${options.useReadonlyTypes ? "Readonly" : ""}Array<any> | undefined): ListValue;
+        unwrap(message: ${options.useReadonlyTypes ? "any" : "ListValue"}): Array<any>;
+      }
+    `);
+    const FieldMaskWrapperFns = (0, ts_poet_1.conditionalOutput)("FieldMaskWrapperFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface FieldMaskWrapperFns {
+        wrap(paths: ${options.useReadonlyTypes ? "readonly" : ""} string[]): FieldMask;
+        unwrap(message: ${options.useReadonlyTypes ? "any" : "FieldMask"}): string[] ${options.useOptionals === "all" ? "| undefined" : ""};
+      }
+    `);
+    return {
+        MessageFns,
+        ExtensionFns,
+        ExtensionHolder,
+        StructWrapperFns,
+        AnyValueWrapperFns,
+        ListValueWrapperFns,
+        FieldMaskWrapperFns,
+    };
+}
 function makeObjectIdMethods() {
     const mongodb = (0, ts_poet_1.imp)("mongodb*mongodb");
     const fromProtoObjectId = (0, ts_poet_1.conditionalOutput)("fromProtoObjectId", (0, ts_poet_1.code) `
@@ -882,7 +1030,7 @@ function generateDecode(ctx, fullName, messageDesc) {
     messageDesc.field.forEach((field) => {
         const fieldName = (0, utils_1.getFieldName)(field, options);
         const messageProperty = (0, utils_1.getPropertyAccessor)("message", fieldName);
-        chunks.push((0, ts_poet_1.code) `case ${field.number}:`);
+        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}) {
@@ -935,11 +1083,23 @@ function generateDecode(ctx, fullName, messageDesc) {
             }`
                     : "";
                 if ((0, types_1.packedType)(field.type) === undefined) {
-                    chunks.push((0, ts_poet_1.code) `
-            ${tagCheck}
-            ${initializerSnippet}
-            ${messageProperty}${maybeNonNullAssertion}.push(${readSnippet});
-          `);
+                    if (options.useOptionals === "all") {
+                        chunks.push((0, ts_poet_1.code) `
+              ${tagCheck}
+              ${initializerSnippet}
+              const el = ${readSnippet};
+              if (el !== undefined) {
+                ${messageProperty}${maybeNonNullAssertion}.push(el);
+              }
+            `);
+                    }
+                    else {
+                        chunks.push((0, ts_poet_1.code) `
+              ${tagCheck}
+              ${initializerSnippet}
+              ${messageProperty}${maybeNonNullAssertion}.push(${readSnippet});
+            `);
+                    }
                 }
                 else {
                     const packedTag = ((field.number << 3) | 2) >>> 0;
@@ -962,7 +1122,7 @@ function generateDecode(ctx, fullName, messageDesc) {
             }
 
             break;
-          `);
+          }`);
                 }
             }
         }
@@ -983,7 +1143,7 @@ function generateDecode(ctx, fullName, messageDesc) {
       `);
         }
         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) `continue; }`);
         }
     });
     chunks.push((0, ts_poet_1.code) `}`);

package/build/src/schema.js

@@ -197,9 +197,9 @@ function encodedOptionsToOptions(ctx, extendee, encodedOptions) {
             // getExtensionValue is to decode the encoded value into a message, but this
             // Message.decode(...) method is not always included in the generated code.
             // We should fix this so that we can always create an option definition by
-            // somehow premptively decoding the encoded value and then inserting it into
-            // the option defintion.
-            // please refer to inteegration/options-types-only to see this in action
+            // somehow preemptively decoding the encoded value and then inserting it into
+            // the option definition.
+            // please refer to integration/options-types-only to see this in action
             resultOptions.push(getExtensionValue(ctx, extension, value));
         }
     }

package/build/src/sourceInfo.d.ts

@@ -69,10 +69,10 @@ export default class SourceInfo implements SourceDescription {
     get leadingComments(): string;
     /** Documentation is unclear about what exactly this is */
     get trailingComments(): string;
-    /** Detached comments are those preceeding but separated by a blank non-comment line */
+    /** Detached comments are those preceding but separated by a blank non-comment line */
     get leadingDetachedComments(): string[];
-    /** Return the source info for the field id and index specficied */
+    /** Return the source info for the field id and index specified */
     lookup(type: FieldID, index?: number): SourceDescription;
-    /** Returns a new SourceInfo class representing the field id and index specficied */
+    /** Returns a new SourceInfo class representing the field id and index specified */
     open(type: FieldID, index: number): SourceInfo;
 }

package/build/src/sourceInfo.js

@@ -80,18 +80,18 @@ class SourceInfo {
     get trailingComments() {
         return this.selfDescription.trailingComments;
     }
-    /** Detached comments are those preceeding but separated by a blank non-comment line */
+    /** Detached comments are those preceding but separated by a blank non-comment line */
     get leadingDetachedComments() {
         return this.selfDescription.leadingDetachedComments;
     }
-    /** Return the source info for the field id and index specficied */
+    /** Return the source info for the field id and index specified */
     lookup(type, index) {
         if (index === undefined) {
             return this.sourceCode[`${type}`] || new EmptyDescription();
         }
         return this.sourceCode[`${type}.${index}`] || new EmptyDescription();
     }
-    /** Returns a new SourceInfo class representing the field id and index specficied */
+    /** Returns a new SourceInfo class representing the field id and index specified */
     open(type, index) {
         const prefix = `${type}.${index}.`;
         const map = {};

package/package.json

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