velocious 1.0.28 → 1.0.30

package/spec/dummy/src/config/routes.js

@@ -8,6 +8,8 @@ routes.draw((route) => {
   route.resources("tasks", (route) => {
     route.get("users")
   })
+
+  route.get("ping")
 })
 
 export default {routes}

package/spec/dummy/src/database/migrations/20250903112845-create-accounts.js

@@ -0,0 +1,18 @@
+import Migration from "../../../../../src/database/migration/index.js"
+
+class CreateAccounts extends Migration {
+  async up() {
+    await this.createTable("accounts", (t) => {
+      t.string("name")
+      t.timestamps()
+    })
+  }
+
+  async down() {
+    await this.dropTable("accounts")
+  }
+}
+
+CreateAccounts.onDatabases(["mssql"])
+
+export default CreateAccounts

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

@@ -0,0 +1,11 @@
+import Controller from "../../../../../src/controller.js"
+
+export default class RootController extends Controller {
+  ping() {
+    this.render({
+      json: {
+        message: "Pong"
+      }
+    })
+  }
+}

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

@@ -2,7 +2,6 @@ import {digg} from "diggerize"
 
 import Controller from "../../../../../src/controller.js"
 import Project from "../../models/project.js"
-import Task from "../../models/task.js"
 
 export default class ProjectsController extends Controller {
   index() {

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

@@ -0,0 +1,26 @@
+import fetch from "node-fetch"
+import Dummy from "../dummy/index.js"
+
+describe("HttpServer", () => {
+  it("handles root get requests", async () => {
+    await Dummy.run(async () => {
+      const response = await fetch("http://localhost:3006/ping")
+      const text = await response.text()
+
+      expect(response.status).toEqual(200)
+      expect(response.statusText).toEqual("OK")
+      expect(text).toEqual("{\"message\":\"Pong\"}")
+    })
+  })
+
+  it("returns a 404 error when a root get isn't found", async () => {
+    await Dummy.run(async () => {
+      const response = await fetch("http://localhost:3006/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/cli/commands/db/create.js

@@ -1,32 +1,42 @@
 import BaseCommand from "../../base-command.js"
 import {digg} from "diggerize"
+import {incorporate} from "incorporator"
 import TableData from "../../../database/table-data/index.js"
 
 export default class DbCreate extends BaseCommand{
   async execute() {
-    this.databasePool = this.configuration.getDatabasePool()
-    this.newConfiguration = Object.assign({}, this.databasePool.getConfiguration())
+    for (const databaseIdentifier of this.configuration.getDatabaseIdentifiers()) {
+      const databaseType = this.configuration.getDatabaseType(databaseIdentifier)
 
-    if (this.args.testing) this.result = []
+      this.databasePool = this.configuration.getDatabasePool(databaseIdentifier)
+      this.newConfiguration = incorporate({}, this.databasePool.getConfiguration())
 
-    // 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"
+      if (this.args.testing) this.result = []
 
-    this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
-    await this.databaseConnection.connect()
+      // 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"
 
-    if (this.configuration.getDatabaseType() != "sqlite") {
-      await this.createDatabase()
-    }
+      // 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
+      }
+
+      this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
+      await this.databaseConnection.connect()
 
-    await this.createSchemaMigrationsTable()
-    await this.databaseConnection.close()
+      if (databaseType != "sqlite") {
+        await this.createDatabase(databaseIdentifier)
+      }
+
+      await this.createSchemaMigrationsTable()
+      await this.databaseConnection.close()
 
-    if (this.args.testing) return this.result
+      if (this.args.testing) return this.result
+    }
   }
 
-  async createDatabase() {
-    const databaseName = digg(this, "configuration", "database", "default", "master", "database")
+  async createDatabase(databaseIdentifier) {
+    const databaseName = digg(this.configuration.getDatabaseConfiguration(), databaseIdentifier, "database")
     const sql = this.databaseConnection.createDatabaseSql(databaseName, {ifNotExists: true})
 
     if (this.args.testing) {

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

@@ -9,10 +9,6 @@ export default class DbMigrate extends BaseCommand {
     const migrationsPath = `${projectPath}/src/database/migrations`
     let files = await fs.readdir(migrationsPath)
 
-    this.migrator = new Migrator({configuration: this.configuration})
-
-    await this.migrator.prepare()
-
     files = files
       .map((file) => {
         const match = file.match(/^(\d{14})-(.+)\.js$/)
@@ -33,85 +29,11 @@ export default class DbMigrate extends BaseCommand {
       .filter((migration) => Boolean(migration))
       .sort((migration1, migration2) => migration1.date - migration2.date)
 
-    for (const migration of files) {
-      if (!this.migrator.hasRunMigrationVersion(migration.date)) {
-        await this.runMigrationFile(migration)
-      }
-    }
-  }
-
-  async executeRequireContext(requireContext) {
-    const migrationFiles = requireContext.keys()
-
-    files = migrationFiles
-      .map((file) => {
-        const match = file.match(/^(\d{14})-(.+)\.js$/)
-
-        if (!match) return null
-
-        const date = parseInt(match[1])
-        const migrationName = match[2]
-        const migrationClassName = inflection.camelize(migrationName)
-
-        return {
-          file,
-          fullPath: `${migrationsPath}/${file}`,
-          date,
-          migrationClassName
-        }
-      })
-      .filter((migration) => Boolean(migration))
-      .sort((migration1, migration2) => migration1.date - migration2.date)
-
-    for (const migration of files) {
-      if (!this.migrator.hasRunMigrationVersion(migration.date)) {
-        await this.runMigrationFileFromRequireContext(migration, requireContext)
-      }
-    }
-  }
-
-  async runMigrationFileFromRequireContext(migration, requireContext) {
-    if (!this.configuration) throw new Error("No configuration set")
-    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
-
-    await this.configuration.getDatabasePool().withConnection(async (db) => {
-      const MigrationClass = requireContext(migration.file).default
-      const migrationInstance = new MigrationClass({
-        configuration: this.configuration
-      })
-
-      if (migrationInstance.change) {
-        await migrationInstance.change()
-      } else if (migrationInstance.up) {
-        await migrationInstance.up()
-      } else {
-        throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`)
-      }
-
-      await db.insert({tableName: "schema_migrations", data: {version: migration.date}})
-    })
-  }
-
-  async runMigrationFile(migration) {
-    if (!this.configuration) throw new Error("No configuration set")
-    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
-
-    await this.configuration.getDatabasePool().withConnection(async (db) => {
-      const migrationImport = await import(migration.fullPath)
-      const MigrationClass = migrationImport.default
-      const migrationInstance = new MigrationClass({
-        configuration: this.configuration
-      })
-
-      if (migrationInstance.change) {
-        await migrationInstance.change()
-      } else if (migrationInstance.up) {
-        await migrationInstance.up()
-      } else {
-        throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`)
-      }
+    this.migrator = new Migrator({configuration: this.configuration})
 
-      await db.insert({tableName: "schema_migrations", data: {version: migration.date}})
+    await this.configuration.withConnections(async () => {
+      await this.migrator.prepare()
+      await this.migrator.migrateFiles(files)
     })
   }
 }

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

@@ -0,0 +1,40 @@
+import BaseCommand from "../../base-command.js"
+import fs from "node:fs/promises"
+import * as inflection from "inflection"
+import Migrator from "../../../database/migrator.js"
+
+export default class DbReset extends BaseCommand {
+  async execute() {
+    const projectPath = this.configuration.getDirectory()
+    const migrationsPath = `${projectPath}/src/database/migrations`
+    let files = await fs.readdir(migrationsPath)
+
+    files = files
+      .map((file) => {
+        const match = file.match(/^(\d{14})-(.+)\.js$/)
+
+        if (!match) return null
+
+        const date = parseInt(match[1])
+        const migrationName = match[2]
+        const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"))
+
+        return {
+          file,
+          fullPath: `${migrationsPath}/${file}`,
+          date,
+          migrationClassName
+        }
+      })
+      .filter((migration) => Boolean(migration))
+      .sort((migration1, migration2) => migration1.date - migration2.date)
+
+    this.migrator = new Migrator({configuration: this.configuration})
+
+    await this.configuration.withConnections(async () => {
+      await this.migrator.reset()
+      await this.migrator.prepare()
+      await this.migrator.migrateFiles(files)
+    })
+  }
+}

package/src/configuration.js

@@ -8,12 +8,14 @@ export default class VelociousConfiguration {
     return this.velociousConfiguration
   }
 
-  constructor({cors, database, debug, directory, initializeModels, locale, localeFallbacks, locales, ...restArgs}) {
+  constructor({cors, database, debug, directory, environment, initializeModels, locale, localeFallbacks, locales, ...restArgs}) {
     restArgsError(restArgs)
 
     this.cors = cors
     this.database = database
+    this.databasePools = {}
     this.debug = debug
+    this._environment = environment || process.env.VELOCIOUS_ENV || process.env.NODE_ENV || "development"
     this._directory = directory
     this._initializeModels = initializeModels
     this._isInitialized = false
@@ -23,16 +25,30 @@ export default class VelociousConfiguration {
     this.modelClasses = {}
   }
 
-  getDatabasePool() {
-    if (!this.isDatabasePoolInitialized()) {
-      this.initializeDatabasePool()
+  getDatabaseConfiguration() {
+    return digg(this, "database", this.getEnvironment())
+  }
+
+  getDatabaseIdentifiers() {
+    return Object.keys(this.getDatabaseConfiguration())
+  }
+
+  getDatabasePool(identifier = "default") {
+    if (!this.isDatabasePoolInitialized(identifier)) {
+      this.initializeDatabasePool(identifier)
     }
 
-    return this.databasePool
+    return digg(this, "databasePools", identifier)
+  }
+
+  getDatabaseIdentifier(identifier) {
+    if (!this.getDatabaseConfiguration()[identifier]) throw new Error(`No such database identifier configured: ${identifier}`)
+
+    return this.getDatabaseConfiguration()[identifier]
   }
 
-  getDatabasePoolType() {
-    const poolTypeClass = digg(this, "database", "default", "master", "poolType")
+  getDatabasePoolType(identifier = "default") {
+    const poolTypeClass = digg(this.getDatabaseIdentifier(identifier), "poolType")
 
     if (!poolTypeClass) {
       throw new Error("No poolType given in database configuration")
@@ -41,12 +57,10 @@ export default class VelociousConfiguration {
     return poolTypeClass
   }
 
-  getDatabaseType() {
-    const databaseType = digg(this, "database", "default", "master", "type")
+  getDatabaseType(identifier = "default") {
+    const databaseType = digg(this.getDatabaseIdentifier(identifier), "type")
 
-    if (!databaseType) {
-      throw new Error("No database type given in database configuration")
-    }
+    if (!databaseType) throw new Error("No database type given in database configuration")
 
     return databaseType
   }
@@ -59,6 +73,10 @@ export default class VelociousConfiguration {
     return this._directory
   }
 
+  getEnvironment() {
+    return digg(this, "_environment")
+  }
+
   getLocaleFallbacks = () => this.localeFallbacks
   setLocaleFallbacks(newLocaleFallbacks) {
     this.localeFallbacks = newLocaleFallbacks
@@ -84,17 +102,17 @@ export default class VelociousConfiguration {
     return modelClass
   }
 
-  initializeDatabasePool() {
+  initializeDatabasePool(identifier = "default") {
     if (!this.database) throw new Error("No 'database' was given")
-    if (this.databasePool) throw new Error("DatabasePool has already been initialized")
+    if (this.databasePools[identifier]) throw new Error("DatabasePool has already been initialized")
 
-    const PoolType = this.getDatabasePoolType()
+    const PoolType = this.getDatabasePoolType(identifier)
 
-    this.databasePool = new PoolType({configuration: this})
-    this.databasePool.setCurrent()
+    this.databasePools[identifier] = new PoolType({configuration: this, identifier})
+    this.databasePools[identifier].setCurrent()
   }
 
-  isDatabasePoolInitialized = () => Boolean(this.databasePool)
+  isDatabasePoolInitialized = (identifier = "default") => Boolean(this.databasePools[identifier])
   isInitialized = () => this._isInitialized
 
   async initialize() {
@@ -118,4 +136,39 @@ export default class VelociousConfiguration {
   setRoutes(newRoutes) {
     this.routes = newRoutes
   }
+
+  async withConnections(callback) {
+    const dbs = {}
+    const actualCallback = async () => {
+      return await callback(dbs)
+    }
+
+    let runRequest = actualCallback
+
+    for (const identifier of this.getDatabaseIdentifiers()) {
+      let actualRunRequest = runRequest
+
+      const nextRunRequest = async () => {
+        return await this.getDatabasePool(identifier).withConnection(async (db) => {
+          dbs[identifier] = db
+
+          await actualRunRequest()
+        })
+      }
+
+      runRequest = nextRunRequest
+    }
+
+    await runRequest()
+  }
+
+  async getCurrentConnections() {
+    const dbs = {}
+
+    for (const identifier of this.getDatabaseIdentifiers()) {
+      dbs[identifier] = this.getDatabasePool(identifier).getCurrentConnection()
+    }
+
+    return dbs
+  }
 }

package/src/database/drivers/base.js

@@ -1,3 +1,4 @@
+import {Logger} from "../../logger.js"
 import Query from "../query/index.js"
 import Handler from "../handler.js"
 import {v4 as uuidv4} from "uuid"
@@ -6,6 +7,7 @@ export default class VelociousDatabaseDriversBase {
   constructor(config, configuration) {
     this._args = config
     this.configuration = configuration
+    this.logger = new Logger(this)
     this._transactionsCount = 0
   }
 
@@ -23,6 +25,14 @@ export default class VelociousDatabaseDriversBase {
     await this.query(sql)
   }
 
+  async dropTable(...args) {
+    const sqls = this.dropTableSql(...args)
+
+    for (const sql of sqls) {
+      await this.query(sql)
+    }
+  }
+
   getArgs() {
     return this._args
   }
@@ -56,12 +66,38 @@ export default class VelociousDatabaseDriversBase {
     throw new Error(`${this.constructor.name}#lastInsertID not implemented`)
   }
 
-  async select(tableName) {
+  quote(value) {
+    if (typeof value == "number") return value
+
+    const escapedValue = this.escape(value)
+    const result = `"${escapedValue}"`
+
+    return result
+  }
+
+  quoteColumn(columnName) {
+    return this.options().quoteColumnName(columnName)
+  }
+
+  quoteIndex(columnName) {
+    return this.options().quoteIndexName(columnName)
+  }
+
+  quoteTable(tableName) {
+    return this.options().quoteColumnName(tableName)
+  }
+
+  newQuery() {
     const handler = new Handler()
-    const query = new Query({
+
+    return new Query({
       driver: this,
       handler
     })
+  }
+
+  async select(tableName) {
+    const query = this.newQuery()
 
     const sql = query
       .from(tableName)
@@ -83,38 +119,48 @@ export default class VelociousDatabaseDriversBase {
     return false
   }
 
-  async startTransaction() {
-    return await this.query("BEGIN TRANSACTION")
-  }
-
   async transaction(callback) {
-    const savePointName = `sp${uuidv4().replaceAll("-", "")}`
+    const savePointName = this.generateSavePointName()
     let transactionStarted = false
+    let savePointStarted = false
 
     if (this._transactionsCount == 0) {
+      this.logger.debug("Start transaction")
       await this.startTransaction()
       transactionStarted = true
       this._transactionsCount++
+    } else {
+      this.logger.debug("Start savepoint", savePointName)
+      await this.startSavePoint(savePointName)
+      savePointStarted = true
     }
 
-    await this.query(`SAVEPOINT ${savePointName}`)
-
     let result
 
     try {
       result = await callback()
 
-      await this.query(`RELEASE SAVEPOINT ${savePointName}`)
+      if (savePointStarted) {
+        this.logger.debug("Release savepoint", savePointName)
+        await this.releaseSavePoint(savePointName)
+      }
 
       if (transactionStarted) {
-        await this.query("COMMIT")
+        this.logger.debug("Commit transaction")
+        await this.commitTransaction()
         this._transactionsCount--
       }
     } catch (error) {
-      await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`)
+      this.logger.debug("Transaction error", error.message)
+
+      if (savePointStarted) {
+        this.logger.debug("Rollback savepoint", savePointName)
+        await this.rollbackSavePoint(savePointName)
+      }
 
       if (transactionStarted) {
-        await this.query("ROLLBACK")
+        this.logger.debug("Rollback transaction")
+        await this.rollbackTransaction()
         this._transactionsCount--
       }
 
@@ -124,9 +170,47 @@ export default class VelociousDatabaseDriversBase {
     return result
   }
 
+  async startTransaction() {
+    return await this.query("BEGIN TRANSACTION")
+  }
+
+  async commitTransaction() {
+    await this.query("COMMIT")
+  }
+
+  async rollbackTransaction() {
+    await this.query("ROLLBACK")
+  }
+
+  generateSavePointName() {
+    return `sp${uuidv4().replaceAll("-", "")}`
+  }
+
+  async startSavePoint(savePointName) {
+    await this.query(`SAVEPOINT ${savePointName}`)
+  }
+
+  async releaseSavePoint(savePointName) {
+    await this.query(`RELEASE SAVEPOINT ${savePointName}`)
+  }
+
+  async rollbackSavePoint(savePointName) {
+    await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`)
+  }
+
   async update(...args) {
     const sql = this.updateSql(...args)
 
     await this.query(sql)
   }
+
+  async withDisabledForeignKeys(callback) {
+    await this.disableForeignKeys()
+
+    try {
+      return await callback()
+    } finally {
+      await this.enableForeignKeys()
+    }
+  }
 }

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

@@ -0,0 +1,10 @@
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversMssqlColumn {
+  constructor(table, data) {
+    this.data = data
+    this.table = table
+  }
+
+  getName = () => digg(this, "data", "COLUMN_NAME")
+}

package/src/database/drivers/mssql/connect-connection.js

@@ -0,0 +1,12 @@
+// Async function to connect a MS-SQL connection
+export default function connectConnection(connection) {
+  return new Promise((resolve, reject) => {
+    connection.connect((error) => {
+      if (error) {
+        reject(error)
+      } else {
+        resolve()
+      }
+    })
+  })
+}

package/src/database/drivers/mssql/foreign-key.js

@@ -0,0 +1,13 @@
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversMssqlForeignKey {
+  constructor(data) {
+    this.data = data
+  }
+
+  getColumnName = () => digg(this, "data", "ParentColumn")
+  getName = () => digg(this, "data", "CONSTRAINT_NAME")
+  getTableName = () => digg(this, "data", "TableName")
+  getReferencedColumnName = () => digg(this, "data", "ReferencedColumn")
+  getReferencedTableName = () => digg(this, "data", "ReferencedTable")
+}