velocious 1.0.92 → 1.0.94

package/src/database/query-parser/group-parser.js

@@ -1,24 +1,37 @@
-import {digs} from "diggerize"
+// @ts-check
+
+import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryParserFromParser {
-  constructor({pretty, query}) {
+  /**
+   * @param {object} args
+   * @param {boolean} args.pretty
+   * @param {import("../query/index.js").default} args.query
+   */
+  constructor({pretty, query, ...restArgs}) {
+    restArgsError(restArgs)
+
     this.pretty = pretty
     this.query = query
   }
 
+  /**
+   * @returns {string}
+   */
   toSql() {
-    const {pretty, query} = digs(this, "pretty", "query")
+    const {pretty, query} = this
+    const groups = query.getGroups()
 
-    if (query._groups.length == 0) {
+    if (groups.length == 0) {
       return ""
     }
 
     let sql = " GROUP BY"
 
-    for (const groupKey in query._groups) {
-      const group = query._groups[groupKey]
+    for (const groupKey in groups) {
+      const group = groups[groupKey]
 
-      if (groupKey > 0) {
+      if (typeof groupKey == "number" && groupKey > 0) {
         sql += ","
       }
 
@@ -31,7 +44,7 @@ export default class VelociousDatabaseQueryParserFromParser {
       if (typeof group == "string") {
         sql += group
       } else {
-        sql += group.toSql()
+        throw new Error(`Unsupported group type: ${typeof group}`)
       }
     }
 

package/src/database/record/index.js

@@ -306,6 +306,7 @@ class VelociousDatabaseRecord {
    * Adds a has-many-relationship to the model class.
    * @param {string} relationshipName The name of the relationship (e.g. "posts")
    * @param {object} options The options for the relationship (e.g. {className: "Post"})
+   * @returns {void}
    */
   static hasMany(relationshipName, options = {}) {
     return this._defineRelationship(relationshipName, Object.assign({type: "hasMany"}, options))
@@ -315,6 +316,7 @@ class VelociousDatabaseRecord {
    * Adds a has-one-relationship to the model class.
    * @param {string} relationshipName The name of the relationship (e.g. "post")
    * @param {object} options The options for the relationship (e.g. {className: "Post"})
+   * @returns {void}
    */
   static hasOne(relationshipName, options = {}) {
     return this._defineRelationship(relationshipName, Object.assign({type: "hasOne"}, options))
@@ -526,6 +528,9 @@ class VelociousDatabaseRecord {
     return this._columnNames
   }
 
+  /**
+   * @returns {import("../drivers/base-table.js").default}
+   */
   static _getTable() {
     if (!this._table) throw new Error(`${this.name} hasn't been initialized yet`)
 

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

@@ -1,7 +1,22 @@
 import restArgsError from "../../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseRecordBaseRelationship {
-  constructor({className, configuration, dependent, foreignKey, inverseOf, klass, modelClass, primaryKey = "id", relationshipName, through, type, ...restArgs}) { // eslint-disable-line no-unused-vars
+  /**
+   * @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
     restArgsError(restArgs)
 
     if (!modelClass) throw new Error(`'modelClass' wasn't given for ${relationshipName}`)
@@ -14,6 +29,7 @@ export default class VelociousDatabaseRecordBaseRelationship {
     this._inverseOf
     this.klass = klass
     this.modelClass = modelClass
+    this._polymorphic = polymorphic
     this._primaryKey = primaryKey
     this.relationshipName = relationshipName
     this.through = through
@@ -42,8 +58,7 @@ export default class VelociousDatabaseRecordBaseRelationship {
   }
 
   /**
-   * @template T extends import("../index.js").default
-   * @returns {typeof T}
+   * @returns {typeof import("../index.js").default}
    */
   getModelClass() { return this.modelClass }
 

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,80 @@
+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} 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++
+      }
+
+      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})`)
   }