velocious 1.0.5 → 1.0.6

package/src/database/query/index.mjs

@@ -1,20 +1,27 @@
 import FromPlain from "./from-plain.mjs"
+import {incorporate} from "incorporator"
+import * as inflection from "inflection"
 import JoinPlain from "./join-plain.mjs"
 import OrderPlain from "./order-plain.mjs"
+import Preloader from "./preloader.mjs"
 import SelectPlain from "./select-plain.mjs"
+import WhereHash from "./where-hash.mjs"
+import WherePlain from "./where-plain.mjs"
 
 export default class VelociousDatabaseQuery {
-  constructor({driver, froms = [], joins = [], handler, limits = [], modelClass, orders = [], selects = [], wheres = []}) {
-    if (!driver) throw new Error("No driver given")
-    if (!handler) throw new Error("No handler given")
+  constructor({driver, froms = [], groups = [], joins = [], handler, limits = [], modelClass, orders = [], preload = {}, selects = [], wheres = []}) {
+    if (!driver) throw new Error("No driver given to query")
+    if (!handler) throw new Error("No handler given to query")
 
     this.driver = driver
     this.handler = handler
     this.modelClass = modelClass
     this._froms = froms
+    this._groups = groups
     this._joins = joins
     this._limits = limits
     this._orders = orders
+    this._preload = preload
     this._selects = selects
     this._wheres = wheres
   }
@@ -24,10 +31,12 @@ export default class VelociousDatabaseQuery {
       driver: this.driver,
       froms: [...this._froms],
       handler: this.handler.clone(),
+      groups: [...this._groups],
       joins: [...this._joins],
       limits: [...this._limits],
       modelClass: this.modelClass,
       orders: [...this._orders],
+      preload: {...this._preload},
       selects: [...this._selects],
       wheres: [...this._wheres]
     })
@@ -35,8 +44,38 @@ export default class VelociousDatabaseQuery {
     return newQuery
   }
 
-  getOptions() {
-    return this.driver.options()
+  getOptions = () => this.driver.options()
+
+  async findBy(conditions) {
+    const newConditions = {}
+
+    for (const key in conditions) {
+      const keyUnderscore = inflection.underscore(key)
+
+      newConditions[keyUnderscore] = conditions[key]
+    }
+
+    return await this.clone().where(newConditions).first()
+  }
+
+  async findOrCreateBy(conditions) {
+    const record = await this.findOrInitializeBy(conditions)
+
+    if (record.isNewRecord()) {
+      await record.save()
+    }
+
+    return record
+  }
+
+  async findOrInitializeBy(conditions) {
+    const record = await this.findBy(conditions)
+
+    if (record) return record
+
+    const newRecord = new this.modelClass(conditions)
+
+    return newRecord
   }
 
   async first() {
@@ -55,24 +94,31 @@ export default class VelociousDatabaseQuery {
     return this
   }
 
-  async last() {
-    return await this.clone().reverseOrder().first()
-  }
-
-  limit(value) {
-    this._limits.push(value)
+  group(group) {
+    this._groups.push(group)
     return this
   }
 
   joins(join) {
-    if (typeof join == "string") join = new JoinPlain({plain: join, query: this})
-
-    join.query = this
+    if (typeof join == "string") {
+      join = new JoinPlain({plain: join, query: this})
+    } else if (typeof join == "object") {
+      // Do nothing
+    } else {
+      throw new Error(`Unknown type of join: ${typeof join}`)
+    }
 
     this._joins.push(join)
     return this
   }
 
+  last = async () => await this.clone().reverseOrder().first()
+
+  limit(value) {
+    this._limits.push(value)
+    return this
+  }
+
   order(order) {
     if (typeof order == "number" || typeof order == "string") order = new OrderPlain({plain: order, query: this})
 
@@ -82,6 +128,11 @@ export default class VelociousDatabaseQuery {
     return this
   }
 
+  preload(data) {
+    incorporate(this._preload, data)
+    return this
+  }
+
   reorder(order) {
     this._orders = []
     this.order(order)
@@ -119,23 +170,34 @@ export default class VelociousDatabaseQuery {
     const models = []
 
     for (const result of results) {
-      const model = new this.modelClass(result)
+      const model = new this.modelClass()
 
+      model.loadExistingRecord(result)
       models.push(model)
     }
 
+    if (Object.keys(this._preload).length > 0 && models.length > 0) {
+      const preloader = new Preloader({
+        modelClass: this.modelClass,
+        models,
+        preload: this._preload
+      })
+
+      await preloader.run()
+    }
+
     return models
   }
 
-  toSql() {
-    return this.driver.queryToSql(this)
-  }
+  toSql = () => this.driver.queryToSql(this)
 
   where(where) {
     if (typeof where == "string") {
-      where = new WherePlain({plain: where})
-    } else if (typeof where == "object" && where.constructor.name == "object") {
-      where = new WhereHash({hash: where})
+      where = new WherePlain(this, where)
+    } else if (typeof where == "object" && (where.constructor.name == "object" || where.constructor.name == "Object")) {
+      where = new WhereHash(this, where)
+    } else {
+      throw new Error(`Invalid type of where: ${typeof where} (${where.constructor.name})`)
     }
 
     this._wheres.push(where)

package/src/database/query/preloader/belongs-to.mjs

@@ -0,0 +1,52 @@
+import * as inflection from "inflection"
+import restArgsError from "../../../utils/rest-args-error.mjs"
+
+export default class VelociousDatabaseQueryPreloaderBelongsTo {
+  constructor({models, relationship, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.models = models
+    this.relationship = relationship
+  }
+
+  async run() {
+    const foreignKeyValues = []
+    const modelsById = {}
+    const foreignKey = this.relationship.getForeignKey()
+    const foreignKeyCamelized = inflection.camelize(foreignKey, true)
+    const preloadCollections = {}
+
+    for (const model of this.models) {
+      const foreignKeyValue = model[foreignKeyCamelized]()
+
+      preloadCollections[model.id()] = []
+      foreignKeyValues.push(foreignKeyValue)
+      modelsById[model.id()] = model
+    }
+
+    const whereArgs = {}
+    const primaryKey = this.relationship.getPrimaryKey()
+
+    whereArgs[primaryKey] = foreignKeyValues
+
+    // Load target models to be preloaded on the given models
+    const targetModels = await this.relationship.getTargetModelClass().where(whereArgs).toArray()
+    const targetModelsById = {}
+
+    for (const targetModel of targetModels) {
+      targetModelsById[targetModel.id()] = targetModel
+    }
+
+    // Set the target preloaded models on the given models
+    for (const model of this.models) {
+      const foreignKeyValue = model[foreignKeyCamelized]()
+      const targetModel = targetModelsById[foreignKeyValue]
+      const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
+
+      modelRelationship.setPreloaded(true)
+      modelRelationship.setLoaded(targetModel)
+    }
+
+    return targetModels
+  }
+}

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

@@ -0,0 +1,55 @@
+import * as inflection from "inflection"
+import restArgsError from "../../../utils/rest-args-error.mjs"
+
+export default class VelociousDatabaseQueryPreloaderHasMany {
+  constructor({models, relationship, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.models = models
+    this.relationship = relationship
+  }
+
+  async run() {
+    const modelIds = []
+    const modelsById = {}
+    const foreignKey = this.relationship.getForeignKey()
+    const foreignKeyCamelized = inflection.camelize(foreignKey, true)
+    const preloadCollections = {}
+
+    for (const model of this.models) {
+      preloadCollections[model.id()] = []
+      modelIds.push(model.id())
+
+      if (!(model.id in modelsById)) modelsById[model.id()] = []
+
+      modelsById[model.id()].push(model)
+    }
+
+    const whereArgs = {}
+
+    whereArgs[foreignKey] = modelIds
+
+    // Load target models to be preloaded on the given models
+    const targetModels = await this.relationship.getTargetModelClass().where(whereArgs).toArray()
+
+    for (const targetModel of targetModels) {
+      const foreignKeyValue = targetModel[foreignKeyCamelized]()
+
+      preloadCollections[foreignKeyValue].push(targetModel)
+    }
+
+    // Set the target preloaded models on the given models
+    for (const modelId in preloadCollections) {
+      const preloadedCollection = preloadCollections[modelId]
+
+      for (const model of modelsById[modelId]) {
+        const modelRelationship = model.getRelationshipByName(this.relationship.getRelationshipName())
+
+        modelRelationship.setPreloaded(true)
+        modelRelationship.addToLoaded(preloadedCollection)
+      }
+    }
+
+    return targetModels
+  }
+}

package/src/database/query/preloader.mjs

@@ -0,0 +1,41 @@
+import BelongsToPreloader from "./preloader/belongs-to.mjs"
+import HasManyPreloader from "./preloader/has-many.mjs"
+import restArgsError from "../../utils/rest-args-error.mjs"
+
+export default class VelociousDatabaseQueryPreloader {
+  constructor({modelClass, models, preload, ...restArgs}) {
+    restArgsError(restArgs)
+
+    this.modelClass = modelClass
+    this.models = models
+    this.preload = preload
+  }
+
+  async run() {
+    for (const preloadRelationshipName in this.preload) {
+      const relationship = this.modelClass.getRelationshipByName(preloadRelationshipName)
+      let targetModels
+
+      if (relationship.getType() == "belongsTo") {
+        const hasManyPreloader = new BelongsToPreloader({models: this.models, relationship: relationship})
+
+        targetModels = await hasManyPreloader.run()
+      } else if (relationship.getType() == "hasMany") {
+        const hasManyPreloader = new HasManyPreloader({models: this.models, relationship: relationship})
+
+        targetModels = await hasManyPreloader.run()
+      } else {
+        throw new Error(`Unknown relationship type: ${relationship.getType()}`)
+      }
+
+      // Handle any further preloads in the tree
+      const newPreload = this.preload[preloadRelationshipName]
+
+      if (typeof newPreload == "object" && targetModels.length > 0) {
+        const preloader = new VelociousDatabaseQueryPreloader({modelClass: relationship.getTargetModelClass(), models: targetModels, preload: newPreload})
+
+        await preloader.run()
+      }
+    }
+  }
+}

package/src/database/query/where-base.mjs

@@ -0,0 +1,9 @@
+export default class VelociousDatabaseQueryWhereBase {
+  getOptions() {
+    return this.query.getOptions()
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

package/src/database/query/where-hash.mjs

@@ -0,0 +1,35 @@
+import WhereBase from "./where-base.mjs"
+
+export default class VelociousDatabaseQueryWhereHash extends WhereBase {
+  constructor(query, hash) {
+    super()
+    this.hash = hash
+    this.query = query
+  }
+
+  toSql() {
+    const options = this.getOptions()
+    let sql = "("
+    let index = 0
+
+    for (const whereKey in this.hash) {
+      const whereValue = this.hash[whereKey]
+
+      if (index > 0) sql += " AND "
+
+      sql += `${options.quoteColumnName(whereKey)}`
+
+      if (Array.isArray(whereValue)) {
+        sql += ` IN (${whereValue.map((value) => options.quote(value)).join(", ")})`
+      } else {
+        sql += ` = ${options.quote(whereValue)}`
+      }
+
+      index++
+    }
+
+    sql += ")"
+
+    return sql
+  }
+}

package/src/database/query/where-plain.mjs

@@ -0,0 +1,13 @@
+import WhereBase from "./where-base.mjs"
+
+export default class VelociousDatabaseQueryWhereHash extends WhereBase {
+  constructor(query, plain) {
+    super()
+    this.plain = plain
+    this.query = query
+  }
+
+  toSql() {
+    return this.plain
+  }
+}

package/src/database/query-parser/base-query-parser.mjs

@@ -0,0 +1,33 @@
+import {digs} from "diggerize"
+import FromParser from "./from-parser.mjs"
+import GroupParser from "./group-parser.mjs"
+import JoinsParser from "./joins-parser.mjs"
+import LimitParser from "./limit-parser.mjs"
+import OrderParser from "./order-parser.mjs"
+import SelectParser from "./select-parser.mjs"
+import WhereParser from "./where-parser.mjs"
+
+export default class VelociousDatabaseBaseQueryParser {
+  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()
+    sql += new WhereParser({pretty, query}).toSql()
+    sql += new GroupParser({pretty, query}).toSql()
+    sql += new OrderParser({pretty, query}).toSql()
+    sql += new LimitParser({pretty, query}).toSql()
+
+    return sql
+  }
+}

package/src/database/query-parser/group-parser.mjs

@@ -0,0 +1,40 @@
+import {digs} from "diggerize"
+
+export default class VelociousDatabaseQueryParserFromParser {
+  constructor({pretty, query}) {
+    this.pretty = pretty
+    this.query = query
+  }
+
+  toSql() {
+    const {pretty, query} = digs(this, "pretty", "query")
+
+    if (query._groups.length == 0) {
+      return ""
+    }
+
+    let sql = " GROUP BY"
+
+    for (const groupKey in query._groups) {
+      const group = query._groups[groupKey]
+
+      if (groupKey > 0) {
+        sql += ","
+      }
+
+      if (pretty) {
+        sql += "\n  "
+      } else {
+        sql += " "
+      }
+
+      if (typeof group == "string") {
+        sql += group
+      } else {
+        sql += group.toSql()
+      }
+    }
+
+    return sql
+  }
+}

package/src/database/query-parser/joins-parser.mjs

@@ -1,28 +1,69 @@
 import {digs} from "diggerize"
+import JoinPlain from "../query/join-plain.mjs"
 
 export default class VelocuiousDatabaseQueryParserJoinsParser {
   constructor({pretty, query}) {
     this.pretty = pretty
     this.query = query
+    this.conn = this.query.driver
   }
 
   toSql() {
     const {pretty, query} = digs(this, "pretty", "query")
-
     let sql = ""
 
     for (const joinKey in query._joins) {
       const join = query._joins[joinKey]
 
-      if (joinKey == 0) {
-        if (pretty) {
-          sql += "\n\n"
-        } else {
-          sql += " "
+      if (join instanceof JoinPlain) {
+        if (joinKey == 0) {
+          if (pretty) {
+            sql += "\n\n"
+          } else {
+            sql += " "
+          }
         }
+
+        sql += join.toSql()
+      } else if (typeof join == "object") {
+        sql = this.joinObject({join, modelClass: query.modelClass, sql})
+      } else {
+        throw new Error(`Unknown join object: ${join.constructor.name}`)
+      }
+    }
+
+    return sql
+  }
+
+  joinObject({join, modelClass, sql}) {
+    const {conn, pretty} = this
+
+    for (const joinKey in join) {
+      const joinValue = join[joinKey]
+      const relationship = modelClass.getRelationshipByName(joinKey)
+      const targetModelClass = relationship.getTargetModelClass()
+
+      if (pretty) {
+        sql += "\n\n"
+      } else {
+        sql += " "
       }
 
-      sql += join.toSql()
+      sql += `LEFT JOIN ${conn.quoteTable(targetModelClass.tableName())} ON `
+
+      if (relationship.getType() == "belongsTo") {
+        sql += `${conn.quoteTable(targetModelClass.tableName())}.${conn.quoteColumn(relationship.getPrimaryKey())} = `
+        sql += `${conn.quoteTable(modelClass.tableName())}.${conn.quoteColumn(relationship.getForeignKey())}`
+      } else if (relationship.getType() == "hasMany" || relationship.getType() == "hasOne") {
+        sql += `${conn.quoteTable(targetModelClass.tableName())}.${conn.quoteColumn(relationship.getForeignKey())} = `
+        sql += `${conn.quoteTable(modelClass.tableName())}.${conn.quoteColumn(relationship.getPrimaryKey())}`
+      } else {
+        throw new Error(`Unknown relationship type: ${relationship.getType()}`)
+      }
+
+      if (typeof joinValue == "object") {
+        sql = this.joinObject({join: joinValue, modelClass: targetModelClass, sql})
+      }
     }
 
     return sql

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

@@ -0,0 +1,40 @@
+import {digs} from "diggerize"
+
+export default class VelocuiousDatabaseQueryParserLimitParser {
+  constructor({pretty, query}) {
+    this.pretty = pretty
+    this.query = query
+  }
+
+  toSql() {
+    const {pretty, query} = digs(this, "pretty", "query")
+    let sql = ""
+
+    if (query._limits.length == 0) return sql
+    if (query._limits.length >= 2) throw new Error(`Multiple limits found: ${query._limits.join(", ")}`)
+
+    if (pretty) {
+      sql += "\n\n"
+    } else {
+      sql += " "
+    }
+
+    sql += "LIMIT"
+
+    for (const limitKey in query._limits) {
+      const limit = query._limits[limitKey]
+
+      if (limitKey > 0) sql += ","
+
+      if (pretty) {
+        sql += "\n  "
+      } else {
+        sql += " "
+      }
+
+      sql += this.query.getOptions().quote(limit)
+    }
+
+    return sql
+  }
+}

package/src/database/query-parser/options.mjs

@@ -3,11 +3,12 @@ import {digg} from "diggerize"
 export default class VelociousDatabaseQueryParserOptions {
   constructor(options) {
     this.columnQuote = digg(options, "columnQuote")
+    this.indexQuote = digg(options, "indexQuote")
     this.driver = digg(options, "driver")
     this.tableQuote = digg(options, "tableQuote")
     this.stringQuote = digg(options, "stringQuote")
 
-    if (!this.driver) throw new Error("No driver given")
+    if (!this.driver) throw new Error("No driver given to parser options")
   }
 
   quoteColumnName(columnName) {

package/src/database/query-parser/order-parser.mjs

@@ -0,0 +1,39 @@
+import {digs} from "diggerize"
+
+export default class VelocuiousDatabaseQueryParserOrderParser {
+  constructor({pretty, query}) {
+    this.pretty = pretty
+    this.query = query
+  }
+
+  toSql() {
+    const {pretty, query} = digs(this, "pretty", "query")
+    let sql = ""
+
+    if (query._orders.length == 0) return sql
+
+    if (pretty) {
+      sql += "\n\n"
+    } else {
+      sql += " "
+    }
+
+    sql += "ORDER BY"
+
+    for (const orderKey in query._orders) {
+      const order = query._orders[orderKey]
+
+      if (orderKey > 0) sql += " ,"
+
+      if (pretty) {
+        sql += "\n  "
+      } else {
+        sql += " "
+      }
+
+      sql += order.toSql()
+    }
+
+    return sql
+  }
+}

package/src/database/query-parser/select-parser.mjs

@@ -35,7 +35,11 @@ export default class VelociousDatabaseQueryParserSelectParser {
     }
 
     if (query._selects.length == 0) {
-      sql += "*"
+      if (query.modelClass) {
+        sql += `${query.modelClass.connection().quoteTable(query.modelClass.tableName())}.*`
+      } else {
+        sql += "*"
+      }
     }
 
     return sql

package/src/database/query-parser/where-parser.mjs

@@ -0,0 +1,39 @@
+import {digs} from "diggerize"
+
+export default class VelocuiousDatabaseQueryParserWhereParser {
+  constructor({pretty, query}) {
+    this.pretty = pretty
+    this.query = query
+  }
+
+  toSql() {
+    const {pretty, query} = digs(this, "pretty", "query")
+    let sql = ""
+
+    if (query._wheres.length == 0) return sql
+
+    if (pretty) {
+      sql += "\n\n"
+    } else {
+      sql += " "
+    }
+
+    sql += "WHERE"
+
+    for (const whereKey in query._wheres) {
+      const where = query._wheres[whereKey]
+
+      if (whereKey > 0) sql += " &&"
+
+      if (pretty) {
+        sql += "\n  "
+      } else {
+        sql += " "
+      }
+
+      sql += where.toSql()
+    }
+
+    return sql
+  }
+}