velocious 1.0.5 → 1.0.7

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

@@ -0,0 +1,55 @@
+import BetterLocalStorage from "better-localstorage"
+import debounce from "debounce"
+import {digg} from "diggerize"
+import initSqlJs from "sql.js"
+import query from "./query"
+
+import Base from "./base.js"
+
+export default class VelociousDatabaseDriversSqliteWeb extends Base {
+  async connect() {
+    this.betterLocaleStorage ||= new BetterLocalStorage()
+
+    const args = this.getArgs()
+
+    if (args.reset) {
+      await this.betterLocaleStorage.delete(this.localStorageName())
+    }
+
+    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 = await this.betterLocaleStorage.get(this.localStorageName())
+
+    this.connection = new SQL.Database(databaseContent)
+  }
+
+  localStorageName = () => `VelociousDatabaseDriversSqliteWeb---${digg(this.getArgs(), "name")}`
+  disconnect = () => this.saveDatabase()
+  saveDatabase = async () => {
+    const localStorageContent = this.connection.export()
+    await this.betterLocaleStorage.set(this.localStorageName(), localStorageContent)
+  }
+
+  saveDatabaseDebounce = debounce(this.saveDatabase, 500)
+
+  async close() {
+    await this.saveDatabase()
+    await this.connection.end()
+    this.connection = undefined
+  }
+
+  query = async (sql) => {
+    const result = await query(this.connection, sql)
+    const downcasedSQL = sql.toLowerCase().trim()
+
+    // Auto-save database in local storage in case we can find manipulating instructions in the SQL
+    if (downcasedSQL.startsWith("delete ") || downcasedSQL.startsWith("insert into ") || downcasedSQL.startsWith("update ")) {
+      this.saveDatabaseDebounce()
+    }
+
+    return result
+  }
+}

package/src/database/drivers/{mysql/options.mjs → sqlite/options.js}

@@ -1,8 +1,9 @@
-import QueryParserOptions from "../../query-parser/options.mjs"
+import QueryParserOptions from "../../query-parser/options.js"
 
-export default class VelociousDatabaseDriversMysqlOptions extends QueryParserOptions {
+export default class VelociousDatabaseDriversSqliteOptions extends QueryParserOptions {
   constructor(options) {
     options.columnQuote = "`"
+    options.indexQuote = "`"
     options.stringQuote = "'"
     options.tableQuote = "`"
 

package/src/database/drivers/sqlite/query-parser.js

@@ -0,0 +1,4 @@
+import BaseQueryParser from "../../query-parser/base-query-parser.js"
+
+export default class VelociousDatabaseConnectionDriversSqliteQueryParser extends BaseQueryParser {
+}

package/src/database/drivers/sqlite/query.native.js

@@ -0,0 +1,24 @@
+export default async function query(connection, sql) {
+  const rows = []
+  let result
+
+  try {
+    result = await connection.getAllAsync(sql)
+  } catch (error) {
+    let sqlInErrorMessage = `${sql}`
+
+    if (sqlInErrorMessage.length >= 4096) {
+      sqlInErrorMessage = `${sqlInErrorMessage.substring(0, 4096)}...`
+    }
+
+    error.message += `\n\n${sqlInErrorMessage}`
+
+    throw error
+  }
+
+  for await (const entry of result) {
+    rows.push(entry)
+  }
+
+  return rows
+}

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

@@ -0,0 +1,34 @@
+export default async function query(connection, sql) {
+  const rows = []
+  let result
+
+  try {
+    result = connection.exec(sql)
+  } catch (error) {
+    let sqlInErrorMessage = `${sql}`
+
+    if (sqlInErrorMessage.length >= 4096) {
+      sqlInErrorMessage = `${sqlInErrorMessage.substring(0, 4096)}...`
+    }
+
+    error.message += `\n\n${sqlInErrorMessage}`
+
+    throw error
+  }
+
+  if (result[0]) {
+    const columns = result[0].columns
+
+    for (const rowValues of result[0].values) {
+      const row = {}
+
+      for (const columnIndex in columns) {
+        row[columns[columnIndex]] = rowValues[columnIndex]
+      }
+
+      rows.push(row)
+    }
+  }
+
+  return rows
+}

package/src/database/drivers/sqlite/sql/create-index.js

@@ -0,0 +1,4 @@
+import CreateIndexBase from "../../../query/create-index-base.js"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlCreateIndex extends CreateIndexBase {
+}

package/src/database/drivers/{mysql/sql/create-table.mjs → sqlite/sql/create-table.js}

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

package/src/database/drivers/sqlite/sql/{delete.mjs → delete.js}

@@ -1,4 +1,4 @@
-import DeleteBase from "../../../query/delete-base.mjs"
+import DeleteBase from "../../../query/delete-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlDelete extends DeleteBase {
   toSql() {

package/src/database/drivers/{mysql/sql/insert.mjs → sqlite/sql/insert.js}

@@ -1,4 +1,4 @@
-import InsertBase from "../../../query/insert-base.mjs"
+import InsertBase from "../../../query/insert-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlInsert extends InsertBase {
   toSql() {

package/src/database/drivers/sqlite/sql/{update.mjs → update.js}

@@ -1,4 +1,4 @@
-import UpdateBase from "../../../query/update-base.mjs"
+import UpdateBase from "../../../query/update-base.js"
 
 export default class VelociousDatabaseConnectionDriversMysqlSqlUpdate extends UpdateBase {
   toSql() {

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

@@ -0,0 +1,24 @@
+import Column from "./column.js"
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversSqliteTable {
+  constructor({driver, row}) {
+    this.driver = driver
+    this.row = row
+  }
+
+  getColumns = async () => {
+    const result = await this.driver.query(`PRAGMA table_info('${this.getName()}')`)
+    const columns = []
+
+    for (const columnData of result) {
+      const column = new Column({column: columnData, driver: this.driver, table: this})
+
+      columns.push(column)
+    }
+
+    return columns
+  }
+
+  getName = () => digg(this, "row", "name")
+}

package/src/database/initializer-from-require-context.js

@@ -0,0 +1,21 @@
+export default class VelociousDatabaseInitializerFromRequireContext {
+  constructor({requireContext, ...restProps}) {
+    const restPropsKeys = Object.keys(restProps)
+
+    if (restPropsKeys.length > 0) throw new Error(`Unknown arguments: ${restPropsKeys.join(", ")}`)
+
+    this.requireContext = requireContext
+  }
+
+  async initialize({configuration}) {
+    for (const fileName of this.requireContext.keys()) {
+      const modelClass = this.requireContext(fileName).default
+
+      await modelClass.initializeRecord({configuration})
+
+      if (await modelClass.hasTranslationsTable()) {
+        await modelClass.getTranslationClass().initializeRecord({configuration})
+      }
+    }
+  }
+}

package/src/database/{migrate-from-require-context.mjs → migrate-from-require-context.js}

@@ -1,4 +1,4 @@
-import Configuration from "../configuration.mjs"
+import Configuration from "../configuration.js"
 import * as inflection from "inflection"
 import Migrator from "./migrator"
 
@@ -14,7 +14,7 @@ export default class VelociousDatabaseMigrateFromRequireContext {
 
     const files = requireContext.keys()
       .map((file) => {
-        const match = file.match(/^\.\/(\d{14})-(.+)\.mjs$/)
+        const match = file.match(/^\.\/(\d{14})-(.+)\.js$/)
 
         if (!match) return null
 

package/src/database/migration/index.js

@@ -0,0 +1,50 @@
+import TableData from "../table-data/index.js"
+
+export default class VelociousDatabaseMigration {
+  constructor({configuration}) {
+    this.configuration = configuration
+  }
+
+  async addIndex(tableName, columns, args) {
+    const databasePool = this.configuration.getDatabasePool()
+    const createIndexArgs = Object.assign(
+      {
+        columns,
+        tableName
+      },
+      args
+    )
+    const sql = databasePool.createIndexSql(createIndexArgs)
+
+    await databasePool.query(sql)
+  }
+
+  async createTable(tableName, callback) {
+    const tableData = new TableData(tableName)
+
+    tableData.integer("id", {null: false, primaryKey: true})
+
+    callback(tableData)
+
+    const databasePool = this.configuration.getDatabasePool()
+    const sqls = databasePool.createTableSql(tableData)
+
+    for (const sql of sqls) {
+      await databasePool.query(sql)
+    }
+  }
+
+  getConnection() {
+    const connection = this.configuration.getDatabasePool().getCurrentConnection()
+
+    if (!connection) throw new Error("Couldn't get current connection")
+
+    return connection
+  }
+
+  async tableExists(tableName) {
+    const exists = await this.getConnection().tableExists(tableName)
+
+    return exists
+  }
+}

package/src/database/{migrator.mjs → migrator.js}

@@ -20,9 +20,11 @@ export default class VelociousDatabaseMigrator {
     schemaMigrationsTable.string("version", {null: false, primaryKey: true})
 
     await this.configuration.getDatabasePool().withConnection(async (db) => {
-      const createSchemaMigrationsTableSql = db.createTableSql(schemaMigrationsTable)
+      const createSchemaMigrationsTableSqls = db.createTableSql(schemaMigrationsTable)
 
-      await db.query(createSchemaMigrationsTableSql)
+      for (const createSchemaMigrationsTableSql of createSchemaMigrationsTableSqls) {
+        await db.query(createSchemaMigrationsTableSql)
+      }
     })
   }
 

package/src/database/pool/{async-tracked-multi-connection.mjs → async-tracked-multi-connection.js}

@@ -1,5 +1,5 @@
 import {AsyncLocalStorage} from "async_hooks"
-import BasePool from "./base.mjs"
+import BasePool from "./base.js"
 
 let idSeq = 0
 

package/src/database/pool/{base.mjs → base.js}

@@ -1,4 +1,4 @@
-import Configuration from "../../configuration.mjs"
+import Configuration from "../../configuration.js"
 import {digg} from "diggerize"
 
 class VelociousDatabasePoolBase {
@@ -35,6 +35,8 @@ class VelociousDatabasePoolBase {
 }
 
 const forwardMethods = [
+  "createIndex",
+  "createIndexSql",
   "createTable",
   "createTableSql",
   "delete",
@@ -52,6 +54,9 @@ const forwardMethods = [
 for (const forwardMethod of forwardMethods) {
   VelociousDatabasePoolBase.prototype[forwardMethod] = function(...args) {
     const connection = this.getCurrentConnection()
+    const connectionMethod = connection[forwardMethod]
+
+    if (!connectionMethod) throw new Error(`${forwardMethod} isn't defined on driver`)
 
     return connection[forwardMethod](...args)
   }

package/src/database/pool/{single-multi-use.mjs → single-multi-use.js}

@@ -1,4 +1,4 @@
-import BasePool from "./base.mjs"
+import BasePool from "./base.js"
 
 export default class VelociousDatabasePoolSingleMultiUser extends BasePool {
   static current() {

package/src/database/query/{base.mjs → base.js}

@@ -3,7 +3,8 @@ export default class VelociousDatabaseQueryBase {
     this.driver = driver
   }
 
-  getOptions = () => this.driver?.options()
+  getDriver = () => this.driver
+  getOptions = () => this.getDriver()?.options()
 
   toSql() {
     throw new Error("'toSql' wasn't implemented")

package/src/database/query/{create-database-base.mjs → create-database-base.js}

@@ -1,5 +1,5 @@
 import {digs} from "diggerize"
-import QueryBase from "./base.mjs"
+import QueryBase from "./base.js"
 
 export default class VelociousDatabaseQueryCreateDatabaseBase extends QueryBase {
   constructor({driver, databaseName, ifNotExists}) {

package/src/database/query/create-index-base.js

@@ -0,0 +1,50 @@
+import {digs} from "diggerize"
+import QueryBase from "./base.js"
+
+export default class VelociousDatabaseQueryCreateIndexBase extends QueryBase {
+  constructor({columns, driver, ifNotExists, name, unique, tableName}) {
+    super({driver})
+    this.columns = columns
+    this.name = name
+    this.tableName = tableName
+    this.ifNotExists = ifNotExists
+    this.unique = unique
+  }
+
+  generateIndexName() {
+    let indexName = `index_on_${this.tableName}_`
+
+    for (const columnIndex in this.columns) {
+      if (columnIndex > 0) indexName += "_"
+
+      indexName += this.columns[columnIndex]
+    }
+
+    return indexName
+  }
+
+  toSql() {
+    const {tableName} = this
+    const {columnQuote, indexQuote, tableQuote} = digs(this.getOptions(), "columnQuote", "indexQuote", "tableQuote")
+    let sql = "CREATE"
+
+    if (this.unique) sql += " UNIQUE"
+
+    sql += " INDEX"
+
+    if (this.ifNotExists) sql += " IF NOT EXISTS"
+
+    sql += ` ${indexQuote}${this.name || this.generateIndexName()}${indexQuote}`
+    sql += ` ON ${tableQuote}${tableName}${tableQuote} (`
+
+    for (const columnIndex in this.columns) {
+      if (columnIndex > 0) sql += ", "
+
+      sql += `${columnQuote}${this.columns[columnIndex]}${columnQuote}`
+    }
+
+    sql += ")"
+
+    return sql
+  }
+}

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

@@ -0,0 +1,92 @@
+import CreateIndexBase from "./create-index-base.js"
+import QueryBase from "./base.js"
+
+export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
+  constructor({driver, ifNotExists, indexInCreateTable = true, tableData}) {
+    super({driver})
+    this.ifNotExists = ifNotExists
+    this.indexInCreateTable = indexInCreateTable
+    this.tableData = tableData
+  }
+
+  toSql() {
+    const {tableData} = this
+    const sqls = []
+
+    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"
+      if (column.args.null === false) sql += " NOT NULL"
+    }
+
+    if (this.indexInCreateTable) {
+      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 += ")"
+
+    sqls.push(sql)
+
+    if (!this.indexInCreateTable) {
+      for (const index of tableData.getIndexes()) {
+        const createIndexArgs = {
+          columns: index.getColumns(),
+          driver: this.getDriver(),
+          tableName: tableData.getName(),
+          unique: index.getUnique()
+        }
+        const sql = new CreateIndexBase(createIndexArgs).toSql()
+
+        sqls.push(sql)
+      }
+    }
+
+    return [sql]
+  }
+}

package/src/database/query/{delete-base.mjs → delete-base.js}

@@ -1,4 +1,4 @@
-import QueryBase from "./base.mjs"
+import QueryBase from "./base.js"
 
 export default class VelociousDatabaseQueryDeleteBase extends QueryBase {
   constructor({conditions, driver, tableName}) {

package/src/database/query/{from-plain.mjs → from-plain.js}

@@ -1,4 +1,4 @@
-import FromBase from "./from-base.mjs"
+import FromBase from "./from-base.js"
 
 export default class VelociousDatabaseQueryFromPlain extends FromBase {
   constructor({driver, plain}) {

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

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