velocious 1.0.29 → 1.0.31

package/src/database/drivers/mssql/index.js

@@ -0,0 +1,216 @@
+import Base from "../base.js"
+import CreateDatabase from "./sql/create-database.js"
+import CreateIndex from "./sql/create-index.js"
+import CreateTable from "./sql/create-table.js"
+import Delete from "./sql/delete.js"
+import DropTable from "./sql/drop-table.js"
+import {digg} from "diggerize"
+import escapeString from "sql-escape-string"
+import Insert from "./sql/insert.js"
+import Options from "./options.js"
+import mssql from "mssql"
+import QueryParser from "./query-parser.js"
+import Table from "./table.js"
+import Update from "./sql/update.js"
+import {v4 as uuidv4} from "uuid"
+
+export default class VelociousDatabaseDriversMssql extends Base{
+  async connect() {
+    const args = this.getArgs()
+    const sqlConfig = digg(args, "sqlConfig")
+
+    try {
+      this.connection = await mssql.connect(sqlConfig)
+    } catch (error) {
+      throw new Error(`Couldn't connect to database: ${error.message}`) // Re-throw to fix unuseable stack trace.
+    }
+  }
+
+  disconnect() {
+    this.connection.end()
+  }
+
+  async close() {
+    await this.connection.close()
+    this.connection = undefined
+  }
+
+  createDatabaseSql(databaseName, args) {
+    const createArgs = Object.assign({databaseName, driver: this}, args)
+    const createDatabase = new CreateDatabase(createArgs)
+
+    return createDatabase.toSql()
+  }
+
+  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 createTable = new CreateTable(createArgs)
+
+    return createTable.toSql()
+  }
+
+  async disableForeignKeys() {
+    await this.query("EXEC sp_MSforeachtable \"ALTER TABLE ? NOCHECK CONSTRAINT all\"")
+  }
+
+  async enableForeignKeys() {
+    await this.query("EXEC sp_MSforeachtable @command1=\"print '?'\", @command2=\"ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all\"")
+  }
+
+  dropTableSql(tableName, args = {}) {
+    const dropArgs = Object.assign({tableName, driver: this}, args)
+    const dropTable = new DropTable(dropArgs)
+
+    return dropTable.toSql()
+  }
+
+  getType = () => "mssql"
+  primaryKeyType = () => "bigint"
+
+  async query(sql) {
+    let result, request
+
+    if (this._currentTransaction) {
+      request = new mssql.Request(this._currentTransaction)
+    } else {
+      request = mssql
+    }
+
+    try {
+      result = await request.query(sql)
+    } catch (error) {
+      // Re-throw error because the stack-trace is broken and can't be used for app-development.
+      throw new Error(`Query failed '${error.message})': ${sql}`)
+    }
+
+    return result.recordsets[0]
+  }
+
+  queryToSql(query) {
+    return new QueryParser({query}).toSql()
+  }
+
+  shouldSetAutoIncrementWhenPrimaryKey = () => true
+
+  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) => this.options().quoteColumnName(string)
+  quoteTable = (string) => this.options().quoteTableName(string)
+
+  deleteSql({tableName, conditions}) {
+    const deleteInstruction = new Delete({conditions, driver: this, tableName})
+
+    return deleteInstruction.toSql()
+  }
+
+  insertSql(args) {
+    const insertArgs = Object.assign({driver: this}, args)
+    const insert = new Insert(insertArgs)
+
+    return insert.toSql()
+  }
+
+  async getTables() {
+    const result = await this.query(`SELECT [TABLE_NAME] FROM [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_CATALOG] = DB_NAME() AND [TABLE_SCHEMA] = 'dbo'`)
+    const tables = []
+
+    for (const row of result) {
+      const table = new Table(this, row)
+
+      tables.push(table)
+    }
+
+    return tables
+  }
+
+  async getTableByName(tableName) {
+    const result = await this.query(`SELECT [TABLE_NAME] FROM [INFORMATION_SCHEMA].[TABLES] WHERE [TABLE_CATALOG] = DB_NAME() AND [TABLE_SCHEMA] = 'dbo' AND [TABLE_NAME] = ${this.quote(tableName)}`)
+
+    if (!result[0]) throw new Error(`Couldn't find a table by that name: ${tableName}`)
+
+    return new Table(this, result[0])
+  }
+
+  async lastInsertID() {
+    const result = await this.query("SELECT SCOPE_IDENTITY() AS last_insert_id")
+    const lastInsertID = digg(result, 0, "last_insert_id")
+
+    if (lastInsertID === null) throw new Error("Couldn't get the last inserted ID")
+
+    return lastInsertID
+  }
+
+  options() {
+    if (!this._options) this._options = new Options({driver: this})
+
+    return this._options
+  }
+
+  async startTransaction() {
+    if (this._currentTransaction) throw new Error("A transaction is already running")
+
+    this._currentTransaction = new mssql.Transaction()
+    await this._currentTransaction.begin()
+  }
+
+  async commitTransaction() {
+    if (!this._currentTransaction) throw new Error("A transaction isn't running")
+
+    await this._currentTransaction.commit()
+    this._currentTransaction = null
+  }
+
+  async rollbackTransaction() {
+    if (!this._currentTransaction) throw new Error("A transaction isn't running")
+
+    await this._currentTransaction.rollback()
+    this._currentTransaction = null
+  }
+
+  async startSavePoint(savePointName) {
+    await this.query(`SAVE TRANSACTION [${savePointName}]`)
+  }
+
+  async releaseSavePoint(savePointName) {
+    // Do nothing in MS-SQL.
+  }
+
+  async rollbackSavePoint(savePointName) {
+    await this.query(`ROLLBACK TRANSACTION [${savePointName}]`)
+  }
+
+  generateSavePointName() {
+    return `sp${uuidv4().replaceAll("-", "")}`.substring(0, 32)
+  }
+
+  updateSql({conditions, data, tableName}) {
+    const update = new Update({conditions, data, driver: this, tableName})
+
+    return update.toSql()
+  }
+}

package/src/database/drivers/mssql/options.js

@@ -0,0 +1,43 @@
+import QueryParserOptions from "../../query-parser/options.js"
+
+export default class VelociousDatabaseDriversMssqlOptions extends QueryParserOptions {
+  constructor(options) {
+    options.columnQuote = "\""
+    options.indexQuote = "\""
+    options.stringQuote = "'"
+    options.tableQuote = "\""
+
+    super(options)
+  }
+
+  quote(string) {
+    if (!this.driver) throw new Error("Driver not set")
+
+    return this.driver.quote(string)
+  }
+
+  quoteColumnName = (string) => {
+    if (string.includes("[") || string.includes("]")) throw new Error(`Possible SQL injection in column name: ${string}`)
+
+    return `[${string}]`
+  }
+
+  quoteDatabaseName(databaseName) {
+    if (typeof databaseName != "string") throw new Error(`Invalid database name given: ${databaseName}`)
+    if (databaseName.includes("[") || databaseName.includes("]")) throw new Error(`Possible SQL injection in database name: ${databaseName}`)
+
+    return `[${databaseName}]`
+  }
+
+  quoteIndexName = (string) => {
+    if (string.includes("[") || string.includes("]")) throw new Error(`Possible SQL injection in index name: ${string}`)
+
+    return `[${string}]`
+  }
+
+  quoteTableName = (string) => {
+    if (string.includes("[") || string.includes("]")) throw new Error(`Possible SQL injection in table name: ${string}`)
+
+    return `[${string}]`
+  }
+}

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

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

package/src/database/drivers/mssql/sql/create-database.js

@@ -0,0 +1,28 @@
+import CreateDatabaseBase from "../../../query/create-database-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlCreateDatabase extends CreateDatabaseBase {
+  constructor({driver, databaseName, ifNotExists}) {
+    super({driver})
+    this.databaseName = databaseName
+    this.ifNotExists = ifNotExists
+  }
+
+  toSql() {
+    const {databaseName} = this
+    const options = this.getOptions()
+
+    let sql = ""
+
+    if (this.ifNotExists) {
+      sql += `IF NOT EXISTS(SELECT * FROM [sys].[databases] WHERE [name] = ${options.quote(databaseName)}) BEGIN `
+    }
+
+    sql += `CREATE DATABASE ${options.quoteDatabaseName(databaseName)}`
+
+    if (this.ifNotExists) {
+      sql += " END"
+    }
+
+    return sql
+  }
+}

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

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

package/src/database/drivers/mssql/sql/create-table.js

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

package/src/database/drivers/mssql/sql/delete.js

@@ -0,0 +1,19 @@
+import DeleteBase from "../../../query/delete-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlDelete 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/mssql/sql/drop-table.js

@@ -0,0 +1,4 @@
+import DropTableBase from "../../../query/drop-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlDropTable extends DropTableBase {
+}

package/src/database/drivers/mssql/sql/insert.js

@@ -0,0 +1,4 @@
+import InsertBase from "../../../query/insert-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlInsert extends InsertBase {
+}

package/src/database/drivers/mssql/sql/update.js

@@ -0,0 +1,31 @@
+import UpdateBase from "../../../query/update-base.js"
+
+export default class VelociousDatabaseConnectionDriversMssqlSqlUpdate 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/drivers/mssql/table.js

@@ -0,0 +1,65 @@
+import Column from "./column.js"
+import {digg} from "diggerize"
+import ForeignKey from "./foreign-key.js"
+
+export default class VelociousDatabaseDriversMssqlTable {
+  constructor(driver, data) {
+    this.data = data
+    this.driver = driver
+  }
+
+  async getColumns() {
+    const result = await this.driver.query(`SELECT [COLUMN_NAME] FROM [INFORMATION_SCHEMA].[COLUMNS] WHERE [TABLE_NAME] = ${this.driver.quote(this.getName())}`)
+    const columns = []
+
+    for (const data of result) {
+      const column = new Column(this, data)
+
+      columns.push(column)
+    }
+
+    return columns
+  }
+
+  async getForeignKeys() {
+    const sql = `
+      SELECT
+          fk.name AS ForeignKeyName,
+          tp.name AS ParentTable,
+          ref.name AS ReferencedTable,
+          cp.name AS ParentColumn,
+          cref.name AS ReferencedColumn,
+          tp.name AS TableName
+      FROM sys.foreign_keys fk
+      INNER JOIN sys.foreign_key_columns fkc
+          ON fkc.constraint_object_id = fk.object_id
+      INNER JOIN sys.tables tp
+          ON fkc.parent_object_id = tp.object_id
+      INNER JOIN sys.columns cp
+          ON fkc.parent_object_id = cp.object_id
+          AND fkc.parent_column_id = cp.column_id
+      INNER JOIN sys.tables ref
+          ON fkc.referenced_object_id = ref.object_id
+      INNER JOIN sys.columns cref
+          ON fkc.referenced_object_id = cref.object_id
+          AND fkc.referenced_column_id = cref.column_id
+      WHERE tp.name = ${this.driver.quote(this.getName())}
+      ORDER BY ForeignKeyName, ParentTable, ReferencedTable;
+    `
+
+    const foreignKeyRows = await this.driver.query(sql)
+    const foreignKeys = []
+
+    for (const foreignKeyRow of foreignKeyRows) {
+      const foreignKey = new ForeignKey(foreignKeyRow)
+
+      foreignKeys.push(foreignKey)
+    }
+
+    return foreignKeys
+  }
+
+  getName() {
+    return digg(this.data, "TABLE_NAME")
+  }
+}

package/src/database/drivers/mysql/index.js

@@ -5,6 +5,7 @@ import CreateIndex from "./sql/create-index.js"
 import CreateTable from "./sql/create-table.js"
 import Delete from "./sql/delete.js"
 import {digg} from "diggerize"
+import DropTable from "./sql/drop-table.js"
 import Insert from "./sql/insert.js"
 import Options from "./options.js"
 import mysql from "mysql"
@@ -65,11 +66,31 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return createTable.toSql()
   }
 
+  async disableForeignKeys() {
+    await this.query("SET FOREIGN_KEY_CHECKS = 0")
+  }
+
+  async enableForeignKeys() {
+    await this.query("SET FOREIGN_KEY_CHECKS = 1")
+  }
+
+  dropTableSql(tableName, args = {}) {
+    const dropArgs = Object.assign({tableName, driver: this}, args)
+    const dropTable = new DropTable(dropArgs)
+
+    return dropTable.toSql()
+  }
+
   getType = () => "mysql"
   primaryKeyType = () => "bigint"
 
   async query(sql) {
-    return await query(this.connection, sql)
+    try {
+      return await query(this.connection, sql)
+    } catch (error) {
+      // Re-throw to un-corrupt stacktrace
+      throw new Error(error.message)
+    }
   }
 
   queryToSql(query) {
@@ -78,26 +99,18 @@ export default class VelociousDatabaseDriversMysql extends Base{
 
   shouldSetAutoIncrementWhenPrimaryKey = () => true
 
-  escape(string) {
+  escape(value) {
     if (!this.connection) throw new Error("Can't escape before connected")
 
-    return this.connection.escape(string)
-  }
+    const escapedValueWithQuotes = this.connection.escape(value)
 
-  quote(string) {
-    return `${this.escape(string)}`
+    return escapedValueWithQuotes.slice(1, escapedValueWithQuotes.length - 1)
   }
 
-  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}`)
+  quote(value) {
+    if (!this.connection) throw new Error("Can't escape before connected")
 
-    return `\`${string}\``
+    return this.connection.escape(value)
   }
 
   deleteSql({tableName, conditions}) {
@@ -133,9 +146,7 @@ export default class VelociousDatabaseDriversMysql extends Base{
   }
 
   options() {
-    if (!this._options) {
-      this._options = new Options({driver: this})
-    }
+    if (!this._options) this._options = new Options({driver: this})
 
     return this._options
   }

package/src/database/drivers/mysql/query.js

@@ -2,7 +2,7 @@ export default async function query(connection, sql) {
   return new Promise((resolve, reject) => {
     connection.query(sql, (error, results, fields) => {
       if (error) {
-        reject(error)
+        reject(new Error(`Query failed because of ${error}: ${sql}`))
       } else {
         const rows = []
 

package/src/database/drivers/mysql/sql/drop-table.js

@@ -0,0 +1,4 @@
+import DropTableBase from "../../../query/drop-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversMysqlSqlDropTable extends DropTableBase {
+}

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

@@ -1,16 +1,17 @@
 import {digg} from "diggerize"
 
-import AlterTable from "../sqlite/sql/alter-table.js"
+import AlterTable from "./sql/alter-table.js"
 import Base from "../base.js"
-import CreateIndex from "../sqlite/sql/create-index.js"
-import CreateTable from "../sqlite/sql/create-table.js"
-import Delete from "../sqlite/sql/delete.js"
+import CreateIndex from "./sql/create-index.js"
+import CreateTable from "./sql/create-table.js"
+import Delete from "./sql/delete.js"
+import DropTable from "./sql/drop-table.js"
 import escapeString from "sql-escape-string"
-import Insert from "../sqlite/sql/insert.js"
-import Options from "../sqlite/options.js"
-import QueryParser from "../sqlite/query-parser.js"
+import Insert from "./sql/insert.js"
+import Options from "./options.js"
+import QueryParser from "./query-parser.js"
 import Table from "./table.js"
-import Update from "../sqlite/sql/update.js"
+import Update from "./sql/update.js"
 
 export default class VelociousDatabaseDriversSqliteBase extends Base {
   alterTableSql(columnData) {
@@ -34,6 +35,21 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     return createTable.toSql()
   }
 
+  async disableForeignKeys() {
+    await this.query("PRAGMA foreign_keys = 0")
+  }
+
+  async enableForeignKeys() {
+    await this.query("PRAGMA foreign_keys = 1")
+  }
+
+  dropTableSql(tableName, args = {}) {
+    const dropArgs = Object.assign({tableName, driver: this}, args)
+    const dropTable = new DropTable(dropArgs)
+
+    return dropTable.toSql()
+  }
+
   deleteSql = (args) => new Delete(Object.assign({driver: this}, args)).toSql()
   getType = () => "sqlite"
   insertSql = (args) => new Insert(Object.assign({driver: this}, args)).toSql()
@@ -121,9 +137,7 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
   }
 
   options() {
-    if (!this._options) {
-      this._options = new Options({driver: this})
-    }
+    if (!this._options) this._options = new Options({driver: this})
 
     return this._options
   }
@@ -169,17 +183,5 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     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/index.native.js

@@ -1,4 +1,5 @@
 import {digg} from "diggerize"
+import envSense from "env-sense/src/use-env-sense.js"
 import query from "./query"
 import * as SQLite from "expo-sqlite"
 
@@ -6,6 +7,10 @@ import Base from "./base"
 
 export default class VelociousDatabaseDriversSqliteNative extends Base {
   async connect() {
+    const {isBrowser, isNative, isServer} = envSense()
+
+    if (!isNative) throw new Error(`SQLite native driver running inside non-native environment: ${JSON.stringify({isBrowser, isNative, isServer})}`)
+
     const args = this.getArgs()
 
     if (!args.name) throw new Error("No name given for SQLite Native")
@@ -51,5 +56,9 @@ export default class VelociousDatabaseDriversSqliteNative extends Base {
     this.connection = undefined
   }
 
-  query = async (sql) => await query(this.connection, sql)
+  query = async (sql) => {
+    if (!this.connection) throw new Error("Not connected yet")
+
+    return await query(this.connection, sql)
+  }
 }

package/src/database/drivers/sqlite/sql/drop-table.js

@@ -0,0 +1,4 @@
+import DropTableBase from "../../../query/drop-table-base.js"
+
+export default class VelociousDatabaseConnectionDriversSqliteSqlDropTable extends DropTableBase {
+}

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

@@ -18,7 +18,9 @@ export default class VelociousDatabaseInitializerFromRequireContext {
       await modelClass.initializeRecord({configuration})
 
       if (await modelClass.hasTranslationsTable()) {
-        await modelClass.getTranslationClass().initializeRecord({configuration})
+        const translationClass = modelClass.getTranslationClass()
+
+        await translationClass.initializeRecord({configuration})
       }
     }
   }