velocious 1.0.106 → 1.0.108

package/src/database/drivers/sqlite/sql/alter-table.js

@@ -23,7 +23,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
   }
 
   /**
-   * @returns {string[]}
+   * @returns {Promise<string[]>}
    */
   async toSQLs() {
     const {tableData} = this
@@ -108,7 +108,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
       tableDataColumn.setForeignKey(foreignKey)
     }
 
-    const createNewTableSQL = this.getDriver().createTableSql(newTableData)
+    const createNewTableSQL = await this.getDriver().createTableSql(newTableData)
     const insertSQL = `INSERT INTO ${options.quoteTableName(tempTableName)} (${newColumnsSQL}) SELECT ${oldColumnsSQL} FROM ${options.quoteTableName(tableName)}`
     const dropTableSQLs = `DROP TABLE ${options.quoteTableName(tableName)}`
     const renameTableSQL = `ALTER TABLE ${options.quoteTableName(tempTableName)} RENAME TO ${options.quoteTableName(tableName)}`
@@ -141,7 +141,7 @@ export default class VelociousDatabaseConnectionDriversSqliteSqlAlterTable exten
         tableName,
         unique: actualTableIndex.getUnique()
       }
-      const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSQLs()
+      const createIndexSQLs = await new CreateIndexBase(createIndexArgs).toSQLs()
 
       for (const createIndexSQL of createIndexSQLs) {
         sqls.push(createIndexSQL)

package/src/database/migration/index.js

@@ -135,7 +135,7 @@ export default class VelociousDatabaseMigration {
       },
       args
     )
-    const sqls = this.getDriver().createIndexSQLs(createIndexArgs)
+    const sqls = await this.getDriver().createIndexSQLs(createIndexArgs)
 
     for (const sql of sqls) {
       await this.getDriver().query(sql)
@@ -246,14 +246,25 @@ export default class VelociousDatabaseMigration {
    * @property {CreateTableIdArgsType | false} [id]
    */
   /**
+   * @typedef {(TableData) => void} CreateTableCallbackType
+   */
+  /**
+   * @overload
+   * @param {string} tableName
+   * @param {CreateTableCallbackType} callback
+   * @returns {Promise<void>}
+   */
+  /**
+   * @overload
    * @param {string} tableName
-   * @param {function(TableData) : void} arg1
+   * @param {CreateTableArgsType} args
+   * @param {CreateTableCallbackType} callback
    * @returns {Promise<void>}
    */
   /**
    * @param {string} tableName
-   * @param {CreateTableArgsType} arg1
-   * @param {function(TableData) : void} arg2
+   * @param {CreateTableArgsType | CreateTableCallbackType} arg1
+   * @param {CreateTableCallbackType | undefined} [arg2]
    * @returns {Promise<void>}
    */
   async createTable(tableName, arg1, arg2) {
@@ -297,7 +308,7 @@ export default class VelociousDatabaseMigration {
       callback(tableData)
     }
 
-    const sqls = this.getDriver().createTableSql(tableData)
+    const sqls = await this.getDriver().createTableSql(tableData)
 
     for (const sql of sqls) {
       await this._db.query(sql)

package/src/database/migrator.js

@@ -56,7 +56,7 @@ export default class VelociousDatabaseMigrator {
 
       schemaMigrationsTable.string("version", {null: false, primaryKey: true})
 
-      const createSchemaMigrationsTableSqls = db.createTableSql(schemaMigrationsTable)
+      const createSchemaMigrationsTableSqls = await db.createTableSql(schemaMigrationsTable)
 
       for (const createSchemaMigrationsTableSql of createSchemaMigrationsTableSqls) {
         await db.query(createSchemaMigrationsTableSql)
@@ -64,6 +64,10 @@ export default class VelociousDatabaseMigrator {
     }
   }
 
+  async dropDatabase() {
+    throw new Error("Not implemented yet")
+  }
+
   /**
    * @param {string} dbIdentifier
    * @param {number} version

package/src/database/pool/base-methods-forward.js

@@ -28,16 +28,12 @@ export default function baseMethodsForward(PoolBase) {
   ]
 
   for (const forwardMethod of forwardMethods) {
-    // @ts-expect-error
     PoolBase.prototype[forwardMethod] = function(...args) {
       const connection = this.getCurrentConnection()
-
-      // @ts-expect-error
       const connectionMethod = connection[forwardMethod]
 
       if (!connectionMethod) throw new Error(`${forwardMethod} isn't defined on driver`)
 
-        // @ts-expect-error
       return connection[forwardMethod](...args)
     }
   }

package/src/database/query/alter-table-base.js

@@ -20,9 +20,9 @@ export default class VelociousDatabaseQueryAlterTableBase extends QueryBase {
   }
 
   /**
-   * @returns {string[]}
+   * @returns {Promise<string[]>}
    */
-  toSQLs() {
+  async toSQLs() {
     const databaseType = this.getDriver().getType()
     const sqls = []
     const {tableData} = this

package/src/database/query/base.js

@@ -38,9 +38,9 @@ export default class VelociousDatabaseQueryBase {
 
   /**
    * @abstract
-   * @returns {string[]}
+   * @returns {Promise<string[]>}
    */
-  toSQLs() {
+  async toSQLs() {
     throw new Error("'toSQLs' wasn't implemented")
   }
 }

package/src/database/query/create-index-base.js

@@ -52,9 +52,9 @@ export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
   }
 
   /**
-   * @returns {string[]}
+   * @returns {Promise<string[]>}
    */
-  toSQLs() {
+  async toSQLs() {
     const databaseType = this.getDriver().getType()
     const indexName = this.name || this.generateIndexName()
     const options = this.getOptions()

package/src/database/query/create-table-base.js

@@ -24,9 +24,9 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
   }
 
   /**
-   * @returns {string[]}
+   * @returns {Promise<string[]>}
    */
-  toSql() {
+  async toSql() {
     const databaseType = this.getDatabaseType()
     const driver = this.getDriver()
     const options = this.getOptions()
@@ -128,7 +128,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
           tableName: tableData.getName(),
           unique: index.getUnique()
         }
-        const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSQLs()
+        const createIndexSQLs = await new CreateIndexBase(createIndexArgs).toSQLs()
 
         for (const createIndexSQL of createIndexSQLs) {
           sqls.push(createIndexSQL)
@@ -156,7 +156,7 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
           tableName: tableData.getName(),
           unique
         }
-        const createIndexSQLs = new CreateIndexBase(createIndexArgs).toSQLs()
+        const createIndexSQLs = await new CreateIndexBase(createIndexArgs).toSQLs()
 
         for (const createIndexSQL of createIndexSQLs) {
           sqls.push(createIndexSQL)

package/src/database/query/drop-table-base.js

@@ -22,9 +22,9 @@ export default class VelociousDatabaseQueryDropTableBase extends QueryBase {
   }
 
   /**
-   * @returns {string[]}
+   * @returns {Promise<string[]>}
    */
-  toSQLs() {
+  async toSQLs() {
     const databaseType = this.getDatabaseType()
     const options = this.getOptions()
     const {cascade, ifExists, tableName} = this

package/src/database/query/index.js

@@ -2,8 +2,8 @@
 
 /**
  * @typedef {{[key: string]: boolean | NestedPreloadRecord }} NestedPreloadRecord
- * @typedef {string|SelectPlain} SelectArgumentType
- * @typedef {object|string} WhereArgumentType
+ * @typedef {string | string[] | import("./select-base.js").default | import("./select-base.js").default[]} SelectArgumentType
+ * @typedef {object | string} WhereArgumentType
  */
 
 import FromPlain from "./from-plain.js"

package/src/database/record/index.js

@@ -181,29 +181,20 @@ class VelociousDatabaseRecord {
       actualData.className = inflection.camelize(inflection.singularize(relationshipName))
     }
 
-    /** @type {Record<string, (this: VelociousDatabaseRecord) => unknown>} */
-    const proto = /** @type {any} */ (this.prototype);
-
     let relationship
 
     if (actualData.type == "belongsTo") {
       relationship = new BelongsToRelationship(actualData)
 
-      proto[relationshipName] = function() {
+      this.prototype[relationshipName] = function() {
         const relationship = this.getRelationshipByName(relationshipName)
 
         return relationship.loaded()
       }
 
-      // @ts-expect-error
-      proto[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
-        // @ts-expect-error
+      this.prototype[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
         const instanceRelationship = this.getRelationshipByName(relationshipName)
-
-        // @ts-expect-error
         const record = instanceRelationship.build(attributes)
-
-        // @ts-expect-error
         const inverseOf = instanceRelationship.getRelationship().getInverseOf()
 
         if (inverseOf) {
@@ -223,51 +214,40 @@ class VelociousDatabaseRecord {
         return record
       }
 
-      proto[`load${inflection.camelize(relationshipName)}`] = async function() {
+      this.prototype[`load${inflection.camelize(relationshipName)}`] = async function() {
         await this.getRelationshipByName(relationshipName).load()
       }
 
-      // @ts-expect-error
-      proto[`set${inflection.camelize(relationshipName)}`] = function(model) {
-        // @ts-expect-error
+      this.prototype[`set${inflection.camelize(relationshipName)}`] = function(model) {
         const relationship = this.getRelationshipByName(relationshipName)
 
-        // @ts-expect-error
         relationship.setLoaded(model)
-
-        // @ts-expect-error
         relationship.setDirty(true)
       }
     } else if (actualData.type == "hasMany") {
       relationship = new HasManyRelationship(actualData)
 
-      proto[relationshipName] = function() {
-        return this.getRelationshipByName(relationshipName)
+      this.prototype[relationshipName] = function() {
+        return /** @type {import("./instance-relationships/has-many.js").default} */ (this.getRelationshipByName(relationshipName))
       }
 
-      proto[`${relationshipName}Loaded`] = function() {
+      this.prototype[`${relationshipName}Loaded`] = function() {
         return this.getRelationshipByName(relationshipName).loaded()
       }
 
-      proto[`load${inflection.camelize(relationshipName)}`] = async function() {
+      this.prototype[`load${inflection.camelize(relationshipName)}`] = async function() {
         await this.getRelationshipByName(relationshipName).load()
       }
     } else if (actualData.type == "hasOne") {
       relationship = new HasOneRelationship(actualData)
 
-      proto[relationshipName] = function() {
+      this.prototype[relationshipName] = function() {
         return this.getRelationshipByName(relationshipName).loaded()
       }
 
-      // @ts-expect-error
-      proto[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
-        // @ts-expect-error
+      this.prototype[`build${inflection.camelize(relationshipName)}`] = function(attributes) {
         const instanceRelationship = this.getRelationshipByName(relationshipName)
-
-        // @ts-expect-error
         const record = instanceRelationship.build(attributes)
-
-        // @ts-expect-error
         const inverseOf = instanceRelationship.getRelationship().getInverseOf()
 
         if (inverseOf) {
@@ -280,7 +260,7 @@ class VelociousDatabaseRecord {
         return record
       }
 
-      proto[`load${inflection.camelize(relationshipName)}`] = async function() {
+      this.prototype[`load${inflection.camelize(relationshipName)}`] = async function() {
         await this.getRelationshipByName(relationshipName).load()
       }
     } else {
@@ -477,19 +457,15 @@ class VelociousDatabaseRecord {
       attributeNameToColumnName[camelizedColumnName] = column.getName()
       columnNameToAttributeName[column.getName()] = camelizedColumnName
 
-      // @ts-expect-error
       this.prototype[camelizedColumnName] = function() {
         return this.readAttribute(camelizedColumnName)
       }
 
-      // @ts-expect-error
       this.prototype[`set${camelizedColumnNameBigFirst}`] = function(newValue) {
         return this._setColumnAttribute(camelizedColumnName, newValue)
       }
 
-      // @ts-expect-error
       this.prototype[`has${camelizedColumnNameBigFirst}`] = function() {
-        // @ts-expect-error
         let value = this[camelizedColumnName]()
 
         return this._hasAttribute(value)
@@ -537,16 +513,13 @@ class VelociousDatabaseRecord {
         const nameCamelized = inflection.camelize(name)
         const setterMethodName = `set${nameCamelized}`
 
-        // @ts-expect-error
         this.prototype[name] = function getTranslatedAttribute() {
           const locale = this._getConfiguration().getLocale()
 
           return this._getTranslatedAttributeWithFallback(name, locale)
         }
 
-        // @ts-expect-error
         this.prototype[`has${nameCamelized}`] = function hasTranslatedAttribute() {
-          // @ts-expect-error
           const candidate = this[name]
 
           if (typeof candidate == "function") {
@@ -558,7 +531,6 @@ class VelociousDatabaseRecord {
           }
         }
 
-        // @ts-expect-error
         this.prototype[setterMethodName] = function setTranslatedAttribute(newValue) {
           const locale = this._getConfiguration().getLocale()
 
@@ -571,19 +543,15 @@ class VelociousDatabaseRecord {
           const setterMethodNameLocalized = `${setterMethodName}${localeCamelized}`
           const hasMethodNameLocalized = `has${inflection.camelize(name)}${localeCamelized}`
 
-          // @ts-expect-error
           this.prototype[getterMethodNameLocalized] = function getTranslatedAttributeWithLocale() {
             return this._getTranslatedAttribute(name, locale)
           }
 
-          // @ts-expect-error
           this.prototype[setterMethodNameLocalized] = function setTranslatedAttributeWithLocale(newValue) {
             return this._setTranslatedAttribute(name, locale, newValue)
           }
 
-          // @ts-expect-error
           this.prototype[hasMethodNameLocalized] = function hasTranslatedAttribute() {
-            // @ts-expect-error
             const candidate = this[getterMethodNameLocalized]
 
             if (typeof candidate == "function") {
@@ -646,7 +614,6 @@ class VelociousDatabaseRecord {
     if (!this.getModelClass().isInitialized()) throw new Error(`${this.constructor.name} model isn't initialized yet`)
     if (!(setterName in this)) throw new Error(`No such setter method: ${this.constructor.name}#${setterName}`)
 
-    // @ts-expect-error
     this[setterName](newValue)
   }
 

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

@@ -17,10 +17,10 @@ export default class VelociousDatabaseRecordBaseInstanceRelationship {
 
   /**
    * @abstract
-   * @param {import("../index.js").default[]} records
+   * @param {import("../index.js").default[] | import("../index.js").default} models
    * @returns {void}
    */
-  addToLoaded(records) { // eslint-disable-line no-unused-vars
+  addToLoaded(models) { // eslint-disable-line no-unused-vars
     throw new Error("addToLoaded not implemented")
   }
 

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

@@ -78,7 +78,7 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
   }
 
   /**
-   * @param {import("../index.js").default[]} models
+   * @param {import("../index.js").default[] | import("../index.js").default} models
    * @returns {void}
    */
   addToLoaded(models) {

package/src/database/use-database.js

@@ -1,5 +1,6 @@
 // @ts-check
 
+// @ts-expect-error
 import React from "react"
 import useEnvSense from "env-sense/src/use-env-sense.js"
 

package/src/environment-handlers/base.js

@@ -122,10 +122,10 @@ export default class VelociousEnvironmentHandlerBase {
   importTestingConfigPath() { throw new Error(`'importTestingConfigPath' not implemented`) }
 
   /**
+   * @abstract
    * @param {object} args
    * @param {string[]} args.commandParts
-   * @returns {Promise<import ("../cli/base-command.js").default>}
-   * @abstract
+   * @returns {Promise<typeof import ("../cli/base-command.js").default>}
    */
   async requireCommand({commandParts}) { throw new Error("'requireCommand' not implemented") } // eslint-disable-line no-unused-vars
 

package/src/environment-handlers/browser.js

@@ -1,12 +1,33 @@
 import Base from "./base.js"
-import {digg} from "diggerize"
 import * as inflection from "inflection"
 import restArgsError from "../utils/rest-args-error.js"
 
+/**
+ * @typedef {(id: string) => {default: typeof import("../database/migration/index.js").default}} MigrationsRequireContextIDFunctionType
+ * @typedef {MigrationsRequireContextIDFunctionType & {
+ *   keys: () => string[],
+ *   id: string
+ * }} MigrationsRequireContextType
+ */
+
+/**
+ * @typedef {(id: string) => {default: typeof import("../cli/base-command.js").default}} CommandsRequireContextIDFunctionType
+ * @typedef {CommandsRequireContextIDFunctionType & {
+ *   keys: () => string[],
+ *   id: string
+ * }} CommandsRequireContextType
+ */
+
 export default class VelociousEnvironmentsHandlerBrowser extends Base {
+  /** @type {CommandsRequireContextType | undefined} */
+  findCommandsRequireContextResult = undefined
+
+  /** @type {MigrationsRequireContextType | undefined} */
+  _migrationsRequireContextResult = undefined
+
   /**
    * @param {object} args
-   * @param {function() : void} args.migrationsRequireContextCallback
+   * @param {() => Promise<MigrationsRequireContextType>} [args.migrationsRequireContextCallback]
    */
   constructor({migrationsRequireContextCallback, ...restArgs} = {}) {
     super()
@@ -16,29 +37,33 @@ export default class VelociousEnvironmentsHandlerBrowser extends Base {
   }
 
   /**
-   * @returns {object}
+   * @returns {Promise<MigrationsRequireContextType>}
    */
-  migrationsRequireContext() {
-    const migrationsRequireContextCallback = digg(this, "migrationsRequireContextCallback")
+  async migrationsRequireContext() {
+    const {migrationsRequireContextCallback} = this
 
     if (!migrationsRequireContextCallback) throw new Error("migrationsRequireContextCallback is required")
 
-    this._migrationsRequireContextResult ||= migrationsRequireContextCallback()
+    this._migrationsRequireContextResult ||= await migrationsRequireContextCallback()
 
     return this._migrationsRequireContextResult
   }
 
   /**
-   * @returns {Promise<Array<{name: string, file: string}>>}
+   * @returns {Promise<Array<import("./base.js").CommandFileObjectType>>}
    */
-  findCommands() {
+  async findCommands() {
     this._findCommandsResult = this._actualFindCommands()
 
     return this._findCommandsResult
   }
 
+  /**
+   * @returns {CommandsRequireContextType}
+   */
   _findCommandsRequireContext() {
-    this.findCommandsRequireContextResult ||= require.context("../cli/commands", true, /\.js$/)
+    // @ts-expect-error
+    this.findCommandsRequireContextResult ||= /** @type {CommandsRequireContextType} */ (require.context("../cli/commands", true, /\.js$/))
 
     return this.findCommandsRequireContextResult
   }
@@ -65,13 +90,11 @@ export default class VelociousEnvironmentsHandlerBrowser extends Base {
   }
 
   /**
-   * @param {Array<string>} commandParts
-   * @template T extends import("./base-command.js").default
-   * @returns {Promise<T>}
+   * @param {object} args
+   * @param {Array<string>} args.commandParts
+   * @returns {Promise<typeof import("../cli/base-command.js").default>}
    */
-  async requireCommand({commandParts, ...restArgs}) {
-    restArgsError(restArgs)
-
+  async requireCommand({commandParts}) {
     let filePath = "."
 
     for (let commandPart of commandParts) {
@@ -109,7 +132,7 @@ export default class VelociousEnvironmentsHandlerBrowser extends Base {
   }
 
   /**
-   * @returns {Promise<Array<{name: string, file: string}>>}
+   * @returns {Promise<Array<import("./base.js").MigrationObjectType>>}
    */
   async findMigrations() {
     const migrationsRequireContext = await this.migrationsRequireContext()
@@ -150,8 +173,7 @@ export default class VelociousEnvironmentsHandlerBrowser extends Base {
 
   /**
    * @param {string} filePath
-   * @template T extends import("../migration/index.js").default
-   * @returns {Promise<T>}
+   * @returns {Promise<typeof import("../database/migration/index.js").default>}
    */
   requireMigration = async (filePath) => {
     if (!filePath) throw new Error("filePath is required")

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

@@ -1,9 +1,13 @@
 import BaseCommand from "../../../../../cli/base-command.js"
 import fs from "fs/promises"
 
+/**
+ * @typedef {{destroyed: string[]}} DestroyMigrationResult
+ */
+
 export default class DbDestroyMigration extends BaseCommand {
   /**
-   * @returns {Promise<void>}
+   * @returns {Promise<void | DestroyMigrationResult>}
    */
   async execute() {
     const migrationName = this.processArgs[1]

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

@@ -29,14 +29,19 @@ export default class DbGenerateModel extends BaseCommand {
       console.log(`create src/model-bases/${modelBaseFileName}`)
 
       let fileContent = ""
+      let velociousPath = "velocious"
 
       if (devMode) {
-        fileContent += `import Record from "../../../../src/database/record/index.js"\n\n`
+        velociousPath = "../../../.."
+        fileContent += `import DatabaseRecord from "../../../../src/database/record/index.js"\n\n`
+        // /** @type {import("./instance-relationships/has-many.js").default} */
       } else {
-        fileContent += `import Record from "velocious/src/database/record/index.js"\n\n`
+        fileContent += `import DatabaseRecord from "velocious/src/database/record/index.js"\n\n`
       }
 
-      fileContent += `export default class ${modelNameCamelized}Base extends Record {\n`
+      const hasManyRelationFilePath = `${velociousPath}/src/database/record/instance-relationships/has-many.js`
+
+      fileContent += `export default class ${modelNameCamelized}Base extends DatabaseRecord {\n`
 
       const columns = await modelClass._getTable().getColumns()
       let methodsCount = 0
@@ -135,13 +140,15 @@ export default class DbGenerateModel extends BaseCommand {
       }
 
       for (const relationship of modelClass.getRelationships()) {
-        let fileName, fullFilePath
+        let baseFilePath, baseFullFilePath, fileName, fullFilePath
 
         if (relationship.getPolymorphic()) {
           fileName = "velocious/src/database/record/index.js"
         } else {
           fileName = inflection.dasherize(inflection.underscore(relationship.getTargetModelClass().name))
           fullFilePath = `src/models/${fileName}.js`
+          baseFilePath = `../model-bases/${fileName}.js`
+          baseFullFilePath = `src/model-bases/${fileName}.js`
         }
 
         if (methodsCount > 0) {
@@ -153,6 +160,8 @@ export default class DbGenerateModel extends BaseCommand {
 
           if (fullFilePath && await fileExists(fullFilePath)) {
             modelFilePath = `../models/${fileName}.js`
+          } else if (baseFullFilePath && await fileExists(baseFullFilePath)) {
+            modelFilePath = baseFilePath
           } else {
             modelFilePath = "velocious/src/database/record/index.js"
           }
@@ -160,7 +169,7 @@ export default class DbGenerateModel extends BaseCommand {
           fileContent += "  /**\n"
           fileContent += `   * @returns {import("${modelFilePath}").default}\n`
           fileContent += "   */\n"
-          fileContent += `  ${relationship.getRelationshipName()}() { return this.getRelationshipByName("${relationship.getRelationshipName()}").loaded() }\n`
+          fileContent += `  ${relationship.getRelationshipName()}() { return /** @type {import("${modelFilePath}").default} */ (this.getRelationshipByName("${relationship.getRelationshipName()}").loaded()) }\n`
 
           fileContent += "\n"
           fileContent += "  /**\n"
@@ -189,20 +198,22 @@ export default class DbGenerateModel extends BaseCommand {
 
           if (fullFilePath && await fileExists(fullFilePath)) {
             recordImport = `../models/${fileName}.js`
+          } else if (baseFullFilePath && await fileExists(baseFullFilePath)) {
+            recordImport = `../model-bases/${fileName}.js`
           } else {
-            recordImport = "velocious/src/database/record/index.js"
+            recordImport = `${velociousPath}/src/database/record/index.js`
           }
 
           fileContent += "  /**\n"
-          fileContent += `   * @returns {import("velocious/src/database/query/index.js").default<import("${recordImport}").default>}\n`
+          fileContent += `   * @returns {import("${hasManyRelationFilePath}").default}\n`
           fileContent += "   */\n"
-          fileContent += `  ${relationship.getRelationshipName()}() { return this.getRelationshipByName("${relationship.getRelationshipName()}") }\n`
+          fileContent += `  ${relationship.getRelationshipName()}() { return /** @type {import("${hasManyRelationFilePath}").default} */ (this.getRelationshipByName("${relationship.getRelationshipName()}")) }\n`
 
           fileContent += "\n"
           fileContent += "  /**\n"
           fileContent += `   * @returns {Array<import("${recordImport}").default>}\n`
           fileContent += "   */\n"
-          fileContent += `  ${relationship.getRelationshipName()}Loaded() { return this.getRelationshipByName("${relationship.getRelationshipName()}").loaded() }\n`
+          fileContent += `  ${relationship.getRelationshipName()}Loaded() { return /** @type {Array<import("${recordImport}").default>} */ (this.getRelationshipByName("${relationship.getRelationshipName()}").loaded()) }\n`
 
           fileContent += "\n"
           fileContent += "  /**\n"

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

@@ -4,9 +4,13 @@ import fs from "fs/promises"
 import * as inflection from "inflection"
 import strftime from "strftime"
 
+/**
+ * @typedef {{date: Date, migrationContent: string, migrationName: string, migrationNameCamelized: string, migrationNumber: string, migrationPath: string}} DbGenerateMigrationReturnType
+ */
+
 export default class DbGenerateMigration extends BaseCommand {
   /**
-   * @returns {Promise<void>}
+   * @returns {Promise<void | DbGenerateMigrationReturnType>}
    */
   async execute() {
     const migrationName = this.processArgs[1]