velocious 1.0.104 → 1.0.105

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

@@ -628,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/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

package/src/routes/base-route.js

@@ -1,73 +1,82 @@
-import GetRoute from "./get-route.js"
-import NamespaceRoute from "./namespace-route.js"
-import PostRoute from "./post-route.js"
-import ResourceRoute from "./resource-route.js"
+// @ts-check
 
-var VelociousBaseRoute
+export default class VelociousBaseRoute {
+  /** @type {typeof import("./get-route.js").default} */
+  static GetRouteType
 
-export function initBaseRoute() {
-  if (VelociousBaseRoute) return
+  /** @type {typeof import("./namespace-route.js").default} */
+  static NameSpaceRouteType
 
-  VelociousBaseRoute = class VelociousBaseRoute {
-    routes = []
+  /** @type {typeof import("./post-route.js").default} */
+  static PostRouteType
 
-    /**
-     * @param {string} name
-     */
-    get(name) {
-      const route = new GetRoute({name})
+  /** @type {typeof import("./resource-route.js").default} */
+  static ResourceRouteType
 
-      this.routes.push(route)
-    }
+  /** @param {typeof import("./get-route.js").default} RouteClass */
+  static registerRouteGetType(RouteClass) {
+    this.GetRouteType = RouteClass
+  }
 
-    /**
-     * @abstract
-     * @param {string} _path
-     */
-    matchWithPath(_path) { // eslint-disable-line no-unused-vars
-      throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
-    }
+  /** @param {typeof import("./namespace-route.js").default} RouteClass */
+  static registerRouteNamespaceType(RouteClass) {
+    this.NameSpaceRouteType = RouteClass
+  }
 
-    /**
-     * @param {string} name
-     * @param {function(NamespaceRoute) : void} callback
-     * @returns {void}
-     */
-    namespace(name, callback) {
-      const route = new NamespaceRoute({name})
+  /** @param {typeof import("./post-route.js").default} RouteClass */
+  static registerRoutePostType(RouteClass) {
+    this.PostRouteType = RouteClass
+  }
 
-      this.routes.push(route)
+  /** @param {typeof import("./resource-route.js").default} RouteClass */
+  static registerRouteResourceType(RouteClass) {
+    this.ResourceRouteType = RouteClass
+  }
 
-      if (callback) {
-        callback(route)
-      }
-    }
+  constructor() {
+    // Nothing
+  }
 
-    /**
-     * @param {string} name
-     * @returns {void}
-     */
-    post(name) {
-      const route = new PostRoute({name})
+  /** @type {Array<VelociousBaseRoute>} */
+  routes = []
 
-      this.routes.push(route)
-    }
+  /**
+   * @abstract
+   * @param {string} name
+   */
+  get(name) { throw new Error("'get' not implemented") } // eslint-disable-line no-unused-vars
 
-    /**
-     * @param {string} name
-     * @param {function(ResourceRoute) : void} callback
-     * @returns {void}
-     */
-    resources(name, callback) {
-      const route = new ResourceRoute({name})
+  /**
+   * @param {object} args
+   * @param {Record<string, any>} args.params
+   * @param {string} args.path
+   * @param {import("../http-server/client/request.js").default} args.request
+   * @returns {{restPath: string} | undefined}
+   */
+  matchWithPath({params, path, request}) { // eslint-disable-line no-unused-vars
+    throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
+  }
 
-      this.routes.push(route)
+  /**
+   * @abstract
+   * @param {string} name
+   * @param {function(import("./namespace-route.js").default) : void} callback
+   * @returns {void}
+   */
+  namespace(name, callback) { throw new Error("'namespace' not implemented") } // eslint-disable-line no-unused-vars
 
-      if (callback) {
-        callback(route)
-      }
-    }
-  }
-}
+  /**
+   * @abstract
+   * @param {string} name
+   * @returns {void}
+   */
+  post(name) { throw new Error("'post' not implemented") } // eslint-disable-line no-unused-vars
 
-export {VelociousBaseRoute as default}
+  /**
+   * @abstract
+   * @param {string} name
+   * @param {function(import("./resource-route.js").default) : void} callback
+   * @returns {void}
+   */
+  resources(name, callback) { throw new Error("'resources' not implemented") } // eslint-disable-line no-unused-vars
+}

package/src/routes/basic-route.js

@@ -0,0 +1,76 @@
+// @ts-check
+
+import BaseRoute from "./base-route.js"
+
+export default class VelociousBasicRoute extends BaseRoute {
+  /** @param {string} name */
+  get(name) {
+    const GetRoute = VelociousBasicRoute.GetRouteType
+    const route = new GetRoute({name})
+
+    this.routes.push(route)
+  }
+
+  /**
+   * @param {object} args
+   * @param {Record<string, any>} args.params
+   * @param {string} args.path
+   * @param {import("../http-server/client/request.js").default} args.request
+   * @returns {{restPath: string} | undefined}
+   */
+  matchWithPath({params, path, request}) { // eslint-disable-line no-unused-vars
+    throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
+  }
+
+  /**
+   * @param {string} name
+   * @param {function(import("./namespace-route.js").default) : void} callback
+   * @returns {void}
+   */
+  namespace(name, callback) {
+    const NamespaceRoute = VelociousBasicRoute.NameSpaceRouteType
+
+    if (!NamespaceRoute) throw new Error("No NamespaceRoute registered")
+
+    const route = new NamespaceRoute({name})
+
+    this.routes.push(route)
+
+    if (callback) {
+      callback(route)
+    }
+  }
+
+  /**
+   * @param {string} name
+   * @returns {void}
+   */
+  post(name) {
+    const PostRoute = VelociousBasicRoute.PostRouteType
+
+    if (!PostRoute) throw new Error("No PostRoute registered")
+
+    const route = new PostRoute({name})
+
+    this.routes.push(route)
+  }
+
+  /**
+   * @param {string} name
+   * @param {function(import("./resource-route.js").default) : void} callback
+   * @returns {void}
+   */
+  resources(name, callback) {
+    const ResourceRoute = VelociousBasicRoute.ResourceRouteType
+
+    if (!ResourceRoute) throw new Error("No ResourceRoute registered")
+
+    const route = new ResourceRoute({name})
+
+    this.routes.push(route)
+
+    if (callback) {
+      callback(route)
+    }
+  }
+}

package/src/routes/get-route.js

@@ -1,10 +1,15 @@
-import BaseRoute, {initBaseRoute} from "./base-route.js"
+// @ts-check
+
 import escapeStringRegexp from "escape-string-regexp"
-import restArgsError from "../utils/rest-args-error.js"
 
-initBaseRoute()
+import BaseRoute from "./base-route.js"
+import restArgsError from "../utils/rest-args-error.js"
 
-export default class VelociousRouteGetRoute extends BaseRoute {
+class VelociousRouteGetRoute extends BaseRoute {
+  /**
+   * @param {object} args
+   * @param {string} args.name
+   */
   constructor({name, ...restArgs}) {
     super()
     restArgsError(restArgs)
@@ -12,7 +17,14 @@ export default class VelociousRouteGetRoute extends BaseRoute {
     this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
   }
 
-  matchWithPath({params, path}) {
+  /**
+   * @param {object} args
+   * @param {Record<string, any>} args.params
+   * @param {string} args.path
+   * @param {import("../http-server/client/request.js").default} args.request
+   * @returns {{restPath: string} | undefined}
+   */
+  matchWithPath({params, path, request}) { // eslint-disable-line no-unused-vars
     const match = path.match(this.regExp)
 
     if (match) {
@@ -24,3 +36,7 @@ export default class VelociousRouteGetRoute extends BaseRoute {
     }
   }
 }
+
+BaseRoute.registerRouteGetType(VelociousRouteGetRoute)
+
+export default VelociousRouteGetRoute

package/src/routes/index.js

@@ -1,8 +1,18 @@
+// @ts-check
+
+import GetRoute from "./get-route.js" // eslint-disable-line no-unused-vars
+import NameSpaceRoute from "./namespace-route.js" // eslint-disable-line no-unused-vars
+import PostRoute from "./post-route.js" // eslint-disable-line no-unused-vars
 import RootRoute from "./root-route.js"
+import ResourceRoute from "./resource-route.js" // eslint-disable-line no-unused-vars
 
 export default class VelociousRoutes {
   rootRoute = new RootRoute()
 
+  /**
+   * @param {function(import("./root-route.js").default) : void} callback
+   * @returns {void}
+   */
   draw(callback) {
     callback(this.rootRoute)
   }