velocious 1.0.46 → 1.0.48

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

@@ -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) {
@@ -142,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_${column.getName()}`
+        let indexName = `index_on_`
+
+        if (databaseType == "sqlite") sql += `${tableData.getName()}_`
+
+        indexName += column.getName()
 
         sql += ","
 
@@ -174,6 +105,8 @@ 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()
         }
@@ -182,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_${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,103 +1,69 @@
-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
-
-      restArgsError(restArgs)
-    }
-
-    this.args = args
-    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
-}
-
-class TableIndex {
-  constructor(columns, args) {
-    if (args) {
-      const {name, unique, ...restArgs} = args
-
-      restArgsError(restArgs)
-    }
-
-    this.args = args
-    this.columns = columns
-  }
-
-  getColumns = () => this.columns
-  getName = () => this.args.name
-  getUnique = () => Boolean(this.args.unique)
-}
-
-class TableReference {
-  constructor(name, args) {
-    this.args = args
-    this.name = name
-  }
-}
-
-export {TableColumn}
+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 = []
 
   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
+  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 }
+  getReferences() { return 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))
+  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 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})
+    const index = new TableIndex([column])
 
     this._columns.push(column)
     this._indexes.push(index)
     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)) }
 }

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
+  }
+}