react-awesome-query-builder-pd/lib/export/sql.js

User-friendly query builder for React. Demo: https://ukrbublik.github.io/react-awesome-query-builder

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.sqlFormat = void 0;

var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));

var _configUtils = require("../utils/configUtils");

var _ruleUtils = require("../utils/ruleUtils");

var _omit = _interopRequireDefault(require("lodash/omit"));

var _pick = _interopRequireDefault(require("lodash/pick"));

var _stuff = require("../utils/stuff");

var _defaultUtils = require("../utils/defaultUtils");

var _default = require("../config/default");

var _funcUtils = require("../utils/funcUtils");

var _immutable = require("immutable");

var _sql = require("../utils/sql");

var sqlFormat = function sqlFormat(tree, config) {
  //meta is mutable
  var meta = {
    errors: []
  };
  var res = formatItem(tree, config, meta);
  if (meta.errors.length) console.warn("Errors while exporting to SQL:", meta.errors);
  return res;
};

exports.sqlFormat = sqlFormat;

var formatItem = function formatItem(item, config, meta) {
  if (!item) return undefined;
  var type = item.get("type");
  var children = item.get("children1");

  if ((type === "group" || type === "rule_group") && children && children.size) {
    return formatGroup(item, config, meta);
  } else if (type === "rule") {
    return formatRule(item, config, meta);
  }

  return undefined;
};

var formatGroup = function formatGroup(item, config, meta) {
  var type = item.get("type");
  var properties = item.get("properties") || new _immutable.Map();
  var children = item.get("children1");
  var groupField = type === "rule_group" ? properties.get("field") : null;
  var groupFieldDef = (0, _configUtils.getFieldConfig)(config, groupField) || {};

  if (groupFieldDef.mode == "array") {
    meta.errors.push("Aggregation is not supported for ".concat(groupField));
  }

  var not = properties.get("not");
  var list = children.map(function (currentChild) {
    return formatItem(currentChild, config, meta);
  }).filter(function (currentChild) {
    return typeof currentChild !== "undefined";
  });
  if (!list.size) return undefined;
  var conjunction = properties.get("conjunction");
  if (!conjunction) conjunction = (0, _defaultUtils.defaultConjunction)(config);
  var conjunctionDefinition = config.conjunctions[conjunction];
  return conjunctionDefinition.sqlFormatConj(list, conjunction, not);
};

var formatRule = function formatRule(item, config, meta) {
  var properties = item.get("properties") || new _immutable.Map();
  var field = properties.get("field");
  var operator = properties.get("operator");
  var operatorOptions = properties.get("operatorOptions");
  var iValueSrc = properties.get("valueSrc");
  var iValueType = properties.get("valueType");
  var iValue = properties.get("value");
  if (field == null || operator == null) return undefined;
  var fieldDefinition = (0, _configUtils.getFieldConfig)(config, field) || {};
  var operatorDefinition = (0, _configUtils.getOperatorConfig)(config, operator, field) || {};
  var reversedOp = operatorDefinition.reversedOp;
  var revOperatorDefinition = (0, _configUtils.getOperatorConfig)(config, reversedOp, field) || {};
  var cardinality = (0, _stuff.defaultValue)(operatorDefinition.cardinality, 1); //format value

  var valueSrcs = [];
  var valueTypes = [];
  var fvalue = iValue.map(function (currentValue, ind) {
    var valueSrc = iValueSrc ? iValueSrc.get(ind) : null;
    var valueType = iValueType ? iValueType.get(ind) : null;
    var cValue = (0, _funcUtils.completeValue)(currentValue, valueSrc, config);
    var widget = (0, _ruleUtils.getWidgetForFieldOp)(config, field, operator, valueSrc);
    var fieldWidgetDefinition = (0, _omit["default"])((0, _configUtils.getFieldWidgetConfig)(config, field, operator, widget, valueSrc), ["factory"]);
    var fv = formatValue(meta, config, cValue, valueSrc, valueType, fieldWidgetDefinition, fieldDefinition, operator, operatorDefinition);

    if (fv !== undefined) {
      valueSrcs.push(valueSrc);
      valueTypes.push(valueType);
    }

    return fv;
  });
  var hasUndefinedValues = fvalue.filter(function (v) {
    return v === undefined;
  }).size > 0;
  if (hasUndefinedValues || fvalue.size < cardinality) return undefined;
  var formattedValue = cardinality == 1 ? fvalue.first() : fvalue; //find fn to format expr

  var isRev = false;
  var fn = operatorDefinition.sqlFormatOp;

  if (!fn && reversedOp) {
    fn = revOperatorDefinition.sqlFormatOp;

    if (fn) {
      isRev = true;
    }
  }

  if (!fn) {
    var sqlOp = operatorDefinition.sqlOp || operator;

    if (cardinality == 0) {
      fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions) {
        return "".concat(field, " ").concat(sqlOp);
      };
    } else if (cardinality == 1) {
      fn = function fn(field, op, value, valueSrc, valueType, opDef, operatorOptions) {
        return "".concat(field, " ").concat(sqlOp, " ").concat(value);
      };
    } else if (cardinality == 2) {
      // between
      fn = function fn(field, op, values, valueSrc, valueType, opDef, operatorOptions) {
        var valFrom = values.first();
        var valTo = values.get(1);
        return "".concat(field, " ").concat(sqlOp, " ").concat(valFrom, " AND ").concat(valTo);
      };
    }
  }

  if (!fn) {
    meta.errors.push("Operator ".concat(operator, " is not supported"));
    return undefined;
  } //format field


  var formattedField = formatField(meta, config, field); //format expr

  var args = [formattedField, operator, formattedValue, valueSrcs.length > 1 ? valueSrcs : valueSrcs[0], valueTypes.length > 1 ? valueTypes : valueTypes[0], (0, _omit["default"])(operatorDefinition, ["formatOp", "mongoFormatOp", "sqlFormatOp", "jsonLogic"]), operatorOptions];
  var ret = fn.apply(void 0, args);

  if (isRev) {
    ret = config.settings.sqlFormatReverse(ret, operator, reversedOp, operatorDefinition, revOperatorDefinition);
  }

  return ret;
};

var formatValue = function formatValue(meta, config, currentValue, valueSrc, valueType, fieldWidgetDef, fieldDef, operator, operatorDef) {
  if (currentValue === undefined) return undefined;
  var ret;

  if (valueSrc == "field") {
    ret = formatField(meta, config, currentValue);
  } else if (valueSrc == "func") {
    ret = formatFunc(meta, config, currentValue);
  } else {
    if (typeof fieldWidgetDef.sqlFormatValue === "function") {
      var fn = fieldWidgetDef.sqlFormatValue;
      var args = [currentValue, (0, _pick["default"])(fieldDef, ["fieldSettings", "listValues"]), //useful options: valueFormat for date/time
      (0, _omit["default"])(fieldWidgetDef, ["formatValue", "mongoFormatValue", "sqlFormatValue", "jsonLogic", "elasticSearchFormatValue"])];

      if (operator) {
        args.push(operator);
        args.push(operatorDef);
      }

      if (valueSrc == "field") {
        var valFieldDefinition = (0, _configUtils.getFieldConfig)(config, currentValue) || {};
        args.push(valFieldDefinition);
      }

      ret = fn.apply(void 0, args);
    } else {
      ret = _sql.SqlString.escape(currentValue);
    }
  }

  return ret;
};

var formatField = function formatField(meta, config, field) {
  var fieldSeparator = config.settings.fieldSeparator;
  var fieldDefinition = (0, _configUtils.getFieldConfig)(config, field) || {};
  var fieldParts = Array.isArray(field) ? field : field.split(fieldSeparator);

  var _fieldKeys = (0, _ruleUtils.getFieldPath)(field, config);

  var fieldPartsLabels = (0, _ruleUtils.getFieldPathLabels)(field, config);
  var fieldFullLabel = fieldPartsLabels ? fieldPartsLabels.join(fieldSeparator) : null;
  var formatFieldFn = config.settings.formatField || _default.settings.formatField;
  var fieldName = (0, _ruleUtils.formatFieldName)(field, config, meta);
  var formattedField = formatFieldFn(fieldName, fieldParts, fieldFullLabel, fieldDefinition, config);
  return formattedField;
};

var formatFunc = function formatFunc(meta, config, currentValue) {
  var funcKey = currentValue.get("func");
  var args = currentValue.get("args");
  var funcConfig = (0, _configUtils.getFuncConfig)(config, funcKey);
  var funcName = funcConfig.sqlFunc || funcKey;
  var formattedArgs = {};

  for (var argKey in funcConfig.args) {
    var argConfig = funcConfig.args[argKey];
    var fieldDef = (0, _configUtils.getFieldConfig)(config, argConfig);
    var argVal = args ? args.get(argKey) : undefined;
    var argValue = argVal ? argVal.get("value") : undefined;
    var argValueSrc = argVal ? argVal.get("valueSrc") : undefined;
    var formattedArgVal = formatValue(meta, config, argValue, argValueSrc, argConfig.type, fieldDef, argConfig, null, null);

    if (argValue != undefined && formattedArgVal === undefined) {
      meta.errors.push("Can't format value of arg ".concat(argKey, " for func ").concat(funcKey));
      return undefined;
    }

    if (formattedArgVal !== undefined) {
      // skip optional in the end
      formattedArgs[argKey] = formattedArgVal;
    }
  }

  var ret;

  if (typeof funcConfig.sqlFormatFunc === "function") {
    var fn = funcConfig.sqlFormatFunc;
    var _args = [formattedArgs];
    ret = fn.apply(void 0, _args);
  } else {
    var argsStr = Object.entries(formattedArgs).map(function (_ref) {
      var _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
          k = _ref2[0],
          v = _ref2[1];

      return v;
    }).join(", ");
    ret = "".concat(funcName, "(").concat(argsStr, ")");
  }

  return ret;
};