velocious 1.0.94 → 1.0.96

package/package.json

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

package/src/database/query/index.js

@@ -15,37 +15,51 @@ import restArgsError from "../../utils/rest-args-error.js"
  * @typedef {Record<string, boolean|NestedPreloadRecord>} NestedPreloadRecord
  */
 
+/**
+ * A generic query over some model type.
+ */
 export default class VelociousDatabaseQuery {
   /**
    * @param {object} args
-   * @template {import("../drivers/base.js").default} Tdriver
-   * @param {Tdriver} args.driver
-   * @template {import("./from-base.js").default} TfromBase
-   * @param {TfromBase[]} args.froms
-   * @param {string[]} args.groups
-   * @template {import("./join-base.js").default} TjoinBase
-   * @param {TjoinBase[]} args.joins
+   * @param {import("../drivers/base.js").default} args.driver
+   * @param {Array<import("./from-base.js").default>} [args.froms]
+   * @param {string[]} [args.groups]
+   * @param {Array<import("./join-base.js").default>} [args.joins]
    * @param {import("../handler.js").default} args.handler
-   * @param {number} args.limit
-   * @template {import("../record/index.js").default} Trecord
-   * @param {typeof Trecord} args.modelClass
-   * @param {number} args.offset
-   * @template {import("./order-basejs").default} TorderBase
-   * @param {TorderBase[]} args.orders
-   * @param {number} args.page
+   * @param {number | null} [args.limit]
+   * @param {typeof import("../record/index.js").default} args.modelClass
+   * @param {number | null} [args.offset]
+   * @param {Array<import("./order-base.js").default>} [args.orders]
+   * @param {number | null} [args.page]
    * @param {number} args.perPage
-   * @param {NestedPreloadRecord} args.preload
-   * @param {Record<string, Array<string>>} args.selects
-   * @template {import("./where-base.js").default} TwhereBase
-   * @param {TwhereBase[]} args.wheres
+   * @param {NestedPreloadRecord} [args.preload]
+   * @param {Array<import("./select-base.js").default>} [args.selects]
+   * @param {Array<import("./where-base.js").default>} [args.wheres]
    */
-  constructor({driver, froms = [], groups = [], joins = [], handler, limit = null, modelClass, offset = null, orders = [], page = null, perPage, preload = {}, selects = [], wheres = [], ...restArgs}) {
+  constructor({
+    driver,
+    froms = [],
+    groups = [],
+    joins = [],
+    handler,
+    limit = null,
+    modelClass,
+    offset = null,
+    orders = [],
+    page = null,
+    perPage,
+    preload = {},
+    selects = [],
+    wheres = [],
+    ...restArgs
+  }) {
     if (!driver) throw new Error("No driver given to query")
     if (!handler) throw new Error("No handler given to query")
 
     restArgsError(restArgs)
 
     this.driver = driver
+
     this.handler = handler
     this.logger = new Logger(this)
     this.modelClass = modelClass
@@ -147,6 +161,11 @@ export default class VelociousDatabaseQuery {
    */
   getOptions() { return this.driver.options() }
 
+  /**
+   * @returns {Array<import("./select-base.js").default>}
+   */
+  getSelects() { return this._selects }
+
   /**
    * @returns {Promise<void>}
    */
@@ -160,7 +179,7 @@ export default class VelociousDatabaseQuery {
 
   /**
    * @param {number|string} recordId
-   * @returns {Promise<InstanceType<this["modelClass"]>>}
+   * @returns {Promise<import("../record/index.js").default>}
    */
   async find(recordId) {
     const conditions = {}
@@ -179,7 +198,7 @@ export default class VelociousDatabaseQuery {
 
   /**
    * @param {object} conditions
-   * @returns {Promise<InstanceType<this["modelClass"]>>}
+   * @returns {Promise<import("../record/index.js").default|null>}
    */
   async findBy(conditions) {
     const newConditions = {}
@@ -195,7 +214,7 @@ export default class VelociousDatabaseQuery {
 
   /**
    * @param {...Parameters<this["findOrInitializeBy"]>} args
-   * @returns {Promise<InstanceType<this["modelClass"]>>}
+   * @returns {Promise<import("../record/index.js").default>}
    */
   async findOrCreateBy(...args) {
     const record = await this.findOrInitializeBy(...args)
@@ -209,7 +228,7 @@ export default class VelociousDatabaseQuery {
 
   /**
    * @param {object} conditions
-   * @returns {Promise<InstanceType<this["modelClass"]>>}
+   * @returns {Promise<import("../record/index.js").default>}
    */
   async findByOrFail(conditions) {
     const newConditions = {}
@@ -232,7 +251,7 @@ export default class VelociousDatabaseQuery {
   /**
    * @param {object} conditions
    * @param {function() : void} callback
-   * @returns {Promise<InstanceType<this["modelClass"]>>}
+   * @returns {Promise<import("../record/index.js").default>}
    */
   async findOrInitializeBy(conditions, callback) {
     const record = await this.findBy(conditions)
@@ -249,7 +268,7 @@ export default class VelociousDatabaseQuery {
   }
 
   /**
-   * @returns {Promise<InstanceType<this["modelClass"]>>}
+   * @returns {Promise<import("../record/index.js").default>}
    */
   async first() {
     const newQuery = this.clone().limit(1).reorder(`${this.driver.quoteTable(this.modelClass.tableName())}.${this.driver.quoteColumn(this.modelClass.orderableColumn())}`)
@@ -298,7 +317,7 @@ export default class VelociousDatabaseQuery {
   }
 
   /**
-   * @returns {Promise<InstanceType<this["modelClass"]>>}
+   * @returns {Promise<import("../record/index.js").default>}
    */
   async last() {
     const primaryKey = this.modelClass.primaryKey()
@@ -435,7 +454,7 @@ export default class VelociousDatabaseQuery {
 
   /**
    * Converts query results to array of model instances
-   * @returns {Promise<Array<InstanceType<this["modelClass"]>>>}
+   * @returns {Promise<Array<import("../record/index.js").default>>}
    */
   async toArray() {
     const models = []

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

@@ -1,7 +1,15 @@
 import {digs} from "diggerize"
+import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQueryParserSelectParser {
-  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
   }
@@ -34,7 +42,7 @@ export default class VelociousDatabaseQueryParserSelectParser {
       }
     }
 
-    if (query._selects.length == 0) {
+    if (query.getSelects().length == 0) {
       if (query.modelClass) {
         sql += `${query.modelClass.connection().quoteTable(query.modelClass.tableName())}.*`
       } else {

package/src/database/record/index.js

@@ -44,8 +44,7 @@ class ValidationError extends Error {
 
 class VelociousDatabaseRecord {
   /**
-   * @template T extends import("./validators/base.js").default
-   * @returns {Record<string, T>}
+   * @returns {Record<string, import("./validators/base.js").default>}
    */
   static validatorTypes() {
     if (!this._validatorTypes) this._validatorTypes = {}
@@ -55,16 +54,14 @@ class VelociousDatabaseRecord {
 
   /**
    * @param {string} name
-   * @template T extends import("./validators/base.js").default
-   * @param {T} validatorClass
+   * @param {import("./validators/base.js").default} validatorClass
    */
   static registerValidatorType(name, validatorClass) {
     this.validatorTypes()[name] = validatorClass
   }
 
   /**
-   * @template T extends import("./validators/base.js").default
-   * @returns {T}
+   * @returns {import("./validators/base.js").default}
    */
   static getValidatorType(validatorName) {
     if (!(validatorName in this.validatorTypes())) throw new Error(`Validator type ${validatorName} not found`)
@@ -152,6 +149,10 @@ class VelociousDatabaseRecord {
         return this.getRelationshipByName(relationshipName)
       }
 
+      this.prototype[`${relationshipName}Loaded`] = function() {
+        return this.getRelationshipByName(relationshipName).loaded()
+      }
+
       this.prototype[`load${inflection.camelize(relationshipName)}`] = async function() {
         await this.getRelationshipByName(relationshipName).load()
       }
@@ -189,8 +190,7 @@ class VelociousDatabaseRecord {
   }
 
   /**
-   * @template T extends import("./relationships/index.js").default
-   * @returns {T}
+   * @returns {import("./relationships/base.js").default}
    */
   static getRelationshipByName(relationshipName) {
     if (!this._relationships) this._relationships = {}
@@ -203,7 +203,7 @@ class VelociousDatabaseRecord {
   }
 
   /**
-   * @returns {Array}
+   * @returns {Array<import("./relationships/base.js").default>}
    */
   static getRelationships() {
     if (this._relationships) return Object.values(this._relationships)
@@ -269,7 +269,7 @@ class VelociousDatabaseRecord {
   }
 
   /**
-   * @param {object} attributes
+   * @param {Record<string, any>} attributes
    * @returns {Promise<InstanceType<typeof this>>}
    */
   static async create(attributes) {
@@ -1050,7 +1050,7 @@ class VelociousDatabaseRecord {
 
   /**
    * Assigns the given attributes to the record.
-   * @param {object} attributesToAssign
+   * @param {Record<string, any>} attributesToAssign
    * @returns {void}
    */
   assign(attributesToAssign) {

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

@@ -67,6 +67,13 @@ export default class VelociousDatabaseRecordBaseRelationship {
    */
   getRelationshipName() { return this.relationshipName }
 
+  /**
+   * @returns {boolean}
+   */
+  getPolymorphic() {
+    return this._polymorphic
+  }
+
   /**
    * @returns {string} The name of the foreign key, e.g. "id" etc.
    */
@@ -78,11 +85,12 @@ export default class VelociousDatabaseRecordBaseRelationship {
   getType() { return this.type }
 
   /**
-   * @template T extends import("../index.js").default
-   * @returns {typeof T} 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} 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.className) {
+    if (this.getPolymorphic()) {
+      return null
+    } else if (this.className) {
       return this.modelClass._getConfiguration().getModelClass(this.className)
     } else if (this.klass) {
       return this.klass

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

@@ -25,7 +25,7 @@ export default class DbGenerateModel extends BaseCommand {
 
       let fileContent = `import Record from "velocious/src/database/record/index.js"\n\n`
 
-      fileContent += `export default class ${modelNameCamelized} extends Record {\n`
+      fileContent += `export default class ${modelNameCamelized}Base extends Record {\n`
 
       const columns = await modelClass._getTable().getColumns()
       let methodsCount = 0
@@ -72,6 +72,99 @@ export default class DbGenerateModel extends BaseCommand {
         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") {
+          let modelFilePath
+
+          if (fullFilePath && await fileExists(fullFilePath)) {
+            modelFilePath = `../models/${fileName}.js`
+          } else {
+            modelFilePath = "velocious/src/database/record/index.js"
+          }
+
+          fileContent += "  /**\n"
+          fileContent += "   * @interface\n"
+          fileContent += `   * @returns {import("${modelFilePath}").default}\n`
+          fileContent += "   */\n"
+          fileContent += `  ${relationship.getRelationshipName()}() { return this.getRelationshipByName("${relationship.getRelationshipName()}").loaded() }\n`
+
+          fileContent += "\n"
+          fileContent += "  /**\n"
+          fileContent += "   * @interface\n"
+          fileContent += `   * @returns {import("${modelFilePath}").default}\n`
+          fileContent += "   */\n"
+          fileContent += `  build${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`
+
+          fileContent += "\n"
+          fileContent += "  /**\n"
+          fileContent += "   * @interface\n"
+          fileContent += "   * @returns {Promise<void>}\n"
+          fileContent += "   */\n"
+          fileContent += `  load${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`
+
+          fileContent += "\n"
+          fileContent += "  /**\n"
+          fileContent += "   * @interface\n"
+          fileContent += `   * @param {import("${modelFilePath}").default} newModel\n`
+          fileContent += `   * @returns {void}\n`
+          fileContent += "   */\n"
+          fileContent += `  set${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`
+        } else if (relationship.getType() == "hasMany") {
+          let recordImport
+
+          if (fullFilePath && await fileExists(fullFilePath)) {
+            recordImport = `../models/${fileName}.js`
+          } else {
+            recordImport = "velocious/src/database/record/index.js"
+          }
+
+          fileContent += "  /**\n"
+          fileContent += "   * @interface\n"
+          fileContent += `   * @returns {import("velocious/src/database/query/index.js").default<import("${recordImport}").default>}\n`
+          fileContent += "   */\n"
+          fileContent += `  ${relationship.getRelationshipName()}() { return this.getRelationshipByName("${relationship.getRelationshipName()}") }\n`
+
+          fileContent += "\n"
+          fileContent += "  /**\n"
+          fileContent += "   * @interface\n"
+          fileContent += `   * @returns {Array<import("${recordImport}").default>}\n`
+          fileContent += "   */\n"
+          fileContent += `  ${relationship.getRelationshipName()}Loaded() { return this.getRelationshipByName("${relationship.getRelationshipName()}").loaded() }\n`
+
+          fileContent += "\n"
+          fileContent += "  /**\n"
+          fileContent += "   * @interface\n"
+          fileContent += "   * @returns {Promise<void>}\n"
+          fileContent += "   */\n"
+          fileContent += `  load${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`
+
+          fileContent += "\n"
+          fileContent += "  /**\n"
+          fileContent += "   * @interface\n"
+          fileContent += `   * @param {Array<import("${recordImport}").default>} newModels\n`
+          fileContent += "   * @returns {void>}\n"
+          fileContent += "   */\n"
+          fileContent += `  set${inflection.camelize(relationship.getRelationshipName())}() { throw new Error("Not implemented") }\n`
+        } else {
+          throw new Error(`Unknown relationship type: ${relationship.getType()}`)
+        }
+
+        methodsCount++
+      }
+
       fileContent += "}\n"
 
       await fs.writeFile(modelPath, fileContent)