velocious 1.0.2 → 1.0.3

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/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

@@ -1,22 +1,18 @@
+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) {
@@ -26,14 +22,38 @@ export default class VelociousCli {
       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 (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

@@ -1,3 +1,4 @@
+import DatabasePool from "./database/pool/index.mjs"
 import {digg} from "diggerize"
 
 export default class VelociousConfiguration {
@@ -7,9 +8,10 @@ export default class VelociousConfiguration {
     return global.velociousConfiguration
   }
 
-  constructor({debug, directory}) {
-    if (!directory) throw new Error("No directory given")
+  constructor({database, debug, directory}) {
+    if (!directory) directory = process.cwd()
 
+    this.database = database
     this.debug = debug
     this.directory = directory
   }
@@ -18,10 +20,30 @@ export default class VelociousConfiguration {
     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
+  }
 }

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})
 

package/src/database/drivers/mysql/sql/create-database.mjs

@@ -0,0 +1,4 @@
+import CreateDatabaseBase from "../../../query/create-database-base.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlCreateDatabase extends CreateDatabaseBase {
+}

package/src/database/drivers/mysql/sql/create-table.mjs

@@ -0,0 +1,4 @@
+import CreateTableBase from "../../../query/create-table-base.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlCreateTable extends CreateTableBase {
+}

package/src/database/drivers/sqlite/options.mjs

@@ -0,0 +1,17 @@
+import QueryParserOptions from "../../query-parser/options.mjs"
+
+export default class VelociousDatabaseDriversMysqlOptions extends QueryParserOptions {
+  constructor(options) {
+    options.columnQuote = "`"
+    options.stringQuote = "'"
+    options.tableQuote = "`"
+
+    super(options)
+  }
+
+  quote(string) {
+    if (!this.driver) throw new Error("Driver not set")
+
+    return this.driver.quote(string)
+  }
+}

package/src/database/drivers/sqlite/query-parser.mjs

@@ -0,0 +1,25 @@
+import {digs} from "diggerize"
+import FromParser from "../../query-parser/from-parser.mjs"
+import JoinsParser from "../../query-parser/joins-parser.mjs"
+import SelectParser from "../../query-parser/select-parser.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlQueryParser {
+  constructor({pretty, query}) {
+    if (!query) throw new Error("No query given")
+
+    this.pretty = pretty
+    this.query = query
+  }
+
+  toSql() {
+    const {pretty, query} = digs(this, "pretty", "query")
+
+    let sql = ""
+
+    sql += new SelectParser({pretty, query}).toSql()
+    sql += new FromParser({pretty, query}).toSql()
+    sql += new JoinsParser({pretty, query}).toSql()
+
+    return sql
+  }
+}

package/src/database/drivers/sqlite/sql/create-database.mjs

@@ -0,0 +1,4 @@
+import CreateDatabaseBase from "../../../query/create-database-base.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlCreateDatabase extends CreateDatabaseBase {
+}

package/src/database/drivers/sqlite/sql/create-table.mjs

@@ -0,0 +1,4 @@
+import CreateTableBase from "../../../query/create-table-base.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlCreateTable extends CreateTableBase {
+}

package/src/database/drivers/sqlite/sql/delete.mjs

@@ -0,0 +1,19 @@
+import DeleteBase from "../../../query/delete-base.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlDelete extends DeleteBase {
+  toSql() {
+    let sql = `DELETE FROM ${this.getOptions().quoteTableName(this.tableName)} WHERE `
+    let count = 0
+
+    for (let columnName in this.conditions) {
+      if (count > 0) sql += " AND "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.getOptions().quote(this.conditions[columnName])
+      count++
+    }
+
+    return sql
+  }
+}

package/src/database/drivers/sqlite/sql/insert.mjs

@@ -0,0 +1,29 @@
+import InsertBase from "../../../query/insert-base.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlInsert extends InsertBase {
+  toSql() {
+    let sql = `INSERT INTO ${this.getOptions().quoteTableName(this.tableName)} (`
+    let count = 0
+
+    for (let columnName in this.data) {
+      if (count > 0) sql += ", "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      count++
+    }
+
+    sql += ") VALUES ("
+    count = 0
+
+    for (let columnName in this.data) {
+      if (count > 0) sql += ", "
+
+      sql += this.getOptions().quote(this.data[columnName])
+      count++
+    }
+
+    sql += ")"
+
+    return sql
+  }
+}

package/src/database/drivers/sqlite/sql/update.mjs

@@ -0,0 +1,31 @@
+import UpdateBase from "../../../query/update-base.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlUpdate extends UpdateBase {
+  toSql() {
+    let sql = `UPDATE ${this.getOptions().quoteTableName(this.tableName)} SET `
+    let count = 0
+
+    for (let columnName in this.data) {
+      if (count > 0) sql += ", "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.getOptions().quote(this.data[columnName])
+      count++
+    }
+
+    sql += " WHERE "
+    count = 0
+
+    for (let columnName in this.conditions) {
+      if (count > 0) sql += " AND "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      sql += " = "
+      sql += this.getOptions().quote(this.conditions[columnName])
+      count++
+    }
+
+    return sql
+  }
+}