velocious 1.0.0 → 1.0.2

package/src/cli/index.mjs

@@ -0,0 +1,39 @@
+import {dirname} from "path"
+import {fileURLToPath} from "url"
+import fs from "node:fs/promises"
+
+const fileExists = async (path) => {
+  try {
+    await fs.access(path)
+
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+export default class VelociousCli {
+  async execute({args}) {
+    const __filename = fileURLToPath(`${import.meta.url}/../..`)
+    const __dirname = dirname(__filename)
+    const commandParts = args[0].split(":")
+    let filePath = `${__dirname}/src/cli/commands`
+
+    for (let commandPart of commandParts) {
+      if (commandPart == "d") commandPart = "destroy"
+      if (commandPart == "g") commandPart = "generate"
+
+      filePath += `/${commandPart}`
+    }
+
+    filePath += ".mjs"
+
+    if (!fileExists(filePath)) throw new Error(`Unknown command: ${args[0]} which should have been in ${filePath}`)
+
+    const commandClassImport = await import(filePath)
+    const CommandClass = commandClassImport.default
+    const commandInstance = new CommandClass({args})
+
+    await commandInstance.execute()
+  }
+}

package/src/configuration.mjs

@@ -0,0 +1,27 @@
+import {digg} from "diggerize"
+
+export default class VelociousConfiguration {
+  static current() {
+    if (!global.velociousConfiguration) throw new Error("A Velocious configuration hasn't been set")
+
+    return global.velociousConfiguration
+  }
+
+  constructor({debug, directory}) {
+    if (!directory) throw new Error("No directory given")
+
+    this.debug = debug
+    this.directory = directory
+  }
+
+  async initialize() {
+    await this.initializeRoutes()
+  }
+
+  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")
+  }
+}

package/src/{controller.cjs → controller.mjs}

@@ -1,7 +1,7 @@
-const {digg, digs} = require("diggerize")
-const ejs = require("ejs")
+import {digg, digs} from "diggerize"
+import ejs from "ejs"
 
-module.exports = class VelociousController {
+export default class VelociousController {
   constructor({configuration, params, request, response}) {
     if (!configuration) throw new Error("No configuration given")
     if (!params) throw new Error("No params given")
@@ -15,7 +15,24 @@ module.exports = class VelociousController {
     this.viewParams = {}
   }
 
-  render() {
+  params = () => this._params
+
+  render(args = {}) {
+    if (args.json) {
+      return this.renderJsonArg(args)
+    }
+
+    return this.renderView()
+  }
+
+  renderJsonArg(args) {
+    const body = JSON.stringify(args.json)
+
+    this._response.addHeader("Content-Type", "application/json")
+    this._response.setBody(body)
+  }
+
+  renderView() {
     return new Promise((resolve, reject) => {
       const actionName = digg(this, "_params", "action")
       const controllerName = digg(this, "_params", "controller")

package/src/database/drivers/base.mjs

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseDriversBase {
+  constructor(args) {
+    this._args = args
+  }
+
+  getArgs() {
+    return this._args
+  }
+}

package/src/database/drivers/index.mjs

@@ -0,0 +1,5 @@
+import Mysql from "../drivers/mysql/index.mjs"
+
+export default {
+  Mysql
+}

package/src/database/drivers/mysql/connect-connection.mjs

@@ -0,0 +1,12 @@
+// Async function to connect a MySQL connection
+export default function connectConnection(connection) {
+  return new Promise((resolve, reject) => {
+    connection.connect((error) => {
+      if (error) {
+        reject(error)
+      } else {
+        resolve()
+      }
+    })
+  })
+}

package/src/database/drivers/mysql/index.mjs

@@ -0,0 +1,77 @@
+import Base from "../base.mjs"
+import connectConnection from "./connect-connection.mjs"
+import Delete from "./sql/delete.mjs"
+import {digg} from "diggerize"
+import Insert from "./sql/insert.mjs"
+import Options from "./options.mjs"
+import mysql from "mysql"
+import query from "./query.mjs"
+import QueryParser from "./query-parser.mjs"
+import Update from "./sql/update.mjs"
+
+export default class VelociousDatabaseDriversMysql extends Base{
+  async connect() {
+    const connection = mysql.createConnection(this.connectArgs())
+
+    await connectConnection(connection)
+    this.connection = connection
+  }
+
+  disconnect() {
+    this.connection.end()
+  }
+
+  connectArgs() {
+    const args = this.getArgs()
+    const connectArgs = []
+    const forward = ["database", "host", "password"]
+
+    for (const forwardValue of forward) {
+      if (forwardValue in args) connectArgs[forwardValue] = digg(args, forwardValue)
+    }
+
+    if ("username" in args) connectArgs["user"] = args["username"]
+
+    return connectArgs
+  }
+
+  async query(sql) {
+    return await query(this.connection, sql)
+  }
+
+  queryToSql(query) {
+    return new QueryParser({query}).toSql()
+  }
+
+  quote(string) {
+    if (!this.connection) throw new Error("Can't escape before connected")
+
+    return this.connection.escape(string)
+  }
+
+  deleteSql({tableName, conditions}) {
+    const deleteInstruction = new Delete({conditions, driver: this, tableName})
+
+    return deleteInstruction.toSql()
+  }
+
+  insertSql({tableName, data}) {
+    const insert = new Insert({driver: this, tableName, data})
+
+    return insert.toSql()
+  }
+
+  options() {
+    if (!this._options) {
+      this._options = new Options({driver: this})
+    }
+
+    return this._options
+  }
+
+  updateSql({conditions, data, tableName}) {
+    const update = new Update({conditions, data, driver: this, tableName})
+
+    return update.toSql()
+  }
+}

package/src/database/drivers/mysql/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/mysql/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/mysql/query.mjs

@@ -0,0 +1,26 @@
+export default async function query(connection, sql) {
+  return new Promise((resolve, reject) => {
+    connection.query(sql, (error, results, fields) => {
+      if (error) {
+        reject(error)
+      } else {
+        const rows = []
+
+        for (const resultIndex in results) {
+          const result = {}
+
+          for (const fieldKey in fields) {
+            const field = fields[fieldKey].name
+            const value = results[resultIndex][field]
+
+            result[field] = value
+          }
+
+          rows.push(result)
+        }
+
+        resolve(rows)
+      }
+    })
+  })
+}

package/src/database/drivers/mysql/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/mysql/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/mysql/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
+  }
+}

package/src/database/handler.mjs

@@ -0,0 +1,11 @@
+export default class VelociousDatabaseHandler {
+  constructor() {
+    console.log("stub")
+  }
+
+  clone() {
+    const newHandler = new VelociousDatabaseHandler()
+
+    return newHandler
+  }
+}

package/src/database/index.mjs

@@ -0,0 +1,15 @@
+import Drivers from "./drivers/index.mjs"
+import Handler from "./handler.mjs"
+import Migration from "./migration/index.mjs"
+import Migrator from "./migrator/index.mjs"
+import Query from "./query/index.mjs"
+import Record from "./record/index.mjs"
+
+export default {
+  Drivers,
+  Handler,
+  Migration,
+  Migrator,
+  Query,
+  Record
+}

package/src/database/migration/index.mjs

@@ -0,0 +1,5 @@
+export default class VelociousDatabaseMigration {
+  createTable(tableName, callback) {
+    throw new Error("stub")
+  }
+}

package/src/database/migrator/index.mjs

@@ -0,0 +1,15 @@
+export default class VelociousDatabaseMigrator {
+  constructor({path}) {
+    if (!path) throw new Error("No 'path' given")
+
+    this.path = path
+  }
+
+  migrateUp() {
+    throw new Error("stub")
+  }
+
+  migrateDown() {
+    throw new Error("stub")
+  }
+}

package/src/database/pool/index.mjs

@@ -0,0 +1,43 @@
+import Configuration from "../../configuration.mjs"
+import {digg} from "diggerize"
+
+export default class VelociousDatabasePool {
+  static current() {
+    if (!global.velociousDatabasePool) global.velociousDatabasePool = new VelociousDatabasePool()
+
+    return global.velociousDatabasePool
+  }
+
+  async connect() {
+    if (this.connection) {
+      console.warn("DatabasePoool#connect: Already connected")
+    } else {
+      this.connection = await this.spawnConnection()
+
+      if (!this.connection) throw new Error("spawnConnection didn't set a connection")
+
+      await this.connection.connect()
+    }
+  }
+
+  isConnected = () => Boolean(this.connection)
+
+  singleConnection() {
+    if (!this.connection) throw new Error("Not connected")
+
+    return this.connection
+  }
+
+  async spawnConnection() {
+    const databaseConfigPath = `${Configuration.current().directory}/src/config/database.mjs`
+    const {databaseConfiguration} = await import(databaseConfigPath)
+    const config = databaseConfiguration()
+    const defaultConfig = digg(config, "default", "master")
+    const driverPath = `../drivers/${digg(defaultConfig, "type")}/index.mjs`
+    const DriverClassImport = await import(driverPath)
+    const DriverClass = DriverClassImport.default
+    const connection = new DriverClass(defaultConfig)
+
+    return connection
+  }
+}

package/src/database/query/delete-base.mjs

@@ -0,0 +1,15 @@
+export default class VelociousDatabaseQueryDeleteBase {
+  constructor({conditions, driver, tableName}) {
+    this.conditions = conditions
+    this.driver = driver
+    this.tableName = tableName
+  }
+
+  getOptions() {
+    return this.driver.options()
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

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

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseQueryFromBase {
+  getOptions() {
+    return this.query.getOptions()
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

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

@@ -0,0 +1,12 @@
+import FromBase from "./from-base.mjs"
+
+export default class VelociousDatabaseQueryFromPlain extends FromBase {
+  constructor({plain}) {
+    super()
+    this.plain = plain
+  }
+
+  toSql() {
+    return this.plain
+  }
+}

package/src/database/query/{from-table.cjs → from-table.mjs}

@@ -1,6 +1,6 @@
-const FromBase = require("./from-base.cjs")
+import FromBase from "./from-base.mjs"
 
-module.exports = class VelociousDatabaseQueryFromTable extends FromBase {
+export default class VelociousDatabaseQueryFromTable extends FromBase {
   constructor({tableName}) {
     super()
     this.tableName = tableName

package/src/database/query/index.mjs

@@ -0,0 +1,144 @@
+import FromPlain from "./from-plain.mjs"
+import JoinPlain from "./join-plain.mjs"
+import OrderPlain from "./order-plain.mjs"
+import SelectPlain from "./select-plain.mjs"
+
+export default class VelociousDatabaseQuery {
+  constructor({driver, froms = [], joins = [], handler, limits = [], modelClass, orders = [], selects = [], wheres = []}) {
+    if (!driver) throw new Error("No driver given")
+    if (!handler) throw new Error("No handler given")
+
+    this.driver = driver
+    this.handler = handler
+    this.modelClass = modelClass
+    this._froms = froms
+    this._joins = joins
+    this._limits = limits
+    this._orders = orders
+    this._selects = selects
+    this._wheres = wheres
+  }
+
+  clone() {
+    const newQuery = new VelociousDatabaseQuery({
+      driver: this.driver,
+      froms: [...this._froms],
+      handler: this.handler.clone(),
+      joins: [...this._joins],
+      limits: [...this._limits],
+      modelClass: this.modelClass,
+      orders: [...this._orders],
+      selects: [...this._selects],
+      wheres: [...this._wheres]
+    })
+
+    return newQuery
+  }
+
+  getOptions() {
+    return this.driver.options()
+  }
+
+  async first() {
+    const newQuery = this.clone()
+    const results = await newQuery.limit(1).reorder(this.modelClass.orderableColumn()).toArray()
+
+    return results[0]
+  }
+
+  from(from) {
+    if (typeof from == "string") from = new FromPlain({plain: from, query: this})
+
+    from.query = this
+
+    this._froms.push(from)
+    return this
+  }
+
+  async last() {
+    return await this.clone().reverseOrder().first()
+  }
+
+  limit(value) {
+    this._limits.push(value)
+    return this
+  }
+
+  joins(join) {
+    if (typeof join == "string") join = new JoinPlain({plain: join, query: this})
+
+    join.query = this
+
+    this._joins.push(join)
+    return this
+  }
+
+  order(order) {
+    if (typeof order == "number" || typeof order == "string") order = new OrderPlain({plain: order, query: this})
+
+    order.query = this
+
+    this._orders.push(order)
+    return this
+  }
+
+  reorder(order) {
+    this._orders = []
+    this.order(order)
+    return this
+  }
+
+  reverseOrder() {
+    for (const order of this._orders) {
+      order.setReverseOrder(true)
+    }
+
+    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})
+
+    select.query = this
+
+    this._selects.push(select)
+    return this
+  }
+
+  async toArray() {
+    const sql = this.toSql()
+    const results = await this.driver.query(sql)
+    const models = []
+
+    for (const result of results) {
+      const model = new this.modelClass(result)
+
+      models.push(model)
+    }
+
+    return models
+  }
+
+  toSql() {
+    return this.driver.queryToSql(this)
+  }
+
+  where(where) {
+    if (typeof where == "string") {
+      where = new WherePlain({plain: where})
+    } else if (typeof where == "object" && where.constructor.name == "object") {
+      where = new WhereHash({hash: where})
+    }
+
+    this._wheres.push(where)
+    return this
+  }
+}

package/src/database/query/insert-base.mjs

@@ -0,0 +1,15 @@
+export default class VelociousDatabaseQueryInsertBase {
+  constructor({driver, tableName, data}) {
+    this.data = data
+    this.driver = driver
+    this.tableName = tableName
+  }
+
+  getOptions() {
+    return this.driver.options()
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

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

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseQueryJoinBase {
+  getOptions() {
+    return this.query.driver.options()
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}