velocious 1.0.0

package/src/database/query-parser/from-parser.cjs

@@ -0,0 +1,35 @@
+const {digs} = require("diggerize")
+
+module.exports = class VelociousDatabaseQueryParserFromParser {
+  constructor({pretty, query, queryParserOptions}) {
+    this.pretty = pretty
+    this.query = query
+    this.queryParserOptions = queryParserOptions
+  }
+
+  toSql() {
+    const {pretty, query} = digs(this, "pretty", "query")
+
+    let sql = " FROM"
+
+    for (const fromKey in query._froms) {
+      const from = query._froms[fromKey]
+
+      from.setOptions(this.queryParserOptions)
+
+      if (fromKey > 0) {
+        sql += ","
+      }
+
+      if (pretty) {
+        sql += "\n  "
+      } else {
+        sql += " "
+      }
+
+      sql += from.toSql()
+    }
+
+    return sql
+  }
+}

package/src/database/query-parser/joins-parser.cjs

@@ -0,0 +1,33 @@
+const {digs} = require("diggerize")
+
+module.exports = class VelocuiousDatabaseQueryParserJoinsParser {
+  constructor({pretty, query, queryParserOptions}) {
+    this.pretty = pretty
+    this.query = query
+    this.queryParserOptions = queryParserOptions
+  }
+
+  toSql() {
+    const {pretty, query} = digs(this, "pretty", "query")
+
+    let sql = ""
+
+    for (const joinKey in query._joins) {
+      const join = query._joins[joinKey]
+
+      join.setOptions(this.queryParserOptions)
+
+      if (joinKey == 0) {
+        if (pretty) {
+          sql += "\n\n"
+        } else {
+          sql += " "
+        }
+      }
+
+      sql += join.toSql()
+    }
+
+    return sql
+  }
+}

package/src/database/query-parser/options.cjs

@@ -0,0 +1,20 @@
+const {digg} = require("diggerize")
+
+module.exports = class VelociousDatabaseQueryParserOptions {
+  constructor(options) {
+    this.columnQuote = digg(options, "columnQuote")
+    this.tableQuote = digg(options, "tableQuote")
+  }
+
+  quoteColumnName(columnName) {
+    if (columnName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${columnName}`)
+
+    return `${this.columnQuote}${columnName}${this.columnQuote}`
+  }
+
+  quoteTableName(tableName) {
+    if (tableName.includes(this.tableQuote)) throw new Error(`Invalid table name: ${tableName}`)
+
+    return `${this.tableQuote}${tableName}${this.tableQuote}`
+  }
+}

package/src/database/query-parser/select-parser.cjs

@@ -0,0 +1,42 @@
+const {digs} = require("diggerize")
+
+module.exports = class VelociousDatabaseQueryParserSelectParser {
+  constructor({pretty, query, queryParserOptions}) {
+    this.pretty = pretty
+    this.query = query
+    this.queryParserOptions = queryParserOptions
+  }
+
+  toSql() {
+    const {pretty, query} = digs(this, "pretty", "query")
+
+    let sql = ""
+
+    sql += "SELECT"
+
+    if (pretty) {
+      sql += "\n"
+    } else {
+      sql += " "
+    }
+
+    for (const selectKey in query._selects) {
+      const selectValue = query._selects[selectKey]
+
+      selectValue.setOptions(this.queryParserOptions)
+
+      sql += selectValue.toSql()
+
+      if (selectKey + 1 < query._selects.length) {
+        if (pretty) {
+          sql += ","
+          sql += "  "
+        } else {
+          sql += ", "
+        }
+      }
+    }
+
+    return sql
+  }
+}

package/src/database/record/index.cjs

@@ -0,0 +1,5 @@
+module.exports = class VelociousDatabaseRecord {
+  static find(recordId) {
+    throw new Error("stub")
+  }
+}

package/src/error-logger.js

@@ -0,0 +1,18 @@
+module.exports = function errorLogger(callback) {
+  return async function(...args) {
+    try {
+      await callback(...args)
+    } catch (error) {
+      console.error(`ErrorLogger: ${error.message}`)
+
+      if (error.stack) {
+        console.error("Stack", error.stack)
+      } else {
+        console.error("No stack")
+      }
+
+      // Give console some time to write out messages before crashing
+      setTimeout(() => { throw error })
+    }
+  }
+}

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

@@ -0,0 +1,75 @@
+const Configuration = require("../../configuration.cjs")
+const {digg} = require("diggerize")
+const {EventEmitter} = require("events")
+const logger = require("../../logger.cjs")
+const Request = require("./request.cjs")
+const RequestRunner = require("./request-runner.cjs")
+
+module.exports = class VeoliciousHttpServerClient {
+  events = new EventEmitter()
+  state = "initial"
+
+  constructor({clientCount, configuration, onExecuteRequest}) {
+    if (!configuration) throw new Error("No configuration given")
+
+    this.clientCount = clientCount
+    this.configuration = configuration
+    this.onExecuteRequest = onExecuteRequest
+  }
+
+  executeCurrentRequest() {
+    logger(this, "executeCurrentRequest")
+
+    this.state = "response"
+
+    const requestRunner = new RequestRunner({
+      configuration: this.configuration,
+      request: this.currentRequest,
+      routes: this.routes
+    })
+
+    requestRunner.events.on("done", (requestRunner) => this.sendResponse(requestRunner))
+    requestRunner.run()
+  }
+
+  onWrite(data) {
+    if (this.state == "initial") {
+      this.currentRequest = new Request({
+        configuration: this.configuration
+      })
+      this.currentRequest.requestParser.events.on("done", () => this.executeCurrentRequest())
+      this.currentRequest.feed(data)
+      this.state = "requestStarted"
+    } else if (this.state == "requestStarted") {
+      this.currentRequest.feed(data)
+    } else {
+      throw new Error(`Unknown state: ${this.state}`)
+    }
+  }
+
+  sendResponse(requestRunner) {
+    const response = digg(requestRunner, "response")
+    const body = response.getBody()
+    const date = new Date()
+
+    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 200 OK\r\n"
+
+    for (const headerKey in response.headers) {
+      for (const headerValue of response.headers[headerKey]) {
+        headers += `${headerKey}: ${headerValue}\r\n`
+      }
+    }
+
+    headers += "\r\n"
+
+    this.events.emit("output", headers)
+    this.events.emit("output", body)
+  }
+}

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

@@ -0,0 +1,92 @@
+const {EventEmitter} = require("events")
+const logger = require("../../logger.cjs")
+
+module.exports = class VelociousHttpServerClientRequestParser {
+  constructor({configuration}) {
+    if (!configuration) throw new Error("No configuration given")
+
+    this.configuration = configuration
+    this.data = []
+    this.events = new EventEmitter()
+    this.headers = []
+    this.headersByName = {}
+    this.state = "status"
+  }
+
+  addHeader(name, value) {
+    logger(this, "addHeader", {name, value})
+
+    this.headers.push({name, value})
+
+    const formattedName = name.toLowerCase().trim()
+
+    this.headersByName[formattedName] = value
+  }
+
+  feed(data) {
+    if (this.state == "status" || this.state == "headers") {
+      for (const char of data) {
+        this.data.push(char)
+
+        if (char == 10) {
+          const line = String.fromCharCode.apply(null, this.data)
+
+          this.data = []
+          this.parse(line)
+        }
+      }
+    }
+  }
+
+  matchAndRemove(regex) {
+    const match = this.data.match(regex)
+
+    if (!match) {
+      return null
+    }
+
+    this.data = this.data.replace(regex, "")
+
+    return match
+  }
+
+  parse(line) {
+    if (this.state == "status") {
+      this.parseStatusLine(line)
+    } else if (this.state == "headers") {
+      this.parseHeader(line)
+    } else {
+      throw new Error(`Unknown state: ${this.state}`)
+    }
+  }
+
+  parseHeader(line) {
+    let match
+
+    if (match = line.match(/^(.+): (.+)\r\n/)) {
+      const name = match[1]
+      const value = match[2]
+
+      this.addHeader(name, value)
+    } else if (line == "\r\n") {
+      if (this.httpMethod.toUpperCase() == "GET") {
+        this.state = "done"
+        this.events.emit("done")
+      } else {
+        throw new Error(`Unknown HTTP method: ${this.httpMethod}`)
+      }
+    }
+  }
+
+  parseStatusLine(line) {
+    const match = line.match(/^(GET|POST) (.+?) HTTP\/1\.1\r\n/)
+
+    if (!match) {
+      throw new Error(`Couldn't match status line from: ${line}`)
+    }
+
+    this.httpMethod = match[1]
+    this.path = match[2]
+    this.state = "headers"
+  }
+}

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

@@ -0,0 +1,32 @@
+const EventEmitter = require("events")
+const logger = require("../../logger.cjs")
+const Response = require("./response.cjs")
+const RoutesResolver = require("../../routes/resolver.cjs")
+
+module.exports = class VelociousHttpServerClientRequestRunner {
+  events = new EventEmitter()
+
+  constructor({configuration, request}) {
+    if (!configuration) throw new Error("No configuration given")
+    if (!request) throw new Error("No request given")
+
+    this.configuration = configuration
+    this.request = request
+    this.response = new Response({configuration})
+  }
+
+  async run() {
+    if (!this.request) throw new Error("No request?")
+
+    logger(this, "Run request")
+
+    const routesResolver = new RoutesResolver({
+      configuration: this.configuration,
+      request: this.request,
+      response: this.response
+    })
+
+    await routesResolver.resolve()
+    this.events.emit("done", this)
+  }
+}

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

@@ -0,0 +1,25 @@
+const {digg} = require("diggerize")
+const RequestParser = require("./request-parser.cjs")
+
+module.exports = class VelociousHttpServerClientRequest {
+  constructor({configuration}) {
+    this.configuration = configuration
+    this.requestParser = new RequestParser({configuration})
+  }
+
+  feed(data) {
+    this.requestParser.feed(data)
+  }
+
+  httpMethod() {
+    return digg(this, "requestParser", "httpMethod")
+  }
+
+  host() {
+    return digg(this, "requestParser", "headersByName", "host")
+  }
+
+  path() {
+    return digg(this, "requestParser", "path")
+  }
+}

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

@@ -0,0 +1,28 @@
+module.exports = class VelociousHttpServerClientResponse {
+  body = undefined
+  headers = {}
+
+  constructor({configuration}) {
+    this.configuration = configuration
+  }
+
+  addHeader(key, value) {
+    if (!(key in this.headers)) {
+      this.headers[key] = []
+    }
+
+    this.headers[key].push(value)
+  }
+
+  getBody() {
+    if (this.body) {
+      return this.body
+    }
+
+    throw new Error("No body has been set")
+  }
+
+  setBody(value) {
+    this.body = value
+  }
+}

package/src/http-server/index.cjs

@@ -0,0 +1,78 @@
+const logger = require("../logger.cjs")
+const Net = require("net")
+const WorkerHandler = require("./worker-handler/index.cjs")
+
+module.exports = class VelociousHttpServer {
+  constructor({configuration, host, maxWorkers, port}) {
+    this.configuration = configuration
+    this.host = host
+    this.port = port
+    this.clientCount = 0
+    this.maxWorkers = maxWorkers || 16
+    this.workerCount = 0
+    this.workerHandlers = []
+  }
+
+  async start() {
+    // We need at least one worker to handle requests
+    if (this.workerHandlers.length == 0) {
+      await this.spawnWorker()
+    }
+
+    this.netServer = new Net.Server()
+    this.netServer.on("connection", (socket) => this.onConnection(socket))
+    this.netServer.listen(this.port, () => {
+      logger(this, `Velocious listening on ${this.host}:${this.port}`)
+    })
+  }
+
+  stop() {
+    return new Promise((resolve) => {
+      this.netServer?.close(() => resolve())
+    })
+  }
+
+  onConnection(socket) {
+    const clientCount = this.clientCount
+
+    logger(this, `New client ${clientCount}`)
+
+    this.clientCount++
+
+    const workerHandler = this.workerHandlerToUse()
+
+    logger(this, `Gave client ${clientCount} to worker ${workerHandler.workerCount}`)
+
+    workerHandler.addSocketConnection({
+      socket,
+      clientCount: this.clientCount
+    })
+  }
+
+  async spawnWorker() {
+    const workerCount = this.workerCount
+
+    this.workerCount++
+
+    const workerHandler = new WorkerHandler({
+      configuration: this.configuration,
+      workerCount
+    })
+
+    await workerHandler.start()
+    this.workerHandlers.push(workerHandler)
+  }
+
+  workerHandlerToUse() {
+    logger(this, `Worker handlers length: ${this.workerHandlers.length}`)
+
+    const randomWorkerNumber = parseInt(Math.random() * this.workerHandlers.length)
+    const workerHandler = this.workerHandlers[randomWorkerNumber]
+
+    if (!workerHandler) {
+      throw new Error(`No workerHandler by that number: ${randomWorkerNumber}`)
+    }
+
+    return workerHandler
+  }
+}

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

@@ -0,0 +1,78 @@
+const {digs} = require("diggerize")
+const logger = require("../../logger.cjs")
+const SocketHandler = require("./socket-handler.cjs")
+const {Worker} = require("worker_threads")
+
+module.exports = class VelociousHttpServerWorker {
+  constructor({configuration, workerCount}) {
+    this.configuration = configuration
+    this.socketHandlers = {}
+    this.workerCount = workerCount
+  }
+
+  async start() {
+    return new Promise((resolve) => {
+      const {debug, directory} = digs(this.configuration, "debug", "directory")
+
+      this.onStartCallback = resolve
+      this.worker = new Worker("./src/http-server/worker-handler/worker-script.cjs", {
+        workerData: {
+          debug,
+          directory,
+          workerCount: this.workerCount
+        }
+      })
+      this.worker.on("error", (error) => this.onWorkerError(error))
+      this.worker.on("exit", (code) => this.onWorkerExit(code))
+      this.worker.on("message", (message) => this.onWorkerMessage(message))
+    })
+  }
+
+  addSocketConnection({socket, clientCount}) {
+    socket.on("end", () => {
+      logger(this, `Removing ${clientCount} from socketHandlers`)
+      delete this.socketHandlers[clientCount]
+    })
+
+    const socketHandler = new SocketHandler({
+      configuration: this.configuration,
+      socket,
+      clientCount,
+      worker: this.worker
+    })
+
+    this.socketHandlers[clientCount] = socketHandler
+    this.worker.postMessage({command: "newClient", clientCount})
+  }
+
+  onWorkerError(error) {
+    throw new Error(`Worker error: ${error}`)
+  }
+
+  onWorkerExit(code) {
+    if (code !== 0) {
+      throw new Error(`Client worker stopped with exit code ${code}`)
+    }
+  }
+
+  onWorkerMessage(data) {
+    logger(this, `Worker message`, data)
+
+    const {command} = digs(data, "command")
+
+    if (command == "started") {
+      this.onStartCallback()
+      this.onStartCallback = null
+    } else if (command == "clientOutput") {
+      logger(this, "CLIENT OUTPUT", data)
+
+      const {clientCount, output} = digs(data, "clientCount", "output")
+
+      logger(this, "CLIENT OUTPUT", data)
+
+      this.socketHandlers[clientCount].send(output)
+    } else {
+      throw new Error(`Unknown command: ${command}`)
+    }
+  }
+}

package/src/http-server/worker-handler/socket-handler.cjs

@@ -0,0 +1,35 @@
+const logger = require("../../logger.cjs")
+
+module.exports = class VelociousHttpServerWorkerHandlerSocketHandler {
+  constructor({configuration, socket, clientCount, worker}) {
+    if (!configuration) throw new Error("No configuration given")
+
+    this.configuration = configuration
+    this.socket = socket
+    this.clientCount = clientCount
+    this.worker = worker
+
+    socket.on("data", (chunk) => this.onSocketData(chunk))
+    socket.on("end", () => this.onSocketEnd())
+  }
+
+  onSocketData(chunk) {
+    logger(this, `Socket ${this.clientCount}: ${chunk}`)
+
+    this.worker.postMessage({
+      command: "clientWrite",
+      chunk,
+      clientCount: this.clientCount
+    })
+  }
+
+  onSocketEnd() {
+    logger(this, `Socket ${this.clientCount} end`)
+  }
+
+  send(data) {
+    logger(this, "Send", data)
+
+    this.socket.write(data)
+  }
+}

package/src/http-server/worker-handler/worker-script.cjs

@@ -0,0 +1,4 @@
+const { workerData, parentPort } = require("worker_threads")
+const WorkerThread = require("./worker-thread.cjs")
+
+new WorkerThread({parentPort, workerData})

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

@@ -0,0 +1,49 @@
+const Client = require("../client/index.cjs")
+const Configuration = require("../../configuration.cjs")
+const {digg, digs} = require("diggerize")
+const errorLogger = require("../../error-logger")
+const logger = require("../../logger.cjs")
+
+module.exports = class VelociousHttpServerWorkerHandlerWorkerThread {
+  constructor({parentPort, workerData}) {
+    const {debug, directory, workerCount} = digs(workerData, "debug", "directory", "workerCount")
+
+    this.clients = {}
+    this.configuration = new Configuration({debug, directory})
+    this.parentPort = parentPort
+    this.workerCount = workerCount
+
+    parentPort.on("message", errorLogger((data) => this.onCommand(data)))
+
+    logger(this, `Worker ${workerCount} started`)
+
+    parentPort.postMessage({command: "started"})
+  }
+
+  onCommand(data) {
+    logger(this, `Worker ${this.workerCount} received command`, data)
+
+    const {command} = data
+
+    if (command == "newClient") {
+      const {clientCount} = digs(data, "clientCount")
+      const client = new Client({
+        clientCount,
+        configuration: this.configuration
+      })
+
+      client.events.on("output", (output) => {
+        this.parentPort.postMessage({command: "clientOutput", clientCount, output})
+      })
+
+      this.clients[clientCount] = client
+    } else if (command == "clientWrite") {
+      const {chunk, clientCount} = digs(data, "chunk", "clientCount")
+      const client = digg(this.clients, clientCount)
+
+      client.onWrite(chunk)
+    } else {
+      throw new Error(`Unknown command: ${command}`)
+    }
+  }
+}

package/src/logger.cjs

@@ -0,0 +1,11 @@
+const {digg} = require("diggerize")
+
+module.exports = function log(object, ...messages) {
+  if (!object.configuration) console.error(`No configuration on ${object.constructor.name}`)
+
+  if (object.configuration?.debug) {
+    const className = digg(object, "constructor", "name")
+
+    console.log(className, ...messages)
+  }
+}