velocious 1.0.95 → 1.0.96

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.95",
+  "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

@@ -149,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()
       }

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

@@ -87,27 +87,77 @@ export default class DbGenerateModel extends BaseCommand {
         }
 
         if (relationship.getType() == "belongsTo" || relationship.getType() == "hasOne") {
-          fileContent += "  /**\n"
+          let modelFilePath
 
           if (fullFilePath && await fileExists(fullFilePath)) {
-            fileContent += `   * @returns {import("../models/${fileName}.js").default}\n`
+            modelFilePath = `../models/${fileName}.js`
           } else {
-            fileContent += `   * @returns {import("velocious/src/database/record/index.js").default}\n`
+            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`
-        } else if (relationship.getType() == "hasMany") {
+
+          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)) {
-            fileContent += `   * @returns {Array<import("../models/${fileName}.js").default>}\n`
+            recordImport = `../models/${fileName}.js`
           } else {
-            fileContent += `   * @returns {Array<import("velocious/src/database/record/index.js").default>}\n`
+            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()}").loaded() }\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()}`)
         }