velocious 1.0.1 → 1.0.3

package/src/database/pool/index.mjs

@@ -0,0 +1,112 @@
+import {AsyncLocalStorage} from "node:async_hooks"
+import Configuration from "../../configuration.mjs"
+import {digg} from "diggerize"
+
+const asyncLocalStorage = new AsyncLocalStorage()
+let idSeq = 0
+
+class VelociousDatabasePool {
+  static current() {
+    if (!global.velociousDatabasePool) global.velociousDatabasePool = new VelociousDatabasePool()
+
+    return global.velociousDatabasePool
+  }
+
+  constructor(args = {}) {
+    this.configuration = args.configuration || Configuration.current()
+    this.connections = []
+    this.connectionsInUse = {}
+  }
+
+  checkin = (connection) => {
+    const id = connection.getIdSeq()
+
+    if (id in this.connectionsInUse) {
+      delete this.connectionsInUse[id]
+    }
+
+    connection.setIdSeq(undefined)
+
+    this.connections.push(connection)
+  }
+
+  async checkout() {
+    let connection = this.connections.shift()
+
+    if (!connection) {
+      connection = await this.spawnConnection()
+    }
+
+    if (connection.getIdSeq() !== undefined) throw new Error(`Connection already has an ID-seq - is it in use? ${connection.getIdSeq()}`)
+
+    const id = idSeq++
+
+    connection.setIdSeq(id)
+    this.connectionsInUse[id] = connection
+
+    return connection
+  }
+
+  getConfiguration = () => digg(this, "configuration", "database", "default", "master")
+
+  setCurrent() {
+    global.velociousDatabasePool = this
+  }
+
+  async spawnConnection() {
+    const defaultConfig = this.getConfiguration()
+    const connection = await this.spawnConnectionWithConfiguration(defaultConfig)
+
+    return connection
+  }
+
+  async spawnConnectionWithConfiguration(config) {
+    const driverPath = `../drivers/${digg(config, "type")}/index.mjs`
+    const DriverClassImport = await import(driverPath)
+    const DriverClass = DriverClassImport.default
+    const connection = new DriverClass(config)
+
+    await connection.connect()
+
+    return connection
+  }
+
+  async withConnection(callback) {
+    const connection = await this.checkout()
+    const id = connection.getIdSeq()
+
+    await asyncLocalStorage.run(id, async () => {
+      try {
+        await callback()
+      } finally {
+        this.checkin(connection)
+      }
+    })
+  }
+
+  getCurrentConnection() {
+    const id = asyncLocalStorage.getStore()
+
+    if (id === undefined) {
+      throw new Error("ID hasn't been set for this async context")
+    }
+
+    if (!(id in this.connectionsInUse)) {
+      throw new Error(`Connection ${id} doesn't exist any more - has it been checked in again?`)
+    }
+
+    return this.connectionsInUse[id]
+  }
+}
+
+const forwardMethods = ["createTableSql", "deleteSql", "insertSql", "query", "quote", "updateSql"]
+
+for (const forwardMethod of forwardMethods) {
+  VelociousDatabasePool.prototype[forwardMethod] = function(...args) {
+    const connection = this.getCurrentConnection()
+
+    return connection[forwardMethod](...args)
+  }
+}
+
+export default VelociousDatabasePool

package/src/database/query/base.mjs

@@ -0,0 +1,11 @@
+export default class VelociousDatabaseQueryBase {
+  constructor({driver}) {
+    this.driver = driver
+  }
+
+  getOptions = () => this.driver?.options()
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

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

@@ -0,0 +1,20 @@
+import QueryBase from "./base.mjs"
+
+export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
+  constructor({driver, databaseName, ifNotExists}) {
+    super({driver})
+    this.databaseName = databaseName
+    this.ifNotExists = ifNotExists
+  }
+
+  toSql() {
+    const {databaseName} = this
+    let sql = "CREATE DATABASE"
+
+    if (this.ifNotExists) sql += " IF NOT EXISTS"
+
+    sql += ` ${databaseName}`
+
+    return sql
+  }
+}

package/src/database/query/create-table-base.mjs

@@ -0,0 +1,69 @@
+import QueryBase from "./base.mjs"
+
+export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
+  constructor({driver, ifNotExists, tableData}) {
+    super({driver})
+    this.ifNotExists = ifNotExists
+    this.tableData = tableData
+  }
+
+  toSql() {
+    const {tableData} = this
+    let sql = "CREATE TABLE"
+
+    if (this.ifNotExists || tableData.getIfNotExists()) sql += " IF NOT EXISTS"
+
+    sql += ` ${tableData.getName()} (`
+
+    let columnCount = 0
+
+    for (const column of tableData.getColumns()) {
+      columnCount++
+
+      let maxlength = column.args.maxlength
+      let type = column.args.type
+
+      if (type == "string") {
+        type = "varchar"
+        maxlength ||= 255
+      }
+
+      if (columnCount > 1) sql += ", "
+
+      sql += `${this.driver.quoteColumn(column.name)} ${type}`
+
+      if (maxlength !== undefined) sql += `(${maxlength})`
+
+      if (column.args.autoIncrement) sql += " AUTO_INCREMENT"
+      if (column.args.primaryKey) sql += " PRIMARY KEY"
+    }
+
+    for (const index of tableData.getIndexes()) {
+      sql += ","
+
+      if (index.getUnique()) {
+        sql += " UNIQUE"
+      }
+
+      sql += " INDEX"
+
+      if (index.getName()) {
+        sql += ` ${index.getName()}`
+      }
+
+      sql += " ("
+
+      index.getColumns().forEach((column, columnIndex) => {
+        if (columnIndex > 0) sql += ", "
+
+        sql += this.driver.quoteColumn(column.name)
+      })
+
+      sql += ")"
+    }
+
+    sql += ")"
+
+    return sql
+  }
+}

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

@@ -0,0 +1,9 @@
+import QueryBase from "./base.mjs"
+
+export default class VelociousDatabaseQueryDeleteBase extends QueryBase {
+  constructor({conditions, driver, tableName}) {
+    super({driver})
+    this.conditions = conditions
+    this.tableName = tableName
+  }
+}

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,10 @@
+import FromBase from "./from-base.mjs"
+
+export default class VelociousDatabaseQueryFromPlain extends FromBase {
+  constructor({driver, plain}) {
+    super({driver})
+    this.plain = plain
+  }
+
+  toSql = () => this.plain
+}

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

@@ -0,0 +1,12 @@
+import FromBase from "./from-base.mjs"
+
+export default class VelociousDatabaseQueryFromTable extends FromBase {
+  constructor({driver, tableName}) {
+    super({driver})
+    this.tableName = tableName
+  }
+
+  toSql() {
+    return this.getOptions().quoteTableName(this.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")
+  }
+}

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

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

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

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

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

@@ -0,0 +1,21 @@
+import OrderBase from "./order-base.mjs"
+
+export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
+  constructor({plain}) {
+    super()
+    this.plain = plain
+    this.reverseOrder = false
+  }
+
+  setReverseOrder() {
+    this.reverseOrder = true
+  }
+
+  toSql() {
+    if (this.reverseOrder) {
+      return `${this.plain} DESC`
+    }
+
+    return this.plain
+  }
+}

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

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

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

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

package/src/database/query/{select-table-and-column.cjs → select-table-and-column.mjs}

@@ -1,8 +1,8 @@
-const SelectBase = require("./select-base.cjs")
+import SelectBase from "./select-base.mjs"
 
-module.exports = class VelociousDatabaseQuerySelectTableAndColumn extends SelectBase {
-  constructor({tableName, columnName}) {
-    super()
+export default class VelociousDatabaseQuerySelectTableAndColumn extends SelectBase {
+  constructor({query, tableName, columnName}) {
+    super({query})
     this.columnName = columnName
     this.tableName = tableName
   }

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

@@ -0,0 +1,16 @@
+export default class VelociousDatabaseQueryUpdateBase {
+  constructor({conditions, data, driver, tableName}) {
+    this.conditions = conditions
+    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-parser/{from-parser.cjs → from-parser.mjs}

@@ -1,10 +1,9 @@
-const {digs} = require("diggerize")
+import {digs} from "diggerize"
 
-module.exports = class VelociousDatabaseQueryParserFromParser {
-  constructor({pretty, query, queryParserOptions}) {
+export default class VelociousDatabaseQueryParserFromParser {
+  constructor({pretty, query}) {
     this.pretty = pretty
     this.query = query
-    this.queryParserOptions = queryParserOptions
   }
 
   toSql() {
@@ -15,8 +14,6 @@ module.exports = class VelociousDatabaseQueryParserFromParser {
     for (const fromKey in query._froms) {
       const from = query._froms[fromKey]
 
-      from.setOptions(this.queryParserOptions)
-
       if (fromKey > 0) {
         sql += ","
       }

package/src/database/query-parser/{joins-parser.cjs → joins-parser.mjs}

@@ -1,10 +1,9 @@
-const {digs} = require("diggerize")
+import {digs} from "diggerize"
 
-module.exports = class VelocuiousDatabaseQueryParserJoinsParser {
-  constructor({pretty, query, queryParserOptions}) {
+export default class VelocuiousDatabaseQueryParserJoinsParser {
+  constructor({pretty, query}) {
     this.pretty = pretty
     this.query = query
-    this.queryParserOptions = queryParserOptions
   }
 
   toSql() {
@@ -15,8 +14,6 @@ module.exports = class VelocuiousDatabaseQueryParserJoinsParser {
     for (const joinKey in query._joins) {
       const join = query._joins[joinKey]
 
-      join.setOptions(this.queryParserOptions)
-
       if (joinKey == 0) {
         if (pretty) {
           sql += "\n\n"

package/src/database/query-parser/{options.cjs → options.mjs}

@@ -1,9 +1,13 @@
-const {digg} = require("diggerize")
+import {digg} from "diggerize"
 
-module.exports = class VelociousDatabaseQueryParserOptions {
+export default class VelociousDatabaseQueryParserOptions {
   constructor(options) {
     this.columnQuote = digg(options, "columnQuote")
+    this.driver = digg(options, "driver")
     this.tableQuote = digg(options, "tableQuote")
+    this.stringQuote = digg(options, "stringQuote")
+
+    if (!this.driver) throw new Error("No driver given")
   }
 
   quoteColumnName(columnName) {
@@ -17,4 +21,11 @@ module.exports = class VelociousDatabaseQueryParserOptions {
 
     return `${this.tableQuote}${tableName}${this.tableQuote}`
   }
+
+  quote(value) {
+    if (typeof value == "number")
+      return value
+
+    return this.quoteString(value)
+  }
 }

package/src/database/query-parser/{select-parser.cjs → select-parser.mjs}

@@ -1,10 +1,9 @@
-const {digs} = require("diggerize")
+import {digs} from "diggerize"
 
-module.exports = class VelociousDatabaseQueryParserSelectParser {
-  constructor({pretty, query, queryParserOptions}) {
+export default class VelociousDatabaseQueryParserSelectParser {
+  constructor({pretty, query}) {
     this.pretty = pretty
     this.query = query
-    this.queryParserOptions = queryParserOptions
   }
 
   toSql() {
@@ -23,8 +22,6 @@ module.exports = class VelociousDatabaseQueryParserSelectParser {
     for (const selectKey in query._selects) {
       const selectValue = query._selects[selectKey]
 
-      selectValue.setOptions(this.queryParserOptions)
-
       sql += selectValue.toSql()
 
       if (selectKey + 1 < query._selects.length) {
@@ -37,6 +34,10 @@ module.exports = class VelociousDatabaseQueryParserSelectParser {
       }
     }
 
+    if (query._selects.length == 0) {
+      sql += "*"
+    }
+
     return sql
   }
 }