velocious 1.0.3 → 1.0.5

package/src/database/drivers/sqlite/index.native.mjs

@@ -0,0 +1,54 @@
+import Base from "./base"
+import {digg} from "diggerize"
+import escapeString from "sql-string-escape"
+import Options from "../sqlite/options.mjs"
+import query from "./query"
+import * as SQLite from "expo-sqlite"
+
+export default class VelociousDatabaseDriversSqliteNative extends Base {
+  async connect() {
+    const connection = await SQLite.openDatabaseAsync(digg(this.getArgs(), "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
+  }
+
+  query = async (sql) => await query(this.connection, sql)
+
+  quote(string) {
+    const type = typeof string
+
+    if (type == "number") return string
+    if (type != "string") string = `${string}`
+
+    return escapeString(string)
+  }
+
+  options() {
+    if (!this._options) this._options = new Options({driver: this})
+
+    return this._options
+  }
+}

package/src/database/drivers/sqlite/index.web.mjs

@@ -0,0 +1,45 @@
+import Base from "./base.mjs"
+import {digg} from "diggerize"
+import Options from "../sqlite/options.mjs"
+import query from "./query"
+
+import initSqlJs from "sql.js"
+
+export default class VelociousDatabaseDriversSqliteWeb extends Base {
+  async connect() {
+    const SQL = await initSqlJs({
+      // Required to load the wasm binary asynchronously. Of course, you can host it wherever you want you can omit locateFile completely when running in Node.
+      locateFile: (file) => `https://sql.js.org/dist/${file}`
+    })
+
+    const databaseContent = localStorage.getItem(this.localStorageName())
+
+    this.connection = new SQL.Database(databaseContent)
+  }
+
+  localStorageName = () => `VelociousDatabaseDriversSqliteWeb---${digg(this.getArgs(), "name")}`
+  disconnect = () => this.saveDatabase()
+  saveDatabase = () => localStorage.setItem(this.localStorageName(), this.connection.export())
+
+  async close() {
+    this.saveDatabase()
+    await this.connection.end()
+    this.connection = undefined
+  }
+
+  query = async (sql) => await query(this.connection, sql)
+
+  quote(string) {
+    if (!this.connection) throw new Error("Can't escape before connected")
+
+    return this.connection.escape(string)
+  }
+
+  options() {
+    if (!this._options) {
+      this._options = new Options({driver: this})
+    }
+
+    return this._options
+  }
+}

package/src/database/drivers/sqlite/query.web.mjs

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

package/src/database/drivers/sqlite/table.mjs

@@ -0,0 +1,9 @@
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversSqliteTable {
+  constructor(row) {
+    this.row = row
+  }
+
+  getName = () => digg(this, "row", "name")
+}

package/src/database/migrate-from-require-context.mjs

@@ -0,0 +1,62 @@
+import Configuration from "../configuration.mjs"
+import * as inflection from "inflection"
+import Migrator from "./migrator"
+
+export default class VelociousDatabaseMigrateFromRequireContext {
+  constructor(configuration) {
+    this.configuration = configuration || Configuration.current()
+  }
+
+  async execute(requireContext) {
+    const migrator = new Migrator({configuration: this.configuration})
+
+    await migrator.prepare()
+
+    const files = requireContext.keys()
+      .map((file) => {
+        const match = file.match(/^\.\/(\d{14})-(.+)\.mjs$/)
+
+        if (!match) return null
+
+        const date = parseInt(match[1])
+        const migrationName = match[2]
+        const migrationClassName = inflection.camelize(migrationName)
+
+        return {
+          file,
+          date,
+          migrationClassName
+        }
+      })
+      .filter((migration) => Boolean(migration))
+      .sort((migration1, migration2) => migration1.date - migration2.date)
+
+    for (const migration of files) {
+      if (!migrator.hasRunMigrationVersion(migration.date)) {
+        await this.runMigrationFile(migration, requireContext)
+      }
+    }
+  }
+
+  async runMigrationFile(migration, requireContext) {
+    if (!this.configuration) throw new Error("No configuration set")
+    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
+
+    await this.configuration.getDatabasePool().withConnection(async (db) => {
+      const MigrationClass = requireContext(migration.file).default
+      const migrationInstance = new MigrationClass({
+        configuration: this.configuration
+      })
+
+      if (migrationInstance.change) {
+        await migrationInstance.change()
+      } else if (migrationInstance.up) {
+        await migrationInstance.up()
+      } else {
+        throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`)
+      }
+
+      await db.insert({tableName: "schema_migrations", data: {version: migration.date}})
+    })
+  }
+}

package/src/database/migration/index.mjs

@@ -10,7 +10,7 @@ export default class VelociousDatabaseMigration {
 
     callback(tableData)
 
-    const databasePool = this.configuration.databasePool
+    const databasePool = this.configuration.getDatabasePool()
     const sql = databasePool.createTableSql(tableData)
 
     await databasePool.query(sql)

package/src/database/migrator.mjs

@@ -0,0 +1,73 @@
+import {digg} from "diggerize"
+import TableData from "./table-data/index"
+
+export default class VelociousDatabaseMigrator {
+  constructor({configuration}) {
+    this.configuration = configuration
+  }
+
+  async prepare() {
+    const exists = await this.migrationsTableExist()
+
+    if (!exists) await this.createMigrationsTable()
+
+    await this.loadMigrationsVersions()
+  }
+
+  async createMigrationsTable() {
+    const schemaMigrationsTable = new TableData("schema_migrations", {ifNotExists: true})
+
+    schemaMigrationsTable.string("version", {null: false, primaryKey: true})
+
+    await this.configuration.getDatabasePool().withConnection(async (db) => {
+      const createSchemaMigrationsTableSql = db.createTableSql(schemaMigrationsTable)
+
+      await db.query(createSchemaMigrationsTableSql)
+    })
+  }
+
+  hasRunMigrationVersion(version) {
+    if (!this.migrationsVersions) {
+      throw new Error("Migrations versions hasn't been loaded yet")
+    }
+
+    if (version in this.migrationsVersions) {
+      return true
+    }
+
+    return false
+  }
+
+  async loadMigrationsVersions() {
+    const db = this.configuration.getDatabasePool()
+
+    this.migrationsVersions = {}
+
+    await db.withConnection(async () => {
+      const rows = await db.select("schema_migrations")
+
+      for (const row of rows) {
+        const version = digg(row, "version")
+
+        this.migrationsVersions[version] = true
+      }
+    })
+  }
+
+  async migrationsTableExist() {
+    let exists = false
+
+    await this.configuration.getDatabasePool().withConnection(async (db) => {
+      const tables = await db.getTables()
+
+      for (const table of tables) {
+        if (table.getName() == "schema_migrations") {
+          exists = true
+          break
+        }
+      }
+    })
+
+    return exists
+  }
+}

package/src/database/pool/async-tracked-multi-connection.mjs

@@ -0,0 +1,81 @@
+import {AsyncLocalStorage} from "async_hooks"
+import BasePool from "./base.mjs"
+
+let idSeq = 0
+
+export default class VelociousDatabasePoolAsyncTrackedMultiConnection extends BasePool {
+  static current() {
+    if (!this.velociousDatabasePoolAsyncTrackedMultiConnection) {
+      this.velociousDatabasePoolAsyncTrackedMultiConnection = new VelociousDatabasePoolAsyncTrackedMultiConnection()
+    }
+
+    return this.velociousDatabasePoolAsyncTrackedMultiConnection
+  }
+
+  constructor(args = {}) {
+    super(args)
+    this.connections = []
+    this.connectionsInUse = {}
+    this.asyncLocalStorage = new AsyncLocalStorage()
+  }
+
+  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
+  }
+
+  setCurrent() {
+    this.constructor.velociousDatabasePoolAsyncTrackedMultiConnection = this
+  }
+
+  async withConnection(callback) {
+    const connection = await this.checkout()
+    const id = connection.getIdSeq()
+
+    await this.asyncLocalStorage.run(id, async () => {
+      try {
+        await callback(connection)
+      } finally {
+        this.checkin(connection)
+      }
+    })
+  }
+
+  getCurrentConnection() {
+    const id = this.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]
+  }
+}

package/src/database/pool/base.mjs

@@ -0,0 +1,60 @@
+import Configuration from "../../configuration.mjs"
+import {digg} from "diggerize"
+
+class VelociousDatabasePoolBase {
+  constructor(args = {}) {
+    this.configuration = args.configuration || Configuration.current()
+    this.connections = []
+    this.connectionsInUse = {}
+  }
+
+  getConfiguration = () => digg(this, "configuration", "database", "default", "master")
+
+  setDriverClass(driverClass) {
+    this.driverClass = driverClass
+  }
+
+  async spawnConnection() {
+    const defaultConfig = this.getConfiguration()
+    const connection = await this.spawnConnectionWithConfiguration(defaultConfig)
+
+    return connection
+  }
+
+  async spawnConnectionWithConfiguration(config) {
+    const DriverClass = config.driver || this.driverClass
+
+    if (!DriverClass) throw new Error("No driver class set in database pool or in given config")
+
+    const connection = new DriverClass(config)
+
+    await connection.connect()
+
+    return connection
+  }
+}
+
+const forwardMethods = [
+  "createTable",
+  "createTableSql",
+  "delete",
+  "deleteSql",
+  "getTables",
+  "insert",
+  "insertSql",
+  "query",
+  "quote",
+  "select",
+  "update",
+  "updateSql"
+]
+
+for (const forwardMethod of forwardMethods) {
+  VelociousDatabasePoolBase.prototype[forwardMethod] = function(...args) {
+    const connection = this.getCurrentConnection()
+
+    return connection[forwardMethod](...args)
+  }
+}
+
+export default VelociousDatabasePoolBase

package/src/database/pool/single-multi-use.mjs

@@ -0,0 +1,40 @@
+import BasePool from "./base.mjs"
+
+export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
+  static current() {
+    if (!this.velociousDatabasePoolSingleMultiUser) {
+      this.velociousDatabasePoolSingleMultiUser = new VelociousDatabasePoolSingleMultiUser()
+    }
+
+    return this.velociousDatabasePoolSingleMultiUser
+  }
+
+  checkin = (connection) => {
+    // Do nothing
+  }
+
+  async checkout() {
+    if (!this.connection) {
+      this.connection = await this.spawnConnection()
+    }
+
+    return this.connection
+  }
+
+  setCurrent() {
+    this.constructor.velociousDatabasePoolSingleMultiUser = this
+  }
+
+  async withConnection(callback) {
+    await this.checkout() // Ensure a connection is present
+    await callback(this.connection)
+  }
+
+  getCurrentConnection() {
+    if (!this.connection) {
+      throw new Error("A connection hasn't been made yet")
+    }
+
+    return this.connection
+  }
+}

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

@@ -1,3 +1,4 @@
+import {digs} from "diggerize"
 import QueryBase from "./base.mjs"
 
 export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
@@ -9,11 +10,12 @@ export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase
 
   toSql() {
     const {databaseName} = this
+    const {tableQuote} = digs(this.getOptions(), "tableQuote")
     let sql = "CREATE DATABASE"
 
     if (this.ifNotExists) sql += " IF NOT EXISTS"
 
-    sql += ` ${databaseName}`
+    sql += ` ${tableQuote}${databaseName}${tableQuote}`
 
     return sql
   }

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

@@ -1,5 +1,9 @@
 export default class VelociousDatabaseQueryInsertBase {
   constructor({driver, tableName, data}) {
+    if (!driver) throw new Error("No driver given to insert base")
+    if (!tableName) throw new Error(`Invalid table name given to insert base: ${tableName}`)
+    if (!data) throw new Error("No data given to insert base")
+
     this.data = data
     this.driver = driver
     this.tableName = tableName

package/src/database/query-parser/options.mjs

@@ -11,13 +11,13 @@ export default class VelociousDatabaseQueryParserOptions {
   }
 
   quoteColumnName(columnName) {
-    if (columnName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${columnName}`)
+    if (!columnName || columnName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${columnName}`)
 
     return `${this.columnQuote}${columnName}${this.columnQuote}`
   }
 
   quoteTableName(tableName) {
-    if (tableName.includes(this.tableQuote)) throw new Error(`Invalid table name: ${tableName}`)
+    if (!tableName || tableName.includes(this.tableQuote)) throw new Error(`Invalid table name: ${tableName}`)
 
     return `${this.tableQuote}${tableName}${this.tableQuote}`
   }

package/src/database/record/index.mjs

@@ -1,4 +1,4 @@
-import DatabasePool from "../pool/index.mjs"
+import Configuration from "../../configuration.mjs"
 import Handler from "../handler.mjs"
 import inflection from "inflection"
 import Query from "../query/index.mjs"
@@ -6,7 +6,7 @@ import RecordNotFoundError from "./record-not-found-error.mjs"
 
 export default class VelociousDatabaseRecord {
   static connection() {
-    const connection = DatabasePool.current().getCurrentConnection()
+    const connection = Configuration.current().getDatabasePoolType().current().getCurrentConnection()
 
     if (!connection) throw new Error("No connection?")
 

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

@@ -13,7 +13,8 @@ export default class VelociousHttpServerWorker {
 
   async start() {
     return new Promise((resolve) => {
-      const {debug, directory} = digs(this.configuration, "debug", "directory")
+      const {debug} = digs(this.configuration, "debug")
+      const directory = this.configuration.getDirectory()
       const __filename = fileURLToPath(import.meta.url)
       const __dirname = dirname(__filename)
 

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

@@ -1,6 +1,5 @@
 import Application from "../../application.mjs"
 import Client from "../client/index.mjs"
-import DatabasePool from "../../database/pool/index.mjs"
 import {digg, digs} from "diggerize"
 import errorLogger from "../../error-logger.mjs"
 import logger from "../../logger.mjs"

package/src/routes/app-routes.mjs

@@ -0,0 +1,10 @@
+import {digg} from "diggerize"
+
+export default class VelociousRoutesAppRoutes {
+  static async getRoutes(configuration) {
+    // Every client need to make their own routes because they probably can't be shared across different worker threads
+    const routesImport = await import(`${configuration.getDirectory()}/src/config/routes.mjs`)
+
+    return digg(routesImport, "default", "routes")
+  }
+}

package/src/routes/resolver.mjs

@@ -21,7 +21,7 @@ export default class VelociousRoutesResolver {
     if (!matchResult) throw new Error(`Couldn't match a route with the given path: ${currentPath}`)
 
     if (this.params.action && this.params.controller) {
-      const controllerPath = `${digg(this, "configuration", "directory")}/src/routes/${digg(this, "params", "controller")}/controller.mjs`
+      const controllerPath = `${this.configuration.getDirectory()}/src/routes/${digg(this, "params", "controller")}/controller.mjs`
       const controllerClassImport = await import(controllerPath)
       const controllerClass = controllerClassImport.default
       const controllerInstance = new controllerClass({

package/src/templates/configuration.mjs

@@ -1,9 +1,13 @@
-import {Configuration} from "velocious"
+import AsyncTrackedMultiConnection from "velocious/src/database/pool/async-tracked-multi-connection.mjs"
+import Configuration from "velocious/src/configuration.mjs"
+import MysqlDriver from "velocious/src/database/drivers/mysql/index.mjs"
 
-const configuration = new Configuration({
+export default new Configuration({
   database: {
     default: {
       master: {
+        driver: MysqlDriver,
+        poolType: AsyncTrackedMultiConnection,
         type: "mysql",
         host: "mariadb",
         username: "username",
@@ -13,5 +17,3 @@ const configuration = new Configuration({
     }
   }
 })
-
-export default configuration

package/src/templates/generate-migration.mjs

@@ -1,6 +1,6 @@
-import {Database} from "velocious"
+import Migration from "velocious/src/database/migration/index.mjs"
 
-export default class __MIGRATION_NAME__ extends Database.Migration {
+export default class __MIGRATION_NAME__ extends Migration {
   async up() {
     await this.connection().execute("...")
   }

package/src/templates/generate-model.mjs

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

package/src/templates/routes.mjs

@@ -1,4 +1,4 @@
-import {Routes} from "velocious"
+import Routes from "velocious/src/routes/index.mjs"
 
 const routes = new Routes()
 

package/src/database/drivers/index.mjs

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

package/src/database/drivers/sqlite/sql/create-database.mjs

@@ -1,4 +0,0 @@
-import CreateDatabaseBase from "../../../query/create-database-base.mjs"
-
-export default class VelociousDatabaseConnectionDriversMysqlSqlCreateDatabase extends CreateDatabaseBase {
-}