@grpc/grpc-js - npm Package Compare versions

Comparing version 1.2.2 to 1.2.3

build/src/call-stream.d.ts

@@ -117,2 +117,3 @@ /// <reference types="node" />
     private listener;
+    private internalErrorMessage;
     constructor(methodName: string, channel: ChannelImplementation, options: CallStreamOptions, filterStackFactory: FilterStackFactory, channelCallCredentials: CallCredentials, callNumber: number);
@@ -119,0 +120,0 @@ private outputStatus;

build/src/call-stream.js

@@ -101,2 +101,3 @@ "use strict";
         this.listener = null;
+        this.internalErrorMessage = null;
         this.filterStack = filterStackFactory.createFilter(this);
@@ -379,58 +380,72 @@ this.credentials = channelCallCredentials;
             stream.on('close', () => {
-                var _a;
-                this.trace('HTTP/2 stream closed with code ' + stream.rstCode);
-                /* If we have a final status with an OK status code, that means that
-                 * we have received all of the messages and we have processed the
-                 * trailers and the call completed successfully, so it doesn't matter
-                 * how the stream ends after that */
-                if (((_a = this.finalStatus) === null || _a === void 0 ? void 0 : _a.code) === constants_1.Status.OK) {
-                    return;
-                }
-                let code;
-                let details = '';
-                switch (stream.rstCode) {
-                    case http2.constants.NGHTTP2_NO_ERROR:
-                        /* If we get a NO_ERROR code and we already have a status, the
-                         * stream completed properly and we just haven't fully processed
-                         * it yet */
-                        if (this.finalStatus !== null) {
-                            return;
-                        }
-                        code = constants_1.Status.INTERNAL;
-                        details = `Received RST_STREAM with code ${stream.rstCode}`;
-                        break;
-                    case http2.constants.NGHTTP2_REFUSED_STREAM:
-                        code = constants_1.Status.UNAVAILABLE;
-                        details = 'Stream refused by server';
-                        break;
-                    case http2.constants.NGHTTP2_CANCEL:
-                        code = constants_1.Status.CANCELLED;
-                        details = 'Call cancelled';
-                        break;
-                    case http2.constants.NGHTTP2_ENHANCE_YOUR_CALM:
-                        code = constants_1.Status.RESOURCE_EXHAUSTED;
-                        details = 'Bandwidth exhausted';
-                        break;
-                    case http2.constants.NGHTTP2_INADEQUATE_SECURITY:
-                        code = constants_1.Status.PERMISSION_DENIED;
-                        details = 'Protocol not secure enough';
-                        break;
-                    case http2.constants.NGHTTP2_INTERNAL_ERROR:
-                        code = constants_1.Status.INTERNAL;
-                        /* This error code was previously handled in the default case, and
-                         * there are several instances of it online, so I wanted to
-                         * preserve the original error message so that people find existing
-                         * information in searches, but also include the more recognizable
-                         * "Internal server error" message. */
-                        details = `Received RST_STREAM with code ${stream.rstCode} (Internal server error)`;
-                        break;
-                    default:
-                        code = constants_1.Status.INTERNAL;
-                        details = `Received RST_STREAM with code ${stream.rstCode}`;
-                }
-                // This is a no-op if trailers were received at all.
-                // This is OK, because status codes emitted here correspond to more
-                // catastrophic issues that prevent us from receiving trailers in the
-                // first place.
-                this.endCall({ code, details, metadata: new metadata_1.Metadata() });
+                /* Use process.next tick to ensure that this code happens after any
+                 * "error" event that may be emitted at about the same time, so that
+                 * we can bubble up the error message from that event. */
+                process.nextTick(() => {
+                    var _a;
+                    this.trace('HTTP/2 stream closed with code ' + stream.rstCode);
+                    /* If we have a final status with an OK status code, that means that
+                     * we have received all of the messages and we have processed the
+                     * trailers and the call completed successfully, so it doesn't matter
+                     * how the stream ends after that */
+                    if (((_a = this.finalStatus) === null || _a === void 0 ? void 0 : _a.code) === constants_1.Status.OK) {
+                        return;
+                    }
+                    let code;
+                    let details = '';
+                    switch (stream.rstCode) {
+                        case http2.constants.NGHTTP2_NO_ERROR:
+                            /* If we get a NO_ERROR code and we already have a status, the
+                             * stream completed properly and we just haven't fully processed
+                             * it yet */
+                            if (this.finalStatus !== null) {
+                                return;
+                            }
+                            code = constants_1.Status.INTERNAL;
+                            details = `Received RST_STREAM with code ${stream.rstCode}`;
+                            break;
+                        case http2.constants.NGHTTP2_REFUSED_STREAM:
+                            code = constants_1.Status.UNAVAILABLE;
+                            details = 'Stream refused by server';
+                            break;
+                        case http2.constants.NGHTTP2_CANCEL:
+                            code = constants_1.Status.CANCELLED;
+                            details = 'Call cancelled';
+                            break;
+                        case http2.constants.NGHTTP2_ENHANCE_YOUR_CALM:
+                            code = constants_1.Status.RESOURCE_EXHAUSTED;
+                            details = 'Bandwidth exhausted';
+                            break;
+                        case http2.constants.NGHTTP2_INADEQUATE_SECURITY:
+                            code = constants_1.Status.PERMISSION_DENIED;
+                            details = 'Protocol not secure enough';
+                            break;
+                        case http2.constants.NGHTTP2_INTERNAL_ERROR:
+                            code = constants_1.Status.INTERNAL;
+                            if (this.internalErrorMessage === null) {
+                                /* This error code was previously handled in the default case, and
+                                 * there are several instances of it online, so I wanted to
+                                 * preserve the original error message so that people find existing
+                                 * information in searches, but also include the more recognizable
+                                 * "Internal server error" message. */
+                                details = `Received RST_STREAM with code ${stream.rstCode} (Internal server error)`;
+                            }
+                            else {
+                                /* The "Received RST_STREAM with code ..." error is preserved
+                                 * here for continuity with errors reported online, but the
+                                 * error message at the end will probably be more relevant in
+                                 * most cases. */
+                                details = `Received RST_STREAM with code ${stream.rstCode} triggered by internal client error: ${this.internalErrorMessage}`;
+                            }
+                            break;
+                        default:
+                            code = constants_1.Status.INTERNAL;
+                            details = `Received RST_STREAM with code ${stream.rstCode}`;
+                    }
+                    // This is a no-op if trailers were received at all.
+                    // This is OK, because status codes emitted here correspond to more
+                    // catastrophic issues that prevent us from receiving trailers in the
+                    // first place.
+                    this.endCall({ code, details, metadata: new metadata_1.Metadata() });
+                });
             });
@@ -441,2 +456,9 @@ stream.on('error', (err) => {
                  * "close" events, where we will handle the error more granularly */
+                /* Specifically looking for stream errors that were *not* constructed
+                 * from a RST_STREAM response here:
+                 * https://github.com/nodejs/node/blob/8b8620d580314050175983402dfddf2674e8e22a/lib/internal/http2/core.js#L2267
+                 */
+                if (err.code !== 'ERR_HTTP2_STREAM_ERROR') {
+                    this.internalErrorMessage = err.message;
+                }
             });
@@ -443,0 +465,0 @@ if (!this.pendingRead) {

build/src/deadline-filter.js

@@ -55,6 +55,8 @@ "use strict";
         let timeout = this.deadline - now;
-        if (timeout < 0) {
-            timeout = 0;
+        if (timeout <= 0) {
+            process.nextTick(() => {
+                callStream.cancelWithStatus(constants_1.Status.DEADLINE_EXCEEDED, 'Deadline exceeded');
+            });
         }
-        if (this.deadline !== Infinity) {
+        else if (this.deadline !== Infinity) {
             this.timer = setTimeout(() => {
@@ -61,0 +63,0 @@ callStream.cancelWithStatus(constants_1.Status.DEADLINE_EXCEEDED, 'Deadline exceeded');

build/src/make-client.js

@@ -33,2 +33,10 @@ "use strict";
 /**
+ * Returns true, if given key is included in the blacklisted
+ * keys.
+ * @param key key for check, string.
+ */
+function isPrototypePolluted(key) {
+    return ['__proto__', 'prototype', 'constructor'].includes(key);
+}
+/**
  * Creates a constructor for a client with the given methods, as specified in
@@ -54,3 +62,3 @@ * the methods argument. The resulting class will have an instance method for
     Object.keys(methods).forEach((name) => {
-        if (name === '__proto__') {
+        if (isPrototypePolluted(name)) {
             return;
@@ -86,3 +94,3 @@ }
         Object.assign(ServiceClientImpl.prototype[name], attrs);
-        if (attrs.originalName && attrs.originalName !== '__proto__') {
+        if (attrs.originalName && !isPrototypePolluted(attrs.originalName)) {
             ServiceClientImpl.prototype[attrs.originalName] =
@@ -116,3 +124,3 @@ ServiceClientImpl.prototype[name];
             const nameComponents = serviceFqn.split('.');
-            if (nameComponents.some(comp => comp === '__proto__')) {
+            if (nameComponents.some((comp) => isPrototypePolluted(comp))) {
                 continue;
@@ -119,0 +127,0 @@ }

package.json

 {
   "name": "@grpc/grpc-js",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "gRPC Library for Node - pure JS implementation",
@@ -5,0 +5,0 @@ "homepage": "https://grpc.io/",

src/call-stream.ts

@@ -40,2 +40,6 @@ /*
 
+interface NodeError extends Error {
+  code: string;
+}
+
 export type Deadline = Date | number;
@@ -206,2 +210,4 @@
 
+  private internalErrorMessage: string | null = null;
+
   constructor(
@@ -523,62 +529,82 @@ private readonly methodName: string,
       stream.on('close', () => {
-        this.trace('HTTP/2 stream closed with code ' + stream.rstCode);
-        /* If we have a final status with an OK status code, that means that
-         * we have received all of the messages and we have processed the
-         * trailers and the call completed successfully, so it doesn't matter
-         * how the stream ends after that */
-        if (this.finalStatus?.code === Status.OK) {
-          return;
-        }
-        let code: Status;
-        let details = '';
-        switch (stream.rstCode) {
-          case http2.constants.NGHTTP2_NO_ERROR:
-            /* If we get a NO_ERROR code and we already have a status, the
-             * stream completed properly and we just haven't fully processed
-             * it yet */
-            if (this.finalStatus !== null) {
-              return;
-            }
-            code = Status.INTERNAL;
-            details = `Received RST_STREAM with code ${stream.rstCode}`;
-            break;
-          case http2.constants.NGHTTP2_REFUSED_STREAM:
-            code = Status.UNAVAILABLE;
-            details = 'Stream refused by server';
-            break;
-          case http2.constants.NGHTTP2_CANCEL:
-            code = Status.CANCELLED;
-            details = 'Call cancelled';
-            break;
-          case http2.constants.NGHTTP2_ENHANCE_YOUR_CALM:
-            code = Status.RESOURCE_EXHAUSTED;
-            details = 'Bandwidth exhausted';
-            break;
-          case http2.constants.NGHTTP2_INADEQUATE_SECURITY:
-            code = Status.PERMISSION_DENIED;
-            details = 'Protocol not secure enough';
-            break;
-          case http2.constants.NGHTTP2_INTERNAL_ERROR:
-            code = Status.INTERNAL;
-            /* This error code was previously handled in the default case, and
-             * there are several instances of it online, so I wanted to
-             * preserve the original error message so that people find existing
-             * information in searches, but also include the more recognizable
-             * "Internal server error" message. */
-            details = `Received RST_STREAM with code ${stream.rstCode} (Internal server error)`;
-            break;
-          default:
-            code = Status.INTERNAL;
-            details = `Received RST_STREAM with code ${stream.rstCode}`;
-        }
-        // This is a no-op if trailers were received at all.
-        // This is OK, because status codes emitted here correspond to more
-        // catastrophic issues that prevent us from receiving trailers in the
-        // first place.
-        this.endCall({ code, details, metadata: new Metadata() });
+        /* Use process.next tick to ensure that this code happens after any
+         * "error" event that may be emitted at about the same time, so that
+         * we can bubble up the error message from that event. */ 
+        process.nextTick(() => {
+          this.trace('HTTP/2 stream closed with code ' + stream.rstCode);
+          /* If we have a final status with an OK status code, that means that
+           * we have received all of the messages and we have processed the
+           * trailers and the call completed successfully, so it doesn't matter
+           * how the stream ends after that */
+          if (this.finalStatus?.code === Status.OK) {
+            return;
+          }
+          let code: Status;
+          let details = '';
+          switch (stream.rstCode) {
+            case http2.constants.NGHTTP2_NO_ERROR:
+              /* If we get a NO_ERROR code and we already have a status, the
+               * stream completed properly and we just haven't fully processed
+               * it yet */
+              if (this.finalStatus !== null) {
+                return;
+              }
+              code = Status.INTERNAL;
+              details = `Received RST_STREAM with code ${stream.rstCode}`;
+              break;
+            case http2.constants.NGHTTP2_REFUSED_STREAM:
+              code = Status.UNAVAILABLE;
+              details = 'Stream refused by server';
+              break;
+            case http2.constants.NGHTTP2_CANCEL:
+              code = Status.CANCELLED;
+              details = 'Call cancelled';
+              break;
+            case http2.constants.NGHTTP2_ENHANCE_YOUR_CALM:
+              code = Status.RESOURCE_EXHAUSTED;
+              details = 'Bandwidth exhausted';
+              break;
+            case http2.constants.NGHTTP2_INADEQUATE_SECURITY:
+              code = Status.PERMISSION_DENIED;
+              details = 'Protocol not secure enough';
+              break;
+            case http2.constants.NGHTTP2_INTERNAL_ERROR:
+              code = Status.INTERNAL;
+              if (this.internalErrorMessage === null) {
+                /* This error code was previously handled in the default case, and
+                 * there are several instances of it online, so I wanted to
+                 * preserve the original error message so that people find existing
+                 * information in searches, but also include the more recognizable
+                 * "Internal server error" message. */
+                details = `Received RST_STREAM with code ${stream.rstCode} (Internal server error)`;
+              } else {
+                /* The "Received RST_STREAM with code ..." error is preserved
+                 * here for continuity with errors reported online, but the
+                 * error message at the end will probably be more relevant in
+                 * most cases. */
+                details = `Received RST_STREAM with code ${stream.rstCode} triggered by internal client error: ${this.internalErrorMessage}`;
+              }
+              break;
+            default:
+              code = Status.INTERNAL;
+              details = `Received RST_STREAM with code ${stream.rstCode}`;
+          }
+          // This is a no-op if trailers were received at all.
+          // This is OK, because status codes emitted here correspond to more
+          // catastrophic issues that prevent us from receiving trailers in the
+          // first place.
+          this.endCall({ code, details, metadata: new Metadata() });
+        });
       });
-      stream.on('error', (err: Error) => {
+      stream.on('error', (err: NodeError) => {
         /* We need an error handler here to stop "Uncaught Error" exceptions
          * from bubbling up. However, errors here should all correspond to
          * "close" events, where we will handle the error more granularly */
+        /* Specifically looking for stream errors that were *not* constructed
+         * from a RST_STREAM response here:
+         * https://github.com/nodejs/node/blob/8b8620d580314050175983402dfddf2674e8e22a/lib/internal/http2/core.js#L2267
+         */
+        if (err.code !== 'ERR_HTTP2_STREAM_ERROR') {
+          this.internalErrorMessage = err.message;
+        }
       });
@@ -585,0 +611,0 @@ if (!this.pendingRead) {

src/deadline-filter.ts

@@ -59,6 +59,10 @@ /*
     let timeout = this.deadline - now;
-    if (timeout < 0) {
-      timeout = 0;
-    }
-    if (this.deadline !== Infinity) {
+    if (timeout <= 0) {
+      process.nextTick(() => {
+        callStream.cancelWithStatus(
+          Status.DEADLINE_EXCEEDED,
+          'Deadline exceeded'
+        );
+      });
+    } else if (this.deadline !== Infinity) {
       this.timer = setTimeout(() => {
@@ -65,0 +69,0 @@ callStream.cancelWithStatus(

src/make-client.ts

@@ -97,2 +97,11 @@ /*
 /**
+ * Returns true, if given key is included in the blacklisted
+ * keys.
+ * @param key key for check, string.
+ */
+function isPrototypePolluted(key: string): Boolean {
+  return ['__proto__', 'prototype', 'constructor'].includes(key);
+}
+
+/**
  * Creates a constructor for a client with the given methods, as specified in
@@ -126,3 +135,3 @@ * the methods argument. The resulting class will have an instance method for
   Object.keys(methods).forEach((name) => {
-    if (name === '__proto__') {
+    if (isPrototypePolluted(name)) {
       return;
@@ -160,3 +169,3 @@ }
     Object.assign(ServiceClientImpl.prototype[name], attrs);
-    if (attrs.originalName && attrs.originalName !== '__proto__') {
+    if (attrs.originalName && !isPrototypePolluted(attrs.originalName)) {
       ServiceClientImpl.prototype[attrs.originalName] =
@@ -210,3 +219,3 @@ ServiceClientImpl.prototype[name];
       const nameComponents = serviceFqn.split('.');
-      if (nameComponents.some(comp => comp === '__proto__')) {
+      if (nameComponents.some((comp: string) => isPrototypePolluted(comp))) {
         continue;
@@ -213,0 +222,0 @@ }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

937246

increased by0.48%

Lines of code

19486

increased by0.36%

No dependency changes