velocious 1.0.85 → 1.0.87

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

@@ -9,6 +9,9 @@ export default class VelociousDatabaseDriversBaseForeignKey {
     return this.getTable().getDriver()
   }
 
+  /**
+   * @returns {import("../query-parser/options.js").default}
+   */
   getOptions() {
     return this.getDriver().options()
   }

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

@@ -15,6 +15,9 @@ export default class VelociousDatabaseDriversBaseTable {
     return this.driver
   }
 
+  /**
+   * @returns {import("../query-parser/options.js").default}
+   */
   getOptions() {
     return this.getDriver().options()
   }

package/src/database/drivers/base.js

@@ -90,6 +90,16 @@ export default class VelociousDatabaseDriversBase {
     return table
   }
 
+  /**
+   * @param {object} args
+   * @param {Array} args.columns
+   * @param {object} args.data
+   * @param {boolean} args.multiple
+   * @param {boolean} args.returnLastInsertedColumnNames
+   * @param {Array} args.rows
+   * @param {string} args.tableName
+   * @returns {Promise<void>}
+   */
   async insert(...args) {
     const sql = this.insertSql(...args)
 
@@ -108,6 +118,10 @@ export default class VelociousDatabaseDriversBase {
     return value
   }
 
+  /**
+   * @param {string} value
+   * @returns {string}
+   */
   quote(value) {
     if (typeof value == "number") return value
 
@@ -117,18 +131,33 @@ export default class VelociousDatabaseDriversBase {
     return result
   }
 
+  /**
+   * @param {string} columnName
+   * @returns {string}
+   */
   quoteColumn(columnName) {
     return this.options().quoteColumnName(columnName)
   }
 
+  /**
+   * @param {string} columnName
+   * @returns {string}
+   */
   quoteIndex(columnName) {
     return this.options().quoteIndexName(columnName)
   }
 
+  /**
+   * @param {string} tableName
+   * @returns {string}
+   */
   quoteTable(tableName) {
     return this.options().quoteTableName(tableName)
   }
 
+  /**
+   * @returns {Query}
+   */
   newQuery() {
     const handler = new Handler()
 
@@ -138,6 +167,10 @@ export default class VelociousDatabaseDriversBase {
     })
   }
 
+  /**
+   * @param {string} tableName
+   * @returns {Promise<Array>}
+   */
   async select(tableName) {
     const query = this.newQuery()
 
@@ -152,6 +185,10 @@ export default class VelociousDatabaseDriversBase {
     this.idSeq = id
   }
 
+  /**
+   * @param {string} tableName
+   * @returns {Promise<boolean>}
+   */
   async tableExists(tableName) {
     const tables = await this.getTables()
     const table = tables.find((table) => table.getName() == tableName)
@@ -231,6 +268,10 @@ export default class VelociousDatabaseDriversBase {
     await this.query("COMMIT")
   }
 
+  /**
+   * @param {string} sql
+   * @returns {Promise<Array>}
+   */
   async query(sql) {
     let tries = 0
 
@@ -251,7 +292,7 @@ export default class VelociousDatabaseDriversBase {
     }
   }
 
-  retryableDatabaseError(_error) {
+  retryableDatabaseError(_error) { // eslint-disable-line no-unused-vars
     return false
   }
 
@@ -280,6 +321,12 @@ export default class VelociousDatabaseDriversBase {
     await this.query(`SAVEPOINT ${savePointName}`)
   }
 
+  /**
+   * @param {string} tableName
+   * @param {string} oldColumnName
+   * @param {string} newColumnName
+   * @returns {Promise<void>}
+   */
   async renameColumn(tableName, oldColumnName, newColumnName) {
     const tableColumn = new TableColumn(oldColumnName)
 
@@ -348,6 +395,13 @@ export default class VelociousDatabaseDriversBase {
     })
   }
 
+  /**
+   * @param {object} args
+   * @param {object} args.conditions
+   * @param {object} args.data
+   * @param {string} args.tableName
+   * @returns {Promise<void>}
+   */
   async update(...args) {
     const sql = this.updateSql(...args)
 

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

@@ -33,6 +33,9 @@ export default class VelociousDatabaseDriversMssql extends Base{
     this.connection = undefined
   }
 
+  /**
+   * @returns {string}
+   */
   async alterTableSql(tableData) {
     const alterArgs = {tableData, driver: this}
     const alterTable = new AlterTable(alterArgs)
@@ -40,6 +43,9 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return await alterTable.toSqls()
   }
 
+  /**
+   * @returns {string}
+   */
   createDatabaseSql(databaseName, args) {
     const createArgs = Object.assign({databaseName, driver: this}, args)
     const createDatabase = new CreateDatabase(createArgs)
@@ -47,6 +53,9 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return createDatabase.toSql()
   }
 
+  /**
+   * @returns {string}
+   */
   createIndexSql(indexData) {
     const createArgs = Object.assign({driver: this}, indexData)
     const createIndex = new CreateIndex(createArgs)
@@ -54,6 +63,9 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return createIndex.toSql()
   }
 
+  /**
+   * @returns {string}
+   */
   createTableSql(tableData) {
     const createArgs = {tableData, driver: this, indexInCreateTable: false}
     const createTable = new CreateTable(createArgs)
@@ -61,6 +73,9 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return createTable.toSql()
   }
 
+  /**
+   * @returns {Promise<string>}
+   */
   async currentDatabase() {
     const rows = await this.query("SELECT DB_NAME() AS db_name")
 
@@ -75,6 +90,9 @@ export default class VelociousDatabaseDriversMssql extends Base{
     await this.query("EXEC sp_MSforeachtable @command1=\"print '?'\", @command2=\"ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all\"")
   }
 
+  /**
+   * @returns {string}
+   */
   dropTableSql(tableName, args = {}) {
     const dropArgs = Object.assign({tableName, driver: this}, args)
     const dropTable = new DropTable(dropArgs)
@@ -82,7 +100,14 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return dropTable.toSql()
   }
 
+  /**
+   * @returns {string}
+   */
   getType() { return "mssql" }
+
+  /**
+   * @returns {string}
+   */
   primaryKeyType() { return "bigint" }
 
   async _queryActual(sql) {
@@ -115,9 +140,17 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return result.recordsets[0]
   }
 
+  /**
+   * @returns {string}
+   */
   queryToSql(query) { return new QueryParser({query}).toSql() }
+
   shouldSetAutoIncrementWhenPrimaryKey() { return true }
 
+  /**
+   * @param {*} value
+   * @returns {string}
+   */
   escape(value) {
     value = this._convertValue(value)
 
@@ -131,6 +164,10 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return result
   }
 
+  /**
+   * @param {*} value
+   * @returns {string}
+   */
   quote(value) {
     value = this._convertValue(value)
 
@@ -142,19 +179,42 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return escapeString(value)
   }
 
+  /**
+   * @param {*} string
+   * @returns {string}
+   */
   quoteColumn(string) { return this.options().quoteColumnName(string) }
+
+  /**
+   * @param {string|number} string
+   * @returns {string}
+   */
   quoteTable(string) { return this.options().quoteTableName(string) }
 
+  /**
+   * @param {string} tableName
+   * @param {string} oldColumnName
+   * @param {string} newColumnName
+   * @returns {Promise<void>}
+   */
   async renameColumn(tableName, oldColumnName, newColumnName) {
     await this.query(`EXEC sp_rename ${this.quote(`${tableName}.${oldColumnName}`)}, ${this.quote(newColumnName)}, 'COLUMN'`)
   }
 
+  /**
+   * @param {object} args
+   * @param {string} args.tableName
+   * @param {object} args.conditions
+   */
   deleteSql({tableName, conditions}) {
     const deleteInstruction = new Delete({conditions, driver: this, tableName})
 
     return deleteInstruction.toSql()
   }
 
+  /**
+   * @returns {string} SQL statement
+   */
   insertSql(args) {
     const insertArgs = Object.assign({driver: this}, args)
     const insert = new Insert(insertArgs)
@@ -228,7 +288,7 @@ export default class VelociousDatabaseDriversMssql extends Base{
     await this.query(`SAVE TRANSACTION [${savePointName}]`)
   }
 
-  async _releaseSavePointAction(savePointName) {
+  async _releaseSavePointAction(savePointName) { // eslint-disable-line no-unused-vars
     // Do nothing in MS-SQL.
   }
 
@@ -240,6 +300,9 @@ export default class VelociousDatabaseDriversMssql extends Base{
     return `sp${new UUID(4).format().replaceAll("-", "")}`.substring(0, 32)
   }
 
+  /**
+   * @returns {string}
+   */
   updateSql({conditions, data, tableName}) {
     const update = new Update({conditions, data, driver: this, tableName})
 

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

@@ -1,5 +1,4 @@
 import BaseColumnsIndex from "../base-columns-index.js"
-import {digg} from "diggerize"
 
 export default class VelociousDatabaseDriversMysqlColumn extends BaseColumnsIndex {
   constructor(table, data) {

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

@@ -54,10 +54,27 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     return dropTable.toSql()
   }
 
+  /**
+   * @returns {string}
+   */
   deleteSql(args) { return new Delete(Object.assign({driver: this}, args)).toSql() }
+
+  /**
+   * @returns {string}
+   */
   getType() { return "sqlite" }
+
+  /**
+   * @returns {string}
+   */
   insertSql(args) { return new Insert(Object.assign({driver: this}, args)).toSql() }
 
+  /**
+   * @param {string} tableName
+   * @param {object} args
+   * @param {boolean} args.throwError
+   * @returns {Promise<Table>}
+   */
   async getTableByName(tableName, args) {
     const result = await this.query(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${this.quote(tableName)} LIMIT 1`)
     const row = result[0]
@@ -74,6 +91,9 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     }
   }
 
+  /**
+   * @returns {Promise<Table[]>}
+   */
   async getTables() {
     const result = await this.query("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name")
     const tables = []
@@ -97,6 +117,9 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     }
   }
 
+  /**
+   * @returns {boolean}
+   */
   supportsMultipleInsertValues() {
     if (this.versionMajor >= 4) return true
     if (this.versionMajor == 3 && this.versionMinor >= 8) return true
@@ -105,6 +128,9 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     return false
   }
 
+  /**
+   * @returns {boolean}
+   */
   supportsInsertIntoReturning() {
     if (this.versionMajor >= 4) return true
     if (this.versionMajor == 3 && this.versionMinor >= 35) return true
@@ -112,6 +138,12 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     return false
   }
 
+  /**
+   * @param {string} tableName
+   * @param {string[]} columns
+   * @param {any[][]} rows
+   * @returns {Promise<any[]>}
+   */
   async insertMultipleWithSingleInsert(tableName, columns, rows) {
     const sql = new Insert({columns, driver: this, rows, tableName}).toSql()
 
@@ -155,7 +187,14 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     return this._options
   }
 
+  /**
+   * @returns {string} - The type of the primary key for this driver.
+   */
   primaryKeyType() { return "integer" } // Because bigint on SQLite doesn't support auto increment
+
+  /**
+   * @returns {string}
+   */
   queryToSql(query) { return new QueryParser({query}).toSql() }
 
   async registerVersion() {

package/src/database/drivers/sqlite/connection-remote.js

@@ -1,5 +1,5 @@
 export default class VelociousDatabaseDriversSqliteConnectionRemote {
-  async query(sql) {
+  async query(sql) { // eslint-disable-line no-unused-vars
     throw new Error("stub")
   }
 }

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

@@ -97,7 +97,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
       // 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()}`)
+      if (!tableDataColumn) throw new Error(`Couldn't find column for foreign key: ${foreignKey.getName()}`)
 
       this.logger.debug(() => [`Setting foreign key on column ${tableDataColumn.getName()}`])
       tableDataColumn.setForeignKey(foreignKey)

package/src/database/drivers/sqlite/sql/delete.js

@@ -2,18 +2,23 @@ import DeleteBase from "../../../query/delete-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlDelete extends DeleteBase {
   toSql() {
-    let sql = `DELETE FROM ${this.getOptions().quoteTableName(this.tableName)} WHERE `
-    let count = 0
+    let sql = `DELETE FROM ${this.getOptions().quoteTableName(this.tableName)}`
 
-    for (let columnName in this.conditions) {
-      if (count > 0) sql += " AND "
+    if (this.conditions && Object.keys(this.conditions).length > 0) {
+      sql += " WHERE "
 
-      sql += this.getOptions().quoteColumnName(columnName)
-      sql += " = "
-      sql += this.getOptions().quote(this.conditions[columnName])
-      count++
-    }
+      let count = 0
+
+      for (let columnName in this.conditions) {
+        if (count > 0) sql += " AND "
 
-    return sql
+        sql += this.getOptions().quoteColumnName(columnName)
+        sql += " = "
+        sql += this.getOptions().quote(this.conditions[columnName])
+        count++
+      }
+
+      return sql
+    }
   }
 }

package/src/database/migration/index.js

@@ -11,6 +11,12 @@ export default class VelociousDatabaseMigration {
     return this._databaseIdentifiers
   }
 
+  /**
+   * @param {object} args
+   * @param {string} args.configuration
+   * @param {string} args.databaseIdentifier
+   * @param {object} args.db
+   */
   constructor({configuration, databaseIdentifier = "default", db}) {
     if (!databaseIdentifier) throw new Error("No database identifier given")
     if (!db) throw new Error("No 'db' given")
@@ -29,10 +35,26 @@ export default class VelociousDatabaseMigration {
   getDriver() { return this._db }
   connection() { return this.getDriver() }
 
+  /**
+   * @param {string} sql
+   * @returns {Promise<Array>}
+   */
   async execute(sql) {
-    await this.connection().query(sql)
+    return await this.connection().query(sql)
   }
 
+  /**
+   * @param {string} tableName
+   * @param {string} columnName
+   * @param {string} columnType
+   * @param {object} args
+   * @param {object} args.default
+   * @param {object} args.foreignKey
+   * @param {object} args.nullable
+   * @param {object} args.primaryKey
+   * @param {object} args.unique
+   * @returns {Promise<void>}
+   */
   async addColumn(tableName, columnName, columnType, args) {
     if (!columnType) throw new Error("No column type given")
 
@@ -48,6 +70,33 @@ export default class VelociousDatabaseMigration {
     }
   }
 
+  /**
+   * @param {string} tableName
+   * @param {string} columnName
+   * @returns {Promise<void>}
+   */
+  async removeColumn(tableName, columnName) {
+    const tableColumnArgs = Object.assign({dropColumn: true})
+    const tableData = new TableData(tableName)
+
+    tableData.addColumn(columnName, tableColumnArgs)
+
+    const sqls = await this.getDriver().alterTableSql(tableData)
+
+    for (const sql of sqls) {
+      await this.getDriver().query(sql)
+    }
+  }
+
+  /**
+   * @param {string} tableName
+   * @param {Array} columns
+   * @param {object} args
+   * @param {boolean} args.ifNotExists
+   * @param {string} args.name
+   * @param {boolean} args.unique
+   * @returns {Promise<void>}
+   */
   async addIndex(tableName, columns, args) {
     const createIndexArgs = Object.assign(
       {
@@ -61,6 +110,11 @@ export default class VelociousDatabaseMigration {
     await this.getDriver().query(sql)
   }
 
+  /**
+   * @param {string} tableName
+   * @param {string} referenceName
+   * @returns {Promise<void>}
+   */
   async addForeignKey(tableName, referenceName) {
     const referenceNameUnderscore = inflection.underscore(referenceName)
     const tableNameUnderscore = inflection.underscore(tableName)
@@ -79,6 +133,15 @@ export default class VelociousDatabaseMigration {
     )
   }
 
+  /**
+   * @param {string} tableName
+   * @param {string} referenceName
+   * @param {object} args
+   * @param {boolean} args.foreignKey
+   * @param {string} args.type
+   * @param {boolean} args.unique
+   * @returns {Promise<void>}
+   */
   async addReference(tableName, referenceName, args) {
     const {foreignKey, type, unique, ...restArgs} = args
     const columnName = `${inflection.underscore(referenceName)}_id`
@@ -93,6 +156,23 @@ export default class VelociousDatabaseMigration {
     }
   }
 
+  /**
+   * @param {string} tableName
+   * @param {string} referenceName
+   * @returns {Promise<void>}
+   */
+  async removeReference(tableName, referenceName) {
+    const columnName = `${inflection.underscore(referenceName)}_id`
+
+    this.removeColumn(tableName, columnName)
+  }
+
+  /**
+   * @param {string} tableName
+   * @param {string} columnName
+   * @param {boolean} nullable
+   * @returns {Promise<void>}
+   */
   async changeColumnNull(tableName, columnName, nullable) {
     const table = await this.getDriver().getTableByName(tableName)
     const column = await table.getColumnByName(columnName)
@@ -100,6 +180,29 @@ export default class VelociousDatabaseMigration {
     await column.changeNullable(nullable)
   }
 
+  /**
+   * @param {string} tableName
+   * @param {string} columnName
+   * @returns {Promise<boolean>}
+   */
+  async columnExists(tableName, columnName) {
+    const table = await this.getDriver().getTableByName(tableName)
+    const column = await table.getColumnByName(columnName)
+
+    return Boolean(column)
+  }
+
+  /**
+   * @param {string} tableName
+   * @param {function() : void} arg1
+   * @returns {Promise<void>}
+   */
+  /**
+   * @param {string} tableName
+   * @param {object} arg1
+   * @param {function() : void} arg2
+   * @returns {Promise<void>}
+   */
   async createTable(tableName, arg1, arg2) {
     let args
     let callback
@@ -138,10 +241,28 @@ export default class VelociousDatabaseMigration {
     }
   }
 
+  /**
+   * @param {string} tableName
+   * @returns {Promise<void>}
+   */
+  async dropTable(tableName) {
+    await this.getDriver().dropTable(tableName)
+  }
+
+  /**
+   * @param {string} tableName
+   * @param {string} oldColumnName
+   * @param {string} newColumnName
+   * @returns {Promise<void>}
+   */
   async renameColumn(tableName, oldColumnName, newColumnName) {
     await this.getDriver().renameColumn(tableName, oldColumnName, newColumnName)
   }
 
+  /**
+   * @param {string} tableName
+   * @returns {Promise<boolean>}
+   */
   async tableExists(tableName) {
     const exists = await this.getDriver().tableExists(tableName)
 

package/src/database/migrator/files-finder.js

@@ -1,9 +1,13 @@
-import fs from "node:fs/promises"
+import fs from "fs/promises"
 import * as inflection from "inflection"
 
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseMigratorFilesFinder {
+  /**
+   * @param {object} args
+   * @param {string} args.path
+   */
   constructor({path, ...restArgs}) {
     restArgsError(restArgs)
 
@@ -12,6 +16,14 @@ export default class VelociousDatabaseMigratorFilesFinder {
     this.path = path
   }
 
+  /**
+   * @returns {Promise<Array<{
+   *   file: string,
+   *   fullPath: string,
+   *   date: number,
+   *   migrationClassName: string
+   * }>>}
+   */
   async findFiles() {
     let files = await fs.readdir(this.path)