velocious 1.0.47 → 1.0.48

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.47",
+  "version": "1.0.48",
   "main": "index.js",
   "scripts": {
     "test": "VELOCIOUS_TEST_DIR=../ cd spec/dummy && npx velocious test",

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

@@ -40,15 +40,43 @@ describe("Cli - Commands - db:migrate", () => {
         }
       }
 
-      // It creates unique indexes
+      // It creates the correct index
       const authenticationTokensTable = await dbs.default.getTableByName("authentication_tokens")
-      const tokenColumn = await authenticationTokensTable.getColumnByName("token")
-      const tokenIndex = await tokenColumn.getIndexByName("index_on_authentication_tokens_token")
+      const indexes = await authenticationTokensTable.getIndexes()
+      const indexesNames = indexes
+        .map((index) => index.getName())
+        .filter((indexName) => indexName != "authentication_tokens_pkey" && indexName != "PRIMARY" && !indexName.startsWith("PK__"))
+        .sort()
+
+      if (defaultDatabaseType == "mysql") {
+        expect(indexesNames).toEqual(["index_on_token","user_id"])
+      } else if (defaultDatabaseType == "sqlite") {
+        expect(indexesNames).toEqual(["index_on_authentication_tokens_token", "index_on_authentication_tokens_user_id"])
+      } else {
+        expect(indexesNames).toEqual(["index_on_token", "index_on_user_id"])
+      }
 
-      expect(tokenIndex.getName()).toEqual("index_on_authentication_tokens_token")
+      // It creates unique indexes
+      let tokenIndexName
+
+      if (defaultDatabaseType == "sqlite") {
+        tokenIndexName = "index_on_authentication_tokens_token"
+      } else {
+        tokenIndexName = "index_on_token"
+      }
+
+      const tokenColumn = await authenticationTokensTable.getColumnByName("user_token")
+      const tokenIndex = await tokenColumn.getIndexByName(tokenIndexName)
+
+      expect(tokenIndex.getName()).toEqual(tokenIndexName)
       expect(tokenIndex.isPrimaryKey()).toBeFalse()
       expect(tokenIndex.isUnique()).toBeTrue()
 
+      // It creates foreign keys
+      const authTokensTableForeignKeys = await authenticationTokensTable.getForeignKeys()
+
+      expect(authTokensTableForeignKeys.length).toEqual(1)
+
       for (const db of Object.values(dbs)) {
         const schemaMigrations = await db.query("SELECT * FROM schema_migrations ORDER BY version")
 
@@ -89,7 +117,8 @@ describe("Cli - Commands - db:migrate", () => {
         "20250903112845",
         "20250912183605",
         "20250912183606",
-        "20250915085450"
+        "20250915085450",
+        "20250916111330"
       ])
     } else {
       expect(tablesResult.sort()).toEqual(
@@ -105,7 +134,16 @@ describe("Cli - Commands - db:migrate", () => {
         ]
       )
 
-      expect(defaultSchemaMigrations.sort()).toEqual(["20230728075328", "20230728075329", "20250605133926", "20250903112845", "20250912183605", "20250912183606", "20250915085450"])
+      expect(defaultSchemaMigrations.sort()).toEqual([
+        "20230728075328",
+        "20230728075329",
+        "20250605133926",
+        "20250903112845",
+        "20250912183605",
+        "20250912183606",
+        "20250915085450",
+        "20250916111330"
+      ])
     }
   })
 })

package/spec/dummy/src/database/migrations/20250916111330-rename_authentication_tokens_token_to_user_token.js

@@ -0,0 +1,11 @@
+import Migration from "../../../../../src/database/migration/index.js"
+
+export default class RenameAuthenticationTokensTokenToUserToken extends Migration {
+  async up() {
+    await this.renameColumn("authentication_tokens", "token", "user_token")
+  }
+
+  async down() {
+    await this.renameColumn("authentication_tokens", "user_token", "token")
+  }
+}

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

@@ -1,4 +1,5 @@
-import TableData, {TableColumn} from "../table-data/index.js"
+import TableColumn from "../table-data/table-column.js"
+import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseDriversBaseColumn {
   async getIndexByName(indexName) {
@@ -18,8 +19,6 @@ export default class VelociousDatabaseDriversBaseColumn {
 
     const sqls = await this.getDriver().alterTableSql(tableData)
 
-    console.log({sqls})
-
     for (const sql of sqls) {
       await this.getDriver().query(sql)
     }

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

@@ -0,0 +1,31 @@
+import TableForeignKey from "../table-data/table-foreign-key.js"
+
+export default class VelociousDatabaseDriversBaseForeignKey {
+  constructor(data) {
+    this.data = data
+  }
+
+  getDriver() {
+    return this.getTable().getDriver()
+  }
+
+  getOptions() {
+    return this.getDriver().options()
+  }
+
+  getTable() {
+    if (!this.table) throw new Error("No table set on column")
+
+    return this.table
+  }
+
+  getTableDataForeignKey() {
+    return new TableForeignKey({
+      columnName: this.getColumnName(),
+      name: this.getName(),
+      tableName: this.getTableName(),
+      referencedColumnName: this.getReferencedColumnName(),
+      referencedTableName: this.getReferencedTableName()
+    })
+  }
+}

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

@@ -21,9 +21,23 @@ export default class VelociousDatabaseDriversBaseTable {
 
   async getTableData() {
     const tableData = new TableData(this.getName())
+    const tableDataColumns = []
 
     for (const column of await this.getColumns()) {
-      tableData.addColumn(column.getTableDataColumn())
+      const tableDataColumn = column.getTableDataColumn()
+
+      tableData.addColumn(tableDataColumn)
+      tableDataColumns.push(tableDataColumn)
+    }
+
+    for (const foreignKey of await this.getForeignKeys()) {
+      tableData.addForeignKey(foreignKey.getTableDataForeignKey())
+
+      const tableDataColumn = tableDataColumns.find((tableDataColumn) => tableDataColumn.getName() == foreignKey.getColumnName())
+
+      if (!tableDataColumn) throw new Error(`Couldn't find table data column for foreign key: ${foreignKey.getColumnName()}`)
+
+      tableDataColumn.setForeignKey(foreignKey)
     }
 
     for (const index of await this.getIndexes()) {

package/src/database/drivers/base.js

@@ -3,6 +3,8 @@ import Query from "../query/index.js"
 import Handler from "../handler.js"
 import strftime from "strftime"
 import UUID from "pure-uuid"
+import TableData from "../table-data/index.js"
+import TableColumn from "../table-data/table-column.js"
 
 export default class VelociousDatabaseDriversBase {
   constructor(config, configuration) {
@@ -42,7 +44,7 @@ export default class VelociousDatabaseDriversBase {
     if (!this.configuration) throw new Error("No configuration set")
 
     return this.configuration
-}
+  }
 
   getIdSeq() {
     return this.idSeq
@@ -203,6 +205,22 @@ export default class VelociousDatabaseDriversBase {
     await this.query(`SAVEPOINT ${savePointName}`)
   }
 
+  async renameColumn(tableName, oldColumnName, newColumnName) {
+    const tableColumn = new TableColumn(oldColumnName)
+
+    tableColumn.setNewName(newColumnName)
+
+    const tableData = new TableData(tableName)
+
+    tableData.addColumn(tableColumn)
+
+    const alterTableSQLs = await this.alterTableSql(tableData)
+
+    for (const alterTableSQL of alterTableSQLs) {
+      await this.query(alterTableSQL)
+    }
+  }
+
   async releaseSavePoint(savePointName) {
     await this.query(`RELEASE SAVEPOINT ${savePointName}`)
   }

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

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

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

@@ -1,10 +1,7 @@
+import BaseForeignKey from "../base-foreign-key.js"
 import {digg} from "diggerize"
 
-export default class VelociousDatabaseDriversMssqlForeignKey {
-  constructor(data) {
-    this.data = data
-  }
-
+export default class VelociousDatabaseDriversMssqlForeignKey extends BaseForeignKey {
   getColumnName = () => digg(this, "data", "ParentColumn")
   getName = () => digg(this, "data", "CONSTRAINT_NAME")
   getTableName = () => digg(this, "data", "TableName")

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

@@ -119,9 +119,7 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return new QueryParser({query}).toSql()
   }
 
-  shouldSetAutoIncrementWhenPrimaryKey = () => true
-
-
+  shouldSetAutoIncrementWhenPrimaryKey() { return true }
 
   escape(value) {
     value = this._convertValue(value)
@@ -147,8 +145,12 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return escapeString(value)
   }
 
-  quoteColumn = (string) => this.options().quoteColumnName(string)
-  quoteTable = (string) => this.options().quoteTableName(string)
+  quoteColumn(string) { return this.options().quoteColumnName(string) }
+  quoteTable(string) { return this.options().quoteTableName(string) }
+
+  async renameColumn(tableName, oldColumnName, newColumnName) {
+    await this.query(`EXEC sp_rename ${this.quote(`${tableName}.${oldColumnName}`)}, ${this.quote(newColumnName)}, 'COLUMN'`)
+  }
 
   deleteSql({tableName, conditions}) {
     const deleteInstruction = new Delete({conditions, driver: this, tableName})

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

@@ -1,5 +1,6 @@
 import BaseTable from "../base-table.js"
 import Column from "./column.js"
+import ColumnsIndex from "./columns-index.js"
 import {digg} from "diggerize"
 import ForeignKey from "./foreign-key.js"
 
@@ -61,6 +62,41 @@ export default class VelociousDatabaseDriversMssqlTable extends BaseTable {
     return foreignKeys
   }
 
+  async getIndexes() {
+    const options = this.getOptions()
+    const sql = `
+      SELECT
+        sys.tables.name AS TableName,
+        sys.columns.name AS ColumnName,
+        sys.indexes.name AS index_name,
+        sys.indexes.type_desc AS IndexType,
+        sys.index_columns.is_included_column AS IsIncludedColumn,
+        sys.indexes.is_unique,
+        sys.indexes.is_primary_key,
+        sys.indexes.is_unique_constraint
+      FROM sys.indexes
+      INNER JOIN sys.index_columns ON sys.indexes.object_id = sys.index_columns.object_id AND sys.indexes.index_id = sys.index_columns.index_id
+      INNER JOIN sys.columns ON sys.index_columns.object_id = sys.columns.object_id AND sys.index_columns.column_id = sys.columns.column_id
+      INNER JOIN sys.tables ON sys.indexes.object_id = sys.tables.object_id
+      WHERE
+        sys.tables.name = ${options.quote(this.getName())}
+      ORDER BY
+        sys.indexes.name,
+        sys.index_columns.key_ordinal
+    `
+
+    const rows = await this.getDriver().query(sql)
+    const indexes = []
+
+    for (const row of rows) {
+      const index = new ColumnsIndex(this, row)
+
+      indexes.push(index)
+    }
+
+    return indexes
+  }
+
   getName() {
     return digg(this.data, "TABLE_NAME")
   }

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

@@ -21,9 +21,10 @@ export default class VelociousDatabaseDriversMysqlColumn extends BaseColumn {
         NON_UNIQUE,
         INDEX_TYPE
       FROM INFORMATION_SCHEMA.STATISTICS
-      WHERE TABLE_SCHEMA = DATABASE()
-        AND TABLE_NAME = ${options.quote(this.table.getName())}
-        AND COLUMN_NAME = ${options.quote(this.getName())}
+      WHERE
+        TABLE_SCHEMA = DATABASE() AND
+        TABLE_NAME = ${options.quote(this.table.getName())} AND
+        COLUMN_NAME = ${options.quote(this.getName())}
     `
     const indexesRows = await this.getDriver().query(sql)
     const indexes = []

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

@@ -1,10 +1,7 @@
+import BaseForeignKey from "../base-foreign-key.js"
 import {digg} from "diggerize"
 
-export default class VelociousDatabaseDriversMysqlForeignKey {
-  constructor(data) {
-    this.data = data
-  }
-
+export default class VelociousDatabaseDriversMysqlForeignKey extends BaseForeignKey {
   getColumnName = () => digg(this, "data", "COLUMN_NAME")
   getName = () => digg(this, "data", "CONSTRAINT_NAME")
   getTableName = () => digg(this, "data", "TABLE_NAME")

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

@@ -1,5 +1,6 @@
 import BaseTable from "../base-table.js"
 import Column from "./column.js"
+import ColumnsIndex from "./columns-index.js"
 import ForeignKey from "./foreign-key.js"
 
 export default class VelociousDatabaseDriversMysqlTable extends BaseTable {
@@ -43,6 +44,46 @@ export default class VelociousDatabaseDriversMysqlTable extends BaseTable {
     return foreignKeys
   }
 
+  async getIndexes() {
+    const options = this.getOptions()
+    const sql = `
+      SELECT
+        TABLE_SCHEMA,
+        TABLE_NAME,
+        INDEX_NAME AS index_name,
+        COLUMN_NAME,
+        SEQ_IN_INDEX,
+        NON_UNIQUE,
+        INDEX_TYPE
+      FROM INFORMATION_SCHEMA.STATISTICS
+      WHERE
+        TABLE_SCHEMA = DATABASE() AND
+        TABLE_NAME = ${options.quote(this.getName())}
+    `
+    const indexesRows = await this.getDriver().query(sql)
+    const indexes = []
+
+    for (const indexRow of indexesRows) {
+      if (indexRow.NON_UNIQUE == 1) {
+        indexRow.is_unique = false
+      } else {
+        indexRow.is_unique = true
+      }
+
+      if (indexRow.index_name == "PRIMARY") {
+        indexRow.is_primary_key = true
+      } else {
+        indexRow.is_primary_key = false
+      }
+
+      const index = new ColumnsIndex(this, indexRow)
+
+      indexes.push(index)
+    }
+
+    return indexes
+  }
+
   getName() {
     return Object.values(this.data)[0]
   }

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

@@ -1,10 +1,7 @@
+import BaseForeignKey from "../base-foreign-key.js"
 import {digg} from "diggerize"
 
-export default class VelociousDatabaseDriversPgsqlForeignKey {
-  constructor(data) {
-    this.data = data
-  }
-
+export default class VelociousDatabaseDriversPgsqlForeignKey extends BaseForeignKey {
   getColumnName = () => digg(this, "data", "column_name")
   getName = () => digg(this, "data", "constraint_name")
   getTableName = () => digg(this, "data", "table_name")

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

@@ -1,5 +1,6 @@
 import BaseTable from "../base-table.js"
 import Column from "./column.js"
+import ColumnsIndex from "./columns-index.js"
 import ForeignKey from "./foreign-key.js"
 
 export default class VelociousDatabaseDriversPgsqlTable extends BaseTable {
@@ -43,10 +44,10 @@ export default class VelociousDatabaseDriversPgsqlTable extends BaseTable {
       WHERE
         constraint_type = 'FOREIGN KEY' AND
         tc.table_catalog = CURRENT_DATABASE() AND
-        tc.table_name = ${this.driver.quote(this.getName())}
+        tc.table_name = ${this.getDriver().quote(this.getName())}
     `
 
-    const foreignKeyRows = await this.driver.query(sql)
+    const foreignKeyRows = await this.getDriver().query(sql)
     const foreignKeys = []
 
     for (const foreignKeyRow of foreignKeyRows) {
@@ -58,6 +59,35 @@ export default class VelociousDatabaseDriversPgsqlTable extends BaseTable {
     return foreignKeys
   }
 
+  async getIndexes() {
+    const options = this.getOptions()
+
+    const indexesRows = await this.getDriver().query(`
+      SELECT
+        pg_attribute.attname AS column_name,
+        pg_index.indexrelid::regclass as index_name,
+        pg_class.relnamespace::regnamespace as schema_name,
+        pg_class.relname as table_name,
+        pg_index.indisprimary as is_primary_key,
+        pg_index.indisunique as is_unique
+      FROM pg_index
+      JOIN pg_class ON pg_class.oid = pg_index.indrelid
+      JOIN pg_attribute ON pg_attribute.attrelid = pg_class.oid AND pg_attribute.attnum = ANY(pg_index.indkey)
+      WHERE
+        pg_class.relname = ${options.quote(this.getName())}
+    `)
+
+    const indexes = []
+
+    for (const indexRow of indexesRows) {
+      const columnsIndex = new ColumnsIndex(this, indexRow)
+
+      indexes.push(columnsIndex)
+    }
+
+    return indexes
+  }
+
   getName() {
     return this.data.table_name
   }

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

@@ -1,8 +1,8 @@
 import BaseColumnsIndex from "../base-columns-index.js"
 import {digg} from "diggerize"
-import {TableIndex} from "../../table-data/index.js"
+import TableIndex from "../../table-data/table-index.js"
 
-export default class VelociousDatabaseDriversSqliteColumn extends BaseColumnsIndex {
+export default class VelociousDatabaseDriversSqliteColumnsIndex extends BaseColumnsIndex {
   constructor(table, data) {
     super()
     this.data = data

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

@@ -1,14 +1,15 @@
+import BaseForeignKey from "../base-foreign-key.js"
 import {digg} from "diggerize"
 
-export default class VelociousDatabaseDriversSqliteForeignKey {
+export default class VelociousDatabaseDriversSqliteForeignKey extends BaseForeignKey {
   constructor(data, {tableName}) {
-    this.data = data
+    super(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")
+  getColumnName() { return digg(this, "data", "from") }
+  getName() { return `${this.getTableName()}_${this.getColumnName()}_${this.data.id}` }
+  getTableName() { return digg(this, "tableName") }
+  getReferencedColumnName() { return digg(this, "data", "to") }
+  getReferencedTableName() { return digg(this, "data", "table") }
 }

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

@@ -45,5 +45,7 @@ export default class VelociousDatabaseDriversSqliteWeb extends Base {
     return `VelociousDatabaseDriversSqliteWeb---${this.args.name}`
   }
 
-  query = async (sql) => await this.getConnection().query(sql)
+  query = async (sql) => {
+    return await this.getConnection().query(sql)
+  }
 }

package/src/database/drivers/sqlite/sql/alter-table.js

@@ -1,6 +1,8 @@
 import AlterTableBase from "../../../query/alter-table-base.js"
 import CreateIndexBase from "../../../query/create-index-base.js"
 import {digs} from "diggerize"
+import * as inflection from "inflection"
+import {Logger} from "../../../../logger.js"
 import restArgsError from "../../../../utils/rest-args-error.js"
 import TableData from "../../../table-data/index.js"
 
@@ -11,6 +13,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
     if (!(tableData instanceof TableData)) throw new Error("Invalid table data was given")
 
     super({driver, tableData})
+    this.logger = new Logger(this)
     this.tableData = tableData
   }
 
@@ -21,7 +24,15 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
     const options = this.getOptions()
     const tableName = tableData.getName()
     const tempTableName = `${tableData.getName()}AlterTableTemp`
+    const newColumnNames = currentTableData.getColumns()
+      .filter((column) => !column.isNewColumn())
+      .map((column) => {
+        const newTableColumn = tableData.getColumns().find((tableColumn) => tableColumn.getName() == column.getName())
+
+        return newTableColumn?.getNewName() || newTableColumn?.getName() || column.getNewName() || column.getName()
+      })
     const oldColumnNames = currentTableData.getColumns().filter((column) => !column.isNewColumn()).map((column) => column.getName())
+    const newColumnsSQL = newColumnNames.map((name) => options.quoteColumnName(name)).join(", ")
     const oldColumnsSQL = oldColumnNames.map((name) => options.quoteColumnName(name)).join(", ")
 
     tableData.setName(tempTableName)
@@ -29,13 +40,71 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
     const newTableData = new TableData(tempTableName)
 
     for (const tableDataColumn of currentTableData.getColumns()) {
-      const newTableDataColumn = newTableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == tableDataColumn.getName())
+      const newTableDataColumn = tableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == tableDataColumn.getName())
+
+      if (newTableDataColumn) {
+        const settingsToClone = ["autoIncrement", "default", "index", "foreignKey", "maxLength", "primaryKey", "type"]
+
+        for (const settingToClone of settingsToClone) {
+          const camelizedSettingToClone = inflection.camelize(settingToClone)
+
+          if (!newTableDataColumn[`get${camelizedSettingToClone}`]) {
+            throw new Error(`No such method on column: get${camelizedSettingToClone}`)
+          }
+
+          if (!newTableDataColumn[`get${camelizedSettingToClone}`]()) {
+            newTableDataColumn[`set${camelizedSettingToClone}`](tableDataColumn[`get${camelizedSettingToClone}`]())
+          }
+        }
+      }
 
       newTableData.addColumn(newTableDataColumn || tableDataColumn)
     }
 
+    for (const tableDataColumn of tableData.getColumns()) {
+      if (!tableDataColumn.isNewColumn()) continue
+
+      newTableData.addColumn(tableDataColumn)
+    }
+
+    const foundForeignKeys = []
+
+    for (const tableDataForeignKey of currentTableData.getForeignKeys()) {
+      const newTableDataForeignKey = newTableData.getForeignKeys().find((newTableDataForeignKey) => newTableDataForeignKey.getName() == tableDataForeignKey.getName())
+
+      if (newTableDataForeignKey) foundForeignKeys.push(newTableDataForeignKey.getName())
+
+      const actualTableDataForeignKey = newTableDataForeignKey || tableDataForeignKey
+
+      // Register foreign key on the table
+      newTableData.addForeignKey(actualTableDataForeignKey)
+
+      // Register foreign key on the column
+      const tableDataColumn = newTableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == actualTableDataForeignKey.getColumnName())
+
+      if (!tableDataColumn) throw new Error(`Couldn't find column for foreign key: ${actualTableDataForeignKey.getName()}`)
+
+      this.logger.debug(() => [`Setting foreign key on column ${tableDataColumn.getName()}`])
+      tableDataColumn.setForeignKey(actualTableDataForeignKey)
+    }
+
+    for (const foreignKey of tableData.getForeignKeys()) {
+      if (foundForeignKeys.includes(foreignKey.getName())) continue
+
+      // Register foreign key on the table
+      newTableData.addForeignKey(foreignKey)
+
+      // Register foreign key on the column
+      const tableDataColumn = newTableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == foreignKey.getColumnName())
+
+      if (!tableDataColumn) throw new Error(`Couldn't find column for foreign key: ${actualTableDataForeignKey.getName()}`)
+
+      this.logger.debug(() => [`Setting foreign key on column ${tableDataColumn.getName()}`])
+      tableDataColumn.setForeignKey(actualTableDataForeignKey)
+    }
+
     const createNewTableSQL = this.getDriver().createTableSql(newTableData)
-    const insertSQL = `INSERT INTO ${options.quoteTableName(tempTableName)} (${oldColumnsSQL}) SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(tableName)}`
+    const insertSQL = `INSERT INTO ${options.quoteTableName(tempTableName)} (${newColumnsSQL}) SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(tableName)}`
     const dropTableSQL = `DROP TABLE ${options.quoteTableName(tableName)}`
     const renameTableSQL = `ALTER TABLE ${options.quoteTableName(tempTableName)} RENAME TO ${options.quoteTableName(tableName)}`
     const sqls = []
@@ -54,10 +123,14 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
 
       newTableData.addIndex(actualTableIndex)
 
-      console.log({actualTableIndex})
+      const columnNames = actualTableIndex.getColumns().map((columnName) => {
+        const newTableColumn = tableData.getColumns().find((tableColumn) => tableColumn.getName() == columnName)
+
+        return newTableColumn?.getNewName() || newTableColumn?.getName() || columnName
+      })
 
       const createIndexArgs = {
-        columns: actualTableIndex.getColumns(),
+        columns: columnNames,
         driver: this.getDriver(),
         name: actualTableIndex.getName(),
         tableName,
@@ -68,8 +141,6 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
       sqls.push(sql)
     }
 
-    console.log({sqls})
-
     return sqls
   }
 }

package/src/database/migration/index.js

@@ -1,6 +1,6 @@
 import * as inflection from "inflection"
 import restArgsError from "../../utils/rest-args-error.js"
-import TableData, {TableColumn} from "../table-data/index.js"
+import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseMigration {
   static onDatabases(databaseIdentifiers) {
@@ -29,15 +29,17 @@ export default class VelociousDatabaseMigration {
   getDriver() { return this._db }
 
   async addColumn(tableName, columnName, columnType, args) {
-    const tableColumnArgs = Object.assign({type: columnType}, args)
+    if (!columnType) throw new Error("No column type given")
+
+    const tableColumnArgs = Object.assign({isNewColumn: true, type: columnType}, args)
     const tableData = new TableData(tableName)
 
     tableData.addColumn(columnName, tableColumnArgs)
 
-    const sqls = await this._db.alterTableSql(tableData)
+    const sqls = await this.getDriver().alterTableSql(tableData)
 
     for (const sql of sqls) {
-      await this._db.query(sql)
+      await this.getDriver().query(sql)
     }
   }
 
@@ -49,9 +51,9 @@ export default class VelociousDatabaseMigration {
       },
       args
     )
-    const sql = this._db.createIndexSql(createIndexArgs)
+    const sql = this.getDriver().createIndexSql(createIndexArgs)
 
-    await this._db.query(sql)
+    await this.getDriver().query(sql)
   }
 
   async addForeignKey(tableName, referenceName) {
@@ -66,16 +68,19 @@ export default class VelociousDatabaseMigration {
     sql += ` FOREIGN KEY (${this._db.quoteColumn(columnName)})`
     sql += ` REFERENCES ${tableNameUnderscore}(id)`
 
-    await this._db.query(sql)
+    await this.getDriver().query(sql)
   }
 
   async addReference(tableName, referenceName, args) {
+    const {foreignKey, type, unique, ...restArgs} = args
     const columnName = `${inflection.underscore(referenceName)}_id`
 
-    await this.addColumn(tableName, columnName, {type: args?.type})
-    await this.addIndex(tableName, [columnName], {unique: args?.unique})
+    restArgsError(restArgs)
+
+    await this.addColumn(tableName, columnName, type || "integer")
+    await this.addIndex(tableName, [columnName], {unique: unique})
 
-    if (args?.foreignKey) {
+    if (foreignKey) {
       await this.addForeignKey(tableName, referenceName)
     }
   }
@@ -118,15 +123,19 @@ export default class VelociousDatabaseMigration {
       callback(tableData)
     }
 
-    const sqls = this._db.createTableSql(tableData)
+    const sqls = this.getDriver().createTableSql(tableData)
 
     for (const sql of sqls) {
       await this._db.query(sql)
     }
   }
 
+  async renameColumn(tableName, oldColumnName, newColumnName) {
+    await this.getDriver().renameColumn(tableName, oldColumnName, newColumnName)
+  }
+
   async tableExists(tableName) {
-    const exists = await this._db.tableExists(tableName)
+    const exists = await this.getDriver().tableExists(tableName)
 
     return exists
   }

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

@@ -27,15 +27,20 @@ export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
 
       if (column.isNewColumn()) {
         sql += "ADD "
+        sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
+      } else if (column.getNewName()) {
+        sql += `RENAME COLUMN ${options.quoteColumnName(column.getName())} TO ${options.quoteColumnName(column.getNewName())}`
       } else {
         if (databaseType == "mssql" || databaseType == "pgsql") {
           sql += "ALTER COLUMN "
         } else {
           sql += "MODIFY "
         }
+
+        sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
       }
 
-      sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
+
       columnsCount++
     }
 

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

@@ -12,7 +12,10 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
   }
 
   generateIndexName() {
-    let indexName = `index_on_${this.tableName}_`
+    const databaseType = this.getDriver().getType()
+    let indexName = `index_on_`
+
+    if (databaseType == "sqlite") indexName += `${this.tableName}_`
 
     for (const columnIndex in this.columns) {
       if (columnIndex > 0) indexName += "_and_"
@@ -33,17 +36,34 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
   }
 
   toSql() {
+    const databaseType = this.getDriver().getType()
+    const indexName = this.name || this.generateIndexName()
     const options = this.getOptions()
     const {tableName} = this
-    let sql = "CREATE"
+    let sql = ""
+
+    if (this.ifNotExists && databaseType == "mssql") {
+      sql += `
+        IF NOT EXISTS (
+          SELECT 1
+          FROM sys.indexes
+          WHERE
+            name = ${options.quote(indexName)} AND
+            object_id = OBJECT_ID(${options.quote(`dbo.${tableName}`)})
+        )
+        BEGIN
+      `
+    }
+
+    sql += "CREATE"
 
     if (this.unique) sql += " UNIQUE"
 
     sql += " INDEX"
 
-    if (this.ifNotExists) sql += " IF NOT EXISTS"
+    if (this.ifNotExists && databaseType != "mssql") sql += " IF NOT EXISTS"
 
-    sql += ` ${options.quoteIndexName(this.name || this.generateIndexName())}`
+    sql += ` ${options.quoteIndexName(indexName)}`
     sql += ` ON ${options.quoteTableName(tableName)} (`
 
     for (const columnIndex in this.columns) {
@@ -63,6 +83,10 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
 
     sql += ")"
 
+    if (this.ifNotExists && databaseType == "mssql") {
+      sql += " END"
+    }
+
     return sql
   }
 }

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

@@ -68,10 +68,15 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         sql += ")"
       }
 
+      // Create indexes for all columns with the index argument
       for (const column of tableData.getColumns()) {
         if (!column.getIndex()) continue
 
-        const indexName = `index_on_${tableData.getName()}_${column.getName()}`
+        let indexName = `index_on_`
+
+        if (databaseType == "sqlite") sql += `${tableData.getName()}_`
+
+        indexName += column.getName()
 
         sql += ","
 
@@ -100,6 +105,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         const createIndexArgs = {
           columns: index.getColumns(),
           driver: this.getDriver(),
+          ifNotExists: true,
           name: index.getName(),
           tableName: tableData.getName(),
           unique: index.getUnique()
@@ -109,14 +115,20 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         sqls.push(sql)
       }
 
+      // Create indexes for all columns with the index argument
       for (const column of tableData.getColumns()) {
         if (!column.getIndex()) continue
 
-        const indexName = `index_on_${tableData.getName()}_${column.getName()}`
         const {unique, ...restIndexArgs} = column.getIndex()
 
         restArgsError(restIndexArgs)
 
+        let indexName = `index_on_`
+
+        if (databaseType == "sqlite") indexName += `${tableData.getName()}_`
+
+        indexName += column.getName()
+
         const createIndexArgs = {
           columns: [column.getName()],
           driver: this.getDriver(),

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

@@ -1,152 +1,10 @@
-import * as inflection from "inflection"
-import restArgsError from "../../utils/rest-args-error.js"
-
-class TableColumn {
-  constructor(name, args) {
-    if (args) {
-      const {autoIncrement, default: columnDefault, foreignKey, index, isNewColumn, maxLength, name, null: argsNull, primaryKey, type, ...restArgs} = args
-
-      if (Object.keys(args).length == 0) {
-        throw new Error("Empty args given")
-      }
-
-      restArgsError(restArgs)
-    }
-
-    this.args = args
-    this.name = name
-  }
-
-  getAutoIncrement() { return this.args?.autoIncrement }
-  getDefault() { return this.args?.default }
-  getForeignKey() { return this.args?.foreignKey }
-  getIndex() { return this.args?.index }
-  getMaxLength() { return this.args?.maxLength }
-  getName() { return this.name }
-  getNull() { return this.args?.null }
-  setNull(nullable) { this.args.null = nullable }
-  getPrimaryKey() { return this.args?.primaryKey }
-  getType() { return this.args?.type }
-  isNewColumn() { return this.args?.isNewColumn }
-
-  getSQL({forAlterTable, driver}) {
-    const databaseType = driver.getType()
-    const options = driver.options()
-    let maxlength = this.getMaxLength()
-    let type = this.getType().toUpperCase()
-
-    if (type == "DATETIME" && databaseType == "pgsql") {
-      type = "TIMESTAMP"
-    }
-
-    if (type == "STRING") {
-      type = "VARCHAR"
-      maxlength ||= 255
-    }
-
-    if (databaseType == "mssql" && type == "BOOLEAN") {
-      type = "BIT"
-    } else if (databaseType == "mssql" && type == "UUID") {
-      type = "VARCHAR"
-      maxlength ||= 36
-    }
-
-    if (databaseType == "sqlite" && this.getAutoIncrement() && this.getPrimaryKey()) {
-      type = "INTEGER"
-    }
-
-    if (databaseType == "pgsql" && this.getAutoIncrement() && this.getPrimaryKey()) {
-      type = "SERIAL"
-    }
-
-    let sql = `${options.quoteColumnName(this.getName())} `
-
-    if (databaseType == "pgsql" && forAlterTable) sql += "TYPE "
-
-    sql += type
-
-    if (maxlength !== undefined && maxlength !== null) sql += `(${maxlength})`
-
-    if (this.getAutoIncrement() && driver.shouldSetAutoIncrementWhenPrimaryKey()) {
-      if (databaseType == "mssql") {
-        sql += " IDENTITY"
-      } else if (databaseType == "pgsql") {
-        if (this.getAutoIncrement() && this.getPrimaryKey()) {
-          // Do nothing
-        } else {
-          throw new Error("pgsql auto increment must be primary key")
-        }
-      } else {
-        sql += " AUTO_INCREMENT"
-      }
-    }
-
-    if (typeof this.getDefault() == "function") {
-      const defaultValue = this.getDefault()()
-
-      sql += ` DEFAULT (`
-
-      if (databaseType == "pgsql" && defaultValue == "UUID()") {
-        sql += "gen_random_uuid()"
-      } else if (databaseType == "mssql" && defaultValue == "UUID()") {
-        sql += "NEWID()"
-      } else {
-        sql += defaultValue
-      }
-
-      sql += ")"
-    } else if (this.getDefault()) {
-      sql += ` DEFAULT ${options.quote(this.getDefault())}`
-    }
-
-    if (this.getPrimaryKey()) sql += " PRIMARY KEY"
-    if (this.getNull() === false) sql += " NOT NULL"
-
-    if (this.getForeignKey()) {
-      let foreignKeyTable, foreignKeyColumn
-
-      if (this.getForeignKey() === true) {
-        foreignKeyColumn = "id"
-        foreignKeyTable = inflection.pluralize(this.getName().replace(/_id$/, ""))
-      } else {
-        throw new Error(`Unknown foreign key type given: ${this.getForeignKey()} (${typeof this.getForeignKey()})`)
-      }
-
-      sql += ` REFERENCES ${options.quoteTableName(foreignKeyTable)}(${options.quoteColumnName(foreignKeyColumn)})`
-    }
-
-    return sql
-  }
-}
-
-class TableIndex {
-  constructor(columns, args) {
-    if (args) {
-      const {name, unique, ...restArgs} = args
-
-      restArgsError(restArgs)
-    }
-
-    this.args = args
-    this.columns = columns
-  }
-
-  getColumns() { return this.columns }
-  getName() { return this.args.name }
-  getUnique() { return Boolean(this.args.unique) }
-}
-
-class TableReference {
-  constructor(name, args) {
-    this.args = args
-    this.name = name
-  }
-}
-
-export {TableColumn, TableIndex}
+import TableColumn from "./table-column.js"
+import TableIndex from "./table-index.js"
+import TableReference from "./table-reference.js"
 
 export default class TableData {
   _columns = []
+  _foreignKeys = []
   _indexes = []
   _references = []
 
@@ -167,12 +25,17 @@ export default class TableData {
     }
   }
 
-  addIndex(index) { this._indexes.push(index) }
   getColumns() { return this._columns }
+
+  addForeignKey(foreignKey) { this._foreignKeys.push(foreignKey) }
+  getForeignKeys() { return this._foreignKeys }
+
+  addIndex(index) { this._indexes.push(index) }
+  getIndexes() { return this._indexes }
+
   getName() { return this._name }
   setName(newName) { this._name = newName }
   getIfNotExists() { return this.args.ifNotExists }
-  getIndexes() { return this._indexes }
   getReferences() { return this._references }
 
   bigint(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "bigint"}, args)) }
@@ -184,11 +47,10 @@ export default class TableData {
 
   references(name, args = {}) {
     const columnName = `${name}_id`
-    const indexName = `index_on_${this.getName()}_${columnName}`
     const reference = new TableReference(name, args)
     const columnArgs = Object.assign({isNewColumn: true, type: "bigint"}, args)
     const column = new TableColumn(columnName, columnArgs)
-    const index = new TableIndex([column], {name: indexName})
+    const index = new TableIndex([column])
 
     this._columns.push(column)
     this._indexes.push(index)

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

@@ -0,0 +1,145 @@
+import * as inflection from "inflection"
+import restArgsError from "../../utils/rest-args-error.js"
+import TableForeignKey from "./table-foreign-key.js"
+
+export default class TableColumn {
+  constructor(name, args) {
+    if (args) {
+      const {autoIncrement, default: columnDefault, foreignKey, index, isNewColumn, maxLength, name, null: argsNull, primaryKey, type, ...restArgs} = args
+
+      if (Object.keys(args).length == 0) {
+        throw new Error("Empty args given")
+      }
+
+      restArgsError(restArgs)
+    }
+
+    this.args = args || {}
+    this.name = name
+  }
+
+  getName() { return this.name }
+
+  getNewName() { return this._newName }
+  setNewName(newName) { this._newName = newName }
+
+  getActualName() { return this.getNewName() || this.getName() }
+
+  getAutoIncrement() { return this.args?.autoIncrement }
+  setAutoIncrement(newAutoIncrement) { this.args.autoIncrement = newAutoIncrement }
+
+  getDefault() { return this.args?.default }
+  setDefault(newDefault) { this.args.default = newDefault }
+
+  getForeignKey() { return this.args?.foreignKey }
+  setForeignKey(newForeignKey) { this.args.foreignKey = newForeignKey }
+
+  getIndex() { return this.args?.index }
+  setIndex(newIndex) { this.args.index = newIndex }
+
+  getMaxLength() { return this.args?.maxLength }
+  setMaxLength(newMaxLength) { this.args.maxLength = newMaxLength }
+
+  getNull() { return this.args?.null }
+  setNull(nullable) { this.args.null = nullable }
+
+  getPrimaryKey() { return this.args?.primaryKey }
+  setPrimaryKey(newPrimaryKey) { this.args.primaryKey = newPrimaryKey }
+
+  getType() { return this.args?.type }
+  setType(newType) { this.args.type = newType }
+
+  isNewColumn() { return this.args?.isNewColumn }
+
+  getSQL({forAlterTable, driver}) {
+    const databaseType = driver.getType()
+    const options = driver.options()
+    let maxlength = this.getMaxLength()
+    let type = this.getType()?.toUpperCase()
+
+    if (type == "DATETIME" && databaseType == "pgsql") {
+      type = "TIMESTAMP"
+    }
+
+    if (type == "STRING") {
+      type = "VARCHAR"
+      maxlength ||= 255
+    }
+
+    if (databaseType == "mssql" && type == "BOOLEAN") {
+      type = "BIT"
+    } else if (databaseType == "mssql" && type == "UUID") {
+      type = "VARCHAR"
+      maxlength ||= 36
+    }
+
+    if (databaseType == "sqlite" && this.getAutoIncrement() && this.getPrimaryKey()) {
+      type = "INTEGER"
+    }
+
+    if (databaseType == "pgsql" && this.getAutoIncrement() && this.getPrimaryKey()) {
+      type = "SERIAL"
+    }
+
+    let sql = `${options.quoteColumnName(this.getActualName())} `
+
+    if (databaseType == "pgsql" && forAlterTable) sql += "TYPE "
+    if (type) sql += type
+    if (type && maxlength !== undefined && maxlength !== null) sql += `(${maxlength})`
+
+    if (this.getAutoIncrement() && driver.shouldSetAutoIncrementWhenPrimaryKey()) {
+      if (databaseType == "mssql") {
+        sql += " IDENTITY"
+      } else if (databaseType == "pgsql") {
+        if (this.getAutoIncrement() && this.getPrimaryKey()) {
+          // Do nothing
+        } else {
+          throw new Error("pgsql auto increment must be primary key")
+        }
+      } else {
+        sql += " AUTO_INCREMENT"
+      }
+    }
+
+    if (typeof this.getDefault() == "function") {
+      const defaultValue = this.getDefault()()
+
+      sql += ` DEFAULT (`
+
+      if (databaseType == "pgsql" && defaultValue == "UUID()") {
+        sql += "gen_random_uuid()"
+      } else if (databaseType == "mssql" && defaultValue == "UUID()") {
+        sql += "NEWID()"
+      } else {
+        sql += defaultValue
+      }
+
+      sql += ")"
+    } else if (this.getDefault()) {
+      sql += ` DEFAULT ${options.quote(this.getDefault())}`
+    }
+
+    if (this.getPrimaryKey()) sql += " PRIMARY KEY"
+    if (this.getNull() === false) sql += " NOT NULL"
+
+    const foreignKey = this.getForeignKey()
+
+    if (foreignKey) {
+      let foreignKeyTable, foreignKeyColumn
+
+      if (foreignKey === true) {
+        foreignKeyColumn = "id"
+        foreignKeyTable = inflection.pluralize(this.getActualName().replace(/_id$/, ""))
+      } else if (foreignKey instanceof TableForeignKey) {
+        foreignKeyColumn = foreignKey.getReferencedColumnName()
+        foreignKeyTable = foreignKey.getReferencedTableName()
+      } else {
+        throw new Error(`Unknown foreign key type given: ${this.getForeignKey()} (${typeof this.getForeignKey()})`)
+      }
+
+      sql += ` REFERENCES ${options.quoteTableName(foreignKeyTable)}(${options.quoteColumnName(foreignKeyColumn)})`
+    }
+
+    return sql
+  }
+}

package/src/database/table-data/table-foreign-key.js

@@ -0,0 +1,21 @@
+import restArgsError from "../../utils/rest-args-error.js"
+
+export default class TableForeignKey {
+  constructor({columnName, name, tableName, referencedColumnName, referencedTableName, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this._columnName = columnName
+    this._name = name
+    this._tableName = tableName
+    this._referencedColumnName = referencedColumnName
+    this._referencedTableName = referencedTableName
+  }
+
+  getColumnName() { return this._columnName }
+  getTableName() { return this._tableName }
+  getReferencedColumnName() { return this._referencedColumnName }
+  getReferencedTableName() { return this._referencedTableName }
+
+  getName() { return this._name }
+  setName(newName) { this._name = newName }
+}

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

@@ -0,0 +1,18 @@
+import restArgsError from "../../utils/rest-args-error.js"
+
+export default class TableIndex {
+  constructor(columns, args) {
+    if (args) {
+      const {name, unique, ...restArgs} = args
+
+      restArgsError(restArgs)
+    }
+
+    this.args = args
+    this.columns = columns
+  }
+
+  getColumns() { return this.columns }
+  getName() { return this.args?.name }
+  getUnique() { return Boolean(this.args?.unique) }
+}

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

@@ -0,0 +1,6 @@
+export default class TableReference {
+  constructor(name, args) {
+    this.args = args
+    this.name = name
+  }
+}