velocious 1.0.97 → 1.0.99

package/eslint.config.js

@@ -20,6 +20,7 @@ export default defineConfig([
       "jsdoc/require-jsdoc": "off",
       "jsdoc/require-param": "off",
       "jsdoc/require-param-description": "off",
+      "jsdoc/require-property-description": "off",
       "jsdoc/require-returns": "off",
       "jsdoc/require-returns-description": "off"
     }

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.97",
+  "version": "1.0.99",
   "main": "index.js",
   "scripts": {
     "lint": "eslint",
@@ -34,6 +34,7 @@
     "escape-string-regexp": "^1.0.5",
     "incorporator": "^1.0.2",
     "inflection": "^3.0.0",
+    "is-plain-object": "^5.0.0",
     "pure-uuid": "^1.8.1",
     "set-state-compare": "^1.0.58",
     "sql-escape-string": "^1.1.0",

package/spec/database/connection/drivers/mysql/query-parser-spec.js

@@ -22,14 +22,14 @@ describe("database - connection - drivers - mysql - query parser", () => {
     expect(sql).toEqual("SELECT tasks.id, tasks.name FROM tasks LEFT JOIN projects ON projects.id = tasks.project_id")
   })
 
-  it("generates sql with selects, joins and orders", () => {
+  it("generates sql with selects, joins and orders with SelectTableAndColumn", () => {
     const handler = new DatabaseHandler()
     const query = new DatabaseQuery({driver: mysqlDriver, handler})
       .select([
-        new SelectTableAndColumn({tableName: "tasks", columnName: "id"}),
-        new SelectTableAndColumn({tableName: "tasks", columnName: "name"})
+        new SelectTableAndColumn("tasks", "id"),
+        new SelectTableAndColumn("tasks", "name")
       ])
-      .from(new FromTable({tableName: "tasks"}))
+      .from(new FromTable("tasks"))
       .joins("LEFT JOIN projects ON projects.id = tasks.project_id")
 
     const sql = new MysqlQueryParser({query}).toSql()

package/spec/http-server/post-spec.js

@@ -67,6 +67,7 @@ describe("HttpServer - post", {databaseCleaning: {transaction: false, truncate:
       for (let i = 0; i <= 5; i++) {
         const body = new FormData()
 
+        body.append("project[creating_user_reference]", 150123)
         body.append("project[name]", "Test create project")
 
         const response = await fetch(
@@ -84,6 +85,7 @@ describe("HttpServer - post", {databaseCleaning: {transaction: false, truncate:
 
         const createdProject = await Project.preload({translations: true}).last()
 
+        expect(createdProject.creatingUserReference()).toEqual("150123")
         expect(createdProject.name()).toEqual("Test create project")
       }
     })

package/src/application.js

@@ -1,18 +1,32 @@
-import AppRoutes from "../src/routes/app-routes.js"
-import {digs} from "diggerize"
+// @ts-check
+
+import AppRoutes from "./routes/app-routes.js"
 import {Logger} from "./logger.js"
 import HttpServer from "./http-server/index.js"
+import restArgsError from "./utils/rest-args-error.js"
+
+/**
+ * @typedef {object} HttpServerConfiguration
+ * @property {number} [port]
+ */
 
 export default class VelociousApplication {
   /**
    * @param {object} args
-   * @param {import("./http-server/index.js").default} args.httpServer
    * @param {import("./configuration.js").default} args.configuration
+   * @param {HttpServerConfiguration} [args.httpServer]
    * @param {string} args.type
    */
-  constructor({configuration, httpServer, type}) {
+  constructor({configuration, httpServer, type, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!configuration) throw new Error("configuration is required")
+
     this.configuration = configuration
-    this.httpServerConfiguration = httpServer ?? {}
+
+    /** @type {HttpServerConfiguration} */
+    this.httpServerConfiguration = httpServer ?? {port: undefined}
+
     this.logger = new Logger(this)
     this._type = type
   }
@@ -41,7 +55,11 @@ export default class VelociousApplication {
    * @returns {boolean}
    */
   isActive() {
-    return this.httpServer?.isActive()
+    if (this.httpServer) {
+      return this.httpServer?.isActive()
+    }
+
+    return false
   }
 
   /**
@@ -49,7 +67,7 @@ export default class VelociousApplication {
    * @returns {Promise<void>}
    */
   async run(callback) {
-    await this.start()
+    await this.startHttpServer()
 
     try {
       await callback()
@@ -62,7 +80,7 @@ export default class VelociousApplication {
    * @returns {Promise<void>}
    */
   async startHttpServer() {
-    const {configuration, httpServerConfiguration} = digs(this, "configuration", "httpServerConfiguration")
+    const {configuration, httpServerConfiguration} = this
     const port = httpServerConfiguration.port || 3006
 
     await this.logger.debug(`Starting server on port ${port}`)
@@ -78,7 +96,7 @@ export default class VelociousApplication {
    */
   async stop() {
     await this.logger.debug("Stopping server")
-    await this.httpServer.stop()
+    await this.httpServer?.stop()
   }
 
   /**

package/src/configuration-resolver.js

@@ -1,23 +1,36 @@
-import Configuration from "./configuration.js"
+// @ts-check
+
+import Configuration, {CurrentConfigurationNotSetError} from "./configuration.js"
 import envSense from "env-sense/src/use-env-sense.js"
 import fileExists from "./utils/file-exists.js"
 
 /**
- * @param {object} args
- * @param {string} args.directory
+ * @param {import("./configuration-types.js").ConfigurationArgsType} [args]
  * @returns {Promise<Configuration>}
  */
-export default async function configurationResolver(args = {}) {
-  if (Configuration.current(false)) {
+export default async function configurationResolver(args) {
+  let configuration
+
+  try {
+    configuration = Configuration.current()
+  } catch (error) {
+    if (error instanceof CurrentConfigurationNotSetError) {
+      // Ignore
+    } else {
+      throw error
+    }
+  }
+
+  if (configuration) {
     return Configuration.current()
   }
 
-  const directory = args.directory || process.cwd()
+  const directory = args?.directory || process.cwd()
   let configurationPrePath = `${directory}/src/config/configuration`
   const configurationPathForNode = `${configurationPrePath}.node.js`
   const configurationPathDefault = `${configurationPrePath}.js`
   const {isServer} = envSense()
-  let configuration, configurationPath
+  let configurationPath
 
   if (isServer && await fileExists(configurationPathForNode)) {
     configurationPath = configurationPathForNode
@@ -30,9 +43,15 @@ export default async function configurationResolver(args = {}) {
 
     configuration = configurationImport.default
   } catch (error) {
-    // This might happen during an "init" CLI command where we copy a sample configuration file.
-    if (!error.message.match(/^Cannot find module '(.+)\/configuration\.js'/)) {
-      throw error
+    if (error instanceof Error) {
+      // This might happen during an "init" CLI command where we copy a sample configuration file.
+      if (!error.message.match(/^Cannot find module '(.+)\/configuration\.js'/)) {
+        throw error
+      }
+    }
+
+    if (!args) {
+      throw new Error("Can't spawn a new configuration because no configuration-arguments was given")
     }
 
     configuration = new Configuration(args)

package/src/configuration-types.js

@@ -0,0 +1,44 @@
+/**
+ * @module types
+ */
+
+/**
+ * @typedef {function({request: import("./http-server/client/request.js").default, response: import("./http-server/client/response.js").default}): Promise<void>} CorsType
+ */
+
+/**
+ * @typedef {(id: string) => {default: typeof import("./initializer.js").default}} InitializersRequireContextType
+ * @typedef {InitializersRequireContextType & {
+ *   keys: () => string[],
+ *   id: string
+ * }} WebpackRequireContext
+ * @typedef {{requireContext: WebpackRequireContext}} InitializersExportType
+ * @typedef {function({configuration: import("./configuration.js").default}) : Promise<InitializersExportType>} InitializersType
+ */
+
+/**
+ * @typedef {object} DatabaseConfigurationType
+ * @property {string} [host]
+ * @property {boolean} [migrations]
+ * @property {string} [password]
+ * @property {string} [username]
+ */
+
+/**
+ * @typedef {object} ConfigurationArgsType
+ * @property {object} args
+ * @property {CorsType} [cors]
+ * @property {{[key: string]: DatabaseConfigurationType}} database
+ * @property {boolean} debug
+ * @property {string} directory
+ * @property {string} environment
+ * @property {import("./environment-handlers/base.js").default} environmentHandler
+ * @property {function({configuration: import("./configuration.js").default, type: string}) : void} initializeModels
+ * @property {InitializersType} initializers
+ * @property {string | function() : string} locale
+ * @property {string[]} locales
+ * @property {object} localeFallbacks
+ * @property {string} testing
+ */
+
+export const nothing = {}

package/src/configuration.js

@@ -1,59 +1,70 @@
+// @ts-check
+
 import {digg} from "diggerize"
 import restArgsError from "./utils/rest-args-error.js"
 import {withTrackedStack} from "./utils/with-tracked-stack.js"
 
+/** @type {{currentConfiguration: VelociousConfiguration | null}} */
+const shared = {
+  currentConfiguration: null
+}
+
+class CurrentConfigurationNotSetError extends Error {}
+
+export {CurrentConfigurationNotSetError}
+
 export default class VelociousConfiguration {
   /**
    * @returns {VelociousConfiguration}
    */
-  static current(throwError = true) {
-    if (!this.velociousConfiguration && throwError) throw new Error("A Velocious configuration hasn't been set")
+  static current() {
+    if (!shared.currentConfiguration) throw new CurrentConfigurationNotSetError("A current configuration hasn't been set")
 
-    return this.velociousConfiguration
+    return shared.currentConfiguration
   }
 
   /**
-   * @template T extends import("./environment-handlers/base.js").default
-   * @param {object} args
-   * @param {function() : void} args.cors
-   * @param {object} args.database
-   * @param {boolean} args.debug
-   * @param {string} args.directory
-   * @param {string} args.environment
-   * @param {T} args.environmentHandler
-   * @param {function() : void} args.initializeModels
-   * @param {function() : void} args.initializers
-   * @param {string} args.locale
-   * @param {object} args.localeFallbacks
-   * @param {string} args.testing
-   */
-  constructor({cors, database, debug, directory, environment, environmentHandler, initializeModels, initializers, locale, localeFallbacks, locales, testing, ...restArgs}) {
+   * @param {import("./configuration-types.js").ConfigurationArgsType} args
+   */
+  constructor({cors, database, debug = false, directory, environment, environmentHandler, initializeModels, initializers, locale, localeFallbacks, locales, testing, ...restArgs}) {
     restArgsError(restArgs)
 
     this.cors = cors
     this.database = database
-    this.databasePools = {}
     this.debug = debug
     this._environment = environment || process.env.VELOCIOUS_ENV || process.env.NODE_ENV || "development"
     this._environmentHandler = environmentHandler
     this._directory = directory
     this._initializeModels = initializeModels
-    this._initializers = initializers
     this._isInitialized = false
     this.locale = locale
     this.localeFallbacks = localeFallbacks
     this.locales = locales
-    this.modelClasses = {}
+    this._initializers = initializers
     this._testing = testing
 
+    /** @type {{[key: string]: import("./database/pool/base.js").default}} */
+    this.databasePools = {}
+
+    /** @type {{[key: string]: typeof import("./database/record/index.js").default}} */
+    this.modelClasses = {}
+
     this.getEnvironmentHandler().setConfiguration(this)
   }
 
+  /**
+   * @returns {import("./configuration-types.js").CorsType | undefined}
+   */
+  getCors() {
+    return this.cors
+  }
+
   /**
    * @returns {Record<string, any>}
    */
   getDatabaseConfiguration() {
     if (!this.database) throw new Error("No database configuration")
+
     if (!this.database[this.getEnvironment()]) {
       throw new Error(`No database configuration for environment: ${this.getEnvironment()} - ${Object.keys(this.database).join(", ")}`)
     }
@@ -68,6 +79,10 @@ export default class VelociousConfiguration {
     return Object.keys(this.getDatabaseConfiguration())
   }
 
+  /**
+   * @param {string} identifier
+   * @returns {import("./database/pool/base.js").default}
+   */
   getDatabasePool(identifier = "default") {
     if (!this.isDatabasePoolInitialized(identifier)) {
       this.initializeDatabasePool(identifier)
@@ -76,12 +91,20 @@ export default class VelociousConfiguration {
     return digg(this, "databasePools", identifier)
   }
 
+  /**
+   * @param {string} identifier
+   * @returns {import("./configuration-types.js").DatabaseConfigurationType})
+   */
   getDatabaseIdentifier(identifier) {
     if (!this.getDatabaseConfiguration()[identifier]) throw new Error(`No such database identifier configured: ${identifier}`)
 
     return this.getDatabaseConfiguration()[identifier]
   }
 
+  /**
+   * @param {string} identifier
+   * @returns {typeof import("./database/pool/base.js").default}
+   */
   getDatabasePoolType(identifier = "default") {
     const poolTypeClass = digg(this.getDatabaseIdentifier(identifier), "poolType")
 
@@ -126,8 +149,7 @@ export default class VelociousConfiguration {
   setEnvironment(newEnvironment) { this._environment = newEnvironment }
 
   /**
-   * @template T extends import("./environment-handlers/base.js").default
-   * @returns {T}
+   * @returns {import("./environment-handlers/base.js").default}
    */
   getEnvironmentHandler() {
     if (!this._environmentHandler) throw new Error("No environment handler set")
@@ -166,8 +188,7 @@ export default class VelociousConfiguration {
 
   /**
    * @param {string} name
-   * @template T extends import("./database/record/index.js").default
-   * @returns {T}
+   * @returns {typeof import("./database/record/index.js").default}
    */
   getModelClass(name) {
     const modelClass = this.modelClasses[name]
@@ -212,7 +233,7 @@ export default class VelociousConfiguration {
   /**
    * @param {object} args
    * @param {string} args.type
-   * @returns {void}
+   * @returns {Promise<void>}
    */
   async initializeModels(args = {type: "server"}) {
     if (!this._modelsInitialized) {
@@ -224,7 +245,12 @@ export default class VelociousConfiguration {
     }
   }
 
-  async initialize({type} = {}) {
+  /**
+   * @param {object} args
+   * @param {string} args.type
+   * @returns {Promise<void>}
+   */
+  async initialize({type} = {type: "undefined"}) {
     if (!this.isInitialized()) {
       this._isInitialized = true
 
@@ -249,7 +275,8 @@ export default class VelociousConfiguration {
   }
 
   /**
-   * @param {Function} modelClass
+   * @param {typeof import("./database/record/index.js").default} modelClass
+   * @returns {void}
    */
   registerModelClass(modelClass) {
     this.modelClasses[modelClass.name] = modelClass
@@ -259,10 +286,11 @@ export default class VelociousConfiguration {
    * @returns {void}
    */
   setCurrent() {
-    this.constructor.velociousConfiguration = this
+    shared.currentConfiguration = this
   }
 
   /**
+   * @param {import("./routes/index.js").default} newRoutes
    * @returns {void}
    */
   setRoutes(newRoutes) { this.routes = newRoutes }
@@ -275,7 +303,7 @@ export default class VelociousConfiguration {
 
   /**
    * @param {string} msgID
-   * @param {object} args
+   * @param {undefined | {defaultValue: string}} args
    * @returns {string}
    */
   _defaultTranslator(msgID, args) {
@@ -296,7 +324,9 @@ export default class VelociousConfiguration {
    * @returns {Promise<void>}
    */
   async withConnections(callback) {
+    /** @type {{[key: string]: import("./database/drivers/base.js").default}} */
     const dbs = {}
+
     const stack = Error().stack
     const actualCallback = async () => {
       await withTrackedStack(stack, async () => {
@@ -324,17 +354,17 @@ export default class VelociousConfiguration {
   }
 
   /**
-   * @template T extends import("./database/drivers/base.js").default
-   * @returns {Record<string, T>} A map of database connections with identifier as key
+   * @returns {Record<string, import("./database/drivers/base.js").default>} A map of database connections with identifier as key
    */
   getCurrentConnections() {
+    /** @type {{[key: string]: import("./database/drivers/base.js").default}} */
     const dbs = {}
 
     for (const identifier of this.getDatabaseIdentifiers()) {
       try {
         dbs[identifier] = this.getDatabasePool(identifier).getCurrentConnection()
       } catch (error) {
-        if (error.message == "ID hasn't been set for this async context" || error.message == "A connection hasn't been made yet") {
+        if (error instanceof Error && (error.message == "ID hasn't been set for this async context" || error.message == "A connection hasn't been made yet")) {
           // Ignore
         } else {
           throw error

package/src/database/drivers/base-column.js

@@ -1,7 +1,12 @@
+// @ts-check
+
 import TableColumn from "../table-data/table-column.js"
 import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseDriversBaseColumn {
+  /** @type {import("./base-table.js").default | undefined} */
+  table = undefined
+
   /**
    * @interface
    * @returns {boolean}
@@ -19,7 +24,7 @@ export default class VelociousDatabaseDriversBaseColumn {
 
   /**
    * @param {string} indexName
-   * @returns {Promise<import('../table-data/table-index.js').default>}
+   * @returns {Promise<import("./base-columns-index.js").default | undefined>}
    */
   async getIndexByName(indexName) {
     const indexes = await this.getIndexes()

package/src/database/drivers/base-columns-index.js

@@ -1,4 +1,6 @@
-import { digg } from "diggerize"
+// @ts-check
+
+import {digg} from "diggerize"
 
 export default class VelociousDatabaseDriversBaseColumnsIndex {
   /**
@@ -40,6 +42,14 @@ export default class VelociousDatabaseDriversBaseColumnsIndex {
     return this.table
   }
 
+  /**
+   * @interface
+   * @returns {import("../table-data/table-index.js").default}
+   */
+  getTableDataIndex() {
+    throw new Error("'getTableDataIndex' not implemented")
+  }
+
   /**
    * @returns {boolean}
    */

package/src/database/drivers/base-foreign-key.js

@@ -1,6 +1,11 @@
+// @ts-check
+
 import TableForeignKey from "../table-data/table-foreign-key.js"
 
 export default class VelociousDatabaseDriversBaseForeignKey {
+  /** @type {import("./base-table.js").default | undefined} */
+  table = undefined
+
   /**
    * @param {object} data
    */
@@ -8,6 +13,14 @@ export default class VelociousDatabaseDriversBaseForeignKey {
     this.data = data
   }
 
+  /**
+   * @interface
+   * @returns {string}
+   */
+  getColumnName() {
+    throw new Error(`'getColumnName' not implemented`)
+  }
+
   /**
    * @returns {import("./base.js").default}
    */
@@ -15,6 +28,14 @@ export default class VelociousDatabaseDriversBaseForeignKey {
     return this.getTable().getDriver()
   }
 
+  /**
+   * @interface
+   * @returns {string}
+   */
+  getName() {
+    throw new Error(`'getName' not implemented`)
+  }
+
   /**
    * @returns {import("../query-parser/options.js").default}
    */
@@ -22,6 +43,22 @@ export default class VelociousDatabaseDriversBaseForeignKey {
     return this.getDriver().options()
   }
 
+  /**
+   * @interface
+   * @returns {string}
+   */
+  getReferencedColumnName() {
+    throw new Error(`'getReferencedColumnName' not implemented`)
+  }
+
+  /**
+   * @interface
+   * @returns {string}
+   */
+  getReferencedTableName() {
+    throw new Error(`'getReferencedTableName' not implemented`)
+  }
+
   /**
    * @returns {import("./base-table.js").default}
    */
@@ -31,6 +68,14 @@ export default class VelociousDatabaseDriversBaseForeignKey {
     return this.table
   }
 
+  /**
+   * @interface
+   * @returns {string}
+   */
+  getTableName() {
+    throw new Error("'getTableName' not implemented")
+  }
+
   /**
    * @returns {TableForeignKey}
    */

package/src/database/drivers/base-table.js

@@ -1,10 +1,15 @@
+// @ts-check
+
 import {digg} from "diggerize"
 import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseDriversBaseTable {
+  /** @type {import("./base.js").default | undefined} */
+  driver = undefined
+
   /**
    * @param {string} columnName
-   * @returns {import("./base-column.js").default}
+   * @returns {Promise<import("./base-column.js").default | undefined>}
    */
   async getColumnByName(columnName) {
     const columnes = await this.getColumns()
@@ -30,6 +35,22 @@ export default class VelociousDatabaseDriversBaseTable {
     return this.driver
   }
 
+  /**
+   * @interface
+   * @returns {Promise<import("./base-foreign-key.js").default[]>}
+   */
+  getForeignKeys() {
+    throw new Error("'getForeignKeys' not implemented")
+  }
+
+  /**
+   * @interface
+   * @returns {Promise<import("./base-columns-index.js").default[]>}
+   */
+  getIndexes() {
+    throw new Error("'getForeignKeys' not implemented")
+  }
+
   /**
    * @interface
    * @returns {string}
@@ -86,6 +107,7 @@ export default class VelociousDatabaseDriversBaseTable {
   }
 
   /**
+   * @param {{cascade: boolean}} [args]
    * @returns {Promise<Array<Record<string, any>>>}
    */
   async truncate(args) {
@@ -102,6 +124,6 @@ export default class VelociousDatabaseDriversBaseTable {
       }
     }
 
-    await this.getDriver().query(sql)
+    return await this.getDriver().query(sql)
   }
 }