velocious 1.0.46 → 1.0.47

package/package.json

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

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

@@ -43,9 +43,9 @@ describe("Cli - Commands - db:migrate", () => {
       // It creates unique indexes
       const authenticationTokensTable = await dbs.default.getTableByName("authentication_tokens")
       const tokenColumn = await authenticationTokensTable.getColumnByName("token")
-      const tokenIndex = await tokenColumn.getIndexByName("index_on_token")
+      const tokenIndex = await tokenColumn.getIndexByName("index_on_authentication_tokens_token")
 
-      expect(tokenIndex.getName()).toEqual("index_on_token")
+      expect(tokenIndex.getName()).toEqual("index_on_authentication_tokens_token")
       expect(tokenIndex.isPrimaryKey()).toBeFalse()
       expect(tokenIndex.isUnique()).toBeTrue()
 
@@ -64,8 +64,6 @@ describe("Cli - Commands - db:migrate", () => {
       }
     })
 
-
-
     expect(projectForeignKey.getTableName()).toEqual("tasks")
     expect(projectForeignKey.getColumnName()).toEqual("project_id")
     expect(projectForeignKey.getReferencedTableName()).toEqual("projects")
@@ -84,7 +82,15 @@ describe("Cli - Commands - db:migrate", () => {
         ]
       )
 
-      expect(uniqunize(defaultSchemaMigrations.sort())).toEqual(["20230728075328", "20230728075329", "20250605133926", "20250903112845", "20250912183605", "20250912183606"])
+      expect(uniqunize(defaultSchemaMigrations.sort())).toEqual([
+        "20230728075328",
+        "20230728075329",
+        "20250605133926",
+        "20250903112845",
+        "20250912183605",
+        "20250912183606",
+        "20250915085450"
+      ])
     } else {
       expect(tablesResult.sort()).toEqual(
         [
@@ -99,7 +105,7 @@ describe("Cli - Commands - db:migrate", () => {
         ]
       )
 
-      expect(defaultSchemaMigrations.sort()).toEqual(["20230728075328", "20230728075329", "20250605133926", "20250903112845", "20250912183605", "20250912183606"])
+      expect(defaultSchemaMigrations.sort()).toEqual(["20230728075328", "20230728075329", "20250605133926", "20250903112845", "20250912183605", "20250912183606", "20250915085450"])
     }
   })
 })

package/spec/dummy/src/database/migrations/20250915085450-change-authentication-tokens-user-id-nullable.js

@@ -0,0 +1,11 @@
+import Migration from "../../../../../src/database/migration/index.js"
+
+export default class ChangeAuthenticationTokensUserIdNullable extends Migration {
+  async up() {
+    await this.changeColumnNull("authentication_tokens", "user_id", true)
+  }
+
+  async down() {
+    await this.changeColumnNull("authentication_tokens", "user_id", false)
+  }
+}

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

@@ -1,3 +1,5 @@
+import TableData, {TableColumn} from "../table-data/index.js"
+
 export default class VelociousDatabaseDriversBaseColumn {
   async getIndexByName(indexName) {
     const indexes = await this.getIndexes()
@@ -6,6 +8,23 @@ export default class VelociousDatabaseDriversBaseColumn {
     return index
   }
 
+  async changeNullable(nullable) {
+    const tableData = new TableData(this.getTable().getName())
+    const column = this.getTableDataColumn()
+
+    column.setNull(nullable)
+
+    tableData.addColumn(column)
+
+    const sqls = await this.getDriver().alterTableSql(tableData)
+
+    console.log({sqls})
+
+    for (const sql of sqls) {
+      await this.getDriver().query(sql)
+    }
+  }
+
   getDriver() {
     return this.getTable().getDriver()
   }
@@ -19,4 +38,14 @@ export default class VelociousDatabaseDriversBaseColumn {
 
     return this.table
   }
+
+  getTableDataColumn() {
+    return new TableColumn(this.getName(), {
+      default: this.getDefault(),
+      isNewColumn: false,
+      maxLength: this.getMaxLength(),
+      null: this.getNull(),
+      type: this.getType()
+    })
+  }
 }

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

@@ -1,4 +1,5 @@
 import {digg} from "diggerize"
+import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseDriversBaseTable {
   async getColumnByName(columnName) {
@@ -18,6 +19,20 @@ export default class VelociousDatabaseDriversBaseTable {
     return this.getDriver().options()
   }
 
+  async getTableData() {
+    const tableData = new TableData(this.getName())
+
+    for (const column of await this.getColumns()) {
+      tableData.addColumn(column.getTableDataColumn())
+    }
+
+    for (const index of await this.getIndexes()) {
+      tableData.addIndex(index.getTableDataIndex())
+    }
+
+    return tableData
+  }
+
   async rowsCount() {
     const result = await this.getDriver().query(`SELECT COUNT(*) AS count FROM ${this.getOptions().quoteTableName(this.getName())}`)
 

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

@@ -45,7 +45,29 @@ export default class VelociousDatabaseDriversMssqlColumn extends BaseColumn {
     return indexes
   }
 
+  getDefault() {
+    return digg(this, "data", "COLUMN_DEFAULT")
+  }
+
+  getMaxLength() {
+    return digg(this, "data", "CHARACTER_MAXIMUM_LENGTH")
+  }
+
   getName() {
     return digg(this, "data", "COLUMN_NAME")
   }
+
+  getNull() {
+    const nullValue = digg(this, "data", "IS_NULLABLE")
+
+    if (nullValue == "NO") {
+      return false
+    } else {
+      return true
+    }
+  }
+
+  getType() {
+    return digg(this, "data", "DATA_TYPE")
+  }
 }

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

@@ -1,3 +1,4 @@
+import AlterTable from "./sql/alter-table.js"
 import Base from "../base.js"
 import CreateDatabase from "./sql/create-database.js"
 import CreateIndex from "./sql/create-index.js"
@@ -32,6 +33,13 @@ export default class VelociousDatabaseDriversMssql extends Base{
     this.connection = undefined
   }
 
+  async alterTableSql(tableData) {
+    const alterArgs = {tableData, driver: this}
+    const alterTable = new AlterTable(alterArgs)
+
+    return await alterTable.toSqls()
+  }
+
   createDatabaseSql(databaseName, args) {
     const createArgs = Object.assign({databaseName, driver: this}, args)
     const createDatabase = new CreateDatabase(createArgs)
@@ -47,7 +55,7 @@ export default class VelociousDatabaseDriversMssql extends Base{
   }
 
   createTableSql(tableData) {
-    const createArgs = Object.assign({tableData, driver: this, indexInCreateTable: false})
+    const createArgs = {tableData, driver: this, indexInCreateTable: false}
     const createTable = new CreateTable(createArgs)
 
     return createTable.toSql()

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

@@ -0,0 +1,4 @@
+import AlterTableBase from "../../../query/alter-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlAlterTable extends AlterTableBase {
+}

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

@@ -11,7 +11,7 @@ export default class VelociousDatabaseDriversMssqlTable extends BaseTable {
   }
 
   async getColumns() {
-    const result = await this.driver.query(`SELECT [COLUMN_NAME] FROM [INFORMATION_SCHEMA].[COLUMNS] WHERE [TABLE_NAME] = ${this.driver.quote(this.getName())}`)
+    const result = await this.driver.query(`SELECT * FROM [INFORMATION_SCHEMA].[COLUMNS] WHERE [TABLE_NAME] = ${this.driver.quote(this.getName())}`)
     const columns = []
 
     for (const data of result) {

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

@@ -49,5 +49,38 @@ export default class VelociousDatabaseDriversMysqlColumn extends BaseColumn {
     return indexes
   }
 
-  getName = () => digg(this, "data", "Field")
+  getDefault() { return digg(this, "data", "Default") }
+
+  getMaxLength() {
+    const type = digg(this, "data", "Type")
+    const match = type.match(/\((\d+)\)$/)
+
+    if (match) {
+      const maxLength = parseInt(match[1])
+
+      return maxLength
+    }
+  }
+
+  getName() { return digg(this, "data", "Field") }
+
+  getNull() {
+    const nullValue = digg(this, "data", "Null")
+
+    if (nullValue == "NO") {
+      return false
+    } else if (nullValue == "YES") {
+      return true
+    } else {
+      throw new Error(`Unknown null value: ${nullValue}`)
+    }
+  }
+
+  getType() {
+    const type = digg(this, "data", "Type")
+    const match = type.match(/^(.+)\((\d+)\)$/)
+    const columnType = match[1]
+
+    return columnType
+  }
 }

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

@@ -1,3 +1,4 @@
+import AlterTable from "./sql/alter-table.js"
 import Base from "../base.js"
 import connectConnection from "./connect-connection.js"
 import CreateDatabase from "./sql/create-database.js"
@@ -41,6 +42,13 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return connectArgs
   }
 
+  async alterTableSql(tableData) {
+    const alterArgs = {tableData, driver: this}
+    const alterTable = new AlterTable(alterArgs)
+
+    return await alterTable.toSqls()
+  }
+
   createDatabaseSql(databaseName, args) {
     const createArgs = Object.assign({databaseName, driver: this}, args)
     const createDatabase = new CreateDatabase(createArgs)
@@ -56,7 +64,7 @@ export default class VelociousDatabaseDriversMysql extends Base{
   }
 
   createTableSql(tableData) {
-    const createArgs = Object.assign({tableData, driver: this})
+    const createArgs = {tableData, driver: this}
     const createTable = new CreateTable(createArgs)
 
     return createTable.toSql()

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

@@ -0,0 +1,4 @@
+import AlterTableBase from "../../../query/alter-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlAlterTable extends AlterTableBase {
+}

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

@@ -39,7 +39,29 @@ export default class VelociousDatabaseDriversPgsqlColumn extends BaseColumn {
     return indexes
   }
 
+  getDefault() {
+    return digg(this, "data", "column_default")
+  }
+
+  getMaxLength() {
+    return digg(this, "data", "character_maximum_length")
+  }
+
   getName() {
     return digg(this, "data", "column_name")
   }
+
+  getNull() {
+    const nullValue = digg(this, "data", "is_nullable")
+
+    if (nullValue == "NO") {
+      return false
+    } else {
+      return true
+    }
+  }
+
+  getType() {
+    return digg(this, "data", "data_type")
+  }
 }

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

@@ -1,5 +1,6 @@
+import AlterTable from "./sql/alter-table.js"
 import Base from "../base.js"
-import {Client, escapeLiteral} from "pg"
+import {Client} from "pg"
 import CreateDatabase from "./sql/create-database.js"
 import CreateIndex from "./sql/create-index.js"
 import CreateTable from "./sql/create-table.js"
@@ -49,6 +50,13 @@ export default class VelociousDatabaseDriversPgsql extends Base{
     this.connection = undefined
   }
 
+  async alterTableSql(tableData) {
+    const alterArgs = {tableData, driver: this}
+    const alterTable = new AlterTable(alterArgs)
+
+    return await alterTable.toSqls()
+  }
+
   createDatabaseSql(databaseName, args) {
     const createArgs = Object.assign({databaseName, driver: this}, args)
     const createDatabase = new CreateDatabase(createArgs)
@@ -64,7 +72,7 @@ export default class VelociousDatabaseDriversPgsql extends Base{
   }
 
   createTableSql(tableData) {
-    const createArgs = Object.assign({tableData, driver: this, indexInCreateTable: false})
+    const createArgs = {tableData, driver: this, indexInCreateTable: false}
     const createTable = new CreateTable(createArgs)
 
     return createTable.toSql()

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

@@ -0,0 +1,4 @@
+import AlterTableBase from "../../../query/alter-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversPgsqlSqlAlterTable extends AlterTableBase {
+}

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

@@ -14,11 +14,11 @@ import Table from "./table.js"
 import Update from "./sql/update.js"
 
 export default class VelociousDatabaseDriversSqliteBase extends Base {
-  alterTableSql(columnData) {
-    const createArgs = Object.assign({driver: this}, columnData)
-    const alterTable = new AlterTable(createArgs)
+  async alterTableSql(tableData) {
+    const alterArgs = {driver: this, tableData}
+    const alterTable = new AlterTable(alterArgs)
 
-    return alterTable.toSqls()
+    return await alterTable.toSqls()
   }
 
   createIndexSql(indexData) {
@@ -29,7 +29,7 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   }
 
   createTableSql(tableData) {
-    const createArgs = Object.assign({tableData, driver: this, indexInCreateTable: false})
+    const createArgs = {tableData, driver: this, indexInCreateTable: false}
     const createTable = new CreateTable(createArgs)
 
     return createTable.toSql()

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

@@ -1,5 +1,5 @@
+import {digg} from "diggerize"
 import BaseColumn from "../base-column.js"
-import ColumnsIndex from "./columns-index.js"
 
 export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
   constructor({column, driver, table}) {
@@ -10,59 +10,51 @@ export default class VelociousDatabaseDriversSqliteColumn extends BaseColumn {
   }
 
   async getIndexes() {
-    const table = this.getTable()
-    const rows = await this.getDriver().query(`PRAGMA index_list(${this.getOptions().quoteTableName(table.getName())})`)
-    const indexes = []
+    const indexes = await this.getTable().getIndexes()
+    const indexesForColumn = indexes.filter((index) => index.getColumnNames().includes(this.getName()))
 
-    for (const row of rows) {
-      const columnsIndex = new ColumnsIndex(table, row)
-      const indexMasterData = await this.getDriver().query(`SELECT * FROM sqlite_master WHERE type = 'index' AND name = ${this.getOptions().quote(columnsIndex.getName())}`)
-
-      columnsIndex.columnNames = this._parseColumnsFromSQL(indexMasterData[0].sql)
-
-      indexes.push(columnsIndex)
-    }
+    return indexesForColumn
+  }
 
-    return indexes
+  getDefault() {
+    return digg(this, "column", "dflt_value")
   }
 
+  getName() {
+    const name = digg(this, "column", "name")
+
+    if (!name) throw new Error("No name given for SQLite column")
 
-  _parseColumnsFromSQL(sql) {
-    const columnsSQLMatch = sql.match(/\((.+?)\)/)
-    const columnsSQL = columnsSQLMatch[1].split(",")
-    const columnNames = []
+    return name
+  }
 
-    for (const column of columnsSQL) {
-      const matchTicks = column.match(/`(.+)`/)
-      const matchQuotes = column.match(/"(.+)"/)
+  getMaxLength() {
+    const columnType = digg(this, "column", "type")
+    const match = columnType.match(/(.*)\((\d+)\)$/)
 
-      if (matchTicks) {
-        columnNames.push(matchTicks[1])
-      } else if (matchQuotes) {
-        columnNames.push(matchQuotes[1])
-      } else{
-        throw new Error(`Couldn't parse column part: ${column}`)
-      }
+    if (match) {
+      return parseInt(match[2])
     }
-
-    return columnNames
   }
 
-  getName() {
-    if (!this.column.name) {
-      throw new Error("No name given for SQLite column")
-    }
+  getNull() {
+    const notNullValue = digg(this, "column", "notnull")
 
-    return this.column.name
+    if (notNullValue === 1) {
+      return false
+    } else {
+      return true
+    }
   }
 
   getType() {
-    const match = this.column.type.match(/(.*)\((\d+)\)$/)
+    const columnType = digg(this, "column", "type")
+    const match = columnType.match(/(.*)\((\d+)\)$/)
 
     if (match) {
       return match[1].toLowerCase()
     }
 
-    return this.column.type.toLowerCase()
+    return columnType.toLowerCase()
   }
 }

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

@@ -1,5 +1,6 @@
 import BaseColumnsIndex from "../base-columns-index.js"
 import {digg} from "diggerize"
+import {TableIndex} from "../../table-data/index.js"
 
 export default class VelociousDatabaseDriversSqliteColumn extends BaseColumnsIndex {
   constructor(table, data) {
@@ -8,10 +9,21 @@ export default class VelociousDatabaseDriversSqliteColumn extends BaseColumnsInd
     this.table = table
   }
 
+  getColumnNames() {
+    return digg(this, "data", "columnNames")
+  }
+
   getName() {
     return digg(this, "data", "name")
   }
 
+  getTableDataIndex() {
+    return new TableIndex(this.getColumnNames(), {
+      name: this.getName(),
+      unique: this.isUnique()
+    })
+  }
+
   isPrimaryKey() {
     return false
   }

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

@@ -34,7 +34,7 @@ export default class VelociousDatabaseDriversSqliteNode extends Base {
     this.connection = undefined
   }
 
-  query = async (sql) => {
+  async query(sql) {
     return await query(this.connection, sql)
   }
 }

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

@@ -1,5 +1,4 @@
 export default async function query(connection, sql) {
-  const rows = []
   let result
 
   try {
@@ -13,7 +12,7 @@ export default async function query(connection, sql) {
 
     error.message += `\n\n${sqlInErrorMessage}`
 
-    throw error
+    throw new Error(error.message)
   }
 
   return result

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

@@ -1,4 +1,75 @@
 import AlterTableBase from "../../../query/alter-table-base.js"
+import CreateIndexBase from "../../../query/create-index-base.js"
+import {digs} from "diggerize"
+import restArgsError from "../../../../utils/rest-args-error.js"
+import TableData from "../../../table-data/index.js"
 
-export default class VelociousDatabaseConnectionDriversMysqlSqlAlterTable extends AlterTableBase {
+export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable extends AlterTableBase {
+  constructor({driver, tableData, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!(tableData instanceof TableData)) throw new Error("Invalid table data was given")
+
+    super({driver, tableData})
+    this.tableData = tableData
+  }
+
+  async toSqls() {
+    const {tableData} = digs(this, "tableData")
+    const table = await this.getDriver().getTableByName(tableData.getName())
+    const currentTableData = await table.getTableData()
+    const options = this.getOptions()
+    const tableName = tableData.getName()
+    const tempTableName = `${tableData.getName()}AlterTableTemp`
+    const oldColumnNames = currentTableData.getColumns().filter((column) => !column.isNewColumn()).map((column) => column.getName())
+    const oldColumnsSQL = oldColumnNames.map((name) => options.quoteColumnName(name)).join(", ")
+
+    tableData.setName(tempTableName)
+
+    const newTableData = new TableData(tempTableName)
+
+    for (const tableDataColumn of currentTableData.getColumns()) {
+      const newTableDataColumn = newTableData.getColumns().find((newTableDataColumn) => newTableDataColumn.getName() == tableDataColumn.getName())
+
+      newTableData.addColumn(newTableDataColumn || tableDataColumn)
+    }
+
+    const createNewTableSQL = this.getDriver().createTableSql(newTableData)
+    const insertSQL = `INSERT INTO ${options.quoteTableName(tempTableName)} (${oldColumnsSQL}) 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 = []
+
+    for (const sql of createNewTableSQL) {
+      sqls.push(sql)
+    }
+
+    sqls.push(insertSQL)
+    sqls.push(dropTableSQL)
+    sqls.push(renameTableSQL)
+
+    for (const tableDataIndex of currentTableData.getIndexes()) {
+      const newTableDataIndex = newTableData.getIndexes().find((newTableDataIndex) => newTableDataIndex.getName() == tableDataIndex.getName())
+      const actualTableIndex = newTableDataIndex || tableDataIndex
+
+      newTableData.addIndex(actualTableIndex)
+
+      console.log({actualTableIndex})
+
+      const createIndexArgs = {
+        columns: actualTableIndex.getColumns(),
+        driver: this.getDriver(),
+        name: actualTableIndex.getName(),
+        tableName,
+        unique: actualTableIndex.getUnique()
+      }
+      const sql = new CreateIndexBase(createIndexArgs).toSql()
+
+      sqls.push(sql)
+    }
+
+    console.log({sqls})
+
+    return sqls
+  }
 }

package/src/database/drivers/sqlite/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 VelociousDatabaseDriversSqliteTable extends BaseTable {
@@ -35,6 +36,43 @@ export default class VelociousDatabaseDriversSqliteTable extends BaseTable {
     return foreignKeys
   }
 
+  async getIndexes() {
+    const rows = await this.getDriver().query(`PRAGMA index_list(${this.getOptions().quoteTableName(this.getName())})`)
+    const indexes = []
+
+    for (const row of rows) {
+      const columnsIndex = new ColumnsIndex(this, row)
+      const indexMasterData = await this.getDriver().query(`SELECT * FROM sqlite_master WHERE type = 'index' AND name = ${this.getOptions().quote(columnsIndex.getName())}`)
+
+      columnsIndex.data.columnNames = this._parseColumnsFromSQL(indexMasterData[0].sql)
+
+      indexes.push(columnsIndex)
+    }
+
+    return indexes
+  }
+
+  _parseColumnsFromSQL(sql) {
+    const columnsSQLMatch = sql.match(/\((.+?)\)/)
+    const columnsSQL = columnsSQLMatch[1].split(",")
+    const columnNames = []
+
+    for (const column of columnsSQL) {
+      const matchTicks = column.match(/`(.+)`/)
+      const matchQuotes = column.match(/"(.+)"/)
+
+      if (matchTicks) {
+        columnNames.push(matchTicks[1])
+      } else if (matchQuotes) {
+        columnNames.push(matchQuotes[1])
+      } else{
+        throw new Error(`Couldn't parse column part: ${column}`)
+      }
+    }
+
+    return columnNames
+  }
+
   getName() {
     if (!this.row.name) {
       throw new Error("No name given for SQLite table")

package/src/database/migration/index.js

@@ -30,11 +30,11 @@ export default class VelociousDatabaseMigration {
 
   async addColumn(tableName, columnName, columnType, args) {
     const tableColumnArgs = Object.assign({type: columnType}, args)
+    const tableData = new TableData(tableName)
+
+    tableData.addColumn(columnName, tableColumnArgs)
 
-    const sqls = this._db.alterTableSql({
-      columns: [new TableColumn(columnName, tableColumnArgs)],
-      tableName
-    })
+    const sqls = await this._db.alterTableSql(tableData)
 
     for (const sql of sqls) {
       await this._db.query(sql)
@@ -80,6 +80,13 @@ export default class VelociousDatabaseMigration {
     }
   }
 
+  async changeColumnNull(tableName, columnName, nullable) {
+    const table = await this.getDriver().getTableByName(tableName)
+    const column = await table.getColumnByName(columnName)
+
+    await column.changeNullable(nullable)
+  }
+
   async createTable(tableName, arg1, arg2) {
     let args
     let callback

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

@@ -1,26 +1,46 @@
+import {digs} from "diggerize"
 import QueryBase from "./base.js"
 import restArgsError from "../../utils/rest-args-error.js"
+import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
-  constructor({columns, driver, tableName, ...restArgs}) {
+  constructor({driver, tableData, ...restArgs}) {
     restArgsError(restArgs)
 
+    if (!(tableData instanceof TableData)) throw new Error("Invalid table data was given")
+
     super({driver})
-    this.columns = columns
-    this.tableName = tableName
+    this.tableData = tableData
   }
 
   toSqls() {
+    const databaseType = this.getDriver().getType()
     const sqls = []
+    const {tableData} = digs(this, "tableData")
+    const options = this.getOptions()
+
+    let sql = `ALTER TABLE ${options.quoteTableName(tableData.getName())} `
+    let columnsCount = 0
 
-    for (const column of this.columns) {
-      let sql = `ALTER TABLE ${this.getOptions().quoteTableName(this.tableName)} ADD `
+    for (const column of tableData.getColumns()) {
+      if (columnsCount > 0) sql += ", "
 
-      sql += this.getOptions().quoteColumnName(column.getName())
+      if (column.isNewColumn()) {
+        sql += "ADD "
+      } else {
+        if (databaseType == "mssql" || databaseType == "pgsql") {
+          sql += "ALTER COLUMN "
+        } else {
+          sql += "MODIFY "
+        }
+      }
 
-      sqls.push(sql)
+      sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
+      columnsCount++
     }
 
+    sqls.push(sql)
+
     return sqls
   }
 }

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

@@ -1,10 +1,13 @@
 import CreateIndexBase from "./create-index-base.js"
-import * as inflection from "inflection"
+import {digs} from "diggerize"
 import QueryBase from "./base.js"
 import restArgsError from "../../utils/rest-args-error.js"
+import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
   constructor({driver, ifNotExists, indexInCreateTable = true, tableData}) {
+    if (!(tableData instanceof TableData)) throw new Error("Invalid table data was given")
+
     super({driver})
     this.ifNotExists = ifNotExists
     this.indexInCreateTable = indexInCreateTable
@@ -15,7 +18,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
     const databaseType = this.getDatabaseType()
     const driver = this.getDriver()
     const options = this.getOptions()
-    const {tableData} = this
+    const {tableData} = digs(this, "tableData")
     const sqls = []
     const ifNotExists = this.ifNotExists || tableData.getIfNotExists()
     let sql = ""
@@ -35,86 +38,9 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
     for (const column of tableData.getColumns()) {
       columnCount++
 
-      let maxlength = column.getMaxLength()
-      let type = column.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" && column.getAutoIncrement() && column.getPrimaryKey()) {
-        type = "INTEGER"
-      }
-
-      if (databaseType == "pgsql" && column.getAutoIncrement() && column.getPrimaryKey()) {
-        type = "SERIAL"
-      }
-
       if (columnCount > 1) sql += ", "
 
-      sql += `${options.quoteColumnName(column.getName())} ${type}`
-
-      if (maxlength !== undefined) sql += `(${maxlength})`
-
-      if (column.getAutoIncrement() && driver.shouldSetAutoIncrementWhenPrimaryKey()) {
-        if (databaseType == "mssql") {
-          sql += " IDENTITY"
-        } else if (databaseType == "pgsql") {
-          if (column.getAutoIncrement() && column.getPrimaryKey()) {
-            // Do nothing
-          } else {
-            throw new Error("pgsql auto increment must be primary key")
-          }
-        } else {
-          sql += " AUTO_INCREMENT"
-        }
-      }
-
-      if (typeof column.getDefault() == "function") {
-        const defaultValue = column.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 (column.getDefault()) {
-        sql += ` DEFAULT ${options.quote(column.getDefault())}`
-      }
-
-      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 ${options.quoteTableName(foreignKeyTable)}(${options.quoteColumnName(foreignKeyColumn)})`
-      }
+      sql += column.getSQL({driver, forAlterTable: false})
     }
 
     if (this.indexInCreateTable) {
@@ -145,7 +71,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
       for (const column of tableData.getColumns()) {
         if (!column.getIndex()) continue
 
-        const indexName = `index_on_${column.getName()}`
+        const indexName = `index_on_${tableData.getName()}_${column.getName()}`
 
         sql += ","
 
@@ -174,6 +100,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         const createIndexArgs = {
           columns: index.getColumns(),
           driver: this.getDriver(),
+          name: index.getName(),
           tableName: tableData.getName(),
           unique: index.getUnique()
         }
@@ -185,7 +112,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
       for (const column of tableData.getColumns()) {
         if (!column.getIndex()) continue
 
-        const indexName = `index_on_${column.getName()}`
+        const indexName = `index_on_${tableData.getName()}_${column.getName()}`
         const {unique, ...restIndexArgs} = column.getIndex()
 
         restArgsError(restIndexArgs)

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

@@ -1,9 +1,14 @@
+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, maxLength, name, null: argsNull, primaryKey, type, ...restArgs} = 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)
     }
@@ -12,15 +17,106 @@ class TableColumn {
     this.name = name
   }
 
-  getAutoIncrement = () => this.args?.autoIncrement
-  getDefault = () => this.args?.default
-  getForeignKey = () => this.args?.foreignKey
-  getIndex = () => this.args?.index
-  getMaxLength = () => this.args?.maxLength
-  getName = () => this.name
-  getNull = () => this.args?.null
-  getPrimaryKey = () => this.args?.primaryKey
-  getType = () => this.args?.type
+  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 {
@@ -35,9 +131,9 @@ class TableIndex {
     this.columns = columns
   }
 
-  getColumns = () => this.columns
-  getName = () => this.args.name
-  getUnique = () => Boolean(this.args.unique)
+  getColumns() { return this.columns }
+  getName() { return this.args.name }
+  getUnique() { return Boolean(this.args.unique) }
 }
 
 class TableReference {
@@ -47,7 +143,7 @@ class TableReference {
   }
 }
 
-export {TableColumn}
+export {TableColumn, TableIndex}
 
 export default class TableData {
   _columns = []
@@ -55,34 +151,42 @@ export default class TableData {
   _references = []
 
   constructor(name, args = {}) {
+    if (!name) throw new Error(`Invalid table name: ${name}`)
+
     this.args = args
     this._name = name
   }
 
-  _defineColumn(name, args = {}) {
-    const column = new TableColumn(name, args)
+  addColumn(name, args = {}) {
+    if (name instanceof TableColumn) {
+      this._columns.push(name)
+    } else {
+      const column = new TableColumn(name, args)
 
-    this._columns.push(column)
+      this._columns.push(column)
+    }
   }
 
-  getColumns = () => this._columns
-  getName = () => this._name
-  getIfNotExists = () => this.args.ifNotExists
-  getIndexes = () => this._indexes
-  getReferences = () => this._references
-
-  bigint = (name, args = {}) => this._defineColumn(name, Object.assign({type: "bigint"}, args))
-  blob = (name, args = {}) => this._defineColumn(name, Object.assign({type: "blob"}, args))
-  boolean = (name, args) => this._defineColumn(name, Object.assign({type: "boolean"}, args))
-  datetime = (name, args) => this._defineColumn(name, Object.assign({type: "datetime"}, args))
-  integer = (name, args = {}) => this._defineColumn(name, Object.assign({type: "integer"}, args))
-  tinyint = (name, args = {}) => this._defineColumn(name, Object.assign({type: "tinyint"}, args))
+  addIndex(index) { this._indexes.push(index) }
+  getColumns() { return this._columns }
+  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)) }
+  blob(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "blob"}, args)) }
+  boolean(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "boolean"}, args)) }
+  datetime(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "datetime"}, args)) }
+  integer(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "integer"}, args)) }
+  tinyint(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "tinyint"}, args)) }
 
   references(name, args = {}) {
     const columnName = `${name}_id`
-    const indexName = `index_on_${columnName}`
+    const indexName = `index_on_${this.getName()}_${columnName}`
     const reference = new TableReference(name, args)
-    const columnArgs = Object.assign({type: "bigint"}, args)
+    const columnArgs = Object.assign({isNewColumn: true, type: "bigint"}, args)
     const column = new TableColumn(columnName, columnArgs)
     const index = new TableIndex([column], {name: indexName})
 
@@ -91,13 +195,13 @@ export default class TableData {
     this._references.push(reference)
   }
 
-  string = (name, args) => this._defineColumn(name, Object.assign({type: "string"}, args))
-  text = (name, args) => this._defineColumn(name, Object.assign({type: "text"}, args))
+  string(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "string"}, args)) }
+  text(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "text"}, args)) }
 
   timestamps(args = {}) {
     this.datetime("created_at", args)
     this.datetime("updated_at", args)
   }
 
-  uuid = (name, args) => this._defineColumn(name, Object.assign({type: "uuid"}, args))
+  uuid(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "uuid"}, args)) }
 }