velocious 1.0.40 → 1.0.42

package/spec/dummy/src/models/task.js

@@ -1,6 +1,6 @@
-import DatabaseRecord from "../../../../src/database/record/index.js"
+import Record from "../../../../src/database/record/index.js"
 
-class Task extends DatabaseRecord {
+class Task extends Record {
 }
 
 Task.belongsTo("project")

package/spec/dummy/src/models/user.js

@@ -0,0 +1,15 @@
+import Record from "../../../../src/database/record/index.js"
+import UserModule from "../../../../src/database/record/user-module.js"
+
+class User extends Record {
+}
+
+User.hasMany("authenticationTokens" , {dependent: "destroy"})
+
+const userModule = new UserModule({
+  secretKey: "02e383b7-aad1-437c-b1e1-17c0240ad851"
+})
+
+userModule.attachTo(User)
+
+export default User

package/spec/dummy/src/routes/projects/controller.js

@@ -22,6 +22,12 @@ export default class ProjectsController extends Controller {
 
     await project.save()
 
-    this.render({json: {status: "success"}})
+    this.render({json: {
+      project: {
+        id: project.id(),
+        name: project.name()
+      },
+      status: "success"
+    }})
   }
 }

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

@@ -3,7 +3,7 @@ import Client from "../../src/http-server/client/index.js"
 import {digg} from "diggerize"
 import dummyConfiguration from "../dummy/src/config/configuration.js"
 
-describe("http server - client", () => {
+describe("http server - client", {databaseCleaning: {transaction: false, truncate: true}}, () => {
   it("spawns a request for each that it is fed", async () => {
     await dummyConfiguration.initialize()
 

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

@@ -1,7 +1,7 @@
 import fetch from "node-fetch"
 import Dummy from "../dummy/index.js"
 
-describe("HttpServer", () => {
+describe("HttpServer - get", {databaseCleaning: {transaction: false, truncate: true}}, () => {
   it("handles get requests", async () => {
     await Dummy.run(async () => {
       for (let i = 0; i <= 5; i++) {

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

@@ -1,10 +1,12 @@
+import {digg} from "diggerize"
 import fetch from "node-fetch"
 import querystring from "querystring"
+import wait from "awaitery/src/wait.js"
 
 import Dummy from "../dummy/index.js"
 import Project from "../dummy/src/models/project.js"
 
-describe("HttpServer", () => {
+describe("HttpServer - post", {databaseCleaning: {transaction: false, truncate: true}}, () => {
   it("handles post requests", async () => {
     await Dummy.run(async () => {
       for (let i = 0; i <= 5; i++) {
@@ -20,10 +22,13 @@ describe("HttpServer", () => {
             method: "POST"
           }
         )
-        const text = await response.text()
-        const createdProject = await Project.preload({translations: true}).last()
+        const data = await response.json()
+        const projectID = digg(data, "project", "id")
+
+        await wait(100) // Wait a bit to ensure the database connections are in sync
+
+        const createdProject = await Project.preload({translations: true}).find(projectID)
 
-        expect(text).toEqual('{"status":"success"}')
         expect(createdProject.name()).toEqual("Test create project")
       }
     })
@@ -44,10 +49,14 @@ describe("HttpServer", () => {
             method: "POST"
           }
         )
-        const text = await response.text()
+        const data = await response.json()
+
+        expect(data.status).toEqual("success")
+
+        await wait(100) // Wait a bit to ensure the database connections are in sync
+
         const createdProject = await Project.preload({translations: true}).last()
 
-        expect(text).toEqual('{"status":"success"}')
         expect(createdProject.name()).toEqual("Test create project")
       }
     })
@@ -67,10 +76,14 @@ describe("HttpServer", () => {
             method: "POST"
           }
         )
-        const text = await response.text()
+        const data = await response.json()
+
+        expect(data.status).toEqual("success")
+
+        await wait(100) // Wait a bit to ensure the database connections are in sync
+
         const createdProject = await Project.preload({translations: true}).last()
 
-        expect(text).toEqual('{"status":"success"}')
         expect(createdProject.name()).toEqual("Test create project")
       }
     })

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

@@ -1,7 +1,7 @@
 import fetch from "node-fetch"
 import Dummy from "../dummy/index.js"
 
-describe("HttpServer", () => {
+describe("HttpServer - root get", {databaseCleaning: {transaction: false, truncate: true}}, () => {
   it("handles root get requests", async () => {
     await Dummy.run(async () => {
       for (let i = 0; i <= 5; i++) {

package/src/cli/commands/db/create.js

@@ -7,21 +7,22 @@ export default class DbCreate extends BaseCommand{
   async execute() {
     for (const databaseIdentifier of this.configuration.getDatabaseIdentifiers()) {
       const databaseType = this.configuration.getDatabaseType(databaseIdentifier)
-
-      this.databasePool = this.configuration.getDatabasePool(databaseIdentifier)
-      this.newConfiguration = incorporate({}, this.databasePool.getConfiguration())
+      const databasePool = this.configuration.getDatabasePool(databaseIdentifier)
+      const newConfiguration = incorporate({}, databasePool.getConfiguration())
+      const DriverClass = digg(newConfiguration, "driver")
 
       if (this.args.testing) this.result = []
 
       // Use a database known to exist. Since we are creating the database, it shouldn't actually exist which would make connecting fail.
-      this.newConfiguration.database = this.newConfiguration.useDatabase || "mysql"
+      newConfiguration.database = newConfiguration.useDatabase || "mysql"
 
       // Login can fail because given db name doesn't exist, which it might not because we are trying to create it right now.
-      if (databaseType == "mssql" && this.newConfiguration.sqlConfig?.database) {
-        delete this.newConfiguration.sqlConfig.database
+      if (databaseType == "mssql" && newConfiguration.sqlConfig?.database) {
+        delete newConfiguration.sqlConfig.database
       }
 
-      this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
+      this.databaseConnection = new DriverClass(newConfiguration, this.configuration)
+
       await this.databaseConnection.connect()
 
       try {
@@ -31,7 +32,9 @@ export default class DbCreate extends BaseCommand{
 
         await this.createSchemaMigrationsTable()
       } finally {
-        await this.databaseConnection.close()
+        if (databaseType != "mssql") {
+          await this.databaseConnection.close()
+        }
       }
 
       if (this.args.testing) return this.result

package/src/cli/commands/db/drop.js

@@ -0,0 +1,19 @@
+import BaseCommand from "../../base-command.js"
+import FilesFinder from "../../../database/migrator/files-finder.js"
+import Migrator from "../../../database/migrator.js"
+
+export default class DbDrop extends BaseCommand {
+  async execute() {
+    const environment = this.configuration.getEnvironment()
+
+    if (environment != "development" && environment != "test") {
+      throw new Error(`This command should only be executed on development and test environments and not: ${environment}`)
+    }
+
+    this.migrator = new Migrator({configuration: this.configuration})
+
+    await this.configuration.ensureConnections(async () => {
+      await this.migrator.dropDatabase()
+    })
+  }
+}

package/src/cli/commands/db/migrate.js

@@ -11,7 +11,7 @@ export default class DbMigrate extends BaseCommand {
 
     this.migrator = new Migrator({configuration: this.configuration})
 
-    await this.configuration.withConnections(async () => {
+    await this.configuration.ensureConnections(async () => {
       await this.migrator.prepare()
       await this.migrator.migrateFiles(files, async (importPath) => await import(importPath))
     })

package/src/cli/commands/db/reset.js

@@ -4,6 +4,12 @@ import Migrator from "../../../database/migrator.js"
 
 export default class DbReset extends BaseCommand {
   async execute() {
+    const environment = this.configuration.getEnvironment()
+
+    if (environment != "development" && environment != "test") {
+      throw new Error(`This command should only be executed on development and test environments and not: ${environment}`)
+    }
+
     const projectPath = this.configuration.getDirectory()
     const migrationsPath = `${projectPath}/src/database/migrations`
     const filesFinder = new FilesFinder({path: migrationsPath})
@@ -11,7 +17,7 @@ export default class DbReset extends BaseCommand {
 
     this.migrator = new Migrator({configuration: this.configuration})
 
-    await this.configuration.withConnections(async () => {
+    await this.configuration.ensureConnections(async () => {
       await this.migrator.reset()
       await this.migrator.prepare()
       await this.migrator.migrateFiles(files, async (importPath) => await import(importPath))

package/src/cli/commands/test.js

@@ -2,19 +2,25 @@ import BaseCommand from "../base-command.js"
 import TestFilesFinder from "../../testing/test-files-finder.js"
 import TestRunner from "../../testing/test-runner.js"
 
-export default class VelociousCliCommandsInit extends BaseCommand {
+export default class VelociousCliCommandsTest extends BaseCommand {
   async execute() {
-    const testFilesFinder = new TestFilesFinder({directory: this.directory(), processArgs: this.processArgs})
+    const testFilesFinder = new TestFilesFinder({directory: `${this.directory()}/..`, processArgs: this.processArgs})
     const testFiles = await testFilesFinder.findTestFiles()
     const testRunner = new TestRunner({configuration: this.configuration, testFiles})
 
+    await testRunner.prepare()
+
+    if (testRunner.getTestsCount() === 0) {
+      throw new Error("No tests has been found")
+    }
+
     await testRunner.run()
 
     if (testRunner.isFailed()) {
-      console.error(`Test run failed with ${testRunner.failedTests} failed tests and ${testRunner.successfulTests} successfull`)
+      console.error(`\nTest run failed with ${testRunner.getFailedTests()} failed tests and ${testRunner.getSuccessfulTests()} successfull`)
       process.exit(1)
     } else {
-      console.log(`Test run succeeded with ${testRunner.successfulTests} successful tests`)
+      console.log(`\nTest run succeeded with ${testRunner.getSuccessfulTests()} successful tests`)
       process.exit(0)
     }
   }

package/src/configuration.js

@@ -9,7 +9,7 @@ export default class VelociousConfiguration {
     return this.velociousConfiguration
   }
 
-  constructor({cors, database, debug, directory, environment, initializeModels, locale, localeFallbacks, locales, ...restArgs}) {
+  constructor({cors, database, debug, directory, environment, initializeModels, locale, localeFallbacks, locales, testing, ...restArgs}) {
     restArgsError(restArgs)
 
     this.cors = cors
@@ -24,9 +24,12 @@ export default class VelociousConfiguration {
     this.localeFallbacks = localeFallbacks
     this.locales = locales
     this.modelClasses = {}
+    this._testing = testing
   }
 
   getDatabaseConfiguration() {
+    if (!this.database) throw new Error("No database configuration")
+
     return digg(this, "database", this.getEnvironment())
   }
 
@@ -74,9 +77,7 @@ export default class VelociousConfiguration {
     return this._directory
   }
 
-  getEnvironment() {
-    return digg(this, "_environment")
-  }
+  getEnvironment() { return digg(this, "_environment") }
 
   getLocaleFallbacks = () => this.localeFallbacks
   setLocaleFallbacks(newLocaleFallbacks) {
@@ -103,6 +104,8 @@ export default class VelociousConfiguration {
     return modelClass
   }
 
+  getTesting() { return this._testing }
+
   initializeDatabasePool(identifier = "default") {
     if (!this.database) throw new Error("No 'database' was given")
     if (this.databasePools[identifier]) throw new Error("DatabasePool has already been initialized")
@@ -180,13 +183,31 @@ export default class VelociousConfiguration {
     await runRequest()
   }
 
-  async getCurrentConnections() {
+  getCurrentConnections() {
     const dbs = {}
 
     for (const identifier of this.getDatabaseIdentifiers()) {
-      dbs[identifier] = this.getDatabasePool(identifier).getCurrentConnection()
+      try {
+        dbs[identifier] = this.getDatabasePool(identifier).getCurrentConnection()
+      } catch (error) {
+        if (error.message == "ID hasn't been set for this async context" || error.message == "A connection hasn't been made yet") {
+          // Ignore
+        } else {
+          throw error
+        }
+      }
     }
 
     return dbs
   }
+
+  async ensureConnections(callback) {
+    let dbs = this.getCurrentConnections()
+
+    if (Object.keys(dbs).length > 0) {
+      await callback(dbs)
+    } else {
+      await this.withConnections(callback)
+    }
+  }
 }

package/src/controller.js

@@ -32,17 +32,10 @@ export default class VelociousController {
     this._viewPath = viewPath
   }
 
-  getAction() {
-    return this._action
-  }
-
-  getParams() {
-    return this._params
-  }
-
-  getRequest() {
-    return this._request
-  }
+  getAction() { return this._action }
+  getConfiguration() { return this._configuration }
+  getParams() { return this._params }
+  getRequest() { return this._request }
 
   async _runBeforeCallbacks() {
     await this.logger.debug("_runBeforeCallbacks")
@@ -74,7 +67,7 @@ export default class VelociousController {
     await this.logger.debug("After runBeforeCallbacks")
   }
 
-  params = () => this._params
+  params() { return this._params }
 
   render({json, status, ...restArgs} = {}) {
     restArgsError(restArgs)
@@ -120,11 +113,6 @@ export default class VelociousController {
     throw new Error("renderText stub")
   }
 
-  request() {
-    return this._request
-  }
-
-  response() {
-    return this._response
-  }
+  request() { return this._request }
+  response() { return this._response }
 }

package/src/database/drivers/base-column.js

@@ -0,0 +1,22 @@
+export default class VelociousDatabaseDriversBaseColumn {
+  async getIndexByName(indexName) {
+    const indexes = await this.getIndexes()
+    const index = indexes.find((index) => index.getName() == indexName)
+
+    return index
+  }
+
+  getDriver() {
+    return this.getTable().getDriver()
+  }
+
+  getOptions() {
+    return this.getDriver().options()
+  }
+
+  getTable() {
+    if (!this.table) throw new Error("No table set on column")
+
+    return this.table
+  }
+}

package/src/database/drivers/base-columns-index.js

@@ -0,0 +1,34 @@
+import { digg } from "diggerize"
+
+export default class VelociousDatabaseDriversBaseColumnsIndex {
+  constructor(table, data) {
+    this.data = data
+    this.table = table
+  }
+
+  getDriver() {
+    return this.getTable().getDriver()
+  }
+
+  getName()  {
+    return digg(this, "data", "index_name")
+  }
+
+  getOptions() {
+    return this.getDriver().options()
+  }
+
+  getTable() {
+    if (!this.table) throw new Error("No table set on column")
+
+    return this.table
+  }
+
+  isPrimaryKey() {
+    return digg(this, "data", "is_primary_key")
+  }
+
+  isUnique() {
+    return digg(this, "data", "is_unique")
+  }
+}

package/src/database/drivers/base-table.js

@@ -0,0 +1,43 @@
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversBaseTable {
+  async getColumnByName(columnName) {
+    const columnes = await this.getColumns()
+    const column = columnes.find((column) => column.getName() == columnName)
+
+    return column
+  }
+
+  getDriver() {
+    if (!this.driver) throw new Error("No driver set on table")
+
+    return this.driver
+  }
+
+  getOptions() {
+    return this.getDriver().options()
+  }
+
+  async rowsCount() {
+    const result = await this.getDriver().query(`SELECT COUNT(*) AS count FROM ${this.getOptions().quoteTableName(this.getName())}`)
+
+    return digg(result, 0, "count")
+  }
+
+  async truncate(args) {
+    const databaseType = this.getDriver().getType()
+    let sql
+
+    if (databaseType == "sqlite") {
+      sql = `DELETE FROM ${this.getOptions().quoteTableName(this.getName())}`
+    } else {
+      sql = `TRUNCATE TABLE ${this.getOptions().quoteTableName(this.getName())}`
+
+      if (args?.cascade && databaseType == "pgsql") {
+        sql += " CASCADE"
+      }
+    }
+
+    await this.getDriver().query(sql)
+  }
+}

package/src/database/drivers/base.js

@@ -38,7 +38,11 @@ export default class VelociousDatabaseDriversBase {
     return this._args
   }
 
-  getConfiguration = () => this.configuration
+  getConfiguration() {
+    if (!this.configuration) throw new Error("No configuration set")
+
+    return this.configuration
+}
 
   getIdSeq() {
     return this.idSeq
@@ -48,11 +52,11 @@ export default class VelociousDatabaseDriversBase {
     throw new Error(`${this.constructor.name}#getTables not implemented`)
   }
 
-  async getTableByName(name) {
+  async getTableByName(name, args) {
     const tables = await this.getTables()
     const table = tables.find((table) => table.getName() == name)
 
-    if (!table) throw new Error(`Couldn't find a table by that name: ${name}`)
+    if (!table && args?.throwError !== false) throw new Error(`Couldn't find a table by that name: ${name}`)
 
     return table
   }
@@ -135,16 +139,7 @@ export default class VelociousDatabaseDriversBase {
 
     if (this._transactionsCount == 0) {
       this.logger.debug("Start transaction")
-      this._transactionsCount++
-
-      try {
-        await this.startTransaction()
-      } catch (error) {
-        this._transactionsCount--
-
-        throw error
-      }
-
+      await this.startTransaction()
       transactionStarted = true
     } else {
       this.logger.debug("Start savepoint", savePointName)
@@ -165,7 +160,6 @@ export default class VelociousDatabaseDriversBase {
       if (transactionStarted) {
         this.logger.debug("Commit transaction")
         await this.commitTransaction()
-        this._transactionsCount--
       }
     } catch (error) {
       this.logger.debug("Transaction error", error.message)
@@ -178,7 +172,6 @@ export default class VelociousDatabaseDriversBase {
       if (transactionStarted) {
         this.logger.debug("Rollback transaction")
         await this.rollbackTransaction()
-        this._transactionsCount--
       }
 
       throw error
@@ -188,15 +181,18 @@ export default class VelociousDatabaseDriversBase {
   }
 
   async startTransaction() {
-    return await this.query("BEGIN TRANSACTION")
+    await this.query("BEGIN TRANSACTION")
+    this._transactionsCount++
   }
 
   async commitTransaction() {
     await this.query("COMMIT")
+    this._transactionsCount--
   }
 
   async rollbackTransaction() {
     await this.query("ROLLBACK")
+    this._transactionsCount--
   }
 
   generateSavePointName() {
@@ -215,6 +211,38 @@ export default class VelociousDatabaseDriversBase {
     await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`)
   }
 
+  async truncateAllTables() {
+    await this.withDisabledForeignKeys(async () => {
+      let tries = 0
+
+      while(tries <= 5) {
+        tries++
+
+        const tables = await this.getTables()
+        const truncateErrors = []
+
+        for (const table of tables) {
+          if (table.getName() != "schema_migrations") {
+            try {
+              await table.truncate({cascade: true})
+            } catch (error) {
+              console.error(error)
+              truncateErrors.push(error)
+            }
+          }
+        }
+
+        if (truncateErrors.length == 0) {
+          break
+        } else if (tries <= 5) {
+          // Retry
+        } else {
+          throw truncateErrors[0]
+        }
+      }
+    })
+  }
+
   async update(...args) {
     const sql = this.updateSql(...args)
 

package/src/database/drivers/mssql/column.js

@@ -1,10 +1,51 @@
+import BaseColumn from "../base-column.js"
+import ColumnsIndex from "./columns-index.js"
 import {digg} from "diggerize"
 
-export default class VelociousDatabaseDriversMssqlColumn {
+export default class VelociousDatabaseDriversMssqlColumn extends BaseColumn {
   constructor(table, data) {
+    super()
     this.data = data
     this.table = table
   }
 
-  getName = () => digg(this, "data", "COLUMN_NAME")
+  async getIndexes() {
+    const options = this.getOptions()
+    const sql = `
+      SELECT
+        sys.tables.name AS TableName,
+        sys.columns.name AS ColumnName,
+        sys.indexes.name AS index_name,
+        sys.indexes.type_desc AS IndexType,
+        sys.index_columns.is_included_column AS IsIncludedColumn,
+        sys.indexes.is_unique,
+        sys.indexes.is_primary_key,
+        sys.indexes.is_unique_constraint
+      FROM sys.indexes
+      INNER JOIN sys.index_columns ON sys.indexes.object_id = sys.index_columns.object_id AND sys.indexes.index_id = sys.index_columns.index_id
+      INNER JOIN sys.columns ON sys.index_columns.object_id = sys.columns.object_id AND sys.index_columns.column_id = sys.columns.column_id
+      INNER JOIN sys.tables ON sys.indexes.object_id = sys.tables.object_id
+      WHERE
+        sys.tables.name = ${options.quote(this.getTable().getName())} AND
+        sys.columns.name = ${options.quote(this.getName())}
+      ORDER BY
+        sys.indexes.name,
+        sys.index_columns.key_ordinal
+    `
+
+    const rows = await this.getDriver().query(sql)
+    const indexes = []
+
+    for (const row of rows) {
+      const index = new ColumnsIndex(this.getTable(), row)
+
+      indexes.push(index)
+    }
+
+    return indexes
+  }
+
+  getName() {
+    return digg(this, "data", "COLUMN_NAME")
+  }
 }

package/src/database/drivers/mssql/columns-index.js

@@ -0,0 +1,9 @@
+import BaseColumnsIndex from "../base-columns-index.js"
+
+export default class VelociousDatabaseDriversMssqlColumn extends BaseColumnsIndex {
+  constructor(table, data) {
+    super()
+    this.data = data
+    this.table = table
+  }
+}