ts-proto 1.164.1 → 1.165.0

package/README.markdown

@@ -19,10 +19,10 @@
 - [Highlights](#highlights)
 - [Auto-Batching / N+1 Prevention](#auto-batching--n1-prevention)
 - [Usage](#usage)
-    - [Supported options](#supported-options)
-    - [NestJS Support](#nestjs-support)
-    - [Watch Mode](#watch-mode)
-    - [Basic gRPC implementation](#basic-grpc-implementation)
+  - [Supported options](#supported-options)
+  - [NestJS Support](#nestjs-support)
+  - [Watch Mode](#watch-mode)
+  - [Basic gRPC implementation](#basic-grpc-implementation)
 - [Sponsors](#sponsors)
 - [Development](#development)
 - [Assumptions](#assumptions)
@@ -121,8 +121,8 @@ plugins:
 
 If you're using a modern TS setup with either `esModuleInterop` or running in an ESM environment, you'll need to pass `ts_proto_opt`s of:
 
-* `esModuleInterop=true` if using `esModuleInterop` in your `tsconfig.json`, and
-* `importSuffix=.js` if executing the generated ts-proto code in an ESM environment
+- `esModuleInterop=true` if using `esModuleInterop` in your `tsconfig.json`, and
+- `importSuffix=.js` if executing the generated ts-proto code in an ESM environment
 
 # Goals
 
@@ -448,9 +448,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=outputBeforeRequest=true`, ts-proto will add a function definition to the Rpc interface definition with the signature: `beforeRequest(request: <RequestType>)`. It will will also automatically set `outputTypeRegistry=true` and `outputServices=true`. 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 will also automatically set `outputServices=default`. Each of the Service's methods will call `beforeRequest` before performing it's request.
 
-- With `--ts_proto_opt=outputAfterResponse=true`, ts-proto will add a function definition to the Rpc interface definition with the signature: `afterResponse(response: <ResponseType>)`. It will will also automatically set `outputTypeRegistry=true` and `outputServices=true`. 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 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=useAbortSignal=true`, the generated services will accept an `AbortSignal` to cancel RPC calls.
 

package/build/generate-grpc-web.js

@@ -301,13 +301,6 @@ function createObservableUnaryMethod(ctx) {
 function createInvokeMethod(ctx) {
     const { options } = ctx;
     const { useAbortSignal } = options;
-    const maybeAbortSignal = useAbortSignal
-        ? `
-      if (abortSignal) abortSignal.addEventListener("abort", () => {
-        observer.error(abortSignal.reason);
-        client.close();
-      });`
-        : "";
     return (0, ts_poet_1.code) `
     invoke<T extends UnaryMethodDefinitionish>(
       methodDesc: T,
@@ -344,14 +337,27 @@ function createInvokeMethod(ctx) {
               }
             },
           });
-          observer.add(() => {
-           ${!useAbortSignal
-        ? `return client.close();`
-        : `if (!abortSignal || !abortSignal.aborted) 
-              return client.close();`}
-          });
+          ${useAbortSignal
+        ? `
+          if (abortSignal) {
+            const abort = () => {
+              observer.error(abortSignal.reason);
+              client.close();
+            };
+            abortSignal.addEventListener("abort", abort);
+            observer.add(() => {
+              if (abortSignal.aborted) {
+                return;
+              }
 
-          ${maybeAbortSignal}
+              abortSignal.removeEventListener('abort', abort); 
+              client.close();
+            });
+          } else {
+            observer.add(() => client.close());
+          }
+          `
+        : `observer.add(() => client.close());`}
         });
         upStream();
       }).pipe(${share}());

package/build/generate-services.js

@@ -87,23 +87,32 @@ function generateRegularRpcMethod(ctx, methodDesc) {
     ];
     const maybeCtx = options.context ? "ctx," : "";
     const maybeAbortSignal = options.useAbortSignal ? "abortSignal || undefined," : "";
+    let errorHandler;
+    if (options.rpcErrorHandler) {
+        errorHandler = (0, ts_poet_1.code) `
+      if (error instanceof Error && this.rpc.handleError) {
+        return Promise.reject(this.rpc.handleError(this.service, "${methodDesc.name}", error));
+      }
+      return Promise.reject(error);
+    `;
+    }
     let encode = (0, ts_poet_1.code) `${rawInputType}.encode(request).finish()`;
     let beforeRequest;
-    if (options.outputBeforeRequest) {
+    if (options.rpcBeforeRequest) {
         beforeRequest = (0, ts_poet_1.code) `
     if (this.rpc.beforeRequest) {
-      this.rpc.beforeRequest(request);
+      this.rpc.beforeRequest(this.service, "${methodDesc.name}", request);
     }`;
     }
-    let decode = (0, ts_poet_1.code) `data => ${rawOutputType}.decode(${Reader}.create(data))`;
-    if (options.outputAfterResponse) {
-        decode = (0, ts_poet_1.code) `data => {
+    let decode = (0, ts_poet_1.code) `${rawOutputType}.decode(${Reader}.create(data))`;
+    if (options.rpcAfterResponse) {
+        decode = (0, ts_poet_1.code) `
       const response = ${rawOutputType}.decode(${Reader}.create(data));
       if (this.rpc.afterResponse) {
-        this.rpc.afterResponse(response);
+        this.rpc.afterResponse(this.service, "${methodDesc.name}", response);
       }
       return response;
-    }`;
+    `;
     }
     // if (options.useDate && rawOutputType.toString().includes("Timestamp")) {
     //   decode = code`data => ${utils.fromTimestamp}(${rawOutputType}.decode(${Reader}.create(data)))`;
@@ -116,19 +125,13 @@ function generateRegularRpcMethod(ctx, methodDesc) {
             encode = (0, ts_poet_1.code) `request.pipe(${(0, ts_poet_1.imp)("map@rxjs/operators")}(request => ${encode}))`;
         }
     }
+    const returnStatement = createDefaultServiceReturn(ctx, methodDesc, decode, errorHandler);
     let returnVariable;
     if (options.returnObservable || methodDesc.serverStreaming) {
         returnVariable = "result";
-        if (options.useAsyncIterable) {
-            decode = (0, ts_poet_1.code) `${rawOutputType}.decodeTransform(result)`;
-        }
-        else {
-            decode = (0, ts_poet_1.code) `result.pipe(${(0, ts_poet_1.imp)("map@rxjs/operators")}(${decode}))`;
-        }
     }
     else {
         returnVariable = "promise";
-        decode = (0, ts_poet_1.code) `promise.then(${decode})`;
     }
     let rpcMethod;
     if (methodDesc.clientStreaming && methodDesc.serverStreaming) {
@@ -155,10 +158,33 @@ function generateRegularRpcMethod(ctx, methodDesc) {
         data,
         ${maybeAbortSignal}
       );
-      return ${decode};
+      return ${returnStatement};
     }
   `;
 }
+function createDefaultServiceReturn(ctx, methodDesc, decode, errorHandler) {
+    const { options } = ctx;
+    const rawOutputType = (0, types_1.responseType)(ctx, methodDesc, { keepValueType: true });
+    if (options.returnObservable || methodDesc.serverStreaming) {
+        if (options.useAsyncIterable) {
+            return (0, ts_poet_1.code) `${rawOutputType}.decodeTransform(result)`;
+        }
+        else {
+            return (0, ts_poet_1.code) `result.pipe(${(0, ts_poet_1.imp)("map@rxjs/operators")}(data => ${decode}))`;
+        }
+    }
+    if (errorHandler) {
+        let tryBlock = decode;
+        if (!options.rpcAfterResponse) {
+            tryBlock = (0, ts_poet_1.code) `return ${decode}`;
+        }
+        return (0, ts_poet_1.code) `promise.then(data => { ${(0, utils_1.tryCatchBlock)(tryBlock, (0, ts_poet_1.code) `return Promise.reject(error);`)}}).catch((error) => { ${errorHandler} })`;
+    }
+    else if (options.rpcAfterResponse) {
+        return (0, ts_poet_1.code) `promise.then(data => { ${decode} } )`;
+    }
+    return (0, ts_poet_1.code) `promise.then(data => ${decode})`;
+}
 function generateServiceClientImpl(ctx, fileDesc, serviceDesc) {
     const { options } = ctx;
     const chunks = [];
@@ -302,11 +328,14 @@ function generateRpcType(ctx, hasStreamingMethods) {
     const maybeAbortSignalParam = options.useAbortSignal ? "abortSignal?: AbortSignal," : "";
     const methods = [[(0, ts_poet_1.code) `request`, (0, ts_poet_1.code) `Uint8Array`, (0, ts_poet_1.code) `Promise<Uint8Array>`]];
     const additionalMethods = [];
-    if (options.outputBeforeRequest) {
-        additionalMethods.push((0, ts_poet_1.code) `beforeRequest?<T extends { [k in keyof T]: unknown }>(request: T): void;`);
+    if (options.rpcBeforeRequest) {
+        additionalMethods.push((0, ts_poet_1.code) `beforeRequest?<T extends { [k in keyof T]: unknown }>(service: string, method: string, request: T): void;`);
+    }
+    if (options.rpcAfterResponse) {
+        additionalMethods.push((0, ts_poet_1.code) `afterResponse?<T extends { [k in keyof T]: unknown }>(service: string, method: string, response: T): void;`);
     }
-    if (options.outputAfterResponse) {
-        additionalMethods.push((0, ts_poet_1.code) `afterResponse?<T extends { [k in keyof T]: unknown }>(response: T): void;`);
+    if (options.rpcErrorHandler) {
+        additionalMethods.push((0, ts_poet_1.code) `handleError?(service: string, method: string, error: Error): Error;`);
     }
     if (hasStreamingMethods) {
         const observable = (0, types_1.observableType)(ctx, true);

package/build/options.js

@@ -93,8 +93,9 @@ function defaultOptions() {
         outputExtensions: false,
         outputIndex: false,
         M: {},
-        outputBeforeRequest: false,
-        outputAfterResponse: false,
+        rpcBeforeRequest: false,
+        rpcAfterResponse: false,
+        rpcErrorHandler: false,
     };
 }
 exports.defaultOptions = defaultOptions;
@@ -183,8 +184,12 @@ function optionsFromParameter(parameter) {
     if (options.outputIndex) {
         options.exportCommonSymbols = false;
     }
-    if (options.outputBeforeRequest || options.outputAfterResponse) {
+    if (options.rpcBeforeRequest || options.rpcAfterResponse || options.rpcErrorHandler) {
+        const includesGeneric = options.outputServices.includes(ServiceOption.GENERIC);
         options.outputServices = [ServiceOption.DEFAULT];
+        if (includesGeneric) {
+            options.outputServices.push(ServiceOption.GENERIC);
+        }
     }
     if (options.unrecognizedEnumValue) {
         // Make sure to cast number options to an actual number

package/build/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.impProto = exports.impFile = exports.getPropertyAccessor = exports.safeAccessor = exports.getFieldName = exports.getFieldJsonName = exports.FormattedMethodDescriptor = exports.assertInstanceOf = exports.maybePrefixPackage = exports.prefixDisableLinter = exports.maybeAddComment = exports.upperFirst = exports.lowerFirst = exports.singular = exports.fail = exports.readToBuffer = exports.generateIndexFiles = exports.protoFilesToGenerate = void 0;
+exports.tryCatchBlock = exports.impProto = exports.impFile = exports.getPropertyAccessor = exports.safeAccessor = exports.getFieldName = exports.getFieldJsonName = exports.FormattedMethodDescriptor = exports.assertInstanceOf = exports.maybePrefixPackage = exports.prefixDisableLinter = exports.maybeAddComment = exports.upperFirst = exports.lowerFirst = exports.singular = exports.fail = exports.readToBuffer = exports.generateIndexFiles = exports.protoFilesToGenerate = void 0;
 const path = require("path");
 const ts_poet_1 = require("ts-poet");
 const options_1 = require("./options");
@@ -243,3 +243,11 @@ function impProto(options, module, type) {
     return (0, ts_poet_1.imp)(`${prefix}${type}@./${module}${options.fileSuffix}${options.importSuffix}`);
 }
 exports.impProto = impProto;
+function tryCatchBlock(tryBlock, handleErrorBlock) {
+    return (0, ts_poet_1.code) `try {
+    ${tryBlock}
+  } catch (error) {
+    ${handleErrorBlock}
+  }`;
+}
+exports.tryCatchBlock = tryCatchBlock;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "1.164.1",
+  "version": "1.165.0",
   "description": "",
   "main": "build/plugin.js",
   "repository": "github:stephenh/ts-proto",
@@ -15,7 +15,7 @@
     "proto2bin-node": "docker compose run --rm node update-bins.sh",
     "proto2pbjs": "docker compose run --rm protoc pbjs.sh",
     "bin2ts": "docker compose run --rm protoc codegen.sh",
-    "test": "yarn jest -c jest.config.js --maxWorkers=2",
+    "test": "yarn jest -c jest.config.js",
     "tsc:check": "./tsc-check.sh tsconfig.json tests/tsconfig.json integration/tsconfig.json integration/tsconfig.proto.json protos/tsconfig.json",
     "format": "prettier --write {src,tests}/**/*.ts integration/*.ts",
     "format:check": "prettier --list-different {src,tests}/**/*.ts",