velocious 1.0.5 → 1.0.7

package/src/database/query/index.js

@@ -0,0 +1,206 @@
+import FromPlain from "./from-plain.js"
+import {incorporate} from "incorporator"
+import * as inflection from "inflection"
+import JoinPlain from "./join-plain.js"
+import OrderPlain from "./order-plain.js"
+import Preloader from "./preloader.js"
+import SelectPlain from "./select-plain.js"
+import WhereHash from "./where-hash.js"
+import WherePlain from "./where-plain.js"
+
+export default class VelociousDatabaseQuery {
+  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
+  }
+
+  clone() {
+    const newQuery = new 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]
+    })
+
+    return newQuery
+  }
+
+  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() {
+    const newQuery = this.clone()
+    const results = await newQuery.limit(1).reorder(this.modelClass.orderableColumn()).toArray()
+
+    return results[0]
+  }
+
+  from(from) {
+    if (typeof from == "string") from = new FromPlain({plain: from, query: this})
+
+    from.query = this
+
+    this._froms.push(from)
+    return this
+  }
+
+  group(group) {
+    this._groups.push(group)
+    return this
+  }
+
+  joins(join) {
+    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})
+
+    order.query = this
+
+    this._orders.push(order)
+    return this
+  }
+
+  preload(data) {
+    incorporate(this._preload, data)
+    return this
+  }
+
+  reorder(order) {
+    this._orders = []
+    this.order(order)
+    return this
+  }
+
+  reverseOrder() {
+    for (const order of this._orders) {
+      order.setReverseOrder(true)
+    }
+
+    return this
+  }
+
+  select(select) {
+    if (Array.isArray(select)) {
+      for (const selectInArray of select) {
+        this.select(selectInArray)
+      }
+
+      return this
+    }
+
+    if (typeof select == "string") select = new SelectPlain({plain: select})
+
+    select.query = this
+
+    this._selects.push(select)
+    return this
+  }
+
+  async toArray() {
+    const sql = this.toSql()
+    const results = await this.driver.query(sql)
+    const models = []
+
+    for (const result of results) {
+      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 = () => this.driver.queryToSql(this)
+
+  where(where) {
+    if (typeof where == "string") {
+      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)
+    return this
+  }
+}

package/src/database/query/{join-plain.mjs → join-plain.js}

@@ -1,4 +1,4 @@
-import JoinBase from "./join-base.mjs"
+import JoinBase from "./join-base.js"
 
 export default class VelociousDatabaseQueryJoinPlain extends JoinBase {
   constructor({plain}) {

package/src/database/query/{order-plain.mjs → order-plain.js}

@@ -1,4 +1,4 @@
-import OrderBase from "./order-base.mjs"
+import OrderBase from "./order-base.js"
 
 export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
   constructor({plain}) {

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

@@ -0,0 +1,52 @@
+import * as inflection from "inflection"
+import restArgsError from "../../../utils/rest-args-error.js"
+
+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.js

@@ -0,0 +1,55 @@
+import * as inflection from "inflection"
+import restArgsError from "../../../utils/rest-args-error.js"
+
+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.js

@@ -0,0 +1,41 @@
+import BelongsToPreloader from "./preloader/belongs-to.js"
+import HasManyPreloader from "./preloader/has-many.js"
+import restArgsError from "../../utils/rest-args-error.js"
+
+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/{select-plain.mjs → select-plain.js}

@@ -1,4 +1,4 @@
-import SelectBase from "./select-base.mjs"
+import SelectBase from "./select-base.js"
 
 export default class VelociousDatabaseQuerySelectPlain extends SelectBase {
   constructor({plain}) {

package/src/database/query/{select-table-and-column.mjs → select-table-and-column.js}

@@ -1,4 +1,4 @@
-import SelectBase from "./select-base.mjs"
+import SelectBase from "./select-base.js"
 
 export default class VelociousDatabaseQuerySelectTableAndColumn extends SelectBase {
   constructor({query, tableName, columnName}) {

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

@@ -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.js

@@ -0,0 +1,35 @@
+import WhereBase from "./where-base.js"
+
+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.js

@@ -0,0 +1,13 @@
+import WhereBase from "./where-base.js"
+
+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.js

@@ -0,0 +1,33 @@
+import {digs} from "diggerize"
+import FromParser from "./from-parser.js"
+import GroupParser from "./group-parser.js"
+import JoinsParser from "./joins-parser.js"
+import LimitParser from "./limit-parser.js"
+import OrderParser from "./order-parser.js"
+import SelectParser from "./select-parser.js"
+import WhereParser from "./where-parser.js"
+
+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.js

@@ -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.js

@@ -0,0 +1,71 @@
+import {digs} from "diggerize"
+import JoinPlain from "../query/join-plain.js"
+
+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 (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 += `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.js

@@ -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 → options.js}

@@ -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.js

@@ -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
+  }
+}