velocious 1.0.87 → 1.0.89

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.87",
+  "version": "1.0.89",
   "main": "index.js",
   "scripts": {
     "lint": "eslint",

package/src/cli/base-command.js

@@ -1,16 +1,39 @@
 import restArgsError from "../utils/rest-args-error.js"
 
 export default class VelociousCliBaseCommand {
-  constructor({args = {}, environmentHandler, ...restArgs}) {
+  /**
+   * @param {object} args
+   * @param {object} args.args
+   */
+  constructor({args = {}, ...restArgs}) {
     restArgsError(restArgs)
 
     this.args = args
     this._configuration = args.configuration
-    this._environmentHandler = environmentHandler
+    this._environmentHandler = args.configuration.getEnvironmentHandler()
     this.processArgs = args.processArgs
   }
 
+  /**
+   * @returns {string}
+   */
   directory() { return this.getConfiguration().getDirectory() }
+
+  /**
+   * @interface
+   */
+  execute() {
+    throw new Error("execute not implemented")
+  }
+
+  /**
+   * @returns {import("../configuration.js").default}
+   */
   getConfiguration() { return this._configuration }
+
+  /**
+   * @template T extends import("../environment-handlers/base.js").default
+   * @returns {T}
+   */
   getEnvironmentHandler() { return this._environmentHandler }
 }

package/src/cli/commands/destroy/migration.js

@@ -1,35 +1,7 @@
 import BaseCommand from "../../base-command.js"
-import fs from "fs/promises"
 
 export default class DbDestroyMigration extends BaseCommand {
   async execute() {
-    const migrationName = this.processArgs[1]
-    const migrationDir = `${this.getConfiguration().getDirectory()}/src/database/migrations`
-    const migrationFiles = await fs.readdir(migrationDir)
-    const destroyed = []
-
-    for (const migrationFile of migrationFiles) {
-      const match = migrationFile.match(/^(\d{14})-(.+)\.js$/)
-
-      if (!match) {
-        continue
-      }
-
-      const fileName = match[2]
-
-      if (fileName != migrationName) continue
-
-      const fullFilePath = `${migrationDir}/${migrationFile}`
-      destroyed.push(fileName)
-
-      if (!this.args.testing) {
-        console.log(`Destroy src/database/migrations/${migrationFile}`)
-        await fs.unlink(fullFilePath)
-      }
-    }
-
-    if (this.args.testing) {
-      return {destroyed}
-    }
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsMigrationDestroy(this)
   }
 }

package/src/cli/commands/generate/migration.js

@@ -1,33 +1,7 @@
 import BaseCommand from "../../base-command.js"
-import fileExists from "../../../utils/file-exists.js"
-import fs from "fs/promises"
-import * as inflection from "inflection"
-import strftime from "strftime"
 
 export default class DbGenerateMigration extends BaseCommand {
   async execute() {
-    const migrationName = this.processArgs[1]
-    const migrationNameCamelized = inflection.camelize(migrationName.replaceAll("-", "_"))
-    const date = new Date()
-    const migrationNumber = strftime("%Y%m%d%H%M%S")
-    const migrationFileName = `${migrationNumber}-${migrationName}.js`
-    const velociousPath = await this.getEnvironmentHandler().getVelociousPath()
-    const templateFilePath = `${velociousPath}/src/templates/generate-migration.js`
-    const migrationContentBuffer = await fs.readFile(templateFilePath)
-    const migrationContent = migrationContentBuffer.toString().replaceAll("__MIGRATION_NAME__", migrationNameCamelized)
-    const migrationDir = `${process.cwd()}/src/database/migrations`
-    const migrationPath = `${migrationDir}/${migrationFileName}`
-
-    if (this.args.testing) {
-      return {date, migrationContent, migrationName, migrationNameCamelized, migrationNumber, migrationPath}
-    } else {
-      if (!await fileExists(migrationDir)) {
-        await fs.mkdir(migrationDir, {recursive: true})
-      }
-
-      await fs.writeFile(migrationPath, migrationContent)
-
-      console.log(`create src/database/migrations/${migrationFileName}`)
-    }
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsMigrationGenerate(this)
   }
 }

package/src/cli/commands/generate/model.js

@@ -1,33 +1,7 @@
 import BaseCommand from "../../base-command.js"
-import fileExists from "../../../utils/file-exists.js"
-import fs from "fs/promises"
-import * as inflection from "inflection"
 
 export default class DbGenerateModel extends BaseCommand {
   async execute() {
-    const modelName = this.processArgs[1]
-    const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))
-    const date = new Date()
-    const modelFileName = `${inflection.dasherize(inflection.underscore(modelName))}.js`
-    const velociousPath = await this.getEnvironmentHandler().getVelociousPath()
-    const templateFilePath = `${velociousPath}/src/templates/generate-model.js`
-    const modelContentBuffer = await fs.readFile(templateFilePath)
-    const modelContent = modelContentBuffer.toString().replaceAll("__MODEL_NAME__", modelNameCamelized)
-    const modelsDir = `${process.cwd()}/src/models`
-    const modelPath = `${modelsDir}/${modelFileName}`
-
-    if (await fileExists(modelPath)) throw new Error(`Model file already exists: ${modelPath}`)
-
-    if (this.args.testing) {
-      return {date, modelContent, modelName, modelNameCamelized, modelPath}
-    } else {
-      if (!await fileExists(modelsDir)) {
-        await fs.mkdir(modelsDir, {recursive: true})
-      }
-
-      await fs.writeFile(modelPath, modelContent)
-
-      console.log(`create src/models/${modelFileName}`)
-    }
+    return await this.getConfiguration().getEnvironmentHandler().cliCommandsModelGenerate(this)
   }
 }

package/src/cli/index.js

@@ -23,7 +23,7 @@ export default class VelociousCli {
     }
 
     const CommandClass = await this.environmentHandler.requireCommand({commandParts: parsedCommandParts})
-    const commandInstance = new CommandClass({args: this.args, environmentHandler: this.environmentHandler})
+    const commandInstance = new CommandClass({args: this.args})
 
     if (commandInstance.initialize) {
       await commandInstance.initialize()

package/src/database/initializer-from-require-context.js

@@ -1,13 +1,24 @@
-export default class VelociousDatabaseInitializerFromRequireContext {
-  constructor({requireContext, ...restProps}) {
-    const restPropsKeys = Object.keys(restProps)
+import restArgsError from "../utils/rest-args-error.js"
 
-    if (restPropsKeys.length > 0) throw new Error(`Unknown arguments: ${restPropsKeys.join(", ")}`)
+export default class VelociousDatabaseInitializerFromRequireContext {
+  /**
+   * @param {object} args
+   * @param {object} args.requireContext
+   */
+  constructor({requireContext, ...restArgs}) {
+    restArgsError(restArgs)
 
     this.requireContext = requireContext
   }
 
-  async initialize({configuration}) {
+  /**
+   * @param {object} args
+   * @param {import("../configuration.js").default} args.configuration
+   * @returns {Promise<void>}
+   */
+  async initialize({configuration, ...restArgs}) {
+    restArgsError(restArgs)
+
     for (const fileName of this.requireContext.keys()) {
       const modelClassImport = this.requireContext(fileName)
 

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

@@ -8,6 +8,10 @@ export default class TableData {
   _indexes = []
   _references = []
 
+  /**
+   * @param {string} name
+   * @param {object} args
+   */
   constructor(name, args = {}) {
     if (!name) throw new Error(`Invalid table name: ${name}`)
 
@@ -15,6 +19,10 @@ export default class TableData {
     this._name = name
   }
 
+  /**
+   * @param {string} name
+   * @param {object} args
+   */
   addColumn(name, args = {}) {
     if (name instanceof TableColumn) {
       this._columns.push(name)
@@ -33,8 +41,20 @@ export default class TableData {
   addIndex(index) { this._indexes.push(index) }
   getIndexes() { return this._indexes }
 
+  /**
+   * @returns {string}
+   */
   getName() { return this._name }
+
+  /**
+   * @param {string} newName
+   * @returns {void}
+   */
   setName(newName) { this._name = newName }
+
+  /**
+   * @returns {boolean}
+   */
   getIfNotExists() { return this.args.ifNotExists }
   getReferences() { return this._references }
 

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

@@ -3,6 +3,21 @@ import restArgsError from "../../utils/rest-args-error.js"
 import TableForeignKey from "./table-foreign-key.js"
 
 export default class TableColumn {
+  /**
+   * @param {string} name
+   * @param {object} args
+   * @param {boolean} args.autoIncrement
+   * @param {any} args.default
+   * @param {boolean} args.dropColumn
+   * @param {boolean|object} args.foreignKey
+   * @param {boolean|object} args.index
+   * @param {boolean} args.isNewColumn
+   * @param {number} args.maxLength
+   * @param {string} args.name
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @param {string} args.type
+   */
   constructor(name, args) {
     if (args) {
       const {autoIncrement, default: columnDefault, dropColumn, foreignKey, index, isNewColumn, maxLength, name, null: argsNull, primaryKey, type, ...restArgs} = args // eslint-disable-line no-unused-vars
@@ -50,6 +65,9 @@ export default class TableColumn {
    */
   setAutoIncrement(newAutoIncrement) { this.args.autoIncrement = newAutoIncrement }
 
+  /**
+   * @returns {any}
+   */
   getDefault() { return this.args?.default }
 
   /**
@@ -62,22 +80,70 @@ export default class TableColumn {
    */
   getDropColumn() { return this.args?.dropColumn || false }
 
+  /**
+   * @returns {boolean|object}
+   */
   getForeignKey() { return this.args?.foreignKey }
+
+  /**
+   * @param {boolean|object} newForeignKey
+   * @returns {void}
+   */
   setForeignKey(newForeignKey) { this.args.foreignKey = newForeignKey }
 
+  /**
+   * @returns {boolean|object}
+   */
   getIndex() { return this.args?.index }
+
+  /**
+   * @param {boolean|object} newIndex
+   * @returns {void}
+   */
   setIndex(newIndex) { this.args.index = newIndex }
 
+  /**
+   * @returns {number}
+   */
   getMaxLength() { return this.args?.maxLength }
+
+  /**
+   * @param {number} newMaxLength
+   * @returns {void}
+   */
   setMaxLength(newMaxLength) { this.args.maxLength = newMaxLength }
 
+  /**
+   * @returns {boolean}
+   */
   getNull() { return this.args?.null }
+
+  /**
+   * @param {boolean} nullable
+   * @returns {void}
+   */
   setNull(nullable) { this.args.null = nullable }
 
+  /**
+   * @returns {boolean}
+   */
   getPrimaryKey() { return this.args?.primaryKey }
+
+  /**
+   * @param {boolean} newPrimaryKey
+   * @returns {void}
+   */
   setPrimaryKey(newPrimaryKey) { this.args.primaryKey = newPrimaryKey }
 
+  /**
+   * @returns {string}
+   */
   getType() { return this.args?.type }
+
+  /**
+   * @param {string} newType
+   * @returns {void}
+   */
   setType(newType) { this.args.type = newType }
 
   /**
@@ -85,7 +151,16 @@ export default class TableColumn {
    */
   isNewColumn() { return this.args?.isNewColumn || false }
 
-  getSQL({forAlterTable, driver}) {
+  /**
+   * @param {object} args
+   * @param {boolean} args.forAlterTable
+   * @template T extends import("../drivers/base.js").default
+   * @param {T} args.driver
+   * @returns {string}
+   */
+  getSQL({forAlterTable, driver, ...restArgs}) {
+    restArgsError(restArgs)
+
     const databaseType = driver.getType()
     const options = driver.options()
     let maxlength = this.getMaxLength()

package/src/database/table-data/table-foreign-key.js

@@ -1,6 +1,15 @@
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class TableForeignKey {
+  /**
+   * @param {object} args
+   * @param {string} args.columnName
+   * @param {boolean} args.isNewForeignKey
+   * @param {string} args.name
+   * @param {string} args.tableName
+   * @param {string} args.referencedColumnName
+   * @param {string} args.referencedTableName
+   */
   constructor({columnName, isNewForeignKey, name, tableName, referencedColumnName, referencedTableName, ...restArgs}) {
     restArgsError(restArgs)
 
@@ -12,12 +21,39 @@ export default class TableForeignKey {
     this._referencedTableName = referencedTableName
   }
 
+  /**
+   * @returns {string}
+   */
   getColumnName() { return this._columnName }
+
+  /**
+   * @returns {boolean}
+   */
   getIsNewForeignKey() { return this._isNewForeignKey }
+
+  /**
+   * @returns {string}
+   */
   getTableName() { return this._tableName }
+
+  /**
+   * @returns {string}
+   */
   getReferencedColumnName() { return this._referencedColumnName }
+
+  /**
+   * @returns {string}
+   */
   getReferencedTableName() { return this._referencedTableName }
 
+  /**
+   * @returns {string}
+   */
   getName() { return this._name }
+
+  /**
+   * @param {string} newName
+   * @returns {void}
+   */
   setName(newName) { this._name = newName }
 }

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

@@ -1,6 +1,12 @@
 import restArgsError from "../../utils/rest-args-error.js"
 
 export default class TableIndex {
+  /**
+   * @param {Array<string>} columns
+   * @param {object} args
+   * @param {string} args.name
+   * @param {boolean} args.unique
+   */
   constructor(columns, args) {
     if (args) {
       const {name, unique, ...restArgs} = args // eslint-disable-line no-unused-vars
@@ -12,7 +18,18 @@ export default class TableIndex {
     this.columns = columns
   }
 
+  /**
+   * @returns {Array<string>}
+   */
   getColumns() { return this.columns }
+
+  /**
+   * @returns {string}
+   */
   getName() { return this.args?.name }
+
+  /**
+   * @returns {boolean}
+   */
   getUnique() { return Boolean(this.args?.unique) }
 }

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

@@ -1,4 +1,8 @@
 export default class TableReference {
+  /**
+   * @param {string} name
+   * @param {object} args
+   */
   constructor(name, args) {
     this.args = args
     this.name = name

package/src/database/use-database.js

@@ -5,7 +5,12 @@ import Configuration from "../configuration.js"
 import Migrator from "./migrator.js"
 import restArgsError from "../utils/rest-args-error.js"
 
-const loadMigrations = function loadMigrations({migrationsRequireContextCallback, ...restArgs}) {
+/**
+ * @param {object} args
+ * @param {object} args.migrationsRequireContextCallback
+ * @returns {Promise<{loaded: boolean}>}
+ */
+export default function loadMigrations({migrationsRequireContextCallback, ...restArgs}) {
   const instance = React.useMemo(() => ({running: false}), [])
   const {isServer} = useEnvSense()
   const [loaded, setLoaded] = React.useState(false)
@@ -38,5 +43,3 @@ const loadMigrations = function loadMigrations({migrationsRequireContextCallback
 
   return {loaded}
 }
-
-export default loadMigrations

package/src/environment-handlers/base.js

@@ -9,6 +9,20 @@ export default class VelociousEnvironmentHandlerBase {
    */
   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}
+   */
+  async forwardCommand(command, CommandClass) {
+    const newCommand = new CommandClass({
+      args: command.args
+    })
+
+    return await newCommand.execute()
+  }
+
   /**
    * @interface
    */

package/src/environment-handlers/browser.js

@@ -15,6 +15,18 @@ export default class VelociousEnvironmentsHandlerBrowser extends Base {
     this.migrationsRequireContextCallback = migrationsRequireContextCallback
   }
 
+  async cliCommandsMigrationGenerate(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("Unsupported on browser")
+  }
+
+  async cliCommandsMigrationDestroy(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("Unsupported on browser")
+  }
+
+  async cliCommandsModelGenerate(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("Unsupported on browser")
+  }
+
   /**
    * @returns {object}
    */

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

@@ -0,0 +1,35 @@
+import BaseCommand from "../../../../../cli/base-command.js"
+import fs from "fs/promises"
+
+export default class DbDestroyMigration extends BaseCommand {
+  async execute() {
+    const migrationName = this.processArgs[1]
+    const migrationDir = `${this.getConfiguration().getDirectory()}/src/database/migrations`
+    const migrationFiles = await fs.readdir(migrationDir)
+    const destroyed = []
+
+    for (const migrationFile of migrationFiles) {
+      const match = migrationFile.match(/^(\d{14})-(.+)\.js$/)
+
+      if (!match) {
+        continue
+      }
+
+      const fileName = match[2]
+
+      if (fileName != migrationName) continue
+
+      const fullFilePath = `${migrationDir}/${migrationFile}`
+      destroyed.push(fileName)
+
+      if (!this.args.testing) {
+        console.log(`Destroy src/database/migrations/${migrationFile}`)
+        await fs.unlink(fullFilePath)
+      }
+    }
+
+    if (this.args.testing) {
+      return {destroyed}
+    }
+  }
+}

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

@@ -0,0 +1,33 @@
+import BaseCommand from "../../../../../cli/base-command.js"
+import fileExists from "../../../../../utils/file-exists.js"
+import fs from "fs/promises"
+import * as inflection from "inflection"
+import strftime from "strftime"
+
+export default class DbGenerateMigration extends BaseCommand {
+  async execute() {
+    const migrationName = this.processArgs[1]
+    const migrationNameCamelized = inflection.camelize(migrationName.replaceAll("-", "_"))
+    const date = new Date()
+    const migrationNumber = strftime("%Y%m%d%H%M%S")
+    const migrationFileName = `${migrationNumber}-${migrationName}.js`
+    const velociousPath = await this.getEnvironmentHandler().getVelociousPath()
+    const templateFilePath = `${velociousPath}/src/templates/generate-migration.js`
+    const migrationContentBuffer = await fs.readFile(templateFilePath)
+    const migrationContent = migrationContentBuffer.toString().replaceAll("__MIGRATION_NAME__", migrationNameCamelized)
+    const migrationDir = `${process.cwd()}/src/database/migrations`
+    const migrationPath = `${migrationDir}/${migrationFileName}`
+
+    if (this.args.testing) {
+      return {date, migrationContent, migrationName, migrationNameCamelized, migrationNumber, migrationPath}
+    } else {
+      if (!await fileExists(migrationDir)) {
+        await fs.mkdir(migrationDir, {recursive: true})
+      }
+
+      await fs.writeFile(migrationPath, migrationContent)
+
+      console.log(`create src/database/migrations/${migrationFileName}`)
+    }
+  }
+}

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

@@ -0,0 +1,33 @@
+import BaseCommand from "../../../../../cli/base-command.js"
+import fileExists from "../../../../../utils/file-exists.js"
+import fs from "fs/promises"
+import * as inflection from "inflection"
+
+export default class DbGenerateModel extends BaseCommand {
+  async execute() {
+    const modelName = this.processArgs[1]
+    const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))
+    const date = new Date()
+    const modelFileName = `${inflection.dasherize(inflection.underscore(modelName))}.js`
+    const velociousPath = await this.getEnvironmentHandler().getVelociousPath()
+    const templateFilePath = `${velociousPath}/src/templates/generate-model.js`
+    const modelContentBuffer = await fs.readFile(templateFilePath)
+    const modelContent = modelContentBuffer.toString().replaceAll("__MODEL_NAME__", modelNameCamelized)
+    const modelsDir = `${process.cwd()}/src/models`
+    const modelPath = `${modelsDir}/${modelFileName}`
+
+    if (await fileExists(modelPath)) throw new Error(`Model file already exists: ${modelPath}`)
+
+    if (this.args.testing) {
+      return {date, modelContent, modelName, modelNameCamelized, modelPath}
+    } else {
+      if (!await fileExists(modelsDir)) {
+        await fs.mkdir(modelsDir, {recursive: true})
+      }
+
+      await fs.writeFile(modelPath, modelContent)
+
+      console.log(`create src/models/${modelFileName}`)
+    }
+  }
+}

package/src/environment-handlers/node.js

@@ -1,4 +1,7 @@
 import Base from "./base.js"
+import CliCommandsDestroyMigration from "./node/cli/commands/destroy/migration.js"
+import CliCommandsGenerateMigration from "./node/cli/commands/generate/migration.js"
+import CliCommandsGenerateModel from "./node/cli/commands/generate/model.js"
 import {dirname} from "path"
 import {fileURLToPath} from "url"
 import fs from "fs/promises"
@@ -42,6 +45,18 @@ export default class VelociousEnvironmentHandlerNode extends Base{
     return commands
   }
 
+  async cliCommandsMigrationGenerate(command) {
+    return await this.forwardCommand(command, CliCommandsGenerateMigration)
+  }
+
+  async cliCommandsMigrationDestroy(command) {
+    return await this.forwardCommand(command, CliCommandsDestroyMigration)
+  }
+
+  async cliCommandsModelGenerate(command) {
+    return await this.forwardCommand(command, CliCommandsGenerateModel)
+  }
+
   /**
    * @param {Array<string>} commandParts
    * @template T extends import ("./base-command.js").default

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

@@ -83,6 +83,11 @@ export default class TestFilesFinder {
     })
   }
 
+  /**
+   * @param {string} file
+   * @param {string} localPath
+   * @returns {boolean}
+   */
   isFileMatchingRequirements(file, localPath) {
     if (this.testArgs.length > 0) {
       for (const testArg of this.testArgs) {

package/src/testing/test.js

@@ -11,12 +11,20 @@ const tests = {
 
 let currentPath = [tests]
 
+/**
+ * @param {function() : void} callback
+ * @returns {void}
+ */
 function beforeEach(callback) {
   const currentTest = currentPath[currentPath.length - 1]
 
   currentTest.beforeEaches.push({callback})
 }
 
+/**
+ * @param {function() : void} callback
+ * @returns {void}
+ */
 function afterEach(callback) {
   const currentTest = currentPath[currentPath.length - 1]
 
@@ -32,6 +40,7 @@ class ExpectToChange {
   }
 
   /**
+   * @param {number} count
    * @returns {Expect}
    */
   by(count) {
@@ -48,6 +57,9 @@ class ExpectToChange {
     this.newCount = await this.changeCallback()
   }
 
+  /**
+   * @returns {void}
+   */
   async execute() {
     const difference = this.newCount - this.oldCount
 
@@ -58,6 +70,9 @@ class ExpectToChange {
 }
 
 class Expect {
+  /**
+   * @param {any} object
+   */
   constructor(object) {
     this._object = object
     this.expectations = []
@@ -80,6 +95,7 @@ class Expect {
   }
 
   /**
+   * @param {any} result
    * @returns {void}
    */
   toBe(result) {
@@ -154,6 +170,7 @@ class Expect {
   }
 
   /**
+   * @param {any} valueToContain
    * @returns {void}
    */
   toContain(valueToContain) {
@@ -165,6 +182,7 @@ class Expect {
   }
 
   /**
+   * @param {any} result
    * @returns {void}
    */
   toEqual(result) {
@@ -192,6 +210,7 @@ class Expect {
   }
 
   /**
+   * @param {RegExp} regex
    * @returns {void}
    */
   toMatch(regex) {
@@ -209,6 +228,8 @@ class Expect {
   }
 
   /**
+   * @template T extends Error
+   * @param {string|T} expectedError
    * @returns {void}
    */
   async toThrowError(expectedError) {
@@ -243,6 +264,9 @@ class Expect {
     }
   }
 
+  /**
+   * @returns {any}
+   */
   async execute() {
     for (const expectation of this.expectations) {
       await expectation.runBefore()
@@ -290,6 +314,8 @@ class Expect {
 
 /**
  * @param {string} description
+ * @param {object|() => Promise<void>} arg1
+ * @param {undefined|() => Promise<void>} arg2
  * @returns {void}
  */
 async function describe(description, arg1, arg2) {
@@ -325,6 +351,7 @@ async function describe(description, arg1, arg2) {
 }
 
 /**
+ * @param {any} arg
  * @returns {Expect}
  */
 function expect(arg) {
@@ -333,6 +360,8 @@ function expect(arg) {
 
 /**
  * @param {string} description
+ * @param {object|() => Promise<void>} arg1
+ * @param {undefined|() => Promise<void>} arg2
  * @returns {void}
  */
 function it(description, arg1, arg2) {
@@ -356,6 +385,8 @@ function it(description, arg1, arg2) {
 
 /**
  * @param {string} description
+ * @param {object|() => Promise<void>} arg1
+ * @param {undefined|() => Promise<void>} arg2
  * @returns {void}
  */
 function fit(description, arg1, arg2) {