velocious 1.0.108 → 1.0.110

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

@@ -1,40 +0,0 @@
-import BaseCommand from "../../../../../cli/base-command.js"
-import fileExists from "../../../../../utils/file-exists.js"
-import fs from "fs/promises"
-import * as inflection from "inflection"
-
-/**
- * @typedef {{date: Date, modelContent: string, modelName: string, modelNameCamelized: string, modelPath: string}} DbGenerateModelResult
- */
-
-export default class DbGenerateModel extends BaseCommand {
-  /**
-   * @returns {Promise<void | DbGenerateModelResult>}
-   */
-  async execute() {
-    const modelName = this.processArgs[1]
-    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/src/environment-handlers/node/cli/commands/init.js

@@ -1,66 +0,0 @@
-import BaseCommand from "../../../../cli/base-command.js"
-import fileExists from "../../../../utils/file-exists.js"
-import fs from "fs/promises"
-
-/**
- * @typedef {{source: string, target: string}} FileMappingType
- */
-
-export default class VelociousCliCommandsInit extends BaseCommand {
-  /**
-   * @returns {Promise<void | {fileMappings: FileMappingType[]}>}
-   */
-  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/src/environment-handlers/node/cli/commands/server.js

@@ -1,30 +0,0 @@
-import Application from "../../../../application.js"
-import BaseCommand from "../../../../cli/base-command.js"
-
-export default class VelociousCliCommandsServer extends BaseCommand{
-  async execute() {
-    this.databasePool = this.getConfiguration().getDatabasePool()
-    this.newConfiguration = Object.assign({}, this.databasePool.getConfiguration())
-    this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
-
-    await this.databaseConnection.connect()
-
-    const {parsedProcessArgs} = this.args
-    const host = parsedProcessArgs.h || parsedProcessArgs.host || "127.0.0.1"
-    const port = parsedProcessArgs.p || parsedProcessArgs.port || 3006
-    const application = new Application({
-      configuration: this.getConfiguration(),
-      httpServer: {
-        host,
-        port
-      },
-      type: "server"
-    })
-    const environment = this.getConfiguration().getEnvironment()
-
-    await application.initialize()
-    await application.startHttpServer()
-    console.log(`Started Velocious HTTP server on ${host}:${port} in ${environment} environment`)
-    await application.wait()
-  }
-}

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

@@ -1,47 +0,0 @@
-// @ts-check
-
-import BaseCommand from "../../../../cli/base-command.js"
-import TestFilesFinder from "../../../../testing/test-files-finder.js"
-import TestRunner from "../../../../testing/test-runner.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 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(`${testRunner.getTestsCount()} tests was found in ${testFiles.length} file(s)`)
-    }
-
-    await testRunner.run()
-
-    if (testRunner.isFailed()) {
-      console.error(`\nTest run failed with ${testRunner.getFailedTests()} failed tests and ${testRunner.getSuccessfulTests()} successfull`)
-      process.exit(1)
-    } else if (testRunner.areAnyTestsFocussed()) {
-      console.error(`\nFocussed run with ${testRunner.getFailedTests()} failed tests and ${testRunner.getSuccessfulTests()} successfull`)
-      process.exit(1)
-    } else {
-      console.log(`\nTest run succeeded with ${testRunner.getSuccessfulTests()} successful tests`)
-      process.exit(0)
-    }
-  }
-}

package/src/environment-handlers/node.js

@@ -1,227 +0,0 @@
-// @ts-check
-
-import Base from "./base.js"
-import CliCommandsDestroyMigration from "./node/cli/commands/destroy/migration.js"
-import CliCommandsInit from "./node/cli/commands/init.js"
-import CliCommandsGenerateBaseModels from "./node/cli/commands/generate/base-models.js"
-import CliCommandsGenerateMigration from "./node/cli/commands/generate/migration.js"
-import CliCommandsGenerateModel from "./node/cli/commands/generate/model.js"
-import CliCommandsServer from "./node/cli/commands/server.js"
-import CliCommandsTest from "./node/cli/commands/test.js"
-import {dirname} from "path"
-import {fileURLToPath} from "url"
-import fs from "fs/promises"
-import * as inflection from "inflection"
-import path from "path"
-
-export default class VelociousEnvironmentHandlerNode extends Base{
-  /** @type {import("./base.js").CommandFileObjectType[] | undefined} */
-  _findCommandsResult = undefined
-
-  /**
-   * @returns {Promise<Array<import("./base.js").CommandFileObjectType>>}
-   */
-  async findCommands() {
-    this._findCommandsResult ||= await this._actualFindCommands()
-
-    if (!this._findCommandsResult) throw new Error("Could not get commands")
-
-    return this._findCommandsResult
-  }
-
-  async _actualFindCommands() {
-    const basePath = await this.getBasePath()
-    const commandFiles = fs.glob(`${basePath}/src/cli/commands/**/*.js`)
-    const commands = []
-
-    for await (const aFilePath of commandFiles) {
-      const aFilePathParts = aFilePath.split("/")
-      const commandPathLocation = aFilePathParts.indexOf("commands") + 1
-      const lastPart = aFilePathParts[aFilePathParts.length - 1]
-      let name, paths
-
-      if (lastPart == "index.js") {
-        name = aFilePathParts[aFilePathParts.length - 2]
-        paths = aFilePathParts.slice(commandPathLocation, -2)
-      } else {
-        name = lastPart.replace(".js", "")
-        paths = aFilePathParts.slice(commandPathLocation, -1)
-      }
-
-      const commandName = `${paths.join(":")}${paths.length > 0 ? ":" : ""}${name}`
-
-      commands.push({name: commandName, file: aFilePath})
-    }
-
-    return commands
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} command
-   * @returns {Promise<void>}
-   */
-  async cliCommandsInit(command) {
-    return await this.forwardCommand(command, CliCommandsInit)
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} command
-   * @returns {Promise<any>}
-   */
-  async cliCommandsMigrationGenerate(command) {
-    return await this.forwardCommand(command, CliCommandsGenerateMigration)
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} command
-   * @returns {Promise<any>}
-   */
-  async cliCommandsMigrationDestroy(command) {
-    return await this.forwardCommand(command, CliCommandsDestroyMigration)
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} command
-   * @returns {Promise<any>}
-   */
-  async cliCommandsGenerateBaseModels(command) {
-    return await this.forwardCommand(command, CliCommandsGenerateBaseModels)
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} command
-   * @returns {Promise<any>}
-   */
-  async cliCommandsGenerateModel(command) {
-    return await this.forwardCommand(command, CliCommandsGenerateModel)
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} command
-   * @returns {Promise<any>}
-   */
-  async cliCommandsServer(command) {
-    return await this.forwardCommand(command, CliCommandsServer)
-  }
-
-  /**
-   * @param {import("../cli/base-command.js").default} command
-   * @returns {Promise<any>}
-   */
-  async cliCommandsTest(command) {
-    return await this.forwardCommand(command, CliCommandsTest)
-  }
-
-  /**
-   * @param {object} args
-   * @param {string[]} args.commandParts
-   * @returns {Promise<typeof import ("../cli/base-command.js").default>}
-   */
-  async requireCommand({commandParts}) {
-    const commands = await this.findCommands()
-    const command = commands.find((aCommand) => aCommand.name === commandParts.join(":"))
-
-    if (!command) {
-      const possibleCommands = commands.map(aCommand => aCommand.name)
-
-      throw new Error(`Unknown command: ${commandParts.join(":")} which should have been one of: ${possibleCommands.sort().join(", ")}`)
-    }
-
-    const commandClassImport = await import(command.file)
-    const CommandClass = commandClassImport.default
-
-    return CommandClass
-  }
-
-  /**
-   * @returns {Promise<Array<import("./base.js").MigrationObjectType>>}
-   */
-  async findMigrations() {
-    const migrationsPath = `${this.getConfiguration().getDirectory()}/src/database/migrations`
-    const glob = await fs.glob(`${migrationsPath}/**/*.js`)
-    let files = []
-
-    for await (const fullPath of glob) {
-      const file = await path.basename(fullPath)
-
-      const match = file.match(/^(\d{14})-(.+)\.js$/)
-
-      if (!match) continue
-
-      const date = parseInt(match[1])
-      const migrationName = match[2]
-      const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"))
-
-      files.push({
-        file,
-        fullPath: `${migrationsPath}/${file}`,
-        date,
-        migrationClassName
-      })
-    }
-
-    files = files.sort((migration1, migration2) => migration1.date - migration2.date)
-
-    return files
-  }
-
-  /**
-   * @returns {Promise<import("../routes/index.js").default>}
-   */
-  async importApplicationRoutes() {
-    const routesImport = await import(`${this.getConfiguration().getDirectory()}/src/config/routes.js`)
-
-    return routesImport.default
-  }
-
-  /**
-   * @returns {Promise<string>}
-   */
-  async getVelociousPath() {
-    if (!this._velociousPath) {
-      const __filename = fileURLToPath(import.meta.url)
-      const __dirname = dirname(__filename)
-
-      this._velociousPath = await fs.realpath(`${__dirname}/../..`)
-    }
-
-    return this._velociousPath
-  }
-
-  /**
-   * @param {string[]} testFiles
-   * @returns {Promise<void>}
-   */
-  async importTestFiles(testFiles) {
-    for (const testFile of testFiles) {
-      await import(testFile)
-    }
-  }
-
-  async importTestingConfigPath() {
-    const testingConfigPath = this.getConfiguration().getTesting()
-
-    await import(testingConfigPath)
-  }
-
-  /**
-   * @param {string} filePath
-   * @returns {Promise<import("../database/migration/index.js").default>}
-   */
-  async requireMigration(filePath) {
-    const migrationImport = await import(filePath)
-    const migrationImportDefault = migrationImport.default
-
-    if (!migrationImportDefault) throw new Error("Migration file must export a default migration class")
-    if (typeof migrationImportDefault !== "function") throw new Error("Migration default export isn't a function (should be a class which is a function in JS)")
-
-    return migrationImportDefault
-  }
-
-  async getBasePath() {
-    const __filename = fileURLToPath(import.meta.url)
-    const basePath = await fs.realpath(`${dirname(__filename)}/../..`)
-
-    return basePath
-  }
-}

package/src/error-logger.js

@@ -1,32 +0,0 @@
-// @ts-check
-
-/**
- * @param {(...args: any[]) => Promise<void>} callback
- */
-export default function errorLogger(callback) {
-  /**
-   * @param  {...any} args
-   * @returns {Promise<void>}
-   */
-  return async function(...args) {
-    try {
-      await callback(...args)
-    } catch (error) {
-      if (error instanceof Error) {
-        console.error(`ErrorLogger: ${error.message}`)
-
-        if (error.stack) {
-          console.error("Stack", error.stack)
-        } else {
-          console.error("No stack")
-        }
-      } else {
-        console.error(`ErrorLogger: ${error}`)
-        console.error("No stack")
-      }
-
-      // Give console some time to write out messages before crashing
-      setTimeout(() => { throw error })
-    }
-  }
-}

package/src/http-client/header.js

@@ -1,16 +0,0 @@
-// @ts-check
-
-export default class Header {
-  /**
-   * @param {string} name
-   * @param {string | number} value
-   */
-  constructor(name, value) {
-    this.name = name
-    this.value = value
-  }
-
-  getName() { return this.name }
-  getValue() { return this.value }
-  toString() { return `${this.getName()}: ${this.getValue()}` }
-}

package/src/http-client/index.js

@@ -1,135 +0,0 @@
-// @ts-check
-
-import net from "net"
-import Request from "./request.js"
-import Response from "./response.js"
-import {Logger} from "../logger.js"
-
-export default class HttpClient {
-  /**
-   * @param {object} args
-   * @param {boolean} [args.debug]
-   * @param {Array<import("./header.js").default>} [args.headers]
-   * @param {string} [args.version]
-   */
-  constructor({debug = false, headers, version = "1.1"}) {
-    this.headers = headers || []
-    this.logger = new Logger(this, {debug})
-    this.version = version
-  }
-
-  connect() {
-    return new Promise((resolve, reject) => {
-      this.connectionReject = reject
-      this.connection = net.createConnection(3006, "127.0.0.1", () => {
-        this.connectionReject = null
-        resolve(null)
-      })
-
-      this.connection.on("data", this.onConnectionData)
-      this.connection.on("end", this.onConnectionEnd)
-      this.connection.on("error", this.onConnectionError)
-    })
-  }
-
-  /**
-   * @param {string} path
-   * @param {object} [options]
-   * @param {Array<import("./header.js").default>} [options.headers]
-   * @returns {Promise<{request: import("./request.js").default, response: import("./response.js").default}>}
-   */
-  get(path, {headers} = {}) {
-    if (!this.connection) throw new Error("Not connected yet")
-
-    return new Promise((resolve, reject) => {
-      this.currentRequestResolve = resolve
-      this.currentRequestReject = reject
-
-      const newHeaders = []
-
-      if (headers) {
-        for (const header of headers) {
-          newHeaders.push(header)
-        }
-      }
-
-      for (const header of this.headers) {
-        const existingNewHeader = newHeaders.find((newHeader) => {
-          return newHeader.getName().toLowerCase().trim() === header.getName().toLowerCase().trim()
-        })
-
-        if (!existingNewHeader) {
-          this.logger.debug(() => [`Pushing header from connection: ${header.toString()}`])
-          newHeaders.push(header)
-        }
-      }
-
-      this.currentResponse = new Response({method: "GET", onComplete: this.onResponseComplete})
-
-      this.currentRequest = new Request({headers: newHeaders, method: "GET", path, version: "1.0"})
-      this.currentRequest.stream((chunk) => {
-        this.logger.debug(() => [`Writing: ${chunk}`])
-
-        if (!this.connection) {
-          throw new Error("No connection to write to")
-        }
-
-        this.connection.write(chunk, "utf8", (error) => {
-          if (error) {
-            if (!this.currentRequestReject) throw new Error("No current request reject function")
-
-            this.currentRequestReject(error)
-          }
-        })
-      })
-    })
-  }
-
-  /**
-   * @param {Buffer} data
-   */
-  onConnectionData = (data) => {
-    if (!this.currentResponse) throw new Error("No current response to feed data to")
-
-    this.currentResponse.feed(data)
-  }
-
-  onConnectionEnd = () => {
-    this.connection = null
-  }
-
-  /**
-   * @param {Error} error
-   */
-  onConnectionError = (error) => {
-    if (this.connectionReject) {
-      this.connectionReject(error)
-    } else {
-      this.logger.error("HttpClient onConnectionError", error)
-    }
-  }
-
-  isConnected() {
-    if (this.connection) {
-      return true
-    }
-
-    return false
-  }
-
-  onResponseComplete = () => {
-    if (!this.currentRequestResolve) throw new Error("No current request resolve function")
-    if (!this.currentRequest) throw new Error("No current request")
-    if (!this.currentResponse) throw new Error("No current response")
-
-    this.currentRequestResolve({
-      request: this.currentRequest,
-      response: this.currentResponse
-    })
-
-    this.currentRequestResolve = null
-    this.currentRequestReject = null
-    this.currentRequest = null
-    this.currentResponse = null
-  }
-}

package/src/http-client/request.js

@@ -1,83 +0,0 @@
-// @ts-check
-
-import Header from "./header.js"
-
-export default class Request {
-  /**
-   * @param {object} args
-   * @param {string} [args.body]
-   * @param {string} args.method
-   * @param {Header[]} args.headers
-   * @param {string} args.path
-   * @param {string} args.version
-   */
-  constructor({body, method = "GET", headers = [], path, version = "1.1"}) {
-    this.body = body
-    this.headers = headers
-    this.method = method
-    this.path = path
-    this.version = version
-  }
-
-  asString() {
-    let requestString = ""
-
-    this.stream((chunk) => {
-      requestString += chunk
-    })
-
-    return requestString
-  }
-
-  /**
-   * @param {string} name
-   */
-  getHeader(name) {
-    const compareName = name.toLowerCase().trim()
-
-    for (const header of this.headers) {
-      const headerCompareName = header.getName().toLowerCase().trim()
-
-      if (compareName == headerCompareName) {
-        return header
-      }
-    }
-
-    throw new Error(`Header ${name} not found`)
-  }
-
-  /**
-   * @param {string} name
-   * @param {string | number} value
-   */
-  addHeader(name, value) {
-    this.headers.push(new Header(name, value))
-  }
-
-  prepare() {
-    if (this.body) {
-      this.addHeader("Content-Length", Buffer.from(this.body).byteLength)
-    }
-  }
-
-  /**
-   * @param {function(string) : void} callback
-   */
-  stream(callback) {
-    this.prepare()
-
-    const requestString = `${this.method} ${this.path} HTTP/${this.version}\r\n`
-
-    callback(requestString)
-
-    for (const header of this.headers) {
-      callback(`${header.toString()}\r\n`)
-    }
-
-    callback(`\r\n`)
-
-    if (this.body) {
-      callback(this.body)
-    }
-  }
-}