velocious 1.0.108 → 1.0.109

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

@@ -1,132 +0,0 @@
-// @ts-check
-
-import BaseTable from "../base-table.js"
-import Column from "./column.js"
-import ColumnsIndex from "./columns-index.js"
-import {digg} from "diggerize"
-import ForeignKey from "./foreign-key.js"
-
-export default class VelociousDatabaseDriversMssqlTable extends BaseTable {
-  /**
-   * @param {import("../base.js").default} driver
-   * @param {Record<string, any>} data
-   */
-  constructor(driver, data) {
-    super()
-    this.data = data
-    this.driver = driver
-  }
-
-  async getColumns() {
-    const result = await this.driver.query(`
-      SELECT
-        *,
-        COLUMNPROPERTY(object_id(TABLE_SCHEMA + '.' + TABLE_NAME), COLUMN_NAME, 'IsIdentity') AS isIdentity
-      FROM [INFORMATION_SCHEMA].[COLUMNS]
-      WHERE [TABLE_NAME] = ${this.driver.quote(this.getName())}
-    `)
-    const columns = []
-
-    for (const data of result) {
-      const column = new Column(this, data)
-
-      columns.push(column)
-    }
-
-    return columns
-  }
-
-  async getForeignKeys() {
-    const sql = `
-      SELECT
-          fk.name AS ForeignKeyName,
-          tp.name AS ParentTable,
-          ref.name AS ReferencedTable,
-          cp.name AS ParentColumn,
-          cref.name AS ReferencedColumn,
-          tp.name AS TableName
-      FROM sys.foreign_keys fk
-      INNER JOIN sys.foreign_key_columns fkc
-          ON fkc.constraint_object_id = fk.object_id
-      INNER JOIN sys.tables tp
-          ON fkc.parent_object_id = tp.object_id
-      INNER JOIN sys.columns cp
-          ON fkc.parent_object_id = cp.object_id
-          AND fkc.parent_column_id = cp.column_id
-      INNER JOIN sys.tables ref
-          ON fkc.referenced_object_id = ref.object_id
-      INNER JOIN sys.columns cref
-          ON fkc.referenced_object_id = cref.object_id
-          AND fkc.referenced_column_id = cref.column_id
-      WHERE tp.name = ${this.driver.quote(this.getName())}
-      ORDER BY ForeignKeyName, ParentTable, ReferencedTable;
-    `
-
-    const foreignKeyRows = await this.driver.query(sql)
-    const foreignKeys = []
-
-    for (const foreignKeyRow of foreignKeyRows) {
-      const foreignKey = new ForeignKey(foreignKeyRow)
-
-      foreignKeys.push(foreignKey)
-    }
-
-    return foreignKeys
-  }
-
-  async getIndexes() {
-    const options = this.getOptions()
-    const sql = `
-      SELECT
-        sys.tables.name AS TableName,
-        sys.columns.name AS ColumnName,
-        sys.indexes.name AS index_name,
-        sys.indexes.type_desc AS IndexType,
-        sys.index_columns.is_included_column AS IsIncludedColumn,
-        sys.indexes.is_unique,
-        sys.indexes.is_primary_key,
-        sys.indexes.is_unique_constraint
-      FROM sys.indexes
-      INNER JOIN sys.index_columns ON sys.indexes.object_id = sys.index_columns.object_id AND sys.indexes.index_id = sys.index_columns.index_id
-      INNER JOIN sys.columns ON sys.index_columns.object_id = sys.columns.object_id AND sys.index_columns.column_id = sys.columns.column_id
-      INNER JOIN sys.tables ON sys.indexes.object_id = sys.tables.object_id
-      WHERE
-        sys.tables.name = ${options.quote(this.getName())}
-      ORDER BY
-        sys.indexes.name,
-        sys.index_columns.key_ordinal
-    `
-
-    const rows = await this.getDriver().query(sql)
-    const indexes = []
-
-    for (const row of rows) {
-      const index = new ColumnsIndex(this, row)
-
-      indexes.push(index)
-    }
-
-    return indexes
-  }
-
-  getName() {
-    return digg(this.data, "TABLE_NAME")
-  }
-
-  /**
-   * @param {{cascade: boolean}} [args]
-   * @returns {Promise<Array<Record<string, any>>>}
-   */
-  async truncate(args) { // eslint-disable-line no-unused-vars
-    try {
-      return await this.getDriver().query(`TRUNCATE TABLE ${this.getOptions().quoteTableName(this.getName())}`)
-    } catch (error) {
-      if (error instanceof Error && error.message.startsWith("Query failed 'Cannot truncate table")) {
-        // Truncate table is really buggy for some reason - fall back to delete all rows instead
-        return await this.getDriver().query(`DELETE FROM ${this.getOptions().quoteTableName(this.getName())}`)
-      } else {
-        throw error
-      }
-    }
-  }
-}

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

@@ -1,105 +0,0 @@
-// @ts-check
-
-import BaseColumn from "../base-column.js"
-import ColumnsIndex from "./columns-index.js"
-import {digg} from "diggerize"
-
-export default class VelociousDatabaseDriversMysqlColumn extends BaseColumn {
-  /**
-   * @param {import("../base-table.js").default} table
-   * @param {Record<string, any>} data
-   */
-  constructor(table, data) {
-    super()
-    this.data = data
-    this.table = table
-  }
-
-  getAutoIncrement() { return digg(this, "data", "Extra").includes("auto_increment") }
-
-  async getIndexes() {
-    const options = this.getOptions()
-    const sql = `
-      SELECT
-        TABLE_SCHEMA,
-        TABLE_NAME,
-        INDEX_NAME AS index_name,
-        COLUMN_NAME,
-        SEQ_IN_INDEX,
-        NON_UNIQUE,
-        INDEX_TYPE
-      FROM INFORMATION_SCHEMA.STATISTICS
-      WHERE
-        TABLE_SCHEMA = DATABASE() AND
-        TABLE_NAME = ${options.quote(this.table.getName())} AND
-        COLUMN_NAME = ${options.quote(this.getName())}
-    `
-    const indexesRows = await this.getDriver().query(sql)
-    const indexes = []
-
-    for (const indexRow of indexesRows) {
-      if (indexRow.NON_UNIQUE == 1) {
-        indexRow.is_unique = false
-      } else {
-        indexRow.is_unique = true
-      }
-
-      if (indexRow.index_name == "PRIMARY") {
-        indexRow.is_primary_key = true
-      } else {
-        indexRow.is_primary_key = false
-      }
-
-      const index = new ColumnsIndex(this.getTable(), indexRow)
-
-      indexes.push(index)
-    }
-
-    return indexes
-  }
-
-  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}`)
-    }
-  }
-
-  getPrimaryKey() { return digg(this, "data", "Key") == "PRI" }
-
-  getType() {
-    const type = digg(this, "data", "Type")
-
-    if (type.match(/^[a-z]+$/)) {
-      return type
-    }
-
-    const match = type.match(/^(.+)\((\d+)\)$/)
-
-    if (!match) throw new Error(`Couldn't match column type from: ${type}`)
-
-    const columnType = match[1]
-
-    return columnType
-  }
-}

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

@@ -1,6 +0,0 @@
-// @ts-check
-
-import BaseColumnsIndex from "../base-columns-index.js"
-
-export default class VelociousDatabaseDriversMysqlColumnsIndex extends BaseColumnsIndex {
-}

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

@@ -1,12 +0,0 @@
-// @ts-check
-
-import BaseForeignKey from "../base-foreign-key.js"
-import {digg} from "diggerize"
-
-export default class VelociousDatabaseDriversMysqlForeignKey extends BaseForeignKey {
-  getColumnName() { return digg(this, "data", "COLUMN_NAME") }
-  getName() { return digg(this, "data", "CONSTRAINT_NAME") }
-  getTableName() { return digg(this, "data", "TABLE_NAME") }
-  getReferencedColumnName() { return digg(this, "data", "REFERENCED_COLUMN_NAME") }
-  getReferencedTableName() { return digg(this, "data", "REFERENCED_TABLE_NAME") }
-}

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

@@ -1,275 +0,0 @@
-// @ts-check
-
-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"
-import CreateTable from "./sql/create-table.js"
-import Delete from "./sql/delete.js"
-import {digg} from "diggerize"
-import DropTable from "./sql/drop-table.js"
-import Insert from "./sql/insert.js"
-import Options from "./options.js"
-import mysql from "mysql"
-import query from "./query.js"
-import QueryParser from "./query-parser.js"
-import Table from "./table.js"
-import Update from "./sql/update.js"
-
-export default class VelociousDatabaseDriversMysql extends Base{
-  /**
-   * @returns {Promise<void>}
-   */
-  async connect() {
-    this.pool = mysql.createPool(Object.assign({connectionLimit: 1}, this.connectArgs()))
-    this.pool.on("error", this.onPoolError)
-  }
-
-  /** @param {Error} error */
-  onPoolError = (error) => {
-    console.error("Velocious / MySQL driver / Pool error", error)
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async close() {
-    await this.pool?.end()
-    this.pool = undefined
-  }
-
-  /**
-   * @returns {Record<string, any>}
-   */
-  connectArgs() {
-    const args = this.getArgs()
-    const forward = ["database", "host", "password"]
-
-    /** @type {Record<string, any>} */
-    const connectArgs = {}
-
-    for (const forwardValue of forward) {
-      if (forwardValue in args) connectArgs[forwardValue] = digg(args, forwardValue)
-    }
-
-    if ("username" in args) connectArgs["user"] = args["username"]
-
-    return connectArgs
-  }
-
-  /**
-   * @param {import("../../table-data/index.js").default} tableData
-   * @returns {Promise<string[]>}
-   */
-  async alterTableSQLs(tableData) {
-    const alterArgs = {tableData, driver: this}
-    const alterTable = new AlterTable(alterArgs)
-
-    return await alterTable.toSQLs()
-  }
-
-  /**
-   * @param {string} databaseName
-   * @param {object} [args]
-   * @param {boolean} [args.ifNotExists]
-   * @returns {string[]}
-   */
-  createDatabaseSql(databaseName, args) {
-    const createArgs = Object.assign({databaseName, driver: this}, args)
-    const createDatabase = new CreateDatabase(createArgs)
-
-    return createDatabase.toSql()
-  }
-
-  /**
-   * @param {import("../base.js").CreateIndexSqlArgs} indexData
-   * @returns {Promise<string[]>}
-   */
-  async createIndexSQLs(indexData) {
-    const createArgs = Object.assign({driver: this}, indexData)
-    const createIndex = new CreateIndex(createArgs)
-
-    return await createIndex.toSQLs()
-  }
-
-  /**
-   * @param {import("../../table-data/index.js").default} tableData
-   * @returns {Promise<string[]>}
-   */
-  async createTableSql(tableData) {
-    const createArgs = {tableData, driver: this}
-    const createTable = new CreateTable(createArgs)
-
-    return createTable.toSql()
-  }
-
-  /**
-   * @returns {Promise<string>}
-   */
-  async currentDatabase() {
-    const rows = await this.query("SELECT DATABASE() AS db_name")
-
-    return digg(rows, 0, "db_name")
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async disableForeignKeys() {
-    await this.query("SET FOREIGN_KEY_CHECKS = 0")
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async enableForeignKeys() {
-    await this.query("SET FOREIGN_KEY_CHECKS = 1")
-  }
-
-  /**
-   * @param {string} tableName
-   * @param {import("../base.js").DropTableSqlArgsType} [args]
-   * @returns {Promise<string[]>}
-   */
-  async dropTableSQLs(tableName, args = {}) {
-    const dropArgs = Object.assign({tableName, driver: this}, args)
-    const dropTable = new DropTable(dropArgs)
-
-    return await dropTable.toSQLs()
-  }
-
-  /**
-   * @returns {string}
-   */
-  getType() { return "mysql" }
-
-  /**
-   * @returns {string}
-   */
-  primaryKeyType() { return "bigint" }
-
-  /**
-   * @param {string} sql
-   * @returns {Promise<import("../base.js").QueryResultType>}
-   */
-  async _queryActual(sql) {
-    if (!this.pool) throw new Error("Not connected to a pool yet")
-
-    try {
-      return await query(this.pool, sql)
-    } catch (error) {
-      // Re-throw to un-corrupt stacktrace
-      if (error instanceof Error) {
-        throw new Error(`Query failed: ${error.message}`)
-      } else {
-        throw new Error(`Query failed: ${error}`)
-      }
-    }
-  }
-
-  /**
-   * @param {import("../../query/index.js").default} query
-   * @returns {string}
-   */
-  queryToSql(query) { return new QueryParser({query}).toSql() }
-
-  /**
-   * @returns {boolean}
-   */
-  shouldSetAutoIncrementWhenPrimaryKey() { return true }
-
-  /**
-   * @param {any} value
-   * @returns {any}
-   */
-  escape(value) {
-    if (!this.pool) throw new Error("Can't escape before connected")
-
-    const escapedValueWithQuotes = this.pool.escape(this._convertValue(value))
-
-    return escapedValueWithQuotes.slice(1, escapedValueWithQuotes.length - 1)
-  }
-
-  /**
-   * @param {string} value
-   * @returns {string}
-   */
-  quote(value) {
-    if (!this.pool) throw new Error("Can't escape before connected")
-
-    return this.pool.escape(this._convertValue(value))
-  }
-
-  /**
-   * @param {import("../base.js").DeleteSqlArgsType} args
-   * @returns {string}
-   */
-  deleteSql({tableName, conditions}) {
-    const deleteInstruction = new Delete({conditions, driver: this, tableName})
-
-    return deleteInstruction.toSql()
-  }
-
-  /**
-   * @abstract
-   * @param {import("../base.js").InsertSqlArgsType} args
-   * @returns {string}
-   */
-  insertSql(args) {
-    const insertArgs = Object.assign({driver: this}, args)
-    const insert = new Insert(insertArgs)
-
-    return insert.toSql()
-  }
-
-  /**
-   * @returns {Promise<Array<import("../base-table.js").default>>}
-   */
-  async getTables() {
-    const result = await this.query("SHOW FULL TABLES")
-    const tables = []
-
-    for (const row of result) {
-      const table = new Table(this, row)
-
-      tables.push(table)
-    }
-
-    return tables
-  }
-
-  /**
-   * @returns {Promise<number>}
-   */
-  async lastInsertID() {
-    const result = await this.query("SELECT LAST_INSERT_ID() AS last_insert_id")
-
-    return digg(result, 0, "last_insert_id")
-  }
-
-  /**
-   * @returns {Options}
-   */
-  options() {
-    if (!this._options) this._options = new Options({driver: this})
-
-    return this._options
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async _startTransactionAction() {
-    await this.query("START TRANSACTION")
-  }
-
-  /**
-   * @param {import("../base.js").UpdateSqlArgsType} args
-   * @returns {string}
-   */
-  updateSql({conditions, data, tableName}) {
-    const update = new Update({conditions, data, driver: this, tableName})
-
-    return update.toSql()
-  }
-}

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

@@ -1,31 +0,0 @@
-// @ts-check
-
-import QueryParserOptions from "../../query-parser/options.js"
-
-export default class VelociousDatabaseDriversMysqlOptions extends QueryParserOptions {
-  /**
-   * @param {object} args
-   * @param {import("../base.js").default} args.driver
-   */
-  constructor({driver}) {
-    const options = {
-      driver,
-      columnQuote: "`",
-      indexQuote: "`",
-      stringQuote: "'",
-      tableQuote: "`"
-    }
-
-    super(options)
-  }
-
-  /**
-   * @param {any} string
-   * @returns {number | string}
-   */
-  quote(string) {
-    if (!this.driver) throw new Error("Driver not set")
-
-    return this.driver.quote(string)
-  }
-}

package/src/database/drivers/mysql/query-parser.js

@@ -1,6 +0,0 @@
-// @ts-check
-
-import BaseQueryParser from "../../query-parser/base-query-parser.js"
-
-export default class VelociousDatabaseConnectionDriversMysqlQueryParser extends BaseQueryParser {
-}

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

@@ -1,31 +0,0 @@
-/**
- * @param {import("mysql").Pool} pool
- * @param {string} sql
- */
-export default async function query(pool, sql) {
-  return new Promise((resolve, reject) => {
-    pool.query(sql, (error, results, fields) => {
-      if (error) {
-        reject(new Error(`Query failed because of ${error}: ${sql}`))
-      } else {
-        const rows = []
-
-        for (const resultIndex in results) {
-          /** @type {Record<string, any>} */
-          const result = {}
-
-          for (const fieldKey in fields) {
-            const field = fields[fieldKey].name
-            const value = results[resultIndex][field]
-
-            result[field] = value
-          }
-
-          rows.push(result)
-        }
-
-        resolve(rows)
-      }
-    })
-  })
-}

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

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

package/src/database/drivers/mysql/sql/create-database.js

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

package/src/database/drivers/mysql/sql/create-index.js

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

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

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

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

@@ -1,21 +0,0 @@
-// @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)} 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/src/database/drivers/mysql/sql/drop-table.js

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

package/src/database/drivers/mysql/sql/insert.js

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