velocious 1.0.8 → 1.0.10

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "main": "index.js",
   "scripts": {
     "test": "jasmine",

package/src/database/drivers/base.js

@@ -69,6 +69,31 @@ export default class VelociousDatabaseDriversBase {
     this.idSeq = id
   }
 
+  async tableExists(tableName) {
+    const tables = await this.getTables()
+    const table = tables.find((table) => table.getName() == tableName)
+
+    if (table) return true
+
+    return false
+  }
+
+  async transaction(callback) {
+    await this.query("BEGIN TRANSACTION")
+
+    let result
+
+    try {
+      result = await callback()
+      await this.query("COMMIT")
+    } catch (error) {
+      this.query("ROLLBACK")
+      throw error
+    }
+
+    return result
+  }
+
   async update(...args) {
     const sql = this.updateSql(...args)
 

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

@@ -93,8 +93,9 @@ export default class VelociousDatabaseDriversMysql extends Base{
     return deleteInstruction.toSql()
   }
 
-  insertSql({tableName, data}) {
-    const insert = new Insert({driver: this, tableName, data})
+  insertSql(args) {
+    const insertArgs = Object.assign({driver: this}, args)
+    const insert = new Insert(insertArgs)
 
     return insert.toSql()
   }

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

@@ -1,29 +1,4 @@
 import InsertBase from "../../../query/insert-base.js"
 
 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/base.js

@@ -34,8 +34,8 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     return createTable.toSql()
   }
 
-  deleteSql = ({tableName, conditions}) => new Delete({conditions, driver: this, tableName}).toSql()
-  insertSql = ({tableName, data}) => new Insert({driver: this, tableName, data}).toSql()
+  deleteSql = (args) => new Delete(Object.assign({driver: this}, args)).toSql()
+  insertSql = (args) => new Insert(Object.assign({driver: this}, args)).toSql()
 
   async getTableByName(tableName) {
     const result = await this.query(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${this.quote(tableName)} LIMIT 1`)
@@ -64,6 +64,53 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
     return tables
   }
 
+  async insertMultiple(...args) {
+    if (this.supportsMultipleInsertValues()) {
+      return await this.insertMultipleWithSingleInsert(...args)
+    } else {
+      return await this.insertMultipleWithTransaction(...args)
+    }
+  }
+
+  supportsMultipleInsertValues() {
+    if (this.versionMajor >= 4) return true
+    if (this.versionMajor == 3 && this.versionMinor >= 8) return true
+    if (this.versionMajor == 3 && this.versionMinor == 7 && this.versionPatch >= 11) return true
+
+    return false
+  }
+
+  async insertMultipleWithSingleInsert(tableName, columns, rows) {
+    const sql = new Insert({columns, driver: this, rows, tableName}).toSql()
+
+    return await this.query(sql)
+  }
+
+  async insertMultipleWithTransaction(tableName, columns, rows) {
+    const sqls = []
+
+    for (const row of rows) {
+      const data = []
+
+      for (const columnIndex in columns) {
+        const columnName = columns[columnIndex]
+        const value = row[columnIndex]
+
+        data[columnName] = value
+      }
+
+      const insertSql = this.insertSql({tableName, data})
+
+      sqls.push(insertSql)
+    }
+
+    await this.transaction(async () => {
+      for (const sql of sqls) {
+        await this.query(sql)
+      }
+    })
+  }
+
   async lastInsertID() {
     const result = await this.query("SELECT LAST_INSERT_ROWID() AS last_insert_id")
 
@@ -80,6 +127,18 @@ export default class VelociousDatabaseDriversSqliteBase extends Base {
 
   queryToSql = (query) => new QueryParser({query}).toSql()
 
+  async registerVersion() {
+    const versionResult = await this.query("SELECT sqlite_version() AS version")
+
+    this.version = versionResult[0].version
+
+    const versionParts = this.version.split(".")
+
+    this.versionMajor = versionParts[0]
+    this.versionMinor = versionParts[1]
+    this.versionPatch = versionParts[2]
+  }
+
   escape(value) {
     const type = typeof value
 

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

@@ -22,6 +22,7 @@ export default class VelociousDatabaseDriversSqliteNative extends Base {
     }
 
     this.connection = await SQLite.openDatabaseAsync(databaseName)
+    await this.registerVersion()
   }
 
   async disconnect() {

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

@@ -24,6 +24,7 @@ export default class VelociousDatabaseDriversSqliteWeb extends Base {
     const databaseContent = await this.betterLocaleStorage.get(this.localStorageName())
 
     this.connection = new SQL.Database(databaseContent)
+    await this.registerVersion()
   }
 
   localStorageName = () => `VelociousDatabaseDriversSqliteWeb---${digg(this.getArgs(), "name")}`

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

@@ -1,29 +1,4 @@
 import InsertBase from "../../../query/insert-base.js"
 
 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/migrate-from-require-context.js

@@ -5,12 +5,11 @@ import Migrator from "./migrator"
 export default class VelociousDatabaseMigrateFromRequireContext {
   constructor(configuration) {
     this.configuration = configuration || Configuration.current()
+    this.migrator = new Migrator({configuration: this.configuration})
   }
 
   async execute(requireContext) {
-    const migrator = new Migrator({configuration: this.configuration})
-
-    await migrator.prepare()
+    await this.migrator.prepare()
 
     const files = requireContext.keys()
       .map((file) => {
@@ -32,7 +31,7 @@ export default class VelociousDatabaseMigrateFromRequireContext {
       .sort((migration1, migration2) => migration1.date - migration2.date)
 
     for (const migration of files) {
-      if (!migrator.hasRunMigrationVersion(migration.date)) {
+      if (!this.migrator.hasRunMigrationVersion(migration.date)) {
         await this.runMigrationFile(migration, requireContext)
       }
     }

package/src/database/query/insert-base.js

@@ -1,11 +1,17 @@
+import restArgsError from "../../utils/rest-args-error.js"
+
 export default class VelociousDatabaseQueryInsertBase {
-  constructor({driver, tableName, data}) {
+  constructor({columns, data, driver, multiple, tableName, rows, ...restArgs}) {
     if (!driver) throw new Error("No driver given to insert base")
     if (!tableName) throw new Error(`Invalid table name given to insert base: ${tableName}`)
-    if (!data) throw new Error("No data given to insert base")
 
+    restArgsError(restArgs)
+
+    this.columns = columns
     this.data = data
     this.driver = driver
+    this.multiple = multiple
+    this.rows = rows
     this.tableName = tableName
   }
 
@@ -14,6 +20,56 @@ export default class VelociousDatabaseQueryInsertBase {
   }
 
   toSql() {
-    throw new Error("'toSql' wasn't implemented")
+    let sql = `INSERT INTO ${this.getOptions().quoteTableName(this.tableName)} (`
+    let count = 0
+    let columns
+
+    if (this.columns && this.rows) {
+      columns = this.columns
+    } else if (this.data) {
+      columns = Object.keys(this.data)
+    } else {
+      throw new Error("Neither 'column' and 'rows' or data was given")
+    }
+
+    for (const columnName of columns) {
+      if (count > 0) sql += ", "
+
+      sql += this.getOptions().quoteColumnName(columnName)
+      count++
+    }
+
+    sql += ") VALUES "
+
+    if (this.columns && this.rows) {
+      let count = 0
+
+      for (const row of this.rows) {
+        if (count >= 1) sql += ", "
+
+        count++
+        sql += this._valuesSql(row)
+      }
+    } else {
+      sql += this._valuesSql(Object.values(this.data))
+    }
+
+    return sql
+  }
+
+  _valuesSql(data) {
+    let count = 0
+    let sql = "("
+
+    for (const value of data) {
+      if (count > 0) sql += ", "
+
+      sql += this.getOptions().quote(value)
+      count++
+    }
+
+    sql += ")"
+
+    return sql
   }
 }

package/src/database/record/index.js

@@ -19,6 +19,7 @@ export default class VelociousDatabaseRecord {
   }
 
   static _defineRelationship(relationshipName, data) {
+    if (!relationshipName) throw new Error(`Invalid relationship name given: ${relationshipName}`)
     if (!this._relationships) this._relationships = {}
     if (this._relationshipExists(relationshipName)) throw new Error(`Relationship ${relationshipName} already exists`)
 
@@ -77,6 +78,12 @@ export default class VelociousDatabaseRecord {
     return relationship
   }
 
+  static getRelationships() {
+    if (this._relationships) return Object.values(this._relationships)
+
+    return []
+  }
+
   getRelationshipByName(relationshipName) {
     if (!this._instanceRelationships) this._instanceRelationships = {}
 
@@ -269,6 +276,10 @@ export default class VelociousDatabaseRecord {
     return this._table
   }
 
+  static async insertMultiple(columns, rows) {
+    return await this.connection().insertMultiple(this.tableName(), columns, rows)
+  }
+
   static async last() {
     const query = this._newQuery().order(this.primaryKey())
     const record = await query.last()
@@ -308,7 +319,7 @@ export default class VelociousDatabaseRecord {
 
       const model = instanceRelationship.loaded()
 
-      if (model.isChanged()) {
+      if (model?.isChanged()) {
         await model.save()
 
         const foreignKey = instanceRelationship.getForeignKey()
@@ -409,9 +420,11 @@ export default class VelociousDatabaseRecord {
   }
 
   _setTranslatedAttribute(name, locale, newValue) {
-    let translation = this.translations().loaded()?.find((translation) =>translation.locale() == locale)
+    let translation = this.translations().loaded()?.find((translation) => translation.locale() == locale)
 
-    if (!translation) translation = this.translations().build({locale})
+    if (!translation) {
+      translation = this.translations().build({locale})
+    }
 
     const assignments = {}
 
@@ -513,7 +526,7 @@ export default class VelociousDatabaseRecord {
   _hasChanges = () => Object.keys(this._changes).length > 0
 
   isChanged() {
-    if (this.isNewRecord() || this._hasChanges()) {
+    if (this.isNewRecord() || this._hasChanges()){
       return true
     }
 
@@ -537,6 +550,18 @@ export default class VelociousDatabaseRecord {
     return false
   }
 
+  changes() {
+    const changes = {}
+
+    for (const changeKey in this._changes) {
+      const changeValue = this._changes[changeKey]
+
+      changes[changeKey] = [this._attributes[changeKey], changeValue]
+    }
+
+    return changes
+  }
+
   _tableName() {
     if (this.__tableName) return this.__tableName
 
@@ -569,6 +594,13 @@ export default class VelociousDatabaseRecord {
 
     await this._reloadWithId(id)
     this.setIsNewRecord(false)
+
+    // Mark all relationships as preloaded, since we don't expect anything to have magically appeared since we created the record.
+    for (const relationship of this.constructor.getRelationships()) {
+      const instanceRelationship = this.getRelationshipByName(relationship.getRelationshipName())
+
+      instanceRelationship.setPreloaded(true)
+    }
   }
 
   async _updateRecordWithChanges() {

package/src/database/record/instance-relationships/has-many.js

@@ -39,9 +39,5 @@ export default class VelociousDatabaseRecordHasManyInstanceRelationship extends
     this._loaded = models
   }
 
-  setPreloaded(preloadedValue) {
-    this._preloaded = preloadedValue
-  }
-
   getTargetModelClass = () => this.relationship.getTargetModelClass()
 }