velocious 1.0.97 → 1.0.98

package/src/http-server/client/request-buffer/index.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import {EventEmitter} from "events"
 import FormDataPart from "./form-data-part.js"
 import Header from "./header.js"
@@ -8,18 +10,38 @@ import querystring from "querystring"
 
 export default class RequestBuffer {
   bodyLength = 0
+
+  /** @type {number[]} */
   data = []
+
   events = new EventEmitter()
+
+  /** @type {Record<string, Header>} */
   headersByName = {}
+
+  multiPartyFormData = false
+
   params = {}
   readingBody = false
   state = "status"
 
+  /**
+   * @param {object} args
+   * @param {import("../../../configuration.js").default} args.configuration
+   */
   constructor({configuration}) {
     this.configuration = configuration
     this.logger = new Logger(this, {debug: false})
   }
 
+  destroy() {
+    // Do nothing for now...
+  }
+
+  /**
+   * @param {Buffer} data
+   * @returns {void}
+   */
   feed(data) {
     for (const char of data) {
       if (this.readingBody) this.bodyLength += 1
@@ -40,6 +62,10 @@ export default class RequestBuffer {
 
           break
         case "multi-part-form-data-body":
+          if (!this.formDataPart) throw new Error("FormData part not initialized")
+          if (!this.boundaryLineEnd) throw new Error("Boundary line end not initialized")
+          if (!this.boundaryLineNext) throw new Error("Boundary line next not initialized")
+
           const body = this.formDataPart.body // eslint-disable-line no-case-declarations
 
           body.push(char)
@@ -71,6 +97,8 @@ export default class RequestBuffer {
 
           break
         case "post-body":
+          if (!this.postBodyChars) throw new Error("postBodyChars not initialized")
+
           this.postBodyChars[this.bodyLength - 1] = char
 
           if (this.contentLength && this.bodyLength >= this.contentLength) {
@@ -84,6 +112,10 @@ export default class RequestBuffer {
     }
   }
 
+  /**
+   * @param {string} name
+   * @returns {Header}
+   */
   getHeader(name) {
     const result = this.headersByName[name.toLowerCase().trim()]
 
@@ -92,7 +124,11 @@ export default class RequestBuffer {
     return result
   }
 
+  /**
+   * @returns {Record<string, string>}
+   */
   getHeadersHash() {
+    /** @type {Record<string, string>} */
     const result = {}
 
     for (const headerFormattedName in this.headersByName) {
@@ -104,9 +140,14 @@ export default class RequestBuffer {
     return result
   }
 
+  /**
+   * @returns {void}
+   */
   formDataPartDone() {
     const formDataPart = this.formDataPart
 
+    if (!formDataPart) throw new Error("formDataPart wasnt set")
+
     this.formDataPart = undefined
     formDataPart.finish()
 
@@ -117,11 +158,18 @@ export default class RequestBuffer {
     return this.multiPartyFormData
   }
 
+  /**
+   * @returns {void}
+   */
   newFormDataPart() {
     this.formDataPart = new FormDataPart()
     this.setState("multi-part-form-data-header")
   }
 
+  /**
+   * @param {string} line
+   * @returns {void}
+   */
   parse(line) {
     if (this.state == "status") {
       this.parseStatusLine(line)
@@ -139,8 +187,10 @@ export default class RequestBuffer {
       const header = this.readHeaderFromLine(line)
 
       if (header) {
+        if (!this.formDataPart) throw new Error("formDataPart not set")
+
         this.formDataPart.addHeader(header)
-        this.state == "multi-part-form-data"
+        //this.state == "multi-part-form-data"
       } else if (line == "\r\n") {
         this.setState("multi-part-form-data-body")
       }
@@ -149,6 +199,10 @@ export default class RequestBuffer {
     }
   }
 
+  /**
+   * @param {string} line
+   * @returns {Header | undefined}
+   */
   readHeaderFromLine(line) {
     const match = line.match(/^(.+): (.+)\r\n/)
 
@@ -159,6 +213,9 @@ export default class RequestBuffer {
     }
   }
 
+  /**
+   * @param {Header} header
+   */
   addHeader(header) {
     const formattedName = header.getFormattedName()
 
@@ -167,6 +224,10 @@ export default class RequestBuffer {
     if (formattedName == "content-length") this.contentLength = parseInt(header.getValue())
   }
 
+  /**
+   * @param {string} line
+   * @returns {void}
+   */
   parseHeader(line) {
     const header = this.readHeaderFromLine(line)
 
@@ -175,9 +236,9 @@ export default class RequestBuffer {
       this.addHeader(header)
       this.events.emit("header", header)
     } else if (line == "\r\n") {
-      if (this.httpMethod.toUpperCase() == "GET" || this.httpMethod.toUpperCase() == "OPTIONS") {
+      if (this.httpMethod?.toUpperCase() == "GET" || this.httpMethod?.toUpperCase() == "OPTIONS") {
         this.completeRequest()
-      } else if (this.httpMethod.toUpperCase() == "POST") {
+      } else if (this.httpMethod?.toUpperCase() == "POST") {
         this.readingBody = true
         this.bodyLength = 0
 
@@ -196,8 +257,11 @@ export default class RequestBuffer {
           } else if (!this.contentLength) {
             throw new Error("Content length hasn't been set")
           } else {
-            this.postBodyBuffer = new ArrayBuffer(this.contentLength)
-            this.postBodyChars = new Uint8Array(this.postBodyBuffer)
+            /** @type {number[]} */
+            this.postBodyChars = []
+
+            // this.postBodyBuffer = new ArrayBuffer(this.contentLength)
+            // this.postBodyChars = new Uint8Array(this.postBodyBuffer)
 
             this.setState("post-body")
           }
@@ -208,6 +272,10 @@ export default class RequestBuffer {
     }
   }
 
+  /**
+   * @param {string} line
+   * @returns {void}
+   */
   parseStatusLine(line) {
     const match = line.match(/^(GET|OPTIONS|POST) (.+?) HTTP\/(.+)\r\n/)
 
@@ -223,14 +291,20 @@ export default class RequestBuffer {
   }
 
   postRequestDone() {
-    this.postBody = String.fromCharCode.apply(null, this.postBodyChars)
+    if (this.postBodyChars) {
+      this.postBody = String.fromCharCode.apply(null, this.postBodyChars)
+    }
 
     delete this.postBodyChars
-    delete this.postBodyBuffer
+    // delete this.postBodyBuffer
 
     this.completeRequest()
   }
 
+  /**
+   * @param {string} newState
+   * @returns {void}
+   */
   setState(newState) {
     this.logger.debug(() => [`Changing state from ${this.state} to ${newState}`])
     this.state = newState
@@ -251,16 +325,20 @@ export default class RequestBuffer {
   }
 
   parseApplicationJsonParams() {
-    const newParams = JSON.parse(this.postBody)
+    if (this.postBody) {
+      const newParams = JSON.parse(this.postBody)
 
-    incorporate(this.params, newParams)
+      incorporate(this.params, newParams)
+    }
   }
 
   parseQueryStringPostParams() {
-    const unparsedParams = querystring.parse(this.postBody)
-    const paramsToObject = new ParamsToObject(unparsedParams)
-    const newParams = paramsToObject.toObject()
+    if (this.postBody) {
+      const unparsedParams = querystring.parse(this.postBody)
+      const paramsToObject = new ParamsToObject(unparsedParams)
+      const newParams = paramsToObject.toObject()
 
-    incorporate(this.params, newParams)
+      incorporate(this.params, newParams)
+    }
   }
 }

package/src/http-server/client/request-parser.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import {digg} from "diggerize"
 import {EventEmitter} from "events"
 import {incorporate} from "incorporator"
@@ -5,6 +7,10 @@ import ParamsToObject from "./params-to-object.js"
 import RequestBuffer from "./request-buffer/index.js"
 
 export default class VelociousHttpServerClientRequestParser {
+  /**
+   * @param {object} args
+   * @param {import("../../configuration.js").default} args.configuration
+   */
   constructor({configuration}) {
     if (!configuration) throw new Error("No configuration given")
 
@@ -26,7 +32,12 @@ export default class VelociousHttpServerClientRequestParser {
     this.requestBuffer.destroy()
   }
 
+  /**
+   * @param {import("./request-buffer/form-data-part.js").default} formDataPart
+   * @returns {void}
+   */
   onFormDataPart = (formDataPart) => {
+    /** @type {Record<string, string>} */
     const unorderedParams = {}
 
     unorderedParams[formDataPart.getName()] = formDataPart.getValue()
@@ -37,10 +48,25 @@ export default class VelociousHttpServerClientRequestParser {
     incorporate(this.params, newParams)
   }
 
+  /**
+   * @param {Buffer} data
+   */
   feed = (data) => this.requestBuffer.feed(data)
+
+  /**
+   * @param {string} name
+   */
   getHeader(name) { return this.requestBuffer.getHeader(name)?.value }
   getHeaders() { return this.requestBuffer.getHeadersHash() }
+
+  /**
+   * @returns {string}
+   */
   getHttpMethod() { return digg(this, "requestBuffer", "httpMethod") }
+
+  /**
+   * @returns {string}
+   */
   getHttpVersion() { return digg(this, "requestBuffer", "httpVersion") }
 
   _getHostMatch() {

package/src/http-server/client/request-runner.js

@@ -1,4 +1,7 @@
+// @ts-check
+
 import BacktraceCleaner from "../../utils/backtrace-cleaner.js"
+import ensureError from "../../utils/ensure-error.js"
 import EventEmitter from "events"
 import {Logger} from "../../logger.js"
 import Response from "./response.js"
@@ -7,6 +10,11 @@ import RoutesResolver from "../../routes/resolver.js"
 export default class VelociousHttpServerClientRequestRunner {
   events = new EventEmitter()
 
+  /**
+   * @param {object} args
+   * @param {import("../../configuration.js").default} args.configuration
+   * @param {import("./request.js").default} args.request
+   */
   constructor({configuration, request}) {
     if (!configuration) throw new Error("No configuration given")
     if (!request) throw new Error("No request given")
@@ -30,8 +38,10 @@ export default class VelociousHttpServerClientRequestRunner {
       // Before we checked if the sec-fetch-mode was "cors", but it seems the sec-fetch-mode isn't always present
       await this.logger.debug(() => ["Run CORS", {httpMethod: request.httpMethod(), secFetchMode: request.header("sec-fetch-mode")}])
 
-      if (configuration.cors) {
-        await configuration.cors({request, response})
+      const cors = configuration.getCors()
+
+      if (cors) {
+        await cors({request, response})
       }
 
       if (request.httpMethod() == "OPTIONS" && request.header("sec-fetch-mode") == "cors") {
@@ -43,7 +53,9 @@ export default class VelociousHttpServerClientRequestRunner {
 
         await routesResolver.resolve()
       }
-    } catch (error) {
+    } catch (e) {
+      const error = ensureError(e)
+
       await this.logger.error(() => [`Error while running request: ${BacktraceCleaner.getCleanedStack(error)}`])
 
       response.setStatus(500)

package/src/http-server/client/request.js

@@ -1,8 +1,15 @@
+// @ts-check
+
 import {digg} from "diggerize"
 import RequestParser from "./request-parser.js"
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousHttpServerClientRequest {
+  /**
+   * @param {object} args
+   * @param {import("./index.js").default} args.client
+   * @param {import("../../configuration.js").default} args.configuration
+   */
   constructor({client, configuration, ...restArgs}) {
     restArgsError(restArgs)
 
@@ -12,7 +19,17 @@ export default class VelociousHttpServerClientRequest {
   }
 
   baseURL() { return `${this.protocol()}://${this.hostWithPort()}` }
+
+  /**
+   * @param {Buffer} data
+   * @returns {void}
+   */
   feed(data) { return this.requestParser.feed(data) }
+
+  /**
+   * @param {string} headerName
+   * @returns {string | null}
+   */
   header(headerName) { return this.getRequestBuffer().getHeader(headerName)?.getValue() }
   headers() { return this.getRequestBuffer().getHeadersHash() }
   httpMethod() { return this.requestParser.getHttpMethod() }

package/src/http-server/client/response.js

@@ -1,11 +1,25 @@
+// @ts-check
+
 export default class VelociousHttpServerClientResponse {
-  body = undefined
+  /** @type {string | null} */
+  body = null
+
+  /** @type {Record<string, string[]>} */
   headers = {}
 
+  /**
+   * @param {object} args
+   * @param {import("../../configuration.js").default} args.configuration
+   */
   constructor({configuration}) {
     this.configuration = configuration
   }
 
+  /**
+   * @param {string} key
+   * @param {string} value
+   * @returns {void}
+   */
   addHeader(key, value) {
     if (!(key in this.headers)) {
       this.headers[key] = []
@@ -14,10 +28,18 @@ export default class VelociousHttpServerClientResponse {
     this.headers[key].push(value)
   }
 
+  /**
+   * @param {string} key
+   * @param {string} value
+   * @returns {void}
+   */
   setHeader(key, value) {
     this.headers[key] = [value]
   }
 
+  /**
+   * @returns {string | null}
+   */
   getBody() {
     if (this.body !== undefined) {
       return this.body
@@ -26,23 +48,41 @@ export default class VelociousHttpServerClientResponse {
     throw new Error("No body has been set")
   }
 
+  /**
+   * @returns {number}
+   */
   getStatusCode() {
     return this.statusCode || 200
   }
 
+  /**
+   * @returns {string}
+   */
   getStatusMessage() {
     return this.statusMessage || "OK"
   }
 
+  /**
+   * @param {string} value
+   * @returns {void}
+   */
   setBody(value) {
     this.body = value
   }
 
+  /**
+   * @param {Error} error
+   * @returns {void}
+   */
   setErrorBody(error) {
     this.setHeader("Content-Type", "text/plain; charset=UTF-8")
     this.setBody(`${error.message}\n\n${error.stack}`)
   }
 
+  /**
+   * @param {number | string} status
+   * @returns {void}
+   */
   setStatus(status) {
     if (status == "success" || status == 200) {
       this.statusCode = 200

package/src/http-server/index.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import {digg} from "diggerize"
 import EventEmitter from "events"
 import {Logger} from "../logger.js"
@@ -7,11 +9,23 @@ import WorkerHandler from "./worker-handler/index.js"
 
 export default class VelociousHttpServer {
   clientCount = 0
+
+  /** @type {Record<string, ServerClient>}  */
   clients = {}
+
   events = new EventEmitter()
   workerCount = 0
+
+  /** @type {WorkerHandler[]} */
   workerHandlers = []
 
+  /**
+   * @param {object} args
+   * @param {import("../configuration.js").default} args.configuration
+   * @param {string} [args.host]
+   * @param {number} [args.port]
+   * @param {number} [args.maxWorkers]
+   */
   constructor({configuration, host, maxWorkers, port}) {
     this.configuration = configuration
     this.logger = new Logger(this)
@@ -33,10 +47,12 @@ export default class VelociousHttpServer {
 
   _netServerListen() {
     return new Promise((resolve, reject) => {
+      if (!this.netServer) throw new Error("No netServer")
+
       try {
         this.netServer.listen(this.port, this.host, () => {
           this.logger.debug(`Velocious listening on ${this.host}:${this.port}`)
-          resolve()
+          resolve(null)
         })
       } catch (error) {
         reject(error)
@@ -54,7 +70,11 @@ export default class VelociousHttpServer {
    * @returns {boolean}
    */
   isActive() {
-    return this.netServer.listening
+    if (this.netServer) {
+      return this.netServer.listening
+    }
+
+    return false
   }
 
   async stopClients() {
@@ -71,11 +91,13 @@ export default class VelociousHttpServer {
 
   stopServer() {
     return new Promise((resolve, reject) => {
+      if (!this.netServer) throw new Error("No netServer to stop")
+
       this.netServer.close((error) => {
         if (error) {
           reject(error)
         } else {
-          resolve()
+          resolve(null)
         }
       })
     })
@@ -90,6 +112,9 @@ export default class VelociousHttpServer {
     this.events.emit("close")
   }
 
+  /**
+   * @param {import("net").Socket} socket
+   */
   onConnection = (socket) => {
     const clientCount = this.clientCount
 
@@ -110,6 +135,9 @@ export default class VelociousHttpServer {
     this.clients[clientCount] = client
   }
 
+  /**
+   * @param {ServerClient} client
+   */
   onClientClose = (client) => {
     const clientCount = digg(client, "clientCount")
     const oldClientsLength = Object.keys(this.clients).length
@@ -140,7 +168,7 @@ export default class VelociousHttpServer {
   workerHandlerToUse() {
     this.logger.debug(`Worker handlers length: ${this.workerHandlers.length}`)
 
-    const randomWorkerNumber = parseInt(Math.random() * this.workerHandlers.length)
+    const randomWorkerNumber = Math.floor(Math.random() * this.workerHandlers.length)
     const workerHandler = this.workerHandlers[randomWorkerNumber]
 
     if (!workerHandler) {

package/src/http-server/server-client.js

@@ -1,9 +1,17 @@
+// @ts-check
+
 import EventEmitter from "events"
 import {Logger} from "../logger.js"
 
 export default class ServerClient {
   events = new EventEmitter()
 
+  /**
+   * @param {object} args
+   * @param {import("../configuration.js").default} args.configuration
+   * @param {import("net").Socket} args.socket
+   * @param {number} args.clientCount
+   */
   constructor({configuration, socket, clientCount}) {
     if (!configuration) throw new Error("No configuration given")
 
@@ -15,18 +23,26 @@ export default class ServerClient {
     socket.on("end", this.onSocketEnd)
   }
 
-  listen = () => this.socket.on("data", this.onSocketData)
+  listen() {
+    this.socket.on("data", this.onSocketData)
+  }
 
   end() {
     return new Promise((resolve) => {
-      this.socket.once("close", () => resolve())
+      this.socket.once("close", () => resolve(null))
       this.socket.end()
     })
   }
 
+  /**
+   * @param {Buffer} chunk
+   * @returns {void}
+   */
   onSocketData = (chunk) => {
     this.logger.debug(() => [`Socket ${this.clientCount}: ${chunk}`])
 
+    if (!this.worker) throw new Error("No worker")
+
     this.worker.postMessage({
       command: "clientWrite",
       chunk,
@@ -34,11 +50,18 @@ export default class ServerClient {
     })
   }
 
+  /**
+   * @returns {void}
+   */
   onSocketEnd = () => {
     this.logger.debug(`Socket ${this.clientCount} end`)
     this.events.emit("close", this)
   }
 
+  /**
+   * @param {string} data
+   * @returns {Promise<void>}
+   */
   async send(data) {
     return new Promise((resolve) => {
       this.logger.debug("Send", data)
@@ -47,4 +70,12 @@ export default class ServerClient {
       })
     })
   }
+
+  /**
+   * @param {import("worker_threads").Worker} newWorker
+   * @returns {void}
+   */
+  setWorker(newWorker) {
+    this.worker = newWorker
+  }
 }