velocious 1.0.430 → 1.0.432

package/build/database/query/join-base.js

@@ -0,0 +1,43 @@
+// @ts-check
+
+export default class VelociousDatabaseQueryJoinBase {
+  pretty = false
+
+  /**
+   * Runs get options.
+   * @returns {import("../query-parser/options.js").default} - The options options.
+   */
+  getOptions() {
+    return this.getQuery().driver.options()
+  }
+
+  /**
+   * Runs get query.
+   * @returns {import("./index.js").default} - The query.
+   */
+  getQuery() {
+    if (!this.query) throw new Error("'query' hasn't been set")
+
+    return this.query
+  }
+
+  /**
+   * Runs set pretty.
+   * @param {boolean} value - Value to use.
+   */
+  setPretty(value) {
+    this.pretty = value
+  }
+
+  /**
+   * Runs set query.
+   * @param {import("./index.js").default} query - Query instance.
+   */
+  setQuery(query) {
+    this.query = query
+  }
+
+  toSql() {
+    throw new Error("'toSql' wasn't implemented")
+  }
+}

package/build/database/query/join-object.js

@@ -0,0 +1,167 @@
+// @ts-check
+
+import JoinBase from "./join-base.js"
+import WhereHash from "./where-hash.js"
+import WhereNot from "./where-not.js"
+
+/**
+ * VelociousDatabaseQueryJoinObject class.
+ * @typedef {{[key: string]: boolean | string | string[] | JoinObjectInput}} JoinObjectInput
+ * @typedef {{[key: string]: boolean | JoinObject}} JoinObject
+ */
+
+export default class VelociousDatabaseQueryJoinObject extends JoinBase {
+  /**
+   * Runs constructor.
+   * @param {JoinObject} object - Object.
+   * @param {string[]} [basePath] - Join base path relative to the root query.
+   */
+  constructor(object, basePath = []) {
+    super()
+    this.object = object
+    this.basePath = basePath
+  }
+
+  toSql() {
+    const query = this.getQuery()
+
+    if (query.constructor.name != "VelociousDatabaseQueryModelClassQuery") {
+      throw new Error(`Query has to be a ModelClassQuery but was a ${query.constructor.name}`)
+    }
+
+    const modelQuery = /**
+                        * Narrows the runtime value to the documented type.
+                         @type {import("./model-class-query.js").default} */ (query)
+    const ModelClass = /**
+                        * Narrows the runtime value to the documented type.
+                         @type {typeof import("../record/index.js").default} */ (
+      this.basePath.length > 0 ? modelQuery._resolveModelClassForJoinPath(this.basePath) : modelQuery.modelClass
+    )
+
+    return this.joinObject(this.object, ModelClass, "", 0, modelQuery.getJoinBasePath().concat(this.basePath))
+  }
+
+  /**
+   * Runs join object.
+   * @param {JoinObject} join - Join.
+   * @param {typeof import("../record/index.js").default} modelClass - Model class.
+   * @param {string} sql - SQL string.
+   * @param {number} joinsCount - Joins count.
+   * @param {string[]} path - Join path.
+   * @returns {string} - The join object.
+   */
+  joinObject(join, modelClass, sql, joinsCount, path) {
+    const pretty = this.pretty
+    const conn = this.getQuery().driver
+    const query = /**
+                   * Narrows the runtime value to the documented type.
+                    @type {import("./model-class-query.js").default} */ (this.getQuery())
+
+    for (const joinKey in join) {
+      const joinValue = join[joinKey]
+      const relationship = modelClass.getRelationshipByName(joinKey)
+      const targetModelClass = relationship.getTargetModelClass()
+
+      if (!targetModelClass) {
+        throw new Error(`Relationship ${modelClass.name}#${joinKey} has no target model class`)
+      }
+
+      const joinPath = path.concat([joinKey])
+      const parentTableRef = query.getJoinTableReference(path)
+      const targetEntry = query._registerJoinPath(joinPath)
+      const targetTableRef = targetEntry.alias || targetEntry.tableName
+      const joinTableSql = targetEntry.alias
+        ? `${conn.quoteTable(targetEntry.tableName)} AS ${conn.quoteTable(targetEntry.alias)}`
+        : conn.quoteTable(targetEntry.tableName)
+
+      if (joinsCount > 0) {
+        if (pretty) {
+          sql += "\n\n"
+        } else {
+          sql += " "
+        }
+      }
+
+      sql += `LEFT JOIN ${joinTableSql} ON `
+
+      if (relationship.getType() == "belongsTo") {
+        sql += `${conn.quoteTable(targetTableRef)}.${conn.quoteColumn(relationship.getPrimaryKey())} = `
+        sql += `${conn.quoteTable(parentTableRef)}.${conn.quoteColumn(relationship.getForeignKey())}`
+      } else if (relationship.getType() == "hasMany" || relationship.getType() == "hasOne") {
+        sql += `${conn.quoteTable(targetTableRef)}.${conn.quoteColumn(relationship.getForeignKey())} = `
+        sql += `${conn.quoteTable(parentTableRef)}.${conn.quoteColumn(relationship.getPrimaryKey())}`
+      } else {
+        throw new Error(`Unknown relationship type: ${relationship.getType()}`)
+      }
+
+      const scopeSql = this._scopeSql({relationship, query, targetModelClass, joinPath, targetTableRef})
+
+      if (scopeSql) {
+        sql += ` AND ${scopeSql}`
+      }
+
+      if (typeof joinValue == "object") {
+        sql = this.joinObject(joinValue, targetModelClass, sql, joinsCount + 1, joinPath)
+      }
+    }
+
+    return sql
+  }
+
+  /**
+   * Runs scope sql.
+   * @param {object} args - Options object.
+   * @param {import("../record/relationships/base.js").default} args.relationship - Relationship definition.
+   * @param {import("./model-class-query.js").default} args.query - Model class query.
+   * @param {typeof import("../record/index.js").default} args.targetModelClass - Target model class.
+   * @param {string[]} args.joinPath - Join path.
+   * @param {string} args.targetTableRef - Target table reference.
+   * @returns {string} - Scope SQL.
+   */
+  _scopeSql({relationship, query, targetModelClass, joinPath, targetTableRef}) {
+    if (!relationship.getScope()) return ""
+
+    const scopedQuery = query.buildJoinScopeQuery(targetModelClass, joinPath)
+    const appliedQuery = relationship.applyScope(scopedQuery) || scopedQuery
+    const wheres = appliedQuery._wheres
+
+    if (!wheres || wheres.length === 0) return ""
+
+    const parts = []
+
+    for (const where of wheres) {
+      parts.push(this._scopeSqlForWhere(where, targetTableRef))
+    }
+
+    return parts.join(" AND ")
+  }
+
+  /**
+   * Runs scope sql for where.
+   * @param {import("./where-base.js").default} where - Where.
+   * @param {string} targetTableRef - Target table reference.
+   * @returns {string} - Scope where SQL.
+   */
+  _scopeSqlForWhere(where, targetTableRef) {
+    if (where instanceof WhereHash) {
+      const hash = where.hash
+      const hasNested = Object.values(hash).some((value) => value !== null && typeof value === "object" && !Array.isArray(value))
+
+      return hasNested
+        ? where.toSql()
+        : `(${where._whereSQLFromHash(hash, targetTableRef)})`
+    }
+
+    if (where instanceof WhereNot && where.where instanceof WhereHash) {
+      const hash = where.where.hash
+      const hasNested = Object.values(hash).some((value) => value !== null && typeof value === "object" && !Array.isArray(value))
+      const innerSql = hasNested
+        ? where.where.toSql()
+        : `(${where.where._whereSQLFromHash(hash, targetTableRef)})`
+
+      return `NOT (${innerSql})`
+    }
+
+    return where.toSql()
+  }
+}

package/build/database/query/join-plain.js

@@ -0,0 +1,18 @@
+// @ts-check
+
+import JoinBase from "./join-base.js"
+
+export default class VelociousDatabaseQueryJoinPlain extends JoinBase {
+  /**
+   * Runs constructor.
+   * @param {string} plain - Plain.
+   */
+  constructor(plain) {
+    super()
+    this.plain = plain
+  }
+
+  toSql() {
+    return this.plain
+  }
+}

package/build/database/query/join-tracker.js

@@ -0,0 +1,93 @@
+// @ts-check
+
+export default class VelociousDatabaseQueryJoinTracker {
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {typeof import("../record/index.js").default} args.modelClass - Root model class.
+   */
+  constructor({modelClass}) {
+    if (!modelClass) throw new Error("No modelClass given to JoinTracker")
+
+    this._rootModelClass = modelClass
+    this._entries = new Map()
+    this._tableUsage = new Map()
+
+    this.registerPath([], modelClass.tableName())
+  }
+
+  /**
+   * Runs clone.
+   * @returns {VelociousDatabaseQueryJoinTracker} - The clone.
+   */
+  clone() {
+    const cloned = new VelociousDatabaseQueryJoinTracker({modelClass: this._rootModelClass})
+
+    cloned._entries = new Map(this._entries)
+    cloned._tableUsage = new Map(this._tableUsage)
+
+    return cloned
+  }
+
+  /**
+   * Runs get root model class.
+   * @returns {typeof import("../record/index.js").default} - Root model class.
+   */
+  getRootModelClass() {
+    return this._rootModelClass
+  }
+
+  /**
+   * Runs path key.
+   * @param {string[]} path - Join path.
+   * @returns {string} - Path key.
+   */
+  pathKey(path) {
+    return path.join(".")
+  }
+
+  /**
+   * Runs get entry.
+   * @param {string[]} path - Join path.
+   * @returns {{tableName: string, alias: string | undefined} | undefined} - Entry.
+   */
+  getEntry(path) {
+    return this._entries.get(this.pathKey(path))
+  }
+
+  /**
+   * Runs register path.
+   * @param {string[]} path - Join path.
+   * @param {string} tableName - Table name.
+   * @returns {{tableName: string, alias: string | undefined}} - Entry.
+   */
+  registerPath(path, tableName) {
+    const key = this.pathKey(path)
+    const existing = this._entries.get(key)
+
+    if (existing) return existing
+
+    const usageCount = this._tableUsage.get(tableName) || 0
+    const alias = usageCount > 0 ? this.buildAlias(tableName, path) : undefined
+
+    this._tableUsage.set(tableName, usageCount + 1)
+
+    const entry = {tableName, alias}
+
+    this._entries.set(key, entry)
+
+    return entry
+  }
+
+  /**
+   * Runs build alias.
+   * @param {string} tableName - Table name.
+   * @param {string[]} path - Join path.
+   * @returns {string} - Alias.
+   */
+  buildAlias(tableName, path) {
+    if (path.length === 0) return tableName
+
+    return `${tableName}__${path.join("__")}`
+  }
+}