velocious 1.0.55 → 1.0.57

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.55",
+  "version": "1.0.57",
   "main": "index.js",
   "scripts": {
     "test": "VELOCIOUS_TEST_DIR=../ cd spec/dummy && npx velocious test",
@@ -22,6 +22,7 @@
   "homepage": "https://github.com/kaspernj/velocious#readme",
   "description": "",
   "dependencies": {
+    "async-mutex": "^0.5.0",
     "awaitery": "^1.0.1",
     "bcryptjs": "^3.0.2",
     "better-localstorage": "^1.0.7",

package/spec/dummy/index.js

@@ -57,13 +57,6 @@ export default class Dummy {
 
     this.application = new Application({
       configuration: dummyConfiguration,
-      databases: {
-        default: {
-          host: "mysql",
-          username: "user",
-          password: ""
-        }
-      },
       httpServer: {
         maxWorkers: 1,
         port: 3006

package/spec/dummy/src/config/configuration.example.js

@@ -1,3 +1,4 @@
+import "../../../../src/utils/with-tracked-stack-async-hooks.js"
 import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
 import Configuration from "../../../../src/configuration.js"
 import dummyDirectory from "../../dummy-directory.js"

package/spec/dummy/src/config/configuration.peakflow.mariadb.js

@@ -1,3 +1,4 @@
+import "../../../../src/utils/with-tracked-stack-async-hooks.js"
 import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
 import Configuration from "../../../../src/configuration.js"
 import dummyDirectory from "../../dummy-directory.js"

package/spec/dummy/src/config/configuration.peakflow.mssql.js

@@ -1,3 +1,4 @@
+import "../../../../src/utils/with-tracked-stack-async-hooks.js"
 import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
 import Configuration from "../../../../src/configuration.js"
 import dummyDirectory from "../../dummy-directory.js"

package/spec/dummy/src/config/configuration.peakflow.pgsql.js

@@ -1,3 +1,4 @@
+import "../../../../src/utils/with-tracked-stack-async-hooks.js"
 import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
 import Configuration from "../../../../src/configuration.js"
 import dummyDirectory from "../../dummy-directory.js"

package/spec/dummy/src/config/configuration.peakflow.sqlite.js

@@ -1,3 +1,4 @@
+import "../../../../src/utils/with-tracked-stack-async-hooks.js"
 import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.js"
 import Configuration from "../../../../src/configuration.js"
 import dummyDirectory from "../../dummy-directory.js"

package/spec/http-server/get-spec.js

@@ -1,5 +1,8 @@
 import fetch from "node-fetch"
 import Dummy from "../dummy/index.js"
+import Header from "../../src/http-client/header.js"
+import HttpClient from "../../src/http-client/index.js"
+import {wait, waitFor} from "awaitery"
 
 describe("HttpServer - get", {databaseCleaning: {transaction: false, truncate: true}}, () => {
   it("handles get requests", async () => {
@@ -27,4 +30,57 @@ describe("HttpServer - get", {databaseCleaning: {transaction: false, truncate: t
       }
     })
   })
+
+  it("supports HTTP 1.0 close connection", async () => {
+    await Dummy.run(async () => {
+      await wait(200)
+
+      const httpClient = new HttpClient({
+        debug: false,
+        headers: [
+          new Header("Connection", "Close")
+        ],
+        version: "1.0"
+      })
+
+      await httpClient.connect()
+
+      const {response} = await httpClient.get("/ping")
+
+      expect(response.json()).toEqual({message: "Pong"})
+      expect(response.getHeader("Connection")?.value).toEqual("Close")
+
+      await waitFor(() => {
+        if (httpClient.isConnected()) throw new Error("HTTP client is still connected")
+      })
+    })
+  })
+
+  it("supports HTTP 1.0 keep-alive", async () => {
+    await Dummy.run(async () => {
+      await wait(200)
+
+      const httpClient = new HttpClient({
+        debug: false,
+        headers: [
+          new Header("Connection", "Keep-Alive")
+        ],
+        version: "1.0"
+      })
+
+      await httpClient.connect()
+
+      for (let i = 0; i < 5; i++) {
+        const {response} = await httpClient.get("/ping")
+
+        expect(response.json()).toEqual({message: "Pong"})
+        expect(response.getHeader("Connection")?.value).toEqual("Keep-Alive")
+        await wait(100)
+        expect(httpClient.isConnected()).toBeTrue()
+      }
+
+      await wait(500)
+      expect(httpClient.isConnected()).toBeTrue()
+    })
+  })
 })

package/src/application.js

@@ -38,7 +38,6 @@ export default class VelociousApplication {
 
   async startHttpServer() {
     const {configuration, httpServerConfiguration} = digs(this, "configuration", "httpServerConfiguration")
-
     const port = httpServerConfiguration.port || 3006
 
     await this.logger.debug(`Starting server on port ${port}`)

package/src/database/drivers/base.js

@@ -6,13 +6,16 @@ import UUID from "pure-uuid"
 import TableData from "../table-data/index.js"
 import TableColumn from "../table-data/table-column.js"
 import TableForeignKey from "../table-data/table-foreign-key.js"
+import {Mutex} from "async-mutex"
 
 export default class VelociousDatabaseDriversBase {
   constructor(config, configuration) {
     this._args = config
     this.configuration = configuration
+    this.mutex = new Mutex() // Can be used to lock this instance for exclusive use
     this.logger = new Logger(this)
     this._transactionsCount = 0
+    this._transactionsActionsMutex = new Mutex()
   }
 
   async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, args) {
@@ -206,18 +209,36 @@ export default class VelociousDatabaseDriversBase {
   }
 
   async startTransaction() {
+    await this._transactionsActionsMutex.runExclusive(async () => {
+      await this._startTransactionAction()
+      this._transactionsCount++
+    })
+  }
+
+  async _startTransactionAction() {
     await this.query("BEGIN TRANSACTION")
-    this._transactionsCount++
   }
 
   async commitTransaction() {
+    await this._transactionsActionsMutex.runExclusive(async () => {
+      await this._commitTransactionAction()
+      this._transactionsCount--
+    })
+  }
+
+  async _commitTransactionAction() {
     await this.query("COMMIT")
-    this._transactionsCount--
   }
 
   async rollbackTransaction() {
+    await this._transactionsActionsMutex.runExclusive(async () => {
+      await this._rollbackTransactionAction()
+      this._transactionsCount--
+    })
+  }
+
+  async _rollbackTransactionAction() {
     await this.query("ROLLBACK")
-    this._transactionsCount--
   }
 
   generateSavePointName() {
@@ -225,6 +246,12 @@ export default class VelociousDatabaseDriversBase {
   }
 
   async startSavePoint(savePointName) {
+    await this._transactionsActionsMutex.runExclusive(async () => {
+      await this._startSavePointAction(savePointName)
+    })
+  }
+
+  async _startSavePointAction(savePointName) {
     await this.query(`SAVEPOINT ${savePointName}`)
   }
 
@@ -245,10 +272,22 @@ export default class VelociousDatabaseDriversBase {
   }
 
   async releaseSavePoint(savePointName) {
+    await this._transactionsActionsMutex.runExclusive(async () => {
+      await this._releaseSavePointAction(savePointName)
+    })
+  }
+
+  async _releaseSavePointAction(savePointName) {
     await this.query(`RELEASE SAVEPOINT ${savePointName}`)
   }
 
   async rollbackSavePoint(savePointName) {
+    await this._transactionsActionsMutex.runExclusive(async () => {
+      await this._rollbackSavePointAction(savePointName)
+    })
+  }
+
+  async _rollbackSavePointAction(savePointName) {
     await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`)
   }
 

package/src/database/drivers/mssql/index.js

@@ -203,42 +203,39 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return this._options
   }
 
-  async startTransaction() {
+  async _startTransactionAction() {
     if (!this.connection) throw new Error("No connection")
     if (this._currentTransaction) throw new Error("A transaction is already running")
 
     this._currentTransaction = new mssql.Transaction(this.connection)
 
     await this._currentTransaction.begin()
-    this._transactionsCount++
   }
 
-  async commitTransaction() {
+  async _commitTransactionAction() {
     if (!this._currentTransaction) throw new Error("A transaction isn't running")
 
     await this._currentTransaction.commit()
     this._currentTransaction = null
-    this._transactionsCount--
   }
 
-  async rollbackTransaction() {
+  async _rollbackTransactionAction() {
     if (!this._currentTransaction) throw new Error("A transaction isn't running")
 
     await this._currentTransaction.rollback()
 
     this._currentTransaction = null
-    this._transactionsCount--
   }
 
-  async startSavePoint(savePointName) {
+  async _startSavePointAction(savePointName) {
     await this.query(`SAVE TRANSACTION [${savePointName}]`)
   }
 
-  async releaseSavePoint(savePointName) {
+  async _releaseSavePointAction(savePointName) {
     // Do nothing in MS-SQL.
   }
 
-  async rollbackSavePoint(savePointName) {
+  async _rollbackSavePointAction(savePointName) {
     await this.query(`ROLLBACK TRANSACTION [${savePointName}]`)
   }
 

package/src/database/drivers/mysql/index.js

@@ -161,9 +161,8 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return this._options
   }
 
-  async startTransaction() {
+  async _startTransactionAction() {
     await this.query("START TRANSACTION")
-    this._transactionsCount++
   }
 
   updateSql({conditions, data, tableName}) {

package/src/database/drivers/pgsql/index.js

@@ -174,9 +174,8 @@ export default class VelociousDatabaseDriversPgsql extends Base{
     return this._options
   }
 
-  async startTransaction() {
+  async _startTransactionAction() {
     await this.query("START TRANSACTION")
-    this._transactionsCount++
   }
 
   updateSql({conditions, data, tableName}) {

package/src/database/drivers/sqlite/index.web.js

@@ -27,7 +27,9 @@ export default class VelociousDatabaseDriversSqliteWeb extends Base {
     }
   }
 
-  close = async () => await this.getConnection().close()
+  async close() {
+    await this.getConnection().close()
+  }
 
   getConnection() {
     if (this.args.getConnection) {

package/src/database/migrator.js

@@ -22,12 +22,12 @@ export default class VelociousDatabaseMigrator {
       const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier)
 
       if (!databaseConfiguration.migrations) {
-        this.logger.log(`${dbIdentifier} isn't configured for migrations - skipping creating migrations table for it`)
+        this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping creating migrations table for it`)
         continue
       }
 
       if (await this.migrationsTableExist(db)) {
-        this.logger.log(`${dbIdentifier} migrations table already exists - skipping`)
+        this.logger.debug(`${dbIdentifier} migrations table already exists - skipping`)
         continue
       }
 

package/src/http-client/header.js

@@ -0,0 +1,10 @@
+export default class Header {
+  constructor(name, value) {
+    this.name = name
+    this.value = value
+  }
+
+  getName() { return this.name }
+  getValue() { return this.value }
+  toString() { return `${this.getName()}: ${this.getValue()}` }
+}

package/src/http-client/index.js

@@ -0,0 +1,103 @@
+import net from "net"
+import Request from "./request.js"
+import Response from "./response.js"
+import {Logger} from "../logger.js"
+
+export default class HttpClient {
+  constructor({debug = false, headers, version = "1.1"}) {
+    this.headers = headers || []
+    this.logger = new Logger(this, {debug})
+    this.version = version
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      this.connectionReject = reject
+      this.connection = net.createConnection(3006, "127.0.0.1", () => {
+        this.connectionReject = null
+        resolve()
+      })
+
+      this.connection.on("data", this.onConnectionData)
+      this.connection.on("end", this.onConnectionEnd)
+      this.connection.on("error", this.onConnectionError)
+    })
+  }
+
+  get(path, {headers} = {}) {
+    if (!this.connection) throw new Error("Not connected yet")
+
+    return new Promise((resolve, reject) => {
+      this.currentRequestResolve = resolve
+      this.currentRequestReject = reject
+
+      const newHeaders = []
+
+      if (headers) {
+        for (const header of headers) {
+          newHeaders.push(header)
+        }
+      }
+
+      for (const header of this.headers) {
+        const existingNewHeader = newHeaders.find((newHeader) => {
+          return newHeader.key.toLowerCase().trim() === header.key.toLowerCase().trim()
+        })
+
+        if (!existingNewHeader) {
+          this.logger.debug(() => [`Pushing header from connection: ${header.toString()}`])
+          newHeaders.push(header)
+        }
+      }
+
+      this.currentResponse = new Response({method: "GET", onComplete: this.onResponseComplete})
+
+      this.currentRequest = new Request({headers: newHeaders, method: "GET", path, version: "1.0"})
+      this.currentRequest.stream((chunk) => {
+        this.logger.debug(() => [`Writing: ${chunk}`])
+
+        this.connection.write(chunk, "utf8", (error) => {
+          if (error) {
+            this.currentRequestReject(error)
+          }
+        })
+      })
+    })
+  }
+
+  onConnectionData = (data) => {
+    this.currentResponse.feed(data)
+  }
+
+  onConnectionEnd = () => {
+    this.connection = null
+  }
+
+  onConnectionError = (error) => {
+    if (this.connectionReject) {
+      this.connectionReject(error)
+    } else {
+      this.logger.error("HttpClient onConnectionError", error)
+    }
+  }
+
+  isConnected() {
+    if (this.connection) {
+      return true
+    }
+
+    return false
+  }
+
+  onResponseComplete = () => {
+    this.currentRequestResolve({
+      request: this.currentRequest,
+      response: this.currentResponse
+    })
+
+    this.currentRequestResolve = null
+    this.currentRequestReject = null
+    this.currentRequest = null
+    this.currentResponse = null
+  }
+}

package/src/http-client/request.js

@@ -0,0 +1,57 @@
+export default class Request {
+  constructor({body, method = "GET", headers = [], path, version = "1.1"}) {
+    this.body = body
+    this.headers = headers
+    this.method = method
+    this.path = path
+    this.version = version
+  }
+
+  asString() {
+    let requestString = ""
+
+    this.stream((chunk) => {
+      requestString += chunk
+    })
+
+    return requestString
+  }
+
+  getHeader(key) {
+    const compareName = key.toLowerCase().trim()
+
+    for (const header of this.headers) {
+      const headerCompareName = header.key.toLowerCase().trim()
+
+      if (compareName == headerCompareName) {
+        return header
+      }
+    }
+
+    throw new Error(`Header ${key} not found`)
+  }
+
+  prepare() {
+    if (this.body) {
+      this.addHeader("Content-Length", this.body.byteLength)
+    }
+  }
+
+  stream(callback) {
+    this.prepare()
+
+    const requestString = `${this.method} ${this.path} HTTP/${this.version}\r\n`
+
+    callback(requestString)
+
+    for (const header of this.headers) {
+      callback(`${header.toString()}\r\n`)
+    }
+
+    callback(`\r\n`)
+
+    if (this.body) {
+      callback(this.body)
+    }
+  }
+}

package/src/http-client/response.js

@@ -0,0 +1,112 @@
+import Header from "./header.js"
+
+export default class Response {
+  constructor({method = "GET", onComplete}) {
+    if (!method) throw new Error(`Invalid method given: ${method}`)
+
+    this.headers = []
+    this.method = method.toUpperCase().trim()
+    this.onComplete = onComplete
+    this.state = "status-line"
+
+    this.arrayBuffer = new ArrayBuffer()
+    this.response = new Uint8Array(this.arrayBuffer)
+  }
+
+  feed(data) {
+    this.response += data
+    this.tryToParse()
+  }
+
+  getHeader(name) {
+    const compareName = name.toLowerCase().trim()
+
+    for (const header of this.headers) {
+      const headerCompareName = header.getName().toLowerCase().trim()
+
+      if (compareName == headerCompareName) {
+        return header
+      }
+    }
+
+    throw new Error(`Header ${name} not found`)
+  }
+
+  json() {
+    const contentTypeHeader = this.getHeader("Content-Type")?.getValue()?.toLowerCase()?.trim()
+
+    if (!contentTypeHeader.startsWith("application/json")) {
+      throw new Error(`Content-Type is not JSON: ${contentTypeHeader}`)
+    }
+
+    const body = this.response.toString()
+    const json = JSON.parse(body)
+
+    return json
+  }
+
+  tryToParse() {
+    while (true) {
+      if (this.state == "body") {
+        const contentLengthValue = this.getHeader("Content-Length")?.value
+
+        if (contentLengthValue === undefined) {
+          throw new Error("No content length given")
+        }
+
+        const contentLengthNumber = parseInt(contentLengthValue)
+
+        if (this.response.byteLength >= contentLengthNumber) {
+          this.completeResponse()
+          break
+        }
+      } else {
+        const response = this.response.toString()
+        let lineEndIndex = response.indexOf("\r\n")
+        let lineEndLength = 2
+
+        if (lineEndIndex === -1) {
+          lineEndIndex = response.indexOf("\n")
+          lineEndLength = 1
+        }
+
+        if (lineEndIndex === -1) {
+          break // We need to get fed more to continue reading
+        } else {
+          const line = response.substring(0, lineEndIndex)
+
+          this.response = this.response.slice(lineEndIndex + lineEndLength)
+
+          if (this.state == "status-line") {
+            this.statusLine = line
+            this.state = "headers"
+          } else if (this.state == "headers") {
+            if (line == "") {
+              if (this.method == "GET" || this.method == "HEAD") {
+                this.completeResponse()
+                break
+              } else if (this.method == "POST") {
+                this.state = "body"
+              }
+            } else {
+              const headerMatch = line.match(/^(.+?):\s*(.+)$/)
+
+              if (!headerMatch) throw new Error(`Invalid header: ${line}`)
+
+              const header = new Header(headerMatch[1], headerMatch[2])
+
+              this.headers.push(header)
+            }
+          } else {
+            throw new Error(`Unexpected state: ${this.state}`)
+          }
+        }
+      }
+    }
+  }
+
+  completeResponse() {
+    this.state = "done"
+    this.onComplete()
+  }
+}

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

@@ -38,7 +38,7 @@ export default class VeoliciousHttpServerClient {
 
   onWrite(data) {
     if (this.state == "initial") {
-      this.currentRequest = new Request({configuration: this.configuration})
+      this.currentRequest = new Request({client: this, configuration: this.configuration})
       this.currentRequest.requestParser.events.on("done", this.executeCurrentRequest)
       this.currentRequest.feed(data)
       this.state = "requestStarted"
@@ -56,29 +56,49 @@ export default class VeoliciousHttpServerClient {
   sendDoneRequests() {
     while (true) {
       const requestRunner = this.requestRunners[0]
+      const request = requestRunner?.getRequest()
 
       if (requestRunner?.getState() == "done") {
+        const httpVersion = request.httpVersion()
+        const connectionHeader = request.header("connection")?.toLowerCase()?.trim()
+
         this.requestRunners.shift()
         this.sendResponse(requestRunner)
+        this.logger.debug(() => ["sendDoneRequests", {clientCount: this.clientCount, connectionHeader, httpVersion}])
+
+        if (httpVersion == "1.0" && connectionHeader != "keep-alive") {
+          this.logger.debug(() => [`Closing the connection because ${httpVersion} and connection header ${connectionHeader}`, {clientCount: this.clientCount}])
+          this.events.emit("close")
+        }
       } else {
         break
       }
     }
   }
 
-  sendResponse = (requestRunner) => {
+  sendResponse(requestRunner) {
     const response = digg(requestRunner, "response")
+    const request = requestRunner.getRequest()
     const body = response.getBody()
     const date = new Date()
+    const connectionHeader = request.header("connection")?.toLowerCase()?.trim()
+    const httpVersion = request.httpVersion()
+
+    this.logger.debug("sendResponse", {clientCount: this.clientCount, connectionHeader, httpVersion})
+
+    if (httpVersion == "1.0" && connectionHeader == "keep-alive") {
+      response.addHeader("Connection", "Keep-Alive")
+    } else {
+      response.addHeader("Connection", "Close")
+    }
 
-    response.addHeader("Connection", "keep-alive")
     response.addHeader("Content-Length", response.body.length)
     response.addHeader("Date", date.toUTCString())
     response.addHeader("Server", "Velocious")
 
     let headers = ""
 
-    headers += `HTTP/1.1 ${response.getStatusCode()} ${response.getStatusMessage()}\r\n`
+    headers += `HTTP/${this.currentRequest.httpVersion()} ${response.getStatusCode()} ${response.getStatusMessage()}\r\n`
 
     for (const headerKey in response.headers) {
       for (const headerValue of response.headers[headerKey]) {

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

@@ -4,4 +4,9 @@ export default class Header {
     this.name = name
     this.value = value
   }
+
+  getName() { return this.name }
+  getFormattedName() { return this.formattedName }
+  getValue() { return this.value }
+  toString() { return `${this.getName()}: ${this.getValue()}` }
 }

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

@@ -10,7 +10,6 @@ export default class RequestBuffer {
   bodyLength = 0
   data = []
   events = new EventEmitter()
-  headers = []
   headersByName = {}
   params = {}
   readingBody = false
@@ -18,7 +17,7 @@ export default class RequestBuffer {
 
   constructor({configuration}) {
     this.configuration = configuration
-    this.logger = new Logger(this)
+    this.logger = new Logger(this, {debug: false})
   }
 
   feed(data) {
@@ -85,7 +84,25 @@ export default class RequestBuffer {
     }
   }
 
-  getHeader = (name) => this.headersByName[name.toLowerCase().trim()]
+  getHeader(name) {
+    const result = this.headersByName[name.toLowerCase().trim()]
+
+    this.logger.debug(() => [`getHeader ${name}`, {result: result?.toString()}])
+
+    return result
+  }
+
+  getHeadersHash() {
+    const result = {}
+
+    for (const headerFormattedName in this.headersByName) {
+      const header = this.headersByName[headerFormattedName]
+
+      result[header.getName()] = header.getValue()
+    }
+
+    return result
+  }
 
   formDataPartDone() {
     const formDataPart = this.formDataPart
@@ -96,7 +113,9 @@ export default class RequestBuffer {
     this.events.emit("form-data-part", formDataPart)
   }
 
-  isMultiPartyFormData = () => this.multiPartyFormData
+  isMultiPartyFormData() {
+    return this.multiPartyFormData
+  }
 
   newFormDataPart() {
     this.formDataPart = new FormDataPart()
@@ -140,14 +159,20 @@ export default class RequestBuffer {
     }
   }
 
+  addHeader(header) {
+    const formattedName = header.getFormattedName()
+
+    this.headersByName[formattedName] = header
+
+    if (formattedName == "content-length") this.contentLength = parseInt(header.getValue())
+  }
+
   parseHeader(line) {
     const header = this.readHeaderFromLine(line)
 
     if (header) {
-      this.headersByName[header.formattedName] = header
-
-      if (header.formattedName == "content-length") this.contentLength = parseInt(header.value)
-
+      this.logger.debug(() => [`Parsed header: ${header.toString()}`])
+      this.addHeader(header)
       this.events.emit("header", header)
     } else if (line == "\r\n") {
       if (this.httpMethod.toUpperCase() == "GET" || this.httpMethod.toUpperCase() == "OPTIONS") {
@@ -184,16 +209,17 @@ export default class RequestBuffer {
   }
 
   parseStatusLine(line) {
-    const match = line.match(/^(GET|OPTIONS|POST) (.+?) HTTP\/1\.1\r\n/)
+    const match = line.match(/^(GET|OPTIONS|POST) (.+?) HTTP\/(.+)\r\n/)
 
     if (!match) {
       throw new Error(`Couldn't match status line from: ${line}`)
     }
 
     this.httpMethod = match[1]
+    this.httpVersion = match[3]
     this.path = match[2]
     this.setState("headers")
-    this.logger.debug(() => ["Parsed status line", {httpMethod: this.httpMethod, path: this.path}])
+    this.logger.debug(() => ["Parsed status line", {httpMethod: this.httpMethod, httpVersion: this.httpVersion, path: this.path}])
   }
 
   postRequestDone() {

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

@@ -38,10 +38,11 @@ export default class VelociousHttpServerClientRequestParser {
   }
 
   feed = (data) => this.requestBuffer.feed(data)
-  getHeader = (name) => this.requestBuffer.getHeader(name)?.value
-  getHttpMethod = () => digg(this, "requestBuffer", "httpMethod")
+  getHeader(name) { return this.requestBuffer.getHeader(name)?.value }
+  getHttpMethod() { return digg(this, "requestBuffer", "httpMethod") }
+  getHttpVersion() { return digg(this, "requestBuffer", "httpVersion") }
 
-  _getHostMatch = () => {
+  _getHostMatch() {
     const rawHost = this.requestBuffer.getHeader("origin")?.value
 
     if (!rawHost) return null
@@ -63,7 +64,7 @@ export default class VelociousHttpServerClientRequestParser {
     if (rawHostSplit && rawHostSplit[0]) return rawHostSplit[0]
   }
 
-  getPath = () => digg(this, "requestBuffer", "path")
+  getPath() { return digg(this, "requestBuffer", "path") }
 
   getPort() {
     const rawHostSplit = this.requestBuffer.getHeader("host")?.value?.split(":")
@@ -78,7 +79,8 @@ export default class VelociousHttpServerClientRequestParser {
     }
   }
 
-  getProtocol = () => this._getHostMatch()?.protocol
+  getProtocol() { return this._getHostMatch()?.protocol }
+  getRequestBuffer() { return this.requestBuffer }
 
   requestDone = () => {
     incorporate(this.params, this.requestBuffer.params)

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

@@ -18,7 +18,8 @@ export default class VelociousHttpServerClientRequestRunner {
     this.state = "running"
   }
 
-  getState = () => this.state
+  getRequest() { return this.request }
+  getState() { return this.state }
 
   async run() {
     const {configuration, request, response} = this

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

@@ -1,16 +1,21 @@
 import {digg} from "diggerize"
 import RequestParser from "./request-parser.js"
+import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousHttpServerClientRequest {
-  constructor({configuration}) {
+  constructor({client, configuration, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.client = client
     this.configuration = configuration
     this.requestParser = new RequestParser({configuration})
   }
 
   baseURL() { return `${this.protocol()}://${this.hostWithPort()}` }
   feed(data) { return this.requestParser.feed(data) }
-  header(headerName) { return this.requestParser.requestBuffer.getHeader(headerName)?.value }
+  header(headerName) { return this.getRequestBuffer().getHeader(headerName)?.getValue() }
   httpMethod() { return this.requestParser.getHttpMethod() }
+  httpVersion() { return this.requestParser.getHttpVersion() }
   host() { return this.requestParser.getHost() }
 
   hostWithPort() {
@@ -29,9 +34,12 @@ export default class VelociousHttpServerClientRequest {
     return hostWithPort
   }
 
-  origin = () => this.header("origin")
-  path = () => this.requestParser.getPath()
-  params = () => digg(this, "requestParser", "params")
-  port = () => this.requestParser.getPort()
-  protocol = () => this.requestParser.getProtocol()
+  origin() { return this.header("origin") }
+  path() { return this.requestParser.getPath() }
+  params() { return digg(this, "requestParser", "params") }
+  port() { return this.requestParser.getPort() }
+  protocol() { return this.requestParser.getProtocol() }
+
+  getRequestBuffer() { return this.getRequestParser().getRequestBuffer() }
+  getRequestParser() { return this.requestParser }
 }

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

@@ -18,15 +18,8 @@ export default class ServerClient {
   listen = () => this.socket.on("data", this.onSocketData)
 
   close() {
-    return new Promise((resolve, reject) => {
-      try {
-        this.socket.destroy()
-        this.events.emit("close", this)
-        resolve()
-      } catch (error) {
-        reject(error)
-      }
-    })
+    this.socket.destroy()
+    this.events.emit("close", this)
   }
 
   onSocketData = (chunk) => {

package/src/http-server/worker-handler/index.js

@@ -75,6 +75,10 @@ export default class VelociousHttpServerWorker {
       const {clientCount, output} = digs(data, "clientCount", "output")
 
       this.clients[clientCount].send(output)
+    } else if (command == "clientClose") {
+      const {clientCount} = digs(data, "clientCount")
+
+      this.clients[clientCount].close()
     } else {
       throw new Error(`Unknown command: ${command}`)
     }

package/src/http-server/worker-handler/worker-thread.js

@@ -9,7 +9,7 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
     const {workerCount} = digs(workerData, "workerCount")
 
     this.clients = {}
-    this.logger = new Logger(this)
+    this.logger = new Logger(this, {debug: false})
     this.parentPort = parentPort
     this.workerData = workerData
     this.workerCount = workerCount
@@ -56,6 +56,11 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
         this.parentPort.postMessage({command: "clientOutput", clientCount, output})
       })
 
+      client.events.on("close", (output) => {
+        this.logger.log("Close received from client in worker - forwarding to worker parent")
+        this.parentPort.postMessage({command: "clientClose", clientCount, output})
+      })
+
       this.clients[clientCount] = client
     } else if (command == "clientWrite") {
       await this.logger.debug("Looking up client")

package/src/logger.js

@@ -47,7 +47,9 @@ function messagesToMessage(...messages) {
 }
 
 class Logger {
-  constructor(object) {
+  constructor(object, args) {
+    this._debug = args?.debug
+
     if (typeof object == "string") {
       this._subject = object
     } else {
@@ -69,7 +71,7 @@ class Logger {
   }
 
   async debug(...messages) {
-    if (this.getConfiguration()?.debug) {
+    if (this._debug || this.getConfiguration()?.debug) {
       await this.log(...messages)
     }
   }