velocious 1.0.103 → 1.0.105

package/src/database/drivers/sqlite/connection-remote.js

@@ -1,4 +1,11 @@
+// @ts-check
+
 export default class VelociousDatabaseDriversSqliteConnectionRemote {
+  /**
+   * @abstract
+   * @param {string} sql
+   * @returns {Promise<any[]>}
+   */
   async query(sql) { // eslint-disable-line no-unused-vars
     throw new Error("stub")
   }

package/src/database/drivers/sqlite/connection-sql-js.js

@@ -1,7 +1,13 @@
+// @ts-check
+
 import debounce from "debounce"
 import query from "./query"
 
 export default class VelociousDatabaseDriversSqliteConnectionSqlJs {
+  /**
+   * @param {import("../base.js").default} driver
+   * @param {import("sql.js").Database} connection
+   */
   constructor(driver, connection) {
     this.connection = connection
     this.driver = driver
@@ -9,12 +15,15 @@ export default class VelociousDatabaseDriversSqliteConnectionSqlJs {
 
   async close() {
     await this.saveDatabase()
-    await this.connection.end()
-    this.connection = undefined
+    await this.connection.close()
   }
 
   async disconnect() { await this.saveDatabase() }
 
+  /**
+   * @param {string} sql
+   * @returns {Promise<Record<string, any>[]>}
+   */
   async query(sql) {
     const result = await query(this.connection, sql)
     const downcasedSQL = sql.toLowerCase().trim()
@@ -30,6 +39,7 @@ export default class VelociousDatabaseDriversSqliteConnectionSqlJs {
   saveDatabase = async () => {
     const localStorageContent = this.connection.export()
 
+    // @ts-expect-error
     await this.driver.betterLocalStorage.set(this.driver.localStorageName(), localStorageContent)
   }
 

package/src/database/drivers/sqlite/foreign-key.js

@@ -1,7 +1,14 @@
+// @ts-check
+
 import BaseForeignKey from "../base-foreign-key.js"
 import {digg} from "diggerize"
 
 export default class VelociousDatabaseDriversSqliteForeignKey extends BaseForeignKey {
+  /**
+   * @param {Record<string, any>} data
+   * @param {object} args
+   * @param {string} args.tableName
+   */
   constructor(data, {tableName}) {
     super(data)
     this.tableName = tableName

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

@@ -1,3 +1,5 @@
+// @ts-check
+
 import fs from "fs/promises"
 import query from "./query.js"
 import sqlite3 from "sqlite3"
@@ -30,10 +32,14 @@ export default class VelociousDatabaseDriversSqliteNode extends Base {
   }
 
   async close() {
-    await this.connection.close()
+    await this.connection?.close()
     this.connection = undefined
   }
 
+  /**
+   * @param {string} sql
+   * @returns {Promise<Record<string, any>[]>}
+   */
   async _queryActual(sql) {
     return await query(this.connection, sql)
   }

package/src/database/drivers/sqlite/index.web.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import BetterLocalStorage from "better-localstorage"
 import ConnectionSqlJs from "./connection-sql-js"
 import initSqlJs from "sql.js"
@@ -5,6 +7,9 @@ import initSqlJs from "sql.js"
 import Base from "./base.js"
 
 export default class VelociousDatabaseDriversSqliteWeb extends Base {
+  /** @type {BetterLocalStorage | undefined} */
+  betterLocalStorage = undefined
+
   async connect() {
     this.args = this.getArgs()
 
@@ -32,7 +37,7 @@ export default class VelociousDatabaseDriversSqliteWeb extends Base {
   }
 
   getConnection() {
-    if (this.args.getConnection) {
+    if (this.args?.getConnection) {
       return this.args.getConnection()
     } else {
       return this._connection
@@ -40,13 +45,17 @@ export default class VelociousDatabaseDriversSqliteWeb extends Base {
   }
 
   localStorageName() {
-    if (!this.args.name) {
+    if (!this.args?.name) {
       throw new Error("No name given in arguments for SQLite Web database")
     }
 
-    return `VelociousDatabaseDriversSqliteWeb---${this.args.name}`
+    return `VelociousDatabaseDriversSqliteWeb---${this.args?.name}`
   }
 
+  /**
+   * @param {string} sql
+   * @returns {Promise<Record<string, any>[]>}
+   */
   async _queryActual(sql) {
     return await this.getConnection().query(sql)
   }

package/src/database/drivers/sqlite/options.js

@@ -1,6 +1,11 @@
+// @ts-check
+
 import QueryParserOptions from "../../query-parser/options.js"
 
 export default class VelociousDatabaseDriversSqliteOptions extends QueryParserOptions {
+  /**
+   * @param {import("../../query-parser/options.js").OptionsObjectArgsType} options
+   */
   constructor(options) {
     options.columnQuote = "`"
     options.indexQuote = "`"
@@ -10,6 +15,10 @@ export default class VelociousDatabaseDriversSqliteOptions extends QueryParserOp
     super(options)
   }
 
+  /**
+   * @param {string} string
+   * @returns {number | string}
+   */
   quote(string) {
     if (!this.driver) throw new Error("Driver not set")
 

package/src/database/drivers/sqlite/query-parser.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import BaseQueryParser from "../../query-parser/base-query-parser.js"
 
 export default class VelociousDatabaseConnectionDriversSqliteQueryParser extends BaseQueryParser {

package/src/database/drivers/sqlite/query.js

@@ -1,8 +1,19 @@
-export default async function query(connection, sql) {
-  let result
+// @ts-check
 
+/**
+ * @param {import("sqlite3").Database} connection
+ * @param {string} sql
+ * @returns {Promise<Record<string, any>[]>}
+ */
+export default async function query(connection, sql) {
   try {
+    /** @type {Record<string, any>[]} */
+    let result
+
+    // @ts-expect-error
     result = await connection.all(sql)
+
+    return result
   } catch (error) {
     let sqlInErrorMessage = `${sql}`
 
@@ -10,10 +21,12 @@ export default async function query(connection, sql) {
       sqlInErrorMessage = `${sqlInErrorMessage.substring(0, 4096)}...`
     }
 
-    error.message += `\n\n${sqlInErrorMessage}`
+    if (error instanceof Error) {
+      error.message += `\n\n${sqlInErrorMessage}`
 
-    throw new Error(error.message)
+      throw new Error(error.message)
+    } else {
+      throw new Error(`An error occurred: ${error}\n\n${sql}`)
+    }
   }
-
-  return result
 }

package/src/database/drivers/sqlite/query.web.js

@@ -1,3 +1,10 @@
+// @ts-check
+
+/**
+ * @param {import("sql.js").Database} connection
+ * @param {string} sql
+ * @returns {Promise<Record<string, any>[]>}
+ */
 export default async function query(connection, sql) {
   const rows = []
   let result
@@ -11,7 +18,11 @@ export default async function query(connection, sql) {
       sqlInErrorMessage = `${sqlInErrorMessage.substring(0, 4096)}...`
     }
 
-    error.message += `\n\n${sqlInErrorMessage}`
+    if (error instanceof Error) {
+      error.message += `\n\n${sqlInErrorMessage}`
+    } else {
+      throw new Error(`An error occurred: ${error}\n\n${sqlInErrorMessage}`)
+    }
 
     throw error
   }
@@ -20,6 +31,7 @@ export default async function query(connection, sql) {
     const columns = result[0].columns
 
     for (const rowValues of result[0].values) {
+      /** @type {Record<string, any>} */
       const row = {}
 
       for (const columnIndex in columns) {

package/src/database/initializer-from-require-context.js

@@ -1,9 +1,19 @@
+// @ts-check
+
+/**
+ * @typedef {(id: string) => {default: typeof import("./record/index.js").default}} ModelClassRequireContextIDFunctionType
+ * @typedef {ModelClassRequireContextIDFunctionType & {
+ *   keys: () => string[],
+ *   id: string
+ * }} ModelClassRequireContextType
+ */
+
 import restArgsError from "../utils/rest-args-error.js"
 
 export default class VelociousDatabaseInitializerFromRequireContext {
   /**
    * @param {object} args
-   * @param {object} args.requireContext
+   * @param {ModelClassRequireContextType} args.requireContext
    */
   constructor({requireContext, ...restArgs}) {
     restArgsError(restArgs)

package/src/database/migrator/types.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
  * @typedef {object} MigrationObjectType
  * @property {number} date

package/src/database/pool/base-methods-forward.js

@@ -1,5 +1,8 @@
+// @ts-check
+
 /**
  * @param {typeof import("./base.js").default} PoolBase
+ * @returns {void}
  */
 export default function baseMethodsForward(PoolBase) {
   const forwardMethods = [
@@ -25,12 +28,16 @@ export default function baseMethodsForward(PoolBase) {
   ]
 
   for (const forwardMethod of forwardMethods) {
+    // @ts-expect-error
     PoolBase.prototype[forwardMethod] = function(...args) {
       const connection = this.getCurrentConnection()
+
+      // @ts-expect-error
       const connectionMethod = connection[forwardMethod]
 
       if (!connectionMethod) throw new Error(`${forwardMethod} isn't defined on driver`)
 
+        // @ts-expect-error
       return connection[forwardMethod](...args)
     }
   }

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

@@ -1,6 +1,14 @@
+// @ts-check
+
 import QueryBase from "./base.js"
 
 export default class VelociousDatabaseQueryDeleteBase extends QueryBase {
+  /**
+   * @param {object} args
+   * @param {Record<string, any>} args.conditions
+   * @param {import("../drivers/base.js").default} args.driver
+   * @param {string} args.tableName
+   */
   constructor({conditions, driver, tableName}) {
     super({driver})
     this.conditions = conditions

package/src/database/query/preloader/belongs-to.js

@@ -1,6 +1,13 @@
+// @ts-check
+
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloaderBelongsTo {
+  /**
+   * @param {object} args
+   * @param {import("../../record/index.js").default[]} args.models
+   * @param {import("../../record/relationships/belongs-to.js").default} args.relationship
+   */
   constructor({models, relationship, ...restArgs}) {
     restArgsError(restArgs)
 
@@ -9,6 +16,7 @@ export default class VelociousDatabaseQueryPreloaderBelongsTo {
   }
 
   async run() {
+    /** @type {Array<number | string>} */
     const foreignKeyValues = []
     const foreignKey = this.relationship.getForeignKey()
 
@@ -18,13 +26,20 @@ export default class VelociousDatabaseQueryPreloaderBelongsTo {
       if (!foreignKeyValues.includes(foreignKeyValue)) foreignKeyValues.push(foreignKeyValue)
     }
 
+    /** @type {Record<string, any>} */
     const whereArgs = {}
     const primaryKey = this.relationship.getPrimaryKey()
 
     whereArgs[primaryKey] = foreignKeyValues
 
+    const targetModelClass = this.relationship.getTargetModelClass()
+
+    if (!targetModelClass) throw new Error("No target model class could be gotten from relationship")
+
     // Load target models to be preloaded on the given models
-    const targetModels = await this.relationship.getTargetModelClass().where(whereArgs).toArray()
+    const targetModels = await targetModelClass.where(whereArgs).toArray()
+
+    /** @type {Record<string, import("../../record/index.js").default>} */
     const targetModelsById = {}
 
     for (const targetModel of targetModels) {

package/src/database/query/preloader/has-many.js

@@ -1,6 +1,13 @@
+// @ts-check
+
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloaderHasMany {
+  /**
+   * @param {object} args
+   * @param {import("../../record/index.js").default[]} args.models
+   * @param {import("../../record/relationships/has-many.js").default} args.relationship
+   */
   constructor({models, relationship, ...restArgs}) {
     restArgsError(restArgs)
 
@@ -9,10 +16,16 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
   }
 
   async run() {
+    /** @type {Array<number | string>} */
     const modelsPrimaryKeyValues = []
+
+    /** @type {Record<number | string, Array<import("../../record/index.js").default>>} */
     const modelsByPrimaryKeyValue = {}
+
     const foreignKey = this.relationship.getForeignKey()
     const primaryKey = this.relationship.getPrimaryKey()
+
+    /** @type {Record<number | string, Array<import("../../record/index.js").default>>} */
     const preloadCollections = {}
 
     if (!primaryKey) {
@@ -30,12 +43,17 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
       modelsByPrimaryKeyValue[primaryKeyValue].push(model)
     }
 
+    /** @type {Record<string, any>} */
     const whereArgs = {}
 
     whereArgs[foreignKey] = modelsPrimaryKeyValues
 
+    const targetModelClass = this.relationship.getTargetModelClass()
+
+    if (!targetModelClass) throw new Error("No target model class could be gotten from relationship")
+
     // Load target models to be preloaded on the given models
-    const targetModels = await this.relationship.getTargetModelClass().where(whereArgs).toArray()
+    const targetModels = await targetModelClass.where(whereArgs).toArray()
 
     for (const targetModel of targetModels) {
       const foreignKeyValue = targetModel.readColumn(foreignKey)

package/src/database/query/preloader/has-one.js

@@ -1,6 +1,13 @@
+// @ts-check
+
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloaderHasOne {
+  /**
+   * @param {object} args
+   * @param {Array<import("../../record/index.js").default>} args.models
+   * @param {import("../../record/relationships/has-one.js").default} args.relationship
+   */
   constructor({models, relationship, ...restArgs}) {
     restArgsError(restArgs)
 
@@ -9,16 +16,22 @@ export default class VelociousDatabaseQueryPreloaderHasOne {
   }
 
   async run() {
+    /** @type {Array<number | string>} */
     const modelsPrimaryKeyValues = []
+
+    /** @type {Record<number | string, Array<import("../../record/index.js").default>>} */
     const modelsByPrimaryKeyValue = {}
+
     const foreignKey = this.relationship.getForeignKey()
     const primaryKey = this.relationship.getPrimaryKey()
+
+    /** @type {Record<number | string, import("../../record/index.js").default | undefined>} */
     const preloadCollections = {}
 
     for (const model of this.models) {
       const primaryKeyValue = model.readColumn(primaryKey)
 
-      preloadCollections[primaryKeyValue] = null
+      preloadCollections[primaryKeyValue] = undefined
 
       if (!modelsPrimaryKeyValues.includes(primaryKeyValue)) modelsPrimaryKeyValues.push(primaryKeyValue)
       if (!(primaryKeyValue in modelsByPrimaryKeyValue)) modelsByPrimaryKeyValue[primaryKeyValue] = []
@@ -26,12 +39,17 @@ export default class VelociousDatabaseQueryPreloaderHasOne {
       modelsByPrimaryKeyValue[primaryKeyValue].push(model)
     }
 
+    /** @type {Record<string, any>} */
     const whereArgs = {}
 
     whereArgs[foreignKey] = modelsPrimaryKeyValues
 
+    const targetModelClass = this.relationship.getTargetModelClass()
+
+    if (!targetModelClass) throw new Error("No target model class could be gotten from relationship")
+
     // Load target models to be preloaded on the given models
-    const targetModels = await this.relationship.getTargetModelClass().where(whereArgs).toArray()
+    const targetModels = await targetModelClass.where(whereArgs).toArray()
 
     for (const targetModel of targetModels) {
       const foreignKeyValue = targetModel.readColumn(foreignKey)

package/src/database/query/preloader.js

@@ -1,9 +1,17 @@
+// @ts-check
+
 import BelongsToPreloader from "./preloader/belongs-to.js"
 import HasManyPreloader from "./preloader/has-many.js"
 import HasOnePreloader from "./preloader/has-one.js"
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryPreloader {
+  /**
+   * @param {object} args
+   * @param {typeof import("../record/index.js").default} args.modelClass
+   * @param {import("../record/index.js").default[]} args.models
+   * @param {Record<string, any>} args.preload
+   */
   constructor({modelClass, models, preload, ...restArgs}) {
     restArgsError(restArgs)
 
@@ -18,15 +26,18 @@ export default class VelociousDatabaseQueryPreloader {
       let targetModels
 
       if (relationship.getType() == "belongsTo") {
-        const hasManyPreloader = new BelongsToPreloader({models: this.models, relationship: relationship})
+        const belongsToRelationship = /** @type {import("../record/relationships/belongs-to.js").default} */ (relationship)
+        const hasManyPreloader = new BelongsToPreloader({models: this.models, relationship: belongsToRelationship})
 
         targetModels = await hasManyPreloader.run()
       } else if (relationship.getType() == "hasMany") {
-        const hasManyPreloader = new HasManyPreloader({models: this.models, relationship: relationship})
+        const hasManyRelationship = /** @type {import("../record/relationships/has-many.js").default} */ (relationship)
+        const hasManyPreloader = new HasManyPreloader({models: this.models, relationship: hasManyRelationship})
 
         targetModels = await hasManyPreloader.run()
       } else if (relationship.getType() == "hasOne") {
-        const hasOnePreloader = new HasOnePreloader({models: this.models, relationship: relationship})
+        const hasOneRelationship = /** @type {import("../record/relationships/has-one.js").default} */ (relationship)
+        const hasOnePreloader = new HasOnePreloader({models: this.models, relationship: hasOneRelationship})
 
         targetModels = await hasOnePreloader.run()
       } else {
@@ -37,7 +48,11 @@ export default class VelociousDatabaseQueryPreloader {
       const newPreload = this.preload[preloadRelationshipName]
 
       if (typeof newPreload == "object" && targetModels.length > 0) {
-        const preloader = new VelociousDatabaseQueryPreloader({modelClass: relationship.getTargetModelClass(), models: targetModels, preload: newPreload})
+        const targetModelClass = relationship.getTargetModelClass()
+
+        if (!targetModelClass) throw new Error("No target model class could be gotten from relationship")
+
+        const preloader = new VelociousDatabaseQueryPreloader({modelClass: targetModelClass, models: targetModels, preload: newPreload})
 
         await preloader.run()
       }

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

@@ -1,4 +1,13 @@
+// @ts-check
+
 export default class VelociousDatabaseQueryUpdateBase {
+  /**
+   * @param {object} args
+   * @param {Record<string, any>} args.conditions
+   * @param {Record<string, any>} args.data
+   * @param {import("../drivers/base.js").default} args.driver
+   * @param {string} args.tableName
+   */
   constructor({conditions, data, driver, tableName}) {
     this.conditions = conditions
     this.data = data

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

@@ -1,13 +1,18 @@
-import {digs} from "diggerize"
+// @ts-check
 
 export default class VelocuiousDatabaseQueryParserLimitParser {
+  /**
+   * @param {object} args
+   * @param {boolean} args.pretty
+   * @param {import("../query/index.js").default} args.query
+   */
   constructor({pretty, query}) {
     this.pretty = pretty
     this.query = query
   }
 
   toSql() {
-    const {pretty, query} = digs(this, "pretty", "query")
+    const {pretty, query} = this
     const driver = query.driver
     const options = this.query.getOptions()
     let sql = ""

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

@@ -1,28 +1,52 @@
-import {digg} from "diggerize"
+// @ts-check
+
+/**
+ * @typedef {object} OptionsObjectArgsType
+ * @property {string} columnQuote
+ * @property {string} indexQuote
+ * @property {import("../drivers/base.js").default} driver
+ * @property {string} tableQuote
+ * @property {string} stringQuote
+ */
 
 export default class VelociousDatabaseQueryParserOptions {
+  /**
+   * @param {OptionsObjectArgsType} options
+   */
   constructor(options) {
-    this.columnQuote = digg(options, "columnQuote")
-    this.indexQuote = digg(options, "indexQuote")
-    this.driver = digg(options, "driver")
-    this.tableQuote = digg(options, "tableQuote")
-    this.stringQuote = digg(options, "stringQuote")
+    this.columnQuote = options.columnQuote
+    this.indexQuote = options.indexQuote
+    this.driver = options.driver
+    this.tableQuote = options.tableQuote
+    this.stringQuote = options.stringQuote
 
     if (!this.driver) throw new Error("No driver given to parser options")
   }
 
+  /**
+   * @param {any} value
+   * @returns {number | string}
+   */
   quote(value) {
     if (typeof value == "number") return value
 
     return this.quoteString(value)
   }
 
+  /**
+   * @param {string} databaseName
+   * @returns {string}
+   */
   quoteDatabaseName(databaseName) {
     if (databaseName.includes(this.tableQuote)) throw new Error(`Possible SQL injection in database name: ${databaseName}`)
 
     return `${this.tableQuote}${databaseName}${this.tableQuote}`
   }
 
+  /**
+   * @param {string} columnName
+   * @returns {string}
+   */
   quoteColumnName(columnName) {
     if (!columnName) throw new Error("No column name was given")
     if (columnName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${columnName}`)
@@ -30,12 +54,29 @@ export default class VelociousDatabaseQueryParserOptions {
     return `${this.columnQuote}${columnName}${this.columnQuote}`
   }
 
+  /**
+   * @param {string} indexName
+   * @returns {string}
+   */
   quoteIndexName(indexName) {
     if (!indexName || indexName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${indexName}`)
 
     return `${this.columnQuote}${indexName}${this.columnQuote}`
   }
 
+  /**
+   * @abstract
+   * @param {any} string
+   * @returns {string}
+   */
+  quoteString(string) { // eslint-disable-line no-unused-vars
+    throw new Error("quoteString not implemented")
+  }
+
+  /**
+   * @param {string} tableName
+   * @returns {string}
+   */
   quoteTableName(tableName) {
     if (!tableName || tableName.includes(this.tableQuote)) throw new Error(`Invalid table name: ${tableName}`)