velocious 1.0.108 → 1.0.110

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

@@ -1,345 +0,0 @@
-// @ts-check
-
-import {EventEmitter} from "events"
-import FormDataPart from "./form-data-part.js"
-import Header from "./header.js"
-import {incorporate} from "incorporator"
-import {Logger} from "../../../logger.js"
-import ParamsToObject from "../params-to-object.js"
-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
-
-      switch(this.state) {
-        case "status":
-        case "headers":
-        case "multi-part-form-data":
-        case "multi-part-form-data-header":
-          this.data.push(char)
-
-          if (char == 10) {
-            const line = String.fromCharCode.apply(null, this.data)
-
-            this.data = []
-            this.parse(line)
-          }
-
-          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)
-
-          const possibleBoundaryEndPosition = body.length - this.boundaryLineEnd.length // eslint-disable-line no-case-declarations
-          const possibleBoundaryEndChars = body.slice(possibleBoundaryEndPosition, body.length) // eslint-disable-line no-case-declarations
-          const possibleBoundaryEnd = String.fromCharCode.apply(null, possibleBoundaryEndChars) // eslint-disable-line no-case-declarations
-
-          const possibleBoundaryNextPosition = body.length - this.boundaryLineNext.length // eslint-disable-line no-case-declarations
-          const possibleBoundaryNextChars = body.slice(possibleBoundaryNextPosition, body.length) // eslint-disable-line no-case-declarations
-          const possibleBoundaryNext = String.fromCharCode.apply(null, possibleBoundaryNextChars) // eslint-disable-line no-case-declarations
-
-          if (possibleBoundaryEnd == this.boundaryLineEnd) {
-            this.formDataPart.removeFromBody(possibleBoundaryEnd)
-            this.formDataPartDone()
-            this.completeRequest()
-          } else if (possibleBoundaryNext == this.boundaryLineNext) {
-            this.formDataPart.removeFromBody(possibleBoundaryNext)
-            this.formDataPartDone()
-            this.newFormDataPart()
-          } else if (this.contentLength && this.bodyLength >= this.contentLength) {
-            this.formDataPartDone()
-            this.completeRequest()
-          } else if (this.formDataPart.contentLength && this.bodyLength >= this.formDataPart.contentLength) {
-            this.formDataPartDone()
-
-            throw new Error("stub")
-          }
-
-          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) {
-            this.postRequestDone()
-          }
-
-          break
-        default:
-          console.error(`Unknown state for request buffer: ${this.state}`)
-      }
-    }
-  }
-
-  /**
-   * @param {string} name
-   * @returns {Header}
-   */
-  getHeader(name) {
-    const result = this.headersByName[name.toLowerCase().trim()]
-
-    this.logger.debug(() => [`getHeader ${name}`, {result: result?.toString()}])
-
-    return result
-  }
-
-  /**
-   * @returns {Record<string, string>}
-   */
-  getHeadersHash() {
-    /** @type {Record<string, string>} */
-    const result = {}
-
-    for (const headerFormattedName in this.headersByName) {
-      const header = this.headersByName[headerFormattedName]
-
-      result[header.getName()] = header.getValue()
-    }
-
-    return result
-  }
-
-  /**
-   * @returns {void}
-   */
-  formDataPartDone() {
-    const formDataPart = this.formDataPart
-
-    if (!formDataPart) throw new Error("formDataPart wasnt set")
-
-    this.formDataPart = undefined
-    formDataPart.finish()
-
-    this.events.emit("form-data-part", formDataPart)
-  }
-
-  isMultiPartyFormData() {
-    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)
-    } else if (this.state == "headers") {
-      this.parseHeader(line)
-    } else if (this.state == "multi-part-form-data") {
-      if (line == this.boundaryLine) {
-        this.newFormDataPart()
-      } else if (line == "\r\n") {
-        this.setState("done")
-      } else {
-        throw new Error(`Expected boundary line but didn't get it: ${line}`)
-      }
-    } else if (this.state == "multi-part-form-data-header") {
-      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"
-      } else if (line == "\r\n") {
-        this.setState("multi-part-form-data-body")
-      }
-    } else {
-      throw new Error(`Unknown state parsing line: ${this.state}`)
-    }
-  }
-
-  /**
-   * @param {string} line
-   * @returns {Header | undefined}
-   */
-  readHeaderFromLine(line) {
-    const match = line.match(/^(.+): (.+)\r\n/)
-
-    if (match) {
-      const header = new Header(match[1], match[2])
-
-      return header
-    }
-  }
-
-  /**
-   * @param {Header} header
-   */
-  addHeader(header) {
-    const formattedName = header.getFormattedName()
-
-    this.headersByName[formattedName] = header
-
-    if (formattedName == "content-length") this.contentLength = parseInt(header.getValue())
-  }
-
-  /**
-   * @param {string} line
-   * @returns {void}
-   */
-  parseHeader(line) {
-    const header = this.readHeaderFromLine(line)
-
-    if (header) {
-      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") {
-        this.completeRequest()
-      } else if (this.httpMethod?.toUpperCase() == "POST") {
-        this.readingBody = true
-        this.bodyLength = 0
-
-        const match = this.getHeader("content-type")?.value?.match(/^multipart\/form-data;\s*boundary=(.+)$/i)
-
-        if (match) {
-          this.boundary = match[1]
-          this.boundaryLine = `--${this.boundary}\r\n`
-          this.boundaryLineNext = `\r\n--${this.boundary}\r\n`
-          this.boundaryLineEnd = `\r\n--${this.boundary}--`
-          this.multiPartyFormData = true
-          this.setState("multi-part-form-data")
-        } else {
-          if (this.contentLength === 0) {
-            this.completeRequest()
-          } else if (!this.contentLength) {
-            throw new Error("Content length hasn't been set")
-          } else {
-            /** @type {number[]} */
-            this.postBodyChars = []
-
-            // this.postBodyBuffer = new ArrayBuffer(this.contentLength)
-            // this.postBodyChars = new Uint8Array(this.postBodyBuffer)
-
-            this.setState("post-body")
-          }
-        }
-      } else {
-        throw new Error(`Unknown HTTP method: ${this.httpMethod}`)
-      }
-    }
-  }
-
-  /**
-   * @param {string} line
-   * @returns {void}
-   */
-  parseStatusLine(line) {
-    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, httpVersion: this.httpVersion, path: this.path}])
-  }
-
-  postRequestDone() {
-    if (this.postBodyChars) {
-      this.postBody = String.fromCharCode.apply(null, this.postBodyChars)
-    }
-
-    delete this.postBodyChars
-    // 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
-  }
-
-  completeRequest = () => {
-    this.state = "status" // Reset state to new request
-
-    if (this.getHeader("content-type")?.value?.startsWith("application/json")) {
-      this.parseApplicationJsonParams()
-    } else if (this.multiPartyFormData) {
-      // Done after each new form data part
-    } else {
-      this.parseQueryStringPostParams()
-    }
-
-    this.events.emit("completed")
-  }
-
-  parseApplicationJsonParams() {
-    if (this.postBody) {
-      const newParams = JSON.parse(this.postBody)
-
-      incorporate(this.params, newParams)
-    }
-  }
-
-  parseQueryStringPostParams() {
-    if (this.postBody) {
-      /** @type {Record<string, any>} */
-      const unparsedParams = querystring.parse(this.postBody)
-      const paramsToObject = new ParamsToObject(unparsedParams)
-      const newParams = paramsToObject.toObject()
-
-      incorporate(this.params, newParams)
-    }
-  }
-}

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

@@ -1,118 +0,0 @@
-// @ts-check
-
-import {digg} from "diggerize"
-import {EventEmitter} from "events"
-import {incorporate} from "incorporator"
-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")
-
-    this.configuration = configuration
-    this.data = []
-    this.events = new EventEmitter()
-    this.params = {}
-
-    this.requestBuffer = new RequestBuffer({configuration})
-    this.requestBuffer.events.on("completed", this.requestDone)
-    this.requestBuffer.events.on("form-data-part", this.onFormDataPart)
-    this.requestBuffer.events.on("request-done", this.requestDone)
-  }
-
-  destroy() {
-    this.requestBuffer.events.off("completed", this.requestDone)
-    this.requestBuffer.events.off("form-data-part", this.onFormDataPart)
-    this.requestBuffer.events.off("request-done", this.requestDone)
-    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()
-
-    const paramsToObject = new ParamsToObject(unorderedParams)
-    const newParams = paramsToObject.toObject()
-
-    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() {
-    const rawHost = this.requestBuffer.getHeader("origin")?.value
-
-    if (!rawHost) return null
-
-    const match = rawHost.match(/^(.+):\/\/(.+)(|:(\d+))/)
-
-    if (!match) throw new Error(`Couldn't match host: ${rawHost}`)
-
-    return {
-      protocol: match[1],
-      host: match[2],
-      port: match[4]
-    }
-  }
-
-  getHost() {
-    const rawHostSplit = this.requestBuffer.getHeader("host")?.value?.split(":")
-
-    if (rawHostSplit && rawHostSplit[0]) return rawHostSplit[0]
-  }
-
-  getPath() { return digg(this, "requestBuffer", "path") }
-
-  getPort() {
-    const rawHostSplit = this.requestBuffer.getHeader("host")?.value?.split(":")
-    const httpMethod = this.getHttpMethod()
-
-    if (rawHostSplit && rawHostSplit[1]) {
-      return parseInt(rawHostSplit[1])
-    } else if (httpMethod == "http") {
-      return 80
-    } else if (httpMethod == "https") {
-      return 443
-    }
-  }
-
-  getProtocol() { return this._getHostMatch()?.protocol }
-  getRequestBuffer() { return this.requestBuffer }
-
-  requestDone = () => {
-    incorporate(this.params, this.requestBuffer.params)
-
-    this.state = "done"
-    this.events.emit("done")
-  }
-}

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

@@ -1,68 +0,0 @@
-// @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"
-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")
-
-    this.logger = new Logger(this)
-    this.configuration = configuration
-    this.request = request
-    this.response = new Response({configuration})
-    this.state = "running"
-  }
-
-  getRequest() { return this.request }
-  getState() { return this.state }
-
-  async run() {
-    const {configuration, request, response} = this
-
-    if (!request) throw new Error("No request?")
-
-    try {
-      // 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")}])
-
-      const cors = configuration.getCors()
-
-      if (cors) {
-        await cors({request, response})
-      }
-
-      if (request.httpMethod() == "OPTIONS" && request.header("sec-fetch-mode") == "cors") {
-        response.setStatus(200)
-        response.setBody("")
-      } else {
-        await this.logger.debug("Run request")
-        const routesResolver = new RoutesResolver({configuration, request, response})
-
-        await routesResolver.resolve()
-      }
-    } catch (e) {
-      const error = ensureError(e)
-
-      await this.logger.error(() => [`Error while running request: ${BacktraceCleaner.getCleanedStack(error)}`])
-
-      response.setStatus(500)
-      response.setErrorBody(error)
-    }
-
-    this.state = "done"
-    this.events.emit("done", this)
-  }
-}

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

@@ -1,63 +0,0 @@
-// @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)
-
-    this.client = client
-    this.configuration = configuration
-    this.requestParser = new RequestParser({configuration})
-  }
-
-  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() }
-  httpVersion() { return this.requestParser.getHttpVersion() }
-  host() { return this.requestParser.getHost() }
-
-  hostWithPort() {
-    const port = this.port()
-    const protocol = this.protocol()
-    let hostWithPort = `${this.host()}`
-
-    if (port == 80 && protocol == "http") {
-      // Do nothing
-    } else if (port == 443 && protocol == "https") {
-      // Do nothing
-    } else if (port) {
-      hostWithPort += `:${port}`
-    }
-
-    return hostWithPort
-  }
-
-  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/client/response.js

@@ -1,100 +0,0 @@
-// @ts-check
-
-export default class VelociousHttpServerClientResponse {
-  /** @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] = []
-    }
-
-    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
-    }
-
-    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
-      this.statusMessage = "OK"
-    } else if (status == "not-found" || status == 404) {
-      this.statusCode = 404
-      this.statusMessage = "Not Found"
-    } else if (status == "internal-server-error" || status == 500) {
-      this.statusCode = 500
-      this.statusMessage = "Internal server error"
-    } else {
-      throw new Error(`Unhandled status: ${status}`)
-    }
-  }
-}