silvie/database/builders/condition/having.js

Typescript Back-end Framework

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
class HavingConditionBuilder {
  constructor() {
    _defineProperty(this, "conditions", void 0);
    this.conditions = [];
  }
  baseHaving(type, relation, lhs, operator, rhs) {
    const condition = {
      type,
      relation
    };
    if (lhs instanceof Function) {
      const conditionBuilder = new HavingConditionBuilder();
      lhs(conditionBuilder);
      condition.type = 'group';
      condition.conditions = conditionBuilder.conditions;
    } else {
      condition.leftHandSide = lhs;
      if (rhs === undefined) {
        if (operator === undefined) {
          if (!type.endsWith('null')) {
            throw new Error(`Invalid usage of ${type} having`);
          }
        } else {
          if (!['between', 'not between', 'in', 'not in', 'like', 'not like'].includes(type)) {
            condition.operator = '=';
          }
          condition.rightHandSide = operator;
        }
      } else {
        if (operator) condition.operator = operator;
        condition.rightHandSide = rhs;
      }
    }
    this.conditions.push(condition);
    return this;
  }
  having(column, operator, value) {
    return this.baseHaving('value', 'and', column, operator, value);
  }
  orHaving(column, operator, value) {
    return this.baseHaving('value', 'or', column, operator, value);
  }
  havingNull(column) {
    return this.baseHaving('null', 'and', column);
  }
  orHavingNull(column) {
    return this.baseHaving('null', 'or', column);
  }
  havingNotNull(column) {
    return this.baseHaving('not null', 'and', column);
  }
  orHavingNotNull(column) {
    return this.baseHaving('not null', 'or', column);
  }
  havingBetween(column, values) {
    return this.baseHaving('between', 'and', column, values);
  }
  orHavingBetween(column, values) {
    return this.baseHaving('between', 'and', column, values);
  }
  havingNotBetween(column, values) {
    return this.baseHaving('not between', 'and', column, values);
  }
  orHavingNotBetween(column, values) {
    return this.baseHaving('not between', 'and', column, values);
  }
  havingIn(column, values) {
    return this.baseHaving('in', 'and', column, values);
  }
  orHavingIn(column, values) {
    return this.baseHaving('in', 'or', column, values);
  }
  havingNotIn(column, values) {
    return this.baseHaving('not in', 'and', column, values);
  }
  orHavingNotIn(column, values) {
    return this.baseHaving('not in', 'or', column, values);
  }
  havingLike(column, value) {
    return this.baseHaving('like', 'and', column, value);
  }
  orHavingLike(column, value) {
    return this.baseHaving('like', 'or', column, value);
  }
  havingNotLike(column, value) {
    return this.baseHaving('not like', 'and', column, value);
  }
  orHavingNotLike(column, value) {
    return this.baseHaving('not like', 'or', column, value);
  }
  havingColumn(firstColumn, operator, secondColumn) {
    return this.baseHaving('column', 'and', firstColumn, operator, secondColumn);
  }
  orHavingColumn(firstColumn, operator, secondColumn) {
    return this.baseHaving('column', 'or', firstColumn, operator, secondColumn);
  }
  havingDate(column, operator, value) {
    return this.baseHaving('date', 'and', column, operator, value);
  }
  orHavingDate(column, operator, value) {
    return this.baseHaving('date', 'or', column, operator, value);
  }
  havingYear(column, operator, value) {
    return this.baseHaving('year', 'and', column, operator, value);
  }
  orHavingYear(column, operator, value) {
    return this.baseHaving('year', 'or', column, operator, value);
  }
  havingMonth(column, operator, value) {
    return this.baseHaving('month', 'and', column, operator, value);
  }
  orHavingMonth(column, operator, value) {
    return this.baseHaving('month', 'or', column, operator, value);
  }
  havingDay(column, operator, value) {
    return this.baseHaving('day', 'and', column, operator, value);
  }
  orHavingDay(column, operator, value) {
    return this.baseHaving('day', 'or', column, operator, value);
  }
  havingTime(column, operator, value) {
    return this.baseHaving('time', 'and', column, operator, value);
  }
  orHavingTime(column, operator, value) {
    return this.baseHaving('time', 'or', column, operator, value);
  }
  havingRaw(query, params) {
    this.conditions.push({
      type: 'raw',
      relation: 'and',
      query,
      params: params || []
    });
    return this;
  }
  orHavingRaw(query, params) {
    this.conditions.push({
      type: 'raw',
      relation: 'or',
      query,
      params: params || []
    });
    return this;
  }
}
exports.default = HavingConditionBuilder;