velocious 1.0.104 → 1.0.106

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

package/src/testing/test.js

@@ -1,9 +1,15 @@
+// @ts-check
+
 import {anythingDifferent} from "set-state-compare/src/diff-utils.js"
 import restArgsError from "../utils/rest-args-error.js"
 
+/** @type {import("./test-runner.js").TestsArgument} */
 const tests = {
+  /** @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
   afterEaches: [],
   args: {},
+
+  /** @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
   beforeEaches: [],
   subs: {},
   tests: {}
@@ -12,7 +18,7 @@ const tests = {
 let currentPath = [tests]
 
 /**
- * @param {function() : void} callback
+ * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback
  * @returns {void}
  */
 function beforeEach(callback) {
@@ -22,7 +28,7 @@ function beforeEach(callback) {
 }
 
 /**
- * @param {function() : void} callback
+ * @param {import("./test-runner.js").AfterBeforeEachCallbackType} callback
  * @returns {void}
  */
 function afterEach(callback) {
@@ -31,8 +37,28 @@ function afterEach(callback) {
   currentTest.afterEaches.push({callback})
 }
 
-class ExpectToChange {
+class BaseExpect {
+  /**
+   * @abstract
+   * @returns {Promise<void>}
+   */
+  async runBefore() { /* do nothing */ }
+
+  /**
+   * @abstract
+   * @returns {Promise<void>}
+   */
+  async runAfter() { /* do nothing */ }
+}
+
+class ExpectToChange extends BaseExpect {
+  /**
+   * @param {object} args
+   * @param {function(): Promise<number>} args.changeCallback
+   * @param {Expect} args.expect
+   */
   constructor({changeCallback, expect, ...restArgs}) {
+    super()
     restArgsError(restArgs)
 
     this.expect = expect
@@ -58,9 +84,13 @@ class ExpectToChange {
   }
 
   /**
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   async execute() {
+    if (this.newCount === undefined || this.oldCount === undefined) {
+      throw new Error("ExpectToChange not executed properly")
+    }
+
     const difference = this.newCount - this.oldCount
 
     if (difference != this.count) {
@@ -69,20 +99,24 @@ class ExpectToChange {
   }
 }
 
-class Expect {
+class Expect extends BaseExpect {
   /**
    * @param {any} object
    */
   constructor(object) {
+    super()
     this._object = object
+
+    /** @type {Array<Expect | ExpectToChange>} */
     this.expectations = []
   }
 
   /**
+   * @param {function(): Promise<number>} changeCallback
    * @returns {ExpectToChange}
    */
-  andChange(...args) {
-    return this.toChange(...args)
+  andChange(changeCallback) {
+    return this.toChange(changeCallback)
   }
 
   /**
@@ -126,6 +160,7 @@ class Expect {
   }
 
   /**
+   * @param {Function} klass
    * @returns {void}
    */
   toBeInstanceOf(klass) {
@@ -156,7 +191,7 @@ class Expect {
   }
 
   /**
-   * @param {function(): void} changeCallback
+   * @param {function(): Promise<number>} changeCallback
    * @returns {ExpectToChange}
    */
   toChange(changeCallback) {
@@ -230,7 +265,7 @@ class Expect {
   /**
    * @template T extends Error
    * @param {string|T} expectedError
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   async toThrowError(expectedError) {
     if (this._not) throw new Error("not stub")
@@ -249,14 +284,18 @@ class Expect {
 
     if (typeof failedError == "string") {
       failedErrorMessage = failedError
-    } else {
+    } else if (failedError instanceof Error) {
       failedErrorMessage = failedError.message
+    } else {
+      failedErrorMessage = String(failedError)
     }
 
     if (typeof expectedError == "string") {
       expectedErrorMessage = expectedError
-    } else {
+    } else if (expectedError instanceof Error) {
       expectedErrorMessage = expectedError.message
+    } else {
+      expectedErrorMessage = String(expectedError)
     }
 
     if (failedErrorMessage != expectedErrorMessage) {
@@ -265,7 +304,7 @@ class Expect {
   }
 
   /**
-   * @returns {any}
+   * @returns {Promise<any>}
    */
   async execute() {
     for (const expectation of this.expectations) {
@@ -286,12 +325,13 @@ class Expect {
   }
 
   /**
-   * @param {object} result
+   * @param {Record<string, any>} result
    * @returns {void}
    */
   toHaveAttributes(result) {
     if (this._not) throw new Error("not stub")
 
+    /** @type {Record<string, any[]>} */
     const differences = {}
 
     for (const key in result) {
@@ -314,9 +354,9 @@ class Expect {
 
 /**
  * @param {string} description
- * @param {object|() => Promise<void>} arg1
- * @param {undefined|() => Promise<void>} [arg2]
- * @returns {void}
+ * @param {object|(() => Promise<void>)} arg1
+ * @param {undefined|(() => Promise<void>)} [arg2]
+ * @returns {Promise<void>}
  */
 async function describe(description, arg1, arg2) {
   let testArgs, testFunction
@@ -360,15 +400,19 @@ function expect(arg) {
 
 /**
  * @param {string} description
- * @param {object|() => Promise<void>} arg1
- * @param {undefined|() => Promise<void>} [arg2]
+ * @param {object|(() => Promise<void>)} arg1
+ * @param {undefined|(() => Promise<void>)} [arg2]
  * @returns {void}
  */
 function it(description, arg1, arg2) {
   const currentTest = currentPath[currentPath.length - 1]
-  let testArgs, testFunction
+  let testArgs
+
+  /** @type {() => Promise<void>} */
+  let testFunction
 
   if (typeof arg1 == "function") {
+    // @ts-expect-error
     testFunction = arg1
     testArgs = {}
   } else if (typeof arg2 == "function") {
@@ -385,14 +429,18 @@ function it(description, arg1, arg2) {
 
 /**
  * @param {string} description
- * @param {object|() => Promise<void>} arg1
- * @param {undefined|() => Promise<void>} [arg2]
+ * @param {object|(() => Promise<void>)} arg1
+ * @param {undefined|(() => Promise<void>)} [arg2]
  * @returns {void}
  */
 function fit(description, arg1, arg2) {
-  let testArgs, testFunction
+  let testArgs
+
+  /** @type {() => Promise<void>} */
+  let testFunction
 
   if (typeof arg1 == "function") {
+    // @ts-expect-error
     testFunction = arg1
     testArgs = {focus: true}
   } else if (typeof arg2 == "function") {
@@ -413,4 +461,4 @@ globalThis.expect = expect
 globalThis.it = it
 globalThis.fit = fit
 
-export {describe, expect, fit, it, tests}
+export {afterEach, beforeEach, describe, expect, fit, it, tests}

package/src/utils/with-tracked-stack-async-hooks.js

@@ -1,11 +1,15 @@
+// @ts-check
+
 import {AsyncLocalStorage} from "async_hooks"
 
+/** @type {AsyncLocalStorage<Array<string[]>> | undefined} */
 let asyncLocalStorage
 
 if (AsyncLocalStorage) {
   asyncLocalStorage = new AsyncLocalStorage()
 }
 
+/** @param {Error} error */
 function addTrackedStackToError(error) {
   // Not supported
   if (!asyncLocalStorage) return
@@ -23,15 +27,27 @@ function addTrackedStackToError(error) {
   error.stack += "\n" + additionalStackLines.join("\n")
 }
 
+/**
+ *
+ * @param {() => Promise<void> | string} arg1
+ * @param {() => Promise<void> | Error} [arg2]
+ * @returns {Promise<void>}
+ */
 async function withTrackedStack(arg1, arg2) {
-  let callback, stack
+  /** @type {() => Promise<void>} */
+  let callback
+
+  /** @type {string} */
+  let stack
 
-  if (arg2) {
+  if (typeof arg2 == "function" && typeof arg1 == "string") {
+    // @ts-expect-error
     callback = arg2
     stack = arg1
   } else {
+    // @ts-expect-error
     callback = arg1
-    stack = Error().stack
+    stack = Error().stack || ""
   }
 
   // Not supported
@@ -56,13 +72,15 @@ async function withTrackedStack(arg1, arg2) {
   const newStacks = [additionalStackLines, ...parentStacks]
 
   await asyncLocalStorage.run(newStacks, async () => {
-    return await callback()
+    await callback()
   })
 }
 
+// @ts-expect-error
 if (globalThis.withTrackedStack) {
   console.warn("globalThis.withTrackedStack was already defined")
 } else {
+  // @ts-expect-error
   globalThis.withTrackedStack = {addTrackedStackToError, withTrackedStack}
 }
 

package/src/utils/with-tracked-stack.js

@@ -1,8 +1,17 @@
+// @ts-check
+
+/** @param {Error} error */
 function addTrackedStackToError(error) {
+  // @ts-expect-error
   globalThis.withTrackedStack?.addTrackedStackToError(error)
 }
 
+/**
+ * @param  {...any} args
+ * @returns {Promise<any>}
+ */
 async function withTrackedStack(...args) {
+  // @ts-expect-error
   const withTrackedStack = globalThis.withTrackedStack?.withTrackedStack
 
   let callback