velocious 1.0.2 → 1.0.4

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

@@ -0,0 +1,105 @@
+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 = this.configuration.getDirectory()
+    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 executeRequireContext(requireContext) {
+    const migrationFiles = requireContext.keys()
+
+    files = migrationFiles
+      .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.runMigrationFileFromRequireContext(migration, requireContext)
+    }
+  }
+
+  async runMigrationFileFromRequireContext(migration, requireContext) {
+    if (!this.configuration) throw new Error("No configuration set")
+    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
+
+    await this.configuration.getDatabasePool().withConnection(async () => {
+      const MigrationClass = requireContext(migration.file).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}`)
+      }
+    })
+  }
+
+  async runMigrationFile(migration) {
+    if (!this.configuration) throw new Error("No configuration set")
+    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
+
+    await this.configuration.getDatabasePool().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.getDirectory()}/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

@@ -1,12 +1,36 @@
-export default class DbGenerateMigration {
-  constructor({args}) {
-    this.args = args
-  }
+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"
 
-  execute() {
-    const migrationName = this.args[1]
+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({ migrationName, date })
+      console.log(`create src/database/migrations/${migrationFileName}`)
+    }
   }
 }

package/src/cli/commands/generate/model.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"
+
+export default class DbGenerateModel extends BaseCommand {
+  async execute() {
+    const modelName = this.processArgs[1]
+    const modelNameCamelized = inflection.camelize(modelName.replaceAll("-", "_"))
+    const date = new Date()
+    const modelFileName = `${inflection.dasherize(inflection.underscore(modelName))}.mjs`
+    const __filename = fileURLToPath(`${import.meta.url}/../../..`)
+    const __dirname = dirname(__filename)
+    const templateFilePath = `${__dirname}/templates/generate-model.mjs`
+    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/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?.getDirectory() || 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/server.mjs

@@ -0,0 +1,15 @@
+import BaseCommand from "../base-command.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 = []
+
+    this.databaseConnection = await this.databasePool.spawnConnectionWithConfiguration(this.newConfiguration)
+    await this.databaseConnection.connect()
+
+    throw new Error("stub")
+  }
+}

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

@@ -1,39 +1,60 @@
+import configurationResolver from "../configuration-resolver.mjs"
 import {dirname} from "path"
 import {fileURLToPath} from "url"
-import fs from "node:fs/promises"
+import fileExists from "../utils/file-exists.mjs"
 
-const fileExists = async (path) => {
-  try {
-    await fs.access(path)
-
-    return true
-  } catch (error) {
-    return false
+export default class VelociousCli {
+  constructor(args = {}) {
+    this.args = args
   }
-}
 
-export default class VelociousCli {
-  async execute({args}) {
+  async execute() {
     const __filename = fileURLToPath(`${import.meta.url}/../..`)
     const __dirname = dirname(__filename)
-    const commandParts = args[0].split(":")
+    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"
+      if (commandPart == "s") commandPart = "server"
 
       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 (!fileExists(filePath)) throw new Error(`Unknown command: ${args[0]} which should have been in ${filePath}`)
+    if (!fileFound) throw new Error(`Unknown command: ${this.args.processArgs[0]} which should have been one of ${filePaths.join(", ")}`)
 
-    const commandClassImport = await import(filePath)
+    const commandClassImport = await import(fileFound)
     const CommandClass = commandClassImport.default
-    const commandInstance = new CommandClass({args})
 
-    await commandInstance.execute()
+    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 (Configuration.current(false)) {
+    return Configuration.current()
+  }
+
+  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

@@ -1,27 +1,65 @@
 import {digg} from "diggerize"
 
 export default class VelociousConfiguration {
-  static current() {
-    if (!global.velociousConfiguration) throw new Error("A Velocious configuration hasn't been set")
+  static current(throwError = true) {
+    if (!this.velociousConfiguration && throwError) throw new Error("A Velocious configuration hasn't been set")
 
-    return global.velociousConfiguration
+    return this.velociousConfiguration
   }
 
-  constructor({debug, directory}) {
-    if (!directory) throw new Error("No directory given")
-
+  constructor({database, debug, directory}) {
+    this.database = database
     this.debug = debug
-    this.directory = directory
+    this._directory = directory
   }
 
-  async initialize() {
-    await this.initializeRoutes()
+  getDatabasePool() {
+    if (!this.isDatabasePoolInitialized()) {
+      this.initializeDatabasePool()
+    }
+
+    return this.databasePool
+  }
+
+  getDatabasePoolType = () => {
+    const poolTypeClass = digg(this, "database", "default", "master", "poolType")
+
+    if (!poolTypeClass) {
+      throw new Error("No poolType given in database configuration")
+    }
+
+    return poolTypeClass
+  }
+
+  getDirectory = () => {
+    if (!this._directory) {
+      this._directory = process.cwd()
+    }
+
+    return this._directory
   }
 
-  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`)
+  initializeDatabasePool() {
+    if (!this.database) throw new Error("No 'database' was given")
+    if (this.databasePool) throw new Error("DatabasePool has already been initialized")
+
+    const PoolType = this.getDatabasePoolType()
+
+    this.databasePool = new PoolType({configuration: this})
+    this.databasePool.setCurrent()
+  }
+
+  isDatabasePoolInitialized = () => Boolean(this.databasePool)
+
+  initialize() {
+    // Doesn't currently do anything.
+  }
+
+  setCurrent() {
+    this.constructor.velociousConfiguration = this
+  }
 
-    this.routes = digg(routesImport, "default", "routes")
+  setRoutes(newRoutes) {
+    this.routes = newRoutes
   }
 }

package/src/controller.mjs

@@ -36,7 +36,7 @@ export default class VelociousController {
     return new Promise((resolve, reject) => {
       const actionName = digg(this, "_params", "action")
       const controllerName = digg(this, "_params", "controller")
-      const directory = digg(this, "_configuration", "directory")
+      const directory = digg(this, "_configuration").getDirectory()
       const viewPath = `${directory}/src/routes/${controllerName}/${actionName}.ejs`
       const {viewParams} = digs(this, "viewParams")
 

package/src/database/drivers/base.mjs

@@ -6,4 +6,12 @@ export default class VelociousDatabaseDriversBase {
   getArgs() {
     return this._args
   }
+
+  getIdSeq() {
+    return this.idSeq
+  }
+
+  setIdSeq(id) {
+    this.idSeq = id
+  }
 }

package/src/database/drivers/mysql/index.mjs

@@ -1,5 +1,7 @@
 import Base from "../base.mjs"
 import connectConnection from "./connect-connection.mjs"
+import CreateDatabase from "./sql/create-database.mjs"
+import CreateTable from "./sql/create-table.mjs"
 import Delete from "./sql/delete.mjs"
 import {digg} from "diggerize"
 import Insert from "./sql/insert.mjs"
@@ -35,6 +37,25 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return connectArgs
   }
 
+  async close() {
+    await this.connection.end()
+    this.connection = undefined
+  }
+
+  createDatabaseSql(databaseName, args) {
+    const createArgs = Object.assign({databaseName, driver: this}, args)
+    const createDatabase = new CreateDatabase(createArgs)
+
+    return createDatabase.toSql()
+  }
+
+  createTableSql(tableData) {
+    const createArgs = Object.assign({tableData, driver: this})
+    const createTable = new CreateTable(createArgs)
+
+    return createTable.toSql()
+  }
+
   async query(sql) {
     return await query(this.connection, sql)
   }
@@ -49,6 +70,10 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return this.connection.escape(string)
   }
 
+  quoteColumn(string) {
+    return `\`${string}\``
+  }
+
   deleteSql({tableName, conditions}) {
     const deleteInstruction = new Delete({conditions, driver: this, tableName})