ts-proto 1.111.0 → 1.112.2

package/CHANGELOG.md

@@ -1,3 +1,29 @@
+## [1.112.2](https://github.com/stephenh/ts-proto/compare/v1.112.1...v1.112.2) (2022-05-18)
+
+
+### Bug Fixes
+
+* enum type returns 'UNRECOGNIZED' or '-1' in xxxToJSON/xxxToNumber ([#566](https://github.com/stephenh/ts-proto/issues/566)) ([19911a1](https://github.com/stephenh/ts-proto/commit/19911a1c62e3fe5c8a0eb0a795489340512898da))
+
+## [1.112.1](https://github.com/stephenh/ts-proto/compare/v1.112.0...v1.112.1) (2022-05-06)
+
+
+### Bug Fixes
+
+* use Long.fromValue instead of Long.fromString ([#562](https://github.com/stephenh/ts-proto/issues/562)) ([c99891e](https://github.com/stephenh/ts-proto/commit/c99891e0fec6d9b7225025eb0c5bd7393e80af36))
+
+# [1.112.0](https://github.com/stephenh/ts-proto/compare/v1.111.0...v1.112.0) (2022-05-02)
+
+
+### Bug Fixes
+
+* update codegen for `nice-grpc` ([#561](https://github.com/stephenh/ts-proto/issues/561)) ([d503f67](https://github.com/stephenh/ts-proto/commit/d503f677922402e880b5d8502b3d8bc099b7f39d))
+
+
+### Features
+
+* add support for generating `nice-grpc` server and client stubs ([#555](https://github.com/stephenh/ts-proto/issues/555)) ([8c19361](https://github.com/stephenh/ts-proto/commit/8c19361ede9a7a039acf3a1375913d012b0fcb7d)), closes [#545](https://github.com/stephenh/ts-proto/issues/545)
+
 # [1.111.0](https://github.com/stephenh/ts-proto/compare/v1.110.4...v1.111.0) (2022-05-01)
 
 

package/README.markdown

@@ -362,6 +362,8 @@ Generated code will be placed in the Gradle build directory.
 
 - 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=nice-grpc`, ts-proto will output server and client stubs for [nice-grpc](https://github.com/deeplay-io/nice-grpc). This should be used together with generic definitions, i.e. you should specify two options: `outputServices=nice-grpc,outputServices=generic-definitions`.
+
 - With `--ts_proto_opt=metadataType=Foo@./some-file`, ts-proto add a generic (framework-agnostic) metadata field to the generic service definition.
 
 - With `--ts_proto_opt=outputServices=generic-definitions,outputServices=default`, ts-proto will output both generic definitions and interfaces.  This is useful if you want to rely on the interfaces, but also have some reflection capabilities at runtime.

package/build/enums.js

@@ -43,11 +43,11 @@ function generateEnum(ctx, fullName, enumDesc, sourceInfo) {
     }
     if (options.outputJsonMethods) {
         chunks.push(ts_poet_1.code `\n`);
-        chunks.push(generateEnumToJson(fullName, enumDesc));
+        chunks.push(generateEnumToJson(ctx, fullName, enumDesc));
     }
     if (options.stringEnums && options.outputEncodeMethods) {
         chunks.push(ts_poet_1.code `\n`);
-        chunks.push(generateEnumToNumber(fullName, enumDesc));
+        chunks.push(generateEnumToNumber(ctx, fullName, enumDesc));
     }
     return ts_poet_1.joinCode(chunks, { on: '\n' });
 }
@@ -87,7 +87,8 @@ function generateEnumFromJson(ctx, fullName, enumDesc) {
 }
 exports.generateEnumFromJson = generateEnumFromJson;
 /** Generates a function with a big switch statement to encode our enum -> JSON. */
-function generateEnumToJson(fullName, enumDesc) {
+function generateEnumToJson(ctx, fullName, enumDesc) {
+    const { options, utils } = ctx;
     const chunks = [];
     const functionName = case_1.camelCase(fullName) + 'ToJSON';
     chunks.push(ts_poet_1.code `export function ${ts_poet_1.def(functionName)}(object: ${fullName}): string {`);
@@ -95,14 +96,28 @@ function generateEnumToJson(fullName, enumDesc) {
     for (const valueDesc of enumDesc.value) {
         chunks.push(ts_poet_1.code `case ${fullName}.${valueDesc.name}: return "${valueDesc.name}";`);
     }
-    chunks.push(ts_poet_1.code `default: return "UNKNOWN";`);
+    if (options.unrecognizedEnum) {
+        chunks.push(ts_poet_1.code `
+      case ${fullName}.${UNRECOGNIZED_ENUM_NAME}:
+      default:
+        return "${UNRECOGNIZED_ENUM_NAME}";
+    `);
+    }
+    else {
+        // We use globalThis to avoid conflicts on protobuf types named `Error`.
+        chunks.push(ts_poet_1.code `
+      default:
+        throw new ${utils.globalThis}.Error("Unrecognized enum value " + object + " for enum ${fullName}");
+    `);
+    }
     chunks.push(ts_poet_1.code `}`);
     chunks.push(ts_poet_1.code `}`);
     return ts_poet_1.joinCode(chunks, { on: '\n' });
 }
 exports.generateEnumToJson = generateEnumToJson;
 /** Generates a function with a big switch statement to encode our string enum -> int value. */
-function generateEnumToNumber(fullName, enumDesc) {
+function generateEnumToNumber(ctx, fullName, enumDesc) {
+    const { options, utils } = ctx;
     const chunks = [];
     const functionName = case_1.camelCase(fullName) + 'ToNumber';
     chunks.push(ts_poet_1.code `export function ${ts_poet_1.def(functionName)}(object: ${fullName}): number {`);
@@ -110,7 +125,20 @@ function generateEnumToNumber(fullName, enumDesc) {
     for (const valueDesc of enumDesc.value) {
         chunks.push(ts_poet_1.code `case ${fullName}.${valueDesc.name}: return ${valueDesc.number};`);
     }
-    chunks.push(ts_poet_1.code `default: return 0;`);
+    if (options.unrecognizedEnum) {
+        chunks.push(ts_poet_1.code `
+      case ${fullName}.${UNRECOGNIZED_ENUM_NAME}:
+      default:
+        return ${UNRECOGNIZED_ENUM_VALUE};
+    `);
+    }
+    else {
+        // We use globalThis to avoid conflicts on protobuf types named `Error`.
+        chunks.push(ts_poet_1.code `
+      default:
+        throw new ${utils.globalThis}.Error("Unrecognized enum value " + object + " for enum ${fullName}");
+    `);
+    }
     chunks.push(ts_poet_1.code `}`);
     chunks.push(ts_poet_1.code `}`);
     return ts_poet_1.joinCode(chunks, { on: '\n' });

package/build/generate-nice-grpc.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNiceGrpcService = void 0;
+const ts_poet_1 = require("ts-poet");
+const case_1 = require("./case");
+const sourceInfo_1 = require("./sourceInfo");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const CallOptions = ts_poet_1.imp('CallOptions@nice-grpc-common');
+const CallContext = ts_poet_1.imp('CallContext@nice-grpc-common');
+/**
+ * Generates server / client stubs for `nice-grpc` library.
+ */
+function generateNiceGrpcService(ctx, fileDesc, sourceInfo, serviceDesc) {
+    const chunks = [];
+    chunks.push(generateServerStub(ctx, sourceInfo, serviceDesc));
+    chunks.push(generateClientStub(ctx, sourceInfo, serviceDesc));
+    return ts_poet_1.joinCode(chunks, { on: '\n\n' });
+}
+exports.generateNiceGrpcService = generateNiceGrpcService;
+function generateServerStub(ctx, sourceInfo, serviceDesc) {
+    var _a;
+    const chunks = [];
+    chunks.push(ts_poet_1.code `export interface ${ts_poet_1.def(`${serviceDesc.name}ServiceImplementation`)}<CallContextExt = {}> {`);
+    for (const [index, methodDesc] of serviceDesc.method.entries()) {
+        utils_1.assertInstanceOf(methodDesc, utils_1.FormattedMethodDescriptor);
+        const inputType = types_1.messageToTypeName(ctx, methodDesc.inputType, { keepValueType: true });
+        let outputType = types_1.messageToTypeName(ctx, methodDesc.outputType, { keepValueType: true });
+        if (ctx.options.outputPartialMethods) {
+            outputType = ts_poet_1.code `${ctx.utils.DeepPartial}<${outputType}>`;
+        }
+        const ServerStreamingMethodResult = ctx.utils.NiceGrpcServerStreamingMethodResult;
+        const info = sourceInfo.lookup(sourceInfo_1.Fields.service.method, index);
+        utils_1.maybeAddComment(info, chunks, (_a = methodDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated);
+        if (methodDesc.clientStreaming) {
+            if (methodDesc.serverStreaming) {
+                // bidi streaming
+                chunks.push(ts_poet_1.code `
+          ${case_1.camelCase(methodDesc.name)}(
+            request: AsyncIterable<${inputType}>,
+            context: ${CallContext} & CallContextExt,
+          ): ${ServerStreamingMethodResult}<${outputType}>;
+        `);
+            }
+            else {
+                // client streaming
+                chunks.push(ts_poet_1.code `
+          ${case_1.camelCase(methodDesc.name)}(
+            request: AsyncIterable<${inputType}>,
+            context: ${CallContext} & CallContextExt,
+          ): Promise<${outputType}>;
+        `);
+            }
+        }
+        else {
+            if (methodDesc.serverStreaming) {
+                // server streaming
+                chunks.push(ts_poet_1.code `
+          ${case_1.camelCase(methodDesc.name)}(
+            request: ${inputType},
+            context: ${CallContext} & CallContextExt,
+          ): ${ServerStreamingMethodResult}<${outputType}>;
+        `);
+            }
+            else {
+                // unary
+                chunks.push(ts_poet_1.code `
+          ${case_1.camelCase(methodDesc.name)}(
+            request: ${inputType},
+            context: ${CallContext} & CallContextExt,
+          ): Promise<${outputType}>;
+        `);
+            }
+        }
+    }
+    chunks.push(ts_poet_1.code `}`);
+    return ts_poet_1.joinCode(chunks, { on: '\n' });
+}
+function generateClientStub(ctx, sourceInfo, serviceDesc) {
+    var _a;
+    const chunks = [];
+    chunks.push(ts_poet_1.code `export interface ${ts_poet_1.def(`${serviceDesc.name}Client`)}<CallOptionsExt = {}> {`);
+    for (const [index, methodDesc] of serviceDesc.method.entries()) {
+        utils_1.assertInstanceOf(methodDesc, utils_1.FormattedMethodDescriptor);
+        let inputType = types_1.messageToTypeName(ctx, methodDesc.inputType, { keepValueType: true });
+        if (ctx.options.outputPartialMethods) {
+            inputType = ts_poet_1.code `${ctx.utils.DeepPartial}<${inputType}>`;
+        }
+        const outputType = types_1.messageToTypeName(ctx, methodDesc.outputType, { keepValueType: true });
+        const info = sourceInfo.lookup(sourceInfo_1.Fields.service.method, index);
+        utils_1.maybeAddComment(info, chunks, (_a = methodDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated);
+        if (methodDesc.clientStreaming) {
+            if (methodDesc.serverStreaming) {
+                // bidi streaming
+                chunks.push(ts_poet_1.code `
+          ${case_1.camelCase(methodDesc.name)}(
+            request: AsyncIterable<${inputType}>,
+            options?: ${CallOptions} & CallOptionsExt,
+          ): AsyncIterable<${outputType}>;
+        `);
+            }
+            else {
+                // client streaming
+                chunks.push(ts_poet_1.code `
+          ${case_1.camelCase(methodDesc.name)}(
+            request: AsyncIterable<${inputType}>,
+            options?: ${CallOptions} & CallOptionsExt,
+          ): Promise<${outputType}>;
+        `);
+            }
+        }
+        else {
+            if (methodDesc.serverStreaming) {
+                // server streaming
+                chunks.push(ts_poet_1.code `
+          ${case_1.camelCase(methodDesc.name)}(
+            request: ${inputType},
+            options?: ${CallOptions} & CallOptionsExt,
+          ): AsyncIterable<${outputType}>;
+        `);
+            }
+            else {
+                // unary
+                chunks.push(ts_poet_1.code `
+          ${case_1.camelCase(methodDesc.name)}(
+            request: ${inputType},
+            options?: ${CallOptions} & CallOptionsExt,
+          ): Promise<${outputType}>;
+        `);
+            }
+        }
+    }
+    chunks.push(ts_poet_1.code `}`);
+    return ts_poet_1.joinCode(chunks, { on: '\n' });
+}

package/build/main.js

@@ -16,6 +16,7 @@ const schema_1 = require("./schema");
 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");
 function generateFile(ctx, fileDesc) {
     var _a;
     const { options, utils } = ctx;
@@ -124,6 +125,9 @@ function generateFile(ctx, fileDesc) {
                 if (outputService === options_1.ServiceOption.GRPC) {
                     chunks.push(generate_grpc_js_1.generateGrpcJsService(ctx, fileDesc, sInfo, serviceDesc));
                 }
+                else if (outputService === options_1.ServiceOption.NICE_GRPC) {
+                    chunks.push(generate_nice_grpc_1.generateNiceGrpcService(ctx, fileDesc, sInfo, serviceDesc));
+                }
                 else if (outputService === options_1.ServiceOption.GENERIC) {
                     chunks.push(generate_generic_service_definition_1.generateGenericServiceDefinition(ctx, fileDesc, sInfo, serviceDesc));
                 }
@@ -206,6 +210,7 @@ function makeUtils(options) {
         ...makeTimestampMethods(options, longs),
         ...longs,
         ...makeComparisonUtils(),
+        ...makeNiceGrpcServerStreamingMethodResult(),
     };
 }
 exports.makeUtils = makeUtils;
@@ -444,6 +449,14 @@ function makeComparisonUtils() {
     }`);
     return { isObject, isSet };
 }
+function makeNiceGrpcServerStreamingMethodResult() {
+    const NiceGrpcServerStreamingMethodResult = ts_poet_1.conditionalOutput('ServerStreamingMethodResult', ts_poet_1.code `
+      export type ServerStreamingMethodResult<Response> = {
+        [Symbol.asyncIterator](): AsyncIterator<Response, void>;
+      };  
+    `);
+    return { NiceGrpcServerStreamingMethodResult };
+}
 // Create the interface with properties
 function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fullTypeName) {
     var _a;
@@ -935,7 +948,7 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                 }
                 else if (types_1.isLong(field) && options.forceLong === options_1.LongOption.LONG) {
                     const cstr = case_1.capitalize(types_1.basicTypeName(ctx, field, { keepValueType: true }).toCodeString());
-                    return ts_poet_1.code `${cstr}.fromString(${from})`;
+                    return ts_poet_1.code `${cstr}.fromValue(${from})`;
                 }
                 else {
                     const cstr = case_1.capitalize(types_1.basicTypeName(ctx, field, { keepValueType: true }).toCodeString());

package/build/options.js

@@ -27,6 +27,7 @@ var OneofOption;
 var ServiceOption;
 (function (ServiceOption) {
     ServiceOption["GRPC"] = "grpc-js";
+    ServiceOption["NICE_GRPC"] = "nice-grpc";
     ServiceOption["GENERIC"] = "generic-definitions";
     ServiceOption["DEFAULT"] = "default";
     ServiceOption["NONE"] = "none";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "1.111.0",
+  "version": "1.112.2",
   "description": "",
   "main": "build/plugin.js",
   "repository": "github:stephenh/ts-proto",
@@ -50,6 +50,7 @@
     "chokidar": "^3.5.2",
     "jest": "^26.6.3",
     "mongodb": "^4.3.0",
+    "nice-grpc": "^1.1.1",
     "prettier": "^2.2.1",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.4.0",