ts-proto 1.91.0 → 1.93.0

package/CHANGELOG.md

@@ -1,3 +1,31 @@
+# [1.93.0](https://github.com/stephenh/ts-proto/compare/v1.92.2...v1.93.0) (2021-12-08)
+
+
+### Features
+
+* Allow optional suffix for generated files ([#431](https://github.com/stephenh/ts-proto/issues/431)) ([d826966](https://github.com/stephenh/ts-proto/commit/d826966f22830920444963b3894ffc0be9b7c319))
+
+## [1.92.2](https://github.com/stephenh/ts-proto/compare/v1.92.1...v1.92.2) (2021-12-08)
+
+
+### Bug Fixes
+
+* noImplicitReturns error in Value.unwrap ([#436](https://github.com/stephenh/ts-proto/issues/436)) ([2d7a5d0](https://github.com/stephenh/ts-proto/commit/2d7a5d04c72ace58fa3a6745c3857f6cc0468543)), closes [#432](https://github.com/stephenh/ts-proto/issues/432)
+
+## [1.92.1](https://github.com/stephenh/ts-proto/compare/v1.92.0...v1.92.1) (2021-12-02)
+
+
+### Bug Fixes
+
+* Respect stringEnums option in wrap function ([#420](https://github.com/stephenh/ts-proto/issues/420)) ([7adf90c](https://github.com/stephenh/ts-proto/commit/7adf90c23c46950bcf457b317764393ff4af2bf2))
+
+# [1.92.0](https://github.com/stephenh/ts-proto/compare/v1.91.0...v1.92.0) (2021-11-28)
+
+
+### Features
+
+* Use exact types for fromPartial ([#412](https://github.com/stephenh/ts-proto/issues/412)) ([808f8a7](https://github.com/stephenh/ts-proto/commit/808f8a7a77d56f65dd4a4643dd66158f106ab755)), closes [#156](https://github.com/stephenh/ts-proto/issues/156)
+
 # [1.91.0](https://github.com/stephenh/ts-proto/compare/v1.90.1...v1.91.0) (2021-11-27)
 
 

package/README.markdown

@@ -9,25 +9,29 @@
 
 ## Table of contents
 
+- [ts-proto](#ts-proto)
+  - [Table of contents](#table-of-contents)
+- [Overview](#overview)
 - [QuickStart](#quickstart)
 - [Goals](#goals)
 - [Example Types](#example-types)
 - [Highlights](#highlights)
 - [Auto-Batching / N+1 Prevention](#auto-batching--n1-prevention)
 - [Usage](#usage)
-  - [Supported options](#supported-options)
-  - [Only Types](#only-types)
-  - [NestJS Support](NESTJS.markdown)
+    - [Supported options](#supported-options)
+    - [Only Types](#only-types)
+    - [NestJS Support](#nestjs-support)
+    - [Watch Mode](#watch-mode)
+- [Sponsors](#sponsors)
 - [Development](#development)
 - [Assumptions](#assumptions)
 - [Todo](#todo)
 - [OneOf Handling](#oneof-handling)
-- [Default Values and Unset Fields](#default-values-and-unset-fields)
+- [Default values and unset fields](#default-values-and-unset-fields)
 - [Well-Known Types](#well-known-types)
   - [Wrapper Types](#wrapper-types)
   - [JSON Types (Struct Types)](#json-types-struct-types)
-  - [Timestamps](#timestamp)
-- [Wrapper Types](#wrapper-types)
+  - [Timestamp](#timestamp)
 - [Number Types](#number-types)
 - [Current Status of Optional Values](#current-status-of-optional-values)
 
@@ -329,7 +333,7 @@ Generated code will be placed in the Gradle build directory.
 
   Note that `addGrpcMetadata`, `addNestjsRestParameter` and `returnObservable` will still be false.
 
-- With `--ts_proto_opt=useDate=false`, fields of type `google.protobuf.Timestamp` will not be mapped to type `Date` in the generated types. See [Timestamps](#timestamps) for more details.
+- With `--ts_proto_opt=useDate=false`, fields of type `google.protobuf.Timestamp` will not be mapped to type `Date` in the generated types. See [Timestamp](#timestamp) for more details.
 
 - With `--ts_proto_opt=outputSchema=true`, meta typings will be generated that can later be used in other code generators.
 
@@ -337,13 +341,15 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=outputServices=grpc-js`, ts-proto will output service definitions and server / client stubs in [grpc-js](https://github.com/grpc/grpc-node/tree/master/packages/grpc-js) format.
 
-- With `--ts_proto_opt=outputServices=generic-definitions`, ts-proto will output generic (framework-agnostic) service definitions.
+- With `--ts_proto_opt=outputServices=generic-definitions`, ts-proto will output generic (framework-agnostic) service definitions. These definitions contain descriptors for each method with links to request and response types, which allows to generate server and client stubs at runtime, and also generate strong types for them at compile time. An example of a library that uses this approach is [nice-grpc](https://github.com/deeplay-io/nice-grpc).
 
 - With `--ts_proto_opt=outputServices=false`, or `=none`, ts-proto will output NO service definitions.
 
 - With `--ts_proto_opt=emitImportedFiles=false`, ts-proto will not emit `google/protobuf/*` files unless you explicit add files to `protoc` like this
 `protoc --plugin=./node_modules/.bin/protoc-gen-ts_proto my_message.proto google/protobuf/duration.proto`
 
+- With `--ts_proto_opt=fileSuffix=<SUFFIX>`, ts-proto will emit generated files using the specified suffix. A `helloworld.proto` file with `fileSuffix=.pb` would be generated as `helloworld.pb.ts`. This is common behavior in other protoc plugins and provides a way to quickly glob all the generated files. 
+
 ### Only Types
 
 If you're looking for `ts-proto` to generate only types for your Protobuf types then passing all three of `outputEncodeMethods`, `outputJsonMethods`, and `outputClientImpl` as `false` is probably what you want, i.e.:
@@ -354,6 +360,15 @@ If you're looking for `ts-proto` to generate only types for your Protobuf types
 
 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).
 
+### Watch Mode
+
+If you want to run `ts-proto` on every change of a proto file, you'll need to use a tool like [chokidar-cli](https://www.npmjs.com/package/chokidar-cli) and use it as a script in `package.json`:
+
+```json
+"proto:generate": "protoc --ts_proto_out=. ./<proto_path>/<proto_name>.proto --ts_proto_opt=esModuleInterop=true",
+"proto:watch": "chokidar \"**/*.proto\" -c \"npm run proto:generate\""
+```
+
 # Sponsors
 
 Kudos to our sponsors:

package/build/encode.js

@@ -4,24 +4,25 @@ exports.generateDecoder = exports.generateEncoder = void 0;
 const ts_poet_1 = require("ts-poet");
 const types_1 = require("./types");
 const options_1 = require("./options");
+const utils_1 = require("./utils");
 function generateEncoder(ctx, typeName) {
     const name = types_1.wrapperTypeName(typeName);
     if (!name) {
         return ts_poet_1.code `${types_1.messageToTypeName(ctx, typeName, { keepValueType: true })}.encode(value).finish()`;
     }
     if (name == 'Timestamp') {
-        const TimestampValue = ts_poet_1.imp(`${name}@./google/protobuf/timestamp`);
+        const TimestampValue = utils_1.impProto(ctx.options, 'google/protobuf/timestamp', name);
         return ts_poet_1.code `${TimestampValue}.encode(${ctx.utils.toTimestamp}(value)).finish()`;
     }
     if (name == 'Struct') {
-        const StructType = ts_poet_1.imp(`${name}@./google/protobuf/struct`);
+        const StructType = utils_1.impProto(ctx.options, 'google/protobuf/struct', name);
         return ts_poet_1.code `${StructType}.encode(${StructType}.wrap(value)).finish()`;
     }
     if (name == 'ListValue') {
-        const ListValueType = ts_poet_1.imp(`${name}@./google/protobuf/struct`);
+        const ListValueType = utils_1.impProto(ctx.options, 'google/protobuf/struct', name);
         return ts_poet_1.code `${ListValueType}.encode({values: value ?? []}).finish()`;
     }
-    const TypeValue = ts_poet_1.imp(`${name}@./google/protobuf/wrappers`);
+    const TypeValue = utils_1.impProto(ctx.options, 'google/protobuf/wrappers', name);
     switch (name) {
         case 'StringValue':
             return ts_poet_1.code `${TypeValue}.encode({value: value ?? ""}).finish()`;
@@ -45,20 +46,21 @@ function generateEncoder(ctx, typeName) {
 }
 exports.generateEncoder = generateEncoder;
 function generateDecoder(ctx, typeName) {
+    const { options } = ctx;
     let name = types_1.wrapperTypeName(typeName);
     if (!name) {
         return ts_poet_1.code `${types_1.messageToTypeName(ctx, typeName, { keepValueType: true })}.decode(value)`;
     }
     let TypeValue;
     if (name == 'Timestamp') {
-        TypeValue = ts_poet_1.imp(`${name}@./google/protobuf/timestamp`);
+        TypeValue = utils_1.impProto(ctx.options, 'google/protobuf/timestamp', name);
         return ts_poet_1.code `${TypeValue}.decode(value)`;
     }
     if (name == 'Struct' || name == 'ListValue') {
-        TypeValue = ts_poet_1.imp(`${name}@./google/protobuf/struct`);
+        TypeValue = utils_1.impProto(ctx.options, 'google/protobuf/struct', name);
         return ts_poet_1.code `${TypeValue}.unwrap(${TypeValue}.decode(value))`;
     }
-    TypeValue = ts_poet_1.imp(`${name}@./google/protobuf/wrappers`);
+    TypeValue = utils_1.impProto(ctx.options, 'google/protobuf/wrappers', name);
     return ts_poet_1.code `${TypeValue}.decode(value).value`;
 }
 exports.generateDecoder = generateDecoder;

package/build/generate-type-registry.js

@@ -13,7 +13,7 @@ function generateTypeRegistry(ctx) {
     chunks.push(ts_poet_1.code `
     export const messageTypeRegistry = new Map<string, MessageType>();
   `);
-    chunks.push(ts_poet_1.code `${ctx.utils.DeepPartial.ifUsed}`);
+    chunks.push(ts_poet_1.code ` ${ctx.utils.Builtin.ifUsed} ${ctx.utils.DeepPartial.ifUsed}`);
     return ts_poet_1.joinCode(chunks, { on: '\n\n' });
 }
 exports.generateTypeRegistry = generateTypeRegistry;

package/build/main.js

@@ -30,7 +30,8 @@ function generateFile(ctx, fileDesc) {
     //
     // We'll also assume that the fileDesc.name is already the `company/foo.proto` path, with
     // the package already implicitly in it, so we won't re-append/strip/etc. it out/back in.
-    const moduleName = fileDesc.name.replace('.proto', '.ts');
+    const suffix = `${options.fileSuffix}.ts`;
+    const moduleName = fileDesc.name.replace('.proto', suffix);
     const chunks = [];
     // Indicate this file's source protobuf package for reflective use with google.protobuf.Any
     if (options.exportCommonSymbols) {
@@ -289,11 +290,20 @@ function makeDeepPartial(options, longs) {
     const maybeExport = options.exportCommonSymbols ? 'export' : '';
     // Allow passing longs as numbers or strings, nad we'll convert them
     const maybeLong = options.forceLong === options_1.LongOption.LONG ? ts_poet_1.code ` : T extends ${longs.Long} ? string | number | Long ` : '';
-    const keys = options.outputTypeRegistry ? ts_poet_1.code `Exclude<keyof T, '$type'>` : ts_poet_1.code `keyof T`;
+    const Builtin = ts_poet_1.conditionalOutput('Builtin', ts_poet_1.code `type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;`);
+    // Based on https://github.com/sindresorhus/type-fest/pull/259
+    const maybeExcludeType = options.outputTypeRegistry ? `| '$type'` : '';
+    const Exact = ts_poet_1.conditionalOutput('Exact', ts_poet_1.code `
+      type KeysOfUnion<T> = T extends T ? keyof T : never;
+      ${maybeExport} type Exact<P, I extends P> = P extends ${Builtin}
+        ? P
+        : P &
+        { [K in keyof P]: Exact<P[K], I[K]> } & Record<Exclude<keyof I, KeysOfUnion<P> ${maybeExcludeType}>, never>;
+    `);
     // Based on the type from ts-essentials
+    const keys = options.outputTypeRegistry ? ts_poet_1.code `Exclude<keyof T, '$type'>` : ts_poet_1.code `keyof T`;
     const DeepPartial = ts_poet_1.conditionalOutput('DeepPartial', ts_poet_1.code `
-      type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
-      ${maybeExport} type DeepPartial<T> =  T extends Builtin
+      ${maybeExport} type DeepPartial<T> =  T extends ${Builtin}
         ? T
         ${maybeLong}
         : T extends Array<infer U>
@@ -304,10 +314,10 @@ function makeDeepPartial(options, longs) {
         ? { [K in ${keys}]?: DeepPartial<T[K]> }
         : Partial<T>;
     `);
-    return { DeepPartial };
+    return { Builtin, DeepPartial, Exact };
 }
 function makeTimestampMethods(options, longs) {
-    const Timestamp = ts_poet_1.imp('Timestamp@./google/protobuf/timestamp');
+    const Timestamp = utils_1.impProto(options, 'google/protobuf/timestamp', 'Timestamp');
     let seconds = 'date.getTime() / 1_000';
     let toNumberCode = 't.seconds';
     if (options.forceLong === options_1.LongOption.LONG) {
@@ -521,7 +531,7 @@ function generateDecode(ctx, fullName, messageDesc) {
             }
             else if (types_1.isEnum(field)) {
                 if (options.stringEnums) {
-                    const fromJson = types_1.getEnumMethod(typeMap, field.typeName, 'FromJSON');
+                    const fromJson = types_1.getEnumMethod(ctx, field.typeName, 'FromJSON');
                     readSnippet = ts_poet_1.code `${fromJson}(${readSnippet})`;
                 }
                 else {
@@ -620,7 +630,7 @@ function generateEncode(ctx, fullName, messageDesc) {
         let writeSnippet;
         if (types_1.isEnum(field) && options.stringEnums) {
             const tag = ((field.number << 3) | types_1.basicWireType(field.type)) >>> 0;
-            const toNumber = types_1.getEnumMethod(typeMap, field.typeName, 'ToNumber');
+            const toNumber = types_1.getEnumMethod(ctx, field.typeName, 'ToNumber');
             writeSnippet = (place) => ts_poet_1.code `writer.uint32(${tag}).${types_1.toReaderCall(field)}(${toNumber}(${place}))`;
         }
         else if (types_1.isScalar(field) || types_1.isEnum(field)) {
@@ -682,7 +692,7 @@ function generateEncode(ctx, fullName, messageDesc) {
                 // embedded inside of it, and we want to drop that so that we can encode it packed
                 // (i.e. just one tag and multiple values).
                 const tag = ((field.number << 3) | 2) >>> 0;
-                const toNumber = types_1.getEnumMethod(typeMap, field.typeName, 'ToNumber');
+                const toNumber = types_1.getEnumMethod(ctx, field.typeName, 'ToNumber');
                 chunks.push(ts_poet_1.code `
           writer.uint32(${tag}).fork();
           for (const v of message.${fieldName}) {
@@ -762,7 +772,7 @@ function generateFromJson(ctx, fullName, messageDesc) {
         // get a generic 'reader.doSomething' bit that is specific to the basic type
         const readSnippet = (from) => {
             if (types_1.isEnum(field)) {
-                const fromJson = types_1.getEnumMethod(typeMap, field.typeName, 'FromJSON');
+                const fromJson = types_1.getEnumMethod(ctx, field.typeName, 'FromJSON');
                 return ts_poet_1.code `${fromJson}(${from})`;
             }
             else if (types_1.isPrimitive(field)) {
@@ -934,7 +944,7 @@ function generateToJson(ctx, fullName, messageDesc) {
         const jsonName = utils_1.determineFieldJsonName(field, options);
         const readSnippet = (from) => {
             if (types_1.isEnum(field)) {
-                const toJson = types_1.getEnumMethod(typeMap, field.typeName, 'ToJSON');
+                const toJson = types_1.getEnumMethod(ctx, field.typeName, 'ToJSON');
                 return types_1.isWithinOneOf(field)
                     ? ts_poet_1.code `${from} !== undefined ? ${toJson}(${from}) : undefined`
                     : ts_poet_1.code `${toJson}(${from})`;
@@ -952,7 +962,7 @@ function generateToJson(ctx, fullName, messageDesc) {
                 // For map types, drill-in and then admittedly re-hard-code our per-value-type logic
                 const valueType = typeMap.get(field.typeName)[2].field[1];
                 if (types_1.isEnum(valueType)) {
-                    const toJson = types_1.getEnumMethod(typeMap, valueType.typeName, 'ToJSON');
+                    const toJson = types_1.getEnumMethod(ctx, valueType.typeName, 'ToJSON');
                     return ts_poet_1.code `${toJson}(${from})`;
                 }
                 else if (types_1.isBytes(valueType)) {
@@ -1043,10 +1053,11 @@ function generateToJson(ctx, fullName, messageDesc) {
 function generateFromPartial(ctx, fullName, messageDesc) {
     const { options, utils, typeMap } = ctx;
     const chunks = [];
-    const Timestamp = ts_poet_1.imp('Timestamp@./google/protobuf/timestamp');
+    const Timestamp = utils_1.impProto(options, 'google/protobuf/timestamp', 'Timestamp');
     // create the basic function declaration
+    const paramName = messageDesc.field.length > 0 ? 'object' : '_';
     chunks.push(ts_poet_1.code `
-    fromPartial(${messageDesc.field.length > 0 ? 'object' : '_'}: ${utils.DeepPartial}<${fullName}>): ${fullName} {
+    fromPartial<I extends ${utils.Exact}<${utils.DeepPartial}<${fullName}>, I>>(${paramName}: I): ${fullName} {
       const message = { ...base${fullName} } as ${fullName};
   `);
     // add a check for each incoming field
@@ -1122,7 +1133,7 @@ function generateFromPartial(ctx, fullName, messageDesc) {
             }
             else {
                 chunks.push(ts_poet_1.code `
-          message.${fieldName} = (object.${fieldName} ?? []).map((e) => ${readSnippet('e')});
+          message.${fieldName} = object.${fieldName}?.map((e) => ${readSnippet('e')}) || [];
         `);
             }
         }
@@ -1174,7 +1185,7 @@ function generateWrap(fullProtoTypeName) {
     if (types_1.isAnyValueTypeName(fullProtoTypeName)) {
         chunks.push(ts_poet_1.code `wrap(value: any): Value {
       if (value === null) {
-        return {nullValue: 0} as Value;
+        return {nullValue: NullValue.NULL_VALUE} as Value;
       } else if (typeof value === 'boolean') {
         return {boolValue: value} as Value;
       } else if (typeof value === 'number') {
@@ -1212,19 +1223,20 @@ function generateUnwrap(fullProtoTypeName) {
     }
     if (types_1.isAnyValueTypeName(fullProtoTypeName)) {
         chunks.push(ts_poet_1.code `unwrap(message: Value): string | number | boolean | Object | null | Array<any> | undefined {
-      if (message.stringValue !== undefined) {
+      if (message?.stringValue !== undefined) {
         return message.stringValue;
-      } else if (message.numberValue !== undefined) {
+      } else if (message?.numberValue !== undefined) {
         return message.numberValue;
-      } else if (message.boolValue !== undefined) {
+      } else if (message?.boolValue !== undefined) {
         return message.boolValue;
-      } else if (message.structValue !== undefined) {
+      } else if (message?.structValue !== undefined) {
         return message.structValue;
-      } else if (message.listValue !== undefined) {
+      } else if (message?.listValue !== undefined) {
           return message.listValue;
-      } else if (message.nullValue !== undefined) {
+      } else if (message?.nullValue !== undefined) {
         return null;
       }
+      return undefined;
     }`);
     }
     if (types_1.isListValueTypeName(fullProtoTypeName)) {

package/build/options.js

@@ -40,6 +40,7 @@ function defaultOptions() {
         useDate: DateOption.DATE,
         oneof: OneofOption.PROPERTIES,
         esModuleInterop: false,
+        fileSuffix: '',
         lowerCaseServiceMethods: false,
         outputEncodeMethods: true,
         outputJsonMethods: true,

package/build/types.js

@@ -481,16 +481,16 @@ function messageToTypeName(ctx, protoType, typeOptions = {}) {
         }
     }
     const [module, type] = toModuleAndType(typeMap, protoType);
-    return ts_poet_1.code `${ts_poet_1.imp(`${type}@./${module}`)}`;
+    return ts_poet_1.code `${utils_1.impProto(options, module, type)}`;
 }
 exports.messageToTypeName = messageToTypeName;
 /** Breaks `.some_proto_namespace.Some.Message` into `['some_proto_namespace', 'Some_Message', Descriptor]. */
 function toModuleAndType(typeMap, protoType) {
     return typeMap.get(protoType) || utils_1.fail(`No type found for ${protoType}`);
 }
-function getEnumMethod(typeMap, enumProtoType, methodSuffix) {
-    const [module, type] = toModuleAndType(typeMap, enumProtoType);
-    return ts_poet_1.imp(`${case_1.camelCase(type)}${methodSuffix}@./${module}`);
+function getEnumMethod(ctx, enumProtoType, methodSuffix) {
+    const [module, type] = toModuleAndType(ctx.typeMap, enumProtoType);
+    return utils_1.impProto(ctx.options, module, `${case_1.camelCase(type)}${methodSuffix}`);
 }
 exports.getEnumMethod = getEnumMethod;
 /** Return the TypeName for any field (primitive/message/etc.) as exposed in the interface. */

package/build/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.determineFieldJsonName = exports.FormattedMethodDescriptor = exports.assertInstanceOf = exports.maybePrefixPackage = exports.prefixDisableLinter = exports.maybeAddComment = exports.upperFirst = exports.lowerFirst = exports.singular = exports.fail = exports.readToBuffer = exports.protoFilesToGenerate = void 0;
+exports.impProto = exports.determineFieldJsonName = exports.FormattedMethodDescriptor = exports.assertInstanceOf = exports.maybePrefixPackage = exports.prefixDisableLinter = exports.maybeAddComment = exports.upperFirst = exports.lowerFirst = exports.singular = exports.fail = exports.readToBuffer = exports.protoFilesToGenerate = void 0;
 const ts_poet_1 = require("ts-poet");
 const options_1 = require("./options");
 const case_1 = require("./case");
@@ -153,3 +153,7 @@ function determineFieldJsonName(field, options) {
     return case_1.maybeSnakeToCamel(field.name, options);
 }
 exports.determineFieldJsonName = determineFieldJsonName;
+function impProto(options, module, type) {
+    return ts_poet_1.imp(`${type}@./${module}${options.fileSuffix}`);
+}
+exports.impProto = impProto;

package/package.json

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