velocious 1.0.4 → 1.0.6

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,21 +3,22 @@ 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) {
-    if (columnName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${columnName}`)
+    if (!columnName || columnName.includes(this.columnQuote)) throw new Error(`Invalid column name: ${columnName}`)
 
     return `${this.columnQuote}${columnName}${this.columnQuote}`
   }
 
   quoteTableName(tableName) {
-    if (tableName.includes(this.tableQuote)) throw new Error(`Invalid table name: ${tableName}`)
+    if (!tableName || tableName.includes(this.tableQuote)) throw new Error(`Invalid table name: ${tableName}`)
 
     return `${this.tableQuote}${tableName}${this.tableQuote}`
   }

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