velocious 1.0.108 → 1.0.109

package/src/database/query/index.js

@@ -1,530 +0,0 @@
-// @ts-check
-
-/**
- * @typedef {{[key: string]: boolean | NestedPreloadRecord }} NestedPreloadRecord
- * @typedef {string | string[] | import("./select-base.js").default | import("./select-base.js").default[]} SelectArgumentType
- * @typedef {object | string} WhereArgumentType
- */
-
-import FromPlain from "./from-plain.js"
-import {incorporate} from "incorporator"
-import * as inflection from "inflection"
-import {isPlainObject} from "is-plain-object"
-import JoinObject from "./join-object.js"
-import JoinPlain from "./join-plain.js"
-import {Logger} from "../../logger.js"
-import OrderPlain from "./order-plain.js"
-import Preloader from "./preloader.js"
-import RecordNotFoundError from "../record/record-not-found-error.js"
-import SelectBase from "./select-base.js"
-import SelectPlain from "./select-plain.js"
-import WhereHash from "./where-hash.js"
-import WherePlain from "./where-plain.js"
-import restArgsError from "../../utils/rest-args-error.js"
-
-/**
- * A generic query over some model type.
- */
-export default class VelociousDatabaseQuery {
-  /**
-   * @param {object} args
-   * @param {import("../drivers/base.js").default} args.driver
-   * @param {Array<import("./from-base.js").default>} [args.froms]
-   * @param {string[]} [args.groups]
-   * @param {Array<import("./join-base.js").default>} [args.joins]
-   * @param {import("../handler.js").default} args.handler
-   * @param {number | null} [args.limit]
-   * @param {typeof import("../record/index.js").default} [args.modelClass]
-   * @param {number | null} [args.offset]
-   * @param {Array<import("./order-base.js").default>} [args.orders]
-   * @param {number | null} [args.page]
-   * @param {number} [args.perPage]
-   * @param {NestedPreloadRecord} [args.preload]
-   * @param {Array<import("./select-base.js").default>} [args.selects]
-   * @param {Array<import("./where-base.js").default>} [args.wheres]
-   */
-  constructor({
-    driver,
-    froms = [],
-    groups = [],
-    joins = [],
-    handler,
-    limit = null,
-    modelClass,
-    offset = null,
-    orders = [],
-    page = null,
-    perPage,
-    preload = {},
-    selects = [],
-    wheres = [],
-    ...restArgs
-  }) {
-    if (!driver) throw new Error("No driver given to query")
-    if (!handler) throw new Error("No handler given to query")
-
-    restArgsError(restArgs)
-
-    this.driver = driver
-
-    this.handler = handler
-    this.logger = new Logger(this)
-    this.modelClass = modelClass
-    this._froms = froms
-    this._groups = groups
-    this._joins = joins
-    this._limit = limit
-    this._offset = offset
-    this._orders = orders
-    this._page = page
-    this._perPage = perPage
-    this._preload = preload
-    this._selects = selects
-
-    /** @type {import("./where-base.js").default[]} */
-    this._wheres = wheres
-  }
-
-  /**
-   * @returns {VelociousDatabaseQuery}
-   */
-  clone() {
-    const newQuery = new VelociousDatabaseQuery({
-      driver: this.driver,
-      froms: [...this._froms],
-      handler: this.handler.clone(),
-      groups: [...this._groups],
-      joins: [...this._joins],
-      limit: this._limit,
-      modelClass: this.modelClass,
-      offset: this._offset,
-      orders: [...this._orders],
-      page: this._page,
-      perPage: this._perPage,
-      preload: {...this._preload},
-      selects: [...this._selects],
-      wheres: [...this._wheres]
-    })
-
-    return newQuery
-  }
-
-  /**
-   * @returns {Promise<number>}
-   */
-  async count() {
-    // Generate count SQL
-    let sql = `COUNT(${this.driver.quoteTable(this.getModelClass().tableName())}.${this.driver.quoteColumn(this.getModelClass().primaryKey())})`
-
-    if (this.driver.getType() == "pgsql") sql += "::int"
-
-    sql += " AS count"
-
-
-    // Clone query and execute count
-    const countQuery = this.clone()
-
-    countQuery._selects = []
-    countQuery.select(sql)
-
-    const results = /** @type {{ count: number }[]} */ (await countQuery._executeQuery())
-
-
-    // The query isn't grouped and a single result has been given
-    if (results.length == 1) {
-      return results[0].count
-    }
-
-
-    // The query may be grouped and a lot of different counts a given
-    let countResult = 0
-
-    for (const result of results) {
-      if (!("count" in result)) {
-        throw new Error("Invalid count result")
-      }
-
-      countResult += result.count
-    }
-
-    return countResult
-  }
-
-  /**
-   * @returns {import("./from-base.js").default[]}
-   */
-  getFroms() {
-    return this._froms
-  }
-
-  /**
-   * @returns {string[]}
-   */
-  getGroups() {
-    return this._groups
-  }
-
-  /**
-   * @returns {typeof import("../record/index.js").default}
-   */
-  getModelClass() {
-    if (!this.modelClass) throw new Error("modelClass not set")
-
-    return this.modelClass
-  }
-
-  /**
-   * @returns {import("../query-parser/options.js").default}
-   */
-  getOptions() { return this.driver.options() }
-
-  /**
-   * @returns {Array<import("./select-base.js").default>}
-   */
-  getSelects() { return this._selects }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async destroyAll() {
-    const records = await this.toArray()
-
-    for (const record of records) {
-      await record.destroy()
-    }
-  }
-
-  /**
-   * @param {number|string} recordId
-   * @returns {Promise<import("../record/index.js").default>}
-   */
-  async find(recordId) {
-    /** @type {{[key: string]: number | string}} */
-    const conditions = {}
-
-    conditions[this.getModelClass().primaryKey()] = recordId
-
-    const query = this.clone().where(conditions)
-    const record = await query.first()
-
-    if (!record) {
-      throw new RecordNotFoundError(`Couldn't find ${this.getModelClass().name} with '${this.getModelClass().primaryKey()}'=${recordId}`)
-    }
-
-    return record
-  }
-
-  /**
-   * @param {{[key: string]: any}} conditions
-   * @returns {Promise<import("../record/index.js").default|null>}
-   */
-  async findBy(conditions) {
-    /** @type {{[key: string]: number | string}} */
-    const newConditions = {}
-
-    for (const key in conditions) {
-      const keyUnderscore = inflection.underscore(key)
-
-      newConditions[keyUnderscore] = conditions[key]
-    }
-
-    return await this.clone().where(newConditions).first()
-  }
-
-  /**
-   * @param {{[key: string]: any}} conditions
-   * @param {function() : void} callback
-   * @returns {Promise<import("../record/index.js").default>}
-   */
-  async findOrCreateBy(conditions, callback) {
-    const record = await this.findOrInitializeBy(conditions, callback)
-
-    if (record.isNewRecord()) {
-      await record.save()
-    }
-
-    return record
-  }
-
-  /**
-   * @param {{[key: string]: any}} conditions
-   * @returns {Promise<import("../record/index.js").default>}
-   */
-  async findByOrFail(conditions) {
-    /** @type {{[key: string]: number | string}} */
-    const newConditions = {}
-
-    for (const key in conditions) {
-      const keyUnderscore = inflection.underscore(key)
-
-      newConditions[keyUnderscore] = conditions[key]
-    }
-
-    const model = await this.clone().where(newConditions).first()
-
-    if (!model) {
-      throw new Error("Record not found")
-    }
-
-    return model
-  }
-
-  /**
-   * @param {object} conditions
-   * @param {function(import("../record/index.js").default) : void} callback
-   * @returns {Promise<import("../record/index.js").default>}
-   */
-  async findOrInitializeBy(conditions, callback) {
-    const record = await this.findBy(conditions)
-
-    if (record) return record
-
-    const ModelClass = this.getModelClass()
-    const newRecord = new ModelClass(conditions)
-
-    if (callback) {
-      callback(newRecord)
-    }
-
-    return newRecord
-  }
-
-  /**
-   * @returns {Promise<import("../record/index.js").default>}
-   */
-  async first() {
-    const newQuery = this.clone().limit(1).reorder(`${this.driver.quoteTable(this.getModelClass().tableName())}.${this.driver.quoteColumn(this.getModelClass().orderableColumn())}`)
-    const results = await newQuery.toArray()
-
-    return results[0]
-  }
-
-  /**
-   * @param {string|import("./from-base.js").default} from
-   * @returns {this}
-   */
-  from(from) {
-    if (typeof from == "string") from = new FromPlain(from)
-
-    this._froms.push(from)
-    return this
-  }
-
-  /**
-   * @param {string} group
-   * @returns {this}
-   */
-  group(group) {
-    this._groups.push(group)
-    return this
-  }
-
-  /**
-   * @param {string|{[key: string]: any}} join
-   * @returns {this}
-   */
-  joins(join) {
-    if (typeof join == "string") {
-      this._joins.push(new JoinPlain(join))
-    } else if (isPlainObject(join)) {
-      this._joins.push(new JoinObject(join))
-    } else {
-      throw new Error(`Unknown type of join: ${typeof join}`)
-    }
-
-    return this
-  }
-
-  /**
-   * @returns {Promise<import("../record/index.js").default>}
-   */
-  async last() {
-    const primaryKey = this.getModelClass().primaryKey()
-    const tableName = this.getModelClass().tableName()
-    const results = await this.clone().reorder(`${this.driver.quoteTable(tableName)}.${this.driver.quoteColumn(primaryKey)} DESC`).limit(1).toArray()
-
-    return results[0]
-  }
-
-  /**
-   * @param {number} value
-   * @returns {this}
-   */
-  limit(value) {
-    this._limit = value
-    return this
-  }
-
-  /**
-   * @param {number} value
-   * @returns {this}
-   */
-  offset(value) {
-    this._offset = value
-    return this
-  }
-
-  /**
-   * @param {string | number} order
-   * @returns {this}
-   */
-  order(order) {
-    if (typeof order == "string") {
-      this._orders.push(new OrderPlain(this, order))
-    } else if (typeof order == "number") {
-      this._orders.push(new OrderPlain(this, `${order}`))
-    } else {
-      throw new Error(`Unknown order type: ${typeof order}`)
-    }
-
-    return this
-  }
-
-  /**
-   * @param {number} pageNumber
-   * @returns {this}
-   */
-  page(pageNumber) {
-    const perPage = this._perPage || 30
-    const offset = (pageNumber - 1) * perPage
-    const limit = perPage
-
-    this._page = pageNumber
-    this.limit(limit)
-    this.offset(offset)
-    return this
-  }
-
-  /**
-   * @param {number} perPage
-   * @returns {this}
-   */
-  perPage(perPage) {
-    this._perPage = perPage
-    return this
-  }
-
-  /**
-   * @param {NestedPreloadRecord} data
-   * @returns {this}
-   */
-  preload(data) {
-    incorporate(this._preload, data)
-    return this
-  }
-
-  /**
-   * @param {string | number} order
-   * @returns {this}
-   */
-  reorder(order) {
-    this._orders = []
-    this.order(order)
-    return this
-  }
-
-  /**
-   * @returns {this}
-   */
-  reverseOrder() {
-    for (const order of this._orders) {
-      order.setReverseOrder(true)
-    }
-
-    return this
-  }
-
-  /**
-   * @param {SelectArgumentType} select
-   * @returns {this}
-   */
-  select(select) {
-    if (Array.isArray(select)) {
-      for (const selectInArray of select) {
-        this.select(selectInArray)
-      }
-
-      return this
-    }
-
-    if (typeof select == "string") {
-      this._selects.push(new SelectPlain(select))
-    } else if (select instanceof SelectBase) {
-      this._selects.push(select)
-    } else {
-      throw new Error(`Invalid select type: ${typeof select}`)
-    }
-
-    return this
-  }
-
-  /**
-   * @returns {Promise<Array<object>>} Array of results from the database
-   */
-  async _executeQuery() {
-    const sql = this.toSql()
-    const results = await this.driver.query(sql)
-
-    this.logger.debug(() => ["SQL:", sql])
-
-    return results
-  }
-
-  /**
-   * @returns {Promise<Array<object>>} Array of results from the database
-   */
-  async results() {
-    return await this._executeQuery()
-  }
-
-  /**
-   * Converts query results to array of model instances
-   * @returns {Promise<Array<import("../record/index.js").default>>}
-   */
-  async toArray() {
-    const models = []
-    const results = await this.results()
-
-    for (const result of results) {
-      const ModelClass = this.getModelClass()
-      const model = new ModelClass()
-
-      model.loadExistingRecord(result)
-      models.push(model)
-    }
-
-    if (Object.keys(this._preload).length > 0 && models.length > 0) {
-      const preloader = new Preloader({
-        modelClass: this.modelClass,
-        models,
-        preload: this._preload
-      })
-
-      await preloader.run()
-    }
-
-    return models
-  }
-
-  /**
-   * Generates SQL string representing this query
-   * @returns {string} SQL string representing this query
-   */
-  toSql() { return this.driver.queryToSql(this) }
-
-  /**
-   * @param {WhereArgumentType} where
-   * @returns {VelociousDatabaseQuery} This query instance
-   */
-  where(where) {
-    if (typeof where == "string") {
-      this._wheres.push(new WherePlain(this, where))
-    } else if (typeof where == "object" && (where.constructor.name == "object" || where.constructor.name == "Object")) {
-      this._wheres.push(new WhereHash(this, where))
-    } else {
-      throw new Error(`Invalid type of where: ${typeof where} (${where.constructor.name})`)
-    }
-
-    return this
-  }
-}

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

@@ -1,156 +0,0 @@
-// @ts-check
-
-import restArgsError from "../../utils/rest-args-error.js"
-
-export default class VelociousDatabaseQueryInsertBase {
-  /**
-   * @param {object} args
-   * @param {Record<string, any>} [args.data]
-   * @param {import("../drivers/base.js").default} args.driver
-   * @param {string} args.tableName
-   * @param {Array<string>} [args.columns]
-   * @param {boolean} [args.multiple]
-   * @param {string[]} [args.returnLastInsertedColumnNames]
-   * @param {Array<Array<string>>} [args.rows]
-   */
-  constructor({columns, data, driver, multiple, tableName, returnLastInsertedColumnNames, rows, ...restArgs}) {
-    if (!driver) throw new Error("No driver given to insert base")
-    if (!tableName) throw new Error(`Invalid table name given to insert base: ${tableName}`)
-
-    restArgsError(restArgs)
-
-    this.columns = columns
-    this.data = data
-    this.driver = driver
-    this.multiple = multiple
-    this.returnLastInsertedColumnNames = returnLastInsertedColumnNames
-    this.rows = rows
-    this.tableName = tableName
-  }
-
-  /**
-   * @returns {import("../query-parser/options.js").default}
-   */
-  getOptions() {
-    return this.driver.options()
-  }
-
-  /**
-   * @returns {string} SQL statement
-   */
-  toSql() {
-    const {driver} = this
-
-    let sql = `INSERT INTO ${driver.quoteTable(this.tableName)}`
-    let count = 0
-    let columns, lastInsertedSQL
-
-    if (this.returnLastInsertedColumnNames) {
-      if (driver.getType() == "mssql") {
-        lastInsertedSQL = ` OUTPUT `
-
-        for (let i = 0; i < this.returnLastInsertedColumnNames.length; i++) {
-          const columnName = this.returnLastInsertedColumnNames[i]
-
-          if (i > 0) {
-            lastInsertedSQL += ", "
-          }
-
-          lastInsertedSQL += ` INSERTED.${driver.quoteColumn(columnName)}`
-        }
-
-        if (this.data && Object.keys(this.data).length <= 0) {
-          sql += lastInsertedSQL
-        }
-      } else if (driver.getType() == "mysql" || driver.getType() == "pgsql" || (driver.getType() == "sqlite" && driver.supportsInsertIntoReturning())) {
-        lastInsertedSQL = " RETURNING "
-
-        for (let i = 0; i < this.returnLastInsertedColumnNames.length; i++) {
-          const columnName = this.returnLastInsertedColumnNames[i]
-
-          if (i > 0) {
-            lastInsertedSQL += ", "
-          }
-
-          lastInsertedSQL += ` ${driver.quoteColumn(columnName)}`
-        }
-      }
-    }
-
-    if (this.columns && this.rows) {
-      columns = this.columns
-    } else if (this.data) {
-      columns = Object.keys(this.data)
-    } else {
-      throw new Error("Neither 'column' and 'rows' or data was given")
-    }
-
-    if (columns.length > 0) {
-      sql += " ("
-
-      for (const columnName of columns) {
-        if (count > 0) sql += ", "
-
-        sql += driver.quoteColumn(columnName)
-        count++
-      }
-
-      sql += ")"
-    }
-
-    if (this.returnLastInsertedColumnNames && driver.getType() == "mssql" && this.data && Object.keys(this.data).length > 0) {
-      sql += lastInsertedSQL
-    }
-
-    if (this.columns && this.rows) {
-      if (this.rows.length > 0) {
-        sql += " VALUES "
-      }
-
-      let count = 0
-
-      for (const row of this.rows) {
-        if (count >= 1) sql += ", "
-
-        count++
-        sql += this._valuesSql(row)
-      }
-    } else {
-      if (this.data && Object.keys(this.data).length > 0) {
-        sql += " VALUES "
-        sql += this._valuesSql(Object.values(this.data))
-      } else if (driver.getType() == "sqlite" || driver.getType() == "mssql") {
-        sql += " DEFAULT VALUES"
-      } else if (driver.getType() == "mysql") {
-        sql += " () VALUES ()"
-      }
-    }
-
-    if (this.returnLastInsertedColumnNames) {
-      if (driver.getType() == "pgsql" || driver.getType() == "mysql" || (driver.getType() == "sqlite" && driver.supportsInsertIntoReturning())) {
-        sql += lastInsertedSQL
-      }
-    }
-
-    return sql
-  }
-
-  /**
-   * @param {any[]} data
-   */
-  _valuesSql(data) {
-    let count = 0
-    let sql = "("
-
-    for (const value of data) {
-      if (count > 0) sql += ", "
-
-      sql += this.getOptions().quote(value)
-      count++
-    }
-
-    sql += ")"
-
-    return sql
-  }
-}

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

@@ -1,39 +0,0 @@
-// @ts-check
-
-export default class VelociousDatabaseQueryJoinBase {
-  pretty = false
-
-  /**
-   * @returns {import("../query-parser/options.js").default}
-   */
-  getOptions() {
-    return this.getQuery().driver.options()
-  }
-
-  /**
-   * @returns {import("./index.js").default}
-   */
-  getQuery() {
-    if (!this.query) throw new Error("'query' hasn't been set")
-
-    return this.query
-  }
-
-  /**
-   * @param {boolean} value
-   */
-  setPretty(value) {
-    this.pretty = value
-  }
-
-  /**
-   * @param {import("./index.js").default} query
-   */
-  setQuery(query) {
-    this.query = query
-  }
-
-  toSql() {
-    throw new Error("'toSql' wasn't implemented")
-  }
-}