velocious 1.0.85 → 1.0.87

package/src/http-server/client/request-buffer/index.js

@@ -40,17 +40,17 @@ export default class RequestBuffer {
 
           break
         case "multi-part-form-data-body":
-          const body = this.formDataPart.body
+          const body = this.formDataPart.body // eslint-disable-line no-case-declarations
 
           body.push(char)
 
-          const possibleBoundaryEndPosition = body.length - this.boundaryLineEnd.length
-          const possibleBoundaryEndChars = body.slice(possibleBoundaryEndPosition, body.length)
-          const possibleBoundaryEnd = String.fromCharCode.apply(null, possibleBoundaryEndChars)
+          const possibleBoundaryEndPosition = body.length - this.boundaryLineEnd.length // eslint-disable-line no-case-declarations
+          const possibleBoundaryEndChars = body.slice(possibleBoundaryEndPosition, body.length) // eslint-disable-line no-case-declarations
+          const possibleBoundaryEnd = String.fromCharCode.apply(null, possibleBoundaryEndChars) // eslint-disable-line no-case-declarations
 
-          const possibleBoundaryNextPosition = body.length - this.boundaryLineNext.length
-          const possibleBoundaryNextChars = body.slice(possibleBoundaryNextPosition, body.length)
-          const possibleBoundaryNext = String.fromCharCode.apply(null, possibleBoundaryNextChars)
+          const possibleBoundaryNextPosition = body.length - this.boundaryLineNext.length // eslint-disable-line no-case-declarations
+          const possibleBoundaryNextChars = body.slice(possibleBoundaryNextPosition, body.length) // eslint-disable-line no-case-declarations
+          const possibleBoundaryNext = String.fromCharCode.apply(null, possibleBoundaryNextChars) // eslint-disable-line no-case-declarations
 
           if (possibleBoundaryEnd == this.boundaryLineEnd) {
             this.formDataPart.removeFromBody(possibleBoundaryEnd)
@@ -150,9 +150,9 @@ export default class RequestBuffer {
   }
 
   readHeaderFromLine(line) {
-    let match
+    const match = line.match(/^(.+): (.+)\r\n/)
 
-    if (match = line.match(/^(.+): (.+)\r\n/)) {
+    if (match) {
       const header = new Header(match[1], match[2])
 
       return header

package/src/http-server/index.js

@@ -20,6 +20,9 @@ export default class VelociousHttpServer {
     this.maxWorkers = maxWorkers || 16
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async start() {
     await this._ensureAtLeastOneWorker()
     this.netServer = new Net.Server()
@@ -47,6 +50,9 @@ export default class VelociousHttpServer {
     }
   }
 
+  /**
+   * @returns {boolean}
+   */
   isActive() {
     return this.netServer.listening
   }

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

@@ -1,6 +1,4 @@
 import {digg, digs} from "diggerize"
-import {dirname} from "path"
-import {fileURLToPath} from "url"
 import {Logger} from "../../logger.js"
 import {Worker} from "worker_threads"
 
@@ -12,26 +10,29 @@ export default class VelociousHttpServerWorker {
     this.workerCount = workerCount
   }
 
-  async start() {
+  start() {
     return new Promise((resolve) => {
-      const {debug} = digs(this.configuration, "debug")
-      const directory = this.configuration.getDirectory()
-      const __filename = fileURLToPath(import.meta.url)
-      const __dirname = dirname(__filename)
-
       this.onStartCallback = resolve
-      this.worker = new Worker(`${__dirname}/worker-script.js`, {
-        workerData: {
-          debug,
-          directory,
-          environment: this.configuration.getEnvironment(),
-          workerCount: this.workerCount
-        }
-      })
-      this.worker.on("error", this.onWorkerError)
-      this.worker.on("exit", this.onWorkerExit)
-      this.worker.on("message", this.onWorkerMessage)
+      this._spawnWorker()
+    })
+  }
+
+  async _spawnWorker() {
+    const {debug} = digs(this.configuration, "debug")
+    const directory = this.configuration.getDirectory()
+    const velociousPath = await this.configuration.getEnvironmentHandler().getVelociousPath()
+
+    this.worker = new Worker(`${velociousPath}/src/http-server/worker-handler/worker-script.js`, {
+      workerData: {
+        debug,
+        directory,
+        environment: this.configuration.getEnvironment(),
+        workerCount: this.workerCount
+      }
     })
+    this.worker.on("error", this.onWorkerError)
+    this.worker.on("exit", this.onWorkerExit)
+    this.worker.on("message", this.onWorkerMessage)
   }
 
   addSocketConnection(client) {

package/src/initializer.js

@@ -1,10 +1,26 @@
+import restArgsError from "./utils/rest-args-error.js"
+
 export default class VelociousInitializer {
-  constructor({configuration, type}) {
+  /**
+   * @param {object} args
+   * @param {import("./configuration.js").default} args.configuration
+   * @param {string} args.type
+   */
+  constructor({configuration, type, ...restArgs}) {
+    restArgsError(restArgs)
+
     this._configuration = configuration
     this._type = type
   }
 
+  /**
+   * @returns {import("./configuration.js").default}
+   */
   getConfiguration() { return this._configuration }
+
+  /**
+   * @returns {string}
+   */
   getType() { return this._type }
 
   run() {

package/src/logger.js

@@ -74,6 +74,9 @@ class Logger {
     }
   }
 
+  /**
+   * @returns {import("./configuration.js").default}
+   */
   getConfiguration() {
     if (!this._configuration) {
       this._configuration = this._object?.configuration || Configuration.current()

package/src/routes/app-routes.js

@@ -1,10 +1,14 @@
 import {digg} from "diggerize"
 
 export default class VelociousRoutesAppRoutes {
+  /**
+   * @param {import("../configuration.js")} configuration
+   * @returns {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
-    const routesImport = await import(`${configuration.getDirectory()}/src/config/routes.js`)
+    const routesImport = await configuration.getEnvironmentHandler().importApplicationRoutes()
 
-    return digg(routesImport, "default", "routes")
+    return digg(routesImport, "routes")
   }
 }

package/src/routes/base-route.js

@@ -17,7 +17,7 @@ export function initBaseRoute() {
       this.routes.push(route)
     }
 
-    matchWithPath(_path) {
+    matchWithPath(_path) { // eslint-disable-line no-unused-vars
       throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
     }
 

package/src/routes/get-route.js

@@ -14,7 +14,7 @@ export default class VelociousRouteGetRoute extends BaseRoute {
     const match = path.match(this.regExp)
 
     if (match) {
-      const [_beginnigSlash, _matchedName, restPath] = match
+      const [_beginnigSlash, _matchedName, restPath] = match // eslint-disable-line no-unused-vars
 
       params.action = this.name
 

package/src/routes/namespace-route.js

@@ -14,7 +14,7 @@ export default class VelociousRouteNamespaceRoute extends BaseRoute {
     const match = path.match(this.regExp)
 
     if (match) {
-      const [_beginnigSlash, _matchedName, restPath] = match
+      const [_beginnigSlash, _matchedName, restPath] = match // eslint-disable-line no-unused-vars
 
       params.controller = this.name
 

package/src/routes/post-route.js

@@ -14,7 +14,7 @@ export default class VelociousRoutePostRoute extends BaseRoute {
     const match = path.match(this.regExp)
 
     if (match) {
-      const [_beginnigSlash, _matchedName, restPath] = match
+      const [_beginnigSlash, _matchedName, restPath] = match // eslint-disable-line no-unused-vars
 
       params.action = this.name
 

package/src/routes/resolver.js

@@ -33,7 +33,7 @@ export default class VelociousRoutesResolver {
       controller = "errors"
       controllerPath = "./built-in/errors/controller.js"
       action = "notFound"
-      viewPath = await fs.realpath(`${__dirname}/built-in/errors`) // eslint-disable-line no-undef
+      viewPath = await fs.realpath(`${__dirname}/built-in/errors`)
     } else if (action) {
       if (!controller) controller = "_root"
 

package/src/routes/resource-route.js

@@ -14,7 +14,7 @@ export default class VelociousRouteResourceRoute extends BaseRoute {
     const match = path.match(this.regExp)
 
     if (match) {
-      const [_beginnigSlash, _matchedName, restPath] = match
+      const [_beginnigSlash, _matchedName, restPath] = match // eslint-disable-line no-unused-vars
 
       let action = "index"
       let subRoutesMatchesRestPath = false

package/src/templates/configuration.js

@@ -1,6 +1,10 @@
 import AsyncTrackedMultiConnection from "velocious/src/database/pool/async-tracked-multi-connection.js"
 import Configuration from "velocious/src/configuration.js"
+import fs from "fs/promises"
+import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
 import MysqlDriver from "velocious/src/database/drivers/mysql/index.js"
+import path from "path"
+import requireContext from "require-context"
 
 export default new Configuration({
   database: {

package/src/testing/request-client.js

@@ -3,21 +3,39 @@ class Response {
     this.fetchResponse = fetchResponse
   }
 
+  /**
+   * @returns {void}
+   */
   async parse() {
     this._body = await this.fetchResponse.text()
 
     if (this.statusCode() != 200) throw new Error(`Request failed with code ${this.statusCode()} and body: ${this.body()}`)
   }
 
-  body = () => this._body
-  contentType = () => this.fetchResponse.headers.get("content-type")
-  statusCode = () => this.fetchResponse.status
+  /**
+   * @returns {string}
+   */
+  body() { return this._body }
+
+  /**
+   * @returns {string}
+   */
+  contentType() { return this.fetchResponse.headers.get("content-type") }
+
+  /**
+   * @returns {string}
+   */
+  statusCode() { return this.fetchResponse.status }
 }
 
 export default class RequestClient {
   host = "localhost"
   port = 31006
 
+  /**
+   * @param {string} path
+   * @returns {Response}
+   */
   async get(path) {
     const fetchResponse = await fetch(`http://${this.host}:${this.port}${path}`)
     const response = new Response(fetchResponse)
@@ -27,6 +45,11 @@ export default class RequestClient {
     return response
   }
 
+  /**
+   * @param {string} path
+   * @param {object} data
+   * @returns {Response}
+   */
   async post(path, data) {
     const fetchResponse = await fetch(
       `http://${this.host}:${this.port}${path}`,

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

@@ -75,7 +75,7 @@ export default class TestFilesFinder {
         if (isDir) {
           this.findTestFilesInDir(fullPath)
         } else {
-          if (this.isFileMatchingRequirements(file, localPath, fullPath)) {
+          if (this.isFileMatchingRequirements(file, localPath)) {
             this.foundFiles.push(fullPath)
           }
         }
@@ -83,7 +83,7 @@ export default class TestFilesFinder {
     })
   }
 
-  isFileMatchingRequirements(file, localPath, fullPath) {
+  isFileMatchingRequirements(file, localPath) {
     if (this.testArgs.length > 0) {
       for (const testArg of this.testArgs) {
         if (testArg == localPath) {

package/src/testing/test-runner.js

@@ -2,18 +2,41 @@ import {addTrackedStackToError} from "../utils/with-tracked-stack.js"
 import Application from "../../src/application.js"
 import BacktraceCleaner from "../utils/backtrace-cleaner.js"
 import RequestClient from "./request-client.js"
+import restArgsError from "../utils/rest-args-error.js"
 import {tests} from "./test.js"
 
 export default class TestRunner {
-  constructor({configuration, testFiles}) {
-    this.configuration = configuration
-    this.testFiles = testFiles
+  /**
+   * @param {object} args
+   * @param {import("../configuration.js").default} args.configuration
+   * @param {Array<string>} args.testFiles
+   */
+  constructor({configuration, testFiles, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!configuration) throw new Error("configuration is required")
+
+    this._configuration = configuration
+    this._testFiles = testFiles
   }
 
+  /**
+   * @returns {import("../configuration.js").default}
+   */
+  getConfiguration() { return this._configuration }
+
+  /**
+   * @returns {Array<string>}
+   */
+  getTestFiles() { return this._testFiles }
+
+  /**
+   * @returns {Promise<Application>}
+   */
   async application() {
     if (!this._application) {
       this._application = new Application({
-        configuration: this.configuration,
+        configuration: this.getConfiguration(),
         databases: {
           default: {
             host: "mysql",
@@ -32,6 +55,9 @@ export default class TestRunner {
     return this._application
   }
 
+  /**
+   * @returns {RequestClient}
+   */
   async requestClient() {
     if (!this._requestClient) {
       this._requestClient = new RequestClient()
@@ -40,28 +66,36 @@ export default class TestRunner {
     return this._requestClient
   }
 
+  /**
+   * @returns {void}
+   */
   async importTestFiles() {
-    for (const testFile of this.testFiles) {
-      await import(testFile)
-    }
-  }
-
-  isFailed() {
-    return this._failedTests > 0
-  }
-
-  getFailedTests() {
-    return this._failedTests
-  }
-
-  getSuccessfulTests() {
-    return this._successfulTests
-  }
-
-  getTestsCount() {
-    return this._testsCount
+    await this.getConfiguration().getEnvironmentHandler().importTestFiles(this.getTestFiles())
   }
 
+  /**
+   * @returns {boolean}
+   */
+  isFailed() { return this._failedTests > 0 }
+
+  /**
+   * @returns {number}
+   */
+  getFailedTests() { return this._failedTests }
+
+  /**
+   * @returns {number}
+   */
+  getSuccessfulTests() { return this._successfulTests }
+
+  /**
+   * @returns {number}
+   */
+  getTestsCount() { return this._testsCount }
+
+  /**
+   * @returns {void}
+   */
   async prepare() {
     this.anyTestsFocussed = false
     this._failedTests = 0
@@ -71,13 +105,16 @@ export default class TestRunner {
     await this.analyzeTests(tests)
     this._onlyFocussed = this.anyTestsFocussed
 
-    const testingConfigPath = this.configuration.getTesting()
+    const testingConfigPath = this.getConfiguration().getTesting()
 
     if (testingConfigPath) {
-      await import(testingConfigPath)
+      await this.getConfiguration().getEnvironmentHandler().importTestingConfigPath()
     }
   }
 
+  /**
+   * @returns {boolean}
+   */
   areAnyTestsFocussed() {
     if (this.anyTestsFocussed === undefined) {
       throw new Error("Hasn't been detected yet")
@@ -86,8 +123,11 @@ export default class TestRunner {
     return this.anyTestsFocussed
   }
 
+  /**
+   * @returns {void}
+   */
   async run() {
-    await this.configuration.ensureConnections(async () => {
+    await this.getConfiguration().ensureConnections(async () => {
       await this.runTests({
         afterEaches: [],
         beforeEaches: [],
@@ -98,6 +138,9 @@ export default class TestRunner {
     })
   }
 
+  /**
+   * @returns {object}
+   */
   analyzeTests(tests) {
     let anyTestsFocussedFound = false
 
@@ -127,6 +170,9 @@ export default class TestRunner {
     return {anyTestsFocussed: anyTestsFocussedFound}
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async runTests({afterEaches, beforeEaches, tests, descriptions, indentLevel}) {
     const leftPadding = " ".repeat(indentLevel * 2)
     const newAfterEaches = [...afterEaches, ...tests.afterEaches]
@@ -150,7 +196,7 @@ export default class TestRunner {
 
       try {
         for (const beforeEachData of newBeforeEaches) {
-          await beforeEachData.callback({configuration: this.configuration, testArgs, testData})
+          await beforeEachData.callback({configuration: this.getConfiguration(), testArgs, testData})
         }
 
         await testData.function(testArgs)
@@ -170,7 +216,7 @@ export default class TestRunner {
         }
       } finally {
         for (const afterEachData of newAfterEaches) {
-          await afterEachData.callback({configuration: this.configuration, testArgs, testData})
+          await afterEachData.callback({configuration: this.getConfiguration(), testArgs, testData})
         }
       }
     }

package/src/testing/test.js

@@ -31,6 +31,9 @@ class ExpectToChange {
     this.changeCallback = changeCallback
   }
 
+  /**
+   * @returns {Expect}
+   */
   by(count) {
     this.count = count
 
@@ -60,16 +63,25 @@ class Expect {
     this.expectations = []
   }
 
+  /**
+   * @returns {ExpectToChange}
+   */
   andChange(...args) {
     return this.toChange(...args)
   }
 
+  /**
+   * @returns {this}
+   */
   get not() {
     this._not = true
 
     return this
   }
 
+  /**
+   * @returns {void}
+   */
   toBe(result) {
     if (this._not) {
       if (this._object === result) {
@@ -82,6 +94,9 @@ class Expect {
     }
   }
 
+  /**
+   * @returns {void}
+   */
   toBeDefined() {
     if (this._not) {
       if (this._object !== undefined) {
@@ -94,24 +109,40 @@ class Expect {
     }
   }
 
+  /**
+   * @returns {void}
+   */
   toBeInstanceOf(klass) {
     if (!(this._object instanceof klass)) {
       throw new Error(`Expected ${this._object?.constructor?.name || "null"} to be a ${klass.name} but it wasn't`)
     }
   }
 
+  /**
+   * @returns {void}
+   */
   toBeFalse() {
     this.toBe(false)
   }
 
+  /**
+   * @returns {void}
+   */
   toBeUndefined() {
     this.toBe(undefined)
   }
 
+  /**
+   * @returns {void}
+   */
   toBeTrue() {
     this.toBe(true)
   }
 
+  /**
+   * @param {function(): void} changeCallback
+   * @returns {ExpectToChange}
+   */
   toChange(changeCallback) {
     if (this._not) throw new Error("not stub")
 
@@ -122,6 +153,9 @@ class Expect {
     return expectToChange
   }
 
+  /**
+   * @returns {void}
+   */
   toContain(valueToContain) {
     if (this._not) throw new Error("not stub")
 
@@ -130,6 +164,9 @@ class Expect {
     }
   }
 
+  /**
+   * @returns {void}
+   */
   toEqual(result) {
     if (this._not) {
       if (typeof this._object == "object" && typeof result == "object") {
@@ -154,6 +191,9 @@ class Expect {
     }
   }
 
+  /**
+   * @returns {void}
+   */
   toMatch(regex) {
     const match = this._object.match(regex)
 
@@ -168,6 +208,9 @@ class Expect {
     }
   }
 
+  /**
+   * @returns {void}
+   */
   async toThrowError(expectedError) {
     if (this._not) throw new Error("not stub")
 
@@ -218,6 +261,10 @@ class Expect {
     return result
   }
 
+  /**
+   * @param {object} result
+   * @returns {void}
+   */
   toHaveAttributes(result) {
     if (this._not) throw new Error("not stub")
 
@@ -241,6 +288,10 @@ class Expect {
   }
 }
 
+/**
+ * @param {string} description
+ * @returns {void}
+ */
 async function describe(description, arg1, arg2) {
   let testArgs, testFunction
 
@@ -273,10 +324,17 @@ async function describe(description, arg1, arg2) {
   }
 }
 
+/**
+ * @returns {Expect}
+ */
 function expect(arg) {
   return new Expect(arg)
 }
 
+/**
+ * @param {string} description
+ * @returns {void}
+ */
 function it(description, arg1, arg2) {
   const currentTest = currentPath[currentPath.length - 1]
   let testArgs, testFunction
@@ -296,6 +354,10 @@ function it(description, arg1, arg2) {
   currentTest.tests[description] = {args: newTestArgs, function: testFunction}
 }
 
+/**
+ * @param {string} description
+ * @returns {void}
+ */
 function fit(description, arg1, arg2) {
   let testArgs, testFunction
 

package/src/utils/file-exists.js

@@ -1,13 +1,15 @@
-import fs from "node:fs/promises"
+import fs from "fs/promises"
 
-async function fileExists(path) {
+/**
+ * @param {string} path
+ * @returns {boolean}
+ */
+export default async function fileExists(path) {
   try {
     await fs.access(path)
 
     return true
-  } catch (error) {
+  } catch (error) { // eslint-disable-line no-unused-vars
     return false
   }
 }
-
-export default fileExists