velocious 1.0.103 → 1.0.105

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)
   }

package/src/routes/namespace-route.js

@@ -1,10 +1,15 @@
+// @ts-check
+
 import restArgsError from "../utils/rest-args-error.js"
-import BaseRoute, {initBaseRoute} from "./base-route.js"
+import BaseRoute from "./base-route.js"
+import BasicRoute from "./base-route.js"
 import escapeStringRegexp from "escape-string-regexp"
 
-initBaseRoute()
-
-export default class VelociousRouteNamespaceRoute extends BaseRoute {
+class VelociousRouteNamespaceRoute extends BasicRoute {
+  /**
+   * @param {object} args
+   * @param {string} args.name
+   */
   constructor({name, ...restArgs}) {
     super()
     restArgsError(restArgs)
@@ -12,7 +17,14 @@ export default class VelociousRouteNamespaceRoute 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 VelociousRouteNamespaceRoute extends BaseRoute {
     }
   }
 }
+
+BaseRoute.registerRouteNamespaceType(VelociousRouteNamespaceRoute)
+
+export default VelociousRouteNamespaceRoute

package/src/routes/post-route.js

@@ -1,10 +1,14 @@
-import BaseRoute, {initBaseRoute} from "./base-route.js"
+// @ts-check
+
+import BaseRoute from "./base-route.js"
 import escapeStringRegexp from "escape-string-regexp"
 import restArgsError from "../utils/rest-args-error.js"
 
-initBaseRoute()
-
-export default class VelociousRoutePostRoute extends BaseRoute {
+class VelociousRoutePostRoute extends BaseRoute {
+  /**
+   * @param {object} args
+   * @param {string} args.name
+   */
   constructor({name, ...restArgs}) {
     super()
     restArgsError(restArgs)
@@ -12,7 +16,14 @@ export default class VelociousRoutePostRoute 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 +35,7 @@ export default class VelociousRoutePostRoute extends BaseRoute {
     }
   }
 }
+
+BaseRoute.registerRoutePostType(VelociousRoutePostRoute)
+
+export default VelociousRoutePostRoute

package/src/routes/resolver.js

@@ -1,10 +1,18 @@
-import {digg, digs} from "diggerize"
+// @ts-check
+
+import {digg} from "diggerize"
 import {dirname} from "path"
 import {fileURLToPath} from "url"
 import fs from "fs/promises"
 import * as inflection from "inflection"
 
 export default class VelociousRoutesResolver {
+  /**
+   * @param {object} args
+   * @param {import("../configuration.js").default} args.configuration
+   * @param {import("../http-server/client/request.js").default} args.request
+   * @param {import("../http-server/client/response.js").default} args.response
+   */
   constructor({configuration, request, response}) {
     if (!configuration) throw new Error("No configuration given")
     if (!request) throw new Error("No request given")
@@ -65,6 +73,11 @@ export default class VelociousRoutesResolver {
     })
   }
 
+  /**
+   * @param {import("./base-route.js").default} route
+   * @param {string} path
+   * @returns {{restPath: string} | undefined}
+   */
   matchPathWithRoutes(route, path) {
     const pathWithoutSlash = path.replace(/^\//, "")
 
@@ -77,7 +90,7 @@ export default class VelociousRoutesResolver {
 
       if (!matchResult) continue
 
-      const {restPath} = digs(matchResult, "restPath")
+      const {restPath} = matchResult
 
       if (restPath) {
         return this.matchPathWithRoutes(subRoute, restPath)

package/src/routes/resource-route.js

@@ -1,10 +1,15 @@
-import BaseRoute, {initBaseRoute} from "./base-route.js"
+// @ts-check
+
+import BaseRoute from "./base-route.js"
+import BasicRoute from "./basic-route.js"
 import escapeStringRegexp from "escape-string-regexp"
 import restArgsError from "../utils/rest-args-error.js"
 
-initBaseRoute()
-
-export default class VelociousRouteResourceRoute extends BaseRoute {
+class VelociousRouteResourceRoute extends BasicRoute {
+  /**
+   * @param {object} args
+   * @param {string} args.name
+   */
   constructor({name, ...restArgs}) {
     super()
     restArgsError(restArgs)
@@ -12,6 +17,13 @@ export default class VelociousRouteResourceRoute extends BaseRoute {
     this.regExp = new RegExp(`^(${escapeStringRegexp(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}) {
     const match = path.match(this.regExp)
 
@@ -22,7 +34,7 @@ export default class VelociousRouteResourceRoute extends BaseRoute {
       let subRoutesMatchesRestPath = false
 
       for (const route of this.routes) {
-        if (route.matchWithPath({path: restPath})) {
+        if (route.matchWithPath({params, path: restPath, request})) {
           subRoutesMatchesRestPath = true
         }
       }
@@ -43,3 +55,7 @@ export default class VelociousRouteResourceRoute extends BaseRoute {
     }
   }
 }
+
+BaseRoute.registerRouteResourceType(VelociousRouteResourceRoute)
+
+export default VelociousRouteResourceRoute

package/src/routes/root-route.js

@@ -1,6 +1,6 @@
-import BaseRoute, {initBaseRoute} from "./base-route.js"
+// @ts-check
 
-initBaseRoute()
+import BasicRoute from "./basic-route.js"
 
-export default class VelociousRootRoute extends BaseRoute {
+export default class VelociousRootRoute extends BasicRoute {
 }

package/src/testing/request-client.js

@@ -1,10 +1,15 @@
+// @ts-check
+
 class Response {
+  /**
+   * @param {globalThis.Response} fetchResponse
+   */
   constructor(fetchResponse) {
     this.fetchResponse = fetchResponse
   }
 
   /**
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   async parse() {
     this._body = await this.fetchResponse.text()
@@ -12,19 +17,19 @@ class Response {
     if (this.statusCode() != 200) throw new Error(`Request failed with code ${this.statusCode()} and body: ${this.body()}`)
   }
 
-  /**
-   * @returns {string}
-   */
-  body() { return this._body }
+  /** @returns {string} */
+  body() {
+    if (!this._body) throw new Error("Response body not parsed yet. Call parse() first.")
 
-  /**
-   * @returns {string}
-   */
-  contentType() { return this.fetchResponse.headers.get("content-type") }
+    return this._body
+  }
 
-  /**
-   * @returns {string}
-   */
+  /** @returns {string | null} */
+  contentType() {
+    return this.fetchResponse.headers.get("content-type")
+  }
+
+  /** @returns {number} */
   statusCode() { return this.fetchResponse.status }
 }
 
@@ -34,7 +39,7 @@ export default class RequestClient {
 
   /**
    * @param {string} path
-   * @returns {Response}
+   * @returns {Promise<Response>}
    */
   async get(path) {
     const fetchResponse = await fetch(`http://${this.host}:${this.port}${path}`)
@@ -48,7 +53,7 @@ export default class RequestClient {
   /**
    * @param {string} path
    * @param {object} data
-   * @returns {Response}
+   * @returns {Promise<Response>}
    */
   async post(path, data) {
     const fetchResponse = await fetch(

package/src/testing/test-runner.js

@@ -9,10 +9,11 @@ import {tests} from "./test.js"
 
 /**
  * @typedef {object} TestArgs
- * @property {Application} application
- * @property {RequestClient} client
- * @property {boolean} focus
- * @property {string} type
+ * @property {Application} [application]
+ * @property {RequestClient} [client]
+ * @property {boolean} [focus]
+ * @property {() => Promise<void>} [function]
+ * @property {string} [type]
  */
 
 /**
@@ -22,15 +23,20 @@ import {tests} from "./test.js"
  */
 
 /**
- * @typedef {object} AfterBeforeEachCallback
- * @property {function({configuration: import("../configuration.js").default, testArgs: TestArgs, testData: TestData}) : Promise<void>} callback
+ * @typedef {function({configuration: import("../configuration.js").default, testArgs: TestArgs, testData: TestData}) : Promise<void>} AfterBeforeEachCallbackType
+ */
+
+/**
+ * @typedef {object} AfterBeforeEachCallbackObjectType
+ * @property {AfterBeforeEachCallbackType} callback
  */
 
 /**
  * @typedef {object} TestsArgument
+ * @property {Record<string, TestData>} args
  * @property {boolean} [anyTestsFocussed]
- * @property {AfterBeforeEachCallback[]} afterEaches
- * @property {AfterBeforeEachCallback[]} beforeEaches
+ * @property {AfterBeforeEachCallbackObjectType[]} afterEaches
+ * @property {AfterBeforeEachCallbackObjectType[]} beforeEaches
  * @property {Record<string, TestData>} tests - A unique identifier for the node.
  * @property {Record<string, TestsArgument>} subs - Optional child nodes. Each item is another `Node`, allowing recursion.
  */
@@ -212,8 +218,8 @@ export default class TestRunner {
 
   /**
    * @param {object} args
-   * @param {Array<AfterBeforeEachCallback>} args.afterEaches
-   * @param {Array<AfterBeforeEachCallback>} args.beforeEaches
+   * @param {Array<AfterBeforeEachCallbackObjectType>} args.afterEaches
+   * @param {Array<AfterBeforeEachCallbackObjectType>} args.beforeEaches
    * @param {TestsArgument} args.tests
    * @param {string[]} args.descriptions
    * @param {number} args.indentLevel