velocious 1.0.2 → 1.0.3

package/README.md

@@ -9,7 +9,17 @@ This is still work in progress.
 * Migrations ala Rails
 * Controllers and views ala Rails
 
-## Migrations
+# Setup
+
+Make a new NPM project.
+```bash
+mkdir project
+cd project
+npm install velocious
+npx velocious init
+```
+
+# Migrations
 
 ```bash
 npx velocious db:g:migration create_tasks
@@ -19,7 +29,7 @@ npx velocious db:g:migration create_tasks
 npx velocious db:migrate
 ```
 
-## Testing
+# Testing
 
 ```bash
 npm test

package/bin/velocious.mjs

@@ -2,7 +2,7 @@
 
 import Cli from "../src/cli/index.mjs"
 
-const cli = new Cli()
-const args = process.argv.slice(2)
+const processArgs = process.argv.slice(2)
+const cli = new Cli({processArgs})
 
-cli.execute({args})
+cli.execute()

package/index.mjs

@@ -1,17 +1,21 @@
 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
+  Routes,
+  Spec
 }

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.mjs"
   },
   "name": "velocious",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "main": "index.mjs",
   "scripts": {
     "test": "jasmine",
@@ -27,10 +27,11 @@
     "node-fetch": "^3.3.1"
   },
   "dependencies": {
-    "diggerize": "^1.0.3",
+    "diggerize": "^1.0.5",
     "ejs": "^3.1.6",
     "escape-string-regexp": "^1.0.5",
     "incorporator": "^1.0.2",
-    "inflection": "^2.0.0"
+    "inflection": "^3.0.0",
+    "strftime": "^0.10.2"
   }
 }

package/peak_flow.yml

@@ -1,8 +1,11 @@
 before_install:
-  - curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
+  - 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
+  - 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
 before_script:
-  - cp spec/dummy/src/config/database.peakflow.mjs spec/dummy/src/config/database.mjs
+  - cp spec/dummy/src/config/configuration.peakflow.mjs spec/dummy/src/config/configuration.mjs
   - npm install
   - wait-for-it mariadb:3306
 services:

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

@@ -0,0 +1,25 @@
+import Cli from "../../../../src/cli/index.mjs"
+import dummyDirectory from "../../../dummy/dummy-directory.mjs"
+
+describe("Cli - Commands - db:create", () => {
+  it("generates SQL to create a new database", async () => {
+    const cli = new Cli({
+      directory: dummyDirectory(),
+      processArgs: ["db:create"],
+      testing: true
+    })
+    const result = await cli.execute()
+
+    expect(result).toEqual(
+      [
+        {
+          databaseName: '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/cli/commands/db/migrate-spec.mjs

@@ -0,0 +1,37 @@
+import Cli from "../../../../src/cli/index.mjs"
+import dummyDirectory from "../../../dummy/dummy-directory.mjs"
+
+describe("Cli - Commands - db:migrate", () => {
+  it("runs migrations", async () => {
+    const directory = dummyDirectory()
+    const cli = new Cli({
+      directory,
+      processArgs: ["db:migrate"],
+      testing: true
+    })
+
+    await cli.loadConfiguration()
+
+    const db = cli.configuration.getDatabasePool()
+
+    await db.withConnection(async () => {
+      await db.query("DROP TABLE IF EXISTS tasks")
+      await db.query("DROP TABLE IF EXISTS projects")
+    })
+
+    await cli.execute()
+
+    let tablesResult
+
+    await db.withConnection(async () => {
+      tablesResult = await db.query("SHOW TABLES")
+    })
+
+    expect(tablesResult).toEqual(
+      [
+        {Tables_in_velocious_test: "projects"},
+        {Tables_in_velocious_test: "tasks"}
+      ]
+    )
+  })
+})

package/spec/cli/commands/destroy/migration-spec.mjs

@@ -0,0 +1,15 @@
+import Cli from "../../../../src/cli/index.mjs"
+import dummyDirectory from "../../../dummy/dummy-directory.mjs"
+
+describe("Cli - destroy - migration", () => {
+  it("destroys an existing migration", async () => {
+    const cli = new Cli({
+      directory: dummyDirectory(),
+      processArgs: ["d:migration", "create-tasks"],
+      testing: true
+    })
+    const result = await cli.execute()
+
+    expect(result.destroyed).toEqual(["create-tasks"])
+  })
+})

package/spec/cli/commands/generate/migration-spec.mjs

@@ -0,0 +1,18 @@
+import Cli from "../../../../src/cli/index.mjs"
+import dummyDirectory from "../../../dummy/dummy-directory.mjs"
+
+describe("Cli - generate - migration", () => {
+  it("generates a new migration", async () => {
+    const cli = new Cli({
+      directory: dummyDirectory(),
+      processArgs: ["g:migration", "create-tasks"],
+      testing: true
+    })
+    const result = await cli.execute()
+
+    expect(result.migrationName).toEqual("create-tasks")
+    expect(result.migrationNameCamelized).toEqual("CreateTasks")
+    expect(result.migrationNumber).toMatch(/^\d+$/)
+    expect(result.migrationPath).toMatch(/-create-tasks\.mjs$/)
+  })
+})

package/spec/cli/commands/init-spec.mjs

@@ -0,0 +1,19 @@
+import Cli from "../../../src/cli/index.mjs"
+import dummyDirectory from "../../dummy/dummy-directory.mjs"
+
+describe("Cli - Commands - init", () => {
+  it("inits files and dirs", async () => {
+    const cli = new Cli({
+      directory: dummyDirectory(),
+      processArgs: ["init"],
+      testing: true
+    })
+    const result = await cli.execute()
+
+    expect(result.fileMappings.length).toEqual(2)
+    expect(result.fileMappings[0].source).toContain("/src/templates/configuration.mjs")
+    expect(result.fileMappings[0].target).toContain("/spec/dummy/src/config/configuration.mjs")
+    expect(result.fileMappings[1].source).toContain("/src/templates/routes.mjs")
+    expect(result.fileMappings[1].target).toContain("/spec/dummy/src/config/routes.mjs")
+  })
+})

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

@@ -0,0 +1,12 @@
+import TestFilesFinder from "../../../../src/cli/commands/test/test-files-finder.mjs"
+
+describe("Cli - Commands - test - TestFilesFinder", () => {
+  it("finds the correct test files", async () => {
+    const testFilesFinder = new TestFilesFinder({directory: process.cwd(), processArgs: ["test"]})
+    const testFiles = await testFilesFinder.findTestFiles()
+
+    const sampleTestFilePath = `${process.cwd()}/spec/cli/commands/destroy/migration-spec.mjs`
+
+    expect(testFiles.includes(sampleTestFilePath)).toBe(true)
+  })
+})

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

@@ -1,8 +1,8 @@
 import Database from "../../../../src/database/index.mjs"
-import {databaseConfiguration} from "../../../dummy/src/config/database.mjs"
+import configuration from "../../../dummy/src/config/configuration.mjs"
 import {digg} from "diggerize"
 
-const mysqlConfig = digg(databaseConfiguration(), "default", "master")
+const mysqlConfig = digg(configuration, "database", "default", "master")
 const Mysql = Database.Drivers.Mysql
 
 describe("Database - Drivers - Mysql - Connection", () => {

package/spec/dummy/dummy-directory.mjs

@@ -0,0 +1,11 @@
+import {dirname} from "path"
+import {fileURLToPath} from "url"
+
+const dummyDirectory = () => {
+  const __filename = fileURLToPath(import.meta.url)
+  const __dirname = dirname(__filename)
+
+  return __dirname
+}
+
+export default dummyDirectory

package/spec/dummy/index.mjs

@@ -1,7 +1,5 @@
 import Application from "../../src/application.mjs"
-import DatabasePool from "../../src/database/pool/index.mjs"
-import {dirname} from "path"
-import {fileURLToPath} from "url"
+import dummyConfiguration from "./src/config/configuration.mjs"
 
 export default class Dummy {
   static current() {
@@ -13,10 +11,12 @@ export default class Dummy {
   }
 
   static async prepare() {
-    const connection = DatabasePool.current().singleConnection()
+    const db = dummyConfiguration.getDatabasePool()
 
-    await connection.query("DROP TABLE IF EXISTS tasks")
-    await connection.query("CREATE TABLE tasks (id MEDIUMINT NOT NULL AUTO_INCREMENT, name VARCHAR(255), description TEXT, PRIMARY KEY (id))")
+    await db.withConnection(async () => {
+      await db.query("DROP TABLE IF EXISTS tasks")
+      await db.query("CREATE TABLE tasks (id MEDIUMINT NOT NULL AUTO_INCREMENT, name VARCHAR(255), description TEXT, PRIMARY KEY (id))")
+    })
   }
 
   static async run(callback) {
@@ -24,21 +24,23 @@ export default class Dummy {
   }
 
   async run(callback) {
-    await this.start()
-
-    try {
-      await Dummy.prepare()
-      await callback()
-    } finally {
-      await this.stop()
-    }
+    await dummyConfiguration.getDatabasePool().withConnection(async () => {
+      await this.start()
+
+      try {
+        await Dummy.prepare()
+        await callback()
+      } finally {
+        await this.stop()
+      }
+    })
   }
 
   async start() {
-    const __filename = fileURLToPath(import.meta.url)
-    const __dirname = dirname(__filename)
+    if (!dummyConfiguration.isDatabasePoolInitialized()) await dummyConfiguration.initializeDatabasePool()
 
     this.application = new Application({
+      configuration: dummyConfiguration,
       databases: {
         default: {
           host: "mysql",
@@ -46,19 +48,11 @@ export default class Dummy {
           password: ""
         }
       },
-      debug: false,
-      directory: __dirname,
       httpServer: {port: 3006}
     })
 
     await this.application.initialize()
     await this.application.startHttpServer()
-
-    const databasePool = DatabasePool.current()
-
-    if (!databasePool.isConnected()) {
-      await databasePool.connect()
-    }
   }
 
   async stop() {

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

@@ -0,0 +1,19 @@
+import Configuration from "../../../../src/configuration.mjs"
+import dummyDirectory from "../../dummy-directory.mjs"
+
+const configuration = new Configuration({
+  database: {
+    default: {
+      master: {
+        type: "mysql",
+        host: "mariadb",
+        username: "username",
+        password: "password",
+        database: "velocious_test"
+      }
+    }
+  },
+  directory: dummyDirectory()
+})
+
+export default configuration

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

@@ -0,0 +1,20 @@
+import Configuration from "../../../../src/configuration.mjs"
+import dummyDirectory from "../../dummy-directory.mjs"
+
+const configuration = new Configuration({
+  database: {
+    default: {
+      master: {
+        type: "mysql",
+        host: "mariadb",
+        username: "peakflow",
+        password: "password",
+        database: "velocious_test",
+        useDatabase: "velocious_test"
+      }
+    }
+  },
+  directory: dummyDirectory()
+})
+
+export default configuration

package/spec/dummy/src/database/migrations/20230728075328-create-projects.mjs

@@ -0,0 +1,11 @@
+import Migration from "../../../../../src/database/migration/index.mjs"
+
+export default class CreateProjects extends Migration {
+  async change() {
+    await this.createTable("projects", (table) => {
+      table.bigint("id", {autoIncrement: true, primaryKey: true})
+      table.string("name", {maxLength: 100, null: false})
+      table.timestamps()
+    })
+  }
+}

package/spec/dummy/src/database/migrations/20230728075329-create-tasks.mjs

@@ -0,0 +1,13 @@
+import Migration from "../../../../../src/database/migration/index.mjs"
+
+export default class CreateTasks extends Migration {
+  async change() {
+    await this.createTable("tasks", (table) => {
+      table.bigint("id", {autoIncrement: true, primaryKey: true})
+      table.references("project")
+      table.string("name")
+      table.text("description")
+      table.timestamps()
+    })
+  }
+}

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

@@ -1,24 +1,14 @@
 import Client from "../../src/http-server/client/index.mjs"
-import Configuration from "../../src/configuration.mjs"
 import {digg} from "diggerize"
-import {dirname} from "path"
-import {fileURLToPath} from "url"
-import path from "path"
+import dummyConfiguration from "../dummy/src/config/configuration.mjs"
 
 describe("http server - client", () => {
   it("spawns a request for each that it is fed", async () => {
-    const __filename = fileURLToPath(import.meta.url)
-    const __dirname = dirname(__filename)
-    const dummyDirectory = path.join(__dirname, "../dummy")
-    const configuration = new Configuration({
-      directory: dummyDirectory
-    })
-
-    await configuration.initialize()
+    await dummyConfiguration.initialize()
 
     const client = new Client({
       clientCount: 0,
-      configuration
+      configuration: dummyConfiguration
     })
 
     const strings = [

package/src/application.mjs

@@ -1,22 +1,19 @@
 import {digs} from "diggerize"
-import Configuration from "./configuration.mjs"
 import logger from "./logger.mjs"
 import HttpServer from "./http-server/index.mjs"
 
 export default class VelociousApplication {
-  constructor({debug, directory, httpServer}) {
-    this.configuration = new Configuration({debug, directory})
+  constructor({configuration, httpServer}) {
+    this.configuration = configuration
     this.httpServerConfiguration = httpServer ?? {}
   }
 
   async initialize() {
-    if (global.velociousApplication) throw new Error("A Velocious application is already running")
-    if (global.velociousConfiguration) throw new Error("A Velocious configuration has already been set")
-
-    global.velociousApplication = this
-    global.velociousConfiguration = this.configuration
-
     await this.configuration.initialize()
+
+    if (!this.configuration.isDatabasePoolInitialized()) {
+      await this.configuration.initializeDatabasePool()
+    }
   }
 
   isActive() {
@@ -49,8 +46,5 @@ export default class VelociousApplication {
     logger(this, "Stopping server")
 
     await this.httpServer.stop()
-
-    global.velociousApplication = undefined
-    global.velociousConfiguration = undefined
   }
 }

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

@@ -1,14 +1,50 @@
-export default class DbCreate {
-  constructor({args}) {
-    this.args = args
+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
   }
 
-  execute() {
-    const migrationName = this.args[2]
-    const date = new Date()
+  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})
 
-    console.log({ migrationName, date })
+    const createSchemaMigrationsTableSql = this.databaseConnection.createTableSql(schemaMigrationsTable)
 
-    throw new Error("stub")
+    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}
+    }
+  }
+}