velocious 1.0.101 → 1.0.103

package/src/database/record/instance-relationships/base.js

@@ -1,14 +1,30 @@
+// @ts-check
+
 export default class VelociousDatabaseRecordBaseInstanceRelationship {
+  /** @type {boolean | undefined} */
+  _autoSave = undefined
+
+  /**
+   * @param {object} args
+   * @param {import("../index.js").default} args.model
+   * @param {import("../relationships/base.js").default} args.relationship
+   */
   constructor({model, relationship}) {
-    this._autoSave = null
     this._dirty = false
     this.model = model
     this.relationship = relationship
   }
 
   /**
-   * @returns {boolean} Whether the relationship should be auto-saved before saving the parent model
+   * @abstract
+   * @param {Record<string, any>} attributes
+   * @returns {import("../index.js").default}
    */
+  build(attributes) { // eslint-disable-line no-unused-vars
+    throw new Error("'build' not implemented")
+  }
+
+  /** @returns {boolean | undefined} Whether the relationship should be auto-saved before saving the parent model */
   getAutoSave() { return this._autoSave }
 
   /**
@@ -23,20 +39,21 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
    */
   setDirty(newValue) { this._dirty = newValue }
 
-  /**
-   * @returns {boolean} Whether the relationship is dirty (has been modified)
-   */
+  /** @returns {boolean} Whether the relationship is dirty (has been modified) */
   getDirty() { return this._dirty }
 
   /**
-   * @returns {boolean} Whether the relationship has been preloaded
+   * @abstract
+   * @returns {Promise<void>}
    */
+  load() {
+    throw new Error("'load' not implemented")
+  }
+
+  /**  @returns {boolean} Whether the relationship has been preloaded */
   isLoaded() { return Boolean(this._loaded) }
 
-  /**
-   * @template T extends import("../index.js").default
-   * @returns {T|Array<T>} The loaded model or models (depending on relationship type)
-   */
+  /** @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type) */
   loaded() {
     if (!this._preloaded && this.model.isPersisted()) {
       throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
@@ -45,53 +62,33 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
     return this._loaded
   }
 
-  /**
-   * @template T extends import("../index.js").default
-   * @param {T|Array<T>} model
-   */
+  /** @param {import("../index.js").default|Array<import("../index.js").default>} model */
   setLoaded(model) { this._loaded = model }
 
-  /**
-   * @template T extends import("../index.js").default
-   * @returns {T|Array<T>} The loaded model or models (depending on relationship type)
-   */
-  getPreloaded() { return this._preloaded }
+  /** @returns {import("../index.js").default | import("../index.js").default[] | undefined} */
+  getLoadedOrUndefined() { return this._loaded }
 
-  /**
-   * @template T extends import("../index.js").default
-   * @param {T|Array<T>} preloadedModelOrModels
-   */
-  setPreloaded(preloadedModelOrModels) { this._preloaded = preloadedModelOrModels }
+  /** @returns {boolean} The loaded model or models (depending on relationship type) */
+  getPreloaded() { return this._preloaded || false }
 
-  /**
-   * @returns {string} The foreign key for this relationship
-   */
+  /** @param {boolean} isPreloaded */
+  setPreloaded(isPreloaded) { this._preloaded = isPreloaded }
+
+  /** @returns {string} The foreign key for this relationship */
   getForeignKey() { return this.getRelationship().getForeignKey() }
 
-  /**
-   * @template T extends import("../index.js").default
-   * @returns {T} model
-   */
+  /** @returns {import("../index.js").default} model */
   getModel() { return this.model }
 
-  /**
-   * @returns {string} The primary key for this relationship's model
-   */
+  /** @returns {string} The primary key for this relationship's model */
   getPrimaryKey() { return this.getRelationship().getPrimaryKey() }
 
-  /**
-   * @template T extends import("../relationships/base.js").default
-   * @returns {T} The relationship object that this instance relationship is based on
-   */
+  /** @returns {import("../relationships/base.js").default} The relationship object that this instance relationship is based on */
   getRelationship() { return this.relationship }
 
-  /**
-   * @returns {typeof import("../index.js").default} The model class that this instance relationship
-   */
+  /** @returns {typeof import("../index.js").default | undefined} The model class that this instance relationship */
   getTargetModelClass() { return this.getRelationship().getTargetModelClass() }
 
-  /**
-   * @returns {string} The type of relationship (e.g. "has_many", "belongs_to", etc.)
-   */
+  /** @returns {string} The type of relationship (e.g. "has_many", "belongs_to", etc.) */
   getType() { return this.getRelationship().getType() }
 }

package/src/database/record/instance-relationships/belongs-to.js

@@ -1,21 +1,33 @@
+// @ts-check
+
 import BaseInstanceRelationship from "./base.js"
 
 export default class VelociousDatabaseRecordBelongsToInstanceRelationship extends BaseInstanceRelationship {
+  /**
+   * @param {Record<string, any>} data
+   * @returns {import("../index.js").default}
+   */
   build(data) {
-    const targetModelClass = this.getTargetModelClass()
-    const newInstance = new targetModelClass(data)
+    const TargetModelClass = this.getTargetModelClass()
+
+    if (!TargetModelClass) throw new Error("Can't build a new record without a target model")
+
+    const newInstance = new TargetModelClass(data)
 
     this._loaded = newInstance
 
     return newInstance
   }
 
-  getLoadedOrNull() { return this._loaded }
+  getLoadedOrUndefined() { return this._loaded }
 
   async load() {
     const foreignKey = this.getForeignKey()
     const foreignModelID = this.getModel().readColumn(foreignKey)
     const TargetModelClass = this.getTargetModelClass()
+
+    if (!TargetModelClass) throw new Error("Can't load without a target model")
+
     const foreignModel = await TargetModelClass.find(foreignModelID)
 
     this.setLoaded(foreignModel)

package/src/database/record/instance-relationships/has-many.js

@@ -1,21 +1,30 @@
+// @ts-check
+
 import BaseInstanceRelationship from "./base.js"
 
 export default class VelociousDatabaseRecordHasManyInstanceRelationship extends BaseInstanceRelationship {
-  constructor(args) {
-    super(args)
-    this._loaded = null
-  }
-
+  /**
+   * @param {Record<string, any>} data
+   * @returns {import("../index.js").default}
+   */
   build(data) {
     // Spawn new model of the targeted class
     const targetModelClass = this.getTargetModelClass()
+
+    if (!targetModelClass) throw new Error("Can't build a new record without a taget model class")
+
     const newInstance = new targetModelClass(data)
 
 
     // Add it to the loaded models of this relationship
-    if (this._loaded === null) this._loaded = []
-
-    this._loaded.push(newInstance)
+    if (this._loaded === undefined) {
+      /** @type {import("../index.js").default[]} */
+      this._loaded = [newInstance]
+    } else if (Array.isArray(this._loaded)) {
+      this._loaded.push(newInstance)
+    } else {
+      throw new Error(`Loaded had an unexpected type: ${typeof this._loaded}`)
+    }
 
 
     // Set loaded on the models inversed relationship
@@ -38,6 +47,10 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
     const primaryKey = this.getPrimaryKey()
     const primaryModelID = this.getModel().readColumn(primaryKey)
     const TargetModelClass = this.getTargetModelClass()
+
+    if (!TargetModelClass) throw new Error("Cannot load without a target model class")
+
+    /** @type {Record<string, any>} */
     const whereArgs = {}
 
     whereArgs[foreignKey] = primaryModelID
@@ -49,47 +62,55 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
     this.setPreloaded(true)
   }
 
+  /**
+   * @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type)
+   */
   loaded() {
     if (!this._preloaded && this.model.isPersisted()) {
       throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
     }
 
-    if (this._loaded === null && this.model.isNewRecord()) {
+    if (this._loaded === undefined && this.model.isNewRecord()) {
       return []
     }
 
     return this._loaded
   }
 
-  getLoadedOrNull() { return this._loaded }
-
+  /**
+   * @param {import("../index.js").default[]} models
+   * @returns {void}
+   */
   addToLoaded(models) {
-    if (Array.isArray(models)) {
+    if (!models) {
+      throw new Error("Need to give something")
+    } else if (Array.isArray(models)) {
       for (const model of models) {
-        if (this._loaded === null) this._loaded = []
-
-        this._loaded.push(model)
+        if (this._loaded === undefined) {
+          this._loaded = [model]
+        } else if (Array.isArray(this._loaded)) {
+          this._loaded.push(model)
+        } else {
+          throw new Error(`Unexpected loaded type: ${typeof this._loaded}`)
+        }
       }
     } else {
-      if (this._loaded === null) this._loaded = []
-
-      this._loaded.push(models)
+      if (this._loaded === undefined) {
+        this._loaded = [models]
+      } else if (Array.isArray(this._loaded)) {
+        this._loaded.push(models)
+      } else {
+        throw new Error(`Unexpected loaded type: ${typeof this._loaded}`)
+      }
     }
   }
 
+  /**
+   * @param {import("../index.js").default[]} models
+   */
   setLoaded(models) {
     if (!Array.isArray(models)) throw new Error(`Argument given to setLoaded wasn't an array: ${typeof models}`)
 
     this._loaded = models
   }
-
-  setPreloaded(preloaded) {
-    if (preloaded && !Array.isArray(this._loaded)) {
-      throw new Error("Trying to set preloaded without a loaded value")
-    }
-
-    this._preloaded = preloaded
-  }
-
-  getTargetModelClass() { return this.relationship.getTargetModelClass() }
 }

package/src/database/record/instance-relationships/has-one.js

@@ -1,14 +1,21 @@
+// @ts-check
+
 import BaseInstanceRelationship from "./base.js"
 
 export default class VelociousDatabaseRecordHasOneInstanceRelationship extends BaseInstanceRelationship {
-  constructor(args) {
-    super(args)
-    this._loaded = null
-  }
+  /** @type {import("../index.js").default | undefined} */
+  _loaded = undefined
 
+  /**
+   * @param {Record<string, any>} data
+   * @returns {import("../index.js").default}
+   */
   build(data) {
-    const targetModelClass = this.getTargetModelClass()
-    const newInstance = new targetModelClass(data)
+    const TargetModelClass = this.getTargetModelClass()
+
+    if (!TargetModelClass) throw new Error("Can't build a new record without a target model class")
+
+    const newInstance = new TargetModelClass(data)
 
     this._loaded = newInstance
 
@@ -20,6 +27,10 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
     const primaryKey = this.getPrimaryKey()
     const primaryModelID = this.getModel().readColumn(primaryKey)
     const TargetModelClass = this.getTargetModelClass()
+
+    if (!TargetModelClass) throw new Error("Can't load without a target model class")
+
+    /** @type {Record<string, any>} */
     const whereArgs = {}
 
     whereArgs[foreignKey] = primaryModelID
@@ -31,6 +42,9 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
     this.setPreloaded(true)
   }
 
+  /**
+   * @returns {import("../index.js").default | Array<import("../index.js").default> | undefined} The loaded model or models (depending on relationship type)
+   */
   loaded() {
     if (!this._preloaded && this.model.isPersisted()) {
       throw new Error(`${this.model.constructor.name}#${this.relationship.getRelationshipName()} hasn't been preloaded`)
@@ -39,8 +53,9 @@ export default class VelociousDatabaseRecordHasOneInstanceRelationship extends B
     return this._loaded
   }
 
-  getLoadedOrNull() { return this._loaded }
+  getLoadedOrUndefined() { return this._loaded }
 
+  /** @param {import("../index.js").default|Array<import("../index.js").default>} model */
   setLoaded(model) {
     if (Array.isArray(model)) throw new Error(`Argument given to setLoaded was an array: ${typeof model}`)
 

package/src/database/record/relationships/base.js

@@ -1,32 +1,34 @@
+// @ts-check
+
 import restArgsError from "../../../utils/rest-args-error.js"
 
+/**
+ * @typedef {object} RelationshipBaseArgsType
+ * @property {string} [className]
+ * @property {string} [dependent]
+ * @property {string | undefined} [foreignKey]
+ * @property {string} [inverseOf]
+ * @property {typeof import("../index.js").default} [klass]
+ * @property {typeof import("../index.js").default} modelClass
+ * @property {string} [primaryKey]
+ * @property {boolean} [polymorphic]
+ * @property {string} relationshipName
+ * @property {string} [through]
+ * @property {string} type
+ */
+
 export default class VelociousDatabaseRecordBaseRelationship {
-  /**
-   * @param {object} args
-   * @param {string} args.className
-   * @param {import("../../../configuration.js").default} args.configuration
-   * @param {string} args.dependent
-   * @param {boolean|object} args.foreignKey
-   * @param {string} args.inverseOf
-   * @param {typeof import("../index.js").default} args.klass
-   * @param {typeof import("../index.js").default} args.modelClass
-   * @param {string} args.primaryKey
-   * @param {boolean} args.polymorphic
-   * @param {string} args.relationshipName
-   * @param {string} args.through
-   * @param {string} args.type
-   */
-  constructor({className, configuration, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey = "id", polymorphic, relationshipName, through, type, ...restArgs}) { // eslint-disable-line no-unused-vars
+  /** @param {RelationshipBaseArgsType} args */
+  constructor({className, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey = "id", polymorphic, relationshipName, through, type, ...restArgs}) {
     restArgsError(restArgs)
 
     if (!modelClass) throw new Error(`'modelClass' wasn't given for ${relationshipName}`)
     if (!className && !klass) throw new Error(`Neither 'className' or 'klass' was given for ${modelClass.name}#${relationshipName}`)
 
     this.className = className
-    this.configuration = configuration
     this._dependent = dependent
     this.foreignKey = foreignKey
-    this._inverseOf
+    this._inverseOf = inverseOf
     this.klass = klass
     this.modelClass = modelClass
     this._polymorphic = polymorphic
@@ -36,9 +38,9 @@ export default class VelociousDatabaseRecordBaseRelationship {
     this.type = type
   }
 
-  /**
-   * @returns {string} What will be done when the parent record is destroyed. E.g. "destroy", "nullify", "restrict" etc.
-   */
+  getConfiguration() { return this.modelClass._getConfiguration() }
+
+  /** @returns {string | undefined} What will be done when the parent record is destroyed. E.g. "destroy", "nullify", "restrict" etc. */
   getDependent() { return this._dependent }
 
   /**
@@ -51,47 +53,35 @@ export default class VelociousDatabaseRecordBaseRelationship {
 
   /**
    * @abstract
-   * @returns {string} The name of the inverse relationship, e.g. "posts", "comments" etc.
+   * @returns {string | undefined} The name of the inverse relationship, e.g. "posts", "comments" etc.
    */
   getInverseOf() {
     throw new Error("getInverseOf not implemented")
   }
 
-  /**
-   * @returns {typeof import("../index.js").default}
-   */
+  /** @returns {typeof import("../index.js").default} */
   getModelClass() { return this.modelClass }
 
-  /**
-   * @returns {string} The name of the relationship, e.g. "posts", "user", "comments" etc.
-   */
+  /** @returns {string} The name of the relationship, e.g. "posts", "user", "comments" etc. */
   getRelationshipName() { return this.relationshipName }
 
-  /**
-   * @returns {boolean}
-   */
+  /** @returns {boolean} */
   getPolymorphic() {
-    return this._polymorphic
+    return this._polymorphic || false
   }
 
-  /**
-   * @returns {string} The name of the foreign key, e.g. "id" etc.
-   */
+  /** @returns {string} The name of the foreign key, e.g. "id" etc. */
   getPrimaryKey() { return this._primaryKey }
 
-  /**
-   * @returns {string} The type of the relationship, e.g. "has_many", "belongs_to", "has_one", "has_and_belongs_to_many" etc.
-   */
+  /** @returns {string} The type of the relationship, e.g. "has_many", "belongs_to", "has_one", "has_and_belongs_to_many" etc. */
   getType() { return this.type }
 
-  /**
-   * @returns {typeof import("../index.js").default} The target model class for this relationship, e.g. if the relationship is "posts" then the target model class is the Post class.
-   */
+  /** @returns {typeof import("../index.js").default | undefined} The target model class for this relationship, e.g. if the relationship is "posts" then the target model class is the Post class. */
   getTargetModelClass() {
     if (this.getPolymorphic()) {
-      return null
+      return undefined
     } else if (this.className) {
-      return this.modelClass._getConfiguration().getModelClass(this.className)
+      return this.getConfiguration().getModelClass(this.className)
     } else if (this.klass) {
       return this.klass
     }

package/src/database/record/relationships/belongs-to.js

@@ -1,15 +1,23 @@
+// @ts-check
+
 import BaseRelationship from "./base.js"
 import * as inflection from "inflection"
 
 export default class VelociousDatabaseRecordBelongsToRelationship extends BaseRelationship {
+  /** @returns {string} */
   getForeignKey() {
     if (!this.foreignKey) {
-      this.foreignKey = `${inflection.underscore(this.getTargetModelClass().name)}_id`
+      const targetModelClass = this.getTargetModelClass()
+
+      if (!targetModelClass) throw new Error("Can't calculate foreign key without a target model class")
+
+      this.foreignKey = `${inflection.underscore(targetModelClass.name)}_id`
     }
 
     return this.foreignKey
   }
 
+  /** @returns {string | undefined} */
   getInverseOf() {
     if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
       this._autoGenerateInverseOfAttempted = true
@@ -17,9 +25,11 @@ export default class VelociousDatabaseRecordBelongsToRelationship extends BaseRe
       // Only make auto-inverse-of if the relationships name matches the target model class's name
       const targetClassSimpleName = `${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`
 
-      if (targetClassSimpleName == this.getTargetModelClass().name) {
+      const targetModelClass = this.getTargetModelClass()
+
+      if (targetModelClass && targetClassSimpleName == targetModelClass.name) {
         // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
-        const targetClassRelationshipNames = this.getTargetModelClass().getRelationshipNames()
+        const targetClassRelationshipNames = targetModelClass.getRelationshipNames()
         const autoGeneratedHasOneInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`
         const autoGeneratedHasManyInverseOfName = inflection.pluralize(autoGeneratedHasOneInverseOfName)
 

package/src/database/record/relationships/has-many.js

@@ -1,7 +1,10 @@
+// @ts-check
+
 import BaseRelationship from "./base.js"
 import * as inflection from "inflection"
 
 export default class VelociousDatabaseRecordHasManyRelationship extends BaseRelationship {
+  /** @returns {string} */
   getForeignKey() {
     if (!this.foreignKey) {
       this.foreignKey = `${inflection.underscore(this.modelClass.name)}_id`
@@ -10,6 +13,7 @@ export default class VelociousDatabaseRecordHasManyRelationship extends BaseRela
     return this.foreignKey
   }
 
+  /** @returns {string | undefined} */
   getInverseOf() {
     if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
       this._autoGenerateInverseOfAttempted = true
@@ -17,9 +21,11 @@ export default class VelociousDatabaseRecordHasManyRelationship extends BaseRela
       // Only make auto-inverse-of if the relationships name matches the target model class's name
       const targetClassSimpleName = inflection.singularize(`${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`)
 
-      if (targetClassSimpleName == this.getTargetModelClass().name) {
+      const targetModelClass = this.getTargetModelClass()
+
+      if (targetModelClass && targetClassSimpleName == targetModelClass.name) {
         // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
-        const targetClassRelationshipNames = this.getTargetModelClass().getRelationshipNames()
+        const targetClassRelationshipNames = targetModelClass.getRelationshipNames()
         const autoGeneratedBelongsToInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`
 
         if (targetClassRelationshipNames.includes(autoGeneratedBelongsToInverseOfName)) {

package/src/database/record/relationships/has-one.js

@@ -1,7 +1,10 @@
+// @ts-check
+
 import BaseRelationship from "./base.js"
 import * as inflection from "inflection"
 
 export default class VelociousDatabaseRecordHasOneRelationship extends BaseRelationship {
+  /** @returns {string} */
   getForeignKey() {
     if (!this.foreignKey) {
       this.foreignKey = `${inflection.underscore(this.modelClass.name)}_id`
@@ -10,6 +13,7 @@ export default class VelociousDatabaseRecordHasOneRelationship extends BaseRelat
     return this.foreignKey
   }
 
+  /** @returns {string | undefined} */
   getInverseOf() {
     if (!this._inverseOf && !this._autoGenerateInverseOfAttempted) {
       this._autoGenerateInverseOfAttempted = true
@@ -17,9 +21,11 @@ export default class VelociousDatabaseRecordHasOneRelationship extends BaseRelat
       // Only make auto-inverse-of if the relationships name matches the target model class's name
       const targetClassSimpleName = `${this.getRelationshipName().substring(0, 1).toUpperCase()}${this.getRelationshipName().substring(1, this.getRelationshipName().length)}`
 
-      if (targetClassSimpleName == this.getTargetModelClass().name) {
+      const targetModelClass = this.getTargetModelClass()
+
+      if (targetModelClass && targetClassSimpleName == targetModelClass.name) {
         // Only make auto-inverse-of if the expected relationship exist in a has-one or has-many form
-        const targetClassRelationshipNames = this.getTargetModelClass().getRelationshipNames()
+        const targetClassRelationshipNames = targetModelClass.getRelationshipNames()
         const autoGeneratedBelongsToInverseOfName = `${this.modelClass.name.substring(0, 1).toLowerCase()}${this.modelClass.name.substring(1, this.modelClass.name.length)}`
 
         if (targetClassRelationshipNames.includes(autoGeneratedBelongsToInverseOfName)) {

package/src/database/record/validators/base.js

@@ -1,10 +1,22 @@
+// @ts-check
+
 export default class VelociousDatabaseRecordValidatorsBase {
+  /**
+   * @param {object} args
+   * @param {string} args.attributeName
+   * @param {Record<string, any>} args.args
+   */
+  constructor({attributeName, args}) {
+    this.attributeName = attributeName
+    this.args = args
+  }
+
   /**
    * @abstract
-   * @template T extends import("../index.js").default
    * @param {object} args
-   * @param {T} args.model
+   * @param {import("../index.js").default} args.model
    * @param {string} args.attributeName
+   * @returns {Promise<void>}
    */
   async validate({model, attributeName}) { // eslint-disable-line no-unused-vars
     throw new Error("validate not implemented")

package/src/database/record/validators/presence.js

@@ -1,6 +1,13 @@
+// @ts-check
+
 import Base from "./base.js"
 
 export default class VelociousDatabaseRecordValidatorsPresence extends Base {
+  /**
+   * @param {object} args
+   * @param {import("../index.js").default} args.model
+   * @param {string} args.attributeName
+   */
   async validate({model, attributeName}) {
     const attributeValue = model.readAttribute(attributeName)?.trim()
 

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

@@ -97,7 +97,7 @@ export default class TableColumn {
   getForeignKey() { return this.args?.foreignKey }
 
   /**
-   * @param {boolean | object} newForeignKey
+   * @param {boolean | object | undefined} newForeignKey
    * @returns {void}
    */
   setForeignKey(newForeignKey) { this.args.foreignKey = newForeignKey }
@@ -138,7 +138,7 @@ export default class TableColumn {
   getMaxLength() { return this.args?.maxLength }
 
   /**
-   * @param {number} newMaxLength
+   * @param {number | undefined} newMaxLength
    * @returns {void}
    */
   setMaxLength(newMaxLength) { this.args.maxLength = newMaxLength }
@@ -171,7 +171,7 @@ export default class TableColumn {
   getType() { return this.args?.type }
 
   /**
-   * @param {string} newType
+   * @param {string | undefined} newType
    * @returns {void}
    */
   setType(newType) { this.args.type = newType }

package/src/environment-handlers/node.js

@@ -206,8 +206,7 @@ export default class VelociousEnvironmentHandlerNode extends Base{
 
   /**
    * @param {string} filePath
-   * @template T extends import ("../migration/index.js").default
-   * @returns {Promise<T>}
+   * @returns {Promise<import("../database/migration/index.js").default>}
    */
   async requireMigration(filePath) {
     const migrationImport = await import(filePath)