@rsql/ast/dist/index.js

RSQL AST definitions and functions

"use strict";

Object.defineProperty(exports, "__esModule", { value: true });

var EQ = "==";
var NEQ = "!=";
var LE = "<=";
var GE = ">=";
var LT = "<";
var GT = ">";
var IN = "=in=";
var OUT = "=out=";
var LE_VERBOSE = "=le=";
var GE_VERBOSE = "=ge=";
var LT_VERBOSE = "=lt=";
var GT_VERBOSE = "=gt=";
var CanonicalComparisonOperators = [EQ, NEQ, LE, GE, LT, GT, IN, OUT];
var VerboseComparisonOperators = [LE_VERBOSE, GE_VERBOSE, LT_VERBOSE, GT_VERBOSE];
var ComparisonOperators = [EQ, NEQ, LE, GE, LT, GT, IN, OUT, LE_VERBOSE, GE_VERBOSE, LT_VERBOSE, GT_VERBOSE];
function mapToCanonicalComparisonOperator(operator) {
  switch (operator) {
    case LE_VERBOSE:
      return LE;
    case LT_VERBOSE:
      return LT;
    case GE_VERBOSE:
      return GE;
    case GT_VERBOSE:
      return GT;
    default:
      return operator;
  }
}
var CUSTOM_OPERATOR_REGEXP = /^=[a-z]+=$/;
function isCustomComparisonOperator(candidate) {
  return candidate.length > 2 && CUSTOM_OPERATOR_REGEXP.test(candidate);
}
function isComparisonOperator(candidate, operator) {
  switch (candidate) {
    case EQ:
    case NEQ:
    case LE:
    case GE:
    case LT:
    case GT:
    case IN:
    case OUT:
    case LE_VERBOSE:
    case GE_VERBOSE:
    case LT_VERBOSE:
    case GT_VERBOSE:
      return (
        operator === undefined ||
        mapToCanonicalComparisonOperator(candidate) === mapToCanonicalComparisonOperator(operator)
      );
    default:
      if (isCustomComparisonOperator(candidate)) {
        return operator === undefined || candidate === operator;
      } else {
        return false;
      }
  }
}

var AND = ";";
var OR = ",";
var AND_VERBOSE = "and";
var OR_VERBOSE = "or";
var CanonicalLogicOperators = [AND, OR];
var VerboseLogicOperators = [AND_VERBOSE, OR_VERBOSE];
var LogicOperators = [AND, OR, AND_VERBOSE, OR_VERBOSE];
function mapToCanonicalLogicOperator(operator) {
  switch (operator) {
    case AND_VERBOSE:
      return AND;
    case OR_VERBOSE:
      return OR;
    default:
      return operator;
  }
}
function isLogicOperator(candidate, operator) {
  switch (candidate) {
    case AND:
    case OR:
    case AND_VERBOSE:
    case OR_VERBOSE:
      return operator === undefined || mapToCanonicalLogicOperator(candidate) === mapToCanonicalLogicOperator(operator);
    default:
      return false;
  }
}

var ReservedChars = ['"', "'", "(", ")", ";", ",", "=", "!", "~", "<", ">", " ", "\n", "\t", "\r"];

var NodeType = {
  SELECTOR: "SELECTOR",
  VALUE: "VALUE",
  COMPARISON: "COMPARISON",
  LOGIC: "LOGIC",
};
function createNamedNode(node, toString) {
  Object.defineProperty(node, "toString", {
    value: toString,
    enumerable: false,
    configurable: false,
    writable: false,
  });
  return node;
}
function createSelectorNode(selector, skipChecks) {
  if (skipChecks === void 0) {
    skipChecks = false;
  }
  if (!skipChecks) {
    if (typeof selector !== "string") {
      throw new TypeError('The "selector" has to be a "string", "' + String(selector) + '" passed.');
    }
    if (!selector || selector.length === 0) {
      throw new Error('The "selector" cannot be an empty string.');
    }
    var reservedChar = ReservedChars.find(function (reservedChar) {
      return selector.indexOf(reservedChar) !== -1;
    });
    if (reservedChar) {
      var position = selector.indexOf(reservedChar) + 1;
      throw new Error(
        'The "selector" contains reserved character \'' +
          reservedChar +
          "' at position " +
          position +
          ' in "' +
          selector +
          '".'
      );
    }
  }
  return createNamedNode(
    {
      type: NodeType.SELECTOR,
      selector: selector,
    },
    function () {
      return 'SelectorNode("' + selector + '")';
    }
  );
}
function createValueNode(value, skipChecks) {
  if (skipChecks === void 0) {
    skipChecks = false;
  }
  if (!skipChecks) {
    if (typeof value !== "string" && !Array.isArray(value)) {
      throw new TypeError('The "value" has to be a "string | string[]", "' + String(value) + '" passed.');
    }
    if (Array.isArray(value) && value.length === 0) {
      throw new Error('The "value" cannot be an empty array.');
    }
  }
  return createNamedNode(
    {
      type: NodeType.VALUE,
      value: value,
    },
    function () {
      return "ValueNode(" + JSON.stringify(value) + ")";
    }
  );
}
function createComparisonNode(selector, operator, value, skipChecks) {
  if (skipChecks === void 0) {
    skipChecks = false;
  }
  if (!skipChecks) {
    if (!isSelectorNode(selector)) {
      throw new TypeError('The "selector" has to be a "SelectorNode", "' + String(selector) + '" passed.');
    }
    if (typeof operator !== "string") {
      throw new TypeError('The "operator" has to be a "SelectorNode", "' + String(operator) + '" passed.');
    }
    if (!isComparisonOperator(operator)) {
      throw new TypeError('The "operator" has to be a valid "ComparisonOperator", ' + String(operator) + " passed.");
    }
    if (!isValueNode(value)) {
      throw new TypeError('The "value" has to be a "ValueNode", "' + String(value) + '" passed.');
    }
  }
  return createNamedNode(
    {
      type: NodeType.COMPARISON,
      left: selector,
      operator: operator,
      right: value,
    },
    function () {
      return "ComparisonNode(" + selector + "," + operator + "," + value + ")";
    }
  );
}
function createLogicNode(left, operator, right, skipChecks) {
  if (skipChecks === void 0) {
    skipChecks = false;
  }
  if (!skipChecks) {
    if (!isExpressionNode(left)) {
      throw new TypeError('The "left" has to be a "ExpressionNode", "' + String(left) + '" passed.');
    }
    if (typeof operator !== "string") {
      throw new TypeError('The "operator" has to be a "string", "' + String(operator) + '" passed.');
    }
    if (!isLogicOperator(operator)) {
      throw new TypeError('The "operator" has to be a valid "LogicOperator", ' + String(operator) + " passed.");
    }
    if (!isExpressionNode(right)) {
      throw new TypeError('The "right" has to be a "ExpressionNode", "' + String(right) + '" passed.');
    }
  }
  return createNamedNode(
    {
      type: NodeType.LOGIC,
      left: left,
      operator: operator,
      right: right,
    },
    function () {
      return "LogicNode(" + left + "," + operator + "," + right + ")";
    }
  );
}
function isNode(candidate) {
  return candidate !== undefined && candidate !== null && Object.prototype.hasOwnProperty.call(candidate, "type");
}
function isSelectorNode(candidate) {
  return isNode(candidate) && candidate.type === NodeType.SELECTOR;
}
function isValueNode(candidate) {
  return isNode(candidate) && candidate.type === NodeType.VALUE;
}
function isComparisonNode(candidate, operator) {
  return (
    isNode(candidate) &&
    candidate.type === NodeType.COMPARISON &&
    (operator === undefined || isComparisonOperator(candidate.operator, operator))
  );
}
function isLogicNode(candidate, operator) {
  return (
    isNode(candidate) &&
    candidate.type === NodeType.LOGIC &&
    (operator === undefined || isLogicOperator(candidate.operator, operator))
  );
}
function isExpressionNode(candidate) {
  return isComparisonNode(candidate) || isLogicNode(candidate);
}
function getSelector(comparison) {
  if (!isComparisonNode(comparison)) {
    throw new TypeError('The "comparison" has to be a valid "ComparisonNode", ' + String(comparison) + " passed.");
  }
  return comparison.left.selector;
}
function getValue(comparison) {
  if (!isComparisonNode(comparison)) {
    throw new TypeError('The "comparison" has to be a valid "ComparisonNode", ' + String(comparison) + " passed.");
  }
  return comparison.right.value;
}
function getSingleValue(comparison) {
  var value = getValue(comparison);
  if (Array.isArray(value)) {
    throw new Error(
      'The "comparison" passed to the "getSingleValue" function has to contain string value, but contains an array.'
    );
  }
  return value;
}
function getMultiValue(comparison) {
  var value = getValue(comparison);
  if (typeof value === "string") {
    throw new Error(
      'The "comparison" passed to the "getMultiValue" function has to contain array value, but contains a single string.'
    );
  }
  return value;
}

exports.AND = AND;
exports.AND_VERBOSE = AND_VERBOSE;
exports.CanonicalComparisonOperators = CanonicalComparisonOperators;
exports.CanonicalLogicOperators = CanonicalLogicOperators;
exports.ComparisonOperators = ComparisonOperators;
exports.EQ = EQ;
exports.GE = GE;
exports.GE_VERBOSE = GE_VERBOSE;
exports.GT = GT;
exports.GT_VERBOSE = GT_VERBOSE;
exports.IN = IN;
exports.LE = LE;
exports.LE_VERBOSE = LE_VERBOSE;
exports.LT = LT;
exports.LT_VERBOSE = LT_VERBOSE;
exports.LogicOperators = LogicOperators;
exports.NEQ = NEQ;
exports.OR = OR;
exports.OR_VERBOSE = OR_VERBOSE;
exports.OUT = OUT;
exports.ReservedChars = ReservedChars;
exports.VerboseComparisonOperators = VerboseComparisonOperators;
exports.VerboseLogicOperators = VerboseLogicOperators;
exports.createComparisonNode = createComparisonNode;
exports.createLogicNode = createLogicNode;
exports.createSelectorNode = createSelectorNode;
exports.createValueNode = createValueNode;
exports.getMultiValue = getMultiValue;
exports.getSelector = getSelector;
exports.getSingleValue = getSingleValue;
exports.getValue = getValue;
exports.isComparisonNode = isComparisonNode;
exports.isComparisonOperator = isComparisonOperator;
exports.isExpressionNode = isExpressionNode;
exports.isLogicNode = isLogicNode;
exports.isLogicOperator = isLogicOperator;
exports.isNode = isNode;
exports.isSelectorNode = isSelectorNode;
exports.isValueNode = isValueNode;