velocious 1.0.97 → 1.0.99

package/src/database/query/select-table-and-column.js

@@ -1,8 +1,14 @@
+// @ts-check
+
 import SelectBase from "./select-base.js"
 
 export default class VelociousDatabaseQuerySelectTableAndColumn extends SelectBase {
-  constructor({query, tableName, columnName}) {
-    super({query})
+  /**
+   * @param {string} tableName
+   * @param {string} columnName
+   */
+  constructor(tableName, columnName) {
+    super()
     this.columnName = columnName
     this.tableName = tableName
   }

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

@@ -1,11 +1,33 @@
+// @ts-check
+
 export default class VelociousDatabaseQueryWhereBase {
   /**
    * @returns {import("../query-parser/options.js").default}
    */
   getOptions() {
-    return this.query.getOptions()
+    return this.getQuery().getOptions()
+  }
+
+  /**
+   * @returns {import("./index.js").default}
+   */
+  getQuery() {
+    if (!this.query) throw new Error("'query' hasn't been set")
+
+    return this.query
   }
 
+  /**
+   * @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/where-hash.js

@@ -1,6 +1,16 @@
+// @ts-check
+
 import WhereBase from "./where-base.js"
 
+/**
+ * @typedef {{[key: string]: any}} WhereHash
+ */
+
 export default class VelociousDatabaseQueryWhereHash extends WhereBase {
+  /**
+   * @param {import("./index.js").default} query
+   * @param {WhereHash} hash
+   */
   constructor(query, hash) {
     super()
     this.hash = hash
@@ -16,6 +26,11 @@ export default class VelociousDatabaseQueryWhereHash extends WhereBase {
     return sql
   }
 
+  /**
+   * @param {WhereHash} hash
+   * @param {string} [tableName]
+   * @param {number} index
+   */
   _whereSQLFromHash(hash, tableName, index = 0) {
     const options = this.getOptions()
     let sql = ""

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

@@ -1,6 +1,12 @@
+// @ts-check
+
 import WhereBase from "./where-base.js"
 
 export default class VelociousDatabaseQueryWhereHash extends WhereBase {
+  /**
+   * @param {import("./index.js").default} query
+   * @param {string} plain
+   */
   constructor(query, plain) {
     super()
     this.plain = plain

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

@@ -1,4 +1,5 @@
-import {digs} from "diggerize"
+// @ts-check
+
 import FromParser from "./from-parser.js"
 import GroupParser from "./group-parser.js"
 import JoinsParser from "./joins-parser.js"
@@ -8,6 +9,11 @@ import SelectParser from "./select-parser.js"
 import WhereParser from "./where-parser.js"
 
 export default class VelociousDatabaseBaseQueryParser {
+  /**
+   * @param {object} args
+   * @param {boolean} args.pretty
+   * @param {import("../query/index.js").default} args.query
+   */
   constructor({pretty, query}) {
     if (!query) throw new Error("No query given")
 
@@ -16,7 +22,7 @@ export default class VelociousDatabaseBaseQueryParser {
   }
 
   toSql() {
-    const {pretty, query} = digs(this, "pretty", "query")
+    const {pretty, query} = this
 
     let sql = ""
 

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

@@ -35,6 +35,8 @@ export default class VelociousDatabaseQueryParserFromParser {
         sql += " "
       }
 
+      from.setQuery(query)
+
       sql += from.toSql()
     }
 

package/src/database/query-parser/joins-parser.js

@@ -1,7 +1,11 @@
-import {digs} from "diggerize"
-import JoinPlain from "../query/join-plain.js"
+// @ts-check
 
 export default class VelocuiousDatabaseQueryParserJoinsParser {
+  /**
+   * @param {object} args
+   * @param {boolean} args.pretty
+   * @param {import("../query/index.js").default} args.query
+   */
   constructor({pretty, query}) {
     this.pretty = pretty
     this.query = query
@@ -9,39 +13,14 @@ export default class VelocuiousDatabaseQueryParserJoinsParser {
   }
 
   toSql() {
-    const {pretty, query} = digs(this, "pretty", "query")
+    const {pretty, query} = this
     let sql = ""
 
     for (const joinKey in query._joins) {
       const join = query._joins[joinKey]
 
-      if (join instanceof JoinPlain) {
-        if (joinKey == 0) {
-          if (pretty) {
-            sql += "\n\n"
-          } else {
-            sql += " "
-          }
-        }
-
-        sql += join.toSql()
-      } else if (typeof join == "object") {
-        sql = this.joinObject({join, modelClass: query.modelClass, sql})
-      } else {
-        throw new Error(`Unknown join object: ${join.constructor.name}`)
-      }
-    }
-
-    return sql
-  }
-
-  joinObject({join, modelClass, sql}) {
-    const {conn, pretty} = this
-
-    for (const joinKey in join) {
-      const joinValue = join[joinKey]
-      const relationship = modelClass.getRelationshipByName(joinKey)
-      const targetModelClass = relationship.getTargetModelClass()
+      join.setPretty(pretty)
+      join.setQuery(query)
 
       if (pretty) {
         sql += "\n\n"
@@ -49,21 +28,7 @@ export default class VelocuiousDatabaseQueryParserJoinsParser {
         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({join: joinValue, modelClass: targetModelClass, sql})
-      }
+      sql += join.toSql()
     }
 
     return sql

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

@@ -30,6 +30,8 @@ export default class VelociousDatabaseQueryParserSelectParser {
     for (const selectKey in query._selects) {
       const selectValue = query._selects[selectKey]
 
+      selectValue.setQuery(query)
+
       sql += selectValue.toSql()
 
       if (selectKey + 1 < query._selects.length) {

package/src/database/record/index.js

@@ -892,7 +892,7 @@ class VelociousDatabaseRecord {
       modelClass: this
     })
 
-    return query.from(new FromTable({driver: this.connection(), tableName: this.tableName()}))
+    return query.from(new FromTable(this.tableName()))
   }
 
   /**

package/src/database/table-data/index.js

@@ -1,18 +1,32 @@
+// @ts-check
+
 import TableColumn from "./table-column.js"
 import TableIndex from "./table-index.js"
 import TableReference from "./table-reference.js"
 
+/**
+ * @typedef {object} TableDataArgsType
+ * @property {boolean} ifNotExists
+ */
+
 export default class TableData {
+  /** @type {TableColumn[]} */
   _columns = []
+
+  /** @type {import("./table-foreign-key.js").default[]} */
   _foreignKeys = []
+
+  /** @type {TableIndex[]} */
   _indexes = []
+
+  /** @type {TableReference[]} */
   _references = []
 
   /**
    * @param {string} name
-   * @param {object} args
+   * @param {TableDataArgsType} [args]
    */
-  constructor(name, args = {}) {
+  constructor(name, args) {
     if (!name) throw new Error(`Invalid table name: ${name}`)
 
     this.args = args
@@ -20,10 +34,10 @@ export default class TableData {
   }
 
   /**
-   * @param {string} name
-   * @param {object} args
+   * @param {string|TableColumn} name
+   * @param {import("./table-column.js").TableColumnArgsType} [args]
    */
-  addColumn(name, args = {}) {
+  addColumn(name, args) {
     if (name instanceof TableColumn) {
       this.getColumns().push(name)
     } else {
@@ -72,7 +86,7 @@ export default class TableData {
   /**
    * @returns {boolean}
    */
-  getIfNotExists() { return this.args.ifNotExists }
+  getIfNotExists() { return this.args?.ifNotExists || false }
 
   /**
    * @returns {TableReference[]}
@@ -81,123 +95,59 @@ export default class TableData {
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
-  bigint(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "bigint"}, args)) }
+  bigint(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "bigint"}, args)) }
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
-  blob(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "blob"}, args)) }
+  blob(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "blob"}, args)) }
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
   boolean(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "boolean"}, args)) }
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
   datetime(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "datetime"}, args)) }
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
-  integer(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "integer"}, args)) }
+  integer(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "integer"}, args)) }
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
-  json(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "json"}, args)) }
+  json(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "json"}, args)) }
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
-  tinyint(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "tinyint"}, args)) }
+  tinyint(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "tinyint"}, args)) }
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
-  references(name, args = {}) {
+  references(name, args) {
     const columnName = `${name}_id`
     const reference = new TableReference(name, args)
     const {polymorphic, ...restArgs} = args
@@ -219,62 +169,30 @@ export default class TableData {
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
   string(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "string"}, args)) }
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
   text(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "text"}, args)) }
 
   /**
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
-  timestamps(args = {}) {
+  timestamps(args) {
     this.datetime("created_at", args)
     this.datetime("updated_at", args)
   }
 
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {number} args.maxLength
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
+   * @param {import("./table-column.js").TableColumnArgsType} args
    * @returns {void}
    */
   uuid(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "uuid"}, args)) }

package/src/database/table-data/table-column.js

@@ -1,26 +1,36 @@
+// @ts-check
+
+/**
+ * @typedef {{unique: boolean}} IndexArgType
+ */
+
 import * as inflection from "inflection"
 import restArgsError from "../../utils/rest-args-error.js"
 import TableForeignKey from "./table-foreign-key.js"
 
+/**
+ * @typedef {object} TableColumnArgsType
+ * @property {boolean} [autoIncrement]
+ * @property {any} [default]
+ * @property {boolean} [dropColumn]
+ * @property {boolean|object} [foreignKey]
+ * @property {boolean|IndexArgType} [index]
+ * @property {boolean} [isNewColumn]
+ * @property {number} [maxLength]
+ * @property {boolean} [null]
+ * @property {boolean} [polymorphic]
+ * @property {boolean} [primaryKey]
+ * @property {string} [type]
+ */
+
 export default class TableColumn {
   /**
    * @param {string} name
-   * @param {object} args
-   * @param {boolean} args.autoIncrement
-   * @param {any} args.default
-   * @param {boolean} args.dropColumn
-   * @param {boolean|object} args.foreignKey
-   * @param {boolean|object} args.index
-   * @param {boolean} args.isNewColumn
-   * @param {number} args.maxLength
-   * @param {string} args.name
-   * @param {boolean} args.null
-   * @param {boolean} args.primaryKey
-   * @param {string} args.type
+   * @param {TableColumnArgsType} [args]
    */
   constructor(name, args) {
     if (args) {
-      const {autoIncrement, default: columnDefault, dropColumn, foreignKey, index, isNewColumn, maxLength, name, null: argsNull, primaryKey, type, ...restArgs} = args // eslint-disable-line no-unused-vars
+      const {autoIncrement, default: columnDefault, dropColumn, foreignKey, index, isNewColumn, maxLength, null: argsNull, polymorphic, primaryKey, type, ...restArgs} = args // eslint-disable-line no-unused-vars
 
       if (Object.keys(args).length == 0) {
         throw new Error("Empty args given")
@@ -39,7 +49,7 @@ export default class TableColumn {
   getName() { return this.name }
 
   /**
-   * @returns {string}
+   * @returns {string | undefined}
    */
   getNewName() { return this._newName }
 
@@ -71,6 +81,7 @@ export default class TableColumn {
   getDefault() { return this.args?.default }
 
   /**
+   * @param {any} newDefault
    * @returns {void}
    */
   setDefault(newDefault) { this.args.default = newDefault }
@@ -81,29 +92,48 @@ export default class TableColumn {
   getDropColumn() { return this.args?.dropColumn || false }
 
   /**
-   * @returns {boolean|object}
+   * @returns {boolean | object | undefined}
    */
   getForeignKey() { return this.args?.foreignKey }
 
   /**
-   * @param {boolean|object} newForeignKey
+   * @param {boolean | object} newForeignKey
    * @returns {void}
    */
   setForeignKey(newForeignKey) { this.args.foreignKey = newForeignKey }
 
   /**
-   * @returns {boolean|object}
+   * @returns {boolean|IndexArgType}
+   */
+  getIndex() { return this.args?.index || false }
+
+  /**
+   * @returns {IndexArgType}
    */
-  getIndex() { return this.args?.index }
+  getIndexArgs() {
+    if (typeof this.args?.index == "object") {
+      return this.args.index
+    } else {
+      return {unique: false}
+    }
+  }
+
+  getIndexUnique() {
+    const index = this.args?.index
+
+    if (typeof index == "object" && index.unique === true) return true
+
+    return false
+  }
 
   /**
-   * @param {boolean|object} newIndex
+   * @param {boolean|IndexArgType} newIndex
    * @returns {void}
    */
   setIndex(newIndex) { this.args.index = newIndex }
 
   /**
-   * @returns {number}
+   * @returns {number | undefined}
    */
   getMaxLength() { return this.args?.maxLength }
 
@@ -114,7 +144,7 @@ export default class TableColumn {
   setMaxLength(newMaxLength) { this.args.maxLength = newMaxLength }
 
   /**
-   * @returns {boolean}
+   * @returns {boolean | undefined}
    */
   getNull() { return this.args?.null }
 
@@ -127,7 +157,7 @@ export default class TableColumn {
   /**
    * @returns {boolean}
    */
-  getPrimaryKey() { return this.args?.primaryKey }
+  getPrimaryKey() { return this.args?.primaryKey || false }
 
   /**
    * @param {boolean} newPrimaryKey
@@ -136,7 +166,7 @@ export default class TableColumn {
   setPrimaryKey(newPrimaryKey) { this.args.primaryKey = newPrimaryKey }
 
   /**
-   * @returns {string}
+   * @returns {string | undefined}
    */
   getType() { return this.args?.type }
 
@@ -154,8 +184,7 @@ export default class TableColumn {
   /**
    * @param {object} args
    * @param {boolean} args.forAlterTable
-   * @template T extends import("../drivers/base.js").default
-   * @param {T} args.driver
+   * @param {import("../drivers/base.js").default} args.driver
    * @returns {string}
    */
   getSQL({forAlterTable, driver, ...restArgs}) {

package/src/database/table-data/table-foreign-key.js

@@ -1,11 +1,13 @@
+// @ts-check
+
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class TableForeignKey {
   /**
    * @param {object} args
    * @param {string} args.columnName
-   * @param {boolean} args.isNewForeignKey
-   * @param {string} args.name
+   * @param {boolean} [args.isNewForeignKey]
+   * @param {string} [args.name]
    * @param {string} args.tableName
    * @param {string} args.referencedColumnName
    * @param {string} args.referencedTableName
@@ -29,7 +31,7 @@ export default class TableForeignKey {
   /**
    * @returns {boolean}
    */
-  getIsNewForeignKey() { return this._isNewForeignKey }
+  getIsNewForeignKey() { return this._isNewForeignKey || false }
 
   /**
    * @returns {string}