velocious 1.0.1 → 1.0.3

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

@@ -0,0 +1,47 @@
+import {digg} from "diggerize"
+import {EventEmitter} from "events"
+import Incorporator from "incorporator"
+import ParamsToObject from "./params-to-object.mjs"
+import RequestBuffer from "./request-buffer/index.mjs"
+
+export default class VelociousHttpServerClientRequestParser {
+  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)
+  }
+
+  onFormDataPart = (formDataPart) => {
+    const unorderedParams = {}
+
+    unorderedParams[formDataPart.getName()] = formDataPart.getValue()
+
+    const paramsToObject = new ParamsToObject(unorderedParams)
+    const newParams = paramsToObject.toObject()
+    const incorporator = new Incorporator({objects: [this.params, newParams]})
+
+    incorporator.merge()
+  }
+
+  feed = (data) => this.requestBuffer.feed(data)
+  getHeader = (name) => this.requestBuffer.getHeader(name)?.value
+  getHttpMethod = () => digg(this, "requestBuffer", "httpMethod")
+  getHost = () => this.requestBuffer.getHeader("host")?.value
+  getPath = () => digg(this, "requestBuffer", "path")
+
+  requestDone = () => {
+    const incorporator = new Incorporator({objects: [this.params, this.requestBuffer.params]})
+
+    incorporator.merge()
+    this.state = "done"
+    this.events.emit("done")
+  }
+}

package/src/http-server/client/{request-runner.cjs → request-runner.mjs}

@@ -1,9 +1,9 @@
-const EventEmitter = require("events")
-const logger = require("../../logger.cjs")
-const Response = require("./response.cjs")
-const RoutesResolver = require("../../routes/resolver.cjs")
+import EventEmitter from "events"
+import logger from "../../logger.mjs"
+import Response from "./response.mjs"
+import RoutesResolver from "../../routes/resolver.mjs"
 
-module.exports = class VelociousHttpServerClientRequestRunner {
+export default class VelociousHttpServerClientRequestRunner {
   events = new EventEmitter()
 
   constructor({configuration, request}) {

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

@@ -0,0 +1,15 @@
+import {digg} from "diggerize"
+import RequestParser from "./request-parser.mjs"
+
+export default class VelociousHttpServerClientRequest {
+  constructor({configuration}) {
+    this.configuration = configuration
+    this.requestParser = new RequestParser({configuration})
+  }
+
+  feed = (data) => this.requestParser.feed(data)
+  httpMethod = () => this.requestParser.getHttpMethod()
+  host = () => this.requestParser.getHost()
+  path = () => this.requestParser.getPath()
+  params = () => digg(this, "requestParser", "params")
+}

package/src/http-server/client/{response.cjs → response.mjs}

@@ -1,4 +1,4 @@
-module.exports = class VelociousHttpServerClientResponse {
+export default class VelociousHttpServerClientResponse {
   body = undefined
   headers = {}
 

package/src/http-server/index.mjs

@@ -0,0 +1,137 @@
+import {digg} from "diggerize"
+import logger from "../logger.mjs"
+import Net from "net"
+import ServerClient from "./server-client.mjs"
+import WorkerHandler from "./worker-handler/index.mjs"
+
+export default class VelociousHttpServer {
+  clientCount = 0
+  clients = {}
+  workerCount = 0
+  workerHandlers = []
+
+  constructor({configuration, host, maxWorkers, port}) {
+    this.configuration = configuration
+    this.host = host || "0.0.0.0"
+    this.port = port || 3006
+    this.maxWorkers = maxWorkers || 16
+  }
+
+  async start() {
+    await this._ensureAtLeastOneWorker()
+    this.netServer = new Net.Server()
+    this.netServer.on("connection", this.onConnection)
+    await this._netServerListen()
+  }
+
+  _netServerListen() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.netServer.listen(this.port, this.host, () => {
+          logger(this, `Velocious listening on ${this.host}:${this.port}`)
+          resolve()
+        })
+      } catch (error) {
+        reject(error)
+      }
+    })
+  }
+
+  async _ensureAtLeastOneWorker() {
+    if (this.workerHandlers.length == 0) {
+      await this.spawnWorker()
+    }
+  }
+
+  isActive() {
+    return this.netServer.listening
+  }
+
+  async stopClients() {
+    for (const clientCount in this.clients) {
+      const client = this.clients[clientCount]
+
+      await client.close()
+    }
+  }
+
+  stopServer() {
+    return new Promise((resolve, reject) => {
+      this.netServer.close((error) => {
+        if (error) {
+          reject(error)
+        } else {
+          resolve()
+        }
+      })
+    })
+  }
+
+  async stop() {
+    await this.stopClients()
+    await this.stopServer()
+  }
+
+  onConnection = (socket) => {
+    const clientCount = this.clientCount
+
+    logger(this, `New client ${clientCount}`)
+
+    this.clientCount++
+
+    const workerHandler = this.workerHandlerToUse()
+    const client = new ServerClient({
+      clientCount,
+      configuration: this.configuration,
+      socket
+    })
+
+    client.events.on("close", this.onClientClose)
+
+    logger(this, `Gave client ${clientCount} to worker ${workerHandler.workerCount}`)
+
+    workerHandler.addSocketConnection(client)
+
+    this.clients[clientCount] = client
+  }
+
+  onClientClose = (client) => {
+    const clientCount = digg(client, "clientCount")
+    const oldClientsLength = Object.keys(this.clients).length
+
+    delete this.clients[clientCount]
+
+    const newClientsLength = Object.keys(this.clients).length
+
+    if (newClientsLength != (oldClientsLength - 1)) {
+      console.error(`Expected client to have been removed but length didn't change from ${oldClientsLength} to ${oldClientsLength - 1}`)
+    }
+  }
+
+  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/server-client.mjs

@@ -0,0 +1,47 @@
+import EventEmitter from "events"
+import logger from "../logger.mjs"
+
+export default class ServerClient {
+  events = new EventEmitter()
+
+  constructor({configuration, socket, clientCount}) {
+    if (!configuration) throw new Error("No configuration given")
+
+    this.configuration = configuration
+    this.socket = socket
+    this.clientCount = clientCount
+
+    socket.on("end", this.onSocketEnd)
+  }
+
+  listen = () => this.socket.on("data", this.onSocketData)
+
+  close() {
+    return new Promise((resolve, reject) => {
+      this.socket.destroy()
+      this.events.emit("close", this)
+      resolve()
+    })
+  }
+
+  onSocketData = (chunk) => {
+    logger(this, `Socket ${this.clientCount}: ${chunk}`)
+
+    this.worker.postMessage({
+      command: "clientWrite",
+      chunk,
+      clientCount: this.clientCount
+    })
+  }
+
+  onSocketEnd = () => {
+    logger(this, `Socket ${this.clientCount} end`)
+    this.events.emit("close", this)
+  }
+
+  send(data) {
+    logger(this, "Send", data)
+
+    this.socket.write(data)
+  }
+}

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

@@ -0,0 +1,79 @@
+import {digg, digs} from "diggerize"
+import {dirname} from "path"
+import {fileURLToPath} from "url"
+import logger from "../../logger.mjs"
+import {Worker} from "worker_threads"
+
+export default class VelociousHttpServerWorker {
+  constructor({configuration, workerCount}) {
+    this.configuration = configuration
+    this.clients = {}
+    this.workerCount = workerCount
+  }
+
+  async start() {
+    return new Promise((resolve) => {
+      const {debug, directory} = digs(this.configuration, "debug", "directory")
+      const __filename = fileURLToPath(import.meta.url)
+      const __dirname = dirname(__filename)
+
+      this.onStartCallback = resolve
+      this.worker = new Worker(`${__dirname}/worker-script.mjs`, {
+        workerData: {
+          debug,
+          directory,
+          workerCount: this.workerCount
+        }
+      })
+      this.worker.on("error", this.onWorkerError)
+      this.worker.on("exit", this.onWorkerExit)
+      this.worker.on("message", this.onWorkerMessage)
+    })
+  }
+
+  addSocketConnection(client) {
+    const clientCount = digg(client, "clientCount")
+
+    client.socket.on("end", () => {
+      logger(this, `Removing ${clientCount} from clients`)
+      delete this.clients[clientCount]
+    })
+
+    client.worker = this.worker
+    client.listen()
+
+    this.clients[clientCount] = client
+    this.worker.postMessage({command: "newClient", clientCount})
+  }
+
+  onWorkerError = (error) => {
+    throw error // Throws original error with backtrace and everything into the console
+  }
+
+  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.clients[clientCount].send(output)
+    } else {
+      throw new Error(`Unknown command: ${command}`)
+    }
+  }
+}

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

@@ -0,0 +1,4 @@
+import {workerData, parentPort} from "worker_threads"
+import WorkerThread from "./worker-thread.mjs"
+
+new WorkerThread({parentPort, workerData})

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

@@ -0,0 +1,65 @@
+import Application from "../../application.mjs"
+import Client from "../client/index.mjs"
+import DatabasePool from "../../database/pool/index.mjs"
+import {digg, digs} from "diggerize"
+import errorLogger from "../../error-logger.mjs"
+import logger from "../../logger.mjs"
+
+export default class VelociousHttpServerWorkerHandlerWorkerThread {
+  constructor({parentPort, workerData}) {
+    const {workerCount} = digs(workerData, "workerCount")
+
+    this.clients = {}
+    this.parentPort = parentPort
+    this.workerData = workerData
+    this.workerCount = workerCount
+
+    parentPort.on("message", errorLogger(this.onCommand))
+
+    this.initialize().then(() => {
+      this.application.initialize().then(() => {
+        logger(this, `Worker ${workerCount} started`)
+        parentPort.postMessage({command: "started"})
+      })
+    })
+  }
+
+  async initialize() {
+    const {debug, directory} = digs(this.workerData, "debug", "directory")
+    const configurationPath = `${this.workerData.directory}/src/config/configuration.mjs`
+    const configurationImport = await import(configurationPath)
+    const configuration = configurationImport.default
+
+    this.application = new Application({configuration, debug, directory})
+
+    this.configuration = configuration
+    this.configuration.setCurrent()
+  }
+
+  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 → logger.mjs}

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

package/src/routes/base-route.mjs

@@ -0,0 +1,34 @@
+import GetRoute from "./get-route.mjs"
+import ResourceRoute from "./resource-route.mjs"
+
+var VelociousBaseRoute
+
+export function initBaseRoute() {
+  if (VelociousBaseRoute) return
+
+  VelociousBaseRoute = class VelociousBaseRoute {
+    routes = []
+
+    get(name, args) {
+      const route = new GetRoute({name, args})
+
+      this.routes.push(route)
+    }
+
+    matchWithPath(_path) {
+      throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
+    }
+
+    resources(name, callback) {
+      const route = new ResourceRoute({name})
+
+      this.routes.push(route)
+
+      if (callback) {
+        callback(route)
+      }
+    }
+  }
+}
+
+export {VelociousBaseRoute as default}

package/src/routes/{get-route.cjs → get-route.mjs}

@@ -1,7 +1,9 @@
-const BaseRoute = require("./base-route.cjs")
-const escapeStringRegexp = require("escape-string-regexp")
+import BaseRoute, {initBaseRoute} from "./base-route.mjs"
+import escapeStringRegexp from "escape-string-regexp"
 
-module.exports = class VelociousRouteGetRoute extends BaseRoute {
+initBaseRoute()
+
+export default class VelociousRouteGetRoute extends BaseRoute {
   constructor({name}) {
     super()
     this.name = name

package/src/routes/index.mjs

@@ -0,0 +1,9 @@
+import RootRoute from "./root-route.mjs"
+
+export default class VelociousRoutes {
+  rootRoute = new RootRoute()
+
+  draw(callback) {
+    callback(this.rootRoute)
+  }
+}

package/src/routes/{resolver.cjs → resolver.mjs}

@@ -1,18 +1,18 @@
-const {digg, digs} = require("diggerize")
+import {digg, digs} from "diggerize"
 
-module.exports = class VelociousRoutesResolver {
-  constructor({configuration, request, response, routes}) {
+export default class VelociousRoutesResolver {
+  constructor({configuration, request, response}) {
     if (!configuration) throw new Error("No configuration given")
     if (!request) throw new Error("No request given")
     if (!response) throw new Error("No response given")
 
     this.configuration = configuration
-    this.params = {}
+    this.params = request.params()
     this.request = request
     this.response = response
   }
 
-  resolve() {
+  async resolve() {
     let currentRoute = digg(this, "configuration", "routes", "rootRoute")
     let currentPath = this.request.path()
 
@@ -21,8 +21,9 @@ module.exports = class VelociousRoutesResolver {
     if (!matchResult) throw new Error(`Couldn't match a route with the given path: ${currentPath}`)
 
     if (this.params.action && this.params.controller) {
-      const controllerPath = `${digg(this, "configuration", "directory")}/src/routes/${digg(this, "params", "controller")}/controller.cjs`
-      const controllerClass = require(controllerPath)
+      const controllerPath = `${digg(this, "configuration", "directory")}/src/routes/${digg(this, "params", "controller")}/controller.mjs`
+      const controllerClassImport = await import(controllerPath)
+      const controllerClass = controllerClassImport.default
       const controllerInstance = new controllerClass({
         configuration: this.configuration,
         params: this.params,
@@ -30,7 +31,13 @@ module.exports = class VelociousRoutesResolver {
         response: this.response
       })
 
-      controllerInstance[this.params.action]()
+      if (!(this.params.action in controllerInstance)) {
+        throw new Error(`Missing action on controller: ${this.params.controller}#${this.params.action}`)
+      }
+
+      await this.configuration.getDatabasePool().withConnection(async () => {
+        await controllerInstance[this.params.action]()
+      })
 
       return
     }
@@ -44,7 +51,8 @@ module.exports = class VelociousRoutesResolver {
     for (const subRoute of route.routes) {
       const matchResult = subRoute.matchWithPath({
         params: this.params,
-        path: pathWithoutSlash
+        path: pathWithoutSlash,
+        request: this.request
       })
 
       if (!matchResult) continue

package/src/routes/{resource-route.cjs → resource-route.mjs}

@@ -1,14 +1,16 @@
-const BaseRoute = require("./base-route.cjs")
-const escapeStringRegexp = require("escape-string-regexp")
+import BaseRoute, {initBaseRoute} from "./base-route.mjs"
+import escapeStringRegexp from "escape-string-regexp"
 
-module.exports = class VelociousRouteResourceRoute extends BaseRoute {
+initBaseRoute()
+
+export default class VelociousRouteResourceRoute extends BaseRoute {
   constructor({name}) {
     super()
     this.name = name
     this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
   }
 
-  matchWithPath({params, path}) {
+  matchWithPath({params, path, request}) {
     const match = path.match(this.regExp)
 
     if (match) {
@@ -24,7 +26,9 @@ module.exports = class VelociousRouteResourceRoute extends BaseRoute {
       }
 
       if (!subRoutesMatchesRestPath) {
-        if (restPath.match(/\/(.+)/)) {
+        if (request.httpMethod() == "POST") {
+          action = "create"
+        } else if (restPath.match(/\/(.+)/)) {
           // TODO: This should change the action to "show" and set the "resource_name_id" in params.
           action = "show"
         }

package/src/routes/root-route.mjs

@@ -0,0 +1,6 @@
+import BaseRoute, {initBaseRoute} from "./base-route.mjs"
+
+initBaseRoute()
+
+export default class VelociousRootRoute extends BaseRoute {
+}

package/src/spec/index.mjs

@@ -0,0 +1,5 @@
+export default class VelocuiousSpec {
+  static describe(description) {
+    throw new Error("stub", description)
+  }
+}

package/src/templates/configuration.mjs

@@ -0,0 +1,17 @@
+import {Configuration} from "velocious"
+
+const configuration = new Configuration({
+  database: {
+    default: {
+      master: {
+        type: "mysql",
+        host: "mariadb",
+        username: "username",
+        password: "password",
+        database: "database"
+      }
+    }
+  }
+})
+
+export default configuration

package/src/templates/generate-migration.mjs

@@ -0,0 +1,11 @@
+import {Database} from "velocious"
+
+export default class __MIGRATION_NAME__ extends Database.Migration {
+  async up() {
+    await this.connection().execute("...")
+  }
+
+  async down() {
+    await this.connection().execute("...")
+  }
+}

package/src/templates/routes.mjs

@@ -0,0 +1,11 @@
+import {Routes} from "velocious"
+
+const routes = new Routes()
+
+routes.draw((route) => {
+  route.resources("tasks", (route) => {
+    route.get("users")
+  })
+})
+
+export default {routes}

package/src/utils/file-exists.mjs

@@ -0,0 +1,13 @@
+import fs from "node:fs/promises"
+
+const fileExists = async (path) => {
+  try {
+    await fs.access(path)
+
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+export default fileExists

package/bin/velocious

@@ -1,14 +0,0 @@
-#!/usr/bin/node
-
-console.log("Hello", process.argv)
-
-const args = process.argv.slice(2)
-
-console.log(args)
-
-if (args[0] == "g" && args[1] == "migration") {
-  const migrationName = args[2]
-  const date = new Date()
-
-  console.log({ migrationName, date })
-}