velocious 1.0.39 → 1.0.41

package/src/database/query/drop-table-base.js

@@ -1,12 +1,14 @@
+import {digs} from "diggerize"
 import QueryBase from "./base.js"
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryDropTableBase extends QueryBase {
-  constructor({driver, ifExists, options, tableName, ...restArgs}) {
+  constructor({cascade, driver, ifExists, options, tableName, ...restArgs}) {
     super({driver, options})
 
     restArgsError(restArgs)
 
+    this.cascade = cascade
     this.ifExists = ifExists
     this.tableName = tableName
   }
@@ -14,7 +16,7 @@ export default class VelociousDatabaseQueryDropTableBase extends QueryBase {
   toSql() {
     const databaseType = this.getDatabaseType()
     const options = this.getOptions()
-    const {ifExists, tableName} = this
+    const {cascade, ifExists, tableName} = digs(this, "cascade", "ifExists", "tableName")
     const sqls = []
     let sql = ""
 
@@ -28,6 +30,10 @@ export default class VelociousDatabaseQueryDropTableBase extends QueryBase {
 
     sql += ` ${options.quoteTableName(tableName)}`
 
+    if (cascade && databaseType == "pgsql") {
+      sql += " cascade"
+    }
+
     if (databaseType == "mssql" && ifExists) {
       sql += " END"
     }

package/src/database/record/index.js

@@ -330,7 +330,13 @@ class VelociousDatabaseRecord {
     return record
   }
 
+  static setPrimaryKey(primaryKey) {
+    this._primaryKey = primaryKey
+  }
+
   static primaryKey() {
+    if (this._primaryKey) return this._primaryKey
+
     return "id"
   }
 
@@ -762,13 +768,18 @@ class VelociousDatabaseRecord {
 
   readAttribute(attributeName) {
     const attributeNameUnderscore = inflection.underscore(attributeName)
-    const column = this.constructor.getColumns().find((column) => column.getName() == attributeNameUnderscore)
+
+    return this.readColumn(attributeNameUnderscore)
+  }
+
+  readColumn(attributeName) {
+    const column = this.constructor.getColumns().find((column) => column.getName() == attributeName)
     let result
 
-    if (attributeNameUnderscore in this._changes) {
-      result = this._changes[attributeNameUnderscore]
-    } else if (attributeNameUnderscore in this._attributes) {
-      result = this._attributes[attributeNameUnderscore]
+    if (attributeName in this._changes) {
+      result = this._changes[attributeName]
+    } else if (attributeName in this._attributes) {
+      result = this._attributes[attributeName]
     } else if (this.isPersisted()) {
       throw new Error(`No such attribute or not selected ${this.constructor.name}#${attributeName}`)
     }

package/src/database/record/validators/presence.js

@@ -2,7 +2,7 @@ import Base from "./base.js"
 
 export default class VelociousDatabaseRecordValidatorsPresence extends Base {
   validate({model, attributeName}) {
-    const attributeValue = model.readAttribute(attributeName).trim()
+    const attributeValue = model.readAttribute(attributeName)?.trim()
 
     if (!attributeValue) {
       if (!(attributeName in model._validationErrors)) model._validationErrors[attributeName] = []

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/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)
     }
   }