velocious 1.0.430 → 1.0.432

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

@@ -0,0 +1,114 @@
+// @ts-check
+
+import {digg} from "diggerize"
+import querystring from "querystring"
+import RequestParser from "./request-parser.js"
+import resolveRemoteAddress from "../remote-address.js"
+import restArgsError from "../../utils/rest-args-error.js"
+
+export default class VelociousHttpServerClientRequest {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("./index.js").default} args.client - Client instance.
+   * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
+   */
+  constructor({client, configuration, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.client = client
+    this.configuration = configuration
+    this.requestParser = new RequestParser({configuration})
+  }
+
+  baseURL() { return `${this.protocol()}://${this.hostWithPort()}` }
+
+  /**
+   * Runs feed.
+   * @param {Buffer} data - Data payload.
+   * @returns {Buffer | undefined} - Remaining data, if any.
+   */
+  feed(data) { return this.requestParser.feed(data) }
+
+  /**
+   * Runs header.
+   * @param {string} headerName - Header name.
+   * @returns {string | null} - The header.
+   */
+  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() }
+  /**
+   * Runs metadata.
+   * @param {string} [key] - Metadata key.
+   * @returns {?} - Metadata value for a key, or the full metadata object.
+   */
+  metadata(key) {
+    if (key !== undefined) return undefined
+
+    return {}
+  }
+
+  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() }
+  /**
+   * Runs params.
+   * @returns {Record<string, string | string[] | undefined | Record<string, ?> | Array<?>>} - The request params.
+   */
+  params() { return digg(this, "requestParser", "params") }
+  port() { return this.requestParser.getPort() }
+
+  /**
+   * Runs query params.
+   * @returns {Record<string, string | string[]>} - Parsed query parameters from the URL.
+   */
+  queryParams() {
+    const query = this.path().split("?")[1]
+
+    if (!query) return Object.create(null)
+
+    const parsed = querystring.parse(query)
+    /**
+     * Params.
+      @type {Record<string, string | string[]>} */
+    const params = Object.create(null)
+
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value !== "undefined") {
+        params[key] = value
+      }
+    }
+
+    return params
+  }
+  protocol() { return this.requestParser.getProtocol() }
+  remoteAddress() {
+    return resolveRemoteAddress({
+      configuration: this.configuration,
+      headers: this.headers(),
+      socketRemoteAddress: this.socketRemoteAddress()
+    })
+  }
+  socketRemoteAddress() { return this.client?.remoteAddress }
+
+  getRequestBuffer() { return this.getRequestParser().getRequestBuffer() }
+  getRequestParser() { return this.requestParser }
+}

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

@@ -0,0 +1,251 @@
+// @ts-check
+
+/**
+ * Named status aliases.
+  @type {Record<string, number>} */
+const NAMED_STATUS_ALIASES = {
+  "success": 200,
+  "not-found": 404,
+  "internal-server-error": 500
+}
+
+/**
+ * Standard status messages.
+  @type {Record<number, string>} */
+const STANDARD_STATUS_MESSAGES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  103: "Early Hints",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal server error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+}
+
+export default class VelociousHttpServerClientResponse {
+  /**
+   * Body.
+    @type {string | Uint8Array | null} */
+  body = null
+
+  /**
+   * File path.
+    @type {string | null} */
+  filePath = null
+
+  /**
+   * Headers.
+    @type {Record<string, string[]>} */
+  headers = {}
+
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
+   */
+  constructor({configuration}) {
+    this.configuration = configuration
+    this._requestTimeoutMs = undefined
+    this._requestTimeoutMsChangeHandler = undefined
+  }
+
+  /**
+   * Runs add header.
+   * @param {string} key - Key.
+   * @param {string} value - Value to use.
+   * @returns {void} - No return value.
+   */
+  addHeader(key, value) {
+    if (!(key in this.headers)) {
+      this.headers[key] = []
+    }
+
+    this.headers[key].push(value)
+  }
+
+  /**
+   * Runs set header.
+   * @param {string} key - Key.
+   * @param {string} value - Value to use.
+   * @returns {void} - No return value.
+   */
+  setHeader(key, value) {
+    this.headers[key] = [value]
+  }
+
+  /**
+   * Runs get body.
+   * @returns {string | Uint8Array | null} - The body.
+   */
+  getBody() {
+    if (this.body !== undefined) {
+      return this.body
+    }
+
+    throw new Error("No body has been set")
+  }
+
+  /**
+   * Runs get status code.
+   * @returns {number} - The status code.
+   */
+  getStatusCode() {
+    return this.statusCode || 200
+  }
+
+  /**
+   * Runs get status message.
+   * @returns {string} - The status message.
+   */
+  getStatusMessage() {
+    return this.statusMessage || "OK"
+  }
+
+  /**
+   * Runs set body.
+   * @param {string | Uint8Array} value - Value to use.
+   * @returns {void} - No return value.
+   */
+  setBody(value) {
+    this.filePath = null
+    this.body = value
+  }
+
+  /**
+   * Runs get file path.
+   * @returns {string | null} - File path.
+   */
+  getFilePath() {
+    return this.filePath
+  }
+
+  /**
+   * Runs set file path.
+   * @param {string} path - File path.
+   * @returns {void} - No return value.
+   */
+  setFilePath(path) {
+    this.filePath = path
+    this.body = null
+  }
+
+  /**
+   * Runs set error body.
+   * @param {Error} error - Error instance.
+   * @returns {void} - No return value.
+   */
+  setErrorBody(error) {
+    this.setHeader("Content-Type", "text/plain; charset=UTF-8")
+    this.setBody(`${error.message}\n\n${error.stack}`)
+  }
+
+  /**
+   * Accepts a numeric HTTP status code (e.g. `422`) or one of the
+   * named aliases (`"success"`, `"not-found"`, `"internal-server-error"`).
+   * Numeric inputs in the standard 1xx-5xx range resolve their own
+   * status messages from the IANA registry; aliases keep the
+   * back-compatible code mapping.
+   * @param {number | string} status - Status.
+   * @returns {void} - No return value.
+   */
+  setStatus(status) {
+    const aliasCode = NAMED_STATUS_ALIASES[String(status)]
+    const numericStatus = aliasCode ?? Number(status)
+
+    if (!Number.isInteger(numericStatus) || numericStatus < 100 || numericStatus > 599) {
+      throw new Error(`Unhandled status: ${status}`)
+    }
+
+    this.statusCode = numericStatus
+    this.statusMessage = STANDARD_STATUS_MESSAGES[numericStatus] || "OK"
+  }
+
+  /**
+   * Runs get request timeout ms.
+   * @returns {number | undefined} - Request timeout in seconds.
+   */
+  getRequestTimeoutMs() {
+    return this._requestTimeoutMs
+  }
+
+  /**
+   * Runs set request timeout ms.
+   * @param {number | undefined | null} timeoutSeconds - Timeout in seconds.
+   * @returns {void} - No return value.
+   */
+  setRequestTimeoutMs(timeoutSeconds) {
+    if (typeof timeoutSeconds === "number" && Number.isFinite(timeoutSeconds)) {
+      this._requestTimeoutMs = timeoutSeconds
+    } else {
+      this._requestTimeoutMs = undefined
+    }
+
+    if (this._requestTimeoutMsChangeHandler) {
+      this._requestTimeoutMsChangeHandler(this._requestTimeoutMs)
+    }
+  }
+
+  /**
+   * Runs set request timeout ms change handler.
+   * @param {(timeoutSeconds: number | undefined) => void} handler - Change handler.
+   * @returns {void} - No return value.
+   */
+  setRequestTimeoutMsChangeHandler(handler) {
+    this._requestTimeoutMsChangeHandler = handler
+  }
+}

package/src/http-server/client/uploaded-file/memory-uploaded-file.js

@@ -0,0 +1,32 @@
+// @ts-check
+
+import fs from "fs/promises"
+import UploadedFile from "./uploaded-file.js"
+
+export default class MemoryUploadedFile extends UploadedFile {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {Buffer} args.buffer - Buffer.
+   * @param {string} args.fieldName - Field name.
+   * @param {string} args.filename - Filename.
+   * @param {string | undefined} args.contentType - Content type.
+   * @param {number} args.size - Size.
+   */
+  constructor({buffer, contentType, fieldName, filename, size}) {
+    super({contentType, fieldName, filename, size})
+
+    this.buffer = buffer
+  }
+
+  getBuffer() { return this.buffer }
+
+  /**
+   * Runs save to.
+   * @param {string} destinationPath - Destination path.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async saveTo(destinationPath) {
+    await fs.writeFile(destinationPath, this.buffer)
+  }
+}

package/src/http-server/client/uploaded-file/temporary-uploaded-file.js

@@ -0,0 +1,32 @@
+// @ts-check
+
+import fs from "fs/promises"
+import UploadedFile from "./uploaded-file.js"
+
+export default class TemporaryUploadedFile extends UploadedFile {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {string} args.path - Path.
+   * @param {string} args.fieldName - Field name.
+   * @param {string} args.filename - Filename.
+   * @param {string | undefined} args.contentType - Content type.
+   * @param {number} args.size - Size.
+   */
+  constructor({contentType, fieldName, filename, path, size}) {
+    super({contentType, fieldName, filename, size})
+
+    this.pathValue = path
+  }
+
+  getPath() { return this.pathValue }
+
+  /**
+   * Runs save to.
+   * @param {string} destinationPath - Destination path.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async saveTo(destinationPath) {
+    await fs.copyFile(this.pathValue, destinationPath)
+  }
+}

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

@@ -0,0 +1,36 @@
+// @ts-check
+
+export default class UploadedFile {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {string} args.fieldName - Field name.
+   * @param {string} args.filename - Filename.
+   * @param {string | undefined} args.contentType - Content type.
+   * @param {number} args.size - Size.
+   */
+  constructor({contentType, fieldName, filename, size}) {
+    if (!fieldName) throw new Error("fieldName is required")
+    if (!filename) throw new Error("filename is required")
+    if (typeof size !== "number") throw new Error("size is required")
+
+    this.contentTypeValue = contentType
+    this.fieldNameValue = fieldName
+    this.filenameValue = filename
+    this.sizeValue = size
+  }
+
+  contentType() { return this.contentTypeValue }
+  fieldName() { return this.fieldNameValue }
+  filename() { return this.filenameValue }
+  size() { return this.sizeValue }
+
+  /**
+   * Runs save to.
+   * @param {string} _destinationPath - Destination path.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async saveTo(_destinationPath) {
+    throw new Error("Not implemented")
+  }
+}

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

@@ -0,0 +1,147 @@
+// @ts-check
+
+import querystring from "querystring"
+
+export default class VelociousHttpServerClientWebsocketRequest {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {?} [args.body] - Request body.
+   * @param {Record<string, string>} [args.headers] - Header list.
+   * @param {Record<string, ?>} [args.metadata] - Session metadata.
+   * @param {string} args.method - HTTP method.
+   * @param {string} args.path - Path.
+   * @param {Record<string, ?>} [args.params] - Parameters object.
+   * @param {string} [args.remoteAddress] - Remote address.
+   */
+  constructor({body, headers, metadata, method, params, path, remoteAddress}) {
+    if (!method) throw new Error("method is required")
+    if (!path) throw new Error("path is required")
+
+    this.body = body
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {Record<string, string>} */
+    this.headersMap = {}
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {Record<string, ?>} */
+    this.metadataObject = metadata ? {...metadata} : {}
+    this.method = method.toUpperCase()
+    /**
+     * Narrows the runtime value to the documented type.
+      @type {Record<string, ?>} */
+    this.paramsObject = {}
+    this._path = path
+    this.remoteAddressValue = remoteAddress
+
+    if (headers) {
+      for (const [key, value] of Object.entries(headers)) {
+        this.headersMap[key.toLowerCase()] = value
+      }
+    }
+
+    if (params) this.paramsObject = {...params}
+    if (this.body && typeof this.body === "object") this.paramsObject = {...this.paramsObject, ...this.body}
+    if (this.body && typeof this.body === "object" && !this.headersMap["content-type"]) {
+      this.headersMap["content-type"] = "application/json"
+    }
+
+    const queryParams = this._parseQueryParams()
+
+    this.paramsObject = {...queryParams, ...this.paramsObject}
+  }
+
+  baseURL() {
+    const protocol = this.protocol()
+    const host = this.hostWithPort()
+
+    if (protocol && host) return `${protocol}://${host}`
+  }
+
+  /**
+   * Runs header.
+   * @param {string} name - Header name.
+   * @returns {string | null} - Header value.
+   */
+  header(name) { return this.headersMap[name.toLowerCase()] || null }
+
+  headers() { return this.headersMap }
+
+  httpMethod() { return this.method }
+
+  httpVersion() { return "websocket" }
+
+  host() { return this.header("host") || undefined }
+
+  /**
+   * Runs metadata.
+   * @param {string} [key] - Metadata key.
+   * @returns {?} - Metadata value for a key, or the full metadata object.
+   */
+  metadata(key) {
+    if (key !== undefined) return this.metadataObject[key]
+
+    return {...this.metadataObject}
+  }
+
+  hostWithPort() {
+    const host = this.host()
+    const port = this.port()
+
+    if (!host) return
+    if (!port) return host
+
+    return `${host}:${port}`
+  }
+
+  origin() { return this.header("origin") }
+
+  path() { return this._path }
+
+  params() { return this.paramsObject }
+
+  port() {
+    const hostHeader = this.header("host")
+    const match = hostHeader?.match(/:(\d+)$/)
+
+    if (match) return parseInt(match[1])
+  }
+
+  protocol() {
+    const origin = this.origin()
+    const match = origin?.match(/^(.+):\/\//)
+
+    return match?.[1]
+  }
+
+  /**
+   * Runs query params.
+   * @returns {Record<string, string | string[]>} - Parsed query parameters from the URL.
+   */
+  queryParams() { return this._parseQueryParams() }
+
+  remoteAddress() { return this.remoteAddressValue }
+
+  _parseQueryParams() {
+    const query = this._path.split("?")[1]
+
+    if (!query) return Object.create(null)
+
+    const parsedQuery = querystring.parse(query)
+    /**
+     * Params.
+      @type {Record<string, string | string[]>} */
+    const params = Object.create(null)
+
+    for (const key of Object.keys(parsedQuery)) {
+      const value = parsedQuery[key]
+
+      if (typeof value !== "undefined") {
+        params[key] = value
+      }
+    }
+
+    return params
+  }
+}