velocious 1.0.2 → 1.0.3

package/src/database/drivers/sqlite-expo/index.mjs

@@ -0,0 +1,100 @@
+import Base from "../base.mjs"
+import CreateDatabase from "../sqlite/sql/create-database.mjs"
+import CreateTable from "../sqlite/sql/create-table.mjs"
+import Delete from "../sqlite/sql/delete.mjs"
+import {digg} from "diggerize"
+import Insert from "../sqlite/sql/insert.mjs"
+import Options from "../sqlite/options.mjs"
+import query from "./query.mjs"
+import QueryParser from "../sqlite/query-parser.mjs"
+import * as SQLite from "expo-sqlite"
+import Update from "../sqlite/sql/update.mjs"
+
+export default class VelociousDatabaseDriversMysql extends Base{
+  async connect() {
+    const connection = await SQLite.openDatabaseAsync(digg(this.connectArgs(), "name"))
+
+    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 close() {
+    await this.connection.end()
+    this.connection = undefined
+  }
+
+  createDatabaseSql(databaseName, args) {
+    const createArgs = Object.assign({databaseName, driver: this}, args)
+    const createDatabase = new CreateDatabase(createArgs)
+
+    return createDatabase.toSql()
+  }
+
+  createTableSql(tableData) {
+    const createArgs = Object.assign({tableData, driver: this})
+    const createTable = new CreateTable(createArgs)
+
+    return createTable.toSql()
+  }
+
+  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)
+  }
+
+  quoteColumn(string) {
+    return `\`${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/sqlite-expo/query.mjs

@@ -0,0 +1,9 @@
+export default async function query(connection, sql) {
+  const rows = []
+
+  for await (const entry of connection.getEachAsync(sql)) {
+    rows.push(entry)
+  }
+
+  return rows
+}

package/src/database/handler.mjs

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

package/src/database/migration/index.mjs

@@ -1,5 +1,18 @@
+import TableData from "../table-data/index.mjs"
+
 export default class VelociousDatabaseMigration {
-  createTable(tableName, callback) {
-    throw new Error("stub")
+  constructor({configuration}) {
+    this.configuration = configuration
+  }
+
+  async createTable(tableName, callback) {
+    const tableData = new TableData(tableName)
+
+    callback(tableData)
+
+    const databasePool = this.configuration.databasePool
+    const sql = databasePool.createTableSql(tableData)
+
+    await databasePool.query(sql)
   }
 }

package/src/database/pool/index.mjs

@@ -1,43 +1,112 @@
+import {AsyncLocalStorage} from "node:async_hooks"
 import Configuration from "../../configuration.mjs"
 import {digg} from "diggerize"
 
-export default class VelociousDatabasePool {
+const asyncLocalStorage = new AsyncLocalStorage()
+let idSeq = 0
+
+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()
+  constructor(args = {}) {
+    this.configuration = args.configuration || Configuration.current()
+    this.connections = []
+    this.connectionsInUse = {}
+  }
 
-      if (!this.connection) throw new Error("spawnConnection didn't set a connection")
+  checkin = (connection) => {
+    const id = connection.getIdSeq()
 
-      await this.connection.connect()
+    if (id in this.connectionsInUse) {
+      delete this.connectionsInUse[id]
     }
+
+    connection.setIdSeq(undefined)
+
+    this.connections.push(connection)
   }
 
-  isConnected = () => Boolean(this.connection)
+  async checkout() {
+    let connection = this.connections.shift()
 
-  singleConnection() {
-    if (!this.connection) throw new Error("Not connected")
+    if (!connection) {
+      connection = await this.spawnConnection()
+    }
 
-    return this.connection
+    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 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 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(defaultConfig)
+    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

@@ -1,15 +1,9 @@
-export default class VelociousDatabaseQueryDeleteBase {
+import QueryBase from "./base.mjs"
+
+export default class VelociousDatabaseQueryDeleteBase extends QueryBase {
   constructor({conditions, driver, tableName}) {
+    super({driver})
     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-plain.mjs

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

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

@@ -1,8 +1,8 @@
 import FromBase from "./from-base.mjs"
 
 export default class VelociousDatabaseQueryFromTable extends FromBase {
-  constructor({tableName}) {
-    super()
+  constructor({driver, tableName}) {
+    super({driver})
     this.tableName = tableName
   }
 

package/src/database/record/index.mjs

@@ -6,7 +6,7 @@ import RecordNotFoundError from "./record-not-found-error.mjs"
 
 export default class VelociousDatabaseRecord {
   static connection() {
-    const connection = DatabasePool.current().singleConnection()
+    const connection = DatabasePool.current().getCurrentConnection()
 
     if (!connection) throw new Error("No connection?")
 

package/src/database/table-data/index.mjs

@@ -0,0 +1,83 @@
+class TableColumn {
+  constructor(name, args) {
+    this.args = args
+    this.name = name
+  }
+}
+
+class TableIndex {
+  constructor(columns, args) {
+    this.args = args
+    this.columns = columns
+  }
+
+  getColumns = () => this.columns
+  getName = () => this.args.name
+  getUnique = () => Boolean(this.args.unique)
+}
+
+class TableReference {
+  constructor(name, args) {
+    this.args = args
+    this.name = name
+  }
+}
+
+export default class TableData {
+  _columns = []
+  _indexes = []
+  _references = []
+
+  constructor(name, args = {}) {
+    this.args = args
+    this._name = name
+  }
+
+  getColumns = () => this._columns
+  getName = () => this._name
+  getIfNotExists = () => this.args.ifNotExists
+  getIndexes = () => this._indexes
+  getReferences = () => this._references
+
+  bigint(name, args = {}) {
+    const columnArgs = Object.assign({type: "bigint"}, args)
+    const column = new TableColumn(name, columnArgs)
+
+    this._columns.push(column)
+  }
+
+  references(name, args = {}) {
+    const columnName = `${name}_id`
+    const indexName = `index_on_${columnName}`
+    const reference = new TableReference(name, args)
+    const columnArgs = Object.assign({type: "bigint"}, args)
+    const column = new TableColumn(columnName, columnArgs)
+    const index = new TableIndex([column], {name: indexName})
+
+    this._columns.push(column)
+    this._indexes.push(index)
+    this._references.push(reference)
+  }
+
+  string(name, args) {
+    const columnArgs = Object.assign({type: "string"}, args)
+    const column = new TableColumn(name, columnArgs)
+
+    this._columns.push(column)
+  }
+
+  text(name, args) {
+    const columnArgs = Object.assign({type: "text"}, args)
+    const column = new TableColumn(name, columnArgs)
+
+    this._columns.push(column)
+  }
+
+  timestamps() {
+    const createdAtColumn = new TableColumn("created_at", {type: "datetime"})
+    const updatedAtColumn = new TableColumn("updated_at", {type: "datetime"})
+
+    this._columns.push(createdAtColumn)
+    this._columns.push(updatedAtColumn)
+  }
+}

package/src/http-server/worker-handler/worker-thread.mjs

@@ -7,26 +7,35 @@ import logger from "../../logger.mjs"
 
 export default class VelociousHttpServerWorkerHandlerWorkerThread {
   constructor({parentPort, workerData}) {
-    const {debug, directory, workerCount} = digs(workerData, "debug", "directory", "workerCount")
+    const {workerCount} = digs(workerData, "workerCount")
 
-    this.application = new Application({debug, directory})
-    this.databasePool = DatabasePool.current()
     this.clients = {}
-    this.configuration = this.application.configuration
     this.parentPort = parentPort
+    this.workerData = workerData
     this.workerCount = workerCount
 
     parentPort.on("message", errorLogger(this.onCommand))
 
-    logger(this, `Worker ${workerCount} started`)
-
-    this.application.initialize().then(() => {
-      this.databasePool.connect().then(() => {
+    this.initialize().then(() => {
+      this.application.initialize().then(() => {
+        logger(this, `Worker ${workerCount} started`)
         parentPort.postMessage({command: "started"})
       })
     })
   }
 
+  async initialize() {
+    const {debug, directory} = digs(this.workerData, "debug", "directory")
+    const configurationPath = `${this.workerData.directory}/src/config/configuration.mjs`
+    const configurationImport = await import(configurationPath)
+    const configuration = configurationImport.default
+
+    this.application = new Application({configuration, debug, directory})
+
+    this.configuration = configuration
+    this.configuration.setCurrent()
+  }
+
   onCommand = (data) => {
     logger(this, `Worker ${this.workerCount} received command`, data)
 

package/src/routes/resolver.mjs

@@ -35,7 +35,9 @@ export default class VelociousRoutesResolver {
         throw new Error(`Missing action on controller: ${this.params.controller}#${this.params.action}`)
       }
 
-      await controllerInstance[this.params.action]()
+      await this.configuration.getDatabasePool().withConnection(async () => {
+        await controllerInstance[this.params.action]()
+      })
 
       return
     }

package/src/spec/index.mjs

@@ -0,0 +1,5 @@
+export default class VelocuiousSpec {
+  static describe(description) {
+    throw new Error("stub", description)
+  }
+}

package/src/templates/configuration.mjs

@@ -0,0 +1,17 @@
+import {Configuration} from "velocious"
+
+const configuration = new Configuration({
+  database: {
+    default: {
+      master: {
+        type: "mysql",
+        host: "mariadb",
+        username: "username",
+        password: "password",
+        database: "database"
+      }
+    }
+  }
+})
+
+export default configuration

package/src/templates/generate-migration.mjs

@@ -0,0 +1,11 @@
+import {Database} from "velocious"
+
+export default class __MIGRATION_NAME__ extends Database.Migration {
+  async up() {
+    await this.connection().execute("...")
+  }
+
+  async down() {
+    await this.connection().execute("...")
+  }
+}

package/src/templates/routes.mjs

@@ -0,0 +1,11 @@
+import {Routes} from "velocious"
+
+const routes = new Routes()
+
+routes.draw((route) => {
+  route.resources("tasks", (route) => {
+    route.get("users")
+  })
+})
+
+export default {routes}

package/src/utils/file-exists.mjs

@@ -0,0 +1,13 @@
+import fs from "node:fs/promises"
+
+const fileExists = async (path) => {
+  try {
+    await fs.access(path)
+
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+export default fileExists

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

@@ -1,9 +0,0 @@
-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/dummy/src/config/database.example.mjs

@@ -1,15 +0,0 @@
-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

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