@tanstack/optimistic/dist/esm/query/evaluators.js

Core optimistic updates library

import { evaluateOperandOnNestedRow } from "./extractors.js";
import { isValueInArray, convertLikeToRegex, compareValues } from "./utils.js";
function evaluateConditionOnNestedRow(nestedRow, condition, mainTableAlias, joinedTableAlias) {
  if (condition.length === 3 && !Array.isArray(condition[0])) {
    const [left, comparator, right] = condition;
    return evaluateSimpleConditionOnNestedRow(
      nestedRow,
      left,
      comparator,
      right,
      mainTableAlias,
      joinedTableAlias
    );
  }
  if (condition.length > 3 && !Array.isArray(condition[0]) && typeof condition[1] === `string` && ![`and`, `or`].includes(condition[1])) {
    let result = evaluateSimpleConditionOnNestedRow(
      nestedRow,
      condition[0],
      condition[1],
      condition[2],
      mainTableAlias,
      joinedTableAlias
    );
    for (let i = 3; i < condition.length; i += 4) {
      const logicalOp = condition[i];
      if (i + 3 <= condition.length) {
        const nextResult = evaluateSimpleConditionOnNestedRow(
          nestedRow,
          condition[i + 1],
          condition[i + 2],
          condition[i + 3],
          mainTableAlias,
          joinedTableAlias
        );
        if (logicalOp === `and`) {
          result = result && nextResult;
        } else {
          result = result || nextResult;
        }
      }
    }
    return result;
  }
  if (condition.length > 0 && Array.isArray(condition[0])) {
    let result = evaluateConditionOnNestedRow(
      nestedRow,
      condition[0],
      mainTableAlias,
      joinedTableAlias
    );
    for (let i = 1; i < condition.length; i += 2) {
      if (i + 1 >= condition.length) break;
      const operator = condition[i];
      const nextCondition = condition[i + 1];
      if (operator === `and`) {
        result = result && evaluateConditionOnNestedRow(
          nestedRow,
          nextCondition,
          mainTableAlias,
          joinedTableAlias
        );
      } else {
        result = result || evaluateConditionOnNestedRow(
          nestedRow,
          nextCondition,
          mainTableAlias,
          joinedTableAlias
        );
      }
    }
    return result;
  }
  return true;
}
function evaluateSimpleConditionOnNestedRow(nestedRow, left, comparator, right, mainTableAlias, joinedTableAlias) {
  const leftValue = evaluateOperandOnNestedRow(
    nestedRow,
    left,
    mainTableAlias,
    joinedTableAlias
  );
  const rightValue = evaluateOperandOnNestedRow(
    nestedRow,
    right,
    mainTableAlias,
    joinedTableAlias
  );
  switch (comparator) {
    case `=`:
      return leftValue === rightValue;
    case `!=`:
      return leftValue !== rightValue;
    case `<`:
      return compareValues(leftValue, rightValue, `<`);
    case `<=`:
      return compareValues(leftValue, rightValue, `<=`);
    case `>`:
      return compareValues(leftValue, rightValue, `>`);
    case `>=`:
      return compareValues(leftValue, rightValue, `>=`);
    case `like`:
    case `not like`:
      if (typeof leftValue === `string` && typeof rightValue === `string`) {
        const pattern = convertLikeToRegex(rightValue);
        const matches = new RegExp(`^${pattern}$`, `i`).test(leftValue);
        return comparator === `like` ? matches : !matches;
      }
      return comparator === `like` ? false : true;
    case `in`:
      if (!Array.isArray(rightValue)) {
        return false;
      }
      if (rightValue.length === 0) {
        return false;
      }
      if (Array.isArray(leftValue)) {
        return leftValue.some((item) => isValueInArray(item, rightValue));
      }
      return isValueInArray(leftValue, rightValue);
    case `not in`:
      if (!Array.isArray(rightValue)) {
        return true;
      }
      if (rightValue.length === 0) {
        return true;
      }
      if (Array.isArray(leftValue)) {
        return !leftValue.some((item) => isValueInArray(item, rightValue));
      }
      return !isValueInArray(leftValue, rightValue);
    case `is`:
      return leftValue === rightValue;
    case `is not`:
      if (rightValue === null) {
        return leftValue !== null && leftValue !== void 0;
      }
      return leftValue !== rightValue;
    default:
      return false;
  }
}
export {
  evaluateConditionOnNestedRow,
  evaluateSimpleConditionOnNestedRow
};
//# sourceMappingURL=evaluators.js.map