velocious 1.0.2 → 1.0.4

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

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

package/src/database/drivers/mysql/sql/create-table.mjs

@@ -0,0 +1,4 @@
+import CreateTableBase from "../../../query/create-table-base.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlCreateTable extends CreateTableBase {
+}

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

@@ -0,0 +1,92 @@
+import Base from "../base.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 VelociousDatabaseDriversSqliteNative 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
+  }
+
+  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/index.web.mjs

@@ -0,0 +1,64 @@
+import Base from "../base.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"
+import QueryParser from "../sqlite/query-parser.mjs"
+import Update from "../sqlite/sql/update.mjs"
+
+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
+  }
+
+  createTableSql(tableData) {
+    const createArgs = Object.assign({tableData, driver: this})
+    const createTable = new CreateTable(createArgs)
+
+    return createTable.toSql()
+  }
+
+  query = async (sql) => await query(this.connection, sql)
+  queryToSql = (query) => new QueryParser({query}).toSql()
+
+  quote(string) {
+    if (!this.connection) throw new Error("Can't escape before connected")
+
+    return this.connection.escape(string)
+  }
+
+  quoteColumn = (string) => `\`${string}\``
+  deleteSql = ({tableName, conditions}) => new Delete({conditions, driver: this, tableName}).toSql()
+  insertSql = ({tableName, data}) => new Insert({driver: this, tableName, data}).toSql()
+
+  options() {
+    if (!this._options) {
+      this._options = new Options({driver: this})
+    }
+
+    return this._options
+  }
+
+  updateSql = ({conditions, data, tableName}) => new Update({conditions, data, driver: this, tableName}).toSql()
+}

package/src/database/drivers/sqlite/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/sqlite/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/sqlite/query.native.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/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/sql/create-table.mjs

@@ -0,0 +1,4 @@
+import CreateTableBase from "../../../query/create-table-base.mjs"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlCreateTable extends CreateTableBase {
+}

package/src/database/drivers/sqlite/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/sqlite/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/sqlite/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

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

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

@@ -0,0 +1,53 @@
+import Configuration from "../configuration.mjs"
+import * as inflection from "inflection"
+
+export default class VelociousDatabaseMigrateFromRequireContext {
+  constructor(configuration) {
+    this.configuration = configuration || Configuration.current()
+  }
+
+  async execute(requireContext) {
+    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) {
+      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 () => {
+      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}`)
+      }
+    })
+  }
+}

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.getDatabasePool()
+    const sql = databasePool.createTableSql(tableData)
+
+    await databasePool.query(sql)
   }
 }

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()
+      } 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,47 @@
+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 = ["createTableSql", "deleteSql", "insertSql", "query", "quote", "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()
+  }
+
+  getCurrentConnection() {
+    if (!this.connection) {
+      throw new Error("A connection hasn't been made yet")
+    }
+
+    return this.connection
+  }
+}

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,22 @@
+import {digs} from "diggerize"
+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
+    const {tableQuote} = digs(this.getOptions(), "tableQuote")
+    let sql = "CREATE DATABASE"
+
+    if (this.ifNotExists) sql += " IF NOT EXISTS"
+
+    sql += ` ${tableQuote}${databaseName}${tableQuote}`
+
+    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
+  }
+}