velocious 1.0.14 → 1.0.16

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "main": "index.js",
   "scripts": {
     "test": "jasmine",
@@ -25,16 +25,20 @@
     "jasmine": "^5.0.2",
     "mysql": "^2.18.1",
     "node-fetch": "^3.3.1",
-    "require-context": "^1.1.0"
+    "require-context": "^1.1.0",
+    "sqlite": "^5.1.1",
+    "sqlite3": "^5.1.7"
   },
   "dependencies": {
     "better-localstorage": "^1.0.7",
+    "debounce": "^2.2.0",
     "diggerize": "^1.0.5",
     "ejs": "^3.1.6",
     "escape-string-regexp": "^1.0.5",
     "incorporator": "^1.0.2",
     "inflection": "^3.0.0",
     "sql-escape-string": "^1.1.0",
+    "sql-string-escape": "^1.1.6",
     "sql.js": "^1.12.0",
     "strftime": "^0.10.2"
   }

package/peak_flow.yml

@@ -5,9 +5,7 @@ before_install:
   - sudo apt-get update
   - sudo apt-get install -y nodejs
 before_script:
-  - cp spec/dummy/src/config/configuration.peakflow.js spec/dummy/src/config/configuration.js
   - npm install
-  - wait-for-it mariadb:3306
 services:
   mariadb:
     environment:
@@ -20,5 +18,15 @@ services:
       - 3306
     mem_limit: 4096m
     restart_policy: on-failure
-script:
-  - npm test
+builds:
+  build_1:
+    name: MariaDB
+    script:
+      - cp spec/dummy/src/config/configuration.peakflow.mariadb.js spec/dummy/src/config/configuration.js
+      - wait-for-it mariadb:3306
+      - npm test
+  build_2:
+    name: SQLite
+    script:
+      - cp spec/dummy/src/config/configuration.peakflow.sqlite.js spec/dummy/src/config/configuration.js
+      - npm test

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

@@ -10,16 +10,26 @@ describe("Cli - Commands - db:create", () => {
     })
     const result = await cli.execute()
 
-    expect(result).toEqual(
-      [
-        {
-          databaseName: 'velocious_test',
-          sql: 'CREATE DATABASE IF NOT EXISTS `velocious_test`'
-        },
-        {
-          createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS schema_migrations (`version` varchar(255) PRIMARY KEY NOT NULL)'
-        }
-      ]
-    )
+    if (cli.getConfiguration().getDatabaseType() == "sqlite") {
+      expect(result).toEqual(
+        [
+          {
+            createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS schema_migrations (`version` VARCHAR(255) PRIMARY KEY NOT NULL)'
+          }
+        ]
+      )
+    } else {
+      expect(result).toEqual(
+        [
+          {
+            databaseName: 'velocious_test',
+            sql: 'CREATE DATABASE IF NOT EXISTS `velocious_test`'
+          },
+          {
+            createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS schema_migrations (`version` VARCHAR(255) PRIMARY KEY NOT NULL)'
+          }
+        ]
+      )
+    }
   })
 })

package/spec/cli/commands/db/migrate-spec.js

@@ -12,28 +12,40 @@ describe("Cli - Commands - db:migrate", () => {
 
     await cli.loadConfiguration()
 
-    const db = cli.configuration.getDatabasePool()
+    const dbPool = cli.configuration.getDatabasePool()
 
-    await db.withConnection(async () => {
+    await dbPool.withConnection(async (db) => {
       await db.query("DROP TABLE IF EXISTS tasks")
-      await db.query("DROP TABLE IF EXISTS projects")
       await db.query("DROP TABLE IF EXISTS project_translations")
+      await db.query("DROP TABLE IF EXISTS projects")
     })
 
     await cli.execute()
 
-    let tablesResult
+    let projectForeignKey, tablesResult
+
+    await dbPool.withConnection(async (db) => {
+      const tables = await db.getTables()
 
-    await db.withConnection(async () => {
-      tablesResult = await db.query("SHOW TABLES")
+      tablesResult = tables.map((table) => table.getName())
+
+      const table = await db.getTableByName("tasks")
+      const foreignKeys = await table.getForeignKeys()
+
+      projectForeignKey = foreignKeys.find((foreignKey) => foreignKey.getColumnName() == "project_id")
     })
 
     expect(tablesResult).toEqual(
       [
-        {Tables_in_velocious_test: "project_translations"},
-        {Tables_in_velocious_test: "projects"},
-        {Tables_in_velocious_test: "tasks"}
+        "project_translations",
+        "projects",
+        "tasks"
       ]
     )
+
+    expect(projectForeignKey.getTableName()).toEqual("tasks")
+    expect(projectForeignKey.getColumnName()).toEqual("project_id")
+    expect(projectForeignKey.getReferencedTableName()).toEqual("projects")
+    expect(projectForeignKey.getReferencedColumnName()).toEqual("id")
   })
 })

package/spec/database/drivers/mysql/connection-spec.js

@@ -6,15 +6,17 @@ const mysqlConfig = digg(configuration, "database", "default", "master")
 
 describe("Database - Drivers - Mysql - Connection", () => {
   it("connects", async () => {
-    const mysql = new DatabaseDriversMysql(mysqlConfig)
+    if (configuration.getDatabaseType() != "sqlite") {
+      const mysql = new DatabaseDriversMysql(mysqlConfig)
 
-    await mysql.connect()
+      await mysql.connect()
 
-    const result = await mysql.query("SELECT \"1\" AS test1, \"2\" AS test2")
+      const result = await mysql.query("SELECT \"1\" AS test1, \"2\" AS test2")
 
-    expect(result).toEqual([{
-      test1: "1",
-      test2: "2"
-    }])
+      expect(result).toEqual([{
+        test1: "1",
+        test2: "2"
+      }])
+    }
   })
 })

package/spec/database/record/create-spec.js

@@ -2,7 +2,7 @@ import Dummy from "../../dummy/index.js"
 import Task from "../../dummy/src/models/task.js"
 
 describe("Record - create", () => {
-  it("creates a new simple record", async () => {
+  it("creates a new simple record with relationships and translations", async () => {
     await Dummy.run(async () => {
       const task = new Task({name: "Test task"})
       const project = task.buildProject({nameEn: "Test project", nameDe: "Test projekt"})

package/spec/database/record/destroy-spec.js

@@ -14,4 +14,19 @@ describe("Record - destroy", () => {
       expect(foundTask).toEqual(undefined)
     })
   })
+
+  it("destroys all records in a collection", async () => {
+    await Dummy.run(async () => {
+      const task1 = await Task.create({name: "Test task 1"})
+      const task2 = await Task.create({name: "Test task 2"})
+
+      await Task.where({id: task1.id()}).destroyAll()
+
+      const foundTask1 = await Task.where({id: task1.id()}).first()
+      const foundTask2 = await Task.where({id: task2.id()}).first()
+
+      expect(foundTask1).toEqual(undefined)
+      expect(foundTask2).toBeDefined()
+    })
+  })
 })

package/spec/database/record/translation-fallbacks-spec.js

@@ -2,7 +2,7 @@ import Dummy from "../../dummy/index.js"
 import Task from "../../dummy/src/models/task.js"
 
 describe("Record - create", () => {
-  it("creates a new simple record", async () => {
+  it("creates a new simple record with relationships and translations with fallbacks", async () => {
     await Dummy.run(async () => {
       const task = new Task({name: "Test task"})
       const project = task.buildProject({nameDe: "Test projekt"})

package/spec/dummy/index.js

@@ -1,5 +1,6 @@
 import Application from "../../src/application.js"
 import dummyConfiguration from "./src/config/configuration.js"
+import Migration from "../../src/database/migration/index.js"
 
 export default class Dummy {
   static current() {
@@ -17,13 +18,27 @@ export default class Dummy {
 
     await db.withConnection(async () => {
       await db.query("DROP TABLE IF EXISTS tasks")
-      await db.query("DROP TABLE IF EXISTS projects")
       await db.query("DROP TABLE IF EXISTS project_translations")
+      await db.query("DROP TABLE IF EXISTS projects")
+
+      const migration = new Migration({configuration: dummyConfiguration})
+
+      await migration.createTable("projects", (t) => {
+        t.timestamps()
+      })
+      await migration.createTable("project_translations", (t) => {
+        t.references("project", {null: false, foreignKey: true})
+        t.string("locale", {null: false})
+        t.string("name")
+      })
+
+      await migration.addIndex("project_translations", ["project_id", "locale"], {unique: true})
 
-      await db.query("CREATE TABLE tasks (id MEDIUMINT NOT NULL AUTO_INCREMENT, project_id MEDIUMINT, name VARCHAR(255), description TEXT, PRIMARY KEY (id))")
-      await db.query("CREATE TABLE projects (id MEDIUMINT NOT NULL AUTO_INCREMENT, PRIMARY KEY (id))")
-      await db.query("CREATE TABLE project_translations (id MEDIUMINT NOT NULL AUTO_INCREMENT, project_id MEDIUMINT, locale VARCHAR(255), name VARCHAR(255), PRIMARY KEY (id))")
-      await db.query("CREATE UNIQUE INDEX unique_project_translation ON project_translations (project_id, locale)")
+      await migration.createTable("tasks", (t) => {
+        t.references("project")
+        t.string("name")
+        t.text("description")
+      })
 
       if (!dummyConfiguration.isInitialized()) {
         await dummyConfiguration.initialize()

package/spec/dummy/src/config/configuration.peakflow.sqlite.js

@@ -0,0 +1,37 @@
+import Configuration from "../../../../src/configuration.js"
+import dummyDirectory from "../../dummy-directory.js"
+import fs from "fs/promises"
+import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
+import SqliteDriver from "../../../../src/database/drivers/sqlite/index.js"
+import path from "path"
+import requireContext from "require-context"
+import SingleMultiUsePool from "../../../../src/database/pool/single-multi-use.js"
+
+export default new Configuration({
+  database: {
+    default: {
+      master: {
+        driver: SqliteDriver,
+        poolType: SingleMultiUsePool,
+        type: "sqlite",
+        name: "test-db"
+      }
+    }
+  },
+  directory: dummyDirectory(),
+  initializeModels: async ({configuration}) => {
+    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
+    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
+    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
+
+    await configuration.getDatabasePool().withConnection(async () => {
+      await initializerFromRequireContext.initialize({configuration})
+    })
+  },
+  locale: () => "en",
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
+  },
+  locales: ["de", "en"]
+})

package/spec/dummy/src/config/configuration.sqlite.js

@@ -0,0 +1,37 @@
+import Configuration from "../../../../src/configuration.js"
+import dummyDirectory from "../../dummy-directory.js"
+import fs from "fs/promises"
+import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
+import path from "path"
+import requireContext from "require-context"
+import SqliteDriver from "../../../../src/database/drivers/sqlite/index.js"
+import SingleMultiUsePool from "../../../../src/database/pool/single-multi-use.js"
+
+export default new Configuration({
+  database: {
+    default: {
+      master: {
+        driver: SqliteDriver,
+        poolType: SingleMultiUsePool,
+        type: "sqlite",
+        name: "test-db"
+      }
+    }
+  },
+  directory: dummyDirectory(),
+  initializeModels: async ({configuration}) => {
+    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
+    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
+    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
+
+    await configuration.getDatabasePool().withConnection(async () => {
+      await initializerFromRequireContext.initialize({configuration})
+    })
+  },
+  locale: () => "en",
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
+  },
+  locales: ["de", "en"]
+})

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

@@ -3,6 +3,8 @@ import Routes from "../../../../src/routes/index.js"
 const routes = new Routes()
 
 routes.draw((route) => {
+  route.resources("projects")
+
   route.resources("tasks", (route) => {
     route.get("users")
   })

package/spec/dummy/src/database/migrations/20230728075328-create-projects.js

@@ -3,7 +3,6 @@ import Migration from "../../../../../src/database/migration/index.js"
 export default class CreateProjects extends Migration {
   async change() {
     await this.createTable("projects", (table) => {
-      table.string("name", {maxLength: 100, null: false})
       table.timestamps()
     })
   }

package/spec/dummy/src/database/migrations/20230728075329-create-tasks.js

@@ -3,7 +3,7 @@ import Migration from "../../../../../src/database/migration/index.js"
 export default class CreateTasks extends Migration {
   async change() {
     await this.createTable("tasks", (table) => {
-      table.references("project")
+      table.references("project", {foreignKey: true, null: false})
       table.string("name")
       table.text("description")
       table.timestamps()

package/spec/dummy/src/database/migrations/20250605133926-create-project-translations.js

@@ -3,7 +3,7 @@ import Migration from "../../../../../src/database/migration/index.js"
 export default class CreateProjectTranslations extends Migration {
   async up() {
     await this.createTable("project_translations", (t) => {
-      t.references("project", {null: false})
+      t.references("project", {foreignKey: true, null: false})
       t.string("locale", {null: false})
       t.string("name")
       t.timestamps()

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

@@ -0,0 +1,28 @@
+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() {
+    this.viewParams.numbers = [1, 2, 3, 4, 5]
+    this.render()
+  }
+
+  async show() {
+    const projectId = digg(params, "id")
+    const project = await Project.find(projectId)
+
+    this.viewParams.project = project
+    this.render()
+  }
+
+  async create() {
+    const project = new Project(this.params().project)
+
+    await project.save()
+
+    this.render({json: {status: "success"}})
+  }
+}

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

@@ -1,5 +1,6 @@
-import Controller from "../../../../../src/controller.js"
 import {digg} from "diggerize"
+
+import Controller from "../../../../../src/controller.js"
 import Task from "../../models/task.js"
 
 export default class TasksController extends Controller {

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

@@ -1,14 +1,15 @@
 import fetch from "node-fetch"
-import Dummy from "../dummy/index.js"
 import querystring from "querystring"
-import Task from "../dummy/src/models/task.js"
+
+import Dummy from "../dummy/index.js"
+import Project from "../dummy/src/models/project.js"
 
 describe("HttpServer", () => {
   it("handles post requests", async () => {
     await Dummy.run(async () => {
-      const postData = querystring.stringify({"task[name]": "Test create task"})
+      const postData = querystring.stringify({"project[name]": "Test create project"})
       const response = await fetch(
-        "http://localhost:3006/tasks",
+        "http://localhost:3006/projects",
         {
           body: postData,
           headers: {
@@ -19,18 +20,18 @@ describe("HttpServer", () => {
         }
       )
       const text = await response.text()
-      const createdTask = await Task.last()
+      const createdProject = await Project.preload({translations: true}).last()
 
       expect(text).toEqual('{"status":"success"}')
-      expect(createdTask.readAttribute("name")).toEqual("Test create task")
+      expect(createdProject.name()).toEqual("Test create project")
     })
   })
 
   it("handles post json requests", async () => {
     await Dummy.run(async () => {
-      const postData = JSON.stringify({task: {name: "Test create task"}})
+      const postData = JSON.stringify({project: {name: "Test create project"}})
       const response = await fetch(
-        "http://localhost:3006/tasks",
+        "http://localhost:3006/projects",
         {
           body: postData,
           headers: {
@@ -41,10 +42,10 @@ describe("HttpServer", () => {
         }
       )
       const text = await response.text()
-      const createdTask = await Task.last()
+      const createdProject = await Project.preload({translations: true}).last()
 
       expect(text).toEqual('{"status":"success"}')
-      expect(createdTask.readAttribute("name")).toEqual("Test create task")
+      expect(createdProject.name()).toEqual("Test create project")
     })
   })
 
@@ -52,21 +53,20 @@ describe("HttpServer", () => {
     await Dummy.run(async () => {
       const body = new FormData()
 
-      body.append("task[name]", "Test create task")
-      body.append("task[description]", "This is a task")
+      body.append("project[name]", "Test create project")
 
       const response = await fetch(
-        "http://localhost:3006/tasks",
+        "http://localhost:3006/projects",
         {
           body,
           method: "POST"
         }
       )
       const text = await response.text()
-      const createdTask = await Task.last()
+      const createdProject = await Project.preload({translations: true}).last()
 
       expect(text).toEqual('{"status":"success"}')
-      expect(createdTask.readAttribute("name")).toEqual("Test create task")
+      expect(createdProject.name()).toEqual("Test create project")
     })
   })
 })

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

@@ -15,16 +15,18 @@ export default class DbCreate extends BaseCommand{
     this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
     await this.databaseConnection.connect()
 
-    this.createDatabase()
-    await this.createSchemaMigrationsTable()
+    if (this.configuration.getDatabaseType() != "sqlite") {
+      await this.createDatabase()
+    }
 
+    await this.createSchemaMigrationsTable()
     await this.databaseConnection.close()
 
     if (this.args.testing) return this.result
   }
 
   async createDatabase() {
-    const databaseName = digg(this.databasePool.getConfiguration(), "database")
+    const databaseName = digg(this, "configuration", "database", "default", "master", "database")
     const sql = this.databaseConnection.createDatabaseSql(databaseName, {ifNotExists: true})
 
     if (this.args.testing) {

package/src/cli/index.js

@@ -57,4 +57,6 @@ export default class VelociousCli {
     this.configuration.setCurrent()
     this.args.configuration = this.configuration
   }
+
+  getConfiguration = () => this.args.configuration
 }

package/src/configuration.js

@@ -42,6 +42,16 @@ export default class VelociousConfiguration {
     return poolTypeClass
   }
 
+  getDatabaseType() {
+    const databaseType = digg(this, "database", "default", "master", "type")
+
+    if (!databaseType) {
+      throw new Error("No database type given in database configuration")
+    }
+
+    return databaseType
+  }
+
   getDirectory() {
     if (!this._directory) {
       this._directory = process.cwd()

package/src/database/drivers/base.js

@@ -2,8 +2,9 @@ import Query from "../query/index.js"
 import Handler from "../handler.js"
 
 export default class VelociousDatabaseDriversBase {
-  constructor(args) {
-    this._args = args
+  constructor(config, configuration) {
+    this._args = config
+    this.configuration = configuration
   }
 
   async createTable(...args) {
@@ -24,6 +25,8 @@ export default class VelociousDatabaseDriversBase {
     return this._args
   }
 
+  getConfiguration = () => this.configuration
+
   getIdSeq() {
     return this.idSeq
   }

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

@@ -0,0 +1,13 @@
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversMysqlForeignKey {
+  constructor(data) {
+    this.data = data
+  }
+
+  getColumnName = () => digg(this, "data", "COLUMN_NAME")
+  getName = () => digg(this, "data", "CONSTRAINT_NAME")
+  getTableName = () => digg(this, "data", "TABLE_NAME")
+  getReferencedColumnName = () => digg(this, "data", "REFERENCED_COLUMN_NAME")
+  getReferencedTableName = () => digg(this, "data", "REFERENCED_TABLE_NAME")
+}

package/src/database/drivers/mysql/index.js

@@ -1,6 +1,7 @@
 import Base from "../base.js"
 import connectConnection from "./connect-connection.js"
 import CreateDatabase from "./sql/create-database.js"
+import CreateIndex from "./sql/create-index.js"
 import CreateTable from "./sql/create-table.js"
 import Delete from "./sql/delete.js"
 import {digg} from "diggerize"
@@ -50,6 +51,13 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return createDatabase.toSql()
   }
 
+  createIndexSql(indexData) {
+    const createArgs = Object.assign({driver: this}, indexData)
+    const createIndex = new CreateIndex(createArgs)
+
+    return createIndex.toSql()
+  }
+
   createTableSql(tableData) {
     const createArgs = Object.assign({tableData, driver: this})
     const createTable = new CreateTable(createArgs)
@@ -57,6 +65,9 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return createTable.toSql()
   }
 
+  getType = () => "mysql"
+  primaryKeyType = () => "bigint"
+
   async query(sql) {
     return await query(this.connection, sql)
   }
@@ -65,6 +76,8 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return new QueryParser({query}).toSql()
   }
 
+  shouldSetAutoIncrementWhenPrimaryKey = () => true
+
   escape(string) {
     if (!this.connection) throw new Error("Can't escape before connected")
 

package/src/database/drivers/mysql/sql/create-index.js

@@ -0,0 +1,4 @@
+import CreateIndexBase from "../../../query/create-index-base.js"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlCreateIndex extends CreateIndexBase {
+}

package/src/database/drivers/mysql/table.js

@@ -1,4 +1,5 @@
 import Column from "./column.js"
+import ForeignKey from "./foreign-key.js"
 
 export default class VelociousDatabaseDriversMysqlTable {
   constructor(driver, data) {
@@ -19,6 +20,27 @@ export default class VelociousDatabaseDriversMysqlTable {
     return columns
   }
 
+  async getForeignKeys() {
+    const sql = `
+      SELECT TABLE_NAME, COLUMN_NAME, CONSTRAINT_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+      FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+      WHERE
+        REFERENCED_TABLE_SCHEMA = (SELECT DATABASE()) AND
+        TABLE_NAME = ${this.driver.quote(this.getName())}
+    `
+
+    const foreignKeyRows = await this.driver.query(sql)
+    const foreignKeys = []
+
+    for (const foreignKeyRow of foreignKeyRows) {
+      const foreignKey = new ForeignKey(foreignKeyRow)
+
+      foreignKeys.push(foreignKey)
+    }
+
+    return foreignKeys
+  }
+
   getName() {
     return Object.values(this.data)[0]
   }

package/src/database/drivers/sqlite/base.js

@@ -35,6 +35,7 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   }
 
   deleteSql = (args) => new Delete(Object.assign({driver: this}, args)).toSql()
+  getType = () => "sqlite"
   insertSql = (args) => new Insert(Object.assign({driver: this}, args)).toSql()
 
   async getTableByName(tableName) {
@@ -125,6 +126,7 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     return this._options
   }
 
+  primaryKeyType = () => "integer" // Because bigint on SQLite doesn't support auto increment
   queryToSql = (query) => new QueryParser({query}).toSql()
 
   async registerVersion() {
@@ -139,6 +141,8 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     this.versionPatch = versionParts[2]
   }
 
+  shouldSetAutoIncrementWhenPrimaryKey = () => false
+
   escape(value) {
     const type = typeof value
 

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

@@ -0,0 +1,14 @@
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversSqliteForeignKey {
+  constructor(data, {tableName}) {
+    this.data = data
+    this.tableName = tableName
+  }
+
+  getColumnName = () => digg(this, "data", "from")
+  getName = () => `${this.getTableName()}_${this.getColumnName()}_${this.data.id}`
+  getTableName = () => digg(this, "tableName")
+  getReferencedColumnName = () => digg(this, "data", "to")
+  getReferencedTableName = () => digg(this, "data", "table")
+}

package/src/database/drivers/sqlite/index.js

@@ -1,4 +1,3 @@
-import debounce from "debounce"
 import {digg} from "diggerize"
 import fs from "fs/promises"
 import query from "./query.js"
@@ -10,7 +9,7 @@ import Base from "./base.js"
 export default class VelociousDatabaseDriversSqliteNode extends Base {
   async connect() {
     const args = this.getArgs()
-    const databasePath = `db/${this.localStorageName()}.sqlite`
+    const databasePath = `${this.getConfiguration().getDirectory()}/db/${this.localStorageName()}.sqlite`
 
     if (args.reset) {
       await fs.unlink(databasePath)

package/src/database/drivers/sqlite/sql/create-index.js

@@ -1,4 +1,4 @@
 import CreateIndexBase from "../../../query/create-index-base.js"
 
-export default class VelociousDatabaseConnectionDriversMysqlSqlCreateIndex extends CreateIndexBase {
+export default class VelociousDatabaseConnectionDriversSqliteSqlCreateIndex extends CreateIndexBase {
 }

package/src/database/drivers/sqlite/table.js

@@ -1,5 +1,6 @@
 import Column from "./column.js"
 import {digg} from "diggerize"
+import ForeignKey from "./foreign-key.js"
 
 export default class VelociousDatabaseDriversSqliteTable {
   constructor({driver, row}) {
@@ -7,7 +8,7 @@ export default class VelociousDatabaseDriversSqliteTable {
     this.row = row
   }
 
-  getColumns = async () => {
+  async getColumns() {
     const result = await this.driver.query(`PRAGMA table_info('${this.getName()}')`)
     const columns = []
 
@@ -20,5 +21,18 @@ export default class VelociousDatabaseDriversSqliteTable {
     return columns
   }
 
+  async getForeignKeys() {
+    const foreignKeysData = await this.driver.query(`SELECT * FROM pragma_foreign_key_list(${this.driver.quote(this.getName())})`)
+    const foreignKeys = []
+
+    for (const foreignKeyData of foreignKeysData) {
+      const foreignKey = new ForeignKey(foreignKeyData, {tableName: this.getName()})
+
+      foreignKeys.push(foreignKey)
+    }
+
+    return foreignKeys
+  }
+
   getName = () => digg(this, "row", "name")
 }

package/src/database/initializer-from-require-context.js

@@ -9,7 +9,11 @@ export default class VelociousDatabaseInitializerFromRequireContext {
 
   async initialize({configuration}) {
     for (const fileName of this.requireContext.keys()) {
-      const modelClass = this.requireContext(fileName).default
+      const modelClassImport = this.requireContext(fileName)
+
+      if (!modelClassImport) throw new Error(`Couldn't import model class from ${fileName}`)
+
+      const modelClass = modelClassImport.default
 
       await modelClass.initializeRecord({configuration})
 

package/src/database/migration/index.js

@@ -1,3 +1,4 @@
+import * as inflection from "inflection"
 import TableData, {TableColumn} from "../table-data/index.js"
 
 export default class VelociousDatabaseMigration {
@@ -5,10 +6,12 @@ export default class VelociousDatabaseMigration {
     this.configuration = configuration
   }
 
-  async addColumn(tableName, columnName, args) {
+  async addColumn(tableName, columnName, columnType, args) {
     const databasePool = this.configuration.getDatabasePool()
+    const tableColumnArgs = Object.assign({type: columnType}, args)
+
     const sqls = databasePool.alterTableSql({
-      columns: [new TableColumn(columnName, args)],
+      columns: [new TableColumn(columnName, tableColumnArgs)],
       tableName
     })
 
@@ -31,14 +34,46 @@ export default class VelociousDatabaseMigration {
     await databasePool.query(sql)
   }
 
+  async addForeignKey(tableName, referenceName) {
+    const referenceNameUnderscore = inflection.underscore(referenceName)
+    const tableNameUnderscore = inflection.underscore(tableName)
+    const columnName = `${referenceNameUnderscore}_id`
+    const databasePool = this.configuration.getDatabasePool()
+    const foreignKeyName = `fk_${tableName}_${referenceName}`
+    let sql = ""
+
+    sql += `ALTER TABLE ${databasePool.quoteTable(tableName)}`
+    sql += ` ADD CONSTRAINT ${foreignKeyName} `
+    sql += ` FOREIGN KEY (${databasePool.quoteColumn(columnName)})`
+    sql += ` REFERENCES ${tableNameUnderscore}(id)`
+
+    await databasePool.query(sql)
+  }
+
+  async addReference(tableName, referenceName, args) {
+    const columnName = `${inflection.underscore(referenceName)}_id`
+
+    await this.addColumn(tableName, columnName, {type: args?.type})
+    await this.addIndex(tableName, [columnName], {unique: args?.unique})
+
+    if (args?.foreignKey) {
+      await this.addForeignKey(tableName, referenceName)
+    }
+  }
+
   async createTable(tableName, callback) {
+    const databasePool = this.configuration.getDatabasePool()
+    const primaryKeyType = databasePool.primaryKeyType()
     const tableData = new TableData(tableName)
 
-    tableData.integer("id", {null: false, primaryKey: true})
+    if (!(primaryKeyType in tableData)) throw new Error(`Unsupported primary key type: ${primaryKeyType}`)
 
-    callback(tableData)
+    tableData[primaryKeyType]("id", {autoIncrement: true, null: false, primaryKey: true})
+
+    if (callback) {
+      callback(tableData)
+    }
 
-    const databasePool = this.configuration.getDatabasePool()
     const sqls = databasePool.createTableSql(tableData)
 
     for (const sql of sqls) {

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

@@ -4,14 +4,6 @@ import BasePool from "./base.js"
 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 = []
@@ -48,10 +40,6 @@ export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends Ba
     return connection
   }
 
-  setCurrent() {
-    this.constructor.velociousDatabasePoolAsyncTrackedMultiConnection = this
-  }
-
   async withConnection(callback) {
     const connection = await this.checkout()
     const id = connection.getIdSeq()

package/src/database/pool/base.js

@@ -1,7 +1,21 @@
 import Configuration from "../../configuration.js"
 import {digg} from "diggerize"
 
+if (!globalThis.velociousDatabasePoolBase) {
+  globalThis.velociousDatabasePoolBase = {
+    current: null
+  }
+}
+
 class VelociousDatabasePoolBase {
+  static current() {
+    if (!globalThis.velociousDatabasePoolBase.current) {
+      globalThis.velociousDatabasePoolBase.current = new this()
+    }
+
+    return globalThis.velociousDatabasePoolBase.current
+  }
+
   constructor(args = {}) {
     this.configuration = args.configuration || Configuration.current()
     this.connections = []
@@ -10,6 +24,10 @@ class VelociousDatabasePoolBase {
 
   getConfiguration = () => digg(this, "configuration", "database", "default", "master")
 
+  setCurrent() {
+    globalThis.velociousDatabasePoolBase.current = this
+  }
+
   setDriverClass(driverClass) {
     this.driverClass = driverClass
   }
@@ -26,7 +44,7 @@ class VelociousDatabasePoolBase {
 
     if (!DriverClass) throw new Error("No driver class set in database pool or in given config")
 
-    const connection = new DriverClass(config)
+    const connection = new DriverClass(config, this.configuration)
 
     await connection.connect()
 
@@ -46,8 +64,11 @@ const forwardMethods = [
   "getTables",
   "insert",
   "insertSql",
+  "primaryKeyType",
   "query",
   "quote",
+  "quoteColumn",
+  "quoteTable",
   "select",
   "update",
   "updateSql"

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

@@ -1,14 +1,6 @@
 import BasePool from "./base.js"
 
 export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
-  static current() {
-    if (!this.velociousDatabasePoolSingleMultiUser) {
-      this.velociousDatabasePoolSingleMultiUser = new VelociousDatabasePoolSingleMultiUser()
-    }
-
-    return this.velociousDatabasePoolSingleMultiUser
-  }
-
   checkin = (connection) => {
     // Do nothing
   }
@@ -21,10 +13,6 @@ export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
     return this.connection
   }
 
-  setCurrent() {
-    this.constructor.velociousDatabasePoolSingleMultiUser = this
-  }
-
   async withConnection(callback) {
     await this.checkout() // Ensure a connection is present
     await callback(this.connection)

package/src/database/query/create-index-base.js

@@ -15,7 +15,7 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
     let indexName = `index_on_${this.tableName}_`
 
     for (const columnIndex in this.columns) {
-      if (columnIndex > 0) indexName += "_"
+      if (columnIndex > 0) indexName += "_and_"
 
       indexName += this.columns[columnIndex]
     }

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

@@ -1,4 +1,5 @@
 import CreateIndexBase from "./create-index-base.js"
+import * as inflection from "inflection"
 import QueryBase from "./base.js"
 
 export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
@@ -9,7 +10,10 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
     this.tableData = tableData
   }
 
+  getConfiguration = () => this.driver.getConfiguration()
+
   toSql() {
+    const databaseType = this.getConfiguration().getDatabaseType()
     const {tableData} = this
     const sqls = []
 
@@ -24,23 +28,40 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
     for (const column of tableData.getColumns()) {
       columnCount++
 
-      let maxlength = column.args.maxlength
-      let type = column.args.type
+      let maxlength = column.getMaxLength()
+      let type = column.getType().toUpperCase()
 
-      if (type == "string") {
-        type = "varchar"
+      if (type == "STRING") {
+        type = "VARCHAR"
         maxlength ||= 255
       }
 
+      if (databaseType == "sqlite" && column.getAutoIncrement() && column.getPrimaryKey()) {
+        type = "INTEGER"
+      }
+
       if (columnCount > 1) sql += ", "
 
-      sql += `${this.driver.quoteColumn(column.name)} ${type}`
+      sql += `${this.driver.quoteColumn(column.getName())} ${type}`
 
       if (maxlength !== undefined) sql += `(${maxlength})`
 
-      if (column.args.autoIncrement) sql += " AUTO_INCREMENT"
-      if (column.args.primaryKey) sql += " PRIMARY KEY"
-      if (column.args.null === false) sql += " NOT NULL"
+      if (column.getAutoIncrement() && this.driver.shouldSetAutoIncrementWhenPrimaryKey()) sql += " AUTO_INCREMENT"
+      if (column.getPrimaryKey()) sql += " PRIMARY KEY"
+      if (column.getNull() === false) sql += " NOT NULL"
+
+      if (column.getForeignKey()) {
+        let foreignKeyTable, foreignKeyColumn
+
+        if (column.getForeignKey() === true) {
+          foreignKeyColumn = "id"
+          foreignKeyTable = inflection.pluralize(column.getName().replace(/_id$/, ""))
+        } else {
+          throw new Error(`Unknown foreign key type given: ${column.getForeignKey()} (${typeof column.getForeignKey()})`)
+        }
+
+        sql += ` REFERENCES ${this.driver.quoteTable(foreignKeyTable)}(${this.driver.quoteColumn(foreignKeyColumn)})`
+      }
     }
 
     if (this.indexInCreateTable) {

package/src/database/query/index.js

@@ -47,6 +47,14 @@ export default class VelociousDatabaseQuery {
 
   getOptions = () => this.driver.options()
 
+  async destroyAll() {
+    const records = await this.toArray()
+
+    for (const record of records) {
+      await record.destroy()
+    }
+  }
+
   async find(recordId) {
     const conditions = {}
 

package/src/database/query/insert-base.js

@@ -20,7 +20,7 @@ export default class VelociousDatabaseQueryInsertBase {
   }
 
   toSql() {
-    let sql = `INSERT INTO ${this.getOptions().quoteTableName(this.tableName)} (`
+    let sql = `INSERT INTO ${this.getOptions().quoteTableName(this.tableName)}`
     let count = 0
     let columns
 
@@ -32,16 +32,24 @@ export default class VelociousDatabaseQueryInsertBase {
       throw new Error("Neither 'column' and 'rows' or data was given")
     }
 
-    for (const columnName of columns) {
-      if (count > 0) sql += ", "
+    if (columns.length > 0) {
+      sql += " ("
 
-      sql += this.getOptions().quoteColumnName(columnName)
-      count++
-    }
+      for (const columnName of columns) {
+        if (count > 0) sql += ", "
+
+        sql += this.getOptions().quoteColumnName(columnName)
+        count++
+      }
 
-    sql += ") VALUES "
+      sql += ")"
+    }
 
     if (this.columns && this.rows) {
+      if (this.rows.length > 0) {
+        sql += " VALUES "
+      }
+
       let count = 0
 
       for (const row of this.rows) {
@@ -51,7 +59,14 @@ export default class VelociousDatabaseQueryInsertBase {
         sql += this._valuesSql(row)
       }
     } else {
-      sql += this._valuesSql(Object.values(this.data))
+      if (Object.keys(this.data).length > 0) {
+        sql += " VALUES "
+        sql += this._valuesSql(Object.values(this.data))
+      } else if (this.driver.getType() == "sqlite") {
+        sql += " DEFAULT VALUES"
+      } else if (this.driver.getType() == "mysql") {
+        sql += " () VALUES ()"
+      }
     }
 
     return sql

package/src/database/record/index.js

@@ -457,6 +457,10 @@ export default class VelociousDatabaseRecord {
     return this._newQuery()
   }
 
+  static async destroyAll(...args) {
+    return this._newQuery().destroyAll(...args)
+  }
+
   static async find(...args) {
     return this._newQuery().find(...args)
   }

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

@@ -1,14 +1,34 @@
+import restArgsError from "../../utils/rest-args-error.js"
+
 class TableColumn {
   constructor(name, args) {
+    if (args) {
+      const {autoIncrement, foreignKey, maxLength, name, null: argsNull, primaryKey, type, ...restArgs} = args
+
+      restArgsError(restArgs)
+    }
+
     this.args = args
     this.name = name
   }
 
+  getAutoIncrement = () => this.args?.autoIncrement
+  getForeignKey = () => this.args?.foreignKey
+  getMaxLength = () => this.args?.maxLength
   getName = () => this.name
+  getNull = () => this.args?.null
+  getPrimaryKey = () => this.args?.primaryKey
+  getType = () => this.args?.type
 }
 
 class TableIndex {
   constructor(columns, args) {
+    if (args) {
+      const {name, unique, ...restArgs} = args
+
+      restArgsError(restArgs)
+    }
+
     this.args = args
     this.columns = columns
   }