@opentap/runner-client 2.3.2-alpha.1.6 → 2.3.2-alpha.1.7

package/lib/BaseClient.js

@@ -99,7 +99,7 @@ var BaseClient = /** @class */ (function () {
         configurable: true
     });
     BaseClient.prototype.withTimeout = function (promise, timeout) {
-        return Promise.race([promise, new Promise(function (_, reject) { return setTimeout(function () { return reject(new Error('Request timed out.')); }, timeout); })]);
+        return Promise.race([promise, new Promise(function (_, reject) { return setTimeout(function () { return reject(new Error(ErrorCode.Timeout)); }, timeout); })]);
     };
     /**
      * Send a request to the nats server.
@@ -111,7 +111,7 @@ var BaseClient = /** @class */ (function () {
     BaseClient.prototype.request = function (subject, payload, options) {
         var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function () {
-            var data, headers, replySubject, chunkSize, requestId, opts, fileDescriptor, chunkNumber, getChunk, subscription, responsePromise, chunk, i;
+            var data, headers, timeout, replySubject, chunkSize, requestId, opts, fileDescriptor, chunkNumber, getChunk, subscription, responsePromise, chunk, i;
             var _this = this;
             return __generator(this, function (_d) {
                 // Prepend the base subject if the given subject does not start with that
@@ -124,6 +124,7 @@ var BaseClient = /** @class */ (function () {
                     return [2 /*return*/, Promise.reject("".concat(subject, ": Connection has been closed! Please reconnect!"))];
                 data = this.encode(payload);
                 headers = this.buildHeaders();
+                timeout = (options === null || options === void 0 ? void 0 : options.timeout) || this.timeout;
                 replySubject = crypto.randomUUID();
                 chunkSize = ((_c = (_b = (_a = this.connection) === null || _a === void 0 ? void 0 : _a.info) === null || _b === void 0 ? void 0 : _b.max_payload) !== null && _c !== void 0 ? _c : 512000) - 2000;
                 // The Session and the Client need to agree on the chunk size. Put it in a header.
@@ -138,49 +139,56 @@ var BaseClient = /** @class */ (function () {
                     var offset = chunk * fileDescriptor.chunkSize;
                     return data.slice(offset, offset + fileDescriptor.chunkSize);
                 };
-                subscription = this.connection.subscribe(replySubject);
+                subscription = this.connection.subscribe(replySubject, { timeout: timeout });
                 responsePromise = new Promise(function (resolve, reject) {
                     var messages = [];
                     subscription.callback = function (error, message) {
                         var _a;
                         if (error) {
+                            subscription.unsubscribe();
+                            console.log('error:', error);
                             reject(error);
                         }
                         // Put all the response chunks in an array in the order they are received
                         messages.push(message);
+                        // If the chunk has a size equal to the chunkSize, we should expect another message
+                        if (message.data.length === chunkSize) {
+                            return;
+                        }
                         // If the chunk has a length smaller than the chunkSize, the message is complete
-                        if (message.data.length < chunkSize) {
-                            // If the final message was received, we can safely unsubscribe
-                            subscription.unsubscribe();
-                            // Check if the number of the final message is equal to the number of
-                            // messages we received. If this is not the case, we dropped a chunk,
-                            // likely due to a network error. In this case, the entire message is invalid.
-                            var finalMessage = messages[messages.length - 1];
-                            var finalMessageNumber = (_a = finalMessage.headers) === null || _a === void 0 ? void 0 : _a.get('ChunkNumber');
-                            if (!finalMessageNumber) {
-                                return reject('Response is not a valid chunk.');
-                            }
-                            if (parseInt(finalMessageNumber) !== messages.length) {
-                                return reject("Expected {finalMessageNumber} chunks, but received ".concat(messages.length, ". ") +
-                                    "The connection may have been interrupted.");
-                            }
-                            // Concatenate the payloads
-                            // When there are many chunks, doing a single allocation
-                            // is significantly faster than concatenating arrays in sequence
-                            var dataArrays = messages.map(function (m) { return m.data; });
-                            var flattenedSize = dataArrays.reduce(function (sum, array) { return sum + array.length; }, 0);
-                            var flattenedArray_1 = new Uint8Array(flattenedSize);
-                            var k_1 = 0;
-                            dataArrays.map(function (m) {
-                                for (var i = 0; i < m.length; i++) {
-                                    flattenedArray_1[k_1++] = m[i];
-                                }
-                            });
-                            return resolve(flattenedArray_1);
+                        // If the final message was received, we can safely unsubscribe
+                        subscription.unsubscribe();
+                        // Check if the number of the final message is equal to the number of
+                        // messages we received. If this is not the case, we dropped a chunk,
+                        // likely due to a network error. In this case, the entire message is invalid.
+                        var finalMessage = message;
+                        var finalMessageNumber = (_a = finalMessage.headers) === null || _a === void 0 ? void 0 : _a.get('ChunkNumber');
+                        if (!finalMessageNumber) {
+                            return reject('Response is not a valid chunk.');
+                        }
+                        if (parseInt(finalMessageNumber) !== messages.length) {
+                            return reject("Expected {finalMessageNumber} chunks, but received ".concat(messages.length, ". ") +
+                                "The connection may have been interrupted.");
                         }
+                        // Concatenate the payloads
+                        // When there are many chunks, doing a single allocation
+                        // is significantly faster than concatenating arrays in sequence
+                        var dataArrays = messages.map(function (m) { return m.data; });
+                        var flattenedSize = dataArrays.reduce(function (sum, array) { return sum + array.length; }, 0);
+                        var flattenedArray = new Uint8Array(flattenedSize);
+                        var k = 0;
+                        dataArrays.map(function (m) {
+                            for (var i = 0; i < m.length; i++) {
+                                flattenedArray[k++] = m[i];
+                            }
+                        });
+                        return resolve(flattenedArray);
                     };
                 })
                     .then(function (byteArray) {
+                    if (byteArray.length === 0) {
+                        return Promise.resolve(undefined);
+                    }
                     var jsonCodec = JSONCodec();
                     // If a raw response is requested, we should avoid decoding the bytes.
                     var response = (options === null || options === void 0 ? void 0 : options.rawResponse) ? byteArray : jsonCodec.decode(byteArray);
@@ -205,10 +213,7 @@ var BaseClient = /** @class */ (function () {
                     this.connection.publish(subject, Empty, opts);
                 }
                 // Now that we have sent the terminating chunk, the result should arrive on our promise.
-                if (options === null || options === void 0 ? void 0 : options.timeout) {
-                    return [2 /*return*/, this.withTimeout(responsePromise, options.timeout)];
-                }
-                return [2 /*return*/, responsePromise];
+                return [2 /*return*/, this.withTimeout(responsePromise, timeout)];
             });
         });
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentap/runner-client",
-  "version": "2.3.2-alpha.1.6",
+  "version": "2.3.2-alpha.1.7",
   "description": "This is the web client for the OpenTAP Runner.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",