velocious 1.0.40 → 1.0.42

package/src/database/table-data/index.js

@@ -3,7 +3,7 @@ import restArgsError from "../../utils/rest-args-error.js"
 class TableColumn {
   constructor(name, args) {
     if (args) {
-      const {autoIncrement, default: columnDefault, foreignKey, maxLength, name, null: argsNull, primaryKey, type, ...restArgs} = args
+      const {autoIncrement, default: columnDefault, foreignKey, index, maxLength, name, null: argsNull, primaryKey, type, ...restArgs} = args
 
       restArgsError(restArgs)
     }
@@ -15,6 +15,7 @@ class TableColumn {
   getAutoIncrement = () => this.args?.autoIncrement
   getDefault = () => this.args?.default
   getForeignKey = () => this.args?.foreignKey
+  getIndex = () => this.args?.index
   getMaxLength = () => this.args?.maxLength
   getName = () => this.name
   getNull = () => this.args?.null

package/src/database/use-database.js

@@ -14,7 +14,7 @@ const loadMigrations = function loadMigrations({migrationsRequireContext, ...res
     instance.running = true
 
     try {
-      await Configuration.current().withConnections(async () => {
+      await Configuration.current().ensureConnections(async () => {
         const migrator = new Migrator({configuration: Configuration.current()})
 
         await migrator.prepare()

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

@@ -166,12 +166,16 @@ export default class RequestBuffer {
           this.multiPartyFormData = true
           this.setState("multi-part-form-data")
         } else {
-          if (!this.contentLength) throw new Error("Content length hasn't been set")
-
-          this.postBodyBuffer = new ArrayBuffer(this.contentLength)
-          this.postBodyChars = new Uint8Array(this.postBodyBuffer)
+          if (this.contentLength === 0) {
+            this.completeRequest()
+          } else if (!this.contentLength) {
+            throw new Error("Content length hasn't been set")
+          } else {
+            this.postBodyBuffer = new ArrayBuffer(this.contentLength)
+            this.postBodyChars = new Uint8Array(this.postBodyBuffer)
 
-          this.setState("post-body")
+            this.setState("post-body")
+          }
         }
       } else {
         throw new Error(`Unknown HTTP method: ${this.httpMethod}`)

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

@@ -7,13 +7,13 @@ 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()
+  baseURL() { return `${this.protocol()}://${this.hostWithPort()}` }
+  feed(data) { return this.requestParser.feed(data) }
+  header(headerName) { return this.requestParser.requestBuffer.getHeader(headerName)?.value }
+  httpMethod() { return this.requestParser.getHttpMethod() }
+  host() { return this.requestParser.getHost() }
 
-  hostWithPort = () => {
+  hostWithPort() {
     const port = this.port()
     const protocol = this.protocol()
     let hostWithPort = `${this.host()}`

package/src/routes/base-route.js

@@ -1,4 +1,5 @@
 import GetRoute from "./get-route.js"
+import NamespaceRoute from "./namespace-route.js"
 import PostRoute from "./post-route.js"
 import ResourceRoute from "./resource-route.js"
 
@@ -20,6 +21,16 @@ export function initBaseRoute() {
       throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
     }
 
+    namespace(name, callback) {
+      const route = new NamespaceRoute({name})
+
+      this.routes.push(route)
+
+      if (callback) {
+        callback(route)
+      }
+    }
+
     post(name, args) {
       const route = new PostRoute({name, args})
 

package/src/routes/namespace-route.js

@@ -0,0 +1,24 @@
+import BaseRoute, {initBaseRoute} from "./base-route.js"
+import escapeStringRegexp from "escape-string-regexp"
+
+initBaseRoute()
+
+export default class VelociousRouteNamespaceRoute extends BaseRoute {
+  constructor({name}) {
+    super()
+    this.name = name
+    this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
+  }
+
+  matchWithPath({params, path}) {
+    const match = path.match(this.regExp)
+
+    if (match) {
+      const [_beginnigSlash, _matchedName, restPath] = match
+
+      params.controller = this.name
+
+      return {restPath}
+    }
+  }
+}

package/src/routes/resolver.js

@@ -59,7 +59,7 @@ export default class VelociousRoutesResolver {
       throw new Error(`Missing action on controller: ${controller}#${action}`)
     }
 
-    await this.configuration.withConnections(async () => {
+    await this.configuration.ensureConnections(async () => {
       await controllerInstance._runBeforeCallbacks()
       await controllerInstance[action]()
     })

package/src/templates/configuration.js

@@ -43,7 +43,7 @@ export default new Configuration({
     const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
     const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
 
-    await configuration.withConnections(async () => {
+    await configuration.ensureConnections(async () => {
       await initializerFromRequireContext.initialize({configuration})
     })
   },

package/src/testing/test-runner.js

@@ -45,45 +45,87 @@ export default class TestRunner {
   }
 
   isFailed() {
-    return this.failedTests > 0
+    return this._failedTests > 0
   }
 
-  async run() {
-    this.failedTests = 0
-    this.successfulTests = 0
+  getFailedTests() {
+    return this._failedTests
+  }
+
+  getSuccessfulTests() {
+    return this._successfulTests
+  }
+
+  getTestsCount() {
+    return this._testsCount
+  }
+
+  async prepare() {
+    this._failedTests = 0
+    this._successfulTests = 0
+    this._testsCount = 0
     await this.importTestFiles()
-    this.onlyFocussed = this.areAnyTestsFocussed(tests)
-    await this.runTests(tests, [], 0)
+    await this.analyzeTests(tests)
+    this._onlyFocussed = this.anyTestsFocussed
+
+    const testingConfigPath = this.configuration.getTesting()
+
+    if (testingConfigPath) {
+      await import(testingConfigPath)
+    }
+  }
+
+  async run() {
+    await this.configuration.ensureConnections(async () => {
+      await this.runTests({
+        afterEaches: [],
+        beforeEaches: [],
+        tests,
+        descriptions: [],
+        indentLevel: 0
+      })
+    })
   }
 
-  areAnyTestsFocussed(tests) {
+  analyzeTests(tests) {
+    let anyTestsFocussedFound = false
+
     for (const testDescription in tests.tests) {
       const testData = tests.tests[testDescription]
       const testArgs = Object.assign({}, testData.args)
 
+      this._testsCount++
+
       if (testArgs.focus) {
-        return true
+        anyTestsFocussedFound = true
+        this.anyTestsFocussed = true
       }
     }
 
     for (const subDescription in tests.subs) {
       const subTest = tests.subs[subDescription]
-      const result = this.areAnyTestsFocussed(subTest)
+      const {anyTestsFocussed} = this.analyzeTests(subTest)
+
+      if (anyTestsFocussed) {
+        anyTestsFocussedFound = true
+      }
 
-      if (result) return true
+      subTest.anyTestsFocussed = anyTestsFocussed
     }
 
-    return false
+    return {anyTestsFocussed: anyTestsFocussedFound}
   }
 
-  async runTests(tests, descriptions, indentLevel) {
+  async runTests({afterEaches, beforeEaches, tests, descriptions, indentLevel}) {
     const leftPadding = " ".repeat(indentLevel * 2)
+    const newAfterEaches = [...afterEaches, ...tests.afterEaches]
+    const newBeforeEaches = [...beforeEaches, ...tests.beforeEaches]
 
     for (const testDescription in tests.tests) {
       const testData = tests.tests[testDescription]
       const testArgs = Object.assign({}, testData.args)
 
-      if (this.onlyFocussed && !testArgs.focus) continue
+      if (this._onlyFocussed && !testArgs.focus) continue
 
       if (testArgs.type == "request") {
         testArgs.application = await this.application()
@@ -93,26 +135,44 @@ export default class TestRunner {
       console.log(`${leftPadding}it ${testDescription}`)
 
       try {
+        for (const beforeEachData of newBeforeEaches) {
+          await beforeEachData.callback({testArgs, testData})
+        }
+
         await testData.function(testArgs)
-        this.successfulTests++
+        this._successfulTests++
       } catch (error) {
-        this.failedTests++
+        this._failedTests++
 
         // console.error(`${leftPadding}  Test failed: ${error.message}`)
-        console.error(addTrackedStackToError(error))
-      }
-    }
+        addTrackedStackToError(error)
 
-    await this.configuration.withConnections(async () => {
-      for (const subDescription in tests.subs) {
-        const subTest = tests.subs[subDescription]
-        const newDecriptions = descriptions.concat([subDescription])
+        const stackLines = error.stack.split("\n")
 
-        if (!this.onlyFocussed || this.areAnyTestsFocussed(subTest)) {
-          console.log(`${leftPadding}${subDescription}`)
-          await this.runTests(subTest, newDecriptions, indentLevel + 1)
+        for (const stackLine of stackLines) {
+          console.error(`${leftPadding}  ${stackLine}`)
+        }
+      } finally {
+        for (const afterEachData of newAfterEaches) {
+          await afterEachData.callback({testArgs, testData})
         }
       }
-    })
+    }
+
+    for (const subDescription in tests.subs) {
+      const subTest = tests.subs[subDescription]
+      const newDecriptions = descriptions.concat([subDescription])
+
+      if (!this._onlyFocussed || subTest.anyTestsFocussed) {
+        console.log(`${leftPadding}${subDescription}`)
+        await this.runTests({
+          afterEaches: newAfterEaches,
+          beforeEaches: newBeforeEaches,
+          tests: subTest,
+          descriptions: newDecriptions,
+          indentLevel: indentLevel + 1
+        })
+      }
+    }
   }
 }

package/src/testing/test.js

@@ -1,13 +1,28 @@
+import {anythingDifferent} from "set-state-compare/src/diff-utils.js"
 import restArgsError from "../utils/rest-args-error.js"
 
 const tests = {
+  afterEaches: [],
   args: {},
+  beforeEaches: [],
   subs: {},
   tests: {}
 }
 
 let currentPath = [tests]
 
+function beforeEach(callback) {
+  const currentTest = currentPath[currentPath.length - 1]
+
+  currentTest.beforeEaches.push({callback})
+}
+
+function afterEach(callback) {
+  const currentTest = currentPath[currentPath.length - 1]
+
+  currentTest.afterEaches.push({callback})
+}
+
 class ExpectToChange {
   constructor({changeCallback, expect, ...restArgs}) {
     restArgsError(restArgs)
@@ -45,7 +60,61 @@ class Expect {
     this.expectations = []
   }
 
+  andChange(...args) {
+    return this.toChange(...args)
+  }
+
+  get not() {
+    this._not = true
+
+    return this
+  }
+
+  toBe(result) {
+    if (this._not) {
+      if (this._object === result) {
+        throw new Error(`${this._object} was unexpected not to be ${result}`)
+      }
+    } else {
+      if (this._object !== result) {
+        throw new Error(`${this._object} wasn't expected be ${result}`)
+      }
+    }
+  }
+
+  toBeDefined() {
+    if (this._not) {
+      if (this._object !== undefined) {
+        throw new Error(`${this._object} wasn´t expected to be defined`)
+      }
+    } else {
+      if (this._object === undefined) {
+        throw new Error(`${this._object} wasn't expected be undefined`)
+      }
+    }
+  }
+
+  toBeInstanceOf(klass) {
+    if (!(this._object instanceof klass)) {
+      throw new Error(`Expected ${this._object?.constructor?.name || "null"} to be a ${klass.name} but it wasn't`)
+    }
+  }
+
+  toBeFalse() {
+    this.toBe(false)
+  }
+
+  toBeUndefined() {
+    this.toBe(undefined)
+  }
+
+  toBeTrue() {
+    this.toBe(true)
+  }
+
   toChange(changeCallback) {
+    if (this._not) throw new Error("not stub")
+
     const expectToChange = new ExpectToChange({changeCallback, expect: this})
 
     this.expectations.push(expectToChange)
@@ -53,13 +122,81 @@ class Expect {
     return expectToChange
   }
 
-  andChange(...args) {
-    return this.toChange(...args)
+  toContain(valueToContain) {
+    if (this._not) throw new Error("not stub")
+
+    if (!this._object.includes(valueToContain)) {
+      throw new Error(`${this._object} doesn't contain ${valueToContain}`)
+    }
   }
 
   toEqual(result) {
-    if (this._object != result) {
-      throw new Error(`${this._object} wasn't equal to ${result}`)
+    if (this._not) {
+      if (typeof this._object == "object" && typeof result == "object") {
+        if (!anythingDifferent(this._object, result)) {
+          throw new Error(`${this._object} was unexpected equal to ${result}`)
+        }
+      } else {
+        if (this._object == result) {
+          throw new Error(`${this._object} was unexpected equal to ${result}`)
+        }
+      }
+    } else {
+      if (typeof this._object == "object" && typeof result == "object") {
+        if (anythingDifferent(this._object, result)) {
+          throw new Error(`${JSON.stringify(this._object)} wasn't equal to ${JSON.stringify(result)}`)
+        }
+      } else {
+        if (this._object != result) {
+          throw new Error(`${this._object} wasn't equal to ${result}`)
+        }
+      }
+    }
+  }
+
+  toMatch(regex) {
+    const match = this._object.match(regex)
+
+    if (this._not) {
+      if (match) {
+        throw new Error(`${this._object} shouldn't match ${regex}`)
+      }
+    } else {
+      if (!match) {
+        throw new Error(`${this._object} didn't match ${regex}`)
+      }
+    }
+  }
+
+  async toThrowError(expectedError) {
+    if (this._not) throw new Error("not stub")
+
+    let failedError
+
+    try {
+      await this._object()
+    } catch (error) {
+      failedError = error
+    }
+
+    if (!failedError) throw new Error("Expected to fail but didn't")
+
+    let expectedErrorMessage, failedErrorMessage
+
+    if (typeof failedError == "string") {
+      failedErrorMessage = failedError
+    } else {
+      failedErrorMessage = failedError.message
+    }
+
+    if (typeof expectedError == "string") {
+      expectedErrorMessage = expectedError
+    } else {
+      expectedErrorMessage = expectedError.message
+    }
+
+    if (failedErrorMessage != expectedErrorMessage) {
+      throw new Error(`Expected to fail with '${expectedErrorMessage}' but failed with '${failedErrorMessage}'`)
     }
   }
 
@@ -82,6 +219,8 @@ class Expect {
   }
 
   toHaveAttributes(result) {
+    if (this._not) throw new Error("not stub")
+
     const differences = {}
 
     for (const key in result) {
@@ -93,8 +232,9 @@ class Expect {
       }
     }
 
-    if (Object.keys(differences).length > 0)
-    throw new Error(`Object had differet values: ${JSON.stringify(differences)}`)
+    if (Object.keys(differences).length > 0) {
+      throw new Error(`Object had differet values: ${JSON.stringify(differences)}`)
+    }
   }
 }
 
@@ -118,7 +258,7 @@ async function describe(description, arg1, arg2) {
     throw new Error(`Duplicate test description: ${description}`)
   }
 
-  const newTestData = {args: newTestArgs, subs: {}, tests: {}}
+  const newTestData = {afterEaches: [], args: newTestArgs, beforeEaches: [], subs: {}, tests: {}}
 
   currentTest.subs[description] = newTestData
   currentPath.push(newTestData)
@@ -169,4 +309,12 @@ function fit(description, arg1, arg2) {
   return it(description, testArgs, testFunction)
 }
 
+// Make the methods global so they can be used in test files
+globalThis.afterEach = afterEach
+globalThis.beforeEach = beforeEach
+globalThis.describe = describe
+globalThis.expect = expect
+globalThis.it = it
+globalThis.fit = fit
+
 export {describe, expect, fit, it, tests}

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

@@ -38,16 +38,18 @@ async function withTrackedStack(arg1, arg2) {
   if (!asyncLocalStorage) return await callback()
 
   const parentStacks = asyncLocalStorage.getStore() || []
-  const additionalStackLines = ["    [WITH TRACKED STACK]"]
+  const additionalStackLines = []
   const currentStackLines = stack.split("\n")
 
+  currentStackLines[0] = "    [WITH TRACKED STACK]"
+
   for (let i = currentStackLines.length; i >= 0; i--) {
     const stackLine = currentStackLines[i]
 
+    additionalStackLines.unshift(stackLine)
+
     if (stackLine == "    [WITH TRACKED STACK]") {
       break
-    } else {
-      additionalStackLines.unshift(stackLine)
     }
   }