velocious 1.0.9 → 1.0.11

package/package.json

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

package/spec/database/record/translation-fallbacks-spec.js

@@ -0,0 +1,24 @@
+import Dummy from "../../dummy/index.js"
+import Task from "../../dummy/src/models/task.js"
+
+describe("Record - create", () => {
+  it("creates a new simple record", async () => {
+    await Dummy.run(async () => {
+      const task = new Task({name: "Test task"})
+      const project = task.buildProject({nameDe: "Test projekt"})
+
+      expect(project.name()).toEqual("Test projekt")
+      expect(project.nameEn()).toEqual(undefined)
+      expect(project.nameDe()).toEqual("Test projekt")
+
+      await task.save()
+
+      const sameTask = await Task.preload({project: {translations: true}}).find(task.id())
+      const sameProject = sameTask.project()
+
+      expect(sameProject.name()).toEqual("Test projekt")
+      expect(sameProject.nameEn()).toEqual(undefined)
+      expect(sameProject.nameDe()).toEqual("Test projekt")
+    })
+  })
+})

package/spec/dummy/src/config/configuration.example.js

@@ -32,5 +32,9 @@ export default new Configuration({
     })
   },
   locale: () => "en",
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
+  },
   locales: ["de", "en"]
 })

package/spec/dummy/src/config/configuration.peakflow.js

@@ -33,5 +33,9 @@ export default new Configuration({
     })
   },
   locale: () => "en",
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
+  },
   locales: ["de", "en"]
 })

package/src/configuration.js

@@ -8,7 +8,7 @@ export default class VelociousConfiguration {
     return this.velociousConfiguration
   }
 
-  constructor({database, debug, directory, initializeModels, locale, locales, ...restArgs}) {
+  constructor({database, debug, directory, initializeModels, locale, localeFallbacks, locales, ...restArgs}) {
     restArgsError(restArgs)
 
     if (!initializeModels) throw new Error("initializeModels wasn't given")
@@ -19,6 +19,7 @@ export default class VelociousConfiguration {
     this._initializeModels = initializeModels
     this._isInitialized = false
     this.locale = locale
+    this.localeFallbacks = localeFallbacks
     this.locales = locales
     this.modelClasses = {}
   }
@@ -31,7 +32,7 @@ export default class VelociousConfiguration {
     return this.databasePool
   }
 
-  getDatabasePoolType = () => {
+  getDatabasePoolType() {
     const poolTypeClass = digg(this, "database", "default", "master", "poolType")
 
     if (!poolTypeClass) {
@@ -41,7 +42,7 @@ export default class VelociousConfiguration {
     return poolTypeClass
   }
 
-  getDirectory = () => {
+  getDirectory() {
     if (!this._directory) {
       this._directory = process.cwd()
     }
@@ -49,6 +50,11 @@ export default class VelociousConfiguration {
     return this._directory
   }
 
+  getLocaleFallbacks = () => this.localeFallbacks
+  setLocaleFallbacks(newLocaleFallbacks) {
+    this.localeFallbacks = newLocaleFallbacks
+  }
+
   getLocale() {
     if (typeof this.locale == "function") {
       return this.locale()

package/src/database/drivers/base.js

@@ -78,6 +78,22 @@ export default class VelociousDatabaseDriversBase {
     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/query/index.js

@@ -4,6 +4,7 @@ import * as inflection from "inflection"
 import JoinPlain from "./join-plain.js"
 import OrderPlain from "./order-plain.js"
 import Preloader from "./preloader.js"
+import RecordNotFoundError from "../record/record-not-found-error.js"
 import SelectPlain from "./select-plain.js"
 import WhereHash from "./where-hash.js"
 import WherePlain from "./where-plain.js"
@@ -46,6 +47,21 @@ export default class VelociousDatabaseQuery {
 
   getOptions = () => this.driver.options()
 
+  async find(recordId) {
+    const conditions = {}
+
+    conditions[this.modelClass.primaryKey()] = recordId
+
+    const query = this.clone().where(conditions)
+    const record = await query.first()
+
+    if (!record) {
+      throw new RecordNotFoundError(`Couldn't find ${this.modelClass.name} with '${this.modelClass.primaryKey()}'=${recordId}`)
+    }
+
+    return record
+  }
+
   async findBy(conditions) {
     const newConditions = {}
 

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

@@ -7,7 +7,6 @@ import HasManyRelationship from "./relationships/has-many.js"
 import HasManyInstanceRelationship from "./instance-relationships/has-many.js"
 import * as inflection from "inflection"
 import Query from "../query/index.js"
-import RecordNotFoundError from "./record-not-found-error.js"
 
 export default class VelociousDatabaseRecord {
   static _relationshipExists(relationshipName) {
@@ -19,6 +18,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`)
 
@@ -124,21 +124,6 @@ export default class VelociousDatabaseRecord {
     return record
   }
 
-  static async find(recordId) {
-    const conditions = {}
-
-    conditions[this.primaryKey()] = recordId
-
-    const query = this.where(conditions)
-    const record = await query.first()
-
-    if (!record) {
-      throw new RecordNotFoundError(`Couldn't find ${this.name} with '${this.primaryKey()}'=${recordId}`)
-    }
-
-    return record
-  }
-
   static _getConfiguration() {
     if (!this._configuration) {
       this._configuration = Configuration.current()
@@ -210,7 +195,7 @@ export default class VelociousDatabaseRecord {
         this.prototype[name] = function () {
           const locale = this._getConfiguration().getLocale()
 
-          return this._getTranslatedAttribute(name, locale)
+          return this._getTranslatedAttributeWithFallback(name, locale)
         }
 
         this.prototype[setterMethodName] = function (newValue) {
@@ -275,6 +260,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()
@@ -414,10 +403,31 @@ export default class VelociousDatabaseRecord {
     }
   }
 
+  _getTranslatedAttributeWithFallback(name, locale) {
+    let localesInOrder
+    const fallbacks = this._getConfiguration().getLocaleFallbacks()
+
+    if (fallbacks && locale in fallbacks) {
+      localesInOrder = fallbacks[locale]
+    } else {
+      localesInOrder = [locale]
+    }
+
+    for (const fallbackLocale of localesInOrder) {
+      const result = this._getTranslatedAttribute(name, fallbackLocale)
+
+      if (result && result.trim() != "") {
+        return result
+      }
+    }
+  }
+
   _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 = {}
 
@@ -447,6 +457,10 @@ export default class VelociousDatabaseRecord {
     return this._newQuery()
   }
 
+  static async find(...args) {
+    return this._newQuery().find(...args)
+  }
+
   static async findBy(...args) {
     return this._newQuery().findBy(...args)
   }
@@ -519,7 +533,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
     }
 
@@ -543,6 +557,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
 

package/src/templates/configuration.js

@@ -15,5 +15,9 @@ export default new Configuration({
         database: "database"
       }
     }
+  },
+  localeFallbacks: {
+    de: ["de", "en"],
+    en: ["en", "de"]
   }
 })