velocious 1.0.0

package/.github/dependabot.yml

@@ -0,0 +1,9 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: weekly
+    time: "01:00"
+    timezone: Europe/Copenhagen
+  open-pull-requests-limit: 99

package/bin/velocious

@@ -0,0 +1,14 @@
+#!/usr/bin/node
+
+console.log("Hello", process.argv)
+
+const args = process.argv.slice(2)
+
+console.log(args)
+
+if (args[0] == "g" && args[1] == "migration") {
+  const migrationName = args[2]
+  const date = new Date()
+
+  console.log({ migrationName, date })
+}

package/index.cjs

@@ -0,0 +1,11 @@
+const Application = require("./src/application.cjs")
+const Controller = require("./src/controller.cjs")
+const Database = require("./src/database/index.cjs")
+const HttpServer = require("./src/http-server/index.cjs")
+
+module.exports = {
+  Application,
+  Controller,
+  Database,
+  HttpServer
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "velocious",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "jasmine"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kaspernj/velocious.git"
+  },
+  "author": "k@spernj.org",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/kaspernj/velocious/issues"
+  },
+  "homepage": "https://github.com/kaspernj/velocious#readme",
+  "description": "",
+  "devDependencies": {
+    "jasmine": "^4.0.2",
+    "node-fetch": "^2.6.1"
+  },
+  "dependencies": {
+    "diggerize": "^1.0.3",
+    "ejs": "^3.1.6",
+    "escape-string-regexp": "^1.0.5",
+    "inflection": "^1.13.2"
+  }
+}

package/peak_flow.yml

@@ -0,0 +1,17 @@
+before_script:
+  - cp spec/dummy/config/databases.peakflow.json spec/dummy/config/databases.json
+  - npm install
+  - wait-for-it mysql:3306
+services:
+  mysql:
+    environment:
+      MYSQL_USER: peakflow
+      MYSQL_PASSWORD: password
+      MYSQL_ROOT_PASSWORD: password
+      MYSQL_DATABASE: velocious_test
+    image: mysql:8.0.22
+    expose:
+      - 3306
+    mem_limit: 2048m
+script:
+  - npm test

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

@@ -0,0 +1,34 @@
+const {Database: {Handler, Query}} = require("../../../../../index.cjs")
+const MysqlQueryParser = require("../../../../../src/database/connection/drivers/mysql/query-parser.cjs")
+
+const FromTable = require("../../../../../src/database/query/from-table.cjs")
+const SelectTableAndColumn = require("../../../../../src/database/query/select-table-and-column.cjs")
+
+describe("database - connection - drivers - mysql - query parser", () => {
+  it("generates sql with selects, joins and orders", () => {
+    const handler = new Handler()
+    const query = new Query({handler})
+      .select(["tasks.id", "tasks.name"])
+      .from("tasks")
+      .joins("LEFT JOIN projects ON projects.id = tasks.project_id")
+
+    const sql = new MysqlQueryParser({query}).toSql()
+
+    expect(sql).toEqual("SELECT tasks.id, tasks.name FROM tasks LEFT JOIN projects ON projects.id = tasks.project_id")
+  })
+
+  it("generates sql with selects, joins and orders", () => {
+    const handler = new Handler()
+    const query = new Query({handler})
+      .select([
+        new SelectTableAndColumn({tableName: "tasks", columnName: "id"}),
+        new SelectTableAndColumn({tableName: "tasks", columnName: "name"})
+      ])
+      .from(new FromTable({tableName: "tasks"}))
+      .joins("LEFT JOIN projects ON projects.id = tasks.project_id")
+
+    const sql = new MysqlQueryParser({query}).toSql()
+
+    expect(sql).toEqual("SELECT `tasks`.`id`, `tasks`.`name` FROM `tasks` LEFT JOIN projects ON projects.id = tasks.project_id")
+  })
+})

package/spec/dummy/config/databases.example.json

@@ -0,0 +1,10 @@
+{
+  "default": {
+    "master": {
+      "type": "mysql",
+      "host": "mysql",
+      "username": "username",
+      "password": "password"
+    }
+  }
+}

package/spec/dummy/config/databases.peakflow.json

@@ -0,0 +1,11 @@
+{
+  "default": {
+    "master": {
+      "type": "mysql",
+      "host": "mysql",
+      "username": "peakflow",
+      "password": "password",
+      "database": "velocious_test"
+    }
+  }
+}

package/spec/dummy/index.cjs

@@ -0,0 +1,40 @@
+const {Application} = require("../../index.cjs")
+
+module.exports = class Dummy {
+  static async run(callback) {
+    const dummy = new Dummy()
+
+    await dummy.run(callback)
+  }
+
+  async run(callback) {
+    await this.start()
+
+    try {
+      await callback()
+    } finally {
+      this.stop()
+    }
+  }
+
+  async start() {
+    this.application = new Application({
+      databases: {
+        default: {
+          host: "mysql",
+          username: "user",
+          password: ""
+        }
+      },
+      debug: false,
+      directory: __dirname,
+      httpServer: {port: 3006}
+    })
+
+    await this.application.start()
+  }
+
+  stop() {
+    this.application.stop()
+  }
+}

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

@@ -0,0 +1,4 @@
+const Record = require("../../../../src/database/record/index.cjs")
+
+module.exports = class Task extends Record {
+}

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

@@ -0,0 +1,18 @@
+const Controller = require("../../../../../src/controller.cjs")
+const {digg} = require("diggerize")
+const Task = require("../../models/task.cjs")
+
+module.exports = 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()
+  }
+}

package/spec/dummy/src/routes/tasks/index.ejs

@@ -0,0 +1 @@
+<%= numbers.join(", ") %>

package/spec/dummy/src/routes.cjs

@@ -0,0 +1,10 @@
+const Routes = require("../../../src/routes/index.cjs")
+const routes = new Routes()
+
+routes.draw((route) => {
+  route.resources("tasks", (route) => {
+    route.get("users")
+  })
+})
+
+module.exports = {routes}

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

@@ -0,0 +1,35 @@
+const Client = require("../../src/http-server/client/index.cjs")
+const Configuration = require("../../src/configuration.cjs")
+const {digg} = require("diggerize")
+const path = require("path")
+
+describe("http server - client", () => {
+  it("spawns a request for each that it is fed", () => {
+    const dummyDirectory = path.join(__dirname, "../dummy")
+    const configuration = new Configuration({
+      directory: dummyDirectory
+    })
+    const client = new Client({
+      clientCount: 0,
+      configuration
+    })
+
+    const strings = [
+      "GET /tasks",
+      " HTTP/1.1",
+      "\r\n",
+      "Host: www.example.com\r\n",
+      "\r\n"
+    ]
+
+    for (const string of strings) {
+      client.onWrite(Buffer.from(string, "utf-8"))
+    }
+
+    const currentRequest = digg(client, "currentRequest")
+
+    expect(currentRequest.httpMethod()).toBe("GET")
+    expect(currentRequest.host()).toBe("www.example.com")
+    expect(currentRequest.path()).toBe("/tasks")
+  })
+})

package/spec/http-server/get-spec.cjs

@@ -0,0 +1,13 @@
+const fetch = require("node-fetch")
+const Dummy = require("../dummy/index.cjs")
+
+describe("HttpServer", () => {
+  it("handles get requests", async () => {
+    await Dummy.run(async () => {
+      const response = await fetch("http://localhost:3006/tasks")
+      const text = await response.text()
+
+      expect(text).toEqual("1, 2, 3, 4, 5\n")
+    })
+  })
+})

package/spec/support/jasmine.json

@@ -0,0 +1,11 @@
+{
+  "spec_dir": "spec",
+  "spec_files": [
+    "**/*[sS]pec.cjs"
+  ],
+  "helpers": [
+    "helpers/**/*.cjs"
+  ],
+  "stopSpecOnExpectationFailure": false,
+  "random": false
+}

package/src/application.cjs

@@ -0,0 +1,36 @@
+const {digs} = require("diggerize")
+const Configuration = require("./configuration.cjs")
+const logger = require("./logger.cjs")
+const HttpServer = require("./http-server/index.cjs")
+
+module.exports = class VelociousApplication {
+  constructor({debug, directory, httpServer}) {
+    this.configuration = new Configuration({debug, directory})
+    this.httpServerConfiguration = httpServer ?? {}
+  }
+
+  async run(callback) {
+    await this.start()
+
+    try {
+      await callback()
+    } finally {
+      this.stop()
+    }
+  }
+
+  async start() {
+    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()
+  }
+
+  stop() {
+    this.httpServer.stop()
+  }
+}

package/src/configuration.cjs

@@ -0,0 +1,14 @@
+const Routes = require("./routes/index.cjs")
+
+module.exports = class VelociousConfiguration {
+  constructor({debug, directory}) {
+    if (!directory) throw new Error("No directory given")
+
+    // Every client need to make their own routes because they probably can't be shared across different worker threads
+    const {routes} = require(`${directory}/src/routes.cjs`)
+
+    this.debug = debug
+    this.directory = directory
+    this.routes = routes
+  }
+}

package/src/controller.cjs

@@ -0,0 +1,50 @@
+const {digg, digs} = require("diggerize")
+const ejs = require("ejs")
+
+module.exports = class VelociousController {
+  constructor({configuration, params, request, response}) {
+    if (!configuration) throw new Error("No configuration given")
+    if (!params) throw new Error("No params given")
+    if (!request) throw new Error("No request given")
+    if (!response) throw new Error("No response given")
+
+    this._configuration = configuration
+    this._params = params
+    this._request = request
+    this._response = response
+    this.viewParams = {}
+  }
+
+  render() {
+    return new Promise((resolve, reject) => {
+      const actionName = digg(this, "_params", "action")
+      const controllerName = digg(this, "_params", "controller")
+      const directory = digg(this, "_configuration", "directory")
+      const viewPath = `${directory}/src/routes/${controllerName}/${actionName}.ejs`
+      const {viewParams} = digs(this, "viewParams")
+
+      ejs.renderFile(viewPath, viewParams, {}, (err, str) => {
+        if (err) {
+          reject(err)
+        } else {
+          this._response.addHeader("Content-Type", "text/html")
+          this._response.setBody(str)
+
+          resolve()
+        }
+      })
+    })
+  }
+
+  renderText() {
+    throw new Error("renderText stub")
+  }
+
+  request() {
+    return this._request
+  }
+
+  response() {
+    return this._response
+  }
+}

package/src/database/connection/drivers/mysql/index.cjs

@@ -0,0 +1,5 @@
+module.exports = class VelociousDatabaseConnectionDriversMysql {
+  constructor(args) {
+    this.args = args
+  }
+}

package/src/database/connection/drivers/mysql/options.cjs

@@ -0,0 +1,7 @@
+const QueryParserOptions = require("../../../query-parser/options.cjs")
+const queryParserOptions = new QueryParserOptions({
+  columnQuote: "`",
+  tableQuote: "`"
+})
+
+module.exports = queryParserOptions

package/src/database/connection/drivers/mysql/query-parser.cjs

@@ -0,0 +1,26 @@
+const {digs} = require("diggerize")
+const FromParser = require("../../../query-parser/from-parser.cjs")
+const JoinsParser = require("../../../query-parser/joins-parser.cjs")
+const queryParserOptions = require("./options.cjs")
+const SelectParser = require("../../../query-parser/select-parser.cjs")
+
+module.exports = 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, queryParserOptions}).toSql()
+    sql += new FromParser({pretty, query, queryParserOptions}).toSql()
+    sql += new JoinsParser({pretty, query, queryParserOptions}).toSql()
+
+    return sql
+  }
+}

package/src/database/connection/index.cjs

@@ -0,0 +1,2 @@
+module.exports = class VelociousDatabaseConnection {
+}

package/src/database/handler.cjs

@@ -0,0 +1,5 @@
+module.exports = class VelociousDatabaseHandler {
+  constructor() {
+    console.log("stub")
+  }
+}

package/src/database/index.cjs

@@ -0,0 +1,9 @@
+const Handler = require("./handler.cjs")
+const Query = require("./query/index.cjs")
+const Record = require("./record/index.cjs")
+
+module.exports = {
+  Handler,
+  Query,
+  Record
+}

package/src/database/pool/index.cjs

@@ -0,0 +1,2 @@
+module.exports = class VelociousDatabasePool {
+}

package/src/database/query/from-base.cjs

@@ -0,0 +1,15 @@
+module.exports = class VelociousDatabaseQueryFromBase {
+  getOptions() {
+    if (!this._options) throw new Error("Options hasn't been set")
+
+    return this._options
+  }
+
+  setOptions(options) {
+    this._options = options
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

package/src/database/query/from-plain.cjs

@@ -0,0 +1,12 @@
+const FromBase = require("./from-base.cjs")
+
+module.exports = class VelociousDatabaseQueryFromPlain extends FromBase {
+  constructor({plain}) {
+    super()
+    this.plain = plain
+  }
+
+  toSql() {
+    return this.plain
+  }
+}

package/src/database/query/from-table.cjs

@@ -0,0 +1,12 @@
+const FromBase = require("./from-base.cjs")
+
+module.exports = class VelociousDatabaseQueryFromTable extends FromBase {
+  constructor({tableName}) {
+    super()
+    this.tableName = tableName
+  }
+
+  toSql() {
+    return this.getOptions().quoteTableName(this.tableName)
+  }
+}

package/src/database/query/index.cjs

@@ -0,0 +1,59 @@
+const FromPlain = require("./from-plain.cjs")
+const JoinPlain = require("./join-plain.cjs")
+const SelectPlain = require("./select-plain.cjs")
+
+module.exports = class VelociousDatabaseQuery {
+  constructor({handler}) {
+    if (!handler) throw new Error("No handler given")
+
+    this._froms = []
+    this._joins = []
+    this._orders = []
+    this._selects = []
+  }
+
+  getOptions() {
+    if (!this._options) throw new Error("Options not set")
+    return this._options
+  }
+
+  from(from) {
+    if (typeof from == "string") from = new FromPlain({plain: from})
+
+    this._froms.push(from)
+    return this
+  }
+
+  joins(join) {
+    if (typeof join == "string") join = new JoinPlain({plain: join})
+
+    this._joins.push(join)
+    return this
+  }
+
+  order(order) {
+    if (typeof order == "string") order = new OrderPlain({plain: order})
+
+    this._orders.push(order)
+    return this
+  }
+
+  select(select) {
+    if (Array.isArray(select)) {
+      for (const selectInArray of select) {
+        this.select(selectInArray)
+      }
+
+      return this
+    }
+
+    if (typeof select == "string") select = new SelectPlain({plain: select})
+
+    this._selects.push(select)
+    return this
+  }
+
+  toSql() {
+    throw new Error("stub")
+  }
+}

package/src/database/query/join-base.cjs

@@ -0,0 +1,15 @@
+module.exports = class VelociousDatabaseQueryJoinBase {
+  getOptions() {
+    if (!this._options) throw new Error("Options hasn't been set")
+
+    return this._options
+  }
+
+  setOptions(options) {
+    this._options = options
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

package/src/database/query/join-plain.cjs

@@ -0,0 +1,12 @@
+const JoinBase = require("./join-base.cjs")
+
+module.exports = class VelociousDatabaseQueryJoinPlain extends JoinBase {
+  constructor({plain}) {
+    super()
+    this.plain = plain
+  }
+
+  toSql() {
+    return this.plain
+  }
+}

package/src/database/query/select-base.cjs

@@ -0,0 +1,15 @@
+module.exports = class VelociousDatabaseQuerySelectBase {
+  getOptions() {
+    if (!this._options) throw new Error("Options hasn't been set")
+
+    return this._options
+  }
+
+  setOptions(options) {
+    this._options = options
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

package/src/database/query/select-plain.cjs

@@ -0,0 +1,12 @@
+const SelectBase = require("./select-base.cjs")
+
+module.exports = class VelociousDatabaseQuerySelectPlain extends SelectBase {
+  constructor({plain}) {
+    super()
+    this.plain = plain
+  }
+
+  toSql() {
+    return this.plain
+  }
+}

package/src/database/query/select-table-and-column.cjs

@@ -0,0 +1,21 @@
+const SelectBase = require("./select-base.cjs")
+
+module.exports = class VelociousDatabaseQuerySelectTableAndColumn extends SelectBase {
+  constructor({tableName, columnName}) {
+    super()
+    this.columnName = columnName
+    this.tableName = tableName
+  }
+
+  getColumnName() {
+    return this.columnName
+  }
+
+  getTableName() {
+    return this.tableName
+  }
+
+  toSql() {
+    return `${this.getOptions().quoteTableName(this.tableName)}.${this.getOptions().quoteColumnName(this.columnName)}`
+  }
+}