velocious 1.0.1 → 1.0.2

package/README.md

@@ -0,0 +1,26 @@
+# README
+
+This is still work in progress.
+
+* Concurrent multi threadded web server
+* Database framework ala Rails
+* Database models ala Rails
+* Database models that work almost the same in frontend and backend
+* Migrations ala Rails
+* Controllers and views ala Rails
+
+## Migrations
+
+```bash
+npx velocious db:g:migration create_tasks
+```
+
+```bash
+npx velocious db:migrate
+```
+
+## Testing
+
+```bash
+npm test
+```

package/bin/velocious.mjs

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

package/index.mjs

@@ -0,0 +1,17 @@
+import Application from "./src/application.mjs"
+import Cli from "./src/cli/index.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"
+
+export {
+  Application,
+  Cli,
+  Controller,
+  Database,
+  DatabasePool,
+  HttpServer,
+  Routes
+}

package/package.json

@@ -1,10 +1,15 @@
 {
+  "bin": {
+    "velocious": "bin/velocious.mjs"
+  },
   "name": "velocious",
-  "version": "1.0.1",
-  "main": "index.cjs",
+  "version": "1.0.2",
+  "main": "index.mjs",
   "scripts": {
-    "test": "jasmine"
+    "test": "jasmine",
+    "velocious": "asd"
   },
+  "type": "module",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kaspernj/velocious.git"
@@ -17,13 +22,15 @@
   "homepage": "https://github.com/kaspernj/velocious#readme",
   "description": "",
   "devDependencies": {
-    "jasmine": "^4.0.2",
-    "node-fetch": "^2.6.1"
+    "jasmine": "^5.0.2",
+    "mysql": "^2.18.1",
+    "node-fetch": "^3.3.1"
   },
   "dependencies": {
     "diggerize": "^1.0.3",
     "ejs": "^3.1.6",
     "escape-string-regexp": "^1.0.5",
-    "inflection": "^1.13.2"
+    "incorporator": "^1.0.2",
+    "inflection": "^2.0.0"
   }
 }

package/peak_flow.yml

@@ -1,17 +1,21 @@
+before_install:
+  - curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
+  - sudo apt-get install -y nodejs
 before_script:
-  - cp spec/dummy/config/databases.peakflow.json spec/dummy/config/databases.json
+  - cp spec/dummy/src/config/database.peakflow.mjs spec/dummy/src/config/database.mjs
   - npm install
-  - wait-for-it mysql:3306
+  - wait-for-it mariadb:3306
 services:
-  mysql:
+  mariadb:
     environment:
       MYSQL_USER: peakflow
       MYSQL_PASSWORD: password
       MYSQL_ROOT_PASSWORD: password
       MYSQL_DATABASE: velocious_test
-    image: mysql:8.0.22
+    image: mariadb:latest
     expose:
       - 3306
-    mem_limit: 2048m
+    mem_limit: 4096m
+    restart_policy: on-failure
 script:
   - npm test

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

@@ -0,0 +1,9 @@
+import Cli from "../../../src/cli/index.mjs"
+
+describe("Cli - generate - migration", () => {
+  it("generates a new migration", async () => {
+    const cli = new Cli()
+
+    await cli.execute({args: ["g:migration", "create_tasks"]})
+  })
+})

package/spec/database/connection/drivers/mysql/{query-parser-spec.cjs → query-parser-spec.mjs}

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

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

@@ -0,0 +1,21 @@
+import Database from "../../../../src/database/index.mjs"
+import {databaseConfiguration} from "../../../dummy/src/config/database.mjs"
+import {digg} from "diggerize"
+
+const mysqlConfig = digg(databaseConfiguration(), "default", "master")
+const Mysql = Database.Drivers.Mysql
+
+describe("Database - Drivers - Mysql - Connection", () => {
+  it("connects", async () => {
+    const mysql = new Mysql(mysqlConfig)
+
+    await mysql.connect()
+
+    const result = await mysql.query("SELECT \"1\" AS test1, \"2\" AS test2")
+
+    expect(result).toEqual([{
+      test1: "1",
+      test2: "2"
+    }])
+  })
+})

package/spec/database/record/create-spec.mjs

@@ -0,0 +1,14 @@
+import Dummy from "../../dummy/index.mjs"
+import Task from "../../dummy/src/models/task.mjs"
+
+describe("Record - create", () => {
+  it("creates a new simple record", async () => {
+    await Dummy.run(async () => {
+      const task = new Task({name: "Test task"})
+
+      await task.save()
+
+      expect(task.id()).not.toBeUndefined()
+    })
+  })
+})

package/spec/database/record/destroy-spec.mjs

@@ -0,0 +1,17 @@
+import Dummy from "../../dummy/index.mjs"
+import Task from "../../dummy/src/models/task.mjs"
+
+describe("Record - destroy", () => {
+  it("destroys a record", async () => {
+    await Dummy.run(async () => {
+      const task = new Task({name: "Test task"})
+
+      await task.save()
+      await task.destroy()
+
+      const foundTask = await Task.where({id: task.id()}).first()
+
+      expect(foundTask).toEqual(undefined)
+    })
+  })
+})

package/spec/database/record/find-spec.mjs

@@ -0,0 +1,29 @@
+import Dummy from "../../dummy/index.mjs"
+import RecordNotFoundError from "../../../src/database/record/record-not-found-error.mjs"
+import Task from "../../dummy/src/models/task.mjs"
+
+describe("Record - find", () => {
+  it("finds an existing record", async () => {
+    await Dummy.run(async () => {
+      const task = new Task({name: "Test task"})
+
+      await task.save()
+
+      const foundTask = await Task.find(task.id())
+
+      expect(foundTask.readAttribute("name")).toEqual("Test task")
+    })
+  })
+
+  it("raises an error when a record isn't found", async () => {
+    await Dummy.run(async () => {
+      try {
+        await Task.find(123)
+        throw new Error("Didn't expect to reach this")
+      } catch (error) {
+        expect(error.message).toEqual("Couldn't find Task with 'id'=123")
+        expect(error.constructor.name).toEqual("RecordNotFoundError")
+      }
+    })
+  })
+})

package/spec/database/record/update-spec.mjs

@@ -0,0 +1,15 @@
+import Dummy from "../../dummy/index.mjs"
+import Task from "../../dummy/src/models/task.mjs"
+
+describe("Record - update", () => {
+  it("updates a record", async () => {
+    await Dummy.run(async () => {
+      const task = new Task({name: "Test task"})
+
+      await task.save()
+      await task.update({name: "Updated name"})
+
+      expect(task.readAttribute("name")).toEqual("Updated name")
+    })
+  })
+})

package/spec/dummy/index.mjs

@@ -0,0 +1,69 @@
+import Application from "../../src/application.mjs"
+import DatabasePool from "../../src/database/pool/index.mjs"
+import {dirname} from "path"
+import {fileURLToPath} from "url"
+
+export default class Dummy {
+  static current() {
+    if (!global.velociousDummy) {
+      global.velociousDummy = new Dummy()
+    }
+
+    return global.velociousDummy
+  }
+
+  static async prepare() {
+    const connection = DatabasePool.current().singleConnection()
+
+    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))")
+  }
+
+  static async run(callback) {
+    await this.current().run(callback)
+  }
+
+  async run(callback) {
+    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)
+
+    this.application = new Application({
+      databases: {
+        default: {
+          host: "mysql",
+          username: "user",
+          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() {
+    if (this.application.isActive()) {
+      await this.application.stop()
+    }
+  }
+}

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

@@ -0,0 +1,15 @@
+const databaseConfiguration = () => {
+  return {
+    "default": {
+      "master": {
+        "type": "mysql",
+        "host": "mariadb",
+        "username": "username",
+        "password": "password",
+        "database": "velocious_test"
+      }
+    }
+  }
+}
+
+export {databaseConfiguration}

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

@@ -0,0 +1,15 @@
+const databaseConfiguration = () => {
+  return {
+    "default": {
+      "master": {
+        "type": "mysql",
+        "host": "mariadb",
+        "username": "peakflow",
+        "password": "password",
+        "database": "velocious_test"
+      }
+    }
+  }
+}
+
+export {databaseConfiguration}

package/spec/dummy/src/{routes.cjs → config/routes.mjs}

@@ -1,4 +1,5 @@
-const Routes = require("../../../src/routes/index.cjs")
+import Routes from "../../../../src/routes/index.mjs"
+
 const routes = new Routes()
 
 routes.draw((route) => {
@@ -7,4 +8,4 @@ routes.draw((route) => {
   })
 })
 
-module.exports = {routes}
+export default {routes}

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

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

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

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

package/spec/dummy/src/routes/tasks/controller.mjs

@@ -0,0 +1,26 @@
+import Controller from "../../../../../src/controller.mjs"
+import {digg} from "diggerize"
+import Task from "../../models/task.mjs"
+
+export default class TasksController extends Controller {
+  index() {
+    this.viewParams.numbers = [1, 2, 3, 4, 5]
+    this.render()
+  }
+
+  async show() {
+    const taskId = digg(params, "id")
+    const task = await Task.find(taskId)
+
+    this.viewParams.task = task
+    this.render()
+  }
+
+  async create() {
+    const task = new Task(this.params().task)
+
+    await task.save()
+
+    this.render({json: {status: "success"}})
+  }
+}

package/spec/http-server/{client-spec.cjs → client-spec.mjs}

@@ -1,14 +1,21 @@
-const Client = require("../../src/http-server/client/index.cjs")
-const Configuration = require("../../src/configuration.cjs")
-const {digg} = require("diggerize")
-const path = require("path")
+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"
 
 describe("http server - client", () => {
-  it("spawns a request for each that it is fed", () => {
+  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()
+
     const client = new Client({
       clientCount: 0,
       configuration

package/spec/http-server/{get-spec.cjs → get-spec.mjs}

@@ -1,5 +1,5 @@
-const fetch = require("node-fetch")
-const Dummy = require("../dummy/index.cjs")
+import fetch from "node-fetch"
+import Dummy from "../dummy/index.mjs"
 
 describe("HttpServer", () => {
   it("handles get requests", async () => {

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,56 @@
+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})
+    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()
+  }
+
+  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()
+
+    global.velociousApplication = undefined
+    global.velociousConfiguration = undefined
+  }
+}

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

@@ -0,0 +1,14 @@
+export default class DbCreate {
+  constructor({args}) {
+    this.args = args
+  }
+
+  execute() {
+    const migrationName = this.args[2]
+    const date = new Date()
+
+    console.log({ migrationName, date })
+
+    throw new Error("stub")
+  }
+}

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

@@ -0,0 +1,12 @@
+export default class DbGenerateMigration {
+  constructor({args}) {
+    this.args = args
+  }
+
+  execute() {
+    const migrationName = this.args[1]
+    const date = new Date()
+
+    console.log({ migrationName, date })
+  }
+}