velocious 1.0.1 → 1.0.3

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

@@ -0,0 +1,72 @@
+import fetch from "node-fetch"
+import Dummy from "../dummy/index.mjs"
+import querystring from "querystring"
+import Task from "../dummy/src/models/task.mjs"
+
+describe("HttpServer", () => {
+  it("handles post requests", async () => {
+    await Dummy.run(async () => {
+      const postData = querystring.stringify({"task[name]": "Test create task"})
+      const response = await fetch(
+        "http://localhost:3006/tasks",
+        {
+          body: postData,
+          headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Content-Length": Buffer.byteLength(postData)
+          },
+          method: "POST"
+        }
+      )
+      const text = await response.text()
+      const createdTask = await Task.last()
+
+      expect(text).toEqual('{"status":"success"}')
+      expect(createdTask.readAttribute("name")).toEqual("Test create task")
+    })
+  })
+
+  it("handles post json requests", async () => {
+    await Dummy.run(async () => {
+      const postData = JSON.stringify({task: {name: "Test create task"}})
+      const response = await fetch(
+        "http://localhost:3006/tasks",
+        {
+          body: postData,
+          headers: {
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(postData)
+          },
+          method: "POST"
+        }
+      )
+      const text = await response.text()
+      const createdTask = await Task.last()
+
+      expect(text).toEqual('{"status":"success"}')
+      expect(createdTask.readAttribute("name")).toEqual("Test create task")
+    })
+  })
+
+  it("handles post form-data requests", async () => {
+    await Dummy.run(async () => {
+      const body = new FormData()
+
+      body.append("task[name]", "Test create task")
+      body.append("task[description]", "This is a task")
+
+      const response = await fetch(
+        "http://localhost:3006/tasks",
+        {
+          body,
+          method: "POST"
+        }
+      )
+      const text = await response.text()
+      const createdTask = await Task.last()
+
+      expect(text).toEqual('{"status":"success"}')
+      expect(createdTask.readAttribute("name")).toEqual("Test create task")
+    })
+  })
+})

package/spec/support/jasmine.json

@@ -1,11 +1,12 @@
 {
   "spec_dir": "spec",
   "spec_files": [
-    "**/*[sS]pec.cjs"
+    "**/*-spec.mjs"
   ],
   "helpers": [
-    "helpers/**/*.cjs"
+    "helpers/**/*.mjs"
   ],
   "stopSpecOnExpectationFailure": false,
-  "random": false
+  "random": false,
+  "jsLoader": "import"
 }

package/src/application.mjs

@@ -0,0 +1,50 @@
+import {digs} from "diggerize"
+import logger from "./logger.mjs"
+import HttpServer from "./http-server/index.mjs"
+
+export default class VelociousApplication {
+  constructor({configuration, httpServer}) {
+    this.configuration = configuration
+    this.httpServerConfiguration = httpServer ?? {}
+  }
+
+  async initialize() {
+    await this.configuration.initialize()
+
+    if (!this.configuration.isDatabasePoolInitialized()) {
+      await this.configuration.initializeDatabasePool()
+    }
+  }
+
+  isActive() {
+    return this.httpServer?.isActive()
+  }
+
+  async run(callback) {
+    await this.start()
+
+    try {
+      await callback()
+    } finally {
+      this.stop()
+    }
+  }
+
+  async startHttpServer() {
+    const {configuration, httpServerConfiguration} = digs(this, "configuration", "httpServerConfiguration")
+
+    const port = httpServerConfiguration.port || 3006
+
+    logger(this, `Starting server on port ${port}`)
+
+    this.httpServer = new HttpServer({configuration, port})
+
+    await this.httpServer.start()
+  }
+
+  async stop() {
+    logger(this, "Stopping server")
+
+    await this.httpServer.stop()
+  }
+}

package/src/cli/base-command.mjs

@@ -0,0 +1,11 @@
+import {digg} from "diggerize"
+
+export default class VelociousCliBaseCommand {
+  constructor(args) {
+    this.args = args
+    this.configuration = this.args.configuration
+    this.processArgs = args.processArgs
+  }
+
+  directory = () => digg(this, "configuration", "directory")
+}

package/src/cli/commands/db/create.mjs

@@ -0,0 +1,50 @@
+import BaseCommand from "../../base-command.mjs"
+import {digg} from "diggerize"
+import TableData from "../../../database/table-data/index.mjs"
+
+export default class DbCreate extends BaseCommand{
+  async execute() {
+    this.databasePool = this.configuration.getDatabasePool()
+    this.newConfiguration = Object.assign({}, this.databasePool.getConfiguration())
+
+    if (this.args.testing) this.result = []
+
+    // Use a database known to exist. Since we are creating the database, it shouldn't actually exist which would make connecting fail.
+    this.newConfiguration.database = this.newConfiguration.useDatabase || "mysql"
+
+    this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
+    await this.databaseConnection.connect()
+
+    this.createDatabase()
+    await this.createSchemaMigrationsTable()
+
+    await this.databaseConnection.close()
+
+    if (this.args.testing) return this.result
+  }
+
+  async createDatabase() {
+    const databaseName = digg(this.databasePool.getConfiguration(), "database")
+    const sql = this.databaseConnection.createDatabaseSql(databaseName, {ifNotExists: true})
+
+    if (this.args.testing) {
+      this.result.push({databaseName, sql})
+    } else {
+      await this.databaseConnection.query(sql)
+    }
+  }
+
+  async createSchemaMigrationsTable() {
+    const schemaMigrationsTable = new TableData("schema_migrations", {ifNotExists: true})
+
+    schemaMigrationsTable.string("version", {null: false, primaryKey: true})
+
+    const createSchemaMigrationsTableSql = this.databaseConnection.createTableSql(schemaMigrationsTable)
+
+    if (this.args.testing) {
+      this.result.push({createSchemaMigrationsTableSql})
+    } else {
+      await this.databaseConnection.query(createSchemaMigrationsTableSql)
+    }
+  }
+}

package/src/cli/commands/db/migrate.mjs

@@ -0,0 +1,58 @@
+import BaseCommand from "../../base-command.mjs"
+import {digg} from "diggerize"
+import fs from "node:fs/promises"
+import inflection from "inflection"
+
+export default class DbMigrate extends BaseCommand {
+  async execute() {
+    const projectPath = digg(this.configuration, "directory")
+    const migrationsPath = `${projectPath}/src/database/migrations`
+    let files = await fs.readdir(migrationsPath)
+
+    files = files
+      .map((file) => {
+        const match = file.match(/^(\d{14})-(.+)\.mjs$/)
+
+        if (!match) return null
+
+        const date = parseInt(match[1])
+        const migrationName = match[2]
+        const migrationClassName = inflection.camelize(migrationName)
+
+        return {
+          file,
+          fullPath: `${migrationsPath}/${file}`,
+          date,
+          migrationClassName
+        }
+      })
+      .filter((migration) => Boolean(migration))
+      .sort((migration1, migration2) => migration1.date - migration2.date)
+
+    for (const migration of files) {
+      await this.runMigrationFile(migration)
+    }
+  }
+
+  async runMigrationFile(migration) {
+    if (!this.configuration.isDatabasePoolInitialized()) {
+      await this.configuration.initializeDatabasePool()
+    }
+
+    await this.configuration.databasePool.withConnection(async () => {
+      const migrationImport = await import(migration.fullPath)
+      const MigrationClass = migrationImport.default
+      const migrationInstance = new MigrationClass({
+        configuration: this.configuration
+      })
+
+      if (migrationInstance.change) {
+        await migrationInstance.change()
+      } else if (migrationInstance.up) {
+        await migrationInstance.up()
+      } else {
+        throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`)
+      }
+    })
+  }
+}

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

@@ -0,0 +1,35 @@
+import BaseCommand from "../../base-command.mjs"
+import fs from "node:fs/promises"
+
+export default class DbDestroyMigration extends BaseCommand {
+  async execute() {
+    const migrationName = this.processArgs[1]
+    const migrationDir = `${this.configuration.directory}/src/database/migrations`
+    const migrationFiles = await fs.readdir(migrationDir)
+    const destroyed = []
+
+    for (const migrationFile of migrationFiles) {
+      const match = migrationFile.match(/^(\d{14})-(.+)\.mjs$/)
+
+      if (!match) {
+        continue
+      }
+
+      const fileName = match[2]
+
+      if (fileName != migrationName) continue
+
+      const fullFilePath = `${migrationDir}/${migrationFile}`
+      destroyed.push(fileName)
+
+      if (!this.args.testing) {
+        console.log(`Destroy src/database/migrations/${migrationFile}`)
+        await fs.unlink(fullFilePath)
+      }
+    }
+
+    if (this.args.testing) {
+      return {destroyed}
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+import BaseCommand from "../../base-command.mjs"
+import {dirname} from "path"
+import {fileURLToPath} from "url"
+import fileExists from "../../../utils/file-exists.mjs"
+import fs from "node:fs/promises"
+import inflection from "inflection"
+import strftime from "strftime"
+
+export default class DbGenerateMigration extends BaseCommand {
+  async execute() {
+    const migrationName = this.processArgs[1]
+    const migrationNameCamelized = inflection.camelize(migrationName.replaceAll("-", "_"))
+    const date = new Date()
+    const migrationNumber = strftime("%Y%m%d%H%M%S")
+    const migrationFileName = `${migrationNumber}-${migrationName}.mjs`
+    const __filename = fileURLToPath(`${import.meta.url}/../../..`)
+    const __dirname = dirname(__filename)
+    const templateFilePath = `${__dirname}/templates/generate-migration.mjs`
+    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/src/cli/commands/init.mjs

@@ -0,0 +1,60 @@
+import BaseCommand from "../base-command.mjs"
+import {dirname} from "path"
+import fileExists from "../../utils/file-exists.mjs"
+import {fileURLToPath} from "url"
+import fs from "node:fs/promises"
+
+export default class VelociousCliCommandsInit extends BaseCommand {
+  async execute() {
+    const __filename = fileURLToPath(`${import.meta.url}/../../..`)
+    const velocipusPath = dirname(__filename)
+    const projectPath = this.configuration?.directory || process.cwd()
+    const projectConfigPath = `${projectPath}/src/config`
+    const fileMappings = [
+      {
+        source: `${velocipusPath}/src/templates/configuration.mjs`,
+        target: `${projectConfigPath}/configuration.mjs`
+      },
+      {
+        source: `${velocipusPath}/src/templates/routes.mjs`,
+        target: `${projectConfigPath}/routes.mjs`
+      }
+    ]
+    const paths = [
+      projectConfigPath,
+      `${projectPath}/database/migrations`
+    ]
+
+    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/cli/commands/test/index.mjs

@@ -0,0 +1,14 @@
+import BaseCommand from "../../base-command.mjs"
+import TestFilesFinder from "./test-files-finder.mjs"
+import TestRunner from "./test-runner.mjs"
+
+export default class VelociousCliCommandsInit extends BaseCommand {
+  async execute() {
+    const testFilesFinder = new TestFilesFinder({directory: this.directory(), processArgs: this.processArgs})
+    const testFiles = await testFilesFinder.findTestFiles()
+
+    const testRunner = new TestRunner(testFiles)
+
+    await testRunner.run()
+  }
+}

package/src/cli/commands/test/test-files-finder.mjs

@@ -0,0 +1,99 @@
+import fs from "fs/promises"
+
+// 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}) {
+    this.directory = directory
+    this.foundFiles = []
+    this.findingCount = 0
+    this.findingPromises = {}
+    this.processArgs = processArgs
+    this.testArgs = this.processArgs.filter((processArg, index) => index != 0)
+  }
+
+  async findTestFiles() {
+    await this.withFindingCount(async () => {
+      await this.findTestFilesInDir(this.directory)
+    })
+
+    await this.waitForFindingPromises()
+
+    return this.foundFiles
+  }
+
+  findingPromisesLength = () => Object.keys(this.findingPromises).length
+
+  async waitForFindingPromises() {
+    while (this.findingPromisesLength() > 0) {
+      await this.waitForFindingPromisesIteration()
+    }
+  }
+
+  async waitForFindingPromisesIteration() {
+    const unfinishedPromises = []
+
+    for (const findingPromiseId in this.findingPromises) {
+      const findingPromise = this.findingPromises[findingPromiseId]
+
+      unfinishedPromises.push(findingPromise)
+    }
+
+    await Promise.all(unfinishedPromises)
+  }
+
+  withFindingCount(callback) {
+    return new Promise((resolve) => {
+      const findingPromise = callback()
+      const findingCount = this.findingCount
+
+      this.findingCount += 1
+      this.findingPromises[findingCount] = findingPromise
+
+      findingPromise.finally(() => {
+        delete this.findingPromises[findingCount]
+
+        resolve()
+      })
+    })
+  }
+
+  async findTestFilesInDir(dir) {
+    await this.withFindingCount(async () => {
+      const files = await fs.readdir(dir)
+
+      for (const file of files) {
+        if (TestFilesFinder.IGNORED_NAMES.includes(file)) {
+          continue
+        }
+
+        const fullPath = `${dir}/${file}`
+        const localPath = fullPath.replace(`${this.directory}/`, "")
+        const isDir = (await fs.stat(fullPath)).isDirectory()
+
+        if (isDir) {
+          this.findTestFilesInDir(fullPath)
+        } else {
+          if (this.isFileMatchingRequirements(file, localPath, fullPath)) {
+            this.foundFiles.push(fullPath)
+          }
+        }
+      }
+    })
+  }
+
+  isFileMatchingRequirements(file, localPath, fullPath) {
+    if (this.testArgs.length > 0) {
+      for (const testArg of this.testArgs) {
+        if (testArg == localPath) {
+          return true
+        }
+      }
+    } else if (file.match(/-spec\.mjs/)) {
+      return true
+    }
+
+    return false
+  }
+}

package/src/cli/commands/test/test-runner.mjs

@@ -0,0 +1,19 @@
+export default class TestRunner {
+  constructor(testFiles) {
+    this.testFiles = testFiles
+  }
+
+  async importTestFiles() {
+    for (const testFile of this.testFiles) {
+      const importTestFile = await import(testFile)
+    }
+  }
+
+  async run() {
+    await this.importTestFiles()
+
+    console.log({foundTestFiles: this.testFiles})
+
+    throw new Error("stub")
+  }
+}

package/src/cli/index.mjs

@@ -0,0 +1,59 @@
+import configurationResolver from "../configuration-resolver.mjs"
+import {dirname} from "path"
+import {fileURLToPath} from "url"
+import fileExists from "../utils/file-exists.mjs"
+
+export default class VelociousCli {
+  constructor(args = {}) {
+    this.args = args
+  }
+
+  async execute() {
+    const __filename = fileURLToPath(`${import.meta.url}/../..`)
+    const __dirname = dirname(__filename)
+    const commandParts = this.args.processArgs[0].split(":")
+    const filePaths = []
+    let filePath = `${__dirname}/src/cli/commands`
+
+    for (let commandPart of commandParts) {
+      if (commandPart == "d") commandPart = "destroy"
+      if (commandPart == "g") commandPart = "generate"
+
+      filePath += `/${commandPart}`
+    }
+
+    filePaths.push(`${filePath}/index.mjs`)
+    filePath += ".mjs"
+    filePaths.push(filePath)
+
+    let fileFound
+
+    for (const aFilePath of filePaths) {
+      if (await fileExists(aFilePath)) {
+        fileFound = aFilePath
+        break
+      }
+    }
+
+    if (!fileFound) throw new Error(`Unknown command: ${this.args.processArgs[0]} which should have been one of ${filePaths.join(", ")}`)
+
+    const commandClassImport = await import(fileFound)
+    const CommandClass = commandClassImport.default
+
+    await this.loadConfiguration()
+
+    const commandInstance = new CommandClass(this.args)
+
+    if (commandInstance.initialize) {
+      await commandInstance.initialize()
+    }
+
+    return await commandInstance.execute()
+  }
+
+  async loadConfiguration() {
+    this.configuration = await configurationResolver({directory: this.args.directory})
+    this.configuration.setCurrent()
+    this.args.configuration = this.configuration
+  }
+}

package/src/configuration-resolver.mjs

@@ -0,0 +1,26 @@
+import Configuration from "./configuration.mjs"
+
+const configurationResolver = async (args) => {
+  if (global.velociousConfiguration) {
+    return global.velociousConfiguration
+  }
+
+  const directory = args.directory || process.cwd()
+  const configurationPath = `${directory}/src/config/configuration.mjs`
+  let configuration
+
+  try {
+    const configurationImport = await import(configurationPath)
+
+    configuration = configurationImport.default
+  } catch (error) {
+    // This might happen during an "init" CLI command where we copy a sample configuration file.
+    if (error.code != "ERR_MODULE_NOT_FOUND") throw error
+
+    configuration = new Configuration(args)
+  }
+
+  return configuration
+}
+
+export default configurationResolver

package/src/configuration.mjs

@@ -0,0 +1,49 @@
+import DatabasePool from "./database/pool/index.mjs"
+import {digg} from "diggerize"
+
+export default class VelociousConfiguration {
+  static current() {
+    if (!global.velociousConfiguration) throw new Error("A Velocious configuration hasn't been set")
+
+    return global.velociousConfiguration
+  }
+
+  constructor({database, debug, directory}) {
+    if (!directory) directory = process.cwd()
+
+    this.database = database
+    this.debug = debug
+    this.directory = directory
+  }
+
+  async initialize() {
+    await this.initializeRoutes()
+  }
+
+  getDatabasePool() {
+    if (!this.isDatabasePoolInitialized()) this.initializeDatabasePool()
+
+    return this.databasePool
+  }
+
+  initializeDatabasePool() {
+    if (!this.database) throw new Error("No 'database' was given")
+    if (this.databasePool) throw new Error("DatabasePool has already been initialized")
+
+    this.databasePool = new DatabasePool({configuration: this})
+    this.databasePool.setCurrent()
+  }
+
+  isDatabasePoolInitialized = () => Boolean(this.databasePool)
+
+  async initializeRoutes() {
+    // Every client need to make their own routes because they probably can't be shared across different worker threads
+    const routesImport = await import(`${this.directory}/src/config/routes.mjs`)
+
+    this.routes = digg(routesImport, "default", "routes")
+  }
+
+  setCurrent() {
+    global.velociousConfiguration = this
+  }
+}