@trap_stevo/liveql/dist/cjs/HUDComponents/QueryBuilder.js

Supercharge your database workflow with a visually clean, ultra-intuitive SQL layer. Chain elegant queries, trigger instant real-time events, and manage schemas effortlessly — all without ORM overhead while blending raw SQL power with modern developer erg

"use strict";

function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
var _whereClauses = /*#__PURE__*/new WeakMap();
var _insertData = /*#__PURE__*/new WeakMap();
var _updateData = /*#__PURE__*/new WeakMap();
var _deleted = /*#__PURE__*/new WeakMap();
var _paramIndex = /*#__PURE__*/new WeakMap();
var _limit = /*#__PURE__*/new WeakMap();
var _select = /*#__PURE__*/new WeakMap();
var _order = /*#__PURE__*/new WeakMap();
var _dialect = /*#__PURE__*/new WeakMap();
var _client = /*#__PURE__*/new WeakMap();
var _table = /*#__PURE__*/new WeakMap();
var _QueryBuilder_brand = /*#__PURE__*/new WeakSet();
class QueryBuilder {
  constructor(client, table, dialect = "generic") {
    _classPrivateMethodInitSpec(this, _QueryBuilder_brand);
    _classPrivateFieldInitSpec(this, _whereClauses, []);
    _classPrivateFieldInitSpec(this, _insertData, null);
    _classPrivateFieldInitSpec(this, _updateData, null);
    _classPrivateFieldInitSpec(this, _deleted, false);
    _classPrivateFieldInitSpec(this, _paramIndex, 1);
    _classPrivateFieldInitSpec(this, _limit, null);
    _classPrivateFieldInitSpec(this, _select, "*");
    _classPrivateFieldInitSpec(this, _order, "");
    _classPrivateFieldInitSpec(this, _dialect, void 0);
    _classPrivateFieldInitSpec(this, _client, void 0);
    _classPrivateFieldInitSpec(this, _table, void 0);
    _classPrivateFieldSet(_dialect, this, dialect.toLowerCase());
    _classPrivateFieldSet(_client, this, client);
    _classPrivateFieldSet(_table, this, table);
  }
  select(...fields) {
    _classPrivateFieldSet(_select, this, fields.length ? fields.join(", ") : "*");
    return this;
  }
  where(field, opOrValue, valueIfOp) {
    let op = "=";
    let value;
    if (valueIfOp !== undefined) {
      op = opOrValue;
      value = valueIfOp;
    } else {
      value = opOrValue;
    }
    _classPrivateFieldGet(_whereClauses, this).push({
      opType: "AND",
      field,
      op,
      value
    });
    return this;
  }
  and(field, value) {
    return this.where(field, value);
  }
  or(field, opOrValue, valueIfOp) {
    let op = "=";
    let value;
    if (valueIfOp !== undefined) {
      op = opOrValue;
      value = valueIfOp;
    } else {
      value = opOrValue;
    }
    _classPrivateFieldGet(_whereClauses, this).push({
      opType: "OR",
      clause: `${field} ${op} ${_assertClassBrand(_QueryBuilder_brand, this, _placeholder).call(this)}`,
      value
    });
    return this;
  }
  like(field, pattern) {
    _classPrivateFieldGet(_whereClauses, this).push({
      opType: "AND",
      clause: `${field} LIKE ${_assertClassBrand(_QueryBuilder_brand, this, _placeholder).call(this)}`,
      value: pattern
    });
    return this;
  }
  in(field, values) {
    const placeholders = values.map(() => _assertClassBrand(_QueryBuilder_brand, this, _placeholder).call(this)).join(", ");
    _classPrivateFieldGet(_whereClauses, this).push({
      opType: "AND",
      clause: `${field} IN (${placeholders})`,
      value: values
    });
    return this;
  }
  orderBy(field, dir = "ASC") {
    _classPrivateFieldSet(_order, this, `ORDER BY ${field} ${dir}`);
    return this;
  }
  limit(n) {
    _classPrivateFieldSet(_limit, this, n);
    return this;
  }
  insert(data) {
    _classPrivateFieldSet(_insertData, this, Array.isArray(data) ? data : [data]);
    return this;
  }
  update(data) {
    _classPrivateFieldSet(_updateData, this, data);
    return this;
  }
  delete() {
    _classPrivateFieldSet(_deleted, this, true);
    return this;
  }
  async run() {
    _classPrivateFieldSet(_paramIndex, this, 1);
    let sql = "";
    let params = [];
    if (_classPrivateFieldGet(_insertData, this)) {
      const keys = Object.keys(_classPrivateFieldGet(_insertData, this)[0]);
      const rows = _classPrivateFieldGet(_insertData, this).map(row => {
        keys.forEach(k => params.push(row[k]));
        return `(${keys.map(() => _assertClassBrand(_QueryBuilder_brand, this, _placeholder).call(this)).join(", ")})`;
      }).join(", ");
      sql = `INSERT INTO ${_classPrivateFieldGet(_table, this)} (${keys.join(", ")}) VALUES ${rows}`;
    } else if (_classPrivateFieldGet(_updateData, this)) {
      const sets = Object.keys(_classPrivateFieldGet(_updateData, this)).map(k => {
        params.push(_classPrivateFieldGet(_updateData, this)[k]);
        return `${k} = ${_assertClassBrand(_QueryBuilder_brand, this, _placeholder).call(this)}`;
      }).join(", ");
      sql = `UPDATE ${_classPrivateFieldGet(_table, this)} SET ${sets}`;
    } else if (_classPrivateFieldGet(_deleted, this)) {
      sql = `DELETE FROM ${_classPrivateFieldGet(_table, this)}`;
    } else {
      sql = `SELECT ${_classPrivateFieldGet(_select, this)} FROM ${_classPrivateFieldGet(_table, this)}`;
    }
    if (_classPrivateFieldGet(_whereClauses, this).length) {
      let clauseS = "";
      for (let i = 0; i < _classPrivateFieldGet(_whereClauses, this).length; i++) {
        const {
          opType,
          field,
          op,
          value
        } = _classPrivateFieldGet(_whereClauses, this)[i];
        const clause = Array.isArray(value) ? `${field} ${op} (${value.map(() => _assertClassBrand(_QueryBuilder_brand, this, _placeholder).call(this)).join(", ")})` : `${field} ${op} ${_assertClassBrand(_QueryBuilder_brand, this, _placeholder).call(this)}`;
        if (i === 0) {
          clauseS += clause;
        } else {
          clauseS += ` ${opType} ${clause}`;
        }
        if (Array.isArray(value)) {
          params.push(...value);
        } else {
          params.push(value);
        }
      }
      sql += ` WHERE ${clauseS}`;
    }
    if (_classPrivateFieldGet(_order, this)) {
      sql += ` ${_classPrivateFieldGet(_order, this)}`;
    }
    if (_classPrivateFieldGet(_limit, this) !== null) {
      sql += ` LIMIT ${_classPrivateFieldGet(_limit, this)}`;
    }
    return _classPrivateFieldGet(_client, this).query(sql, params);
  }
}
function _placeholder() {
  if (_classPrivateFieldGet(_dialect, this) === "postgres") {
    var _this$paramIndex, _this$paramIndex2;
    return `$${_classPrivateFieldSet(_paramIndex, this, (_this$paramIndex = _classPrivateFieldGet(_paramIndex, this), _this$paramIndex2 = _this$paramIndex++, _this$paramIndex)), _this$paramIndex2}`;
  }
  return "?";
}
module.exports = QueryBuilder;