velocious 1.0.92 → 1.0.94

package/src/database/drivers/base.js

@@ -10,6 +10,10 @@ import TableForeignKey from "../table-data/table-foreign-key.js"
 import wait from "awaitery/src/wait.js"
 
 export default class VelociousDatabaseDriversBase {
+  /**
+   * @param {object} config
+   * @param {import("../../configuration.js").default} configuration
+   */
   constructor(config, configuration) {
     this._args = config
     this.configuration = configuration
@@ -19,6 +23,14 @@ export default class VelociousDatabaseDriversBase {
     this._transactionsActionsMutex = new Mutex()
   }
 
+  /**
+   * @param {string} tableName
+   * @param {string} columnName
+   * @param {string} referencedTableName
+   * @param {string} referencedColumnName
+   * @param {object} args
+   * @returns {Promise<void>}
+   */
   async addForeignKey(tableName, columnName, referencedTableName, referencedColumnName, args) {
     const tableForeignKeyArgs = Object.assign(
       {
@@ -41,6 +53,18 @@ export default class VelociousDatabaseDriversBase {
     }
   }
 
+  /**
+   * @interface
+   * @returns {Promise<string[]>}
+   */
+  alterTableSql() {
+    throw new Error("alterTableSql not implemented")
+  }
+
+  /**
+   * @param {...Parameters<this["createTableSql"]>} args
+   * @returns {void}
+   */
   async createTable(...args) {
     const sqls = this.createTableSql(...args)
 
@@ -49,12 +73,20 @@ export default class VelociousDatabaseDriversBase {
     }
   }
 
+  /**
+   * @param {...Parameters<this["deleteSql"]>} args
+   * @returns {void}
+   */
   async delete(...args) {
     const sql = this.deleteSql(...args)
 
     await this.query(sql)
   }
 
+  /**
+   * @param {...Parameters<this['dropTableSql']>} args
+   * @returns {void}
+   */
   async dropTable(...args) {
     const sqls = this.dropTableSql(...args)
 
@@ -63,20 +95,45 @@ export default class VelociousDatabaseDriversBase {
     }
   }
 
+  /**
+   * @interface
+   * @param {string} _tableName
+   * @param {object} _args
+   * @param {boolean} _args.cascade
+   * @param {boolean} _args.ifExists
+   * @returns {string}
+   */
+  dropTableSql(_tableName, _args) { // eslint-disable-line no-unused-vars
+    throw new Error("dropTableSql not implemented")
+  }
+
+  /**
+   * @returns {object}
+   */
   getArgs() {
     return this._args
   }
 
+  /**
+   * @returns {import("../../configuration.js").default}
+   */
   getConfiguration() {
     if (!this.configuration) throw new Error("No configuration set")
 
     return this.configuration
   }
 
+  /**
+   * @returns {number}
+   */
   getIdSeq() {
     return this.idSeq
   }
 
+  /**
+   * @interface
+   * @returns {Array<import("./base-table.js").default>}
+   */
   getTables() {
     throw new Error(`${this.constructor.name}#getTables not implemented`)
   }
@@ -106,6 +163,10 @@ export default class VelociousDatabaseDriversBase {
     await this.query(sql)
   }
 
+  /**
+   * @interface
+   * @returns {Promise<number>}
+   */
   lastInsertID() {
     throw new Error(`${this.constructor.name}#lastInsertID not implemented`)
   }
@@ -181,8 +242,12 @@ export default class VelociousDatabaseDriversBase {
     return await this.query(sql)
   }
 
-  setIdSeq(id) {
-    this.idSeq = id
+  /**
+   * @param {number} newIdSeq
+   * @returns {void}
+   */
+  setIdSeq(newIdSeq) {
+    this.idSeq = newIdSeq
   }
 
   /**
@@ -246,6 +311,9 @@ export default class VelociousDatabaseDriversBase {
     return result
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async startTransaction() {
     await this._transactionsActionsMutex.sync(async () => {
       await this._startTransactionAction()
@@ -253,10 +321,16 @@ export default class VelociousDatabaseDriversBase {
     })
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async _startTransactionAction() {
     await this.query("BEGIN TRANSACTION")
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async commitTransaction() {
     await this._transactionsActionsMutex.sync(async () => {
       await this._commitTransactionAction()
@@ -264,13 +338,16 @@ export default class VelociousDatabaseDriversBase {
     })
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async _commitTransactionAction() {
     await this.query("COMMIT")
   }
 
   /**
    * @param {string} sql
-   * @returns {Promise<Array>}
+   * @returns {Promise<Array<Record<string, any>>>}
    */
   async query(sql) {
     let tries = 0
@@ -292,10 +369,18 @@ export default class VelociousDatabaseDriversBase {
     }
   }
 
+  /**
+   * @interface
+   * @param {Error} _error
+   * @returns {boolean}
+   */
   retryableDatabaseError(_error) { // eslint-disable-line no-unused-vars
     return false
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async rollbackTransaction() {
     await this._transactionsActionsMutex.sync(async () => {
       await this._rollbackTransactionAction()
@@ -303,20 +388,34 @@ export default class VelociousDatabaseDriversBase {
     })
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async _rollbackTransactionAction() {
     await this.query("ROLLBACK")
   }
 
+  /**
+   * @returns {string}
+   */
   generateSavePointName() {
     return `sp${new UUID(4).format().replaceAll("-", "")}`
   }
 
+  /**
+   * @param {string} savePointName
+   * @returns {Promise<void>}
+   */
   async startSavePoint(savePointName) {
     await this._transactionsActionsMutex.sync(async () => {
       await this._startSavePointAction(savePointName)
     })
   }
 
+  /**
+   * @param {string} savePointName
+   * @returns {Promise<void>}
+   */
   async _startSavePointAction(savePointName) {
     await this.query(`SAVEPOINT ${savePointName}`)
   }
@@ -343,26 +442,45 @@ export default class VelociousDatabaseDriversBase {
     }
   }
 
+  /**
+   * @param {string} savePointName
+   * @returns {Promise<void>}
+   */
   async releaseSavePoint(savePointName) {
     await this._transactionsActionsMutex.sync(async () => {
       await this._releaseSavePointAction(savePointName)
     })
   }
 
+  /**
+   * @param {string} savePointName
+   * @returns {Promise<void>}
+   */
   async _releaseSavePointAction(savePointName) {
     await this.query(`RELEASE SAVEPOINT ${savePointName}`)
   }
 
+  /**
+   * @param {string} savePointName
+   * @returns {Promise<void>}
+   */
   async rollbackSavePoint(savePointName) {
     await this._transactionsActionsMutex.sync(async () => {
       await this._rollbackSavePointAction(savePointName)
     })
   }
 
+  /**
+   * @param {string} savePointName
+   * @returns {Promise<void>}
+   */
   async _rollbackSavePointAction(savePointName) {
     await this.query(`ROLLBACK TO SAVEPOINT ${savePointName}`)
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async truncateAllTables() {
     await this.withDisabledForeignKeys(async () => {
       let tries = 0
@@ -408,6 +526,10 @@ export default class VelociousDatabaseDriversBase {
     await this.query(sql)
   }
 
+  /**
+   * @param {function() : void} callback
+   * @returns {Promise<any>}
+   */
   async withDisabledForeignKeys(callback) {
     await this.disableForeignKeys()
 

package/src/database/drivers/mysql/index.js

@@ -1,6 +1,5 @@
 import AlterTable from "./sql/alter-table.js"
 import Base from "../base.js"
-import connectConnection from "./connect-connection.js"
 import CreateDatabase from "./sql/create-database.js"
 import CreateIndex from "./sql/create-index.js"
 import CreateTable from "./sql/create-table.js"
@@ -16,18 +15,29 @@ import Table from "./table.js"
 import Update from "./sql/update.js"
 
 export default class VelociousDatabaseDriversMysql extends Base{
+  /**
+   * @returns {Promise<void>}
+   */
   async connect() {
-    const connection = mysql.createConnection(this.connectArgs())
+    this.pool = mysql.createPool(Object.assign({connectionLimit: 1}, this.connectArgs()))
+    this.pool.on("error", this.onPoolError)
+  }
 
-    await connectConnection(connection)
-    this.connection = connection
+  onPoolError = (error) => {
+    console.error("Velocious / MySQL driver / Pool error", error)
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async close() {
-    await this.connection.end()
-    this.connection = undefined
+    await this.pool.end()
+    this.pool = undefined
   }
 
+  /**
+   * @returns {Record<string, any>}
+   */
   connectArgs() {
     const args = this.getArgs()
     const connectArgs = []
@@ -42,6 +52,9 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return connectArgs
   }
 
+  /**
+   * @returns {Promise<string[]>}
+   */
   async alterTableSql(tableData) {
     const alterArgs = {tableData, driver: this}
     const alterTable = new AlterTable(alterArgs)
@@ -49,6 +62,9 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return await alterTable.toSqls()
   }
 
+  /**
+   * @returns {Promise<string[]>}
+   */
   createDatabaseSql(databaseName, args) {
     const createArgs = Object.assign({databaseName, driver: this}, args)
     const createDatabase = new CreateDatabase(createArgs)
@@ -56,6 +72,9 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return createDatabase.toSql()
   }
 
+  /**
+   * @returns {string}
+   */
   createIndexSql(indexData) {
     const createArgs = Object.assign({driver: this}, indexData)
     const createIndex = new CreateIndex(createArgs)
@@ -63,6 +82,9 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return createIndex.toSql()
   }
 
+  /**
+   * @returns {string[]}
+   */
   createTableSql(tableData) {
     const createArgs = {tableData, driver: this}
     const createTable = new CreateTable(createArgs)
@@ -70,20 +92,32 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return createTable.toSql()
   }
 
+  /**
+   * @returns {Promise<string>}
+   */
   async currentDatabase() {
     const rows = await this.query("SELECT DATABASE() AS db_name")
 
     return digg(rows, 0, "db_name")
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async disableForeignKeys() {
     await this.query("SET FOREIGN_KEY_CHECKS = 0")
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async enableForeignKeys() {
     await this.query("SET FOREIGN_KEY_CHECKS = 1")
   }
 
+  /**
+   * @returns {string[]}
+   */
   dropTableSql(tableName, args = {}) {
     const dropArgs = Object.assign({tableName, driver: this}, args)
     const dropTable = new DropTable(dropArgs)
@@ -91,41 +125,70 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return dropTable.toSql()
   }
 
+  /**
+   * @returns {string}
+   */
   getType() { return "mysql" }
+
+  /**
+   * @returns {string}
+   */
   primaryKeyType() { return "bigint" }
 
+  /**
+   * @returns {Array<Record<string, any>>}
+   */
   async _queryActual(sql) {
     try {
-      return await query(this.connection, sql)
+      return await query(this.pool, sql)
     } catch (error) {
       // Re-throw to un-corrupt stacktrace
       throw new Error(error.message)
     }
   }
 
+  /**
+   * @returns {string}
+   */
   queryToSql(query) { return new QueryParser({query}).toSql() }
+
+  /**
+   * @returns {boolean}
+   */
   shouldSetAutoIncrementWhenPrimaryKey() { return true }
 
+  /**
+   * @returns {string}
+   */
   escape(value) {
-    if (!this.connection) throw new Error("Can't escape before connected")
+    if (!this.pool) throw new Error("Can't escape before connected")
 
-    const escapedValueWithQuotes = this.connection.escape(this._convertValue(value))
+    const escapedValueWithQuotes = this.pool.escape(this._convertValue(value))
 
     return escapedValueWithQuotes.slice(1, escapedValueWithQuotes.length - 1)
   }
 
+  /**
+   * @returns {string}
+   */
   quote(value) {
-    if (!this.connection) throw new Error("Can't escape before connected")
+    if (!this.pool) throw new Error("Can't escape before connected")
 
-    return this.connection.escape(this._convertValue(value))
+    return this.pool.escape(this._convertValue(value))
   }
 
+  /**
+   * @returns {string}
+   */
   deleteSql({tableName, conditions}) {
     const deleteInstruction = new Delete({conditions, driver: this, tableName})
 
     return deleteInstruction.toSql()
   }
 
+  /**
+   * @returns {string}
+   */
   insertSql(args) {
     const insertArgs = Object.assign({driver: this}, args)
     const insert = new Insert(insertArgs)
@@ -133,6 +196,9 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return insert.toSql()
   }
 
+  /**
+   * @returns {Array<Table>}
+   */
   async getTables() {
     const result = await this.query("SHOW FULL TABLES")
     const tables = []
@@ -146,22 +212,34 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return tables
   }
 
+  /**
+   * @returns {number}
+   */
   async lastInsertID() {
     const result = await this.query("SELECT LAST_INSERT_ID() AS last_insert_id")
 
     return digg(result, 0, "last_insert_id")
   }
 
+  /**
+   * @returns {Options}
+   */
   options() {
     if (!this._options) this._options = new Options({driver: this})
 
     return this._options
   }
 
+  /**
+   * @returns {void}
+   */
   async _startTransactionAction() {
     await this.query("START TRANSACTION")
   }
 
+  /**
+   * @returns {string}
+   */
   updateSql({conditions, data, tableName}) {
     const update = new Update({conditions, data, driver: this, tableName})
 

package/src/database/migrator.js

@@ -5,20 +5,30 @@ import restArgsError from "../utils/rest-args-error.js"
 import TableData from "./table-data/index.js"
 
 export default class VelociousDatabaseMigrator {
+  /**
+   * @param {object} args
+   * @param {import("../configuration.js").default} args.configuration
+   */
   constructor({configuration, ...restArgs}) {
     restArgsError(restArgs)
 
     if (!configuration) throw new Error("configuration argument is required")
 
     this.configuration = configuration
-    this.logger = new Logger(this)
+    this.logger = new Logger(this, {debug: false})
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async prepare() {
     await this.createMigrationsTable()
     await this.loadMigrationsVersions()
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async createMigrationsTable() {
     const dbs = await this.configuration.getCurrentConnections()
 
@@ -48,6 +58,11 @@ export default class VelociousDatabaseMigrator {
     }
   }
 
+  /**
+   * @param {string} dbIdentifier
+   * @param {string} version
+   * @returns {Promise<boolean>}
+   */
   hasRunMigrationVersion(dbIdentifier, version) {
     if (!this.migrationsVersions) throw new Error("Migrations versions hasn't been loaded yet")
     if (!this.migrationsVersions[dbIdentifier]) throw new Error(`Migrations versions hasn't been loaded yet for db: ${dbIdentifier}`)
@@ -197,7 +212,7 @@ export default class VelociousDatabaseMigrator {
     for (const migration of files) {
       await this.runMigrationFile({
         migration,
-        require: requireContext(migration.file).default
+        require: () => requireContext(migration.file).default
       })
     }
   }

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

@@ -3,6 +3,14 @@ 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 {object} args.options
+   * @param {string} args.tableName
+   */
   constructor({cascade, driver, ifExists, options, tableName, ...restArgs}) {
     super({driver, options})
 

package/src/database/query/index.js

@@ -11,7 +11,34 @@ 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
+ */
+
 export default class VelociousDatabaseQuery {
+  /**
+   * @param {object} args
+   * @template {import("../drivers/base.js").default} Tdriver
+   * @param {Tdriver} args.driver
+   * @template {import("./from-base.js").default} TfromBase
+   * @param {TfromBase[]} args.froms
+   * @param {string[]} args.groups
+   * @template {import("./join-base.js").default} TjoinBase
+   * @param {TjoinBase[]} args.joins
+   * @param {import("../handler.js").default} args.handler
+   * @param {number} args.limit
+   * @template {import("../record/index.js").default} Trecord
+   * @param {typeof Trecord} args.modelClass
+   * @param {number} args.offset
+   * @template {import("./order-basejs").default} TorderBase
+   * @param {TorderBase[]} args.orders
+   * @param {number} args.page
+   * @param {number} args.perPage
+   * @param {NestedPreloadRecord} args.preload
+   * @param {Record<string, Array<string>>} args.selects
+   * @template {import("./where-base.js").default} TwhereBase
+   * @param {TwhereBase[]} 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")
@@ -100,6 +127,21 @@ export default class VelociousDatabaseQuery {
     return countResult
   }
 
+  /**
+   * @template {import("./from-base.js").default} T
+   * @returns {T[]}
+   */
+  getFroms() {
+    return this._froms
+  }
+
+  /**
+   * @returns {string[]}
+   */
+  getGroups() {
+    return this._groups
+  }
+
   /**
    * @returns {import("../query-parser/options.js").default}
    */

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

@@ -1,20 +1,31 @@
-import {digs} from "diggerize"
+// @ts-check
+
+import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryParserFromParser {
-  constructor({pretty, query}) {
+  /**
+   * @param {object} args
+   * @param {boolean} args.pretty
+   * @param {import("../query/index.js").default} args.query
+   */
+  constructor({pretty, query, ...restArgs}) {
+    restArgsError(restArgs)
+
     this.pretty = pretty
     this.query = query
   }
 
+  /** @returns {string} */
   toSql() {
-    const {pretty, query} = digs(this, "pretty", "query")
+    const {pretty, query} = this
+    const froms = query.getFroms()
 
     let sql = " FROM"
 
-    for (const fromKey in query._froms) {
-      const from = query._froms[fromKey]
+    for (const fromKey in froms) {
+      const from = froms[fromKey]
 
-      if (fromKey > 0) {
+      if (typeof fromKey == "number" && fromKey > 0) {
         sql += ","
       }