velocious 1.0.85 → 1.0.86

package/src/cli/commands/db/reset.js

@@ -1,26 +1,22 @@
 import BaseCommand from "../../base-command.js"
-import FilesFinder from "../../../database/migrator/files-finder.js"
+import {digg} from "diggerize"
 import Migrator from "../../../database/migrator.js"
 
 export default class DbReset extends BaseCommand {
   async execute() {
-    const environment = this.configuration.getEnvironment()
+    const environment = this.getConfiguration().getEnvironment()
 
     if (environment != "development" && environment != "test") {
       throw new Error(`This command should only be executed on development and test environments and not: ${environment}`)
     }
 
-    const projectPath = this.configuration.getDirectory()
-    const migrationsPath = `${projectPath}/src/database/migrations`
-    const filesFinder = new FilesFinder({path: migrationsPath})
-    const files = await filesFinder.findFiles()
+    const migrations = await this.getEnvironmentHandler().findMigrations()
+    const migrator = new Migrator({configuration: this.getConfiguration()})
 
-    this.migrator = new Migrator({configuration: this.configuration})
-
-    await this.configuration.ensureConnections(async () => {
-      await this.migrator.reset()
-      await this.migrator.prepare()
-      await this.migrator.migrateFiles(files, async (importPath) => await import(importPath))
+    await this.getConfiguration().ensureConnections(async () => {
+      await migrator.reset()
+      await migrator.prepare()
+      await migrator.migrateFiles(migrations, digg(this.getEnvironmentHandler(), "requireMigration"))
     })
   }
 }

package/src/cli/commands/db/rollback.js

@@ -0,0 +1,15 @@
+import BaseCommand from "../../base-command.js"
+import {digg} from "diggerize"
+import Migrator from "../../../database/migrator.js"
+
+export default class DbRollback extends BaseCommand {
+  async execute() {
+    const migrations = await this.getEnvironmentHandler().findMigrations()
+    const migrator = new Migrator({configuration: this.getConfiguration()})
+
+    await this.getConfiguration().ensureConnections(async () => {
+      await migrator.prepare()
+      await migrator.rollback(migrations, digg(this.getEnvironmentHandler(), "requireMigration"))
+    })
+  }
+}

package/src/cli/commands/destroy/migration.js

@@ -1,10 +1,10 @@
 import BaseCommand from "../../base-command.js"
-import fs from "node:fs/promises"
+import fs from "fs/promises"
 
 export default class DbDestroyMigration extends BaseCommand {
   async execute() {
     const migrationName = this.processArgs[1]
-    const migrationDir = `${this.configuration.getDirectory()}/src/database/migrations`
+    const migrationDir = `${this.getConfiguration().getDirectory()}/src/database/migrations`
     const migrationFiles = await fs.readdir(migrationDir)
     const destroyed = []
 

package/src/cli/commands/generate/migration.js

@@ -1,8 +1,6 @@
 import BaseCommand from "../../base-command.js"
-import {dirname} from "path"
-import {fileURLToPath} from "url"
 import fileExists from "../../../utils/file-exists.js"
-import fs from "node:fs/promises"
+import fs from "fs/promises"
 import * as inflection from "inflection"
 import strftime from "strftime"
 
@@ -13,9 +11,8 @@ export default class DbGenerateMigration extends BaseCommand {
     const date = new Date()
     const migrationNumber = strftime("%Y%m%d%H%M%S")
     const migrationFileName = `${migrationNumber}-${migrationName}.js`
-    const __filename = fileURLToPath(import.meta.url)
-    const __dirname = dirname(__filename)
-    const templateFilePath = `${__dirname}/../../../templates/generate-migration.js`
+    const velociousPath = await this.getEnvironmentHandler().getVelociousPath()
+    const templateFilePath = `${velociousPath}/src/templates/generate-migration.js`
     const migrationContentBuffer = await fs.readFile(templateFilePath)
     const migrationContent = migrationContentBuffer.toString().replaceAll("__MIGRATION_NAME__", migrationNameCamelized)
     const migrationDir = `${process.cwd()}/src/database/migrations`

package/src/cli/commands/generate/model.js

@@ -1,8 +1,6 @@
 import BaseCommand from "../../base-command.js"
-import {dirname} from "path"
-import {fileURLToPath} from "url"
 import fileExists from "../../../utils/file-exists.js"
-import fs from "node:fs/promises"
+import fs from "fs/promises"
 import * as inflection from "inflection"
 
 export default class DbGenerateModel extends BaseCommand {
@@ -11,9 +9,8 @@ export default class DbGenerateModel extends BaseCommand {
     const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))
     const date = new Date()
     const modelFileName = `${inflection.dasherize(inflection.underscore(modelName))}.js`
-    const __filename = fileURLToPath(`${import.meta.url}/../../..`)
-    const __dirname = dirname(__filename)
-    const templateFilePath = `${__dirname}/templates/generate-model.js`
+    const velociousPath = await this.getEnvironmentHandler().getVelociousPath()
+    const templateFilePath = `${velociousPath}/src/templates/generate-model.js`
     const modelContentBuffer = await fs.readFile(templateFilePath)
     const modelContent = modelContentBuffer.toString().replaceAll("__MODEL_NAME__", modelNameCamelized)
     const modelsDir = `${process.cwd()}/src/models`

package/src/cli/commands/init.js

@@ -1,22 +1,19 @@
 import BaseCommand from "../base-command.js"
-import {dirname} from "path"
 import fileExists from "../../utils/file-exists.js"
-import {fileURLToPath} from "url"
-import fs from "node:fs/promises"
+import fs from "fs/promises"
 
 export default class VelociousCliCommandsInit extends BaseCommand {
   async execute() {
-    const __filename = fileURLToPath(`${import.meta.url}/../../..`)
-    const velocipusPath = dirname(__filename)
-    const projectPath = this.configuration?.getDirectory() || process.cwd()
+    const velociousPath = await this.getEnvironmentHandler().getVelociousPath()
+    const projectPath = this.getConfiguration()?.getDirectory() || process.cwd()
     const projectConfigPath = `${projectPath}/src/config`
     const fileMappings = [
       {
-        source: `${velocipusPath}/src/templates/configuration.js`,
+        source: `${velociousPath}/src/templates/configuration.js`,
         target: `${projectConfigPath}/configuration.js`
       },
       {
-        source: `${velocipusPath}/src/templates/routes.js`,
+        source: `${velociousPath}/src/templates/routes.js`,
         target: `${projectConfigPath}/routes.js`
       }
     ]

package/src/cli/commands/server.js

@@ -3,7 +3,7 @@ import BaseCommand from "../base-command.js"
 
 export default class VelociousCliCommandsServer extends BaseCommand{
   async execute() {
-    this.databasePool = this.configuration.getDatabasePool()
+    this.databasePool = this.getConfiguration().getDatabasePool()
     this.newConfiguration = Object.assign({}, this.databasePool.getConfiguration())
     this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
 
@@ -13,14 +13,14 @@ export default class VelociousCliCommandsServer extends BaseCommand{
     const host = parsedProcessArgs.h || parsedProcessArgs.host || "127.0.0.1"
     const port = parsedProcessArgs.p || parsedProcessArgs.port || 3006
     const application = new Application({
-      configuration: this.configuration,
+      configuration: this.getConfiguration(),
       httpServer: {
         host,
         port
       },
       type: "server"
     })
-    const environment = this.configuration.getEnvironment()
+    const environment = this.getConfiguration().getEnvironment()
 
     await application.initialize()
     await application.startHttpServer()

package/src/cli/commands/test.js

@@ -9,7 +9,7 @@ export default class VelociousCliCommandsTest extends BaseCommand {
     const directory = process.env.VELOCIOUS_TEST_DIR || this.directory()
     const testFilesFinder = new TestFilesFinder({directory, processArgs: this.processArgs})
     const testFiles = await testFilesFinder.findTestFiles()
-    const testRunner = new TestRunner({configuration: this.configuration, testFiles})
+    const testRunner = new TestRunner({configuration: this.getConfiguration(), testFiles})
 
     await testRunner.prepare()
 

package/src/cli/index.js

@@ -1,67 +1,29 @@
-import {dirname} from "path"
-import {fileURLToPath} from "url"
-import fs from "fs/promises"
-
-import configurationResolver from "../configuration-resolver.js"
-import fileExists from "../utils/file-exists.js"
-
 export default class VelociousCli {
   constructor(args = {}) {
+    if (!args.configuration) throw new Error("configuration argument is required")
+
     this.args = args
+    this.configuration = args.configuration
+
+    this.environmentHandler = args.configuration.getEnvironmentHandler()
+    this.environmentHandler.setArgs(args)
+    this.environmentHandler.setConfiguration(args.configuration)
   }
 
   async execute() {
     const commandParts = this.args.processArgs[0].split(":")
-    const filePaths = []
-    const basePath = await this.getBasePath()
-    const commandsPath = `${basePath}/src/cli/commands`
-    let filePath = commandsPath
+    const parsedCommandParts = []
 
     for (let commandPart of commandParts) {
       if (commandPart == "d") commandPart = "destroy"
       if (commandPart == "g") commandPart = "generate"
       if (commandPart == "s") commandPart = "server"
 
-      filePath += `/${commandPart}`
-    }
-
-    filePaths.push(`${filePath}/index.js`)
-    filePath += ".js"
-    filePaths.push(filePath)
-
-    let fileFound
-
-    for (const aFilePath of filePaths) {
-      if (await fileExists(aFilePath)) {
-        fileFound = aFilePath
-        break
-      }
-    }
-
-    if (!fileFound) {
-      const possibleCommands = []
-      const commandFiles = fs.glob(`${commandsPath}/**/*.js`)
-
-      for await (const aFilePath of commandFiles) {
-        const aFilePathParts = aFilePath.split("/")
-        const lastPart = aFilePathParts[aFilePathParts.length - 1]
-
-        if (lastPart == "index.js") {
-          possibleCommands.push(aFilePathParts[aFilePathParts.length - 2])
-        } else {
-          possibleCommands.push(lastPart.replace(".js", ""))
-        }
-      }
-
-      throw new Error(`Unknown command: ${this.args.processArgs[0]} which should have been one of: ${possibleCommands.sort().join(", ")}`)
+      parsedCommandParts.push(commandPart)
     }
 
-    const commandClassImport = await import(fileFound)
-    const CommandClass = commandClassImport.default
-
-    await this.loadConfiguration()
-
-    const commandInstance = new CommandClass(this.args)
+    const CommandClass = await this.environmentHandler.requireCommand({commandParts: parsedCommandParts})
+    const commandInstance = new CommandClass({args: this.args, environmentHandler: this.environmentHandler})
 
     if (commandInstance.initialize) {
       await commandInstance.initialize()
@@ -70,18 +32,8 @@ export default class VelociousCli {
     return await commandInstance.execute()
   }
 
-  async getBasePath() {
-    const __filename = fileURLToPath(import.meta.url)
-    const basePath = await fs.realpath(`${dirname(__filename)}/../..`)
-
-    return basePath
-  }
-
-  async loadConfiguration() {
-    this.configuration = await configurationResolver({directory: this.args.directory})
-    this.configuration.setCurrent()
-    this.args.configuration = this.configuration
-  }
-
-  getConfiguration() { return this.args.configuration }
+  /**
+   * @returns {import("../configuration.js").default} configuration
+   */
+  getConfiguration() { return this.configuration }
 }

package/src/cli/use-browser-cli.js

@@ -0,0 +1,25 @@
+import React from "react"
+import BrowserCli from "./browser-cli.js"
+import restArgsError from "../utils/rest-args-error.js"
+
+const shared = {}
+
+/**
+ * @param {object} args
+ * @param {import("../configuration.js").default} args.configuration
+ * @returns {Promise<BrowserCli>} browserCli
+ */
+export default function velociousUseBrowserCli({configuration, ...restArgs}) {
+  const browserCli = React.useMemo(async () => {
+    if (!shared.browserCli) {
+      shared.browserCli = new BrowserCli({configuration})
+      shared.browserCli.enable()
+    }
+
+    return shared.browserCli
+  })
+
+  restArgsError(restArgs)
+
+  return browserCli
+}

package/src/configuration-resolver.js

@@ -2,7 +2,7 @@ import Configuration from "./configuration.js"
 import envSense from "env-sense/src/use-env-sense.js"
 import fileExists from "./utils/file-exists.js"
 
-const configurationResolver = async (args) => {
+const configurationResolver = async (args = {}) => {
   if (Configuration.current(false)) {
     return Configuration.current()
   }

package/src/configuration.js

@@ -3,13 +3,31 @@ import restArgsError from "./utils/rest-args-error.js"
 import {withTrackedStack} from "./utils/with-tracked-stack.js"
 
 export default class VelociousConfiguration {
+  /**
+   * @returns {VelociousConfiguration}
+   */
   static current(throwError = true) {
     if (!this.velociousConfiguration && throwError) throw new Error("A Velocious configuration hasn't been set")
 
     return this.velociousConfiguration
   }
 
-  constructor({cors, database, debug, directory, environment, initializeModels, initializers, locale, localeFallbacks, locales, testing, ...restArgs}) {
+  /**
+   * @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}) {
     restArgsError(restArgs)
 
     this.cors = cors
@@ -17,6 +35,7 @@ export default class VelociousConfiguration {
     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
@@ -26,14 +45,22 @@ export default class VelociousConfiguration {
     this.locales = locales
     this.modelClasses = {}
     this._testing = testing
+
+    this.getEnvironmentHandler().setConfiguration(this)
   }
 
+  /**
+   * @returns {object}
+   */
   getDatabaseConfiguration() {
     if (!this.database) throw new Error("No database configuration")
 
     return digg(this, "database", this.getEnvironment())
   }
 
+  /**
+   * @returns {Array<string>}
+   */
   getDatabaseIdentifiers() {
     return Object.keys(this.getDatabaseConfiguration())
   }
@@ -62,6 +89,9 @@ export default class VelociousConfiguration {
     return poolTypeClass
   }
 
+  /**
+   * @returns {string} The database type.
+   */
   getDatabaseType(identifier = "default") {
     const databaseType = digg(this.getDatabaseIdentifier(identifier), "type")
 
@@ -70,6 +100,9 @@ export default class VelociousConfiguration {
     return databaseType
   }
 
+  /**
+   * @returns {string}
+   */
   getDirectory() {
     if (!this._directory) {
       this._directory = process.cwd()
@@ -78,12 +111,41 @@ export default class VelociousConfiguration {
     return this._directory
   }
 
+  /**
+   * @returns {string}
+   */
   getEnvironment() { return digg(this, "_environment") }
+
+  /**
+   * @param {string} newEnvironment
+   * @returns {void}
+   */
   setEnvironment(newEnvironment) { this._environment = newEnvironment }
 
+  /**
+   * @template T extends import("./environment-handlers/base.js").default
+   * @returns {T}
+   */
+  getEnvironmentHandler() {
+    if (!this._environmentHandler) throw new Error("No environment handler set")
+
+    return this._environmentHandler
+  }
+
+  /**
+   * @returns {object}
+   */
   getLocaleFallbacks() { return this.localeFallbacks }
+
+  /**
+   * @param {object} newLocaleFallbacks
+   * @returns {void}
+   */
   setLocaleFallbacks(newLocaleFallbacks) { this.localeFallbacks = newLocaleFallbacks }
 
+  /**
+   * @returns {string}
+   */
   getLocale() {
     if (typeof this.locale == "function") {
       return this.locale()
@@ -94,8 +156,16 @@ export default class VelociousConfiguration {
     }
   }
 
+  /**
+   * @returns {Array<string>}
+   */
   getLocales() { return digg(this, "locales") }
 
+  /**
+   * @param {string} name
+   * @template T extends import("./database/record/index.js").default
+   * @returns {T}
+   */
   getModelClass(name) {
     const modelClass = this.modelClasses[name]
 
@@ -104,8 +174,14 @@ export default class VelociousConfiguration {
     return modelClass
   }
 
+  /**
+   * @returns {string} The path to a config file that should be used for testing.
+   */
   getTesting() { return this._testing }
 
+  /**
+   * @returns {void}
+   */
   initializeDatabasePool(identifier = "default") {
     if (!this.database) throw new Error("No 'database' was given")
     if (this.databasePools[identifier]) throw new Error("DatabasePool has already been initialized")
@@ -117,6 +193,10 @@ export default class VelociousConfiguration {
   }
 
   isDatabasePoolInitialized(identifier = "default") { return Boolean(this.databasePools[identifier]) }
+
+  /**
+   * @returns {boolean}
+   */
   isInitialized() { return this._isInitialized }
 
   async initialize({type} = {}) {
@@ -145,32 +225,53 @@ export default class VelociousConfiguration {
     }
   }
 
+  /**
+   * @param {Function} modelClass
+   */
   registerModelClass(modelClass) {
     this.modelClasses[modelClass.name] = modelClass
   }
 
+  /**
+   * @returns {void}
+   */
   setCurrent() {
     this.constructor.velociousConfiguration = this
   }
 
-  setRoutes(newRoutes) {
-    this.routes = newRoutes
-  }
-
-  setTranslator(callback) {
-    this._translator = callback
-  }
-
+  /**
+   * @returns {void}
+   */
+  setRoutes(newRoutes) { this.routes = newRoutes }
+
+  /**
+   * @param {Function} callback
+   * @returns {void}
+   */
+  setTranslator(callback) { this._translator = callback }
+
+  /**
+   * @param {string} msgID
+   * @param {object} args
+   * @returns {string}
+   */
   _defaultTranslator(msgID, args) {
     if (args?.defaultValue) return args.defaultValue
 
     return msgID
   }
 
+  /**
+   * @returns {Function}
+   */
   getTranslator() {
     return this._translator || this._defaultTranslator
   }
 
+  /**
+   * @param {Function} callback
+   * @returns {Promise<void>}
+   */
   async withConnections(callback) {
     const dbs = {}
     const stack = Error().stack
@@ -199,6 +300,10 @@ export default class VelociousConfiguration {
     await runRequest()
   }
 
+  /**
+   * @template T extends import("./database/drivers/base.js").default
+   * @returns {Record<string, T>} A map of database connections with identifier as key
+   */
   getCurrentConnections() {
     const dbs = {}
 
@@ -217,6 +322,10 @@ export default class VelociousConfiguration {
     return dbs
   }
 
+  /**
+   * @param {Function} callback
+   * @returns {Promise<void>}
+   */
   async ensureConnections(callback) {
     let dbs = this.getCurrentConnections()
 

package/src/controller.js

@@ -6,6 +6,10 @@ import {Logger} from "./logger.js"
 import restArgsError from "./utils/rest-args-error.js"
 
 export default class VelociousController {
+  /**
+   * @param {string} methodName
+   * @returns {void}
+   */
   static beforeAction(methodName) {
     if (!this._beforeActions) this._beforeActions = []
 
@@ -32,9 +36,24 @@ export default class VelociousController {
     this._viewPath = viewPath
   }
 
+  /**
+   * @returns {string}
+   */
   getAction() { return this._action }
+
+  /**
+   * @returns {import("./configuration.js").default}
+   */
   getConfiguration() { return this._configuration }
+
+  /**
+   * @returns {object}
+   */
   getParams() { return this._params }
+
+  /**
+   * @returns {import("./http-server/client/request.js").default}
+   */
   getRequest() { return this._request }
 
   async _runBeforeCallbacks() {
@@ -67,6 +86,9 @@ export default class VelociousController {
     await this.logger.debug("After runBeforeCallbacks")
   }
 
+  /**
+   * @returns {object}
+   */
   params() { return this._params }
 
   render({json, status, ...restArgs} = {}) {
@@ -113,6 +135,13 @@ export default class VelociousController {
     throw new Error("renderText stub")
   }
 
+  /**
+   * @returns {import("./http-server/client/request.js").default}
+   */
   request() { return this._request }
+
+  /**
+   * @returns {import("./http-server/client/response.js").default}
+   */
   response() { return this._response }
 }

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

@@ -2,6 +2,10 @@ import TableColumn from "../table-data/table-column.js"
 import TableData from "../table-data/index.js"
 
 export default class VelociousDatabaseDriversBaseColumn {
+  /**
+   * @param {string} indexName
+   * @returns {Promise<import('../table-data/table-index.js').default>}
+   */
   async getIndexByName(indexName) {
     const indexes = await this.getIndexes()
     const index = indexes.find((index) => index.getName() == indexName)
@@ -9,6 +13,10 @@ export default class VelociousDatabaseDriversBaseColumn {
     return index
   }
 
+  /**
+   * @param {boolean} nullable Whether the column should be nullable or not.
+   * @returns {Promise<void>}
+   */
   async changeNullable(nullable) {
     const tableData = new TableData(this.getTable().getName())
     const column = this.getTableDataColumn()
@@ -28,6 +36,9 @@ export default class VelociousDatabaseDriversBaseColumn {
     return this.getTable().getDriver()
   }
 
+  /**
+   * @returns {import("../query-parser/options.js").default}
+   */
   getOptions() {
     return this.getDriver().options()
   }
@@ -38,6 +49,9 @@ export default class VelociousDatabaseDriversBaseColumn {
     return this.table
   }
 
+  /**
+   * @returns {TableColumn} The table column data for this column. This is used for altering tables and such.
+   */
   getTableDataColumn() {
     return new TableColumn(this.getName(), {
       autoIncrement: this.getAutoIncrement(),

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

@@ -14,6 +14,9 @@ export default class VelociousDatabaseDriversBaseColumnsIndex {
     return digg(this, "data", "index_name")
   }
 
+  /**
+   * @returns {import("../query-parser/options.js").default}
+   */
   getOptions() {
     return this.getDriver().options()
   }