Refactoring, dependencies update

Author: piliugin-anton

docs/README.md

@@ -324,15 +324,15 @@ const path = require("path");
 
 const uquik = new Server();
 
-const static = StaticFiles({
+const staticFiles = StaticFiles({
   root: path.join(__dirname, "www"), // root directory
   indexFile: "index.html", // index file name
   compress: true, // enable gzip compression?
   compressionThreshold: 1024, // compression threshold
 });
 
-uquik.get("/*", static);
-uquik.head("/*", static);
+uquik.get("/*", staticFiles);
+uquik.head("/*", staticFiles);
 
 uquik
   .listen(5000, "127.0.0.1")

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "uquik",
-  "version": "1.0.39",
+  "version": "1.0.40",
   "description": "uQuik HTTP(S) framework",
   "main": "index.js",
   "scripts": {
@@ -9,9 +9,9 @@
   "dependencies": {
     "ajv": "^8.11.0",
     "dotenv": "^16.0.1",
-    "fast-jwt": "^1.6.0",
+    "fast-jwt": "^1.6.1",
     "fast-uri": "^2.1.0",
-    "readable-stream": "^4.0.0",
+    "readable-stream": "^4.1.0",
     "steed": "^1.1.3",
     "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.10.0"
   },

package.json

@@ -269,7 +269,10 @@ class Response extends Writable {
         // Wait for this chunk to be written to the client
         let drained = false
         return this.drain(() => {
-          if (this.completed) return true
+          if (this.completed) {
+            callback()
+            return true
+          }
           // Call the callback once the chunk is drained
           if (!drained) {
             drained = true
@@ -382,72 +385,86 @@ class Response extends Writable {
   }
 
   /**
+     * Writes a given chunk to the client over uWS with the appropriate writing method.
+     * Note! This method uses `uWS.tryEnd()` when a `total_size` is provided.
+     * Note! This method uses `uWS.write()` when a `total_size` is not provided.
+     *
      * @private
+     * @param {Buffer} chunk
+     * @param {Number=} total_size
+     * @returns {Array<Boolean>} [sent, finished]
+     */
+  _uws_write_chunk (chunk, totalSize) {
+    // The specific uWS method to stream the chunk to the client differs depending on if we have a total_size or not
+    if (totalSize) {
+      // Attempt to stream the current chunk using uWS.tryEnd with a total size
+      return this.raw_response.tryEnd(chunk, totalSize)
+    } else {
+      // Attempt to stream the current chunk uWS.write()
+      const sent = this.raw_response.write(chunk)
+
+      // Since we are streaming without a total size, we are not finished
+      return [sent, false]
+    }
+  }
+
+  /**
      * Streams individual chunk from a stream.
      * Delivers with chunked transfer without content-length header when no total_size is specified.
      * Delivers with backpressure handling and content-length header when a total_size is specified.
      *
+     * @private
      * @param {Readable} stream
      * @param {Buffer} chunk
-     * @param {Number=} totalSize
+     * @param {Number=} total_size
      */
   _stream_chunk (stream, chunk, totalSize) {
     // Ensure the client is still connected and request is pending
     if (!this.completed) {
-      // Attempt to stream the chunk using appropriate uWS.Response chunk serving method
-      // This will depend on whether a total_size is specified or not
-      let sent, finished
-      const lastOffset = this.raw_response.getWriteOffset()
-      if (totalSize) {
-        // Attempt to stream the current chunk using uWS.tryEnd with a total size
-        const [ok, done] = this.raw_response.tryEnd(chunk, totalSize)
-        sent = ok
-        finished = done
-      } else {
-        // Attempt to stream the current chunk uWS.write()
-        sent = this.raw_response.write(chunk)
-
-        // Since we are streaming without a total size, we are not finished
-        finished = false
-      }
-
+      // Write the chunk to the client using the appropriate uWS chunk writing method
+      const [sent, finished] = this._uws_write_chunk(chunk, totalSize)
       if (finished) {
-        // If streaming has finished, we can destroy the readable stream just to be safe
+        // Destroy the readable stream as no more writing will occur
         if (!stream.destroyed) stream.destroy()
       } else if (!sent) {
-        // Pause the readable stream to prevent any further data from being read
-        stream.pause()
+        // Remember the initial write offset for future backpressure sliced chunks
+        const writeOffset = this.write_offset
+        // Pause the readable stream to prevent any further data from being read as chunk was not fully sent
+        if (stream.readable && !stream.isPaused()) stream.pause()
 
-        this.raw_response.stream_lastOffset = lastOffset
-        this.raw_response.stream_chunk = chunk
-
-        // Bind a drain handler which will resume the once the backpressure is cleared
+        // Bind a drain handler to relieve backpressure
+        // Note! This callback may be called as many times as neccessary to send a full chunk when using the tryEnd method
         this.drain((offset) => {
+          // Check if the response has been completed / connection has been closed
           if (this.completed) {
+            // Destroy the readable stream as no more writing will occur
             if (!stream.destroyed) stream.destroy()
 
+            // Return true to signify this was a no-op
             return true
           }
 
+          // If we have a total size then we need to serve sliced chunks as uWS does not buffer under the hood
           if (totalSize) {
-            const [ok, done] = this.raw_response.tryEnd(this.raw_response.stream_chunk.slice(offset - this.raw_response.stream_lastOffset), totalSize)
-            if (done) {
+            // Slice the chunk to the correct offset and send it to the client
+            const [flushed, ended] = this._uws_write_chunk(chunk.slice(offset - writeOffset), totalSize)
+            if (ended) {
+              // Destroy the readable stream as no more writing will occur
               if (!stream.destroyed) stream.destroy()
-            } else if (ok) {
-              // We sent a chunk and it was not the last one, so let's resume reading.
-              // Timeout is still disabled, so we can spend any amount of time waiting
-              // for more chunks to send.
+            } else if (flushed) {
+              // Resume the readable stream to allow more data to be read
               if (stream.readable && stream.isPaused()) stream.resume()
             }
 
-            // We always have to return true/false in onWritable.
-            // If you did not send anything, return true for success.
-            return ok
-          } else {
-            if (stream.readable && stream.isPaused()) stream.resume()
-
-            return true
+            // Return the flushed boolean as that signifies whether this specific chunk was fully sent
+            return flushed
           }
+
+          // Resume the readable stream to allow more data to be read
+          if (stream.readable && stream.isPaused()) stream.resume()
+
+          // Return true to signify this was a no-op
+          return true
         })
       }
     }
@@ -469,9 +486,7 @@ class Response extends Writable {
     if (!this.completed) {
       this.chunked = true
       // Bind an 'abort' event handler which will destroy the consumed stream if request is aborted
-      this.on('abort', () => {
-        if (!readable.destroyed) readable.destroy()
-      })
+      this.once('abort', () => !readable.destroyed && readable.destroy())
 
       // Initiate response as we will begin writing body chunks
       this._initiate_response()
@@ -605,6 +620,16 @@ class Response extends Writable {
     return this.completed
   }
 
+  /**
+     * Returns the current response body content write offset in bytes.
+     * Use in conjunction with the drain() offset handler to retry writing failed chunks.
+     * Note! This method will return `-1` after the Response has been completed and the connection has been closed.
+     * @returns {Number}
+     */
+  get write_offset () {
+    return this.completed ? -1 : this.raw_response.getWriteOffset()
+  }
+
   /**
      * Returns a "Server-Sent Events" connection object to allow for SSE functionality.
      * This property will only be available for GET requests as per the SSE specification.