velocious 1.0.430 → 1.0.432

package/build/database/drivers/sqlite/query.web.js

@@ -0,0 +1,49 @@
+// @ts-check
+
+/**
+ * Runs query.
+ * @param {import("sql.js").Database} connection - Connection.
+ * @param {string} sql - SQL string.
+ * @returns {Promise<Record<string, ?>[]>} - Resolves with string value.
+ */
+export default async function query(connection, sql) {
+  const rows = []
+  let result
+
+  try {
+    result = connection.exec(sql)
+  } catch (error) {
+    let sqlInErrorMessage = `${sql}`
+
+    if (sqlInErrorMessage.length >= 4096) {
+      sqlInErrorMessage = `${sqlInErrorMessage.substring(0, 4096)}...`
+    }
+
+    if (error instanceof Error) {
+      error.message += `\n\n${sqlInErrorMessage}`
+    } else {
+      throw new Error(`An error occurred: ${error} [${typeof error}]\n\n${sqlInErrorMessage}`, {cause: error})
+    }
+
+    throw error
+  }
+
+  if (result[0]) {
+    const columns = result[0].columns
+
+    for (const rowValues of result[0].values) {
+      /**
+       * Row.
+        @type {Record<string, ?>} */
+      const row = {}
+
+      for (const columnIndex in columns) {
+        row[columns[columnIndex]] = rowValues[columnIndex]
+      }
+
+      rows.push(row)
+    }
+  }
+
+  return rows
+}

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

@@ -0,0 +1,187 @@
+// @ts-check
+
+import AlterTableBase from "../../../query/alter-table-base.js"
+import Logger from "../../../../logger.js"
+import restArgsError from "../../../../utils/rest-args-error.js"
+import TableData from "../../../table-data/index.js"
+import TableForeignKey from "../../../table-data/table-foreign-key.js"
+import TableIndex from "../../../table-data/table-index.js"
+import TableRebuilder from "../table-rebuilder.js"
+
+export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable extends AlterTableBase {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../../base.js").default} args.driver - Database driver instance.
+   * @param {import("../../../table-data/index.js").default} args.tableData - Table data.
+   */
+  constructor({driver, tableData, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!(tableData instanceof TableData)) throw new Error("Invalid table data was given")
+
+    super({driver, tableData})
+    this.logger = new Logger(this)
+    this.tableData = tableData
+  }
+
+  /**
+   * Runs to sqls.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  async toSQLs() {
+    const driver = this.getDriver()
+    const {tableData: alterTableData} = this
+    const tableName = alterTableData.getName()
+    const table = await driver.getTableByName(tableName)
+
+    if (!table) throw new Error(`Table ${tableName} does not exist`)
+
+    const currentTableData = await table.getTableData()
+    const {targetTableData, columnPairs} = this._buildTargetSchema(currentTableData, alterTableData)
+
+    const rebuilder = new TableRebuilder({
+      columnPairs,
+      driver,
+      originalTableName: tableName,
+      targetTableData
+    })
+
+    const rebuildSQLs = await rebuilder.toSQLs()
+    const sqls = []
+
+    // PRAGMA foreign_keys can only be toggled outside an active transaction; when the
+    // caller is already inside one these become no-ops (matching prior behavior). Outside
+    // a transaction they protect the rebuild from cross-table FK enforcement during the
+    // DROP/RENAME swap. Capture the prior state so we restore it instead of unconditionally
+    // forcing ON — callers that deliberately disabled FK enforcement (e.g. bulk data fixes)
+    // shouldn't be silently flipped back on by a migration.
+    const priorState = await driver.query("PRAGMA foreign_keys")
+    const wasEnabled = priorState[0]?.foreign_keys == 1
+
+    sqls.push("PRAGMA foreign_keys = OFF")
+
+    for (const sql of rebuildSQLs) sqls.push(sql)
+
+    sqls.push(`PRAGMA foreign_keys = ${wasEnabled ? "ON" : "OFF"}`)
+
+    return sqls
+  }
+
+  /**
+   * Merges the current schema with the alter request to produce the desired final schema
+   * and the column copy plan.
+   * @param {TableData} currentTableData - Current schema as introspected from the database.
+   * @param {TableData} alterTableData - Alter request: new columns (`isNewColumn`), renames (`newName`), drops (`dropColumn`), modifies, and new foreign keys.
+   * @returns {{targetTableData: TableData, columnPairs: Array<[string, string]>}} - The merged target schema and the [oldName, newName] pairs for INSERT...SELECT.
+   */
+  _buildTargetSchema(currentTableData, alterTableData) {
+    const targetTableData = new TableData(currentTableData.getName())
+    /**
+     * Column pairs.
+      @type {Array<[string, string]>} */
+    const columnPairs = []
+    const alterColumns = alterTableData.getColumns()
+    const existingNames = new Set(currentTableData.getColumns().map((column) => column.getName()))
+    /**
+     * Column renames.
+      @type {Map<string, string>} */
+    const columnRenames = new Map()
+
+    for (const alterColumn of alterColumns) {
+      if (alterColumn.isNewColumn()) continue
+
+      const newName = alterColumn.getNewName()
+
+      if (newName) columnRenames.set(alterColumn.getName(), newName)
+    }
+
+    for (const currentColumn of currentTableData.getColumns()) {
+      const alterColumn = alterColumns.find((column) => column.getName() == currentColumn.getName() && !column.isNewColumn())
+
+      if (alterColumn?.getDropColumn()) continue
+
+      let targetColumn
+
+      if (alterColumn) {
+        // The alter request supplies a partial column spec (e.g. just a rename or a type change);
+        // inherit unset properties from the current column so we don't lose existing definitions.
+        alterColumn.setAutoIncrement(alterColumn.getAutoIncrement() || currentColumn.getAutoIncrement())
+        if (alterColumn.getDefault() === undefined) alterColumn.setDefault(currentColumn.getDefault())
+        if (!alterColumn.getIndex()) alterColumn.setIndex(currentColumn.getIndex())
+        if (!alterColumn.getForeignKey()) alterColumn.setForeignKey(currentColumn.getForeignKey())
+        if (alterColumn.getMaxLength() === undefined) alterColumn.setMaxLength(currentColumn.getMaxLength())
+        alterColumn.setPrimaryKey(alterColumn.getPrimaryKey() || currentColumn.getPrimaryKey())
+        if (!alterColumn.getType()) alterColumn.setType(currentColumn.getType())
+
+        targetColumn = alterColumn
+      } else {
+        targetColumn = currentColumn
+      }
+
+      targetTableData.addColumn(targetColumn)
+      columnPairs.push([currentColumn.getName(), targetColumn.getNewName() || targetColumn.getName()])
+    }
+
+    for (const alterColumn of alterColumns) {
+      if (!alterColumn.isNewColumn()) continue
+      if (existingNames.has(alterColumn.getName())) continue
+
+      targetTableData.addColumn(alterColumn)
+    }
+
+    const seenForeignKeyNames = new Set()
+
+    for (const currentForeignKey of currentTableData.getForeignKeys()) {
+      const alterForeignKey = alterTableData.getForeignKeys().find((foreignKey) => foreignKey.getName() == currentForeignKey.getName())
+      const finalForeignKey = this._renameForeignKeyColumn(alterForeignKey || currentForeignKey, columnRenames)
+
+      seenForeignKeyNames.add(finalForeignKey.getName())
+      targetTableData.addForeignKey(finalForeignKey)
+    }
+
+    for (const alterForeignKey of alterTableData.getForeignKeys()) {
+      if (seenForeignKeyNames.has(alterForeignKey.getName())) continue
+
+      targetTableData.addForeignKey(this._renameForeignKeyColumn(alterForeignKey, columnRenames))
+    }
+
+    for (const currentIndex of currentTableData.getIndexes()) {
+      const renamedColumns = currentIndex.getColumns().map((columnName) => {
+        if (typeof columnName != "string") return columnName
+
+        return columnRenames.get(columnName) || columnName
+      })
+
+      targetTableData.addIndex(new TableIndex(renamedColumns, {
+        name: currentIndex.getName(),
+        unique: currentIndex.getUnique()
+      }))
+    }
+
+    return {targetTableData, columnPairs}
+  }
+
+  /**
+   * Returns the foreign key with its column name updated when the column was renamed in the
+   * alter request. SQLite re-creates the constraint inside the rebuilt CREATE TABLE, so a
+   * stale column name there would reference a column that no longer exists.
+   * @param {TableForeignKey} foreignKey - Foreign key to evaluate.
+   * @param {Map<string, string>} columnRenames - Map of old → new column names from the alter request.
+   * @returns {TableForeignKey} - The original foreign key, or a fresh instance with the renamed column.
+   */
+  _renameForeignKeyColumn(foreignKey, columnRenames) {
+    const renamed = columnRenames.get(foreignKey.getColumnName())
+
+    if (!renamed) return foreignKey
+
+    return new TableForeignKey({
+      columnName: renamed,
+      isNewForeignKey: foreignKey.getIsNewForeignKey(),
+      name: foreignKey.getName(),
+      referencedColumnName: foreignKey.getReferencedColumnName(),
+      referencedTableName: foreignKey.getReferencedTableName(),
+      tableName: foreignKey.getTableName()
+    })
+  }
+}

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

@@ -0,0 +1,6 @@
+// @ts-check
+
+import CreateIndexBase from "../../../query/create-index-base.js"
+
+export default class VelociousDatabaseConnectionDriversSqliteSqlCreateIndex extends CreateIndexBase {
+}

package/build/database/drivers/sqlite/sql/create-table.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import CreateTableBase from "../../../query/create-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlCreateTable extends CreateTableBase {
+}

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

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

package/build/database/drivers/sqlite/sql/drop-table.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import DropTableBase from "../../../query/drop-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversSqliteSqlDropTable extends DropTableBase {
+}

package/build/database/drivers/sqlite/sql/insert.js

@@ -0,0 +1,6 @@
+// @ts-check
+
+import InsertBase from "../../../query/insert-base.js"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlInsert extends InsertBase {
+}

package/build/database/drivers/sqlite/sql/update.js

@@ -0,0 +1,33 @@
+// @ts-check
+
+import UpdateBase from "../../../query/update-base.js"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlUpdate extends UpdateBase {
+  toSql() {
+    let sql = `UPDATE ${this.getOptions().quoteTableName(this.tableName)} SET `
+    let count = 0
+
+    for (let columnName in this.data) {
+      if (count > 0) sql += ", "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.formatValue(this.data[columnName])
+      count++
+    }
+
+    sql += " WHERE "
+    count = 0
+
+    for (let columnName in this.conditions) {
+      if (count > 0) sql += " AND "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.formatValue(this.conditions[columnName])
+      count++
+    }
+
+    return sql
+  }
+}

package/build/database/drivers/sqlite/sql/upsert.js

@@ -0,0 +1,14 @@
+// @ts-check
+
+import UpsertBase from "../../../query/upsert-base.js"
+
+export default class VelociousDatabaseConnectionDriversSqliteSqlUpsert extends UpsertBase {
+  toSql() {
+    const conflictSql = this.conflictColumns.map((columnName) => this.quotedColumn(columnName)).join(", ")
+    const updateSql = this.updateColumns.map((columnName) => {
+      return `${this.quotedColumn(columnName)} = excluded.${this.quotedColumn(columnName)}`
+    }).join(", ")
+
+    return `INSERT INTO ${this.quotedTableName()} (${this.quotedInsertColumnsSql()}) VALUES (${this.quotedInsertValuesSql()}) ON CONFLICT (${conflictSql}) DO UPDATE SET ${updateSql}`
+  }
+}

package/build/database/drivers/sqlite/structure-sql.js

@@ -0,0 +1,56 @@
+// @ts-check
+
+import {normalizeSqlStatement} from "../structure-sql/utils.js"
+
+export default class VelociousDatabaseDriversSqliteStructureSql {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../base.js").default} args.driver - Database driver instance.
+   */
+  constructor({driver}) {
+    this.driver = driver
+  }
+
+  /**
+   * Runs to sql.
+   * @returns {Promise<string | null>} - Resolves with SQL string.
+   */
+  async toSql() {
+    const {driver} = this
+    const rows = await driver.query("SELECT type, sql, name FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%' ORDER BY name")
+    const tables = []
+    const views = []
+    const indexes = []
+    const triggers = []
+    const others = []
+
+    for (const row of rows) {
+      const rawSql = row.sql || row.SQL
+      const rawType = row.type || row.TYPE
+      const statement = rawSql ? normalizeSqlStatement(String(rawSql)) : ""
+
+      if (!statement) continue
+
+      const normalizedType = rawType ? String(rawType).toLowerCase() : ""
+
+      if (normalizedType === "table") {
+        tables.push(statement)
+      } else if (normalizedType === "view") {
+        views.push(statement)
+      } else if (normalizedType === "index") {
+        indexes.push(statement)
+      } else if (normalizedType === "trigger") {
+        triggers.push(statement)
+      } else {
+        others.push(statement)
+      }
+    }
+
+    const statements = [...tables, ...views, ...indexes, ...triggers, ...others]
+
+    if (statements.length == 0) return null
+
+    return `${statements.join("\n\n")}\n`
+  }
+}

package/build/database/drivers/sqlite/table-rebuilder.js

@@ -0,0 +1,96 @@
+// @ts-check
+
+import CreateIndexBase from "../../query/create-index-base.js"
+import restArgsError from "../../../utils/rest-args-error.js"
+import TableData from "../../table-data/index.js"
+
+/**
+ * Emits the SQL sequence for SQLite's "rebuild" approach to schema changes.
+ *
+ * SQLite cannot add/drop foreign-key constraints, drop columns on older
+ * versions, change column types, or add CHECK constraints via ALTER TABLE.
+ * The standard workaround (https://sqlite.org/lang_altertable.html) is to
+ * create a new table with the desired schema, copy rows over, drop the
+ * original, and rename the replacement.
+ *
+ * Caller passes the desired final schema; this class handles the mechanical
+ * sequence (CREATE temp / INSERT...SELECT / DROP / RENAME / recreate
+ * indexes). Caller is responsible for any FK toggling or transaction setup
+ * around the returned SQL — `PRAGMA foreign_keys` is connection-scoped and
+ * cannot be flipped inside a transaction, so wrapping policy is left to the
+ * caller (see `sql/alter-table.js`).
+ */
+export default class VelociousDatabaseDriversSqliteTableRebuilder {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../base.js").default} args.driver - Database driver instance.
+   * @param {string} args.originalTableName - Name of the existing table to rebuild.
+   * @param {TableData} args.targetTableData - Desired final schema (columns + foreign keys + indexes). The instance's name is overwritten internally during emission.
+   * @param {Array<[string, string]>} args.columnPairs - Pairs of [oldColumnName, newColumnName] describing how rows from the original table should populate the rebuilt table.
+   */
+  constructor({driver, originalTableName, targetTableData, columnPairs, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!(targetTableData instanceof TableData)) throw new Error("Invalid target table data was given")
+
+    this.driver = driver
+    this.originalTableName = originalTableName
+    this.targetTableData = targetTableData
+    this.columnPairs = columnPairs
+  }
+
+  /**
+   * Runs to sqls.
+   * @returns {Promise<string[]>} - Resolves with SQL statements to execute in order.
+   */
+  async toSQLs() {
+    const driver = this.driver
+    const options = driver.options()
+    const originalTableName = this.originalTableName
+    const tempTableName = `${originalTableName}_velocious_rebuild`
+    const targetTableData = this.targetTableData
+    const previousTargetName = targetTableData.getName()
+
+    targetTableData.setName(tempTableName)
+
+    let createTableSQLs
+
+    try {
+      createTableSQLs = await driver.createTableSql(targetTableData)
+    } finally {
+      targetTableData.setName(previousTargetName)
+    }
+
+    const newColumnsSQL = this.columnPairs.map(([, newName]) => options.quoteColumnName(newName)).join(", ")
+    const oldColumnsSQL = this.columnPairs.map(([oldName]) => options.quoteColumnName(oldName)).join(", ")
+
+    const sqls = []
+
+    for (const sql of createTableSQLs) sqls.push(sql)
+
+    if (this.columnPairs.length > 0) {
+      sqls.push(
+        `INSERT INTO ${options.quoteTableName(tempTableName)} (${newColumnsSQL}) ` +
+        `SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(originalTableName)}`
+      )
+    }
+
+    sqls.push(`DROP TABLE ${options.quoteTableName(originalTableName)}`)
+    sqls.push(`ALTER TABLE ${options.quoteTableName(tempTableName)} RENAME TO ${options.quoteTableName(originalTableName)}`)
+
+    for (const tableDataIndex of targetTableData.getIndexes()) {
+      const createIndexSQLs = await new CreateIndexBase({
+        columns: tableDataIndex.getColumns(),
+        driver,
+        name: tableDataIndex.getName(),
+        tableName: originalTableName,
+        unique: tableDataIndex.getUnique()
+      }).toSQLs()
+
+      for (const sql of createIndexSQLs) sqls.push(sql)
+    }
+
+    return sqls
+  }
+}

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

@@ -0,0 +1,131 @@
+// @ts-check
+
+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 {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../base.js").default} args.driver - Database driver instance.
+   * @param {Record<string, string | number | null>} args.row - Row data.
+   */
+  constructor({driver, row}) {
+    super()
+    this.driver = driver
+    this.row = row
+  }
+
+  /**
+   * Runs get columns.
+   * @returns {Promise<Array<import("../base-column.js").default>>} - Resolves with the columns.
+   */
+  async getColumns() {
+    return await this.getDriver()._cachedTableSchemaMetadata(this.getName(), "columns", async () => {
+      const result = await this.driver.query(`PRAGMA table_info('${this.getName()}')`)
+      const columns = []
+
+      for (const columnData of result) {
+        const column = new Column({column: columnData, driver: this.driver, table: this})
+
+        columns.push(column)
+      }
+
+      return columns
+    })
+  }
+
+  async getForeignKeys() {
+    return await this.getDriver()._cachedTableSchemaMetadata(this.getName(), "foreignKeys", async () => {
+      const foreignKeysData = await this.driver.query(`SELECT * FROM pragma_foreign_key_list(${this.driver.quote(this.getName())})`)
+      const foreignKeys = []
+
+      for (const foreignKeyData of foreignKeysData) {
+        const foreignKey = new ForeignKey(foreignKeyData, {tableName: this.getName()})
+
+        foreignKeys.push(foreignKey)
+      }
+
+      return foreignKeys
+    })
+  }
+
+  async getIndexes() {
+    return await this.getDriver()._cachedTableSchemaMetadata(this.getName(), "indexes", async () => {
+      const rows = await this.getDriver().query(`PRAGMA index_list(${this.getOptions().quoteTableName(this.getName())})`)
+      const indexes = []
+
+      for (const row of rows) {
+        const indexName = row.name
+
+        if (typeof indexName == "string" && indexName.startsWith("sqlite_autoindex_")) {
+          // Skip SQLite internal auto indexes (e.g. primary key / unique constraints)
+          continue
+        }
+
+        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())}`)
+        const sql = indexMasterData[0]?.sql
+
+        if (!sql) throw new Error(`Could not find SQL for index ${columnsIndex.getName()}`)
+
+        const indexData = /**
+                           * Narrows the runtime value to the documented type.
+                            @type {typeof columnsIndex.data & {columnNames?: string[]}} */ (columnsIndex.data)
+
+        indexData.columnNames = this._parseColumnsFromSQL(String(sql))
+
+        indexes.push(columnsIndex)
+      }
+
+      return indexes
+    })
+  }
+
+  /**
+   * Runs parse columns from sql.
+   * @param {string} sql - SQL string.
+   * @returns {string[]} - SQL statements.
+   */
+  _parseColumnsFromSQL(sql) {
+    if (!sql) throw new Error(`Invalid SQL given (${typeof sql}): ${sql}`)
+
+    const columnsSQLMatch = sql.match(/\((.+?)\)/)
+
+    if (!columnsSQLMatch) {
+      throw new Error(`Could not match columns from SQL: ${sql}`)
+    }
+
+    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
+  }
+
+  /**
+   * Runs get name.
+   * @returns {string} - The table name.
+   */
+  getName() {
+    if (!this.row.name) {
+      throw new Error("No name given for SQLite table")
+    }
+
+    return String(this.row.name)
+  }
+}

package/build/database/drivers/structure-sql/utils.js

@@ -0,0 +1,35 @@
+// @ts-check
+
+/**
+ * Runs the normalizeSqlStatement helper.
+ * @param {string} statement - Statement.
+ * @returns {string} - SQL string.
+ */
+export function normalizeSqlStatement(statement) {
+  const trimmed = statement.trim()
+
+  if (!trimmed) return ""
+
+  if (trimmed.endsWith(";")) return trimmed
+
+  return `${trimmed};`
+}
+
+/**
+ * Runs the normalizeCreateStatement helper.
+ * @param {object} args - Options object.
+ * @param {import("../base.js").default} args.db - Database connection.
+ * @param {string} args.objectName - Object name.
+ * @param {string} args.statement - Statement.
+ * @param {string} args.type - Type identifier.
+ * @returns {string} - The create statement.
+ */
+export function normalizeCreateStatement({db, objectName, statement, type}) {
+  const trimmed = statement.trim()
+
+  if (!trimmed) return trimmed
+
+  if (trimmed.toLowerCase().startsWith("create ")) return trimmed
+
+  return `CREATE ${type} ${db.quoteTable(objectName)} AS ${trimmed}`
+}

package/build/database/handler.js

@@ -0,0 +1,13 @@
+// @ts-check
+
+export default class VelociousDatabaseHandler {
+  /**
+   * Runs clone.
+   * @returns {VelociousDatabaseHandler} - The clone.
+   */
+  clone() {
+    const newHandler = new VelociousDatabaseHandler()
+
+    return newHandler
+  }
+}