velocious 1.0.108 → 1.0.109

package/src/database/pool/single-multi-use.js

@@ -1,43 +0,0 @@
-// @ts-check
-
-import BasePool from "./base.js"
-
-export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
-  /**
-   * @param {import("../drivers/base.js").default} _connection
-   */
-  checkin(_connection) { // eslint-disable-line no-unused-vars
-    // Do nothing
-  }
-
-  /**
-   * @returns {Promise<import("../drivers/base.js").default>}
-   */
-  async checkout() {
-    if (!this.connection) {
-      this.connection = await this.spawnConnection()
-    }
-
-    return this.connection
-  }
-
-  /**
-   * @param {function(import("../drivers/base.js").default) : void} callback
-   */
-  async withConnection(callback) {
-    const connection = await this.checkout()
-
-    await callback(connection)
-  }
-
-  /**
-   * @returns {import("../drivers/base.js").default}
-   */
-  getCurrentConnection() {
-    if (!this.connection) {
-      throw new Error("A connection hasn't been made yet")
-    }
-
-    return this.connection
-  }
-}

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

@@ -1,62 +0,0 @@
-// @ts-check
-
-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 {
-  /**
-   * @param {object} args
-   * @param {import("../drivers/base.js").default} args.driver
-   * @param {TableData} args.tableData
-   */
-  constructor({driver, tableData, ...restArgs}) {
-    restArgsError(restArgs)
-
-    if (!(tableData instanceof TableData)) throw new Error("Invalid table data was given")
-
-    super({driver})
-    this.tableData = tableData
-  }
-
-  /**
-   * @returns {Promise<string[]>}
-   */
-  async toSQLs() {
-    const databaseType = this.getDriver().getType()
-    const sqls = []
-    const {tableData} = this
-    const options = this.getOptions()
-
-    let sql = `ALTER TABLE ${options.quoteTableName(tableData.getName())} `
-    let columnsCount = 0
-
-    for (const column of tableData.getColumns()) {
-      if (columnsCount > 0) sql += ", "
-
-      if (column.isNewColumn()) {
-        sql += "ADD "
-        sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
-      } else if (column.getNewName()) {
-        sql += `RENAME COLUMN ${options.quoteColumnName(column.getName())} TO ${options.quoteColumnName(column.getNewName())}`
-      } else if (column.getDropColumn()) {
-        sql += `DROP COLUMN ${options.quoteColumnName}`
-      } else {
-        if (databaseType == "mssql" || databaseType == "pgsql") {
-          sql += "ALTER COLUMN "
-        } else {
-          sql += "MODIFY "
-        }
-
-        sql += column.getSQL({driver: this.getDriver(), forAlterTable: true})
-      }
-
-
-      columnsCount++
-    }
-
-    sqls.push(sql)
-
-    return sqls
-  }
-}

package/src/database/query/base.js

@@ -1,46 +0,0 @@
-// @ts-check
-
-import restArgsError from "../../utils/rest-args-error.js"
-
-export default class VelociousDatabaseQueryBase {
-  /**
-   * @param {object} args
-   * @param {import("../drivers/base.js").default} args.driver
-   * @param {import("../query-parser/options.js").default} [args.options]
-   */
-  constructor({driver, options, ...restArgs}) {
-    restArgsError(restArgs)
-
-    this._driver = driver
-    this._options = options || driver.options()
-
-    if (!this._options) throw new Error("No database options was given or could be gotten from driver")
-  }
-
-  getConfiguration() {
-    return this.getDriver().getConfiguration()
-  }
-
-  getDriver() {
-    return this._driver
-  }
-
-  /**
-   * @returns {import("../query-parser/options.js").default}
-   */
-  getOptions() {
-    return this._options
-  }
-
-  getDatabaseType() {
-    return this.getDriver().getType()
-  }
-
-  /**
-   * @abstract
-   * @returns {Promise<string[]>}
-   */
-  async toSQLs() {
-    throw new Error("'toSQLs' wasn't implemented")
-  }
-}

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

@@ -1,35 +0,0 @@
-// @ts-check
-
-/**
- * @typedef {object} CreateDatabaseArgsType
- * @property {import("../drivers/base.js").default} driver
- * @property {string} databaseName
- * @property {boolean} [ifNotExists]
- */
-
-import QueryBase from "./base.js"
-
-export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
-  /**
-   * @param {CreateDatabaseArgsType} args
-   */
-  constructor({driver, databaseName, ifNotExists}) {
-    super({driver})
-    this.databaseName = databaseName
-    this.ifNotExists = ifNotExists
-  }
-
-  /**
-   * @returns {string[]}
-   */
-  toSql() {
-    const {databaseName} = this
-    let sql = "CREATE DATABASE"
-
-    if (this.ifNotExists) sql += " IF NOT EXISTS"
-
-    sql += ` ${this.getOptions().quoteDatabaseName(databaseName)}`
-
-    return [sql]
-  }
-}

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

@@ -1,114 +0,0 @@
-// @ts-check
-
-import QueryBase from "./base.js"
-
-/**
- * @typedef {object} CreateIndexBaseArgsType
- * @property {Array<string | import("./../table-data/table-column.js").default>} columns
- * @property {import("../drivers/base.js").default} driver
- * @property {boolean} [ifNotExists]
- * @property {string} [name]
- * @property {boolean} [unique]
- * @property {string} tableName
- */
-
-export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
-  /**
-   * @param {CreateIndexBaseArgsType} args
-   */
-  constructor({columns, driver, ifNotExists, name, unique, tableName}) {
-    super({driver})
-    this.columns = columns
-    this.name = name
-    this.tableName = tableName
-    this.ifNotExists = ifNotExists
-    this.unique = unique
-  }
-
-  generateIndexName() {
-    const databaseType = this.getDriver().getType()
-    let indexName = `index_on_`
-    let columnCount = 0
-
-    if (databaseType == "sqlite") indexName += `${this.tableName}_`
-
-    for (const column of this.columns) {
-      columnCount++
-
-      if (columnCount > 1) indexName += "_and_"
-
-      let columnName
-
-      if (typeof column == "string") {
-        columnName = column
-      } else {
-        columnName = column.getName()
-      }
-
-      indexName += columnName
-    }
-
-    return indexName
-  }
-
-  /**
-   * @returns {Promise<string[]>}
-   */
-  async toSQLs() {
-    const databaseType = this.getDriver().getType()
-    const indexName = this.name || this.generateIndexName()
-    const options = this.getOptions()
-    const {tableName} = this
-    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 && databaseType != "mssql") sql += " IF NOT EXISTS"
-
-    sql += ` ${options.quoteIndexName(indexName)}`
-    sql += ` ON ${options.quoteTableName(tableName)} (`
-
-    let columnCount = 0
-
-    for (const column of this.columns) {
-      columnCount++
-
-      if (columnCount > 1) sql += ", "
-
-      let columnName
-
-      if (typeof column == "string") {
-        columnName = column
-      } else {
-        columnName = column.getName()
-      }
-
-      sql += `${options.quoteColumnName(columnName)}`
-    }
-
-    sql += ")"
-
-    if (this.ifNotExists && databaseType == "mssql") {
-      sql += " END"
-    }
-
-    return [sql]
-  }
-}

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

@@ -1,169 +0,0 @@
-// @ts-check
-
-import CreateIndexBase from "./create-index-base.js"
-import QueryBase from "./base.js"
-import restArgsError from "../../utils/rest-args-error.js"
-import TableData from "../table-data/index.js"
-import TableColumn from "../table-data/table-column.js"
-
-export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
-  /**
-   * @param {object} args
-   * @param {import("../drivers/base.js").default} args.driver
-   * @param {boolean} [args.ifNotExists]
-   * @param {boolean} [args.indexInCreateTable]
-   * @param {TableData} args.tableData
-   */
-  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
-    this.tableData = tableData
-  }
-
-  /**
-   * @returns {Promise<string[]>}
-   */
-  async toSql() {
-    const databaseType = this.getDatabaseType()
-    const driver = this.getDriver()
-    const options = this.getOptions()
-    const {tableData} = this
-    const sqls = []
-    const ifNotExists = this.ifNotExists || tableData.getIfNotExists()
-    let sql = ""
-
-    if (databaseType == "mssql" && ifNotExists) {
-      sql += `IF NOT EXISTS(SELECT * FROM [sysobjects] WHERE [name] = ${options.quote(tableData.getName())} AND [xtype] = 'U') BEGIN `
-    }
-
-    sql += "CREATE TABLE"
-
-    if (databaseType != "mssql" && ifNotExists) sql += " IF NOT EXISTS"
-
-    sql += ` ${options.quoteTableName(tableData.getName())} (`
-
-    let columnCount = 0
-
-    for (const column of tableData.getColumns()) {
-      columnCount++
-
-      if (columnCount > 1) sql += ", "
-
-      sql += column.getSQL({driver, forAlterTable: false})
-    }
-
-    if (this.indexInCreateTable) {
-      for (const index of tableData.getIndexes()) {
-        sql += ","
-
-        if (index.getUnique()) {
-          sql += " UNIQUE"
-        }
-
-        sql += " INDEX"
-
-        if (index.getName()) {
-          sql += ` ${options.quoteIndexName(index.getName())}`
-        }
-
-        sql += " ("
-
-        index.getColumns().forEach((column, columnIndex) => {
-          if (columnIndex > 0) sql += ", "
-
-          if (column instanceof TableColumn) {
-            sql += driver.quoteColumn(column.getName())
-          } else if (typeof column == "string") {
-            sql += driver.quoteColumn(column)
-          } else {
-            throw new Error(`Unknown column type: ${typeof column}`)
-          }
-        })
-
-        sql += ")"
-      }
-
-      // Create indexes for all columns with the index argument
-      for (const column of tableData.getColumns()) {
-        if (!column.getIndex()) continue
-
-        let indexName = `index_on_`
-
-        if (databaseType == "sqlite") sql += `${tableData.getName()}_`
-
-        indexName += column.getName()
-
-        sql += ","
-
-        const {unique, ...restIndexArgs} = column.getIndexArgs()
-
-        restArgsError(restIndexArgs)
-
-        if (unique) {
-          sql += " UNIQUE"
-        }
-
-        sql += ` INDEX ${options.quoteIndexName(indexName)} (${options.quoteColumnName(column.getName())})`
-      }
-    }
-
-    sql += ")"
-
-    if (databaseType == "mssql" && ifNotExists) {
-      sql += " END"
-    }
-
-    sqls.push(sql)
-
-    if (!this.indexInCreateTable) {
-      for (const index of tableData.getIndexes()) {
-        const createIndexArgs = {
-          columns: index.getColumns(),
-          driver: this.getDriver(),
-          ifNotExists: true,
-          name: index.getName(),
-          tableName: tableData.getName(),
-          unique: index.getUnique()
-        }
-        const createIndexSQLs = await new CreateIndexBase(createIndexArgs).toSQLs()
-
-        for (const createIndexSQL of createIndexSQLs) {
-          sqls.push(createIndexSQL)
-        }
-      }
-
-      // Create indexes for all columns with the index argument
-      for (const column of tableData.getColumns()) {
-        if (!column.getIndex()) continue
-
-        const {unique, ...restIndexArgs} = column.getIndexArgs()
-
-        restArgsError(restIndexArgs)
-
-        let indexName = `index_on_`
-
-        if (databaseType == "sqlite") indexName += `${tableData.getName()}_`
-
-        indexName += column.getName()
-
-        const createIndexArgs = {
-          columns: [column.getName()],
-          driver: this.getDriver(),
-          name: indexName,
-          tableName: tableData.getName(),
-          unique
-        }
-        const createIndexSQLs = await new CreateIndexBase(createIndexArgs).toSQLs()
-
-        for (const createIndexSQL of createIndexSQLs) {
-          sqls.push(createIndexSQL)
-        }
-      }
-    }
-
-    return sqls
-  }
-}

package/src/database/query/delete-base.js

@@ -1,17 +0,0 @@
-// @ts-check
-
-import QueryBase from "./base.js"
-
-export default class VelociousDatabaseQueryDeleteBase extends QueryBase {
-  /**
-   * @param {object} args
-   * @param {Record<string, any>} args.conditions
-   * @param {import("../drivers/base.js").default} args.driver
-   * @param {string} args.tableName
-   */
-  constructor({conditions, driver, tableName}) {
-    super({driver})
-    this.conditions = conditions
-    this.tableName = tableName
-  }
-}

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

@@ -1,56 +0,0 @@
-// @ts-check
-
-import QueryBase from "./base.js"
-import restArgsError from "../../utils/rest-args-error.js"
-
-export default class VelociousDatabaseQueryDropTableBase extends QueryBase {
-  /**
-   * @param {object} args
-   * @param {boolean} [args.cascade]
-   * @param {import("./../drivers/base.js").default} args.driver
-   * @param {boolean} [args.ifExists]
-   * @param {string} args.tableName
-   */
-  constructor({cascade, driver, ifExists, tableName, ...restArgs}) {
-    super({driver})
-
-    restArgsError(restArgs)
-
-    this.cascade = cascade
-    this.ifExists = ifExists
-    this.tableName = tableName
-  }
-
-  /**
-   * @returns {Promise<string[]>}
-   */
-  async toSQLs() {
-    const databaseType = this.getDatabaseType()
-    const options = this.getOptions()
-    const {cascade, ifExists, tableName} = this
-    const sqls = []
-    let sql = ""
-
-    if (databaseType == "mssql" && ifExists) {
-      sql += `IF EXISTS(SELECT * FROM [sysobjects] WHERE [name] = ${options.quote(tableName)} AND [xtype] = 'U') BEGIN `
-    }
-
-    sql += "DROP TABLE"
-
-    if (databaseType != "mssql" && ifExists) sql += " IF EXISTS"
-
-    sql += ` ${options.quoteTableName(tableName)}`
-
-    if (cascade && databaseType == "pgsql") {
-      sql += " cascade"
-    }
-
-    if (databaseType == "mssql" && ifExists) {
-      sql += " END"
-    }
-
-    sqls.push(sql)
-
-    return sqls
-  }
-}

package/src/database/query/from-base.js

@@ -1,31 +0,0 @@
-// @ts-check
-
-export default class VelociousDatabaseQueryFromBase {
-  /** @type {import("./index.js").default  | null} */
-  query = null
-
-  /**
-   * @param {import("./index.js").default} query
-   * @returns {void}
-   */
-  setQuery(query) {
-    this.query = query
-  }
-
-  /**
-   * @returns {import("../query-parser/options.js").default}
-   */
-  getOptions() {
-    if (!this.query) throw new Error("'query' hasn't been set")
-
-    return this.query.getOptions()
-  }
-
-  /**
-   * @abstract
-   * @returns {string[]}
-   */
-  toSql() {
-    throw new Error("'toSql' wasn't implemented")
-  }
-}

package/src/database/query/from-plain.js

@@ -1,15 +0,0 @@
-// @ts-check
-
-import FromBase from "./from-base.js"
-
-export default class VelociousDatabaseQueryFromPlain extends FromBase {
-  /**
-   * @param {string} plain
-   */
-  constructor(plain) {
-    super()
-    this.plain = plain
-  }
-
-  toSql() { return [this.plain] }
-}

package/src/database/query/from-table.js

@@ -1,17 +0,0 @@
-// @ts-check
-
-import FromBase from "./from-base.js"
-
-export default class VelociousDatabaseQueryFromTable extends FromBase {
-  /**
-   * @param {string} tableName
-   */
-  constructor(tableName) {
-    super()
-    this.tableName = tableName
-  }
-
-  toSql() {
-    return [this.getOptions().quoteTableName(this.tableName)]
-  }
-}