velocious 1.0.95 → 1.0.97

package/package.json

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

package/src/environment-handlers/node/cli/commands/test.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import BaseCommand from "../../../../cli/base-command.js"
 import TestFilesFinder from "../../../../testing/test-files-finder.js"
 import TestRunner from "../../../../testing/test-runner.js"
@@ -6,15 +8,27 @@ export default class VelociousCliCommandsTest extends BaseCommand {
   async execute() {
     this.getConfiguration().setEnvironment("test")
 
-    const directory = process.env.VELOCIOUS_TEST_DIR || this.directory()
-    const testFilesFinder = new TestFilesFinder({directory, processArgs: this.processArgs})
+    let directory
+    const directories = []
+
+    if (process.env.VELOCIOUS_TEST_DIR) {
+      directory = process.env.VELOCIOUS_TEST_DIR
+      directories.push(process.env.VELOCIOUS_TEST_DIR)
+    } else {
+      directory = this.directory()
+      directories.push(`${this.directory()}/__tests__`)
+      directories.push(`${this.directory()}/tests`)
+      directories.push(`${this.directory()}/spec`)
+    }
+
+    const testFilesFinder = new TestFilesFinder({directory, directories, processArgs: this.processArgs})
     const testFiles = await testFilesFinder.findTestFiles()
     const testRunner = new TestRunner({configuration: this.getConfiguration(), testFiles})
 
     await testRunner.prepare()
 
     if (testRunner.getTestsCount() === 0) {
-      throw new Error("No tests has been found")
+      throw new Error(`${testRunner.getTestsCount()} tests was found in ${testFiles.length} file(s)`)
     }
 
     await testRunner.run()

package/src/testing/test-files-finder.js

@@ -1,21 +1,75 @@
+// @ts-check
+
 import fs from "fs/promises"
 
+import fileExists from "../utils/file-exists.js"
+import restArgsError from "../utils/rest-args-error.js"
+
 // Incredibly complex class to find files in multiple simultanious running promises to do it as fast as possible.
 export default class TestFilesFinder {
   static IGNORED_NAMES = [".git", "node_modules"]
 
-  constructor({directory, processArgs}) {
+  /**
+   * @param {object} args
+   * @param {string} args.directory
+   * @param {string[]} args.directories
+   * @param {string[]} args.processArgs
+   */
+  constructor({directory, directories, processArgs, ...restArgs}) {
+    restArgsError(restArgs)
+
     this.directory = directory
-    this.foundFiles = []
+
+    if (directories) {
+      this.directories = directories
+    } else {
+      this.directories = [
+        `${this.directory}/__tests__`,
+        `${this.directory}/tests`,
+        `${this.directory}/spec`
+      ]
+    }
+
     this.findingCount = 0
-    this.findingPromises = {}
     this.processArgs = processArgs
+
+    /** @type {string[]} */
+    this.foundFiles = []
+
+    /** @type {Record<number, Promise<void>>} */
+    this.findingPromises = {}
+
+    /** @type {string[]} */
     this.testArgs = this.processArgs.filter((processArg, index) => index != 0)
+
+    /** @type {string[]} */
+    this.directoryArgs = []
+
+    /** @type {string[]} */
+    this.fileArgs = []
+
+    for (const testArg of this.testArgs) {
+      if (testArg.endsWith("/")) {
+        this.directoryArgs.push(testArg)
+      } else {
+        this.fileArgs.push(testArg)
+      }
+    }
   }
 
+  /**
+   * @returns {Promise<string[]>}
+   */
   async findTestFiles() {
     await this.withFindingCount(async () => {
-      await this.findTestFilesInDir(this.directory)
+      for (const directory of this.directories) {
+        console.log({directory})
+
+        if (await fileExists(directory)) {
+          console.log("Exists!")
+          await this.findTestFilesInDir(directory)
+        }
+      }
     })
 
     await this.waitForFindingPromises()
@@ -23,6 +77,9 @@ export default class TestFilesFinder {
     return this.foundFiles
   }
 
+  /**
+   * @returns {number}
+   */
   findingPromisesLength() { return Object.keys(this.findingPromises).length }
 
   async waitForFindingPromises() {
@@ -31,6 +88,9 @@ export default class TestFilesFinder {
     }
   }
 
+  /**
+   * @returns {Promise<void>}
+   */
   async waitForFindingPromisesIteration() {
     const unfinishedPromises = []
 
@@ -43,6 +103,9 @@ export default class TestFilesFinder {
     await Promise.all(unfinishedPromises)
   }
 
+  /**
+   * @param {function() : Promise<void>} callback
+   */
   withFindingCount(callback) {
     return new Promise((resolve) => {
       const findingPromise = callback()
@@ -54,11 +117,15 @@ export default class TestFilesFinder {
       findingPromise.finally(() => {
         delete this.findingPromises[findingCount]
 
-        resolve()
+        resolve(undefined)
       })
     })
   }
 
+  /**
+   * @param {string} dir
+   * @returns {Promise<void>}
+   */
   async findTestFilesInDir(dir) {
     await this.withFindingCount(async () => {
       const files = await fs.readdir(dir)
@@ -89,16 +156,32 @@ export default class TestFilesFinder {
    * @returns {boolean}
    */
   isFileMatchingRequirements(file, localPath) {
-    if (this.testArgs.length > 0) {
-      for (const testArg of this.testArgs) {
-        if (testArg == localPath) {
+    if (this.directoryArgs.length > 0) {
+      for (const directoryArg of this.directoryArgs) {
+        if (localPath.startsWith(directoryArg) && this.looksLikeTestFile(file)) {
           return true
         }
       }
-    } else if (file.match(/-(spec|test)\.(m|)js$/)) {
+    }
+
+    if (this.fileArgs.length > 0) {
+      for (const fileArg of this.fileArgs) {
+        if (fileArg == localPath) {
+          return true
+        }
+      }
+    } else if (this.looksLikeTestFile(file)) {
       return true
     }
 
     return false
   }
+
+  /**
+   * @param {string} file
+   * @returns {boolean}
+   */
+  looksLikeTestFile(file) {
+    return Boolean(file.match(/-(spec|test)\.(m|)js$/))
+  }
 }

package/src/testing/test-runner.js

@@ -26,7 +26,7 @@ export default class TestRunner {
   getConfiguration() { return this._configuration }
 
   /**
-   * @returns {Array<string>}
+   * @returns {string[]}
    */
   getTestFiles() { return this._testFiles }