velocious 1.0.3 → 1.0.5

package/.github/dependabot.yml

@@ -5,5 +5,5 @@ updates:
   schedule:
     interval: weekly
     time: "01:00"
-    timezone: Europe/Copenhagen
+    timezone: Europe/Berlin
   open-pull-requests-limit: 99

package/README.md

@@ -22,13 +22,19 @@ npx velocious init
 # Migrations
 
 ```bash
-npx velocious db:g:migration create_tasks
+npx velocious g:migration create_tasks
 ```
 
 ```bash
 npx velocious db:migrate
 ```
 
+# Models
+
+```bash
+npx velocious g:model Option
+```
+
 # Testing
 
 ```bash

package/bin/velocious.mjs

@@ -1,8 +1,8 @@
-#!/usr/bin/node
+#!/usr/bin/env node
 
 import Cli from "../src/cli/index.mjs"
 
 const processArgs = process.argv.slice(2)
 const cli = new Cli({processArgs})
 
-cli.execute()
+await cli.execute()

package/index.mjs

@@ -1,21 +1 @@
-import Application from "./src/application.mjs"
-import Cli from "./src/cli/index.mjs"
-import Configuration from "./src/configuration.mjs"
-import Controller from "./src/controller.mjs"
-import Database from "./src/database/index.mjs"
-import DatabasePool from "./src/database/pool/index.mjs"
-import HttpServer from "./src/http-server/index.mjs"
-import Routes from "./src/routes/index.mjs"
-import Spec from "./src/spec/index.mjs"
-
-export {
-  Application,
-  Cli,
-  Configuration,
-  Controller,
-  Database,
-  DatabasePool,
-  HttpServer,
-  Routes,
-  Spec
-}
+export {}

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.mjs"
   },
   "name": "velocious",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "main": "index.mjs",
   "scripts": {
     "test": "jasmine",
@@ -32,6 +32,8 @@
     "escape-string-regexp": "^1.0.5",
     "incorporator": "^1.0.2",
     "inflection": "^3.0.0",
+    "sql-escape-string": "^1.1.0",
+    "sql.js": "^1.12.0",
     "strftime": "^0.10.2"
   }
 }

package/peak_flow.yml

@@ -1,6 +1,6 @@
 before_install:
   - sudo mkdir -p /etc/apt/keyrings
-  - curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
+  - curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --no-tty --batch --yes --dearmor -o /etc/apt/keyrings/nodesource.gpg
   - echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list
   - sudo apt-get update
   - sudo apt-get install -y nodejs

package/spec/cli/commands/db/create-spec.mjs

@@ -14,7 +14,7 @@ describe("Cli - Commands - db:create", () => {
       [
         {
           databaseName: 'velocious_test',
-          sql: 'CREATE DATABASE IF NOT EXISTS velocious_test'
+          sql: 'CREATE DATABASE IF NOT EXISTS `velocious_test`'
         },
         {
           createSchemaMigrationsTableSql: 'CREATE TABLE IF NOT EXISTS schema_migrations (`version` varchar(255) PRIMARY KEY)'

package/spec/database/connection/drivers/mysql/query-parser-spec.mjs

@@ -1,4 +1,5 @@
-import Database from "../../../../../src/database/index.mjs"
+import DatabaseHandler from "../../../../../src/database/handler.mjs"
+import DatabaseQuery from "../../../../../src/database/query/index.mjs"
 import MysqlQueryParser from "../../../../../src/database/drivers/mysql/query-parser.mjs"
 
 import FromTable from "../../../../../src/database/query/from-table.mjs"
@@ -10,8 +11,8 @@ const mysqlDriver = new MysqlDriverClass()
 
 describe("database - connection - drivers - mysql - query parser", () => {
   it("generates sql with selects, joins and orders", () => {
-    const handler = new Database.Handler()
-    const query = new Database.Query({driver: mysqlDriver, handler})
+    const handler = new DatabaseHandler()
+    const query = new DatabaseQuery({driver: mysqlDriver, handler})
       .select(["tasks.id", "tasks.name"])
       .from("tasks")
       .joins("LEFT JOIN projects ON projects.id = tasks.project_id")
@@ -22,8 +23,8 @@ describe("database - connection - drivers - mysql - query parser", () => {
   })
 
   it("generates sql with selects, joins and orders", () => {
-    const handler = new Database.Handler()
-    const query = new Database.Query({driver: mysqlDriver, handler})
+    const handler = new DatabaseHandler()
+    const query = new DatabaseQuery({driver: mysqlDriver, handler})
       .select([
         new SelectTableAndColumn({tableName: "tasks", columnName: "id"}),
         new SelectTableAndColumn({tableName: "tasks", columnName: "name"})

package/spec/database/drivers/mysql/connection-spec.mjs

@@ -1,13 +1,12 @@
-import Database from "../../../../src/database/index.mjs"
+import DatabaseDriversMysql from "../../../../src/database/drivers/mysql/index.mjs"
 import configuration from "../../../dummy/src/config/configuration.mjs"
 import {digg} from "diggerize"
 
 const mysqlConfig = digg(configuration, "database", "default", "master")
-const Mysql = Database.Drivers.Mysql
 
 describe("Database - Drivers - Mysql - Connection", () => {
   it("connects", async () => {
-    const mysql = new Mysql(mysqlConfig)
+    const mysql = new DatabaseDriversMysql(mysqlConfig)
 
     await mysql.connect()
 

package/spec/dummy/index.mjs

@@ -3,11 +3,11 @@ import dummyConfiguration from "./src/config/configuration.mjs"
 
 export default class Dummy {
   static current() {
-    if (!global.velociousDummy) {
-      global.velociousDummy = new Dummy()
+    if (!this.velociousDummy) {
+      this.velociousDummy = new Dummy()
     }
 
-    return global.velociousDummy
+    return this.velociousDummy
   }
 
   static async prepare() {
@@ -37,7 +37,9 @@ export default class Dummy {
   }
 
   async start() {
-    if (!dummyConfiguration.isDatabasePoolInitialized()) await dummyConfiguration.initializeDatabasePool()
+    if (!dummyConfiguration.isDatabasePoolInitialized()) {
+      await dummyConfiguration.initializeDatabasePool()
+    }
 
     this.application = new Application({
       configuration: dummyConfiguration,

package/spec/dummy/src/config/configuration.example.mjs

@@ -1,10 +1,14 @@
+import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.mjs"
 import Configuration from "../../../../src/configuration.mjs"
 import dummyDirectory from "../../dummy-directory.mjs"
+import MysqlDriver from "../../../../src/database/drivers/mysql/index.mjs"
 
-const configuration = new Configuration({
+export default new Configuration({
   database: {
     default: {
       master: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
         type: "mysql",
         host: "mariadb",
         username: "username",
@@ -15,5 +19,3 @@ const configuration = new Configuration({
   },
   directory: dummyDirectory()
 })
-
-export default configuration

package/spec/dummy/src/config/configuration.peakflow.mjs

@@ -1,10 +1,14 @@
+import AsyncTrackedMultiConnection from "../../../../src/database/pool/async-tracked-multi-connection.mjs"
 import Configuration from "../../../../src/configuration.mjs"
 import dummyDirectory from "../../dummy-directory.mjs"
+import MysqlDriver from "../../../../src/database/drivers/mysql/index.mjs"
 
-const configuration = new Configuration({
+export default new Configuration({
   database: {
     default: {
       master: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
         type: "mysql",
         host: "mariadb",
         username: "peakflow",
@@ -16,5 +20,3 @@ const configuration = new Configuration({
   },
   directory: dummyDirectory()
 })
-
-export default configuration

package/spec/dummy/src/models/task.mjs

@@ -1,4 +1,4 @@
-import Database from "../../../../src/database/index.mjs"
+import DatabaseRecord from "../../../../src/database/record/index.mjs"
 
-export default class Task extends Database.Record {
+export default class Task extends DatabaseRecord {
 }

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

@@ -1,3 +1,4 @@
+import AppRoutes from "../../src/routes/app-routes.mjs"
 import Client from "../../src/http-server/client/index.mjs"
 import {digg} from "diggerize"
 import dummyConfiguration from "../dummy/src/config/configuration.mjs"
@@ -6,6 +7,10 @@ describe("http server - client", () => {
   it("spawns a request for each that it is fed", async () => {
     await dummyConfiguration.initialize()
 
+    const routes = await AppRoutes.getRoutes(dummyConfiguration)
+
+    dummyConfiguration.setRoutes(routes)
+
     const client = new Client({
       clientCount: 0,
       configuration: dummyConfiguration

package/src/application.mjs

@@ -1,3 +1,4 @@
+import AppRoutes from "../src/routes/app-routes.mjs"
 import {digs} from "diggerize"
 import logger from "./logger.mjs"
 import HttpServer from "./http-server/index.mjs"
@@ -9,8 +10,12 @@ export default class VelociousApplication {
   }
 
   async initialize() {
+    const routes = await AppRoutes.getRoutes(this.configuration)
+
     await this.configuration.initialize()
 
+    this.configuration.setRoutes(routes)
+
     if (!this.configuration.isDatabasePoolInitialized()) {
       await this.configuration.initializeDatabasePool()
     }

package/src/cli/base-command.mjs

@@ -7,5 +7,5 @@ export default class VelociousCliBaseCommand {
     this.processArgs = args.processArgs
   }
 
-  directory = () => digg(this, "configuration", "directory")
+  directory = () => digg(this, "configuration").getDirectory()
 }

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

@@ -5,7 +5,7 @@ import inflection from "inflection"
 
 export default class DbMigrate extends BaseCommand {
   async execute() {
-    const projectPath = digg(this.configuration, "directory")
+    const projectPath = this.configuration.getDirectory()
     const migrationsPath = `${projectPath}/src/database/migrations`
     let files = await fs.readdir(migrationsPath)
 
@@ -34,12 +34,59 @@ export default class DbMigrate extends BaseCommand {
     }
   }
 
-  async runMigrationFile(migration) {
-    if (!this.configuration.isDatabasePoolInitialized()) {
-      await this.configuration.initializeDatabasePool()
+  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.databasePool.withConnection(async () => {
+    await this.configuration.getDatabasePool().withConnection(async () => {
       const migrationImport = await import(migration.fullPath)
       const MigrationClass = migrationImport.default
       const migrationInstance = new MigrationClass({

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

@@ -4,7 +4,7 @@ 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 migrationDir = `${this.configuration.getDirectory()}/src/database/migrations`
     const migrationFiles = await fs.readdir(migrationDir)
     const destroyed = []
 

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

@@ -22,7 +22,7 @@ export default class DbGenerateMigration extends BaseCommand {
     const migrationPath = `${migrationDir}/${migrationFileName}`
 
     if (this.args.testing) {
-      return {date, migrationContent, migrationName, migrationNameCamelized, migrationNumber, migrationPath }
+      return {date, migrationContent, migrationName, migrationNameCamelized, migrationNumber, migrationPath}
     } else {
       if (!await fileExists(migrationDir)) {
         await fs.mkdir(migrationDir, {recursive: true})

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

@@ -8,7 +8,7 @@ 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 projectPath = this.configuration?.getDirectory() || process.cwd()
     const projectConfigPath = `${projectPath}/src/config`
     const fileMappings = [
       {

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/index.mjs

@@ -18,6 +18,7 @@ export default class VelociousCli {
     for (let commandPart of commandParts) {
       if (commandPart == "d") commandPart = "destroy"
       if (commandPart == "g") commandPart = "generate"
+      if (commandPart == "s") commandPart = "server"
 
       filePath += `/${commandPart}`
     }

package/src/configuration-resolver.mjs

@@ -1,8 +1,8 @@
 import Configuration from "./configuration.mjs"
 
 const configurationResolver = async (args) => {
-  if (global.velociousConfiguration) {
-    return global.velociousConfiguration
+  if (Configuration.current(false)) {
+    return Configuration.current()
   }
 
   const directory = args.directory || process.cwd()

package/src/configuration.mjs

@@ -1,49 +1,65 @@
-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")
+  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({database, debug, directory}) {
-    if (!directory) directory = process.cwd()
-
     this.database = database
     this.debug = debug
-    this.directory = directory
-  }
-
-  async initialize() {
-    await this.initializeRoutes()
+    this._directory = directory
   }
 
   getDatabasePool() {
-    if (!this.isDatabasePoolInitialized()) this.initializeDatabasePool()
+    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
+  }
+
   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})
+    const PoolType = this.getDatabasePoolType()
+
+    this.databasePool = new PoolType({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")
+  initialize() {
+    // Doesn't currently do anything.
   }
 
   setCurrent() {
-    global.velociousConfiguration = this
+    this.constructor.velociousConfiguration = this
+  }
+
+  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

@@ -1,8 +1,23 @@
+import Query from "../query/index.mjs"
+import Handler from "../handler.mjs"
+
 export default class VelociousDatabaseDriversBase {
   constructor(args) {
     this._args = args
   }
 
+  async createTable(...args) {
+    const sql = this.createTableSql(...args)
+
+    await this.query(sql)
+  }
+
+  async delete(...args) {
+    const sql = this.deleteSql(...args)
+
+    await this.query(sql)
+  }
+
   getArgs() {
     return this._args
   }
@@ -11,7 +26,33 @@ export default class VelociousDatabaseDriversBase {
     return this.idSeq
   }
 
+  async insert(...args) {
+    const sql = this.insertSql(...args)
+
+    await this.query(sql)
+  }
+
+  async select(tableName) {
+    const handler = new Handler()
+    const query = new Query({
+      driver: this,
+      handler
+    })
+
+    const sql = query
+      .from(tableName)
+      .toSql()
+
+    return await this.query(sql)
+  }
+
   setIdSeq(id) {
     this.idSeq = id
   }
+
+  async update(...args) {
+    const sql = this.updateSql(...args)
+
+    await this.query(sql)
+  }
 }

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

@@ -0,0 +1,36 @@
+import Base from "../base.mjs"
+import CreateTable from "../sqlite/sql/create-table.mjs"
+import Delete from "../sqlite/sql/delete.mjs"
+import Insert from "../sqlite/sql/insert.mjs"
+import QueryParser from "../sqlite/query-parser.mjs"
+import Table from "./table"
+import Update from "../sqlite/sql/update.mjs"
+
+export default class VelociousDatabaseDriversSqliteBase extends Base {
+  createTableSql(tableData) {
+    const createArgs = Object.assign({tableData, driver: this})
+    const createTable = new CreateTable(createArgs)
+
+    return createTable.toSql()
+  }
+
+  deleteSql = ({tableName, conditions}) => new Delete({conditions, driver: this, tableName}).toSql()
+  insertSql = ({tableName, data}) => new Insert({driver: this, tableName, data}).toSql()
+
+  async getTables() {
+    const result = await this.query("SELECT name FROM sqlite_master WHERE type = 'table'")
+    const tables = []
+
+    for (const row of result) {
+      const table = new Table(row)
+
+      tables.push(table)
+    }
+
+    return tables
+  }
+
+  queryToSql = (query) => new QueryParser({query}).toSql()
+  quoteColumn = (string) => `\`${string}\``
+  updateSql = ({conditions, data, tableName}) => new Update({conditions, data, driver: this, tableName}).toSql()
+}