velocious 1.0.4 → 1.0.6

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

@@ -3,6 +3,7 @@ import QueryParserOptions from "../../query-parser/options.mjs"
 export default class VelociousDatabaseDriversMysqlOptions extends QueryParserOptions {
   constructor(options) {
     options.columnQuote = "`"
+    options.indexQuote = "`"
     options.stringQuote = "'"
     options.tableQuote = "`"
 

package/src/database/drivers/mysql/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 VelociousDatabaseConnectionDriversMysqlQueryParser extends BaseQueryParser {
 }

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

@@ -0,0 +1,25 @@
+import Column from "./column.mjs"
+
+export default class VelociousDatabaseDriversMysqlTable {
+  constructor(driver, data) {
+    this.data = data
+    this.driver = driver
+  }
+
+  async getColumns() {
+    const result = await this.driver.query(`SHOW FULL COLUMNS FROM \`${this.getName()}\``)
+    const columns = []
+
+    for (const data of result) {
+      const column = new Column(this, data)
+
+      columns.push(column)
+    }
+
+    return columns
+  }
+
+  getName() {
+    return Object.values(this.data)[0]
+  }
+}

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

@@ -0,0 +1,108 @@
+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, indexInCreateTable: false})
+    const createTable = new CreateTable(createArgs)
+
+    return createTable.toSql()
+  }
+
+  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' ORDER BY name")
+    const tables = []
+
+    for (const row of result) {
+      const table = new Table({driver: this, row})
+
+      tables.push(table)
+    }
+
+    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()
+
+  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,23 +1,31 @@
-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 query from "./query"
 import * as SQLite from "expo-sqlite"
-import Update from "../sqlite/sql/update.mjs"
 
-export default class VelociousDatabaseDriversSqliteNative extends Base{
+import Base from "./base"
+
+export default class VelociousDatabaseDriversSqliteNative extends Base {
   async connect() {
-    const connection = await SQLite.openDatabaseAsync(digg(this.connectArgs(), "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() {
@@ -39,54 +47,5 @@ export default class VelociousDatabaseDriversSqliteNative extends Base{
     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()
-  }
+  query = async (sql) => await query(this.connection, sql)
 }

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

@@ -1,64 +1,55 @@
-import Base from "../base.mjs"
-import CreateTable from "../sqlite/sql/create-table.mjs"
-import Delete from "../sqlite/sql/delete.mjs"
+import BetterLocalStorage from "better-localstorage"
+import debounce from "debounce"
 import {digg} from "diggerize"
-import Insert from "../sqlite/sql/insert.mjs"
-import Options from "../sqlite/options.mjs"
+import initSqlJs from "sql.js"
 import query from "./query"
-import QueryParser from "../sqlite/query-parser.mjs"
-import Update from "../sqlite/sql/update.mjs"
 
-import initSqlJs from "sql.js"
+import Base from "./base.mjs"
 
-export default class VelociousDatabaseDriversSqliteWeb extends Base{
+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
   }
 
-  createTableSql(tableData) {
-    const createArgs = Object.assign({tableData, driver: this})
-    const createTable = new CreateTable(createArgs)
+  query = async (sql) => {
+    const result = await query(this.connection, sql)
+    const downcasedSQL = sql.toLowerCase().trim()
 
-    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})
+    // 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
   }
-
-  updateSql = ({conditions, data, tableName}) => new Update({conditions, data, driver: this, tableName}).toSql()
 }

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

@@ -0,0 +1,24 @@
+import Column from "./column.mjs"
+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.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/migrate-from-require-context.mjs

@@ -1,5 +1,6 @@
 import Configuration from "../configuration.mjs"
 import * as inflection from "inflection"
+import Migrator from "./migrator"
 
 export default class VelociousDatabaseMigrateFromRequireContext {
   constructor(configuration) {
@@ -7,6 +8,10 @@ export default class VelociousDatabaseMigrateFromRequireContext {
   }
 
   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$/)
@@ -27,7 +32,9 @@ export default class VelociousDatabaseMigrateFromRequireContext {
       .sort((migration1, migration2) => migration1.date - migration2.date)
 
     for (const migration of files) {
-      await this.runMigrationFile(migration, requireContext)
+      if (!migrator.hasRunMigrationVersion(migration.date)) {
+        await this.runMigrationFile(migration, requireContext)
+      }
     }
   }
 
@@ -35,7 +42,7 @@ export default class VelociousDatabaseMigrateFromRequireContext {
     if (!this.configuration) throw new Error("No configuration set")
     if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
 
-    await this.configuration.getDatabasePool().withConnection(async () => {
+    await this.configuration.getDatabasePool().withConnection(async (db) => {
       const MigrationClass = requireContext(migration.file).default
       const migrationInstance = new MigrationClass({
         configuration: this.configuration
@@ -48,6 +55,8 @@ export default class VelociousDatabaseMigrateFromRequireContext {
       } 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

@@ -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
   }
 }