velocious 1.0.93 → 1.0.95

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

@@ -25,20 +25,37 @@ export default class TableData {
    */
   addColumn(name, args = {}) {
     if (name instanceof TableColumn) {
-      this._columns.push(name)
+      this.getColumns().push(name)
     } else {
       const column = new TableColumn(name, args)
 
-      this._columns.push(column)
+      this.getColumns().push(column)
     }
   }
 
+  /**
+   * @returns {TableColumn[]}
+   */
   getColumns() { return this._columns }
 
+  /**
+   * @param {import("./table-foreign-key.js").default} foreignKey
+   */
   addForeignKey(foreignKey) { this._foreignKeys.push(foreignKey) }
+
+  /**
+   * @returns {import("./table-foreign-key.js").default[]}
+   */
   getForeignKeys() { return this._foreignKeys }
 
+  /**
+   * @param {TableIndex} index
+   */
   addIndex(index) { this._indexes.push(index) }
+
+  /**
+   * @returns {TableIndex[]}
+   */
   getIndexes() { return this._indexes }
 
   /**
@@ -56,34 +73,209 @@ export default class TableData {
    * @returns {boolean}
    */
   getIfNotExists() { return this.args.ifNotExists }
+
+  /**
+   * @returns {TableReference[]}
+   */
   getReferences() { return this._references }
 
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   bigint(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "bigint"}, args)) }
+
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   blob(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "blob"}, args)) }
+
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   boolean(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "boolean"}, args)) }
+
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   datetime(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "datetime"}, args)) }
+
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   integer(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "integer"}, args)) }
+
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
+  json(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "json"}, args)) }
+
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   tinyint(name, args = {}) { this.addColumn(name, Object.assign({isNewColumn: true, type: "tinyint"}, args)) }
 
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   references(name, args = {}) {
     const columnName = `${name}_id`
     const reference = new TableReference(name, args)
-    const columnArgs = Object.assign({isNewColumn: true, type: "bigint"}, args)
+    const {polymorphic, ...restArgs} = args
+    const columnArgs = Object.assign({isNewColumn: true, type: "bigint"}, restArgs)
     const column = new TableColumn(columnName, columnArgs)
     const index = new TableIndex([column])
 
-    this._columns.push(column)
-    this._indexes.push(index)
-    this._references.push(reference)
+    this.getColumns().push(column)
+    this.getIndexes().push(index)
+    this.getReferences().push(reference)
+
+    if (polymorphic) {
+      const typeColumnName = `${name}_type`
+      const typeColumn = new TableColumn(typeColumnName, {isNewColumn: true, type: "string"})
+
+      this.getColumns().push(typeColumn)
+    }
   }
 
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   string(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "string"}, args)) }
+
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   text(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "text"}, args)) }
 
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   timestamps(args = {}) {
     this.datetime("created_at", args)
     this.datetime("updated_at", args)
   }
 
+  /**
+   * @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 {number} args.maxLength
+   * @param {boolean} args.null
+   * @param {boolean} args.primaryKey
+   * @returns {void}
+   */
   uuid(name, args) { this.addColumn(name, Object.assign({isNewColumn: true, type: "uuid"}, args)) }
 }

package/src/environment-handlers/base.js

@@ -1,4 +1,60 @@
 export default class VelociousEnvironmentHandlerBase {
+  /**
+   * @param {import("../cli/base-command.js").default} _command
+   * @returns {Promise<void>}
+   */
+  async cliCommandsGenerateBaseModels(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("cliCommandsGenerateBaseModels not implemented")
+  }
+
+  /**
+   * @param {import("../cli/base-command.js").default} _command
+   * @returns {Promise<void>}
+   */
+  async cliCommandsInit(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("cliCommandsInit not implemented")
+  }
+
+  /**
+   * @param {import("../cli/base-command.js").default} _command
+   * @returns {Promise<void>}
+   */
+  async cliCommandsMigrationGenerate(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("cliCommandsMigrationGenerate not implemented")
+  }
+
+  /**
+   * @param {import("../cli/base-command.js").default} _command
+   * @returns {Promise<void>}
+   */
+  async cliCommandsMigrationDestroy(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("cliCommandsMigrationDestroy not implemented")
+  }
+
+  /**
+   * @param {import("../cli/base-command.js").default} _command
+   * @returns {Promise<void>}
+   */
+  async cliCommandsGenerateModel(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("cliCommandsGenerateModel not implemented")
+  }
+
+  /**
+   * @param {import("../cli/base-command.js").default} _command
+   * @returns {Promise<void>}
+   */
+  async cliCommandsServer(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("cliCommandsServer not implemented")
+  }
+
+  /**
+   * @param {import("../cli/base-command.js").default} _command
+   * @returns {Promise<void>}
+   */
+  async cliCommandsTest(_command) { // eslint-disable-line no-unused-vars
+    throw new Error("cliCommandsTest not implemented")
+  }
+
   /**
    * @interface
    */
@@ -34,6 +90,8 @@ export default class VelociousEnvironmentHandlerBase {
   async importApplicationRoutes() { throw new Error("importApplicationRoutes not implemented") }
 
   /**
+   * @param {object} args
+   * @param {string[]} args.commandParts
    * @interface
    */
   async requireCommand({commandParts}) { throw new Error("requireCommand not implemented") } // eslint-disable-line no-unused-vars

package/src/environment-handlers/browser.js

@@ -15,30 +15,6 @@ export default class VelociousEnvironmentsHandlerBrowser extends Base {
     this.migrationsRequireContextCallback = migrationsRequireContextCallback
   }
 
-  async cliCommandsInit(_command) { // eslint-disable-line no-unused-vars
-    throw new Error("Unsupported on browser")
-  }
-
-  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")
-  }
-
-  async cliCommandsServer(_command) { // eslint-disable-line no-unused-vars
-    throw new Error("Unsupported on browser")
-  }
-
-  async cliCommandsTest(_command) { // eslint-disable-line no-unused-vars
-    throw new Error("Unsupported on browser")
-  }
-
   /**
    * @returns {object}
    */

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

@@ -0,0 +1,123 @@
+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() {
+    await this.getConfiguration().initializeModels()
+
+    const modelsDir = `${process.cwd()}/src/model-bases`
+    const modelClasses = this.getConfiguration().getModelClasses()
+
+    if (!await fileExists(modelsDir)) {
+      await fs.mkdir(modelsDir, {recursive: true})
+    }
+
+    for (const modelClassName in modelClasses) {
+      const modelClass = modelClasses[modelClassName]
+      const modelName = inflection.dasherize(modelClassName)
+      const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))
+      const modelBaseFileName = `${inflection.dasherize(inflection.underscore(modelName))}.js`
+      const modelPath = `${modelsDir}/${modelBaseFileName}`
+
+      console.log(`create src/model-bases/${modelBaseFileName}`)
+
+      let fileContent = `import Record from "velocious/src/database/record/index.js"\n\n`
+
+      fileContent += `export default class ${modelNameCamelized}Base extends Record {\n`
+
+      const columns = await modelClass._getTable().getColumns()
+      let methodsCount = 0
+
+      for (const column of columns) {
+        const camelizedColumnName = inflection.camelize(column.getName(), true)
+        const camelizedColumnNameBigFirst = inflection.camelize(column.getName())
+        let jsdocType
+
+        if (column.getType() == "varchar") {
+          jsdocType = "string"
+        } else if (["bigint", "int", "integer", "smallint"].includes(column.getType())) {
+          jsdocType = "number"
+        } else if (["date", "datetime"].includes(column.getType())) {
+          jsdocType = "Date"
+        }
+
+        if (methodsCount > 0) {
+          fileContent += "\n"
+        }
+
+        if (jsdocType) {
+          fileContent += "  /**\n"
+          fileContent += `   * @returns {${jsdocType}}\n`
+          fileContent += "   */\n"
+        }
+
+        fileContent += `  ${camelizedColumnName}() { return this.readAttribute("${camelizedColumnName}") }\n\n`
+
+        if (jsdocType) {
+          fileContent += "  /**\n"
+          fileContent += `   * @param {${jsdocType}} newValue\n`
+          fileContent += "   * @returns {void}\n"
+          fileContent += "   */\n"
+        }
+
+        fileContent += `  set${camelizedColumnNameBigFirst}(newValue) { return this._setColumnAttribute("${camelizedColumnName}", newValue) }\n\n`
+
+        fileContent += "  /**\n"
+        fileContent += "   * @returns {boolean}\n"
+        fileContent += "   */\n"
+        fileContent += `  has${camelizedColumnNameBigFirst}() { return this._hasAttribute(this.${camelizedColumnName}()) }\n`
+
+        methodsCount++
+      }
+
+      for (const relationship of modelClass.getRelationships()) {
+        let 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`
+        }
+
+        if (methodsCount > 0) {
+          fileContent += "\n"
+        }
+
+        if (relationship.getType() == "belongsTo" || relationship.getType() == "hasOne") {
+          fileContent += "  /**\n"
+
+          if (fullFilePath && await fileExists(fullFilePath)) {
+            fileContent += `   * @returns {import("../models/${fileName}.js").default}\n`
+          } else {
+            fileContent += `   * @returns {import("velocious/src/database/record/index.js").default}\n`
+          }
+
+          fileContent += "   */\n"
+          fileContent += `  ${relationship.getRelationshipName()}() { return this.getRelationshipByName("${relationship.getRelationshipName()}").loaded() }\n`
+        } else if (relationship.getType() == "hasMany") {
+          fileContent += "  /**\n"
+
+          if (fullFilePath && await fileExists(fullFilePath)) {
+            fileContent += `   * @returns {Array<import("../models/${fileName}.js").default>}\n`
+          } else {
+            fileContent += `   * @returns {Array<import("velocious/src/database/record/index.js").default>}\n`
+          }
+
+          fileContent += "   */\n"
+          fileContent += `  ${relationship.getRelationshipName()}() { return this.getRelationshipByName("${relationship.getRelationshipName()}").loaded() }\n`
+        } else {
+          throw new Error(`Unknown relationship type: ${relationship.getType()}`)
+        }
+
+        methodsCount++
+      }
+
+      fileContent += "}\n"
+
+      await fs.writeFile(modelPath, fileContent)
+    }
+  }
+}

package/src/environment-handlers/node.js

@@ -1,6 +1,7 @@
 import Base from "./base.js"
 import CliCommandsDestroyMigration from "./node/cli/commands/destroy/migration.js"
 import CliCommandsInit from "./node/cli/commands/init.js"
+import CliCommandsGenerateBaseModels from "./node/cli/commands/generate/base-models.js"
 import CliCommandsGenerateMigration from "./node/cli/commands/generate/migration.js"
 import CliCommandsGenerateModel from "./node/cli/commands/generate/model.js"
 import CliCommandsServer from "./node/cli/commands/server.js"
@@ -60,7 +61,11 @@ export default class VelociousEnvironmentHandlerNode extends Base{
     return await this.forwardCommand(command, CliCommandsDestroyMigration)
   }
 
-  async cliCommandsModelGenerate(command) {
+  async cliCommandsGenerateBaseModels(command) {
+    return await this.forwardCommand(command, CliCommandsGenerateBaseModels)
+  }
+
+  async cliCommandsGenerateModel(command) {
     return await this.forwardCommand(command, CliCommandsGenerateModel)
   }
 

package/src/initializer.js

@@ -23,6 +23,10 @@ export default class VelociousInitializer {
    */
   getType() { return this._type }
 
+  /**
+   * @interface
+   * @returns {Promise<void>}
+   */
   run() {
     throw new Error(`'run' hasn't been implemented on ${this.constructor.name})`)
   }

package/src/logger.js

@@ -1,5 +1,10 @@
 import Configuration from "./configuration.js"
+import restArgsError from "./utils/rest-args-error.js"
 
+/**
+ * @param {string} message
+ * @returns {Promise<void>}
+ */
 function consoleLog(message) {
   return new Promise((resolve) => {
     if (process.stdout) {
@@ -10,6 +15,10 @@ function consoleLog(message) {
   })
 }
 
+/**
+ * @param {string} message
+ * @returns {Promise<void>}
+ */
 function consoleError(message) {
   return new Promise((resolve) => {
     if (process.stderr) {
@@ -20,6 +29,10 @@ function consoleError(message) {
   })
 }
 
+/**
+ * @param {string} message
+ * @returns {Promise<void>}
+ */
 function consoleWarn(message) {
   return new Promise((resolve) => {
     if (process.stderr) {
@@ -30,6 +43,9 @@ function consoleWarn(message) {
   })
 }
 
+/**
+ * @param {Array} messages
+ */
 function functionOrMessages(messages) {
   if (messages.length === 1 && typeof messages[0] == "function") {
     messages = messages[0]()
@@ -38,6 +54,11 @@ function functionOrMessages(messages) {
   return messages
 }
 
+/**
+ * Converts multiple message parts into a single string.
+ * @param {...any} messages - Parts to combine into a message
+ * @returns {string}
+ */
 function messagesToMessage(...messages) {
   let message = ""
 
@@ -59,8 +80,15 @@ function messagesToMessage(...messages) {
 }
 
 class Logger {
-  constructor(object, args) {
-    this._debug = args?.debug
+  /**
+   * @param {any} object
+   * @param {object} args
+   * @param {boolean} args.debug
+   */
+  constructor(object, {debug, ...restArgs} = {}) {
+    restArgsError(restArgs)
+
+    this._debug = debug
 
     if (typeof object == "string") {
       this._subject = object
@@ -85,20 +113,40 @@ class Logger {
     return this._configuration
   }
 
+  /**
+   * @param {...Parameters<typeof consoleLog>} messages - forwarded args
+   */
   async debug(...messages) {
     if (this._debug || this.getConfiguration()?.debug) {
       await this.log(...messages)
     }
   }
 
+  /**
+   * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
+   */
   async log(...messages) {
     await consoleLog(messagesToMessage(this._subject, ...functionOrMessages(messages)))
   }
 
+  /**
+   * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
+   */
   async error(...messages) {
     await consoleError(messagesToMessage(this._subject, ...functionOrMessages(messages)))
   }
 
+  /**
+   * @param {boolean} newValue
+   * @returns {void}
+   */
+  setDebug(newValue) {
+    this._debug = newValue
+  }
+
+  /**
+   * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
+   */
   async warn(...messages) {
     await consoleWarn(messagesToMessage(this._subject, ...functionOrMessages(messages)))
   }
@@ -106,6 +154,10 @@ class Logger {
 
 export {Logger}
 
+/**
+ * @param {any} object
+ * @param {...Parameters<typeof functionOrMessages>} messages - forwarded args
+ */
 export default async function logger(object, ...messages) {
   const className = object.constructor.name
   const configuration = object.configuration || Configuration.current()

package/src/routes/base-route.js

@@ -11,16 +11,28 @@ export function initBaseRoute() {
   VelociousBaseRoute = class VelociousBaseRoute {
     routes = []
 
-    get(name, args) {
-      const route = new GetRoute({name, args})
+    /**
+     * @param {string} name
+     */
+    get(name) {
+      const route = new GetRoute({name})
 
       this.routes.push(route)
     }
 
+    /**
+     * @interface
+     * @param {string} _path
+     */
     matchWithPath(_path) { // eslint-disable-line no-unused-vars
       throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
     }
 
+    /**
+     * @param {string} name
+     * @param {function(NamespaceRoute) : void} callback
+     * @returns {void}
+     */
     namespace(name, callback) {
       const route = new NamespaceRoute({name})
 
@@ -31,12 +43,21 @@ export function initBaseRoute() {
       }
     }
 
-    post(name, args) {
-      const route = new PostRoute({name, args})
+    /**
+     * @param {string} name
+     * @returns {void}
+     */
+    post(name) {
+      const route = new PostRoute({name})
 
       this.routes.push(route)
     }
 
+    /**
+     * @param {string} name
+     * @param {function(ResourceRoute) : void} callback
+     * @returns {void}
+     */
     resources(name, callback) {
       const route = new ResourceRoute({name})