velocious 1.0.24 → 1.0.25

package/bin/velocious.js

@@ -3,7 +3,23 @@
 import Cli from "../src/cli/index.js"
 
 const processArgs = process.argv.slice(2)
-const cli = new Cli({processArgs})
+const parsedProcessArgs = {}
+
+for (let i = 0; i < processArgs.length; i++) {
+  const processArg = processArgs[i]
+  const singleLetterArgMatch = processArg.match(/^-([a-z])$/)
+  const multiLetterArgMatch = processArg.match(/^--([a-z]+)$/)
+
+  if (singleLetterArgMatch) {
+    parsedProcessArgs[singleLetterArgMatch[1]] = processArgs[i + 1]
+    i++
+  } else if (multiLetterArgMatch) {
+    parsedProcessArgs[multiLetterArgMatch[1]] = processArgs[i + 1]
+    i++
+  }
+}
+
+const cli = new Cli({parsedProcessArgs, processArgs})
 
 await cli.execute()
 

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "main": "index.js",
   "scripts": {
     "test": "jasmine",

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

@@ -7,7 +7,20 @@ describe("HttpServer", () => {
       const response = await fetch("http://localhost:3006/tasks")
       const text = await response.text()
 
+      expect(response.status).toEqual(200)
+      expect(response.statusText).toEqual("OK")
       expect(text).toEqual("1, 2, 3, 4, 5\n")
     })
   })
+
+  it("returns a 404 error when a collection action isnt found", async () => {
+    await Dummy.run(async () => {
+      const response = await fetch("http://localhost:3006/tasks/doesnt-exist")
+      const text = await response.text()
+
+      expect(response.status).toEqual(404)
+      expect(response.statusText).toEqual("Not Found")
+      expect(text).toEqual("Not found!\n")
+    })
+  })
 })

package/src/application.js

@@ -55,7 +55,7 @@ export default class VelociousApplication {
   }
 
   onHttpServerClose = () => {
-    console.log("HTTP server closed")
+    logger(this, "HTTP server closed")
 
     if (this.waitResolve) {
       this.waitResolve()

package/src/cli/commands/server.js

@@ -9,8 +9,9 @@ export default class VelociousCliCommandsServer extends BaseCommand{
 
     await this.databaseConnection.connect()
 
-    const host = "0.0.0.0"
-    const port = 3006
+    const {parsedProcessArgs} = this.args
+    const host = parsedProcessArgs.h || parsedProcessArgs.host || "127.0.0.1"
+    const port = parsedProcessArgs.p || parsedProcessArgs.port || 3006
     const application = new Application({
       configuration: this.configuration,
       httpServer: {

package/src/controller.js

@@ -1,9 +1,16 @@
 import {digs} from "diggerize"
 import ejs from "ejs"
 import * as inflection from "inflection"
+import logger from "./logger.js"
 import restArgsError from "./utils/rest-args-error.js"
 
 export default class VelociousController {
+  static beforeAction(methodName) {
+    if (!this._beforeActions) this._beforeActions = []
+
+    this._beforeActions.push(methodName)
+  }
+
   constructor({action, configuration, controller, params, request, response, viewPath}) {
     if (!action) throw new Error("No action given")
     if (!configuration) throw new Error("No configuration given")
@@ -23,6 +30,36 @@ export default class VelociousController {
     this._viewPath = viewPath
   }
 
+  async _runBeforeCallbacks() {
+    await logger(this, "_runBeforeCallbacks")
+
+    let currentControllerClass = this.constructor
+
+    while (currentControllerClass) {
+      await logger(this, `Running callbacks for ${currentControllerClass.name}`)
+
+      const beforeActions = currentControllerClass._beforeActions
+
+      if (beforeActions) {
+        for (const beforeActionName of beforeActions) {
+          const beforeAction = currentControllerClass.prototype[beforeActionName]
+
+          if (!beforeAction) throw new Error(`No such before action: ${beforeActionName}`)
+
+          const boundBeforeAction = beforeAction.bind(this)
+
+          await boundBeforeAction()
+        }
+      }
+
+      currentControllerClass = Object.getPrototypeOf(currentControllerClass)
+
+      if (!currentControllerClass?.name?.endsWith("Controller")) break
+    }
+
+    await logger(this, "After runBeforeCallbacks")
+  }
+
   params = () => this._params
 
   render({json, status, ...restArgs} = {}) {

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

@@ -40,6 +40,7 @@ export default class VeoliciousHttpServerClient {
       this.currentRequest = new Request({
         configuration: this.configuration
       })
+
       this.currentRequest.requestParser.events.on("done", this.executeCurrentRequest)
       this.currentRequest.feed(data)
       this.state = "requestStarted"

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

@@ -152,7 +152,7 @@ export default class RequestBuffer {
 
       this.events.emit("header", header)
     } else if (line == "\r\n") {
-      if (this.httpMethod.toUpperCase() == "GET") {
+      if (this.httpMethod.toUpperCase() == "GET" || this.httpMethod.toUpperCase() == "OPTIONS") {
         this.completeRequest()
       } else if (this.httpMethod.toUpperCase() == "POST") {
         this.readingBody = true
@@ -176,7 +176,7 @@ export default class RequestBuffer {
   }
 
   parseStatusLine(line) {
-    const match = line.match(/^(GET|POST) (.+?) HTTP\/1\.1\r\n/)
+    const match = line.match(/^(GET|OPTIONS|POST) (.+?) HTTP\/1\.1\r\n/)
 
     if (!match) {
       throw new Error(`Couldn't match status line from: ${line}`)
@@ -185,6 +185,8 @@ export default class RequestBuffer {
     this.httpMethod = match[1]
     this.path = match[2]
     this.setState("headers")
+
+    logger(this, () => ["Parsed status line", {httpMethod: this.httpMethod, path: this.path}])
   }
 
   postRequestDone() {
@@ -194,7 +196,7 @@ export default class RequestBuffer {
   }
 
   setState(newState) {
-    logger(this, `Changing state from ${this.state} to ${newState}`)
+    logger(this, () => [`Changing state from ${this.state} to ${newState}`])
 
     this.state = newState
   }

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

@@ -34,9 +34,46 @@ export default class VelociousHttpServerClientRequestParser {
   feed = (data) => this.requestBuffer.feed(data)
   getHeader = (name) => this.requestBuffer.getHeader(name)?.value
   getHttpMethod = () => digg(this, "requestBuffer", "httpMethod")
-  getHost = () => this.requestBuffer.getHeader("host")?.value
+
+  _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 = () => 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 = () => this._getHostMatch()?.protocol
+
   requestDone = () => {
     const incorporator = new Incorporator({objects: [this.params, this.requestBuffer.params]})
 

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

@@ -19,17 +19,27 @@ export default class VelociousHttpServerClientRequestRunner {
   getState = () => this.state
 
   async run() {
-    if (!this.request) throw new Error("No request?")
+    const {configuration, request, response} = this
 
-    logger(this, "Run request")
+    if (!request) throw new Error("No request?")
 
-    const routesResolver = new RoutesResolver({
-      configuration: this.configuration,
-      request: this.request,
-      response: this.response
-    })
+    try {
+      if (request.httpMethod() == "OPTIONS" && request.header("sec-fetch-mode") == "cors") {
+        await logger(this, () => ["Run CORS", {httpMethod: request.httpMethod(), secFetchMode: request.header("sec-fetch-mode")}])
+        await configuration.cors({request, response})
+      } else {
+        await logger(this, "Run request")
+        const routesResolver = new RoutesResolver({configuration, request, response})
+
+        await routesResolver.resolve()
+      }
+    } catch (error) {
+      await logger(this, `Error while running request: ${error.message}`)
+
+      response.setStatus(500)
+      response.setErrorBody(error)
+    }
 
-    await routesResolver.resolve()
     this.state = "done"
     this.events.emit("done", this)
   }

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

@@ -7,9 +7,31 @@ export default class VelociousHttpServerClientRequest {
     this.requestParser = new RequestParser({configuration})
   }
 
+  baseURL = () => `${this.protocol()}://${this.hostWithPort()}`
   feed = (data) => this.requestParser.feed(data)
+  header = (headerName) => this.requestParser.requestBuffer.getHeader(headerName)?.value
   httpMethod = () => this.requestParser.getHttpMethod()
   host = () => 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 = () => this.header("origin")
   path = () => this.requestParser.getPath()
   params = () => digg(this, "requestParser", "params")
+  port = () => this.requestParser.getPort()
+  protocol = () => this.requestParser.getProtocol()
 }

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

@@ -15,7 +15,7 @@ export default class VelociousHttpServerClientResponse {
   }
 
   getBody() {
-    if (this.body) {
+    if (this.body !== undefined) {
       return this.body
     }
 
@@ -34,10 +34,21 @@ export default class VelociousHttpServerClientResponse {
     this.body = value
   }
 
+  setErrorBody(error) {
+    this.body = `${error.message}\n\n${error.stack}`
+    this.addHeader("Content-Type", "text/plain")
+  }
+
   setStatus(status) {
-    if (status == "not-found" || status == 404) {
+    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}`)
     }

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

@@ -25,7 +25,7 @@ export default class ServerClient {
   }
 
   onSocketData = (chunk) => {
-    logger(this, `Socket ${this.clientCount}: ${chunk}`)
+    logger(this, () => [`Socket ${this.clientCount}: ${chunk}`])
 
     this.worker.postMessage({
       command: "clientWrite",

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

@@ -54,6 +54,8 @@ export default class VelociousHttpServerWorker {
   onWorkerExit = (code) => {
     if (code !== 0) {
       throw new Error(`Client worker stopped with exit code ${code}`)
+    } else {
+      logger(this, () => [`Client worker stopped with exit code ${code}`])
     }
   }
 
@@ -66,12 +68,10 @@ export default class VelociousHttpServerWorker {
       this.onStartCallback()
       this.onStartCallback = null
     } else if (command == "clientOutput") {
-      logger(this, "CLIENT OUTPUT", data)
+      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-thread.js

@@ -38,10 +38,10 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
     }
   }
 
-  onCommand = (data) => {
-    logger(this, `Worker ${this.workerCount} received command`, data)
+  onCommand = async (data) => {
+    await logger(this, () => [`Worker ${this.workerCount} received command`, data])
 
-    const {command} = data
+    const command = data.command
 
     if (command == "newClient") {
       const {clientCount} = digs(data, "clientCount")
@@ -56,9 +56,13 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
 
       this.clients[clientCount] = client
     } else if (command == "clientWrite") {
+      await logger(this, "Looking up client")
+
       const {chunk, clientCount} = digs(data, "chunk", "clientCount")
       const client = digg(this.clients, clientCount)
 
+      await logger(this, `Sending to client ${clientCount}`)
+
       client.onWrite(chunk)
     } else {
       throw new Error(`Unknown command: ${command}`)

package/src/logger.js

@@ -1,13 +1,51 @@
-export default function log(object, ...messages) {
-  if (!object.configuration) console.error(`No configuration on ${object.constructor.name}`)
+import Configuration from "./configuration.js"
 
-  if (object.configuration?.debug) {
-    if (!object.constructor.name) {
-      throw new Error(`No constructor name for object`)
-    }
+function consoleLog(message) {
+  return new Promise((resolve) => {
+    process.stdout.write(message, "utf8", resolve)
+  })
+}
+
+export default async function log(object, ...messages) {
+  let configuration
+
+  if (object.configuration) {
+    configuration = object.configuration
+  } else {
+    configuration = Configuration.current()
+  }
+
+  if (configuration?.debug) {
+    try {
+      if (!object.constructor.name) {
+        throw new Error(`No constructor name for object`)
+      }
 
-    const className = object.constructor.name
+      const className = object.constructor.name
 
-    console.log(className, ...messages)
+      if (messages.length === 1 && typeof messages[0] == "function") {
+        messages = messages[0]()
+      }
+
+      let message = ""
+
+      for (const messagePartIndex in messages) {
+        const messagePart = messages[messagePartIndex]
+
+        if (messagePartIndex > 0) {
+          message += " "
+        }
+
+        if (typeof messagePart == "object") {
+          message += JSON.stringify(messagePart)
+        } else {
+          message += messagePart
+        }
+      }
+
+      await consoleLog(`${className} ${message}\n`)
+    } catch (error) {
+      console.error(`ERROR ${error.message}`)
+    }
   }
 }

package/src/routes/get-route.js

@@ -10,7 +10,7 @@ export default class VelociousRouteGetRoute extends BaseRoute {
     this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
   }
 
-  matchWithPath(path) {
+  matchWithPath({path}) {
     if (path.match(this.regExp)) {
       const [_beginnigSlash, _matchedName, restPath] = match
 

package/src/routes/resolver.js

@@ -57,6 +57,7 @@ export default class VelociousRoutesResolver {
     }
 
     await this.configuration.getDatabasePool().withConnection(async () => {
+      await controllerInstance._runBeforeCallbacks()
       await controllerInstance[action]()
     })
   }

package/src/routes/resource-route.js

@@ -20,7 +20,7 @@ export default class VelociousRouteResourceRoute extends BaseRoute {
       let subRoutesMatchesRestPath = false
 
       for (const route of this.routes) {
-        if (route.matchWithPath(restPath)) {
+        if (route.matchWithPath({path: restPath})) {
           subRoutesMatchesRestPath = true
         }
       }