@react-awesome-query-builder/sql/esm/import/convert.js

User-friendly query builder for React. SQL support

import _typeof from "@babel/runtime/helpers/typeof";
import _toArray from "@babel/runtime/helpers/toArray";
import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
/* eslint-disable @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access */

import { Utils } from "@react-awesome-query-builder/core";
import { getLogicDescr } from "./ast";
import { SqlPrimitiveTypes } from "./conv";
export var convertToTree = function convertToTree(logic, conv, config, meta, parentLogic) {
  var _res;
  var returnGroup = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
  if (!logic) return undefined;
  var res;
  if (logic.operator) {
    res = convertOp(logic, conv, config, meta, parentLogic);
  } else if (logic.conj) {
    res = convertConj(logic, conv, config, meta, parentLogic);
  } else if (logic.ternaryChildren) {
    res = convertTernary(logic, conv, config, meta, parentLogic);
  } else if (logic.func) {
    // try to use `sqlImport` in operator definitions
    res = convertOp(logic, conv, config, meta, parentLogic);
  } else {
    meta.errors.push("Unexpected logic: ".concat(getLogicDescr(logic)));
  }
  if (((_res = res) === null || _res === void 0 ? void 0 : _res.type) === "group") {
    res = groupToMaybeRuleGroup(res, config);
  }
  if (returnGroup && res && res.type != "group" && res.type != "switch_group") {
    res = wrapInDefaultConj(res, config, logic.not);
  }
  return res;
};
var convertTernary = function convertTernary(logic, conv, config, meta, parentLogic) {
  var ternaryChildren = logic.ternaryChildren;
  var cases = (ternaryChildren !== null && ternaryChildren !== void 0 ? ternaryChildren : []).map(function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2),
      cond = _ref2[0],
      val = _ref2[1];
    return buildCase(cond, val, conv, config, meta, logic);
  });
  return {
    type: "switch_group",
    children1: cases
  };
};
var buildCase = function buildCase(cond, val, conv, config, meta, parentLogic) {
  var valProperties = buildCaseValProperties(config, meta, conv, val, parentLogic);
  var caseI;
  if (cond) {
    caseI = convertToTree(cond, conv, config, meta, parentLogic, true);
    if (caseI && caseI.type) {
      caseI.type = "case_group";
    } else {
      meta.errors.push("Unexpected case: ".concat(JSON.stringify(caseI)));
      caseI = undefined;
    }
  } else {
    caseI = {
      type: "case_group",
      properties: {}
    };
  }
  if (caseI) {
    caseI.properties = _objectSpread(_objectSpread({}, caseI.properties), valProperties);
  }
  return caseI;
};
var buildCaseValProperties = function buildCaseValProperties(config, meta, conv, val, parentLogic) {
  var caseValueFieldConfig = Utils.ConfigUtils.getFieldConfig(config, "!case_value");
  var widget = caseValueFieldConfig === null || caseValueFieldConfig === void 0 ? void 0 : caseValueFieldConfig.mainWidget;
  var widgetConfig = config.widgets[widget];
  var convVal = convertArg(val, conv, config, meta, parentLogic);
  if (convVal && convVal.valueSrc === "value") {
    // @ts-ignore
    convVal.valueType = widgetConfig.type || caseValueFieldConfig.type || convVal.valueType;
  }
  var valProperties = {
    value: [convVal.value],
    valueSrc: [convVal.valueSrc],
    valueType: [convVal.valueType],
    field: "!case_value"
  };
  return valProperties;
};
var convertConj = function convertConj(logic, conv, config, meta, parentLogic) {
  var conj = logic.conj,
    children = logic.children;
  var conjunction = conv.conjunctions[conj];
  var convChildren = (children || []).map(function (a) {
    return convertToTree(a, conv, config, meta, logic);
  }).filter(function (c) {
    return !!c;
  });
  var res = {
    type: "group",
    properties: {
      conjunction: conjunction,
      not: logic.not
    },
    children1: convChildren
  };
  return res;
};
var getCommonGroupField = function getCommonGroupField(fields, config) {
  if (fields.length > 0) {
    var closestGroupFields = fields.map(function (f) {
      var _groupFields$reverse;
      var paths = Utils.ConfigUtils.getFieldParts(f, config);
      var groupFields = paths.filter(function (path) {
        var _Utils$ConfigUtils$ge;
        return ((_Utils$ConfigUtils$ge = Utils.ConfigUtils.getFieldConfig(config, path)) === null || _Utils$ConfigUtils$ge === void 0 ? void 0 : _Utils$ConfigUtils$ge.type) === "!group";
      });
      var closestGroupField = (_groupFields$reverse = groupFields.reverse()) === null || _groupFields$reverse === void 0 ? void 0 : _groupFields$reverse[0];
      return closestGroupField;
    }).filter(function (gf) {
      return !!gf;
    });
    var isSameGroupField = Array.from(new Set(closestGroupFields)).length === 1;
    var allFieldsAreInsideGroup = closestGroupFields.length === fields.length;
    if (allFieldsAreInsideGroup && isSameGroupField) {
      return closestGroupFields[0];
    }
  }
  return undefined;
};
var groupToMaybeRuleGroup = function groupToMaybeRuleGroup(grp, config) {
  var _grp$children, _grp$children2;
  var fields = ((_grp$children = grp.children1) !== null && _grp$children !== void 0 ? _grp$children : []).filter(function (ch) {
    return ch.type === "rule" || ch.type === "rule_group";
  }).map(function (rule) {
    var _properties;
    return (_properties = rule.properties) === null || _properties === void 0 ? void 0 : _properties.field;
  }).filter(function (f) {
    return !!f;
  });
  if ((fields === null || fields === void 0 ? void 0 : fields.length) === ((_grp$children2 = grp.children1) === null || _grp$children2 === void 0 ? void 0 : _grp$children2.length)) {
    var commonGroupField = getCommonGroupField(fields, config);
    if (commonGroupField) {
      var rgr = grp;
      rgr.type = "rule_group";
      rgr.properties.field = commonGroupField;
      rgr.properties.fieldSrc = "field";
      return rgr;
    }
  }
  return grp;
};
var convertOp = function convertOp(logic, conv, config, meta, parentLogic) {
  var _opKeys, _properties$field;
  var opKeys = conv.operators[logic.operator];
  var opKey = (_opKeys = opKeys) === null || _opKeys === void 0 ? void 0 : _opKeys[0];
  var convChildren;
  var operatorOptions;

  // tip: Even if opKeys.length === 1, still try to use `convertOpFunc` to let `sqlImport` be applied first (eg. `not_like` op)
  var convFuncOp = convertOpFunc(logic, conv, config, meta, parentLogic);
  if (convFuncOp) {
    opKey = convFuncOp.operator;
    convChildren = convFuncOp.children;
    operatorOptions = convFuncOp.operatorOptions;
  } else if (logic.operator) {
    var _opKeys2, _opKeys4;
    // Pre-convert children of type field or value (to determine expected type for other children of type function)
    var preConvChildren = Object.fromEntries((logic.children || []).map(function (a, i) {
      return [i, a];
    }).filter(function (_ref3) {
      var _ref4 = _slicedToArray(_ref3, 2),
        _i = _ref4[0],
        a = _ref4[1];
      return a.value !== undefined || a.field !== undefined;
    }).map(function (_ref5) {
      var _ref6 = _slicedToArray(_ref5, 2),
        i = _ref6[0],
        a = _ref6[1];
      return [i, convertArg(a, conv, config, meta, logic)];
    }));
    // Predict return type for function at RHS based on field type in LHS (and vice versa) (needed to distinguish between date and datetime)
    var expectedTypes = _toConsumableArray(new Set(Object.values(preConvChildren).map(function (v) {
      var _v$valueType;
      return (_v$valueType = v === null || v === void 0 ? void 0 : v.valueType) !== null && _v$valueType !== void 0 ? _v$valueType : v === null || v === void 0 ? void 0 : v._maybeValueType;
    }).filter(function (v) {
      return !!v;
    })));
    var expectedType = expectedTypes.length === 1 ? expectedTypes[0] : undefined;
    var _iterator = _createForOfIteratorHelper(logic.children || []),
      _step;
    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var child = _step.value;
        if (child.func && !child._type) {
          child._type = expectedType;
        }
      }
      // Convert
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
    convChildren = (logic.children || []).map(function (a, i) {
      var _preConvChildren$i;
      return (_preConvChildren$i = preConvChildren[i]) !== null && _preConvChildren$i !== void 0 ? _preConvChildren$i : convertArg(a, conv, config, meta, logic);
    });
    var isMultiselect = convChildren.filter(function (ch) {
      return (ch === null || ch === void 0 ? void 0 : ch.valueType) === "multiselect";
    }).length > 0;
    var isSelect = convChildren.filter(function (ch) {
      return (ch === null || ch === void 0 ? void 0 : ch.valueType) === "select";
    }).length > 0;
    if (((_opKeys2 = opKeys) === null || _opKeys2 === void 0 ? void 0 : _opKeys2.length) > 1) {
      var _opKeys3;
      if (isMultiselect) {
        opKeys = opKeys.filter(function (op) {
          return !["equal", "not_equal", "select_equals", "select_not_equals"].includes(op);
        });
      } else if (isSelect) {
        opKeys = opKeys.filter(function (op) {
          return !["equal", "not_equal"].includes(op);
        });
      }
      opKey = (_opKeys3 = opKeys) === null || _opKeys3 === void 0 ? void 0 : _opKeys3[0];
    }
    if (!((_opKeys4 = opKeys) !== null && _opKeys4 !== void 0 && _opKeys4.length)) {
      meta.errors.push("Can't convert ".concat(getLogicDescr(logic)));
      return undefined;
    } else if (opKeys.length > 1 && !["=", "!=", "<>"].includes(logic.operator)) {
      meta.warnings.push("SQL operator \"".concat(logic.operator, "\" can be converted to several operators: ").concat(opKeys.join(", ")));
    }
  } else {
    meta.errors.push("Can't convert ".concat(getLogicDescr(logic)));
    return undefined;
  }
  var _filter = (convChildren || []).filter(function (c) {
      return !!c;
    }),
    _filter2 = _toArray(_filter),
    left = _filter2[0],
    right = _filter2.slice(1);
  var properties = {
    operator: opKey,
    value: [],
    valueSrc: [],
    valueType: [],
    valueError: [],
    field: undefined
  };
  if (operatorOptions) {
    properties.operatorOptions = operatorOptions;
  }
  if ((left === null || left === void 0 ? void 0 : left.valueSrc) === "field") {
    properties.field = left.value;
    properties.fieldSrc = "field";
  } else if ((left === null || left === void 0 ? void 0 : left.valueSrc) === "func") {
    properties.field = left.value;
    properties.fieldSrc = left.valueSrc;
  }
  var opDef = Utils.ConfigUtils.getOperatorConfig(config, opKey, (_properties$field = properties.field) !== null && _properties$field !== void 0 ? _properties$field : undefined);
  // const opCardinality = opDef?.cardinality;
  var opValueTypes = opDef === null || opDef === void 0 ? void 0 : opDef.valueTypes;
  right.forEach(function (v, i) {
    if (v) {
      properties.valueSrc[i] = v === null || v === void 0 ? void 0 : v.valueSrc;
      var valueType = v === null || v === void 0 ? void 0 : v.valueType;
      var finalVal = v === null || v === void 0 ? void 0 : v.value;
      if (valueType && opValueTypes && !opValueTypes.includes(valueType)) {
        meta.warnings.push("Operator \"".concat(opKey, "\" supports value types [").concat(opValueTypes.join(", "), "] but got ").concat(valueType));
      }
      if ((opValueTypes === null || opValueTypes === void 0 ? void 0 : opValueTypes.length) === 1) {
        valueType = opValueTypes[0];
      }
      if (valueType && (v === null || v === void 0 ? void 0 : v.valueSrc) === "value") {
        finalVal = checkSimpleValueType(finalVal, valueType);
      }
      properties.valueType[i] = valueType;
      properties.value[i] = finalVal;
      if (v !== null && v !== void 0 && v.valueError) {
        properties.valueError[i] = v.valueError;
      }
    }
  });
  return {
    type: "rule",
    properties: properties
  };
};
var convertArg = function convertArg(logic, conv, config, meta, parentLogic) {
  var fieldSeparator = config.settings.fieldSeparator;
  if (logic !== null && logic !== void 0 && logic.valueType) {
    var sqlType = logic === null || logic === void 0 ? void 0 : logic.valueType;
    var valueType = SqlPrimitiveTypes[sqlType];
    var _maybeValueType;
    if (!valueType) {
      meta.warnings.push("Unexpected value type ".concat(sqlType));
    }
    var value = logic.value; // todo: convert ?
    if (valueType === "text") {
      // fix issues with date/time values
      if (value.match(/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}/)) {
        _maybeValueType = "datetime";
      }
      if (value.match(/^\d{4}-\d{2}-\d{2}$/)) {
        _maybeValueType = "date";
      }
      valueType = undefined;
    }
    return {
      valueSrc: "value",
      valueType: valueType,
      _maybeValueType: _maybeValueType,
      value: value
    };
  } else if (logic !== null && logic !== void 0 && logic.field) {
    var field = [logic.table, logic.field].filter(function (v) {
      return !!v;
    }).join(fieldSeparator);
    var _iterator2 = _createForOfIteratorHelper(Utils.ConfigUtils.iterateFields(config)),
      _step2;
    try {
      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
        var _step2$value = _slicedToArray(_step2.value, 3),
          fieldPath = _step2$value[0],
          _fieldConfig = _step2$value[1],
          fieldKey = _step2$value[2];
        if (_fieldConfig.tableName === logic.table && fieldKey === logic.field) {
          field = fieldPath;
          break;
        }
      }
    } catch (err) {
      _iterator2.e(err);
    } finally {
      _iterator2.f();
    }
    var fieldConfig = Utils.ConfigUtils.getFieldConfig(config, field);
    var _valueType = fieldConfig === null || fieldConfig === void 0 ? void 0 : fieldConfig.type;
    return {
      valueSrc: "field",
      valueType: _valueType,
      value: field
    };
  } else if (logic !== null && logic !== void 0 && logic.children && logic._type === "expr_list") {
    return {
      valueSrc: "value",
      valueType: "multiselect",
      value: logic.values
    };
  } else if (logic !== null && logic !== void 0 && logic.value) {
    var _value = logic.value; // todo: convert ?
    return {
      valueSrc: "value",
      value: _value
    };
  } else {
    var maybeFunc = convertValueFunc(logic, conv, config, meta, parentLogic) || convertFunc(logic, conv, config, meta, parentLogic);
    if (maybeFunc) {
      return maybeFunc;
    }
  }
  meta.errors.push("Unexpected arg: ".concat(getLogicDescr(logic)));
  return undefined;
};
var convertFuncArg = function convertFuncArg(logic, argConfig, conv, config, meta, parentLogic) {
  if (_typeof(logic) === "object" && logic !== null && !Array.isArray(logic)) {
    return convertArg(logic, conv, config, meta, parentLogic);
  }
  return {
    valueSrc: "value",
    value: logic
    //valueType: // todo: see SpelPrimitiveTypes[spel.type] or argConfig
  };
};

// `meta` should contain either `funcKey` or `opKey`
var useImportFunc = function useImportFunc(sqlImport, logic, conv, config, meta) {
  var parsed;
  var widgetConfig;
  if (meta.widgetKey) {
    widgetConfig = config.widgets[meta.widgetKey];
  }
  var args = [config.ctx, logic, widgetConfig, config.settings.sqlDialect];
  try {
    var _ref7;
    parsed = (_ref7 = sqlImport).call.apply(_ref7, args);
  } catch (_e) {
    // can't be parsed
  }
  if (parsed) {
    var _ref8, _parsed, _ref9, _ref10, _ref11, _meta$opKey, _parsed2, _parsed3;
    var funcKey = (_ref8 = (_parsed = parsed) === null || _parsed === void 0 ? void 0 : _parsed.func) !== null && _ref8 !== void 0 ? _ref8 : meta.funcKey;
    var sqlFunc = logic === null || logic === void 0 ? void 0 : logic.func;
    var parseKey = (_ref9 = (_ref10 = (_ref11 = (_meta$opKey = meta.opKey) !== null && _meta$opKey !== void 0 ? _meta$opKey : meta.funcKey) !== null && _ref11 !== void 0 ? _ref11 : meta.widgetKey) !== null && _ref10 !== void 0 ? _ref10 : meta.outType) !== null && _ref9 !== void 0 ? _ref9 : "?";
    if ((_parsed2 = parsed) !== null && _parsed2 !== void 0 && _parsed2.children) {
      var _parsed$operator, _children;
      return {
        operator: (_parsed$operator = parsed.operator) !== null && _parsed$operator !== void 0 ? _parsed$operator : meta.opKey,
        children: (_children = parsed.children) === null || _children === void 0 ? void 0 : _children.map(function (ch) {
          return convertArg(ch, conv, config, meta, logic);
        }),
        operatorOptions: parsed.operatorOptions
      };
    } else if ((_parsed3 = parsed) !== null && _parsed3 !== void 0 && _parsed3.args) {
      var funcConfig = Utils.ConfigUtils.getFuncConfig(config, funcKey);
      var _args = {};
      for (var argKey in parsed.args) {
        var argLogic = parsed.args[argKey];
        var argConfig = funcConfig === null || funcConfig === void 0 ? void 0 : funcConfig.args[argKey];
        _args[argKey] = convertFuncArg(argLogic, argConfig, conv, config, meta, logic);
      }
      return {
        func: funcKey,
        funcConfig: funcConfig,
        args: _args
      };
    } else if (Object.keys(parsed).includes("value")) {
      var _widgetConfig;
      var _parsed4 = parsed,
        value = _parsed4.value,
        error = _parsed4.error;
      if (error) {
        meta.errors.push("Error while parsing ".concat(parseKey, " with func ").concat(sqlFunc !== null && sqlFunc !== void 0 ? sqlFunc : "?", ": ").concat(error));
      }
      return {
        value: value,
        valueType: (_widgetConfig = widgetConfig) === null || _widgetConfig === void 0 ? void 0 : _widgetConfig.type,
        valueSrc: "value",
        valueError: error
      };
    } else {
      meta.errors.push("Result of parsing as ".concat(parseKey, " should contain either 'children' or 'args' or 'value'"));
    }
  }
  return undefined;
};
var convertOpFunc = function convertOpFunc(logic, conv, config, meta, parentLogic) {
  for (var opKey in conv.opFuncs) {
    var _iterator3 = _createForOfIteratorHelper(conv.opFuncs[opKey]),
      _step3;
    try {
      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
        var f = _step3.value;
        var parsed = useImportFunc(f, logic, conv, config, _objectSpread(_objectSpread({}, meta), {}, {
          opKey: opKey,
          outType: "op"
        }));
        if (parsed) {
          return parsed;
        }
      }
    } catch (err) {
      _iterator3.e(err);
    } finally {
      _iterator3.f();
    }
  }
  return undefined;
};
var convertValueFunc = function convertValueFunc(logic, conv, config, meta, parentLogic) {
  for (var widgetKey in conv.valueFuncs) {
    var _iterator4 = _createForOfIteratorHelper(conv.valueFuncs[widgetKey]),
      _step4;
    try {
      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
        var f = _step4.value;
        var parsed = useImportFunc(f, logic, conv, config, _objectSpread(_objectSpread({}, meta), {}, {
          outType: "value",
          widgetKey: widgetKey
        }));
        if (parsed) {
          return parsed;
        }
      }
    } catch (err) {
      _iterator4.e(err);
    } finally {
      _iterator4.f();
    }
  }
  return undefined;
};
var convertFunc = function convertFunc(logic, conv, config, meta, parentLogic) {
  var funcKey, argsObj, funcConfig;
  var _iterator5 = _createForOfIteratorHelper(Utils.ConfigUtils.iterateFuncs(config)),
    _step5;
  try {
    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
      var _step5$value = _slicedToArray(_step5.value, 2),
        f = _step5$value[0],
        fc = _step5$value[1];
      var sqlFunc = fc.sqlFunc,
        sqlImport = fc.sqlImport;
      if (sqlImport) {
        var parsed = useImportFunc(sqlImport, logic, conv, config, _objectSpread(_objectSpread({}, meta), {}, {
          funcKey: f,
          outType: "func"
        }));
        if (parsed) {
          funcKey = parsed.func;
          funcConfig = parsed.funcConfig;
          argsObj = parsed.args;

          // Special case to distinct date and datetime
          var isOk = true;
          if (funcConfig) {
            var funcType = funcConfig.returnType;
            if (["date", "datetime"].includes(funcType)) {
              var _funcConfig$args;
              if (logic !== null && logic !== void 0 && logic._type && ["date", "datetime"].includes(logic._type) && logic._type !== funcType) {
                isOk = false;
              }
              var dateArgsKeys = Object.keys((_funcConfig$args = funcConfig.args) !== null && _funcConfig$args !== void 0 ? _funcConfig$args : []).filter(function (k) {
                return ["date", "datetime"].includes(funcConfig.args[k].type);
              });
              var _iterator6 = _createForOfIteratorHelper(dateArgsKeys),
                _step6;
              try {
                for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
                  var _argsObj$k;
                  var k = _step6.value;
                  var _argConfig = funcConfig.args[k];
                  var expectedType = _argConfig.type;
                  var realType = (_argsObj$k = argsObj[k]) === null || _argsObj$k === void 0 ? void 0 : _argsObj$k.valueType;
                  if (realType && realType != expectedType) {
                    isOk = false;
                  }
                }
              } catch (err) {
                _iterator6.e(err);
              } finally {
                _iterator6.f();
              }
            }
          }
          if (isOk) {
            break;
          }
        }
      }
      if (sqlFunc && sqlFunc === (logic === null || logic === void 0 ? void 0 : logic.func)) {
        funcKey = f;
        funcConfig = Utils.ConfigUtils.getFuncConfig(config, funcKey);
        var _funcType = funcConfig.returnType;
        argsObj = {};
        var argIndex = 0;
        for (var _argKey in funcConfig.args) {
          var _logic$children, _funcConfig2;
          var argLogic = (_logic$children = logic.children) === null || _logic$children === void 0 ? void 0 : _logic$children[argIndex];
          var _argConfig2 = (_funcConfig2 = funcConfig) === null || _funcConfig2 === void 0 ? void 0 : _funcConfig2.args[_argKey];
          argsObj[_argKey] = convertFuncArg(argLogic, _argConfig2, conv, config, meta, logic);
          argIndex++;
        }
        // Special case to distinct date and datetime for args of function
        var _isOk = true;
        if (["date", "datetime"].includes(_funcType)) {
          if (parentLogic !== null && parentLogic !== void 0 && parentLogic.func && parentLogic !== null && parentLogic !== void 0 && parentLogic._type && ["date", "datetime"].includes(parentLogic._type)) {
            var expectedFuncType = parentLogic._type;
            if (expectedFuncType != _funcType) {
              _isOk = false;
            }
          }
        }
        if (_isOk) {
          break;
        }
      }
    }
  } catch (err) {
    _iterator5.e(err);
  } finally {
    _iterator5.f();
  }
  if (funcKey) {
    var funcArgs = {};
    for (var argKey in (_funcConfig = funcConfig) === null || _funcConfig === void 0 ? void 0 : _funcConfig.args) {
      var _funcConfig, _argsObj;
      var argConfig = funcConfig.args[argKey];
      var argVal = (_argsObj = argsObj) === null || _argsObj === void 0 ? void 0 : _argsObj[argKey];
      if (argVal === undefined) {
        argVal = argConfig === null || argConfig === void 0 ? void 0 : argConfig.defaultValue;
        if (argVal === undefined) {
          if (argConfig !== null && argConfig !== void 0 && argConfig.isOptional) {
            //ignore
          } else {
            meta.errors.push("No value for arg ".concat(argKey, " of func ").concat(funcKey));
            return undefined;
          }
        } else {
          argVal = {
            value: argVal,
            valueSrc: argVal["func"] ? "func" : "value",
            valueType: argConfig.type
          };
        }
      }
      if (argVal) funcArgs[argKey] = argVal;
    }
    return {
      valueSrc: "func",
      value: {
        func: funcKey,
        args: funcArgs
      },
      valueType: funcConfig.returnType
    };
  } else {
    meta.errors.push("Unexpected func: ".concat(getLogicDescr(logic)));
    return undefined;
  }
};
var wrapInDefaultConj = function wrapInDefaultConj(rule, config) {
  var not = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  return {
    type: "group",
    id: Utils.uuid(),
    children1: [rule],
    properties: {
      conjunction: Utils.DefaultUtils.defaultConjunction(config),
      not: not || false
    }
  };
};
var checkSimpleValueType = function checkSimpleValueType(val, valueType) {
  var _val;
  if (val != null && ((_val = val) === null || _val === void 0 ? void 0 : _val.func) === undefined) {
    var _val2;
    if (valueType === "text") {
      val = "" + val;
    } else if (valueType === "multiselect" && ((_val2 = val) === null || _val2 === void 0 ? void 0 : _val2.map) === undefined) {
      val = [val];
    }
  }
  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
  return val;
};