velocious 1.0.97 → 1.0.99

package/src/http-server/worker-handler/index.js

@@ -1,11 +1,21 @@
-import {digg, digs} from "diggerize"
+// @ts-check
+
 import {Logger} from "../../logger.js"
 import {Worker} from "worker_threads"
+import ensureError from "../../utils/ensure-error.js"
 
 export default class VelociousHttpServerWorker {
+  /**
+   * @param {object} args
+   * @param {import("../../configuration.js").default} args.configuration
+   * @param {number} args.workerCount
+   */
   constructor({configuration, workerCount}) {
     this.configuration = configuration
+
+    /** @type {Record<number, import("../server-client.js").default>} */
     this.clients = {}
+
     this.logger = new Logger(this)
     this.workerCount = workerCount
   }
@@ -18,7 +28,7 @@ export default class VelociousHttpServerWorker {
   }
 
   async _spawnWorker() {
-    const {debug} = digs(this.configuration, "debug")
+    const debug = this.configuration.debug
     const directory = this.configuration.getDirectory()
     const velociousPath = await this.configuration.getEnvironmentHandler().getVelociousPath()
 
@@ -35,25 +45,38 @@ export default class VelociousHttpServerWorker {
     this.worker.on("message", this.onWorkerMessage)
   }
 
+  /**
+   * @param {import("../server-client.js").default} client
+   * @returns {void}
+   */
   addSocketConnection(client) {
-    const clientCount = digg(client, "clientCount")
+    const clientCount = client.clientCount
 
     client.socket.on("end", () => {
       this.logger.debug(`Removing ${clientCount} from clients`)
       delete this.clients[clientCount]
     })
 
-    client.worker = this.worker
+    if (!this.worker) throw new Error("Worker not initialized")
+
+    client.setWorker(this.worker)
     client.listen()
 
     this.clients[clientCount] = client
     this.worker.postMessage({command: "newClient", clientCount})
   }
 
+  /**
+   * @param {any} error
+   */
   onWorkerError = (error) => {
-    throw error // Throws original error with backtrace and everything into the console
+    throw ensureError(error) // Throws original error with backtrace and everything into the console
   }
 
+  /**
+   * @param {number} code
+   * @returns {void}
+   */
   onWorkerExit = (code) => {
     if (code !== 0) {
       throw new Error(`Client worker stopped with exit code ${code}`)
@@ -62,22 +85,32 @@ export default class VelociousHttpServerWorker {
     }
   }
 
+  /**
+   * @param {object} data
+   * @param {string} data.command
+   * @param {number} data.clientCount
+   * @param {string} data.output
+   * @returns {void}
+   */
   onWorkerMessage = (data) => {
     this.logger.debug(`Worker message`, data)
 
-    const {command} = digs(data, "command")
+    const {command} = data
 
     if (command == "started") {
-      this.onStartCallback()
+      if (this.onStartCallback) {
+        this.onStartCallback(null)
+      }
+
       this.onStartCallback = null
     } else if (command == "clientOutput") {
       this.logger.debug("CLIENT OUTPUT", data)
 
-      const {clientCount, output} = digs(data, "clientCount", "output")
+      const {clientCount, output} = data
 
       this.clients[clientCount]?.send(output)
     } else if (command == "clientClose") {
-      const {clientCount} = digs(data, "clientCount")
+      const {clientCount} = data
 
       this.clients[clientCount]?.end()
     } else {

package/src/http-server/worker-handler/worker-script.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import {workerData, parentPort} from "worker_threads"
 import WorkerThread from "./worker-thread.js"
 

package/src/http-server/worker-handler/worker-thread.js

@@ -1,14 +1,25 @@
+// @ts-check
+
 import Application from "../../application.js"
 import Client from "../client/index.js"
-import {digg, digs} from "diggerize"
+import {digg} from "diggerize"
 import errorLogger from "../../error-logger.js"
 import {Logger} from "../../logger.js"
 
 export default class VelociousHttpServerWorkerHandlerWorkerThread {
+  /**
+   * @param {object} args
+   * @param {import("worker_threads").parentPort} args.parentPort
+   * @param {{directory: string, environment: string, workerCount: number}} args.workerData
+   */
   constructor({parentPort, workerData}) {
-    const {workerCount} = digs(workerData, "workerCount")
+    if (!parentPort) throw new Error("parentPort is required")
+
+    const {workerCount} = workerData
 
+    /** @type {Record<number, Client>} */
     this.clients = {}
+
     this.logger = new Logger(this, {debug: false})
     this.parentPort = parentPort
     this.workerData = workerData
@@ -17,6 +28,8 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
     parentPort.on("message", errorLogger(this.onCommand))
 
     this.initialize().then(() => {
+      if (!this.application) throw new Error("Application not initialized")
+
       this.application.initialize().then(() => {
         this.logger.debug(`Worker ${workerCount} started`)
         parentPort.postMessage({command: "started"})
@@ -24,29 +37,44 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
     })
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async initialize() {
-    const {debug, directory, environment} = digs(this.workerData, "debug", "directory", "environment")
+    const {directory, environment} = this.workerData
     const configurationPath = `${directory}/src/config/configuration.js`
     const configurationImport = await import(configurationPath)
 
+    /** @type {import("../../configuration.js").default} */
     this.configuration = configurationImport.default
+
+    if (!this.configuration) throw new Error(`Configuration couldn't be loaded from: ${configurationPath}`)
+
     this.configuration.setEnvironment(environment)
     this.configuration.setCurrent()
 
-    this.application = new Application({configuration: this.configuration, debug, directory, type: "worker-handler"})
+    this.application = new Application({configuration: this.configuration, type: "worker-handler"})
 
     if (this.configuration.isInitialized()) {
       await this.configuration.initialize({type: "worker-handler"})
     }
   }
 
+  /**
+   * @param {object} data
+   * @param {string} data.command
+   * @param {string} [data.chunk]
+   * @param {number} data.clientCount
+   */
   onCommand = async (data) => {
     await this.logger.debug(() => [`Worker ${this.workerCount} received command`, data])
 
     const command = data.command
 
     if (command == "newClient") {
-      const {clientCount} = digs(data, "clientCount")
+      if (!this.configuration) throw new Error("Configuration not initialized")
+
+      const {clientCount} = data
       const client = new Client({
         clientCount,
         configuration: this.configuration
@@ -65,7 +93,7 @@ export default class VelociousHttpServerWorkerHandlerWorkerThread {
     } else if (command == "clientWrite") {
       await this.logger.debug("Looking up client")
 
-      const {chunk, clientCount} = digs(data, "chunk", "clientCount")
+      const {chunk, clientCount} = data
       const client = digg(this.clients, clientCount)
 
       await this.logger.debug(`Sending to client ${clientCount}`)

package/src/logger.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import Configuration from "./configuration.js"
 import restArgsError from "./utils/rest-args-error.js"
 
@@ -8,9 +10,10 @@ import restArgsError from "./utils/rest-args-error.js"
 function consoleLog(message) {
   return new Promise((resolve) => {
     if (process.stdout) {
-      process.stdout.write(`${message}\n`, "utf8", resolve)
+      process.stdout.write(`${message}\n`, "utf8", () => resolve())
     } else {
       console.log(message)
+      resolve()
     }
   })
 }
@@ -22,9 +25,10 @@ function consoleLog(message) {
 function consoleError(message) {
   return new Promise((resolve) => {
     if (process.stderr) {
-      process.stderr.write(`${message}\n`, "utf8", resolve)
+      process.stderr.write(`${message}\n`, "utf8", () => resolve())
     } else {
       console.error(message)
+      resolve()
     }
   })
 }
@@ -36,17 +40,19 @@ function consoleError(message) {
 function consoleWarn(message) {
   return new Promise((resolve) => {
     if (process.stderr) {
-      process.stderr.write(`${message}\n`, "utf8", resolve)
+      process.stderr.write(`${message}\n`, "utf8", () => resolve())
     } else {
       console.warn(message)
+      resolve()
     }
   })
 }
 
 /**
- * @param {Array} messages
+ * @param {...any|function() : Array<any>} messages
+ * @returns {Array<any>} - Either the function result or the messages
  */
-function functionOrMessages(messages) {
+function functionOrMessages(...messages) {
   if (messages.length === 1 && typeof messages[0] == "function") {
     messages = messages[0]()
   }
@@ -65,7 +71,7 @@ function messagesToMessage(...messages) {
   for (const messagePartIndex in messages) {
     const messagePart = messages[messagePartIndex]
 
-    if (messagePartIndex > 0) {
+    if (typeof messagePartIndex == "number" && messagePartIndex > 0) {
       message += " "
     }
 
@@ -85,7 +91,7 @@ class Logger {
    * @param {object} args
    * @param {boolean} args.debug
    */
-  constructor(object, {debug, ...restArgs} = {}) {
+  constructor(object, {debug, ...restArgs} = {debug: false}) {
     restArgsError(restArgs)
 
     this._debug = debug
@@ -114,7 +120,7 @@ class Logger {
   }
 
   /**
-   * @param {...Parameters<typeof consoleLog>} messages - forwarded args
+   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
    */
   async debug(...messages) {
     if (this._debug || this.getConfiguration()?.debug) {
@@ -123,17 +129,17 @@ class Logger {
   }
 
   /**
-   * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
+   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
    */
   async log(...messages) {
-    await consoleLog(messagesToMessage(this._subject, ...functionOrMessages(messages)))
+    await consoleLog(messagesToMessage(this._subject, ...functionOrMessages(...messages)))
   }
 
   /**
-   * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
+   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
    */
   async error(...messages) {
-    await consoleError(messagesToMessage(this._subject, ...functionOrMessages(messages)))
+    await consoleError(messagesToMessage(this._subject, ...functionOrMessages(...messages)))
   }
 
   /**
@@ -145,10 +151,10 @@ class Logger {
   }
 
   /**
-   * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
+   * @type {(...args: Parameters<typeof functionOrMessages>) => Promise<void>}
    */
   async warn(...messages) {
-    await consoleWarn(messagesToMessage(this._subject, ...functionOrMessages(messages)))
+    await consoleWarn(messagesToMessage(this._subject, ...functionOrMessages(...messages)))
   }
 }
 
@@ -163,6 +169,6 @@ export default async function logger(object, ...messages) {
   const configuration = object.configuration || Configuration.current()
 
   if (configuration.debug) {
-    await consoleLog(messagesToMessage(className, ...functionOrMessages(messages)))
+    await consoleLog(messagesToMessage(className, ...functionOrMessages(...messages)))
   }
 }

package/src/routes/app-routes.js

@@ -2,7 +2,7 @@ import {digg} from "diggerize"
 
 export default class VelociousRoutesAppRoutes {
   /**
-   * @param {import("../configuration.js")} configuration
+   * @param {import("../configuration.js").default} configuration
    * @returns {import("./index.js").default}
    */
   static async getRoutes(configuration) {

package/src/testing/test-files-finder.js

@@ -3,6 +3,7 @@
 import fs from "fs/promises"
 
 import fileExists from "../utils/file-exists.js"
+import {Logger} from "../logger.js"
 import restArgsError from "../utils/rest-args-error.js"
 
 // Incredibly complex class to find files in multiple simultanious running promises to do it as fast as possible.
@@ -19,6 +20,7 @@ export default class TestFilesFinder {
     restArgsError(restArgs)
 
     this.directory = directory
+    this.logger = new Logger(this)
 
     if (directories) {
       this.directories = directories
@@ -63,10 +65,7 @@ export default class TestFilesFinder {
   async findTestFiles() {
     await this.withFindingCount(async () => {
       for (const directory of this.directories) {
-        console.log({directory})
-
         if (await fileExists(directory)) {
-          console.log("Exists!")
           await this.findTestFilesInDir(directory)
         }
       }
@@ -159,6 +158,7 @@ export default class TestFilesFinder {
     if (this.directoryArgs.length > 0) {
       for (const directoryArg of this.directoryArgs) {
         if (localPath.startsWith(directoryArg) && this.looksLikeTestFile(file)) {
+          this.logger.debug("Found test file because matching dir and looks like this file:", file)
           return true
         }
       }
@@ -167,10 +167,14 @@ export default class TestFilesFinder {
     if (this.fileArgs.length > 0) {
       for (const fileArg of this.fileArgs) {
         if (fileArg == localPath) {
+          this.logger.debug("Found test file because matching file arg:", file)
           return true
         }
       }
-    } else if (this.looksLikeTestFile(file)) {
+    }
+
+    if (this.fileArgs.length == 0 && this.directoryArgs.length == 0 && this.looksLikeTestFile(file)) {
+      this.logger.debug("Found test file because looks like this file:", file)
       return true
     }
 

package/src/testing/test-runner.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import {addTrackedStackToError} from "../utils/with-tracked-stack.js"
 import Application from "../../src/application.js"
 import BacktraceCleaner from "../utils/backtrace-cleaner.js"
@@ -5,6 +7,34 @@ import RequestClient from "./request-client.js"
 import restArgsError from "../utils/rest-args-error.js"
 import {tests} from "./test.js"
 
+/**
+ * @typedef {object} TestArgs
+ * @property {Application} application
+ * @property {RequestClient} client
+ * @property {boolean} focus
+ * @property {string} type
+ */
+
+/**
+ * @typedef {object} TestData
+ * @property {TestArgs} args
+ * @property {function(TestArgs) : Promise<void>} function
+ */
+
+/**
+ * @typedef {object} AfterBeforeEachCallback
+ * @property {function({configuration: import("../configuration.js").default, testArgs: TestArgs, testData: TestData}) : Promise<void>} callback
+ */
+
+/**
+ * @typedef {object} TestsArgument
+ * @property {boolean} [anyTestsFocussed]
+ * @property {AfterBeforeEachCallback[]} afterEaches
+ * @property {AfterBeforeEachCallback[]} 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.
+ */
+
 export default class TestRunner {
   /**
    * @param {object} args
@@ -18,6 +48,10 @@ export default class TestRunner {
 
     this._configuration = configuration
     this._testFiles = testFiles
+
+    this._failedTests = 0
+    this._successfulTests = 0
+    this._testsCount = 0
   }
 
   /**
@@ -37,13 +71,6 @@ export default class TestRunner {
     if (!this._application) {
       this._application = new Application({
         configuration: this.getConfiguration(),
-        databases: {
-          default: {
-            host: "mysql",
-            username: "user",
-            password: ""
-          }
-        },
         httpServer: {port: 31006},
         type: "test-runner"
       })
@@ -56,7 +83,7 @@ export default class TestRunner {
   }
 
   /**
-   * @returns {RequestClient}
+   * @returns {Promise<RequestClient>}
    */
   async requestClient() {
     if (!this._requestClient) {
@@ -67,7 +94,7 @@ export default class TestRunner {
   }
 
   /**
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   async importTestFiles() {
     await this.getConfiguration().getEnvironmentHandler().importTestFiles(this.getTestFiles())
@@ -76,25 +103,37 @@ export default class TestRunner {
   /**
    * @returns {boolean}
    */
-  isFailed() { return this._failedTests > 0 }
+  isFailed() { return this._failedTests !== undefined && this._failedTests > 0 }
 
   /**
    * @returns {number}
    */
-  getFailedTests() { return this._failedTests }
+  getFailedTests() {
+    if (this._failedTests === undefined) throw new Error("Tests hasn't been run yet")
+
+    return this._failedTests
+  }
 
   /**
    * @returns {number}
    */
-  getSuccessfulTests() { return this._successfulTests }
+  getSuccessfulTests() {
+    if (this._successfulTests === undefined) throw new Error("Tests hasn't been run yet")
+
+    return this._successfulTests
+  }
 
   /**
    * @returns {number}
    */
-  getTestsCount() { return this._testsCount }
+  getTestsCount() {
+    if (this._testsCount === undefined) throw new Error("Tests hasn't been run yet")
+
+    return this._testsCount
+  }
 
   /**
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   async prepare() {
     this.anyTestsFocussed = false
@@ -124,7 +163,7 @@ export default class TestRunner {
   }
 
   /**
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   async run() {
     await this.getConfiguration().ensureConnections(async () => {
@@ -139,7 +178,8 @@ export default class TestRunner {
   }
 
   /**
-   * @returns {object}
+   * @param {TestsArgument} tests
+   * @returns {{anyTestsFocussed: boolean}}
    */
   analyzeTests(tests) {
     let anyTestsFocussedFound = false
@@ -171,6 +211,12 @@ export default class TestRunner {
   }
 
   /**
+   * @param {object} args
+   * @param {Array<AfterBeforeEachCallback>} args.afterEaches
+   * @param {Array<AfterBeforeEachCallback>} args.beforeEaches
+   * @param {TestsArgument} args.tests
+   * @param {string[]} args.descriptions
+   * @param {number} args.indentLevel
    * @returns {Promise<void>}
    */
   async runTests({afterEaches, beforeEaches, tests, descriptions, indentLevel}) {
@@ -180,7 +226,7 @@ export default class TestRunner {
 
     for (const testDescription in tests.tests) {
       const testData = tests.tests[testDescription]
-      const testArgs = Object.assign({}, testData.args)
+      const testArgs = /** @type {TestArgs} */ (Object.assign({}, testData.args))
 
       if (this._onlyFocussed && !testArgs.focus) continue
 
@@ -204,15 +250,21 @@ export default class TestRunner {
       } catch (error) {
         this._failedTests++
 
-        console.error(`${leftPadding}  Test failed: ${error.message}`)
-        addTrackedStackToError(error)
+        if (error instanceof Error) {
+          console.error(`${leftPadding}  Test failed:`, error.message)
+          addTrackedStackToError(error)
 
-        const backtraceCleaner = new BacktraceCleaner(error)
-        const cleanedStack = backtraceCleaner.getCleanedStack()
-        const stackLines = cleanedStack.split("\n")
+          const backtraceCleaner = new BacktraceCleaner(error)
+          const cleanedStack = backtraceCleaner.getCleanedStack()
+          const stackLines = cleanedStack?.split("\n")
 
-        for (const stackLine of stackLines) {
-          console.error(`${leftPadding}  ${stackLine}`)
+          if (stackLines) {
+            for (const stackLine of stackLines) {
+              console.error(`${leftPadding}  ${stackLine}`)
+            }
+          }
+        } else {
+          console.error(`${leftPadding}  Test failed with a ${typeof error}:`, error)
         }
       } finally {
         for (const afterEachData of newAfterEaches) {

package/src/utils/backtrace-cleaner.js

@@ -1,7 +1,9 @@
+// @ts-check
+
 export default class BacktraceCleaner {
   /**
    * @param {Error} error
-   * @returns {string}
+   * @returns {string | undefined}
    */
   static getCleanedStack(error) {
     return new BacktraceCleaner(error).getCleanedStack()
@@ -15,11 +17,11 @@ export default class BacktraceCleaner {
   }
 
   /**
-   * @returns {string}
+   * @returns {string | undefined}
    */
   getCleanedStack() {
-    const backtrace = this.error.stack.split("\n")
+    const backtrace = this.error?.stack?.split("\n")
 
-    return backtrace.filter((line) => !line.includes("node_modules") && !line.includes("(node:internal/process/")).join("\n")
+    return backtrace?.filter((line) => !line.includes("node_modules") && !line.includes("(node:internal/process/")).join("\n")
   }
 }

package/src/utils/ensure-error.js

@@ -0,0 +1,13 @@
+// @ts-check
+
+/**
+ * @param {any} error
+ * @returns {Error}
+ */
+export default function ensureError(error) {
+  if (error instanceof Error) {
+    return error
+  } else {
+    return new Error(`Unknown error type ${typeof error}: ${error}`)
+  }
+}

package/src/utils/file-exists.js

@@ -1,8 +1,10 @@
+// @ts-check
+
 import fs from "fs/promises"
 
 /**
  * @param {string} path
- * @returns {boolean}
+ * @returns {Promise<boolean>}
  */
 export default async function fileExists(path) {
   try {

package/src/utils/rest-args-error.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
  * @param {object} restArgs
  * @returns {void}