velocious 1.0.37 → 1.0.39

package/package.json

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

package/spec/database/record/create-spec.js

@@ -1,6 +1,7 @@
 import Dummy from "../../dummy/index.js"
 import Project from "../../dummy/src/models/project.js"
 import Task from "../../dummy/src/models/task.js"
+import {ValidationError} from "../../../src/database/record/index.js"
 
 describe("Record - create", () => {
   it("creates a new simple record with relationships and translations", async () => {
@@ -49,7 +50,8 @@ describe("Record - create", () => {
 
         throw new Error("Didnt expect to succeed")
       } catch (error) {
-        expect(error.message).toEqual("Validation failed: Name can't be blank")
+        expect(error).toBeInstanceOf(ValidationError)
+        expect(error.message).toEqual("Name can't be blank")
       }
 
       const projectsCount = await Project.count()

package/spec/database/record/validations-spec.js

@@ -1,12 +1,13 @@
 import Dummy from "../../dummy/index.js"
 import Task from "../../dummy/src/models/task.js"
+import {ValidationError} from "../../../src/database/record/index.js"
 
 describe("Record - validations", () => {
   it("raises validations if trying to create an invalid record because of a presence validation", async () => {
     await Dummy.run(async () => {
       const task = new Task({name: " "})
 
-      await expectAsync(task.save()).toBeRejectedWith(new Error("Validation failed: Name can't be blank"))
+      await expectAsync(task.save()).toBeRejectedWith(new ValidationError("Name can't be blank"))
     })
   })
 
@@ -21,7 +22,8 @@ describe("Record - validations", () => {
 
         throw new Error("Task 2 save didn't fail")
       } catch (error) {
-        expect(error.message).toEqual("Validation failed: Name has already been taken")
+        expect(error).toBeInstanceOf(ValidationError)
+        expect(error.message).toEqual("Name has already been taken")
       }
     })
   })

package/spec/database/transactions-spec.js

@@ -1,6 +1,7 @@
 import Dummy from "../dummy/index.js"
 import dummyConfiguration from "../dummy/src/config/configuration.js"
 import Task from "../dummy/src/models/task.js"
+import {ValidationError} from "../../src/database/record/index.js"
 
 describe("database - transactions", () => {
   it("supports transactions and savepoints", async () => {
@@ -22,7 +23,8 @@ describe("database - transactions", () => {
                 throw new Error("Didn't expect to succeed")
               })
             } catch (error) {
-              expect(error.message).toEqual("Validation failed: Name can't be blank")
+              expect(error).toBeInstanceOf(ValidationError)
+              expect(error.message).toEqual("Name can't be blank")
             }
           })
         })

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

@@ -23,7 +23,7 @@ describe("HttpServer", () => {
 
         expect(response.status).toEqual(404)
         expect(response.statusText).toEqual("Not Found")
-        expect(text).toEqual("Not found!\n")
+        expect(text).toEqual("Path not found: /tasks/doesnt-exist\n")
       }
     })
   })

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

@@ -23,7 +23,7 @@ describe("HttpServer", () => {
 
         expect(response.status).toEqual(404)
         expect(response.statusText).toEqual("Not Found")
-        expect(text).toEqual("Not found!\n")
+        expect(text).toEqual("Path not found: /doesnt-exist\n")
       }
     })
   })

package/src/cli/commands/test.js

@@ -12,10 +12,10 @@ export default class VelociousCliCommandsInit extends BaseCommand {
 
     if (testRunner.isFailed()) {
       console.error(`Test run failed with ${testRunner.failedTests} failed tests and ${testRunner.successfulTests} successfull`)
-      process.exit(-1)
+      process.exit(1)
     } else {
       console.log(`Test run succeeded with ${testRunner.successfulTests} successful tests`)
-      process.exit(1)
+      process.exit(0)
     }
   }
 }

package/src/configuration.js

@@ -1,5 +1,6 @@
 import {digg} from "diggerize"
 import restArgsError from "./utils/rest-args-error.js"
+import {withTrackedStack} from "./utils/with-tracked-stack.js"
 
 export default class VelociousConfiguration {
   static current(throwError = true) {
@@ -153,8 +154,11 @@ export default class VelociousConfiguration {
 
   async withConnections(callback) {
     const dbs = {}
+    const stack = Error().stack
     const actualCallback = async () => {
-      return await callback(dbs)
+      await withTrackedStack(stack, async () => {
+        return await callback(dbs)
+      })
     }
 
     let runRequest = actualCallback

package/src/controller.js

@@ -1,5 +1,6 @@
 import {digs} from "diggerize"
 import ejs from "ejs"
+import {incorporate} from "incorporator"
 import * as inflection from "inflection"
 import {Logger} from "./logger.js"
 import restArgsError from "./utils/rest-args-error.js"
@@ -31,6 +32,18 @@ export default class VelociousController {
     this._viewPath = viewPath
   }
 
+  getAction() {
+    return this._action
+  }
+
+  getParams() {
+    return this._params
+  }
+
+  getRequest() {
+    return this._request
+  }
+
   async _runBeforeCallbacks() {
     await this.logger.debug("_runBeforeCallbacks")
 
@@ -88,8 +101,9 @@ export default class VelociousController {
     return new Promise((resolve, reject) => {
       const viewPath = `${this._viewPath}/${inflection.dasherize(inflection.underscore(this._action))}.ejs`
       const {viewParams} = digs(this, "viewParams")
+      const actualViewParams = incorporate({controller: this}, viewParams)
 
-      ejs.renderFile(viewPath, viewParams, {}, (err, str) => {
+      ejs.renderFile(viewPath, actualViewParams, {}, (err, str) => {
         if (err) {
           reject(err)
         } else {

package/src/database/record/index.js

@@ -10,6 +10,24 @@ import Query from "../query/index.js"
 import ValidatorsPresence from "./validators/presence.js"
 import ValidatorsUniqueness from "./validators/uniqueness.js"
 
+class ValidationError extends Error {
+  getModel() {
+    return this._model
+  }
+
+  setModel(model) {
+    this._model = model
+  }
+
+  getValidationErrors() {
+    return this._validationErrors
+  }
+
+  setValidationErrors(validationErrors) {
+    this._validationErrors = validationErrors
+  }
+}
+
 class VelociousDatabaseRecord {
   static validatorTypes() {
     if (!this._validatorTypes) this._validatorTypes = {}
@@ -883,7 +901,12 @@ class VelociousDatabaseRecord {
     }
 
     if (Object.keys(this._validationErrors).length > 0) {
-      throw new Error(`Validation failed: ${this.fullErrorMessages().join(". ")}`)
+      const validationError = new ValidationError(this.fullErrorMessages().join(". "))
+
+      validationError.setValidationErrors(this._validationErrors)
+      validationError.setModel(this)
+
+      throw validationError
     }
   }
 
@@ -913,4 +936,5 @@ class VelociousDatabaseRecord {
 VelociousDatabaseRecord.registerValidatorType("presence", ValidatorsPresence)
 VelociousDatabaseRecord.registerValidatorType("uniqueness", ValidatorsUniqueness)
 
+export {ValidationError}
 export default VelociousDatabaseRecord

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

@@ -1,6 +1,6 @@
 import {digg} from "diggerize"
 import {EventEmitter} from "events"
-import Incorporator from "incorporator"
+import {incorporate} from "incorporator"
 import ParamsToObject from "./params-to-object.js"
 import RequestBuffer from "./request-buffer/index.js"
 
@@ -33,9 +33,8 @@ export default class VelociousHttpServerClientRequestParser {
 
     const paramsToObject = new ParamsToObject(unorderedParams)
     const newParams = paramsToObject.toObject()
-    const incorporator = new Incorporator({objects: [this.params, newParams]})
 
-    incorporator.merge()
+    incorporate(this.params, newParams)
   }
 
   feed = (data) => this.requestBuffer.feed(data)
@@ -82,9 +81,7 @@ export default class VelociousHttpServerClientRequestParser {
   getProtocol = () => this._getHostMatch()?.protocol
 
   requestDone = () => {
-    const incorporator = new Incorporator({objects: [this.params, this.requestBuffer.params]})
-
-    incorporator.merge()
+    incorporate(this.params, this.requestBuffer.params)
 
     this.state = "done"
     this.events.emit("done")

package/src/routes/built-in/errors/not-found.ejs

@@ -1 +1 @@
-Not found!
+Path not found: <%= controller.getRequest().path() %>

package/src/testing/test-runner.js

@@ -1,3 +1,4 @@
+import {addTrackedStackToError} from "../utils/with-tracked-stack.js"
 import Application from "../../src/application.js"
 import RequestClient from "./request-client.js"
 import {tests} from "./test.js"
@@ -39,7 +40,7 @@ export default class TestRunner {
 
   async importTestFiles() {
     for (const testFile of this.testFiles) {
-      const importTestFile = await import(testFile)
+      await import(testFile)
     }
   }
 
@@ -50,18 +51,39 @@ export default class TestRunner {
   async run() {
     this.failedTests = 0
     this.successfulTests = 0
-
     await this.importTestFiles()
+    this.onlyFocussed = this.areAnyTestsFocussed(tests)
     await this.runTests(tests, [], 0)
   }
 
+  areAnyTestsFocussed(tests) {
+    for (const testDescription in tests.tests) {
+      const testData = tests.tests[testDescription]
+      const testArgs = Object.assign({}, testData.args)
+
+      if (testArgs.focus) {
+        return true
+      }
+    }
+
+    for (const subDescription in tests.subs) {
+      const subTest = tests.subs[subDescription]
+      const result = this.areAnyTestsFocussed(subTest)
+
+      if (result) return true
+    }
+
+    return false
+  }
+
   async runTests(tests, descriptions, indentLevel) {
     const leftPadding = " ".repeat(indentLevel * 2)
 
     for (const testDescription in tests.tests) {
       const testData = tests.tests[testDescription]
       const testArgs = Object.assign({}, testData.args)
-      const testName = descriptions.concat([`it ${testDescription}`]).join(" - ")
+
+      if (this.onlyFocussed && !testArgs.focus) continue
 
       if (testArgs.type == "request") {
         testArgs.application = await this.application()
@@ -77,7 +99,7 @@ export default class TestRunner {
         this.failedTests++
 
         // console.error(`${leftPadding}  Test failed: ${error.message}`)
-        console.error(error.stack)
+        console.error(addTrackedStackToError(error))
       }
     }
 
@@ -86,9 +108,10 @@ export default class TestRunner {
         const subTest = tests.subs[subDescription]
         const newDecriptions = descriptions.concat([subDescription])
 
-        console.log(`${leftPadding}${subDescription}`)
-
-        await this.runTests(subTest, newDecriptions, indentLevel + 1)
+        if (!this.onlyFocussed || this.areAnyTestsFocussed(subTest)) {
+          console.log(`${leftPadding}${subDescription}`)
+          await this.runTests(subTest, newDecriptions, indentLevel + 1)
+        }
       }
     })
   }

package/src/testing/test.js

@@ -153,4 +153,20 @@ function it(description, arg1, arg2) {
   currentTest.tests[description] = {args: newTestArgs, function: testFunction}
 }
 
-export {describe, expect, it, tests}
+function fit(description, arg1, arg2) {
+  let testArgs, testFunction
+
+  if (typeof arg1 == "function") {
+    testFunction = arg1
+    testArgs = {focus: true}
+  } else if (typeof arg2 == "function") {
+    testFunction = arg2
+    testArgs = Object.assign({focus: true}, arg1)
+  } else {
+    throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)
+  }
+
+  return it(description, testArgs, testFunction)
+}
+
+export {describe, expect, fit, it, tests}

package/src/utils/with-tracked-stack.js

@@ -0,0 +1,61 @@
+import {AsyncLocalStorage} from "async_hooks"
+
+let asyncLocalStorage
+
+if (AsyncLocalStorage) {
+  asyncLocalStorage = new AsyncLocalStorage()
+}
+
+function addTrackedStackToError(error) {
+  // Not supported
+  if (!asyncLocalStorage) return
+
+  const parentStacks = asyncLocalStorage.getStore() || []
+  const additionalStackLines = []
+
+  for (const parentStack of parentStacks) {
+    for (const parentStackLine of parentStack) {
+      additionalStackLines.push(parentStackLine)
+    }
+  }
+
+  // Replace the error message on the first line with this string
+  error.stack += "\n" + additionalStackLines.join("\n")
+}
+
+async function withTrackedStack(arg1, arg2) {
+  let callback, stack
+
+  if (arg2) {
+    callback = arg2
+    stack = arg1
+  } else {
+    callback = arg1
+    stack = Error().stack
+  }
+
+  // Not supported
+  if (!asyncLocalStorage) return await callback()
+
+  const parentStacks = asyncLocalStorage.getStore() || []
+  const additionalStackLines = ["    [WITH TRACKED STACK]"]
+  const currentStackLines = stack.split("\n")
+
+  for (let i = currentStackLines.length; i >= 0; i--) {
+    const stackLine = currentStackLines[i]
+
+    if (stackLine == "    [WITH TRACKED STACK]") {
+      break
+    } else {
+      additionalStackLines.unshift(stackLine)
+    }
+  }
+
+  const newStacks = [additionalStackLines, ...parentStacks]
+
+  await asyncLocalStorage.run(newStacks, async () => {
+    return await callback()
+  })
+}
+
+export {addTrackedStackToError, withTrackedStack}