velocious 1.0.103 → 1.0.105

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

@@ -1,13 +1,18 @@
-import {digs} from "diggerize"
+// @ts-check
 
 export default class VelocuiousDatabaseQueryParserOrderParser {
+  /**
+   * @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
     let sql = ""
 
     if (query._orders.length == 0) return sql
@@ -19,11 +24,10 @@ export default class VelocuiousDatabaseQueryParserOrderParser {
     }
 
     sql += "ORDER BY"
+    let count = 0
 
-    for (const orderKey in query._orders) {
-      const order = query._orders[orderKey]
-
-      if (orderKey > 0) sql += " ,"
+    for (const order of query._orders) {
+      if (count > 0) sql += " ,"
 
       if (pretty) {
         sql += "\n  "
@@ -32,6 +36,7 @@ export default class VelocuiousDatabaseQueryParserOrderParser {
       }
 
       sql += order.toSql()
+      count++
     }
 
     return sql

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

@@ -1,4 +1,5 @@
-import {digs} from "diggerize"
+// @ts-check
+
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryParserSelectParser {
@@ -15,7 +16,7 @@ export default class VelociousDatabaseQueryParserSelectParser {
   }
 
   toSql() {
-    const {pretty, query} = digs(this, "pretty", "query")
+    const {pretty, query} = this
 
     let sql = ""
 
@@ -27,14 +28,14 @@ export default class VelociousDatabaseQueryParserSelectParser {
       sql += " "
     }
 
-    for (const selectKey in query._selects) {
-      const selectValue = query._selects[selectKey]
+    let count = 0
 
+    for (const selectValue of query._selects) {
       selectValue.setQuery(query)
 
       sql += selectValue.toSql()
 
-      if (selectKey + 1 < query._selects.length) {
+      if (count + 1 < query._selects.length) {
         if (pretty) {
           sql += ","
           sql += "  "
@@ -42,6 +43,8 @@ export default class VelociousDatabaseQueryParserSelectParser {
           sql += ", "
         }
       }
+
+      count++
     }
 
     if (query.getSelects().length == 0) {

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

@@ -1,13 +1,18 @@
-import {digs} from "diggerize"
+// @ts-check
 
 export default class VelocuiousDatabaseQueryParserWhereParser {
+  /**
+   * @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
     let sql = ""
 
     if (query._wheres.length == 0) return sql
@@ -20,10 +25,10 @@ export default class VelocuiousDatabaseQueryParserWhereParser {
 
     sql += "WHERE"
 
-    for (const whereKey in query._wheres) {
-      const where = query._wheres[whereKey]
+    let count = 0
 
-      if (whereKey > 0) sql += " AND"
+    for (const where of query._wheres) {
+      if (count > 0) sql += " AND"
 
       if (pretty) {
         sql += "\n  "
@@ -32,6 +37,7 @@ export default class VelocuiousDatabaseQueryParserWhereParser {
       }
 
       sql += where.toSql()
+      count++
     }
 
     return sql

package/src/database/record/index.js

@@ -468,9 +468,6 @@ class VelociousDatabaseRecord {
     const columnNameToAttributeName = this.getColumnNameToAttributeNameMap()
     const attributeNameToColumnName = this.getAttributeNameToColumnNameMap()
 
-    /** @type {Record<string, (this: VelociousDatabaseRecord) => unknown>} */
-    const proto = /** @type {any} */ (this.prototype);
-
     for (const column of this._columns) {
       this._columnsAsHash[column.getName()] = column
 
@@ -480,17 +477,18 @@ class VelociousDatabaseRecord {
       attributeNameToColumnName[camelizedColumnName] = column.getName()
       columnNameToAttributeName[column.getName()] = camelizedColumnName
 
-      proto[camelizedColumnName] = function() {
+      // @ts-expect-error
+      this.prototype[camelizedColumnName] = function() {
         return this.readAttribute(camelizedColumnName)
       }
 
       // @ts-expect-error
-      proto[`set${camelizedColumnNameBigFirst}`] = function(newValue) {
-        // @ts-expect-error
+      this.prototype[`set${camelizedColumnNameBigFirst}`] = function(newValue) {
         return this._setColumnAttribute(camelizedColumnName, newValue)
       }
 
-      proto[`has${camelizedColumnNameBigFirst}`] = function() {
+      // @ts-expect-error
+      this.prototype[`has${camelizedColumnNameBigFirst}`] = function() {
         // @ts-expect-error
         let value = this[camelizedColumnName]()
 
@@ -539,24 +537,20 @@ class VelociousDatabaseRecord {
         const nameCamelized = inflection.camelize(name)
         const setterMethodName = `set${nameCamelized}`
 
-        /** @type {Record<string, unknown>} */
         // @ts-expect-error
-        const self = this
-
-        /** @type {Record<string, (this: VelociousDatabaseRecord) => unknown>} */
-        const proto = /** @type {any} */ (this.prototype);
-
-        proto[name] = function getTranslatedAttribute() {
+        this.prototype[name] = function getTranslatedAttribute() {
           const locale = this._getConfiguration().getLocale()
 
           return this._getTranslatedAttributeWithFallback(name, locale)
         }
 
-        proto[`has${nameCamelized}`] = function hasTranslatedAttribute() {
-          const candidate = self[name]
+        // @ts-expect-error
+        this.prototype[`has${nameCamelized}`] = function hasTranslatedAttribute() {
+          // @ts-expect-error
+          const candidate = this[name]
 
           if (typeof candidate == "function") {
-            const value = candidate()
+            const value = candidate.bind(this)()
 
             return this._hasAttribute(value)
           } else {
@@ -565,11 +559,9 @@ class VelociousDatabaseRecord {
         }
 
         // @ts-expect-error
-        proto[setterMethodName] = function setTranslatedAttribute(newValue) {
-          // @ts-expect-error
+        this.prototype[setterMethodName] = function setTranslatedAttribute(newValue) {
           const locale = this._getConfiguration().getLocale()
 
-          // @ts-expect-error
           return this._setTranslatedAttribute(name, locale, newValue)
         }
 
@@ -577,6 +569,7 @@ class VelociousDatabaseRecord {
           const localeCamelized = inflection.camelize(locale)
           const getterMethodNameLocalized = `${name}${localeCamelized}`
           const setterMethodNameLocalized = `${setterMethodName}${localeCamelized}`
+          const hasMethodNameLocalized = `has${inflection.camelize(name)}${localeCamelized}`
 
           // @ts-expect-error
           this.prototype[getterMethodNameLocalized] = function getTranslatedAttributeWithLocale() {
@@ -587,6 +580,20 @@ class VelociousDatabaseRecord {
           this.prototype[setterMethodNameLocalized] = function setTranslatedAttributeWithLocale(newValue) {
             return this._setTranslatedAttribute(name, locale, newValue)
           }
+
+          // @ts-expect-error
+          this.prototype[hasMethodNameLocalized] = function hasTranslatedAttribute() {
+            // @ts-expect-error
+            const candidate = this[getterMethodNameLocalized]
+
+            if (typeof candidate == "function") {
+              const value = candidate.bind(this)()
+
+              return this._hasAttribute(value)
+            } else {
+              throw new Error(`Expected candidate to be a function but it was: ${typeof candidate}`)
+            }
+          }
         }
       }
     }
@@ -621,10 +628,7 @@ class VelociousDatabaseRecord {
     return this._attributes[columnName]
   }
 
-  /**
-   *
-   * @returns {typeof VelociousDatabaseRecord}
-   */
+  /** @returns {typeof VelociousDatabaseRecord} */
   getModelClass() {
     const modelClass = /** @type {typeof VelociousDatabaseRecord} */ (this.constructor)
 

package/src/database/record/instance-relationships/base.js

@@ -15,6 +15,15 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
     this.relationship = relationship
   }
 
+  /**
+   * @abstract
+   * @param {import("../index.js").default[]} records
+   * @returns {void}
+   */
+  addToLoaded(records) { // eslint-disable-line no-unused-vars
+    throw new Error("addToLoaded not implemented")
+  }
+
   /**
    * @abstract
    * @param {Record<string, any>} attributes
@@ -62,7 +71,7 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
     return this._loaded
   }
 
-  /** @param {import("../index.js").default|Array<import("../index.js").default>} model */
+  /** @param {import("../index.js").default|Array<import("../index.js").default>|undefined} model */
   setLoaded(model) { this._loaded = model }
 
   /** @returns {import("../index.js").default | import("../index.js").default[] | undefined} */

package/src/database/record/record-not-found-error.js

@@ -1 +1,3 @@
+// @ts-check
+
 export default class RecordNotFoundError extends Error {}

package/src/database/record/user-module.js

@@ -1,7 +1,13 @@
+// @ts-check
+
 import bcryptjs from "bcryptjs"
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class UserModule {
+  /**
+   * @param {object} args
+   * @param {string} args.secretKey
+   */
   constructor({secretKey, ...restArgs}) {
     restArgsError(restArgs)
 
@@ -10,18 +16,25 @@ export default class UserModule {
     this.secretKey = secretKey
   }
 
+  /**
+   * @param {typeof import("./index.js").default} UserClass
+   */
   attachTo(UserClass) {
+    // @ts-expect-error
     UserClass.prototype.setPassword = function(newPassword) {
       const salt = bcryptjs.genSaltSync(10)
       const encryptedPassword = bcryptjs.hashSync(newPassword, salt)
 
+      // @ts-expect-error
       this.setEncryptedPassword(encryptedPassword)
     }
 
+    // @ts-expect-error
     UserClass.prototype.setPasswordConfirmation = function(newPasswordConfirmation) {
       const salt = bcryptjs.genSaltSync(10)
       const encryptedPassword = bcryptjs.hashSync(newPasswordConfirmation, salt)
 
+      // @ts-expect-error
       this._encryptedPasswordConfirmation = encryptedPassword
     }
   }

package/src/database/record/validators/uniqueness.js

@@ -1,18 +1,29 @@
+// @ts-check
+
 import Base from "./base.js"
 import * as inflection from "inflection"
 
 export default class VelociousDatabaseRecordValidatorsUniqueness extends Base {
+  /**
+   * @param {object} args
+   * @param {import("../index.js").default} args.model
+   * @param {string} args.attributeName
+   * @returns {Promise<void>}
+   */
   async validate({model, attributeName}) {
-    const modelClass = model.constructor
+    const modelClass = /** @type {typeof import("../index.js").default} */ (model.constructor)
+
     const connection = modelClass.connection()
     const tableName = modelClass._getTable().getName()
     const attributeValue = model.readAttribute(attributeName)
     const attributeNameUnderscore = inflection.underscore(attributeName)
+
+    /** @type {Record<string, any>} */
     const whereArgs = {}
 
     whereArgs[attributeNameUnderscore] = attributeValue
 
-    let existingRecordQuery = model.constructor
+    let existingRecordQuery = modelClass
       .select(modelClass.primaryKey())
       .where(whereArgs)
 

package/src/environment-handlers/node/cli/commands/generate/base-models.js

@@ -98,6 +98,16 @@ export default class DbGenerateModel extends BaseCommand {
           fileContent += `  ${name}() { return this._getTranslatedAttributeWithFallback("${name}", this._getConfiguration().getLocale()) }\n`
           methodsCount++
 
+          const hasName = `has${inflection.camelize(name)}`
+
+          fileContent += `\n`
+          fileContent += "  /**\n"
+          fileContent += `   * @abstract\n`
+          fileContent += `   * @returns {boolean}\n`
+          fileContent += "   */\n"
+          fileContent += `  ${hasName}() { throw new Error("${hasName} not implemented") }\n`
+          methodsCount++
+
           for (const locale of this.getConfiguration().getLocales()) {
             const localeMethodName = `${name}${inflection.camelize(locale)}`
 
@@ -109,7 +119,16 @@ export default class DbGenerateModel extends BaseCommand {
             }
 
             fileContent += `  ${localeMethodName}() { return this._getTranslatedAttributeWithFallback("${name}", "${locale}") }\n`
+            methodsCount++
+
+            const localeHasName = `has${inflection.camelize(localeMethodName)}`
 
+            fileContent += `\n`
+            fileContent += "  /**\n"
+            fileContent += `   * @abstract\n`
+            fileContent += `   * @returns {boolean}\n`
+            fileContent += "   */\n"
+            fileContent += `  ${localeHasName}() { throw new Error("${localeHasName} not implemented") }\n`
             methodsCount++
           }
         }

package/src/error-logger.js

@@ -1,13 +1,27 @@
+// @ts-check
+
+/**
+ * @param {(...args: any[]) => Promise<void>} callback
+ */
 export default function errorLogger(callback) {
+  /**
+   * @param  {...any} args
+   * @returns {Promise<void>}
+   */
   return async function(...args) {
     try {
       await callback(...args)
     } catch (error) {
-      console.error(`ErrorLogger: ${error.message}`)
+      if (error instanceof Error) {
+        console.error(`ErrorLogger: ${error.message}`)
 
-      if (error.stack) {
-        console.error("Stack", error.stack)
+        if (error.stack) {
+          console.error("Stack", error.stack)
+        } else {
+          console.error("No stack")
+        }
       } else {
+        console.error(`ErrorLogger: ${error}`)
         console.error("No stack")
       }
 

package/src/http-client/index.js

@@ -1,9 +1,17 @@
+// @ts-check
+
 import net from "net"
 import Request from "./request.js"
 import Response from "./response.js"
 import {Logger} from "../logger.js"
 
 export default class HttpClient {
+  /**
+   * @param {object} args
+   * @param {boolean} [args.debug]
+   * @param {Array<import("./header.js").default>} [args.headers]
+   * @param {string} [args.version]
+   */
   constructor({debug = false, headers, version = "1.1"}) {
     this.headers = headers || []
     this.logger = new Logger(this, {debug})
@@ -15,7 +23,7 @@ export default class HttpClient {
       this.connectionReject = reject
       this.connection = net.createConnection(3006, "127.0.0.1", () => {
         this.connectionReject = null
-        resolve()
+        resolve(null)
       })
 
       this.connection.on("data", this.onConnectionData)
@@ -24,6 +32,12 @@ export default class HttpClient {
     })
   }
 
+  /**
+   * @param {string} path
+   * @param {object} [options]
+   * @param {Array<import("./header.js").default>} [options.headers]
+   * @returns {Promise<{request: import("./request.js").default, response: import("./response.js").default}>}
+   */
   get(path, {headers} = {}) {
     if (!this.connection) throw new Error("Not connected yet")
 
@@ -41,7 +55,7 @@ export default class HttpClient {
 
       for (const header of this.headers) {
         const existingNewHeader = newHeaders.find((newHeader) => {
-          return newHeader.key.toLowerCase().trim() === header.key.toLowerCase().trim()
+          return newHeader.getName().toLowerCase().trim() === header.getName().toLowerCase().trim()
         })
 
         if (!existingNewHeader) {
@@ -56,8 +70,14 @@ export default class HttpClient {
       this.currentRequest.stream((chunk) => {
         this.logger.debug(() => [`Writing: ${chunk}`])
 
+        if (!this.connection) {
+          throw new Error("No connection to write to")
+        }
+
         this.connection.write(chunk, "utf8", (error) => {
           if (error) {
+            if (!this.currentRequestReject) throw new Error("No current request reject function")
+
             this.currentRequestReject(error)
           }
         })
@@ -65,7 +85,12 @@ export default class HttpClient {
     })
   }
 
+  /**
+   * @param {Buffer} data
+   */
   onConnectionData = (data) => {
+    if (!this.currentResponse) throw new Error("No current response to feed data to")
+
     this.currentResponse.feed(data)
   }
 
@@ -73,6 +98,9 @@ export default class HttpClient {
     this.connection = null
   }
 
+  /**
+   * @param {Error} error
+   */
   onConnectionError = (error) => {
     if (this.connectionReject) {
       this.connectionReject(error)
@@ -90,6 +118,10 @@ export default class HttpClient {
   }
 
   onResponseComplete = () => {
+    if (!this.currentRequestResolve) throw new Error("No current request resolve function")
+    if (!this.currentRequest) throw new Error("No current request")
+    if (!this.currentResponse) throw new Error("No current response")
+
     this.currentRequestResolve({
       request: this.currentRequest,
       response: this.currentResponse

package/src/http-client/request.js

@@ -5,7 +5,7 @@ import Header from "./header.js"
 export default class Request {
   /**
    * @param {object} args
-   * @param {string} args.body
+   * @param {string} [args.body]
    * @param {string} args.method
    * @param {Header[]} args.headers
    * @param {string} args.path

package/src/http-server/client/params-to-object.js

@@ -1,4 +1,9 @@
+// @ts-check
+
 export default class ParamsToObject {
+  /**
+   * @param {Record<string, string>} object
+   */
   constructor(object) {
     this.object = object
   }
@@ -15,6 +20,11 @@ export default class ParamsToObject {
     return result
   }
 
+  /**
+   * @param {string} key
+   * @param {string} value
+   * @param {Record<string, any> | any[]} result
+   */
   treatInitial(key, value, result) {
     const firstMatch = key.match(/^(.+?)(\[([\s\S]+$))/)
 
@@ -22,43 +32,61 @@ export default class ParamsToObject {
       const inputName = firstMatch[1]
       const rest = firstMatch[2]
 
+      /** @type {Array<any> | Record<string, any>} */
       let newResult
 
       if (inputName in result) {
+        // @ts-expect-error
         newResult = result[inputName]
       } else if (rest == "[]") {
         newResult = []
+        // @ts-expect-error
         result[inputName] = newResult
       } else {
         newResult = {}
+        // @ts-expect-error
         result[inputName] = newResult
       }
 
       this.treatSecond(value, rest, newResult)
     } else {
+      // @ts-expect-error
       result[key] = value
     }
   }
 
+  /**
+   * @param {string} value
+   * @param {string} rest
+   * @param {Record<string, any> | any[]} result
+   */
   treatSecond(value, rest, result) {
     const secondMatch = rest.match(/^\[(.*?)\]([\s\S]*)$/)
+
+    if (!secondMatch) throw new Error(`Could not parse rest part: ${rest}`)
+
     const key = secondMatch[1]
     const newRest = secondMatch[2]
 
+    /** @type {Array<any> | Record<string, any>} */
     let newResult
 
     if (rest == "[]") {
       result.push(value)
     } else if (newRest == "") {
+      // @ts-expect-error
       result[key] = value
     } else {
       if (typeof result == "object" && key in result) {
+        // @ts-expect-error
         newResult = result[key]
       } else if (newRest == "[]") {
         newResult = []
+        // @ts-expect-error
         result[key] = newResult
       } else {
         newResult = {}
+        // @ts-expect-error
         result[key] = newResult
       }
 

package/src/initializer.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import restArgsError from "./utils/rest-args-error.js"
 
 export default class VelociousInitializer {

package/src/routes/app-routes.js

@@ -1,9 +1,11 @@
+// @ts-check
+
 import {digg} from "diggerize"
 
 export default class VelociousRoutesAppRoutes {
   /**
    * @param {import("../configuration.js").default} configuration
-   * @returns {import("./index.js").default}
+   * @returns {Promise<import("./index.js").default>}
    */
   static async getRoutes(configuration) {
     // Every client need to make their own routes because they probably can't be shared across different worker threads