velocious 1.0.430 → 1.0.432

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

@@ -0,0 +1,42 @@
+// @ts-check
+
+/**
+ * CreateDatabaseArgsType type.
+ * @typedef {object} CreateDatabaseArgsType
+ * @property {import("../drivers/base.js").default} driver - Database driver used to generate SQL.
+ * @property {string} databaseName - Name of the database to create.
+ * @property {boolean} [ifNotExists] - Skip creation if the database already exists.
+ * @property {string} [databaseCharset] - Database-default character set (driver-specific; currently used by mysql).
+ * @property {string} [databaseCollation] - Database-default collation (driver-specific; currently used by mysql).
+ */
+
+import QueryBase from "./base.js"
+
+export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
+  /**
+   * Runs constructor.
+   * @param {CreateDatabaseArgsType} args - Options object.
+   */
+  constructor({driver, databaseName, ifNotExists, databaseCharset, databaseCollation}) {
+    super({driver})
+    this.databaseName = databaseName
+    this.ifNotExists = ifNotExists
+    this.databaseCharset = databaseCharset
+    this.databaseCollation = databaseCollation
+  }
+
+  /**
+   * Runs to sql.
+   * @returns {string[]} - SQL statements.
+   */
+  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

@@ -0,0 +1,117 @@
+// @ts-check
+
+import QueryBase from "./base.js"
+
+/**
+ * CreateIndexBaseArgsType type.
+ * @typedef {object} CreateIndexBaseArgsType
+ * @property {Array<string | import("./../table-data/table-column.js").default>} columns - Columns to include in the index.
+ * @property {import("../drivers/base.js").default} driver - Database driver used to generate SQL.
+ * @property {boolean} [ifNotExists] - Skip creation if the index already exists.
+ * @property {string} [name] - Explicit index name to use.
+ * @property {boolean} [unique] - Whether the index should enforce uniqueness.
+ * @property {string} tableName - Name of the table to add the index to.
+ */
+
+export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
+  /**
+   * Runs constructor.
+   * @param {CreateIndexBaseArgsType} args - Options object.
+   */
+  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
+  }
+
+  /**
+   * Runs to sqls.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  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

@@ -0,0 +1,205 @@
+// @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 {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../drivers/base.js").default} args.driver - Database driver instance.
+   * @param {boolean} [args.ifNotExists] - Whether if not exists.
+   * @param {boolean} [args.indexInCreateTable] - Whether index in create table.
+   * @param {TableData} args.tableData - Table data.
+   */
+  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
+  }
+
+  /**
+   * Runs to sql.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  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())} (`
+
+    const tableLevelFKColumnNames = new Set(tableData.getForeignKeys().map((foreignKey) => foreignKey.getColumnName()))
+
+    let columnCount = 0
+
+    for (const column of tableData.getColumns()) {
+      columnCount++
+
+      if (columnCount > 1) sql += ", "
+
+      sql += column.getSQL({driver, forAlterTable: false, skipForeignKey: tableLevelFKColumnNames.has(column.getActualName())})
+    }
+
+    for (const foreignKey of tableData.getForeignKeys()) {
+      sql += ", "
+
+      if (foreignKey.getName()) {
+        sql += `CONSTRAINT ${options.quoteIndexName(foreignKey.getName())} `
+      }
+
+      sql += `FOREIGN KEY (${options.quoteColumnName(foreignKey.getColumnName())})`
+      sql += ` REFERENCES ${options.quoteTableName(foreignKey.getReferencedTableName())} (${options.quoteColumnName(foreignKey.getReferencedColumnName())})`
+    }
+
+    if (this.indexInCreateTable) {
+      for (const index of tableData.getIndexes()) {
+        sql += ","
+
+        if (index.getUnique()) {
+          sql += " UNIQUE"
+        }
+
+        sql += " INDEX"
+
+        if (index.getName()) {
+          const indexName = index.getName()
+
+          if (!indexName) throw new Error("Expected index name")
+
+          sql += ` ${options.quoteIndexName(indexName)}`
+        }
+
+        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 == "mysql") {
+      sql += " DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci"
+    }
+
+    if (databaseType == "mssql" && ifNotExists) {
+      sql += " END"
+    }
+
+    sqls.push(sql)
+
+    if (databaseType == "pgsql") {
+      for (const column of tableData.getColumns()) {
+        const notes = column.getNotesForDatabase(databaseType)
+        const actualName = column.getActualName()
+
+        if (!notes || !actualName) continue
+
+        sqls.push(
+          `COMMENT ON COLUMN ${options.quoteTableName(tableData.getName())}.${options.quoteColumnName(actualName)} IS ${options.quote(notes)}`
+        )
+      }
+    }
+
+    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

@@ -0,0 +1,19 @@
+// @ts-check
+
+import QueryBase from "./base.js"
+
+export default class VelociousDatabaseQueryDeleteBase extends QueryBase {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {Record<string, ?>} args.conditions - Conditions.
+   * @param {import("../drivers/base.js").default} args.driver - Database driver instance.
+   * @param {string} args.tableName - Table name.
+   */
+  constructor({conditions, driver, tableName}) {
+    super({driver})
+    this.conditions = conditions
+    this.tableName = tableName
+  }
+}
+

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

@@ -0,0 +1,38 @@
+// @ts-check
+
+/**
+ * DropDatabaseArgsType type.
+ * @typedef {object} DropDatabaseArgsType
+ * @property {import("../drivers/base.js").default} driver - Database driver used to generate SQL.
+ * @property {string} databaseName - Name of the database to drop.
+ * @property {boolean} [ifExists] - Skip drop if the database does not exist.
+ */
+
+import QueryBase from "./base.js"
+
+export default class VelociousDatabaseQueryDropDatabaseBase extends QueryBase {
+  /**
+   * Runs constructor.
+   * @param {DropDatabaseArgsType} args - Options object.
+   */
+  constructor({driver, databaseName, ifExists}) {
+    super({driver})
+    this.databaseName = databaseName
+    this.ifExists = ifExists
+  }
+
+  /**
+   * Runs to sql.
+   * @returns {string[]} - SQL statements.
+   */
+  toSql() {
+    const {databaseName} = this
+    let sql = "DROP DATABASE"
+
+    if (this.ifExists) sql += " IF EXISTS"
+
+    sql += ` ${this.getOptions().quoteDatabaseName(databaseName)}`
+
+    return [sql]
+  }
+}

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

@@ -0,0 +1,58 @@
+// @ts-check
+
+import QueryBase from "./base.js"
+import restArgsError from "../../utils/rest-args-error.js"
+
+export default class VelociousDatabaseQueryDropTableBase extends QueryBase {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {boolean} [args.cascade] - Whether cascade.
+   * @param {import("./../drivers/base.js").default} args.driver - Database driver instance.
+   * @param {boolean} [args.ifExists] - Whether if exists.
+   * @param {string} args.tableName - Table name.
+   */
+  constructor({cascade, driver, ifExists, tableName, ...restArgs}) {
+    super({driver})
+
+    restArgsError(restArgs)
+
+    this.cascade = cascade
+    this.ifExists = ifExists
+    this.tableName = tableName
+  }
+
+  /**
+   * Runs to sqls.
+   * @returns {Promise<string[]>} - Resolves with SQL statements.
+   */
+  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

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

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

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

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

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