velocious 1.0.5 → 1.0.6

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

@@ -1,14 +1,26 @@
+import {digg} from "diggerize"
+
 import Base from "../base.mjs"
+import CreateIndex from "../sqlite/sql/create-index.mjs"
 import CreateTable from "../sqlite/sql/create-table.mjs"
 import Delete from "../sqlite/sql/delete.mjs"
+import escapeString from "sql-string-escape"
 import Insert from "../sqlite/sql/insert.mjs"
+import Options from "../sqlite/options.mjs"
 import QueryParser from "../sqlite/query-parser.mjs"
 import Table from "./table"
 import Update from "../sqlite/sql/update.mjs"
 
 export default class VelociousDatabaseDriversSqliteBase extends Base {
+  createIndexSql(indexData) {
+    const createArgs = Object.assign({driver: this}, indexData)
+    const createIndex = new CreateIndex(createArgs)
+
+    return createIndex.toSql()
+  }
+
   createTableSql(tableData) {
-    const createArgs = Object.assign({tableData, driver: this})
+    const createArgs = Object.assign({tableData, driver: this, indexInCreateTable: false})
     const createTable = new CreateTable(createArgs)
 
     return createTable.toSql()
@@ -17,12 +29,26 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   deleteSql = ({tableName, conditions}) => new Delete({conditions, driver: this, tableName}).toSql()
   insertSql = ({tableName, data}) => new Insert({driver: this, tableName, data}).toSql()
 
+  async getTableByName(tableName) {
+    const result = await this.query(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${this.quote(tableName)} LIMIT 1`)
+    const row = result[0]
+
+    if (!row) {
+      const tables = await this.getTables()
+      const tableNames = tables.map((table) => table.getName())
+
+      throw new Error(`No table by that name: ${tableName} in ${tableNames.join(", ")}`)
+    }
+
+    return new Table({driver: this, row})
+  }
+
   async getTables() {
-    const result = await this.query("SELECT name FROM sqlite_master WHERE type = 'table'")
+    const result = await this.query("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name")
     const tables = []
 
     for (const row of result) {
-      const table = new Table(row)
+      const table = new Table({driver: this, row})
 
       tables.push(table)
     }
@@ -30,7 +56,53 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     return tables
   }
 
+  async lastInsertID() {
+    const result = await this.query("SELECT LAST_INSERT_ROWID() AS last_insert_id")
+
+    return digg(result, 0, "last_insert_id")
+  }
+
+  options() {
+    if (!this._options) {
+      this._options = new Options({driver: this})
+    }
+
+    return this._options
+  }
+
   queryToSql = (query) => new QueryParser({query}).toSql()
-  quoteColumn = (string) => `\`${string}\``
+
+  escape(value) {
+    const type = typeof value
+
+    if (type != "string") value = `${value}`
+
+    const resultWithQuotes = escapeString(value)
+    const result = resultWithQuotes.substring(1, resultWithQuotes.length - 1)
+
+    return result
+  }
+
+  quote(value) {
+    const type = typeof value
+
+    if (type == "number") return value
+    if (type != "string") value = `${value}`
+
+    return escapeString(value)
+  }
+
+  quoteColumn = (string) => {
+    if (string.includes("`")) throw new Error(`Possible SQL injection in column name: ${string}`)
+
+    return `\`${string}\``
+  }
+
+  quoteTable = (string) => {
+    if (string.includes("`")) throw new Error(`Possible SQL injection in table name: ${string}`)
+
+    return `\`${string}\``
+  }
+
   updateSql = ({conditions, data, tableName}) => new Update({conditions, data, driver: this, tableName}).toSql()
 }

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

@@ -0,0 +1,10 @@
+import {digg} from "diggerize"
+
+export default class VelociousDatabaseDriversSqliteColumn {
+  constructor({column, driver}) {
+    this.column = column
+    this.driver = driver
+  }
+
+  getName = () => digg(this, "column", "name")
+}

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

@@ -1,19 +1,31 @@
-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"
 
+import Base from "./base"
+
 export default class VelociousDatabaseDriversSqliteNative extends Base {
   async connect() {
-    const connection = await SQLite.openDatabaseAsync(digg(this.getArgs(), "name"))
+    const args = this.getArgs()
+    const databaseName = digg(args, "name")
+
+    if (args.reset) {
+      try {
+        await SQLite.deleteDatabaseAsync(databaseName)
+      } catch (error) {
+        if (error.message.match(/Database '(.+)' not found/)) {
+          // Ignore not found
+        } else {
+          throw error
+        }
+      }
+    }
 
-    this.connection = connection
+    this.connection = await SQLite.openDatabaseAsync(databaseName)
   }
 
-  disconnect() {
-    this.connection.end()
+  async disconnect() {
+    await this.connection.closeAsync()
   }
 
   connectArgs() {
@@ -36,19 +48,4 @@ export default class VelociousDatabaseDriversSqliteNative extends Base {
   }
 
   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

@@ -1,45 +1,55 @@
-import Base from "./base.mjs"
+import BetterLocalStorage from "better-localstorage"
+import debounce from "debounce"
 import {digg} from "diggerize"
-import Options from "../sqlite/options.mjs"
+import initSqlJs from "sql.js"
 import query from "./query"
 
-import initSqlJs from "sql.js"
+import Base from "./base.mjs"
 
 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 = localStorage.getItem(this.localStorageName())
+    const databaseContent = await this.betterLocaleStorage.get(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())
+  saveDatabase = async () => {
+    const localStorageContent = this.connection.export()
+    await this.betterLocaleStorage.set(this.localStorageName(), localStorageContent)
+  }
+
+  saveDatabaseDebounce = debounce(this.saveDatabase, 500)
 
   async close() {
-    this.saveDatabase()
+    await 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)
-  }
+  query = async (sql) => {
+    const result = await query(this.connection, sql)
+    const downcasedSQL = sql.toLowerCase().trim()
 
-  options() {
-    if (!this._options) {
-      this._options = new Options({driver: this})
+    // 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 this._options
+    return result
   }
 }

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

@@ -1,8 +1,9 @@
 import QueryParserOptions from "../../query-parser/options.mjs"
 
-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.mjs

@@ -1,25 +1,4 @@
-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"
+import BaseQueryParser from "../../query-parser/base-query-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
-  }
+export default class VelociousDatabaseConnectionDriversSqliteQueryParser extends BaseQueryParser {
 }

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

@@ -1,7 +1,22 @@
 export default async function query(connection, sql) {
   const rows = []
+  let result
 
-  for await (const entry of connection.getEachAsync(sql)) {
+  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)
   }
 

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

@@ -1,8 +1,33 @@
 export default async function query(connection, sql) {
   const rows = []
+  let result
 
-  for await (const entry of connection.exec(sql)) {
-    rows.push(entry)
+  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.mjs

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

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

@@ -1,9 +1,24 @@
+import Column from "./column.mjs"
 import {digg} from "diggerize"
 
 export default class VelociousDatabaseDriversSqliteTable {
-  constructor(row) {
+  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.mjs

@@ -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/migration/index.mjs

@@ -5,14 +5,46 @@ export default class VelociousDatabaseMigration {
     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 sql = databasePool.createTableSql(tableData)
+    const sqls = databasePool.createTableSql(tableData)
 
-    await databasePool.query(sql)
+    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

@@ -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/base.mjs

@@ -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/query/base.mjs

@@ -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-index-base.mjs

@@ -0,0 +1,50 @@
+import {digs} from "diggerize"
+import QueryBase from "./base.mjs"
+
+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.mjs

@@ -1,14 +1,18 @@
+import CreateIndexBase from "./create-index-base.mjs"
 import QueryBase from "./base.mjs"
 
 export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
-  constructor({driver, ifNotExists, tableData}) {
+  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"
@@ -36,34 +40,53 @@ export default class VelociousDatabaseQueryCreateTableBase extends QueryBase {
 
       if (column.args.autoIncrement) sql += " AUTO_INCREMENT"
       if (column.args.primaryKey) sql += " PRIMARY KEY"
+      if (column.args.null === false) sql += " NOT NULL"
     }
 
-    for (const index of tableData.getIndexes()) {
-      sql += ","
+    if (this.indexInCreateTable) {
+      for (const index of tableData.getIndexes()) {
+        sql += ","
 
-      if (index.getUnique()) {
-        sql += " UNIQUE"
-      }
+        if (index.getUnique()) {
+          sql += " UNIQUE"
+        }
 
-      sql += " INDEX"
+        sql += " INDEX"
 
-      if (index.getName()) {
-        sql += ` ${index.getName()}`
-      }
+        if (index.getName()) {
+          sql += ` ${index.getName()}`
+        }
 
-      sql += " ("
+        sql += " ("
 
-      index.getColumns().forEach((column, columnIndex) => {
-        if (columnIndex > 0) sql += ", "
+        index.getColumns().forEach((column, columnIndex) => {
+          if (columnIndex > 0) sql += ", "
 
-        sql += this.driver.quoteColumn(column.name)
-      })
+          sql += this.driver.quoteColumn(column.name)
+        })
 
-      sql += ")"
+        sql += ")"
+      }
     }
 
     sql += ")"
 
-    return 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]
   }
 }