velocious 1.0.3 → 1.0.4

package/.github/dependabot.yml

@@ -5,5 +5,5 @@ updates:
   schedule:
     interval: weekly
     time: "01:00"
-    timezone: Europe/Copenhagen
+    timezone: Europe/Berlin
   open-pull-requests-limit: 99

package/README.md

@@ -22,13 +22,19 @@ npx velocious init
 # Migrations
 
 ```bash
-npx velocious db:g:migration create_tasks
+npx velocious g:migration create_tasks
 ```
 
 ```bash
 npx velocious db:migrate
 ```
 
+# Models
+
+```bash
+npx velocious g:model Option
+```
+
 # Testing
 
 ```bash

package/bin/velocious.mjs

@@ -1,8 +1,8 @@
-#!/usr/bin/node
+#!/usr/bin/env node
 
 import Cli from "../src/cli/index.mjs"
 
 const processArgs = process.argv.slice(2)
 const cli = new Cli({processArgs})
 
-cli.execute()
+await cli.execute()

package/index.mjs

@@ -3,7 +3,6 @@ import Cli from "./src/cli/index.mjs"
 import Configuration from "./src/configuration.mjs"
 import Controller from "./src/controller.mjs"
 import Database from "./src/database/index.mjs"
-import DatabasePool from "./src/database/pool/index.mjs"
 import HttpServer from "./src/http-server/index.mjs"
 import Routes from "./src/routes/index.mjs"
 import Spec from "./src/spec/index.mjs"
@@ -14,7 +13,6 @@ export {
   Configuration,
   Controller,
   Database,
-  DatabasePool,
   HttpServer,
   Routes,
   Spec

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.mjs"
   },
   "name": "velocious",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "main": "index.mjs",
   "scripts": {
     "test": "jasmine",
@@ -32,6 +32,7 @@
     "escape-string-regexp": "^1.0.5",
     "incorporator": "^1.0.2",
     "inflection": "^3.0.0",
+    "sql.js": "^1.12.0",
     "strftime": "^0.10.2"
   }
 }

package/peak_flow.yml

@@ -1,6 +1,6 @@
 before_install:
   - sudo mkdir -p /etc/apt/keyrings
-  - curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
+  - curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --no-tty --batch --yes --dearmor -o /etc/apt/keyrings/nodesource.gpg
   - echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list
   - sudo apt-get update
   - sudo apt-get install -y nodejs

package/spec/cli/commands/db/create-spec.mjs

@@ -14,7 +14,7 @@ describe("Cli - Commands - db:create", () => {
       [
         {
           databaseName: 'velocious_test',
-          sql: 'CREATE DATABASE IF NOT EXISTS velocious_test'
+          sql: 'CREATE DATABASE IF NOT EXISTS `velocious_test`'
         },
         {
           createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS schema_migrations (`version` varchar(255) PRIMARY KEY)'

package/spec/dummy/index.mjs

@@ -3,11 +3,11 @@ import dummyConfiguration from "./src/config/configuration.mjs"
 
 export default class Dummy {
   static current() {
-    if (!global.velociousDummy) {
-      global.velociousDummy = new Dummy()
+    if (!this.velociousDummy) {
+      this.velociousDummy = new Dummy()
     }
 
-    return global.velociousDummy
+    return this.velociousDummy
   }
 
   static async prepare() {
@@ -37,7 +37,9 @@ export default class Dummy {
   }
 
   async start() {
-    if (!dummyConfiguration.isDatabasePoolInitialized()) await dummyConfiguration.initializeDatabasePool()
+    if (!dummyConfiguration.isDatabasePoolInitialized()) {
+      await dummyConfiguration.initializeDatabasePool()
+    }
 
     this.application = new Application({
       configuration: dummyConfiguration,

package/spec/dummy/src/config/configuration.example.mjs

@@ -1,10 +1,14 @@
+import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.mjs"
 import Configuration from "../../../../src/configuration.mjs"
 import dummyDirectory from "../../dummy-directory.mjs"
+import MysqlDriver from "../../../../src/database/drivers/mysql/index.mjs"
 
-const configuration = new Configuration({
+export default new Configuration({
   database: {
     default: {
       master: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
         type: "mysql",
         host: "mariadb",
         username: "username",
@@ -15,5 +19,3 @@ const configuration = new Configuration({
   },
   directory: dummyDirectory()
 })
-
-export default configuration

package/spec/dummy/src/config/configuration.peakflow.mjs

@@ -1,10 +1,14 @@
+import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.mjs"
 import Configuration from "../../../../src/configuration.mjs"
 import dummyDirectory from "../../dummy-directory.mjs"
+import MysqlDriver from "../../../../src/database/drivers/mysql/index.mjs"
 
-const configuration = new Configuration({
+export default new Configuration({
   database: {
     default: {
       master: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
         type: "mysql",
         host: "mariadb",
         username: "peakflow",
@@ -16,5 +20,3 @@ const configuration = new Configuration({
   },
   directory: dummyDirectory()
 })
-
-export default configuration

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

@@ -1,3 +1,4 @@
+import AppRoutes from "../../src/routes/app-routes.mjs"
 import Client from "../../src/http-server/client/index.mjs"
 import {digg} from "diggerize"
 import dummyConfiguration from "../dummy/src/config/configuration.mjs"
@@ -6,6 +7,10 @@ describe("http server - client", () => {
   it("spawns a request for each that it is fed", async () => {
     await dummyConfiguration.initialize()
 
+    const routes = await AppRoutes.getRoutes(dummyConfiguration)
+
+    dummyConfiguration.setRoutes(routes)
+
     const client = new Client({
       clientCount: 0,
       configuration: dummyConfiguration

package/src/application.mjs

@@ -1,3 +1,4 @@
+import AppRoutes from "../src/routes/app-routes.mjs"
 import {digs} from "diggerize"
 import logger from "./logger.mjs"
 import HttpServer from "./http-server/index.mjs"
@@ -9,8 +10,12 @@ export default class VelociousApplication {
   }
 
   async initialize() {
+    const routes = await AppRoutes.getRoutes(this.configuration)
+
     await this.configuration.initialize()
 
+    this.configuration.setRoutes(routes)
+
     if (!this.configuration.isDatabasePoolInitialized()) {
       await this.configuration.initializeDatabasePool()
     }

package/src/cli/base-command.mjs

@@ -7,5 +7,5 @@ export default class VelociousCliBaseCommand {
     this.processArgs = args.processArgs
   }
 
-  directory = () => digg(this, "configuration", "directory")
+  directory = () => digg(this, "configuration").getDirectory()
 }

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

@@ -5,7 +5,7 @@ import inflection from "inflection"
 
 export default class DbMigrate extends BaseCommand {
   async execute() {
-    const projectPath = digg(this.configuration, "directory")
+    const projectPath = this.configuration.getDirectory()
     const migrationsPath = `${projectPath}/src/database/migrations`
     let files = await fs.readdir(migrationsPath)
 
@@ -34,12 +34,59 @@ export default class DbMigrate extends BaseCommand {
     }
   }
 
-  async runMigrationFile(migration) {
-    if (!this.configuration.isDatabasePoolInitialized()) {
-      await this.configuration.initializeDatabasePool()
+  async executeRequireContext(requireContext) {
+    const migrationFiles = requireContext.keys()
+
+    files = migrationFiles
+      .map((file) => {
+        const match = file.match(/^(\d{14})-(.+)\.mjs$/)
+
+        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) {
+      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 () => {
+      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}`)
+      }
+    })
+  }
+
+  async runMigrationFile(migration) {
+    if (!this.configuration) throw new Error("No configuration set")
+    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
 
-    await this.configuration.databasePool.withConnection(async () => {
+    await this.configuration.getDatabasePool().withConnection(async () => {
       const migrationImport = await import(migration.fullPath)
       const MigrationClass = migrationImport.default
       const migrationInstance = new MigrationClass({

package/src/cli/commands/destroy/migration.mjs

@@ -4,7 +4,7 @@ import fs from "node:fs/promises"
 export default class DbDestroyMigration extends BaseCommand {
   async execute() {
     const migrationName = this.processArgs[1]
-    const migrationDir = `${this.configuration.directory}/src/database/migrations`
+    const migrationDir = `${this.configuration.getDirectory()}/src/database/migrations`
     const migrationFiles = await fs.readdir(migrationDir)
     const destroyed = []
 

package/src/cli/commands/generate/migration.mjs

@@ -22,7 +22,7 @@ export default class DbGenerateMigration extends BaseCommand {
     const migrationPath = `${migrationDir}/${migrationFileName}`
 
     if (this.args.testing) {
-      return {date, migrationContent, migrationName, migrationNameCamelized, migrationNumber, migrationPath }
+      return {date, migrationContent, migrationName, migrationNameCamelized, migrationNumber, migrationPath}
     } else {
       if (!await fileExists(migrationDir)) {
         await fs.mkdir(migrationDir, {recursive: true})

package/src/cli/commands/generate/model.mjs

@@ -0,0 +1,36 @@
+import BaseCommand from "../../base-command.mjs"
+import {dirname} from "path"
+import {fileURLToPath} from "url"
+import fileExists from "../../../utils/file-exists.mjs"
+import fs from "node:fs/promises"
+import inflection from "inflection"
+
+export default class DbGenerateModel extends BaseCommand {
+  async execute() {
+    const modelName = this.processArgs[1]
+    const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))
+    const date = new Date()
+    const modelFileName = `${inflection.dasherize(inflection.underscore(modelName))}.mjs`
+    const __filename = fileURLToPath(`${import.meta.url}/../../..`)
+    const __dirname = dirname(__filename)
+    const templateFilePath = `${__dirname}/templates/generate-model.mjs`
+    const modelContentBuffer = await fs.readFile(templateFilePath)
+    const modelContent = modelContentBuffer.toString().replaceAll("__MODEL_NAME__", modelNameCamelized)
+    const modelsDir = `${process.cwd()}/src/models`
+    const modelPath = `${modelsDir}/${modelFileName}`
+
+    if (await fileExists(modelPath)) throw new Error(`Model file already exists: ${modelPath}`)
+
+    if (this.args.testing) {
+      return {date, modelContent, modelName, modelNameCamelized, modelPath}
+    } else {
+      if (!await fileExists(modelsDir)) {
+        await fs.mkdir(modelsDir, {recursive: true})
+      }
+
+      await fs.writeFile(modelPath, modelContent)
+
+      console.log(`create src/models/${modelFileName}`)
+    }
+  }
+}

package/src/cli/commands/init.mjs

@@ -8,7 +8,7 @@ export default class VelociousCliCommandsInit extends BaseCommand {
   async execute() {
     const __filename = fileURLToPath(`${import.meta.url}/../../..`)
     const velocipusPath = dirname(__filename)
-    const projectPath = this.configuration?.directory || process.cwd()
+    const projectPath = this.configuration?.getDirectory() || process.cwd()
     const projectConfigPath = `${projectPath}/src/config`
     const fileMappings = [
       {

package/src/cli/commands/server.mjs

@@ -0,0 +1,15 @@
+import BaseCommand from "../base-command.mjs"
+
+export default class DbCreate extends BaseCommand{
+  async execute() {
+    this.databasePool = this.configuration.getDatabasePool()
+    this.newConfiguration = Object.assign({}, this.databasePool.getConfiguration())
+
+    if (this.args.testing) this.result = []
+
+    this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
+    await this.databaseConnection.connect()
+
+    throw new Error("stub")
+  }
+}

package/src/cli/index.mjs

@@ -18,6 +18,7 @@ export default class VelociousCli {
     for (let commandPart of commandParts) {
       if (commandPart == "d") commandPart = "destroy"
       if (commandPart == "g") commandPart = "generate"
+      if (commandPart == "s") commandPart = "server"
 
       filePath += `/${commandPart}`
     }

package/src/configuration-resolver.mjs

@@ -1,8 +1,8 @@
 import Configuration from "./configuration.mjs"
 
 const configurationResolver = async (args) => {
-  if (global.velociousConfiguration) {
-    return global.velociousConfiguration
+  if (Configuration.current(false)) {
+    return Configuration.current()
   }
 
   const directory = args.directory || process.cwd()

package/src/configuration.mjs

@@ -1,49 +1,65 @@
-import DatabasePool from "./database/pool/index.mjs"
 import {digg} from "diggerize"
 
 export default class VelociousConfiguration {
-  static current() {
-    if (!global.velociousConfiguration) throw new Error("A Velocious configuration hasn't been set")
+  static current(throwError = true) {
+    if (!this.velociousConfiguration && throwError) throw new Error("A Velocious configuration hasn't been set")
 
-    return global.velociousConfiguration
+    return this.velociousConfiguration
   }
 
   constructor({database, debug, directory}) {
-    if (!directory) directory = process.cwd()
-
     this.database = database
     this.debug = debug
-    this.directory = directory
-  }
-
-  async initialize() {
-    await this.initializeRoutes()
+    this._directory = directory
   }
 
   getDatabasePool() {
-    if (!this.isDatabasePoolInitialized()) this.initializeDatabasePool()
+    if (!this.isDatabasePoolInitialized()) {
+      this.initializeDatabasePool()
+    }
 
     return this.databasePool
   }
 
+  getDatabasePoolType = () => {
+    const poolTypeClass = digg(this, "database", "default", "master", "poolType")
+
+    if (!poolTypeClass) {
+      throw new Error("No poolType given in database configuration")
+    }
+
+    return poolTypeClass
+  }
+
+  getDirectory = () => {
+    if (!this._directory) {
+      this._directory = process.cwd()
+    }
+
+    return this._directory
+  }
+
   initializeDatabasePool() {
     if (!this.database) throw new Error("No 'database' was given")
     if (this.databasePool) throw new Error("DatabasePool has already been initialized")
 
-    this.databasePool = new DatabasePool({configuration: this})
+    const PoolType = this.getDatabasePoolType()
+
+    this.databasePool = new PoolType({configuration: this})
     this.databasePool.setCurrent()
   }
 
   isDatabasePoolInitialized = () => Boolean(this.databasePool)
 
-  async initializeRoutes() {
-    // Every client need to make their own routes because they probably can't be shared across different worker threads
-    const routesImport = await import(`${this.directory}/src/config/routes.mjs`)
-
-    this.routes = digg(routesImport, "default", "routes")
+  initialize() {
+    // Doesn't currently do anything.
   }
 
   setCurrent() {
-    global.velociousConfiguration = this
+    this.constructor.velociousConfiguration = this
+  }
+
+  setRoutes(newRoutes) {
+    this.routes = newRoutes
   }
 }

package/src/controller.mjs

@@ -36,7 +36,7 @@ export default class VelociousController {
     return new Promise((resolve, reject) => {
       const actionName = digg(this, "_params", "action")
       const controllerName = digg(this, "_params", "controller")
-      const directory = digg(this, "_configuration", "directory")
+      const directory = digg(this, "_configuration").getDirectory()
       const viewPath = `${directory}/src/routes/${controllerName}/${actionName}.ejs`
       const {viewParams} = digs(this, "viewParams")
 

package/src/database/drivers/{sqlite-expo/index.mjs → sqlite/index.native.mjs}

@@ -1,5 +1,4 @@
 import Base from "../base.mjs"
-import CreateDatabase from "../sqlite/sql/create-database.mjs"
 import CreateTable from "../sqlite/sql/create-table.mjs"
 import Delete from "../sqlite/sql/delete.mjs"
 import {digg} from "diggerize"
@@ -10,7 +9,7 @@ import QueryParser from "../sqlite/query-parser.mjs"
 import * as SQLite from "expo-sqlite"
 import Update from "../sqlite/sql/update.mjs"
 
-export default class VelociousDatabaseDriversMysql extends Base{
+export default class VelociousDatabaseDriversSqliteNative extends Base{
   async connect() {
     const connection = await SQLite.openDatabaseAsync(digg(this.connectArgs(), "name"))
 
@@ -40,13 +39,6 @@ export default class VelociousDatabaseDriversMysql extends Base{
     this.connection = undefined
   }
 
-  createDatabaseSql(databaseName, args) {
-    const createArgs = Object.assign({databaseName, driver: this}, args)
-    const createDatabase = new CreateDatabase(createArgs)
-
-    return createDatabase.toSql()
-  }
-
   createTableSql(tableData) {
     const createArgs = Object.assign({tableData, driver: this})
     const createTable = new CreateTable(createArgs)

package/src/database/drivers/sqlite/index.web.mjs

@@ -0,0 +1,64 @@
+import Base from "../base.mjs"
+import CreateTable from "../sqlite/sql/create-table.mjs"
+import Delete from "../sqlite/sql/delete.mjs"
+import {digg} from "diggerize"
+import Insert from "../sqlite/sql/insert.mjs"
+import Options from "../sqlite/options.mjs"
+import query from "./query"
+import QueryParser from "../sqlite/query-parser.mjs"
+import Update from "../sqlite/sql/update.mjs"
+
+import initSqlJs from "sql.js"
+
+export default class VelociousDatabaseDriversSqliteWeb extends Base{
+  async connect() {
+    const SQL = await initSqlJs({
+      // Required to load the wasm binary asynchronously. Of course, you can host it wherever you want you can omit locateFile completely when running in Node.
+      locateFile: (file) => `https://sql.js.org/dist/${file}`
+    })
+
+    const databaseContent = localStorage.getItem(this.localStorageName())
+
+    this.connection = new SQL.Database(databaseContent)
+  }
+
+  localStorageName = () => `VelociousDatabaseDriversSqliteWeb---${digg(this.getArgs(), "name")}`
+  disconnect = () => this.saveDatabase()
+  saveDatabase = () => localStorage.setItem(this.localStorageName(), this.connection.export())
+
+  async close() {
+    this.saveDatabase()
+    await this.connection.end()
+    this.connection = undefined
+  }
+
+  createTableSql(tableData) {
+    const createArgs = Object.assign({tableData, driver: this})
+    const createTable = new CreateTable(createArgs)
+
+    return createTable.toSql()
+  }
+
+  query = async (sql) => await query(this.connection, sql)
+  queryToSql = (query) => new QueryParser({query}).toSql()
+
+  quote(string) {
+    if (!this.connection) throw new Error("Can't escape before connected")
+
+    return this.connection.escape(string)
+  }
+
+  quoteColumn = (string) => `\`${string}\``
+  deleteSql = ({tableName, conditions}) => new Delete({conditions, driver: this, tableName}).toSql()
+  insertSql = ({tableName, data}) => new Insert({driver: this, tableName, data}).toSql()
+
+  options() {
+    if (!this._options) {
+      this._options = new Options({driver: this})
+    }
+
+    return this._options
+  }
+
+  updateSql = ({conditions, data, tableName}) => new Update({conditions, data, driver: this, tableName}).toSql()
+}

package/src/database/drivers/sqlite/query.web.mjs

@@ -0,0 +1,9 @@
+export default async function query(connection, sql) {
+  const rows = []
+
+  for await (const entry of connection.exec(sql)) {
+    rows.push(entry)
+  }
+
+  return rows
+}

package/src/database/migrate-from-require-context.mjs

@@ -0,0 +1,53 @@
+import Configuration from "../configuration.mjs"
+import * as inflection from "inflection"
+
+export default class VelociousDatabaseMigrateFromRequireContext {
+  constructor(configuration) {
+    this.configuration = configuration || Configuration.current()
+  }
+
+  async execute(requireContext) {
+    const files = requireContext.keys()
+      .map((file) => {
+        const match = file.match(/^\.\/(\d{14})-(.+)\.mjs$/)
+
+        if (!match) return null
+
+        const date = parseInt(match[1])
+        const migrationName = match[2]
+        const migrationClassName = inflection.camelize(migrationName)
+
+        return {
+          file,
+          date,
+          migrationClassName
+        }
+      })
+      .filter((migration) => Boolean(migration))
+      .sort((migration1, migration2) => migration1.date - migration2.date)
+
+    for (const migration of files) {
+      await this.runMigrationFile(migration, requireContext)
+    }
+  }
+
+  async runMigrationFile(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 () => {
+      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}`)
+      }
+    })
+  }
+}

package/src/database/migration/index.mjs

@@ -10,7 +10,7 @@ export default class VelociousDatabaseMigration {
 
     callback(tableData)
 
-    const databasePool = this.configuration.databasePool
+    const databasePool = this.configuration.getDatabasePool()
     const sql = databasePool.createTableSql(tableData)
 
     await databasePool.query(sql)

package/src/database/pool/async-tracked-multi-connection.mjs

@@ -0,0 +1,81 @@
+import {AsyncLocalStorage} from "async_hooks"
+import BasePool from "./base.mjs"
+
+let idSeq = 0
+
+export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends BasePool {
+  static current() {
+    if (!this.velociousDatabasePoolAsyncTrackedMultiConnection) {
+      this.velociousDatabasePoolAsyncTrackedMultiConnection = new VelociousDatabasePoolAsyncTrackedMultiConnection()
+    }
+
+    return this.velociousDatabasePoolAsyncTrackedMultiConnection
+  }
+
+  constructor(args = {}) {
+    super(args)
+    this.connections = []
+    this.connectionsInUse = {}
+    this.asyncLocalStorage = new AsyncLocalStorage()
+  }
+
+  checkin = (connection) => {
+    const id = connection.getIdSeq()
+
+    if (id in this.connectionsInUse) {
+      delete this.connectionsInUse[id]
+    }
+
+    connection.setIdSeq(undefined)
+
+    this.connections.push(connection)
+  }
+
+  async checkout() {
+    let connection = this.connections.shift()
+
+    if (!connection) {
+      connection = await this.spawnConnection()
+    }
+
+    if (connection.getIdSeq() !== undefined) throw new Error(`Connection already has an ID-seq - is it in use? ${connection.getIdSeq()}`)
+
+    const id = idSeq++
+
+    connection.setIdSeq(id)
+    this.connectionsInUse[id] = connection
+
+    return connection
+  }
+
+  setCurrent() {
+    this.constructor.velociousDatabasePoolAsyncTrackedMultiConnection = this
+  }
+
+  async withConnection(callback) {
+    const connection = await this.checkout()
+    const id = connection.getIdSeq()
+
+    await this.asyncLocalStorage.run(id, async () => {
+      try {
+        await callback()
+      } finally {
+        this.checkin(connection)
+      }
+    })
+  }
+
+  getCurrentConnection() {
+    const id = this.asyncLocalStorage.getStore()
+
+    if (id === undefined) {
+      throw new Error("ID hasn't been set for this async context")
+    }
+
+    if (!(id in this.connectionsInUse)) {
+      throw new Error(`Connection ${id} doesn't exist any more - has it been checked in again?`)
+    }
+
+    return this.connectionsInUse[id]
+  }
+}

package/src/database/pool/base.mjs

@@ -0,0 +1,47 @@
+import Configuration from "../../configuration.mjs"
+import {digg} from "diggerize"
+
+class VelociousDatabasePoolBase {
+  constructor(args = {}) {
+    this.configuration = args.configuration || Configuration.current()
+    this.connections = []
+    this.connectionsInUse = {}
+  }
+
+  getConfiguration = () => digg(this, "configuration", "database", "default", "master")
+
+  setDriverClass(driverClass) {
+    this.driverClass = driverClass
+  }
+
+  async spawnConnection() {
+    const defaultConfig = this.getConfiguration()
+    const connection = await this.spawnConnectionWithConfiguration(defaultConfig)
+
+    return connection
+  }
+
+  async spawnConnectionWithConfiguration(config) {
+    const DriverClass = config.driver || this.driverClass
+
+    if (!DriverClass) throw new Error("No driver class set in database pool or in given config")
+
+    const connection = new DriverClass(config)
+
+    await connection.connect()
+
+    return connection
+  }
+}
+
+const forwardMethods = ["createTableSql", "deleteSql", "insertSql", "query", "quote", "updateSql"]
+
+for (const forwardMethod of forwardMethods) {
+  VelociousDatabasePoolBase.prototype[forwardMethod] = function(...args) {
+    const connection = this.getCurrentConnection()
+
+    return connection[forwardMethod](...args)
+  }
+}
+
+export default VelociousDatabasePoolBase

package/src/database/pool/single-multi-use.mjs

@@ -0,0 +1,40 @@
+import BasePool from "./base.mjs"
+
+export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
+  static current() {
+    if (!this.velociousDatabasePoolSingleMultiUser) {
+      this.velociousDatabasePoolSingleMultiUser = new VelociousDatabasePoolSingleMultiUser()
+    }
+
+    return this.velociousDatabasePoolSingleMultiUser
+  }
+
+  checkin = (connection) => {
+    // Do nothing
+  }
+
+  async checkout() {
+    if (!this.connection) {
+      this.connection = await this.spawnConnection()
+    }
+
+    return this.connection
+  }
+
+  setCurrent() {
+    this.constructor.velociousDatabasePoolSingleMultiUser = this
+  }
+
+  async withConnection(callback) {
+    await this.checkout() // Ensure a connection is present
+    await callback()
+  }
+
+  getCurrentConnection() {
+    if (!this.connection) {
+      throw new Error("A connection hasn't been made yet")
+    }
+
+    return this.connection
+  }
+}

package/src/database/query/create-database-base.mjs

@@ -1,3 +1,4 @@
+import {digs} from "diggerize"
 import QueryBase from "./base.mjs"
 
 export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
@@ -9,11 +10,12 @@ export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase
 
   toSql() {
     const {databaseName} = this
+    const {tableQuote} = digs(this.getOptions(), "tableQuote")
     let sql = "CREATE DATABASE"
 
     if (this.ifNotExists) sql += " IF NOT EXISTS"
 
-    sql += ` ${databaseName}`
+    sql += ` ${tableQuote}${databaseName}${tableQuote}`
 
     return sql
   }

package/src/database/record/index.mjs

@@ -1,4 +1,4 @@
-import DatabasePool from "../pool/index.mjs"
+import Configuration from "../../configuration.mjs"
 import Handler from "../handler.mjs"
 import inflection from "inflection"
 import Query from "../query/index.mjs"
@@ -6,7 +6,7 @@ import RecordNotFoundError from "./record-not-found-error.mjs"
 
 export default class VelociousDatabaseRecord {
   static connection() {
-    const connection = DatabasePool.current().getCurrentConnection()
+    const connection = Configuration.current().getDatabasePoolType().current().getCurrentConnection()
 
     if (!connection) throw new Error("No connection?")
 

package/src/http-server/worker-handler/index.mjs

@@ -13,7 +13,8 @@ export default class VelociousHttpServerWorker {
 
   async start() {
     return new Promise((resolve) => {
-      const {debug, directory} = digs(this.configuration, "debug", "directory")
+      const {debug} = digs(this.configuration, "debug")
+      const directory = this.configuration.getDirectory()
       const __filename = fileURLToPath(import.meta.url)
       const __dirname = dirname(__filename)
 

package/src/http-server/worker-handler/worker-thread.mjs

@@ -1,6 +1,5 @@
 import Application from "../../application.mjs"
 import Client from "../client/index.mjs"
-import DatabasePool from "../../database/pool/index.mjs"
 import {digg, digs} from "diggerize"
 import errorLogger from "../../error-logger.mjs"
 import logger from "../../logger.mjs"

package/src/routes/app-routes.mjs

@@ -0,0 +1,10 @@
+import {digg} from "diggerize"
+
+export default class VelociousRoutesAppRoutes {
+  static async getRoutes(configuration) {
+    // Every client need to make their own routes because they probably can't be shared across different worker threads
+    const routesImport = await import(`${configuration.getDirectory()}/src/config/routes.mjs`)
+
+    return digg(routesImport, "default", "routes")
+  }
+}

package/src/routes/resolver.mjs

@@ -21,7 +21,7 @@ export default class VelociousRoutesResolver {
     if (!matchResult) throw new Error(`Couldn't match a route with the given path: ${currentPath}`)
 
     if (this.params.action && this.params.controller) {
-      const controllerPath = `${digg(this, "configuration", "directory")}/src/routes/${digg(this, "params", "controller")}/controller.mjs`
+      const controllerPath = `${this.configuration.getDirectory()}/src/routes/${digg(this, "params", "controller")}/controller.mjs`
       const controllerClassImport = await import(controllerPath)
       const controllerClass = controllerClassImport.default
       const controllerInstance = new controllerClass({

package/src/templates/configuration.mjs

@@ -1,9 +1,13 @@
-import {Configuration} from "velocious"
+import AsyncTrackedMultiConnection from "velocious/src/database/pool/async-tracked-multi-connection.mjs"
+import Configuration from "velocious/src/configuration.mjs"
+import MysqlDriver from "velocious/src/database/drivers/mysql/index.mjs"
 
-const configuration = new Configuration({
+export default new Configuration({
   database: {
     default: {
       master: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
         type: "mysql",
         host: "mariadb",
         username: "username",
@@ -13,5 +17,3 @@ const configuration = new Configuration({
     }
   }
 })
-
-export default configuration

package/src/templates/generate-migration.mjs

@@ -1,6 +1,6 @@
-import {Database} from "velocious"
+import Migration from "velocious/src/database/migration/index.mjs"
 
-export default class __MIGRATION_NAME__ extends Database.Migration {
+export default class __MIGRATION_NAME__ extends Migration {
   async up() {
     await this.connection().execute("...")
   }

package/src/templates/generate-model.mjs

@@ -0,0 +1,4 @@
+import Record from "velocious/src/database/record/index.mjs"
+
+export default class __MODEL_NAME__ extends Record {
+}

package/src/templates/routes.mjs

@@ -1,4 +1,4 @@
-import {Routes} from "velocious"
+import Routes from "velocious/src/routes/index.mjs"
 
 const routes = new Routes()
 

package/src/database/drivers/sqlite/sql/create-database.mjs

@@ -1,4 +0,0 @@
-import CreateDatabaseBase from "../../../query/create-database-base.mjs"
-
-export default class VelociousDatabaseConnectionDriversMysqlSqlCreateDatabase extends CreateDatabaseBase {
-}

package/src/database/pool/index.mjs

@@ -1,112 +0,0 @@
-import {AsyncLocalStorage} from "node:async_hooks"
-import Configuration from "../../configuration.mjs"
-import {digg} from "diggerize"
-
-const asyncLocalStorage = new AsyncLocalStorage()
-let idSeq = 0
-
-class VelociousDatabasePool {
-  static current() {
-    if (!global.velociousDatabasePool) global.velociousDatabasePool = new VelociousDatabasePool()
-
-    return global.velociousDatabasePool
-  }
-
-  constructor(args = {}) {
-    this.configuration = args.configuration || Configuration.current()
-    this.connections = []
-    this.connectionsInUse = {}
-  }
-
-  checkin = (connection) => {
-    const id = connection.getIdSeq()
-
-    if (id in this.connectionsInUse) {
-      delete this.connectionsInUse[id]
-    }
-
-    connection.setIdSeq(undefined)
-
-    this.connections.push(connection)
-  }
-
-  async checkout() {
-    let connection = this.connections.shift()
-
-    if (!connection) {
-      connection = await this.spawnConnection()
-    }
-
-    if (connection.getIdSeq() !== undefined) throw new Error(`Connection already has an ID-seq - is it in use? ${connection.getIdSeq()}`)
-
-    const id = idSeq++
-
-    connection.setIdSeq(id)
-    this.connectionsInUse[id] = connection
-
-    return connection
-  }
-
-  getConfiguration = () => digg(this, "configuration", "database", "default", "master")
-
-  setCurrent() {
-    global.velociousDatabasePool = this
-  }
-
-  async spawnConnection() {
-    const defaultConfig = this.getConfiguration()
-    const connection = await this.spawnConnectionWithConfiguration(defaultConfig)
-
-    return connection
-  }
-
-  async spawnConnectionWithConfiguration(config) {
-    const driverPath = `../drivers/${digg(config, "type")}/index.mjs`
-    const DriverClassImport = await import(driverPath)
-    const DriverClass = DriverClassImport.default
-    const connection = new DriverClass(config)
-
-    await connection.connect()
-
-    return connection
-  }
-
-  async withConnection(callback) {
-    const connection = await this.checkout()
-    const id = connection.getIdSeq()
-
-    await asyncLocalStorage.run(id, async () => {
-      try {
-        await callback()
-      } finally {
-        this.checkin(connection)
-      }
-    })
-  }
-
-  getCurrentConnection() {
-    const id = asyncLocalStorage.getStore()
-
-    if (id === undefined) {
-      throw new Error("ID hasn't been set for this async context")
-    }
-
-    if (!(id in this.connectionsInUse)) {
-      throw new Error(`Connection ${id} doesn't exist any more - has it been checked in again?`)
-    }
-
-    return this.connectionsInUse[id]
-  }
-}
-
-const forwardMethods = ["createTableSql", "deleteSql", "insertSql", "query", "quote", "updateSql"]
-
-for (const forwardMethod of forwardMethods) {
-  VelociousDatabasePool.prototype[forwardMethod] = function(...args) {
-    const connection = this.getCurrentConnection()
-
-    return connection[forwardMethod](...args)
-  }
-}
-
-export default VelociousDatabasePool