velocious 1.0.96 → 1.0.98

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

@@ -1,21 +1,74 @@
+// @ts-check
+
 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.
 export default class TestFilesFinder {
   static IGNORED_NAMES = [".git", "node_modules"]
 
-  constructor({directory, processArgs}) {
+  /**
+   * @param {object} args
+   * @param {string} args.directory
+   * @param {string[]} args.directories
+   * @param {string[]} args.processArgs
+   */
+  constructor({directory, directories, processArgs, ...restArgs}) {
+    restArgsError(restArgs)
+
     this.directory = directory
-    this.foundFiles = []
+    this.logger = new Logger(this)
+
+    if (directories) {
+      this.directories = directories
+    } else {
+      this.directories = [
+        `${this.directory}/__tests__`,
+        `${this.directory}/tests`,
+        `${this.directory}/spec`
+      ]
+    }
+
     this.findingCount = 0
-    this.findingPromises = {}
     this.processArgs = processArgs
+
+    /** @type {string[]} */
+    this.foundFiles = []
+
+    /** @type {Record<number, Promise<void>>} */
+    this.findingPromises = {}
+
+    /** @type {string[]} */
     this.testArgs = this.processArgs.filter((processArg, index) => index != 0)
+
+    /** @type {string[]} */
+    this.directoryArgs = []
+
+    /** @type {string[]} */
+    this.fileArgs = []
+
+    for (const testArg of this.testArgs) {
+      if (testArg.endsWith("/")) {
+        this.directoryArgs.push(testArg)
+      } else {
+        this.fileArgs.push(testArg)
+      }
+    }
   }
 
+  /**
+   * @returns {Promise<string[]>}
+   */
   async findTestFiles() {
     await this.withFindingCount(async () => {
-      await this.findTestFilesInDir(this.directory)
+      for (const directory of this.directories) {
+        if (await fileExists(directory)) {
+          await this.findTestFilesInDir(directory)
+        }
+      }
     })
 
     await this.waitForFindingPromises()
@@ -23,6 +76,9 @@ export default class TestFilesFinder {
     return this.foundFiles
   }
 
+  /**
+   * @returns {number}
+   */
   findingPromisesLength() { return Object.keys(this.findingPromises).length }
 
   async waitForFindingPromises() {
@@ -31,6 +87,9 @@ export default class TestFilesFinder {
     }
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async waitForFindingPromisesIteration() {
     const unfinishedPromises = []
 
@@ -43,6 +102,9 @@ export default class TestFilesFinder {
     await Promise.all(unfinishedPromises)
   }
 
+  /**
+   * @param {function() : Promise<void>} callback
+   */
   withFindingCount(callback) {
     return new Promise((resolve) => {
       const findingPromise = callback()
@@ -54,11 +116,15 @@ export default class TestFilesFinder {
       findingPromise.finally(() => {
         delete this.findingPromises[findingCount]
 
-        resolve()
+        resolve(undefined)
       })
     })
   }
 
+  /**
+   * @param {string} dir
+   * @returns {Promise<void>}
+   */
   async findTestFilesInDir(dir) {
     await this.withFindingCount(async () => {
       const files = await fs.readdir(dir)
@@ -89,16 +155,37 @@ export default class TestFilesFinder {
    * @returns {boolean}
    */
   isFileMatchingRequirements(file, localPath) {
-    if (this.testArgs.length > 0) {
-      for (const testArg of this.testArgs) {
-        if (testArg == localPath) {
+    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
+        }
+      }
+    }
+
+    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 (file.match(/-(spec|test)\.(m|)js$/)) {
+    }
+
+    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
     }
 
     return false
   }
+
+  /**
+   * @param {string} file
+   * @returns {boolean}
+   */
+  looksLikeTestFile(file) {
+    return Boolean(file.match(/-(spec|test)\.(m|)js$/))
+  }
 }