velocious 1.0.97 → 1.0.99

package/src/database/query/base.js

@@ -1,6 +1,13 @@
+// @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)
 
@@ -33,7 +40,7 @@ export default class VelociousDatabaseQueryBase {
    * @interface
    * @returns {string[]}
    */
-  toSql() {
-    throw new Error("'toSql' wasn't implemented")
+  toSqls() {
+    throw new Error("'toSqls' wasn't implemented")
   }
 }

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

@@ -1,6 +1,14 @@
+// @ts-check
+
 import QueryBase from "./base.js"
 
 export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
+  /**
+   * @param {object} args
+   * @param {import("../drivers/base.js").default} args.driver
+   * @param {string} args.databaseName
+   * @param {boolean} [args.ifNotExists]
+   */
   constructor({driver, databaseName, ifNotExists}) {
     super({driver})
     this.databaseName = databaseName

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

@@ -1,6 +1,21 @@
+// @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
@@ -17,7 +32,7 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
     if (databaseType == "sqlite") indexName += `${this.tableName}_`
 
     for (const columnIndex in this.columns) {
-      if (columnIndex > 0) indexName += "_and_"
+      if (typeof columnIndex == "number" && columnIndex > 0) indexName += "_and_"
 
       const column = this.columns[columnIndex]
       let columnName
@@ -35,9 +50,9 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
   }
 
   /**
-   * @returns {string}
+   * @returns {string[]}
    */
-  toSql() {
+  toSqls() {
     const databaseType = this.getDriver().getType()
     const indexName = this.name || this.generateIndexName()
     const options = this.getOptions()
@@ -69,7 +84,7 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
     sql += ` ON ${options.quoteTableName(tableName)} (`
 
     for (const columnIndex in this.columns) {
-      if (columnIndex > 0) sql += ", "
+      if (typeof columnIndex == "number" && columnIndex > 0) sql += ", "
 
       const column = this.columns[columnIndex]
       let columnName
@@ -89,6 +104,6 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
       sql += " END"
     }
 
-    return sql
+    return [sql]
   }
 }

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

@@ -1,10 +1,19 @@
+// @ts-check
+
 import CreateIndexBase from "./create-index-base.js"
-import {digs} from "diggerize"
 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")
 
@@ -21,7 +30,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
     const databaseType = this.getDatabaseType()
     const driver = this.getDriver()
     const options = this.getOptions()
-    const {tableData} = digs(this, "tableData")
+    const {tableData} = this
     const sqls = []
     const ifNotExists = this.ifNotExists || tableData.getIfNotExists()
     let sql = ""
@@ -65,7 +74,13 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
         index.getColumns().forEach((column, columnIndex) => {
           if (columnIndex > 0) sql += ", "
 
-          sql += driver.quoteColumn(column.name)
+          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 += ")"
@@ -83,7 +98,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
 
         sql += ","
 
-        const {unique, ...restIndexArgs} = column.getIndex()
+        const {unique, ...restIndexArgs} = column.getIndexArgs()
 
         restArgsError(restIndexArgs)
 
@@ -113,16 +128,18 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
           tableName: tableData.getName(),
           unique: index.getUnique()
         }
-        const sql = new CreateIndexBase(createIndexArgs).toSql()
+        const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSqls()
 
-        sqls.push(sql)
+        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.getIndex()
+        const {unique, ...restIndexArgs} = column.getIndexArgs()
 
         restArgsError(restIndexArgs)
 
@@ -139,9 +156,11 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
           tableName: tableData.getName(),
           unique
         }
-        const sql = new CreateIndexBase(createIndexArgs).toSql()
+        const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSqls()
 
-        sqls.push(sql)
+        for (const createIndexSQL of createIndexSQLs) {
+          sqls.push(createIndexSQL)
+        }
       }
     }
 

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

@@ -1,8 +1,25 @@
+// @ts-check
+
+import Query from "./index.js"
+
 export default class VelociousDatabaseQueryFromBase {
+  /** @type {Query | 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()
   }
 

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

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

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

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

package/src/database/query/index.js

@@ -1,18 +1,23 @@
+// @ts-check
+
 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"
 
 /**
- * @typedef {Record<string, boolean|NestedPreloadRecord>} NestedPreloadRecord
+ * @typedef {{[key: string]: boolean | NestedPreloadRecord }} NestedPreloadRecord
  */
 
 /**
@@ -27,11 +32,11 @@ export default class VelociousDatabaseQuery {
    * @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 {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 {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]
@@ -73,6 +78,8 @@ export default class VelociousDatabaseQuery {
     this._perPage = perPage
     this._preload = preload
     this._selects = selects
+
+    /** @type {import("./where-base.js").default[]} */
     this._wheres = wheres
   }
 
@@ -118,7 +125,7 @@ export default class VelociousDatabaseQuery {
     countQuery._selects = []
     countQuery.select(sql)
 
-    const results = await countQuery._executeQuery()
+    const results = /** @type {{ count: number }[]} */ (await countQuery._executeQuery())
 
 
     // The query isn't grouped and a single result has been given
@@ -142,8 +149,7 @@ export default class VelociousDatabaseQuery {
   }
 
   /**
-   * @template {import("./from-base.js").default} T
-   * @returns {T[]}
+   * @returns {import("./from-base.js").default[]}
    */
   getFroms() {
     return this._froms
@@ -182,6 +188,7 @@ export default class VelociousDatabaseQuery {
    * @returns {Promise<import("../record/index.js").default>}
    */
   async find(recordId) {
+    /** @type {{[key: string]: number | string}} */
     const conditions = {}
 
     conditions[this.modelClass.primaryKey()] = recordId
@@ -197,10 +204,11 @@ export default class VelociousDatabaseQuery {
   }
 
   /**
-   * @param {object} conditions
+   * @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) {
@@ -213,11 +221,12 @@ export default class VelociousDatabaseQuery {
   }
 
   /**
-   * @param {...Parameters<this["findOrInitializeBy"]>} args
+   * @param {{[key: string]: any}} conditions
+   * @param {function() : void} callback
    * @returns {Promise<import("../record/index.js").default>}
    */
-  async findOrCreateBy(...args) {
-    const record = await this.findOrInitializeBy(...args)
+  async findOrCreateBy(conditions, callback) {
+    const record = await this.findOrInitializeBy(conditions, callback)
 
     if (record.isNewRecord()) {
       await record.save()
@@ -227,10 +236,11 @@ export default class VelociousDatabaseQuery {
   }
 
   /**
-   * @param {object} conditions
+   * @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) {
@@ -250,7 +260,7 @@ export default class VelociousDatabaseQuery {
 
   /**
    * @param {object} conditions
-   * @param {function() : void} callback
+   * @param {function(import("../record/index.js").default) : void} callback
    * @returns {Promise<import("../record/index.js").default>}
    */
   async findOrInitializeBy(conditions, callback) {
@@ -282,9 +292,7 @@ export default class VelociousDatabaseQuery {
    * @returns {this}
    */
   from(from) {
-    if (typeof from == "string") from = new FromPlain({plain: from, query: this})
-
-    from.query = this
+    if (typeof from == "string") from = new FromPlain(from)
 
     this._froms.push(from)
     return this
@@ -300,19 +308,18 @@ export default class VelociousDatabaseQuery {
   }
 
   /**
-   * @param {string|JoinPlain} join
+   * @param {string|{[key: string]: any}} join
    * @returns {this}
    */
   joins(join) {
     if (typeof join == "string") {
-      join = new JoinPlain({plain: join, query: this})
-    } else if (typeof join == "object") {
-      // Do nothing
+      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}`)
     }
 
-    this._joins.push(join)
     return this
   }
 
@@ -350,11 +357,14 @@ export default class VelociousDatabaseQuery {
    * @returns {this}
    */
   order(order) {
-    if (typeof order == "number" || typeof order == "string") order = new OrderPlain({plain: order, query: this})
-
-    order.query = this
+    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}`)
+    }
 
-    this._orders.push(order)
     return this
   }
 
@@ -425,11 +435,14 @@ export default class VelociousDatabaseQuery {
       return this
     }
 
-    if (typeof select == "string") select = new SelectPlain({plain: select})
-
-    select.query = 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}`)
+    }
 
-    this._selects.push(select)
     return this
   }
 
@@ -492,15 +505,13 @@ export default class VelociousDatabaseQuery {
    */
   where(where) {
     if (typeof where == "string") {
-      where = new WherePlain(this, where)
+      this._wheres.push(new WherePlain(this, where))
     } else if (typeof where == "object" && (where.constructor.name == "object" || where.constructor.name == "Object")) {
-      where = new WhereHash(this, where)
+      this._wheres.push(new WhereHash(this, where))
     } else {
       throw new Error(`Invalid type of where: ${typeof where} (${where.constructor.name})`)
     }
 
-    this._wheres.push(where)
-
     return this
   }
 }

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

@@ -1,9 +1,36 @@
+// @ts-check
+
 export default class VelociousDatabaseQueryJoinBase {
+  pretty = false
+
   /**
    * @returns {import("../query-parser/options.js").default}
    */
   getOptions() {
-    return this.query.driver.options()
+    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() {

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

@@ -0,0 +1,67 @@
+// @ts-check
+
+import JoinBase from "./join-base.js"
+
+/**
+ * @typedef {{[key: string]: boolean | JoinObject}} JoinObject
+ */
+
+export default class VelociousDatabaseQueryJoinObject extends JoinBase {
+  /**
+   * @param {JoinObject} object
+   */
+  constructor(object) {
+    super()
+    this.object = object
+  }
+
+  toSql() {
+    const modelClass = this.getQuery().modelClass
+
+    return this.joinObject(this.object, modelClass, "", 0)
+  }
+
+  /**
+   * @param {JoinObject} join
+   * @param {typeof import("../record/index.js").default} modelClass
+   * @param {string} sql
+   * @param {number} joinsCount
+   * @returns {string}
+   */
+  joinObject(join, modelClass, sql, joinsCount) {
+    const pretty = this.pretty
+    const conn = this.getQuery().driver
+
+    for (const joinKey in join) {
+      const joinValue = join[joinKey]
+      const relationship = modelClass.getRelationshipByName(joinKey)
+      const targetModelClass = relationship.getTargetModelClass()
+
+      if (joinsCount > 0) {
+        if (pretty) {
+          sql += "\n\n"
+        } else {
+          sql += " "
+        }
+      }
+
+      sql += `LEFT JOIN ${conn.quoteTable(targetModelClass.tableName())} ON `
+
+      if (relationship.getType() == "belongsTo") {
+        sql += `${conn.quoteTable(targetModelClass.tableName())}.${conn.quoteColumn(relationship.getPrimaryKey())} = `
+        sql += `${conn.quoteTable(modelClass.tableName())}.${conn.quoteColumn(relationship.getForeignKey())}`
+      } else if (relationship.getType() == "hasMany" || relationship.getType() == "hasOne") {
+        sql += `${conn.quoteTable(targetModelClass.tableName())}.${conn.quoteColumn(relationship.getForeignKey())} = `
+        sql += `${conn.quoteTable(modelClass.tableName())}.${conn.quoteColumn(relationship.getPrimaryKey())}`
+      } else {
+        throw new Error(`Unknown relationship type: ${relationship.getType()}`)
+      }
+
+      if (typeof joinValue == "object") {
+        sql = this.joinObject(joinValue, targetModelClass, sql, joinsCount + 1)
+      }
+    }
+
+    return sql
+  }
+}

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

@@ -1,7 +1,12 @@
+// @ts-check
+
 import JoinBase from "./join-base.js"
 
 export default class VelociousDatabaseQueryJoinPlain extends JoinBase {
-  constructor({plain}) {
+  /**
+   * @param {string} plain
+   */
+  constructor(plain) {
     super()
     this.plain = plain
   }

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

@@ -1,4 +1,13 @@
+// @ts-check
+
 export default class VelociousDatabaseQueryOrderBase {
+  /**
+   * @param {import("./index.js").default} query
+   */
+  constructor(query) {
+    this.query = query
+  }
+
   /**
    * @returns {import("../query-parser/options.js").default}
    */
@@ -6,6 +15,15 @@ export default class VelociousDatabaseQueryOrderBase {
     return this.query.driver.options()
   }
 
+  /**
+   * @interface
+   * @param {boolean} _reverseOrder
+   * @returns {void}
+   */
+  setReverseOrder(_reverseOrder) { // eslint-disable-line no-unused-vars
+    throw new Error("setReverseOrder not implemented")
+  }
+
   toSql() {
     throw new Error("'toSql' wasn't implemented")
   }

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

@@ -1,8 +1,14 @@
+// @ts-check
+
 import OrderBase from "./order-base.js"
 
 export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
-  constructor({plain}) {
-    super()
+  /**
+   * @param {import("./index.js").default} query
+   * @param {string} plain
+   */
+  constructor(query, plain) {
+    super(query)
     this.plain = plain
     this.reverseOrder = false
   }

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

@@ -1,11 +1,26 @@
+// @ts-check
+
 export default class VelociousDatabaseQuerySelectBase {
   /**
    * @returns {import("../query-parser/options.js").default}
    */
   getOptions() {
+    if (!this.query) throw new Error("'query' hasn't been set")
+
     return this.query.driver.options()
   }
 
+  /**
+   * @param {import("./index.js").default} query
+   */
+  setQuery(query) {
+    this.query = query
+  }
+
+  /**
+   * @interface
+   * @returns {string}
+   */
   toSql() {
     throw new Error("'toSql' wasn't implemented")
   }

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

@@ -1,7 +1,12 @@
+// @ts-check
+
 import SelectBase from "./select-base.js"
 
 export default class VelociousDatabaseQuerySelectPlain extends SelectBase {
-  constructor({plain}) {
+  /**
+   * @param {string} plain
+   */
+  constructor(plain) {
     super()
     this.plain = plain
   }