velocious 1.0.431 → 1.0.433

package/build/environment-handlers/node/cli/commands/generate/migration.js

@@ -0,0 +1,45 @@
+import BaseCommand from "../../../../../cli/base-command.js"
+import fileExists from "../../../../../utils/file-exists.js"
+import fs from "fs/promises"
+import * as inflection from "inflection"
+import strftime from "strftime"
+
+/**
+ * DbGenerateMigration class.
+ * @typedef {{date: Date, migrationContent: string, migrationName: string, migrationNameCamelized: string, migrationNumber: string, migrationPath: string}} DbGenerateMigrationReturnType
+ */
+
+export default class DbGenerateMigration extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<void | DbGenerateMigrationReturnType>} - Resolves with the execute.
+   */
+  async execute() {
+    const migrationName = this.processArgs?.[1]
+
+    if (!migrationName) throw new Error("Expected migration name")
+
+    const migrationNameCamelized = inflection.camelize(migrationName.replaceAll("-", "_"))
+    const date = new Date()
+    const migrationNumber = strftime("%Y%m%d%H%M%S")
+    const migrationFileName = `${migrationNumber}-${migrationName}.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`
+    const migrationPath = `${migrationDir}/${migrationFileName}`
+
+    if (this.args.testing) {
+      return {date, migrationContent, migrationName, migrationNameCamelized, migrationNumber, migrationPath}
+    } else {
+      if (!await fileExists(migrationDir)) {
+        await fs.mkdir(migrationDir, {recursive: true})
+      }
+
+      await fs.writeFile(migrationPath, migrationContent)
+
+      console.log(`create src/database/migrations/${migrationFileName}`)
+    }
+  }
+}

package/build/environment-handlers/node/cli/commands/generate/model.js

@@ -0,0 +1,45 @@
+import BaseCommand from "../../../../../cli/base-command.js"
+import fileExists from "../../../../../utils/file-exists.js"
+import fs from "fs/promises"
+import * as inflection from "inflection"
+
+/**
+ * DbGenerateModel class.
+ * @typedef {{date: Date, modelContent: string, modelName: string, modelNameCamelized: string, modelPath: string}} DbGenerateModelResult
+ */
+
+export default class DbGenerateModel extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<void | DbGenerateModelResult>} - Resolves with the execute.
+   */
+  async execute() {
+    const modelName = this.processArgs?.[1]
+
+    if (!modelName) throw new Error("Expected model name")
+
+    const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))
+    const date = new Date()
+    const modelFileName = `${inflection.dasherize(inflection.underscore(modelName))}.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`
+    const modelPath = `${modelsDir}/${modelFileName}`
+
+    if (await fileExists(modelPath)) throw new Error(`Model file already exists: ${modelPath}`)
+
+    if (this.args.testing) {
+      return {date, modelContent, modelName, modelNameCamelized, modelPath}
+    } else {
+      if (!await fileExists(modelsDir)) {
+        await fs.mkdir(modelsDir, {recursive: true})
+      }
+
+      await fs.writeFile(modelPath, modelContent)
+
+      console.log(`create src/models/${modelFileName}`)
+    }
+  }
+}

package/build/environment-handlers/node/cli/commands/init.js

@@ -0,0 +1,68 @@
+import BaseCommand from "../../../../cli/base-command.js"
+import fileExists from "../../../../utils/file-exists.js"
+import fs from "fs/promises"
+
+/**
+ * VelociousCliCommandsInit class.
+ * @typedef {{source: string, target: string}} FileMappingType
+ */
+
+export default class VelociousCliCommandsInit extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<void | {fileMappings: FileMappingType[]}>} - Resolves with generated file mappings, if any.
+   */
+  async execute() {
+    const velociousPath = await this.getEnvironmentHandler().getVelociousPath()
+    const projectPath = this.getConfiguration()?.getDirectory() || process.cwd()
+    const projectConfigPath = `${projectPath}/src/config`
+    const fileMappings = [
+      {
+        source: `${velociousPath}/src/templates/configuration.js`,
+        target: `${projectConfigPath}/configuration.js`
+      },
+      {
+        source: `${velociousPath}/src/templates/routes.js`,
+        target: `${projectConfigPath}/routes.js`
+      }
+    ]
+    const paths = [
+      projectConfigPath,
+      `${projectPath}/src/database/migrations`,
+      `${projectPath}/src/models`,
+      `${projectPath}/src/routes`
+    ]
+
+    if (this.args.testing) {
+      return {
+        fileMappings
+      }
+    }
+
+    for (const path of paths) {
+      if (await fileExists(path)) {
+        console.log(`Config dir already exists: ${path}`)
+      } else {
+        console.log(`Config dir doesn't exists: ${path}`)
+        await fs.mkdir(path, {recursive: true})
+      }
+    }
+
+    for (const fileMapping of fileMappings) {
+      if (!await fileExists(fileMapping.source)) {
+        throw new Error(`Template doesn't exist: ${fileMapping.source}`)
+      }
+
+      if (await fileExists(fileMapping.target)) {
+        console.log(`File already exists: ${fileMapping.target}`)
+      } else {
+        console.log(`File doesnt exist: ${fileMapping.target}`)
+        await fs.copyFile(fileMapping.source, fileMapping.target)
+      }
+    }
+  }
+}
+
+const dontLoadConfiguration = true
+
+export {dontLoadConfiguration}

package/build/environment-handlers/node/cli/commands/routes.js

@@ -0,0 +1,63 @@
+import * as inflection from "inflection"
+
+import Application from "../../../../application.js"
+import BaseCommand from "../../../../cli/base-command.js"
+
+export default class VelociousCliCommandsServer extends BaseCommand{
+  output = ""
+
+  /**
+   * Runs normalize action name.
+   * @param {string} actionName - Raw route action name.
+   * @returns {string} - Normalized method name.
+   */
+  normalizeActionName(actionName) {
+    return inflection.camelize(actionName.replaceAll("-", "_").replaceAll("/", "_"), true)
+  }
+
+  async execute() {
+    const application = new Application({
+      configuration: this.getConfiguration(),
+      type: "server"
+    })
+    await application.initialize()
+    const routes = this.getConfiguration().getRoutes()
+
+    if (!routes?.rootRoute) throw new Error("Routes have not been initialized")
+
+    this.printRoutes(routes.rootRoute)
+
+    return {output: this.output}
+  }
+
+  /**
+   * Runs print routes.
+   * @param {import("../../../../routes/base-route.js").default} route - Route.
+   * @param {number} [level] - Level.
+   * @returns {void} - No return value.
+   */
+  printRoutes(route, level = 0) {
+    const prefix = "  ".repeat(level)
+
+    for (const routeData of route.getHumanPaths()) {
+      this.log(`${prefix}${routeData.method} ${routeData.path}${routeData.action ? ` -> ${this.normalizeActionName(routeData.action)}` : ""}`)
+    }
+
+    for (const subRoute of route.getSubRoutes()) {
+      this.printRoutes(subRoute, level + 1)
+    }
+  }
+
+  /**
+   * Runs log.
+   * @param {string} content - Content.
+   * @returns {void} - No return value.
+   */
+  log(content) {
+    if (this.cli.getTesting()) {
+      this.output += `${content}\n`
+    } else {
+      console.log(content)
+    }
+  }
+}

package/build/environment-handlers/node/cli/commands/run-script.js

@@ -0,0 +1,85 @@
+import BaseCommand from "../../../../cli/base-command.js"
+import buildCliCommandContext from "./cli-command-context.js"
+import path from "node:path"
+import toImportSpecifier from "../../../../utils/to-import-specifier.js"
+
+/**
+ * RunScriptContext type.
+ * @typedef {import("./cli-command-context.js").CliCommandContext} RunScriptContext
+ */
+
+/**
+ * Runs import run script function.
+ * @param {string} filePath - Absolute path to script file.
+ * @returns {Promise<(context: RunScriptContext) => Promise<?>>} - The default-exported async function.
+ */
+async function importRunScriptFunction(filePath) {
+  const scriptImport = await import(toImportSpecifier(filePath))
+  const runScriptFunction = scriptImport.default
+
+  if (typeof runScriptFunction !== "function") {
+    throw new Error(`Expected default export to be a function in: ${filePath}`)
+  }
+
+  return runScriptFunction
+}
+
+/** Node command for running a custom script file in initialized app/DB context. */
+export default class RunScriptCommand extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<?>} - Resolves with the script function result.
+   */
+  async execute() {
+    const configuration = this.getConfiguration()
+    const scriptPath = this.scriptFilePath()
+
+    await this.initializeRuntime()
+
+    try {
+      await configuration.ensureGlobalConnections()
+
+      const runScriptFunction = await importRunScriptFunction(scriptPath)
+
+      return await runScriptFunction(this.buildRunScriptContext())
+    } finally {
+      await configuration.closeDatabaseConnections()
+    }
+  }
+
+  /**
+   * Runs initialize runtime.
+   * @returns {Promise<void>} - Resolves when runtime initialization is complete.
+   */
+  async initializeRuntime() {
+    const configuration = this.getConfiguration()
+
+    await configuration.initialize({type: "run-script"})
+
+    if (!configuration.isDatabasePoolInitialized()) {
+      configuration.initializeDatabasePool()
+    }
+  }
+
+  /**
+   * Runs script file path.
+   * @returns {string} - Absolute path to the user-provided script file.
+   */
+  scriptFilePath() {
+    const filePath = this.processArgs?.[1]
+
+    if (!filePath) {
+      throw new Error("Missing file path argument. Usage: npx velocious run-script [file-path]")
+    }
+
+    return path.resolve(this.directory(), filePath)
+  }
+
+  /**
+   * Runs build run script context.
+   * @returns {RunScriptContext} - Runtime context passed to the script function.
+   */
+  buildRunScriptContext() {
+    return buildCliCommandContext(this, 2)
+  }
+}

package/build/environment-handlers/node/cli/commands/runner.js

@@ -0,0 +1,84 @@
+import BaseCommand from "../../../../cli/base-command.js"
+import buildCliCommandContext from "./cli-command-context.js"
+
+/**
+ * RunnerContext type.
+ * @typedef {import("./cli-command-context.js").CliCommandContext} RunnerContext
+ */
+
+/** Node command for evaluating inline JavaScript in initialized app/DB context. */
+export default class RunnerCommand extends BaseCommand {
+  /**
+   * Runs execute.
+   * @returns {Promise<?>} - Resolves with the evaluated code result.
+   */
+  async execute() {
+    const configuration = this.getConfiguration()
+    const code = this.runnerCode()
+
+    await this.initializeRuntime()
+
+    try {
+      await configuration.ensureGlobalConnections()
+
+      return await this.evaluateCode(code)
+    } finally {
+      await configuration.closeDatabaseConnections()
+    }
+  }
+
+  /**
+   * Runs initialize runtime.
+   * @returns {Promise<void>} - Resolves when runtime initialization is complete.
+   */
+  async initializeRuntime() {
+    const configuration = this.getConfiguration()
+
+    await configuration.initialize({type: "runner"})
+
+    if (!configuration.isDatabasePoolInitialized()) {
+      configuration.initializeDatabasePool()
+    }
+  }
+
+  /**
+   * Runs runner code.
+   * @returns {string} - Inline JavaScript code to evaluate.
+   */
+  runnerCode() {
+    const code = (this.processArgs || []).slice(1).join(" ").trim()
+
+    if (!code) {
+      throw new Error("Missing code argument. Usage: npx velocious runner \"<javascript-code>\"")
+    }
+
+    return code
+  }
+
+  /**
+   * Runs build runner context.
+   * @returns {RunnerContext} - Runtime context passed to evaluated code.
+   */
+  buildRunnerContext() {
+    return buildCliCommandContext(this, 2)
+  }
+
+  /**
+   * Runs evaluate code.
+   * @param {string} code - JavaScript code to evaluate.
+   * @returns {Promise<?>} - Evaluated code result.
+   */
+  async evaluateCode(code) {
+    const context = this.buildRunnerContext()
+    const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor
+    const runFunction = new AsyncFunction(
+      "configuration",
+      "db",
+      "dbs",
+      "args",
+      code
+    )
+
+    return await runFunction(context.configuration, context.db, context.dbs, context.args)
+  }
+}

package/build/environment-handlers/node/cli/commands/server.js

@@ -0,0 +1,151 @@
+import Application from "../../../../application.js"
+import BaseCommand from "../../../../cli/base-command.js"
+
+/**
+ * SignalProcess type.
+ * @typedef {object} SignalProcess
+ * @property {(event: "SIGINT" | "SIGTERM", listener: () => void) => SignalProcess} once - Register one signal listener.
+ * @property {(event: "SIGINT" | "SIGTERM", listener: () => void) => SignalProcess} removeListener - Remove one signal listener.
+ */
+
+/**
+ * SignalShutdownApplication type.
+ * @typedef {object} SignalShutdownApplication
+ * @property {() => Promise<void>} stop - Stop the application gracefully.
+ * @property {() => Promise<void>} wait - Wait until the application closes.
+ */
+
+/**
+ * Waits for the HTTP application to close, stopping it gracefully when the
+ * process receives SIGINT or SIGTERM.
+ * @param {object} args - Wait options.
+ * @param {SignalShutdownApplication} args.application - Running application.
+ * @param {SignalProcess} [args.processObject] - Process-like signal emitter.
+ * @returns {Promise<void>} - Resolves when the application has stopped.
+ */
+export function waitForApplicationWithSignalShutdown({application, processObject = process}) {
+  return new Promise((resolve, reject) => {
+    let finished = false
+    let stopping = false
+
+    /**
+     * Cleanup.
+     * @returns {void} - Remove installed signal handlers.
+     */
+    const cleanup = () => {
+      processObject.removeListener("SIGINT", onSignal)
+      processObject.removeListener("SIGTERM", onSignal)
+    }
+
+    /**
+     * Completes the wait promise once.
+     * @param {?} [error] - Optional rejection reason.
+     * @returns {void}
+     */
+    const finish = (error) => {
+      if (finished) return
+
+      finished = true
+      cleanup()
+
+      if (error) {
+        reject(error)
+      } else {
+        resolve(undefined)
+      }
+    }
+
+    /**
+     * Stop application.
+     * @returns {Promise<void>} - Stops the application once.
+     */
+    const stopApplication = async () => {
+      if (stopping || finished) return
+
+      stopping = true
+
+      try {
+        await application.stop()
+      } catch (error) {
+        finish(error)
+      }
+    }
+
+    /**
+     * On signal.
+     * @returns {void} - Handles one shutdown signal.
+     */
+    const onSignal = () => {
+      void stopApplication()
+    }
+
+    processObject.once("SIGINT", onSignal)
+    processObject.once("SIGTERM", onSignal)
+
+    application.wait().then(() => finish()).catch((error) => finish(error))
+  })
+}
+
+/**
+ * Runs first configured value.
+ * @template T
+ * @param {...(T | undefined)} values - Candidate values in priority order.
+ * @returns {T | undefined} - First configured value.
+ */
+function firstConfiguredValue(...values) {
+  return values.find((value) => value !== undefined)
+}
+
+/**
+ * Runs http server workers from arg.
+ * @param {string | number | boolean | undefined} workersArg - Worker count argument.
+ * @returns {number | undefined} - Normalized worker count.
+ */
+function httpServerWorkersFromArg(workersArg) {
+  if (workersArg === undefined) return undefined
+  if (typeof workersArg === "boolean") throw new Error("--workers must be a positive integer")
+
+  const workers = Number(workersArg)
+
+  if (!Number.isInteger(workers) || workers < 1) throw new Error("--workers must be a positive integer")
+
+  return workers
+}
+
+/**
+ * Runs the httpServerConfigFromParsedArgs helper.
+ * @param {Record<string, string | number | boolean | undefined>} parsedProcessArgs - Parsed CLI args.
+ * @param {import("../../../../configuration-types.js").HttpServerConfiguration} [defaults] - Default HTTP server config.
+ * @returns {{host: string, port: number, workers?: number}} - HTTP server config.
+ */
+export function httpServerConfigFromParsedArgs(parsedProcessArgs = {}, defaults = {}) {
+  const host = String(firstConfiguredValue(parsedProcessArgs.h, parsedProcessArgs.host, defaults.host, "127.0.0.1"))
+  const port = Number(firstConfiguredValue(parsedProcessArgs.p, parsedProcessArgs.port, defaults.port, 3006))
+  const workers = httpServerWorkersFromArg(firstConfiguredValue(parsedProcessArgs.workers, defaults.workers))
+
+  if (workers === undefined) return {host, port}
+  return {host, port, workers}
+}
+
+export default class VelociousCliCommandsServer extends BaseCommand{
+  /**
+   * Runs execute.
+   * @returns {Promise<void>} - Starts the HTTP server and waits until it stops.
+   */
+  async execute() {
+    const parsedProcessArgs = this.args?.parsedProcessArgs || {}
+    const configuration = this.getConfiguration()
+    const httpServer = httpServerConfigFromParsedArgs(parsedProcessArgs, configuration.httpServer)
+    const application = new Application({
+      configuration,
+      httpServer,
+      type: "server"
+    })
+    const environment = configuration.getEnvironment()
+
+    await application.initialize()
+    await application.startHttpServer()
+    console.log(`Started Velocious HTTP server on ${httpServer.host}:${httpServer.port} in ${environment} environment`)
+    await waitForApplicationWithSignalShutdown({application})
+  }
+}

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

@@ -0,0 +1,118 @@
+// @ts-check
+
+import BaseCommand from "../../../../cli/base-command.js"
+import picocolors from "picocolors"
+import TestFilesFinder from "../../../../testing/test-files-finder.js"
+import TestRunner from "../../../../testing/test-runner.js"
+import TestSuiteSplitter from "../../../../testing/test-suite-splitter.js"
+import {normalizeExamplePatterns, parseFilters} from "../../../../testing/test-filter-parser.js"
+
+export default class VelociousCliCommandsTest extends BaseCommand {
+  async execute() {
+    this.getConfiguration().setEnvironment("test")
+
+    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 {includeTags, excludeTags, examplePatterns, filteredProcessArgs, groups, groupNumber} = parseFilters(this.processArgs || [])
+    const testFilesFinder = new TestFilesFinder({directory, directories, processArgs: filteredProcessArgs})
+    let testFiles = await testFilesFinder.findTestFiles()
+
+    if (groups !== undefined || groupNumber !== undefined) {
+      if (groups === undefined || groupNumber === undefined) {
+        throw new Error("Both --groups and --group-number must be provided together")
+      }
+
+      const splitter = new TestSuiteSplitter({groups, groupNumber, testFiles, baseDirectory: directory})
+
+      testFiles = splitter.getGroupFiles()
+      console.log(picocolors.cyan(`Running group ${groupNumber} of ${groups} (${testFiles.length} files)`))
+    }
+
+    const testRunner = new TestRunner({
+      configuration: this.getConfiguration(),
+      excludeTags,
+      includeTags,
+      testFiles,
+      lineFilters: testFilesFinder.getLineFiltersByFile(),
+      examplePatterns: normalizeExamplePatterns(examplePatterns)
+    })
+    let signalHandled = false
+
+    const handleSignal = async (/** @type {string} */ signal) => {
+      if (signalHandled) return
+      signalHandled = true
+      console.error(`\nReceived ${signal}, running afterAll hooks before exit...`)
+
+      try {
+        await testRunner.runAfterAllsForActiveScopes()
+      } catch (error) {
+        console.error("Failed while running afterAll hooks:", error)
+      } finally {
+        process.exit(130)
+      }
+    }
+
+    process.once("SIGINT", () => { void handleSignal("SIGINT") })
+    process.once("SIGTERM", () => { void handleSignal("SIGTERM") })
+
+    await testRunner.prepare()
+
+    if (testRunner.getTestsCount() === 0) {
+      throw new Error(`${testRunner.getTestsCount()} tests was found in ${testFiles.length} file(s)`)
+    }
+
+    await testRunner.run()
+
+    const executedTests = testRunner.getExecutedTestsCount()
+
+    const lineFilters = testRunner.getLineFilters()
+    const hasLineFilters = Object.keys(lineFilters).length > 0
+    const hasExampleFilters = examplePatterns.length > 0
+    const hasTagFilters = includeTags.length > 0 || excludeTags.length > 0
+
+    if ((hasTagFilters || hasLineFilters || hasExampleFilters) && executedTests === 0) {
+      console.error(picocolors.red("\nNo tests matched the provided filters"))
+      process.exit(1)
+    }
+
+    if (testRunner.isFailed()) {
+      await testRunner.persistFailedTestConsoleOutputsToAssets()
+      const failedTests = testRunner.getFailedTestDetails()
+
+      if (failedTests.length > 0) {
+      console.error(picocolors.red("\nFailed tests:"))
+
+        for (const failed of failedTests) {
+          const location = failed.filePath && failed.line
+            ? ` (${failed.filePath}:${failed.line})`
+            : ""
+          console.error(picocolors.red(`- ${failed.fullDescription}${location}`))
+
+          if (failed.consoleLogPath) {
+            console.error(picocolors.red(`  Console log: ${failed.consoleLogPath}`))
+          }
+        }
+      }
+
+      console.error(picocolors.red(`\nTest run failed with ${testRunner.getFailedTests()} failed tests and ${testRunner.getSuccessfulTests()} successfull`))
+      process.exit(1)
+    } else if (testRunner.areAnyTestsFocussed()) {
+      console.error(picocolors.red(`\nFocussed run with ${testRunner.getFailedTests()} failed tests and ${testRunner.getSuccessfulTests()} successfull`))
+      process.exit(1)
+    } else {
+      console.log(picocolors.green(`\nTest run succeeded with ${testRunner.getSuccessfulTests()} successful tests`))
+      process.exit(0)
+    }
+  }
+}