velocious 1.0.77 → 1.0.79

package/package.json

@@ -3,7 +3,7 @@
     "velocious": "bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.77",
+  "version": "1.0.79",
   "main": "index.js",
   "scripts": {
     "test": "VELOCIOUS_TEST_DIR=../ cd spec/dummy && npx velocious test",

package/src/database/query/index.js

@@ -9,12 +9,15 @@ 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"
+import restArgsError from "../../utils/rest-args-error.js"
 
 export default class VelociousDatabaseQuery {
-  constructor({driver, froms = [], groups = [], joins = [], handler, limits = [], modelClass, orders = [], preload = {}, selects = [], wheres = []}) {
+  constructor({driver, froms = [], groups = [], joins = [], handler, limit = null, modelClass, offset = null, orders = [], page = null, perPage, preload = {}, selects = [], wheres = [], ...restArgs}) {
     if (!driver) throw new Error("No driver given to query")
     if (!handler) throw new Error("No handler given to query")
 
+    restArgsError(restArgs)
+
     this.driver = driver
     this.handler = handler
     this.logger = new Logger(this)
@@ -22,8 +25,11 @@ export default class VelociousDatabaseQuery {
     this._froms = froms
     this._groups = groups
     this._joins = joins
-    this._limits = limits
+    this._limit = limit
+    this._offset = offset
     this._orders = orders
+    this._page = page
+    this._perPage = perPage
     this._preload = preload
     this._selects = selects
     this._wheres = wheres
@@ -36,9 +42,12 @@ export default class VelociousDatabaseQuery {
       handler: this.handler.clone(),
       groups: [...this._groups],
       joins: [...this._joins],
-      limits: [...this._limits],
+      limit: this._limit,
       modelClass: this.modelClass,
+      offset: this._offset,
       orders: [...this._orders],
+      page: this._page,
+      perPage: this._perPage,
       preload: {...this._preload},
       selects: [...this._selects],
       wheres: [...this._wheres]
@@ -64,11 +73,25 @@ export default class VelociousDatabaseQuery {
 
     const results = await countQuery._executeQuery()
 
+
+    // The query isn't grouped and a single result has been given
     if (results.length == 1) {
       return results[0].count
     }
 
-    throw new Error("count multiple stub")
+
+    // The query may be grouped and a lot of different counts a given
+    let countResult = 0
+
+    for (const result of results) {
+      if (!("count" in result)) {
+        throw new Error("Invalid count result")
+      }
+
+      countResult += result.count
+    }
+
+    return countResult
   }
 
   getOptions() { return this.driver.options() }
@@ -193,7 +216,12 @@ export default class VelociousDatabaseQuery {
   }
 
   limit(value) {
-    this._limits.push(value)
+    this._limit = value
+    return this
+  }
+
+  offset(value) {
+    this._offset = value
     return this
   }
 
@@ -206,6 +234,22 @@ export default class VelociousDatabaseQuery {
     return this
   }
 
+  page(pageNumber) {
+    const perPage = this._perPage || 30
+    const offset = (pageNumber - 1) * perPage
+    const limit = perPage
+
+    this._page = pageNumber
+    this.limit(limit)
+    this.offset(offset)
+    return this
+  }
+
+  perPage(perPage) {
+    this._perPage = perPage
+    return this
+  }
+
   preload(data) {
     incorporate(this._preload, data)
     return this

package/src/database/query/preloader/has-many.js

@@ -15,6 +15,10 @@ export default class VelociousDatabaseQueryPreloaderHasMany {
     const primaryKey = this.relationship.getPrimaryKey()
     const preloadCollections = {}
 
+    if (!primaryKey) {
+      throw new Error(`${this.relationship.getModelClass().name}#${this.relationship.getRelationshipName()} doesn't have a primary key`)
+    }
+
     for (const model of this.models) {
       const primaryKeyValue = model.readColumn(primaryKey)
 

package/src/database/query-parser/limit-parser.js

@@ -9,10 +9,10 @@ export default class VelocuiousDatabaseQueryParserLimitParser {
   toSql() {
     const {pretty, query} = digs(this, "pretty", "query")
     const driver = query.driver
+    const options = this.query.getOptions()
     let sql = ""
 
-    if (query._limits.length == 0) return sql
-    if (query._limits.length >= 2) throw new Error(`Multiple limits found: ${query._limits.join(", ")}`)
+    if (query._limit === null) return sql
 
     if (pretty) {
       sql += "\n\n"
@@ -26,21 +26,28 @@ export default class VelocuiousDatabaseQueryParserLimitParser {
       sql += "LIMIT"
     }
 
-    for (const limitKey in query._limits) {
-      const limit = query._limits[limitKey]
+    const limit = query._limit
+    const offset = query._offset
 
-      if (limitKey > 0) sql += ","
+    if (pretty) {
+      sql += "\n  "
+    } else {
+      sql += " "
+    }
 
-      if (pretty) {
-        sql += "\n  "
-      } else {
-        sql += " "
-      }
+    if (driver.getType() == "mssql") {
+      sql += `OFFSET ${options.quote(offset === null ? 0 : offset)} ROWS FETCH FIRST ${options.quote(limit)} ROWS ONLY`
+    } else {
+      sql += options.quote(limit)
+
+      if (offset !== null) {
+        if (pretty) {
+          sql += "\n  "
+        } else {
+          sql += " "
+        }
 
-      if (driver.getType() == "mssql") {
-        sql += `OFFSET 0 ROWS FETCH FIRST ${this.query.getOptions().quote(limit)} ROWS ONLY`
-      } else {
-        sql += this.query.getOptions().quote(limit)
+        sql += `OFFSET ${options.quote(offset)}`
       }
     }
 

package/src/database/record/index.js

@@ -290,15 +290,7 @@ class VelociousDatabaseRecord {
       this.prototype[`has${camelizedColumnNameBigFirst}`] = function() {
         let value = this[camelizedColumnName]()
 
-        if (typeof value == "string") {
-          value = value.trim()
-        }
-
-        if (value) {
-          return true
-        }
-
-        return false
+        return this._hasAttribute(value)
       }
     }
 
@@ -306,6 +298,18 @@ class VelociousDatabaseRecord {
     this._initialized = true
   }
 
+  _hasAttribute(value) {
+    if (typeof value == "string") {
+      value = value.trim()
+    }
+
+    if (value) {
+      return true
+    }
+
+    return false
+  }
+
   static isInitialized() {
     if (this._initialized) return true
 
@@ -324,13 +328,19 @@ class VelociousDatabaseRecord {
         const nameCamelized = inflection.camelize(name)
         const setterMethodName = `set${nameCamelized}`
 
-        this.prototype[name] = function() {
+        this.prototype[name] = function getTranslatedAttribute() {
           const locale = this._getConfiguration().getLocale()
 
           return this._getTranslatedAttributeWithFallback(name, locale)
         }
 
-        this.prototype[setterMethodName] = function(newValue) {
+        this.prototype[`has${nameCamelized}`] = function hasTranslatedAttribute() {
+          const value = this[name]()
+
+          return this._hasAttribute(value)
+        }
+
+        this.prototype[setterMethodName] = function setTranslatedAttribute(newValue) {
           const locale = this._getConfiguration().getLocale()
 
           return this._setTranslatedAttribute(name, locale, newValue)
@@ -341,11 +351,11 @@ class VelociousDatabaseRecord {
           const getterMethodNameLocalized = `${name}${localeCamelized}`
           const setterMethodNameLocalized = `${setterMethodName}${localeCamelized}`
 
-          this.prototype[getterMethodNameLocalized] = function() {
+          this.prototype[getterMethodNameLocalized] = function getTranslatedAttributeWithLocale() {
             return this._getTranslatedAttribute(name, locale)
           }
 
-          this.prototype[setterMethodNameLocalized] = function(newValue) {
+          this.prototype[setterMethodNameLocalized] = function setTranslatedAttributeWithLocale(newValue) {
             return this._setTranslatedAttribute(name, locale, newValue)
           }
         }
@@ -930,7 +940,7 @@ class VelociousDatabaseRecord {
     }
 
     if (column && this.constructor.getDatabaseType() == "sqlite") {
-      if (column.getType() == "date" || column.getType() == "datetime") {
+      if (result && (column.getType() == "date" || column.getType() == "datetime")) {
         result = new Date(Date.parse(result))
       }
     }

package/src/database/record/relationships/base.js

@@ -21,6 +21,7 @@ export default class VelociousDatabaseRecordBaseRelationship {
   }
 
   getDependent() { return this._dependent }
+  getModelClass() { return this.modelClass }
   getRelationshipName() { return this.relationshipName }
   getPrimaryKey() { return this._primaryKey }
   getType() { return this.type }