velocious 1.0.97 → 1.0.99

package/src/database/table-data/table-index.js

@@ -1,11 +1,17 @@
+// @ts-check
+
 import restArgsError from "../../utils/rest-args-error.js"
 
+/**
+ * @typedef {object} TableIndexArgsType
+ * @property {string} name
+ * @property {boolean} unique
+ */
+
 export default class TableIndex {
   /**
-   * @param {Array<string>} columns
-   * @param {object} args
-   * @param {string} args.name
-   * @param {boolean} args.unique
+   * @param {Array<string | import("./table-column.js").default>} columns
+   * @param {TableIndexArgsType} [args]
    */
   constructor(columns, args) {
     if (args) {
@@ -19,12 +25,12 @@ export default class TableIndex {
   }
 
   /**
-   * @returns {Array<string>}
+   * @returns {Array<string | import("./table-column.js").default>}
    */
   getColumns() { return this.columns }
 
   /**
-   * @returns {string}
+   * @returns {string | undefined}
    */
   getName() { return this.args?.name }
 

package/src/database/table-data/table-reference.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 export default class TableReference {
   /**
    * @param {string} name

package/src/database/use-database.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import React from "react"
 import useEnvSense from "env-sense/src/use-env-sense.js"
 
@@ -7,8 +9,8 @@ import restArgsError from "../utils/rest-args-error.js"
 
 /**
  * @param {object} args
- * @param {object} args.migrationsRequireContextCallback
- * @returns {Promise<{loaded: boolean}>}
+ * @param {() => Promise<import("./migrator/types.js").RequireMigrationContextType>} args.migrationsRequireContextCallback
+ * @returns {{loaded: boolean}}
  */
 export default function loadMigrations({migrationsRequireContextCallback, ...restArgs}) {
   const instance = React.useMemo(() => ({running: false}), [])

package/src/environment-handlers/base.js

@@ -1,3 +1,19 @@
+// @ts-check
+
+/**
+ * @typedef {object} CommandFileObjectType
+ * @property {string} name
+ * @property {string} file
+ */
+
+/**
+ * @typedef {object} MigrationObjectType
+ * @property {number} date
+ * @property {string} [fullPath]
+ * @property {string} migrationClassName
+ * @property {string} file
+ */
+
 export default class VelociousEnvironmentHandlerBase {
   /**
    * @param {import("../cli/base-command.js").default} _command
@@ -8,10 +24,10 @@ export default class VelociousEnvironmentHandlerBase {
   }
 
   /**
-   * @param {import("../cli/base-command.js").default} _command
+   * @param {import("../cli/base-command.js").default} command
    * @returns {Promise<void>}
    */
-  async cliCommandsInit(_command) { // eslint-disable-line no-unused-vars
+  async cliCommandsInit(command) { // eslint-disable-line no-unused-vars
     throw new Error("cliCommandsInit not implemented")
   }
 
@@ -57,19 +73,20 @@ export default class VelociousEnvironmentHandlerBase {
 
   /**
    * @interface
+   * @returns {Promise<CommandFileObjectType[]>}
    */
   async findCommands() { throw new Error("findCommands not implemented") }
 
   /**
    * @interface
+   * @returns {Promise<Array<MigrationObjectType>>}
    */
   async findMigrations() { throw new Error("findMigrations not implemneted") }
 
   /**
-   * @template T extends import("../cli/base-command.js").default
-   * @param {T} command
-   * @param {typeof T} CommandClass
-   * @returns {any}
+   * @param {import("../cli/base-command.js").default} command
+   * @param {typeof import("../cli/base-command.js").default} CommandClass
+   * @returns {Promise<any>}
    */
   async forwardCommand(command, CommandClass) {
     const newCommand = new CommandClass({
@@ -81,20 +98,36 @@ export default class VelociousEnvironmentHandlerBase {
 
   /**
    * @interface
+   * @returns {Promise<string>}
    */
-  async getVelociousPath() { throw new Error("getVelociousPath not implemented") }
+  getVelociousPath() { throw new Error("getVelociousPath not implemented") }
 
   /**
    * @interface
+   * @returns {Promise<import("../routes/index.js").default>}
    */
   async importApplicationRoutes() { throw new Error("importApplicationRoutes not implemented") }
 
+  /**
+   * @interface
+   * @param {string[]} _testFiles
+   * @returns {Promise<void>}
+   */
+  importTestFiles(_testFiles) { throw new Error("'importTestFiles' not implemented") } // eslint-disable-line no-unused-vars
+
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
+  importTestingConfigPath() { throw new Error(`'importTestingConfigPath' not implemented`) }
+
   /**
    * @param {object} args
    * @param {string[]} args.commandParts
+   * @returns {Promise<import ("../cli/base-command.js").default>}
    * @interface
    */
-  async requireCommand({commandParts}) { throw new Error("requireCommand not implemented") } // eslint-disable-line no-unused-vars
+  async requireCommand({commandParts}) { throw new Error("'requireCommand' not implemented") } // eslint-disable-line no-unused-vars
 
   /**
    * @param {object} newArgs

package/src/environment-handlers/node/cli/commands/destroy/migration.js

@@ -2,6 +2,9 @@ import BaseCommand from "../../../../../cli/base-command.js"
 import fs from "fs/promises"
 
 export default class DbDestroyMigration extends BaseCommand {
+  /**
+   * @returns {Promise<void>}
+   */
   async execute() {
     const migrationName = this.processArgs[1]
     const migrationDir = `${this.getConfiguration().getDirectory()}/src/database/migrations`

package/src/environment-handlers/node/cli/commands/generate/migration.js

@@ -5,6 +5,9 @@ import * as inflection from "inflection"
 import strftime from "strftime"
 
 export default class DbGenerateMigration extends BaseCommand {
+  /**
+   * @returns {Promise<void>}
+   */
   async execute() {
     const migrationName = this.processArgs[1]
     const migrationNameCamelized = inflection.camelize(migrationName.replaceAll("-", "_"))

package/src/environment-handlers/node/cli/commands/generate/model.js

@@ -4,6 +4,9 @@ import fs from "fs/promises"
 import * as inflection from "inflection"
 
 export default class DbGenerateModel extends BaseCommand {
+  /**
+   * @returns {Promise<void>}
+   */
   async execute() {
     const modelName = this.processArgs[1]
     const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))

package/src/environment-handlers/node/cli/commands/init.js

@@ -3,6 +3,9 @@ import fileExists from "../../../../utils/file-exists.js"
 import fs from "fs/promises"
 
 export default class VelociousCliCommandsInit extends BaseCommand {
+  /**
+   * @returns {Promise<void>}
+   */
   async execute() {
     const velociousPath = await this.getEnvironmentHandler().getVelociousPath()
     const projectPath = this.getConfiguration()?.getDirectory() || process.cwd()

package/src/environment-handlers/node.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import Base from "./base.js"
 import CliCommandsDestroyMigration from "./node/cli/commands/destroy/migration.js"
 import CliCommandsInit from "./node/cli/commands/init.js"
@@ -13,11 +15,16 @@ import * as inflection from "inflection"
 import path from "path"
 
 export default class VelociousEnvironmentHandlerNode extends Base{
+  /** @type {import("./base.js").CommandFileObjectType[] | undefined} */
+  _findCommandsResult = undefined
+
   /**
-   * @returns {Promise<Array<{name: string, file: string}>>}
+   * @returns {Promise<Array<import("./base.js").CommandFileObjectType>>}
    */
   async findCommands() {
-    this._findCommandsResult ||= this._actualFindCommands()
+    this._findCommandsResult ||= await this._actualFindCommands()
+
+    if (!this._findCommandsResult) throw new Error("Could not get commands")
 
     return this._findCommandsResult
   }
@@ -49,38 +56,66 @@ export default class VelociousEnvironmentHandlerNode extends Base{
     return commands
   }
 
+  /**
+   * @param {import("../cli/base-command.js").default} command
+   * @returns {Promise<void>}
+   */
   async cliCommandsInit(command) {
     return await this.forwardCommand(command, CliCommandsInit)
   }
 
+  /**
+   * @param {import("../cli/base-command.js").default} command
+   * @returns {Promise<any>}
+   */
   async cliCommandsMigrationGenerate(command) {
     return await this.forwardCommand(command, CliCommandsGenerateMigration)
   }
 
+  /**
+   * @param {import("../cli/base-command.js").default} command
+   * @returns {Promise<any>}
+   */
   async cliCommandsMigrationDestroy(command) {
     return await this.forwardCommand(command, CliCommandsDestroyMigration)
   }
 
+  /**
+   * @param {import("../cli/base-command.js").default} command
+   * @returns {Promise<any>}
+   */
   async cliCommandsGenerateBaseModels(command) {
     return await this.forwardCommand(command, CliCommandsGenerateBaseModels)
   }
 
+  /**
+   * @param {import("../cli/base-command.js").default} command
+   * @returns {Promise<any>}
+   */
   async cliCommandsGenerateModel(command) {
     return await this.forwardCommand(command, CliCommandsGenerateModel)
   }
 
+  /**
+   * @param {import("../cli/base-command.js").default} command
+   * @returns {Promise<any>}
+   */
   async cliCommandsServer(command) {
     return await this.forwardCommand(command, CliCommandsServer)
   }
 
+  /**
+   * @param {import("../cli/base-command.js").default} command
+   * @returns {Promise<any>}
+   */
   async cliCommandsTest(command) {
     return await this.forwardCommand(command, CliCommandsTest)
   }
 
   /**
-   * @param {Array<string>} commandParts
-   * @template T extends import ("./base-command.js").default
-   * @returns {Promise<T>}
+   * @param {object} args
+   * @param {string[]} args.commandParts
+   * @returns {Promise<import ("../cli/base-command.js").default>}
    */
   async requireCommand({commandParts}) {
     const commands = await this.findCommands()
@@ -89,7 +124,7 @@ export default class VelociousEnvironmentHandlerNode extends Base{
     if (!command) {
       const possibleCommands = commands.map(aCommand => aCommand.name)
 
-      throw new Error(`Unknown command: ${this.args.processArgs[0]} which should have been one of: ${possibleCommands.sort().join(", ")}`)
+      throw new Error(`Unknown command: ${commandParts.join(":")} which should have been one of: ${possibleCommands.sort().join(", ")}`)
     }
 
     const commandClassImport = await import(command.file)
@@ -99,40 +134,35 @@ export default class VelociousEnvironmentHandlerNode extends Base{
   }
 
   /**
-   * @returns {Promise<Array<{name: string, file: string}>>}
+   * @returns {Promise<Array<import("./base.js").MigrationObjectType>>}
    */
   async findMigrations() {
     const migrationsPath = `${this.getConfiguration().getDirectory()}/src/database/migrations`
     const glob = await fs.glob(`${migrationsPath}/**/*.js`)
-    const files = []
+    let files = []
 
     for await (const fullPath of glob) {
       const file = await path.basename(fullPath)
 
-      files.push(file)
-    }
-
-    const migrationFiles = files
-      .map((file) => {
-        const match = file.match(/^(\d{14})-(.+)\.js$/)
+      const match = file.match(/^(\d{14})-(.+)\.js$/)
 
-        if (!match) return null
+      if (!match) continue
 
-        const date = parseInt(match[1])
-        const migrationName = match[2]
-        const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"))
+      const date = parseInt(match[1])
+      const migrationName = match[2]
+      const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"))
 
-        return {
-          file,
-          fullPath: `${migrationsPath}/${file}`,
-          date,
-          migrationClassName
-        }
+      files.push({
+        file,
+        fullPath: `${migrationsPath}/${file}`,
+        date,
+        migrationClassName
       })
-      .filter((migration) => Boolean(migration))
-      .sort((migration1, migration2) => migration1.date - migration2.date)
+    }
+
+    files = files.sort((migration1, migration2) => migration1.date - migration2.date)
 
-    return migrationFiles
+    return files
   }
 
   /**
@@ -145,7 +175,7 @@ export default class VelociousEnvironmentHandlerNode extends Base{
   }
 
   /**
-   * @returns {string}
+   * @returns {Promise<string>}
    */
   async getVelociousPath() {
     if (!this._velociousPath) {
@@ -159,6 +189,7 @@ export default class VelociousEnvironmentHandlerNode extends Base{
   }
 
   /**
+   * @param {string[]} testFiles
    * @returns {Promise<void>}
    */
   async importTestFiles(testFiles) {

package/src/http-client/header.js

@@ -1,4 +1,10 @@
+// @ts-check
+
 export default class Header {
+  /**
+   * @param {string} name
+   * @param {string | number} value
+   */
   constructor(name, value) {
     this.name = name
     this.value = value

package/src/http-client/request.js

@@ -1,4 +1,16 @@
+// @ts-check
+
+import Header from "./header.js"
+
 export default class Request {
+  /**
+   * @param {object} args
+   * @param {string} args.body
+   * @param {string} args.method
+   * @param {Header[]} args.headers
+   * @param {string} args.path
+   * @param {string} args.version
+   */
   constructor({body, method = "GET", headers = [], path, version = "1.1"}) {
     this.body = body
     this.headers = headers
@@ -17,26 +29,40 @@ export default class Request {
     return requestString
   }
 
-  getHeader(key) {
-    const compareName = key.toLowerCase().trim()
+  /**
+   * @param {string} name
+   */
+  getHeader(name) {
+    const compareName = name.toLowerCase().trim()
 
     for (const header of this.headers) {
-      const headerCompareName = header.key.toLowerCase().trim()
+      const headerCompareName = header.getName().toLowerCase().trim()
 
       if (compareName == headerCompareName) {
         return header
       }
     }
 
-    throw new Error(`Header ${key} not found`)
+    throw new Error(`Header ${name} not found`)
+  }
+
+  /**
+   * @param {string} name
+   * @param {string | number} value
+   */
+  addHeader(name, value) {
+    this.headers.push(new Header(name, value))
   }
 
   prepare() {
     if (this.body) {
-      this.addHeader("Content-Length", this.body.byteLength)
+      this.addHeader("Content-Length", Buffer.from(this.body).byteLength)
     }
   }
 
+  /**
+   * @param {function(string) : void} callback
+   */
   stream(callback) {
     this.prepare()
 

package/src/http-client/response.js

@@ -1,23 +1,37 @@
+// @ts-check
+
 import Header from "./header.js"
 
 export default class Response {
+  /**
+   * @param {object} args
+   * @param {string} args.method
+   * @param {function() : void} args.onComplete
+   */
   constructor({method = "GET", onComplete}) {
     if (!method) throw new Error(`Invalid method given: ${method}`)
 
+    /** @type {Header[]} */
     this.headers = []
+
     this.method = method.toUpperCase().trim()
     this.onComplete = onComplete
     this.state = "status-line"
 
-    this.arrayBuffer = new ArrayBuffer()
-    this.response = new Uint8Array(this.arrayBuffer)
+    /** @type {Buffer} */
+    this.response = Buffer.alloc(0);
   }
 
+  /** @param {Buffer} data */
   feed(data) {
-    this.response += data
+    this.response = Buffer.concat([this.response, data])
     this.tryToParse()
   }
 
+  /**
+   * @param {string} name
+   * @returns {Header}
+   */
   getHeader(name) {
     const compareName = name.toLowerCase().trim()
 
@@ -33,9 +47,11 @@ export default class Response {
   }
 
   json() {
-    const contentTypeHeader = this.getHeader("Content-Type")?.getValue()?.toLowerCase()?.trim()
+    const contentTypeHeader = this.getHeader("Content-Type")?.getValue()
+
+    if (typeof contentTypeHeader != "string") throw new Error(`Content-Type wasn't a string: ${contentTypeHeader}`)
 
-    if (!contentTypeHeader.startsWith("application/json")) {
+    if (!contentTypeHeader.toLowerCase().trim().startsWith("application/json")) {
       throw new Error(`Content-Type is not JSON: ${contentTypeHeader}`)
     }
 
@@ -48,13 +64,21 @@ export default class Response {
   tryToParse() {
     while (true) {
       if (this.state == "body") {
-        const contentLengthValue = this.getHeader("Content-Length")?.value
+        const contentLengthValue = this.getHeader("Content-Length")?.getValue()
 
         if (contentLengthValue === undefined) {
           throw new Error("No content length given")
         }
 
-        const contentLengthNumber = parseInt(contentLengthValue)
+        let contentLengthNumber
+
+        if (typeof contentLengthValue == "number") {
+          contentLengthNumber = contentLengthValue
+        } else if (contentLengthValue == "string") {
+          contentLengthNumber = parseInt(contentLengthValue)
+        } else {
+          throw new Error(`Content-Length is not a number: ${contentLengthValue}`)
+        }
 
         if (this.response.byteLength >= contentLengthNumber) {
           this.completeResponse()

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

@@ -1,3 +1,5 @@
+// @ts-check
+
 import {digg} from "diggerize"
 import {EventEmitter} from "events"
 import {Logger} from "../../logger.js"
@@ -8,26 +10,33 @@ export default class VeoliciousHttpServerClient {
   events = new EventEmitter()
   state = "initial"
 
-  constructor({clientCount, configuration, onExecuteRequest}) {
+  /**
+   * @param {object} args
+   * @param {number} args.clientCount
+   * @param {import("../../configuration.js").default} args.configuration
+   */
+  constructor({clientCount, configuration}) {
     if (!configuration) throw new Error("No configuration given")
 
     this.logger = new Logger(this)
     this.clientCount = clientCount
     this.configuration = configuration
-    this.onExecuteRequest = onExecuteRequest
+
+    /** @type {RequestRunner[]} */
     this.requestRunners = []
   }
 
   executeCurrentRequest = () => {
     this.logger.debug("executeCurrentRequest")
 
+    if (!this.currentRequest) throw new Error("No current request")
+
     // We are done parsing the given request and can theoretically start parsing a new one, before the current request is done - so reset the state.
     this.state = "initial"
 
     const requestRunner = new RequestRunner({
       configuration: this.configuration,
-      request: this.currentRequest,
-      routes: this.routes
+      request: this.currentRequest
     })
 
     this.requestRunners.push(requestRunner)
@@ -36,6 +45,9 @@ export default class VeoliciousHttpServerClient {
     requestRunner.run()
   }
 
+  /**
+   * @param {string} data
+   */
   onWrite(data) {
     if (this.state == "initial") {
       this.currentRequest = new Request({client: this, configuration: this.configuration})
@@ -43,6 +55,8 @@ export default class VeoliciousHttpServerClient {
       this.currentRequest.feed(data)
       this.state = "requestStarted"
     } else if (this.state == "requestStarted") {
+      if (!this.currentRequest) throw new Error("No current request")
+
       this.currentRequest.feed(data)
     } else {
       throw new Error(`Unknown state for client: ${this.state}`)
@@ -76,7 +90,13 @@ export default class VeoliciousHttpServerClient {
     }
   }
 
+  /**
+   * @param {RequestRunner} requestRunner
+   * @returns {void}
+   */
   sendResponse(requestRunner) {
+    if (!this.currentRequest) throw new Error("No current request")
+
     const response = digg(requestRunner, "response")
     const request = requestRunner.getRequest()
     const body = response.getBody()

package/src/http-server/client/request-buffer/form-data-part.js

@@ -1,7 +1,15 @@
+// @ts-check
+
 export default class FormDataPart {
+  /** @type {Record<string, import("./header.js").default>} */
   headers = {}
+
+  /** @type {number[]} */
   body = []
 
+  /**
+   * @param {import("./header.js").default} header
+   */
   addHeader(header) {
     const name = header.formattedName
 
@@ -36,6 +44,9 @@ export default class FormDataPart {
     return this.value
   }
 
+  /**
+   * @param {string} text
+   */
   removeFromBody(text) {
     this.body = this.body.slice(0, this.body.length - text.length)
   }

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

@@ -1,4 +1,10 @@
+// @ts-check
+
 export default class Header {
+  /**
+   * @param {string} name
+   * @param {string} value
+   */
   constructor(name, value) {
     this.formattedName = name.toLowerCase().trim()
     this.name = name