@atlaskit/link-datasource 1.12.4 → 1.13.1

package/dist/es2019/ui/jira-issues-modal/mode-switcher/index.js

@@ -1,7 +1,9 @@
+import _extends from "@babel/runtime/helpers/extends";
 /** @jsx jsx */
 import React from 'react';
 import { css, jsx } from '@emotion/react';
-import { N0, N20, N30A, N700 } from '@atlaskit/theme/colors';
+import { N0, N20, N30A, N60, N700 } from '@atlaskit/theme/colors';
+import Tooltip from '@atlaskit/tooltip';
 const modeSwitcherStyles = css({
   alignItems: 'center',
   background: `var(--ds-background-neutral, ${N20})`,
@@ -44,8 +46,12 @@ const modeSwitcherLabelSelectedStyles = css({
   }
 });
 const modeSwitcherLabelDisabledStyles = css({
+  color: `var(--ds-text-disabled, ${N60})`
+});
+const modeSwitcherDisabledStyles = css({
   ':hover': {
-    cursor: 'not-allowed'
+    cursor: 'not-allowed',
+    background: 'transparent'
   }
 });
 const compactModeSwitcherLabelStyles = css({
@@ -69,22 +75,26 @@ export const ModeSwitcher = props => {
     disabled: isDisabled
   }, options.map(({
     value,
-    label
+    label,
+    disabled: isOptionDisabled,
+    tooltipText
   }) => {
     const isSelected = value === selectedOptionValue;
-    return jsx("label", {
+    return jsx(Tooltip, {
+      content: tooltipText
+    }, tooltipProps => jsx("label", _extends({}, tooltipProps, {
       key: value,
-      css: [modeSwitcherLabelStyles, isCompact && compactModeSwitcherLabelStyles, isSelected && modeSwitcherLabelSelectedStyles, isDisabled && modeSwitcherLabelDisabledStyles],
+      css: [modeSwitcherLabelStyles, isCompact && compactModeSwitcherLabelStyles, isSelected && modeSwitcherLabelSelectedStyles, isDisabled && modeSwitcherDisabledStyles, isOptionDisabled && [modeSwitcherLabelDisabledStyles, modeSwitcherDisabledStyles]],
       "data-testid": `mode-toggle-${value}`
-    }, label, jsx("input", {
+    }), label, jsx("input", {
       "aria-checked": isSelected,
-      "aria-disabled": isDisabled,
+      "aria-disabled": isOptionDisabled,
       checked: isSelected,
       css: modeInputStyles,
-      disabled: isDisabled,
+      disabled: isOptionDisabled,
       onChange: handleModeChange,
       type: "radio",
       value: value
-    }));
+    })));
   })) : null;
 };

package/dist/esm/analytics/constants.js

@@ -1,5 +1,5 @@
 export var EVENT_CHANNEL = 'media';
 export var packageMetaData = {
   packageName: "@atlaskit/link-datasource",
-  packageVersion: "1.12.4"
+  packageVersion: "1.13.1"
 };

package/dist/esm/ui/jira-issues-modal/basic-filters/hooks/useFilterOptions.js

@@ -2,7 +2,7 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-import { useCallback, useState } from 'react';
+import { useCallback, useRef, useState } from 'react';
 import { useBasicFilterAGG } from '../../../../services/useBasicFilterAGG';
 import { mapFieldValuesToFilterOptions, mapFieldValuesToPageCursor, mapFieldValuesToTotalCount } from '../utils/transformers';
 export var useFilterOptions = function useFilterOptions(_ref) {
@@ -24,12 +24,15 @@ export var useFilterOptions = function useFilterOptions(_ref) {
     _useState8 = _slicedToArray(_useState7, 2),
     nextPageCursor = _useState8[0],
     setNextPageCursor = _useState8[1];
+  var initialData = useRef();
   var _useBasicFilterAGG = useBasicFilterAGG(),
     getFieldValues = _useBasicFilterAGG.getFieldValues;
   var fetchFilterOptions = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
     var _ref3,
       pageCursor,
       searchString,
+      isRequestLikeInitialSearch,
+      initialResponseData,
       response,
       isNewSearch,
       _args = arguments;
@@ -38,8 +41,18 @@ export var useFilterOptions = function useFilterOptions(_ref) {
         case 0:
           _ref3 = _args.length > 0 && _args[0] !== undefined ? _args[0] : {}, pageCursor = _ref3.pageCursor, searchString = _ref3.searchString;
           setStatus('loading');
-          _context.prev = 2;
-          _context.next = 5;
+          isRequestLikeInitialSearch = !pageCursor && !searchString;
+          initialResponseData = initialData.current;
+          _context.prev = 4;
+          if (!(isRequestLikeInitialSearch && initialResponseData)) {
+            _context.next = 9;
+            break;
+          }
+          _context.t0 = initialResponseData;
+          _context.next = 12;
+          break;
+        case 9:
+          _context.next = 11;
           return getFieldValues({
             cloudId: cloudId,
             jql: '',
@@ -47,35 +60,44 @@ export var useFilterOptions = function useFilterOptions(_ref) {
             searchString: searchString,
             pageCursor: pageCursor
           });
-        case 5:
-          response = _context.sent;
+        case 11:
+          _context.t0 = _context.sent;
+        case 12:
+          response = _context.t0;
           if (!(response.errors && response.errors.length > 0)) {
-            _context.next = 9;
+            _context.next = 16;
             break;
           }
           setStatus('rejected');
           return _context.abrupt("return");
-        case 9:
+        case 16:
           isNewSearch = !pageCursor;
           if (isNewSearch) {
             setFilterOptions(mapFieldValuesToFilterOptions(response));
+            if (isRequestLikeInitialSearch) {
+              /**
+               * The initial dataset is used in couple of paths, eg: when a user searches and clears the search text.
+               * During these times, we dont want to fetch data again and again, hence a mini cache setup to store and provide the initial dataset
+               */
+              initialData.current = response;
+            }
           } else {
             setFilterOptions([].concat(_toConsumableArray(filterOptions), _toConsumableArray(mapFieldValuesToFilterOptions(response))));
           }
           setTotalCount(mapFieldValuesToTotalCount(response));
           setNextPageCursor(mapFieldValuesToPageCursor(response));
           setStatus('resolved');
-          _context.next = 19;
+          _context.next = 26;
           break;
-        case 16:
-          _context.prev = 16;
-          _context.t0 = _context["catch"](2);
+        case 23:
+          _context.prev = 23;
+          _context.t1 = _context["catch"](4);
           setStatus('rejected');
-        case 19:
+        case 26:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[2, 16]]);
+    }, _callee, null, [[4, 23]]);
   })), [cloudId, filterOptions, filterType, getFieldValues]);
   return {
     filterOptions: filterOptions,

package/dist/esm/ui/jira-issues-modal/basic-filters/ui/async-popup-select/dropdownIndicator.js

@@ -0,0 +1,32 @@
+import React from 'react';
+import CloseIcon from '@atlaskit/icon/glyph/cross-circle';
+import SearchIcon from '@atlaskit/icon/glyph/search';
+import { Box, xcss } from '@atlaskit/primitives';
+import { components } from '@atlaskit/select';
+var customDropdownIndicatorStyles = xcss({
+  display: 'flex',
+  cursor: 'pointer',
+  justifyContent: 'center',
+  width: "var(--ds-space-400, 32px)"
+});
+var CustomDropdownIndicator = function CustomDropdownIndicator(props) {
+  var selectProps = props.selectProps;
+  return /*#__PURE__*/React.createElement(components.DropdownIndicator, props, /*#__PURE__*/React.createElement(Box, {
+    xcss: customDropdownIndicatorStyles,
+    onClick: function onClick() {
+      if (selectProps.inputValue) {
+        selectProps.onInputChange && selectProps.onInputChange('', {
+          action: 'input-change',
+          prevInputValue: selectProps.inputValue
+        });
+      }
+    }
+  }, selectProps.inputValue ? /*#__PURE__*/React.createElement(CloseIcon, {
+    size: "small",
+    label: ""
+  }) : /*#__PURE__*/React.createElement(SearchIcon, {
+    size: "small",
+    label: ""
+  })));
+};
+export default CustomDropdownIndicator;

package/dist/esm/ui/jira-issues-modal/basic-filters/ui/async-popup-select/index.js

@@ -4,11 +4,13 @@ import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 var _excluded = ["isOpen"];
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-import React, { useCallback, useEffect, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import debounce from 'lodash/debounce';
 import { useIntl } from 'react-intl-next';
 import { CheckboxOption, PopupSelect } from '@atlaskit/select';
 import { useFilterOptions } from '../../hooks/useFilterOptions';
 import CustomControl from './control';
+import CustomDropdownIndicator from './dropdownIndicator';
 import PopupFooter from './footer';
 import formatOptionLabel from './formatOptionLabel';
 import { asyncPopupSelectMessages } from './messages';
@@ -17,12 +19,15 @@ import PopupTrigger from './trigger';
 var noFilterOptions = function noFilterOptions() {
   return true;
 };
+var SEARCH_DEBOUNCE_MS = 350;
 var AsyncPopupSelect = function AsyncPopupSelect(_ref) {
   var filterType = _ref.filterType,
     cloudId = _ref.cloudId,
     selection = _ref.selection,
     _ref$onSelectionChang = _ref.onSelectionChange,
-    onSelectionChange = _ref$onSelectionChang === void 0 ? function () {} : _ref$onSelectionChang;
+    onSelectionChange = _ref$onSelectionChang === void 0 ? function () {} : _ref$onSelectionChang,
+    _ref$isDisabled = _ref.isDisabled,
+    isDisabled = _ref$isDisabled === void 0 ? false : _ref$isDisabled;
   var _useIntl = useIntl(),
     formatMessage = _useIntl.formatMessage;
   var pickerRef = useRef(null);
@@ -42,30 +47,49 @@ var AsyncPopupSelect = function AsyncPopupSelect(_ref) {
     fetchFilterOptions = _useFilterOptions.fetchFilterOptions,
     totalCount = _useFilterOptions.totalCount,
     status = _useFilterOptions.status;
-  var handleInputChange = useCallback(function (searchString, actionMeta) {
-    if (actionMeta.action === 'input-change' && searchString !== searchTerm) {
-      setSearchTerm(searchString);
-    }
-  }, [searchTerm]);
+  var handleDebouncedFetchFilterOptions = useMemo(function () {
+    return debounce(fetchFilterOptions, SEARCH_DEBOUNCE_MS);
+  }, [fetchFilterOptions]);
+  var handleInputChange = useCallback( /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(newSearchTerm, actionMeta) {
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (actionMeta.action === 'input-change' && newSearchTerm !== searchTerm) {
+              setSearchTerm(newSearchTerm);
+              handleDebouncedFetchFilterOptions({
+                searchString: newSearchTerm
+              });
+            }
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x, _x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }(), [handleDebouncedFetchFilterOptions, searchTerm]);
   var handleOptionSelection = function handleOptionSelection(newValue) {
     setSelectedOptions(newValue);
     onSelectionChange(newValue);
   };
-  var handleOpenPopup = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-    return _regeneratorRuntime.wrap(function _callee$(_context) {
-      while (1) switch (_context.prev = _context.next) {
+  var handleOpenPopup = useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
         case 0:
           if (!(status === 'empty')) {
-            _context.next = 3;
+            _context2.next = 3;
             break;
           }
-          _context.next = 3;
+          _context2.next = 3;
           return fetchFilterOptions();
         case 3:
         case "end":
-          return _context.stop();
+          return _context2.stop();
       }
-    }, _callee);
+    }, _callee2);
   })), [fetchFilterOptions, status]);
   useEffect(function () {
     if (status === 'resolved') {
@@ -75,6 +99,9 @@ var AsyncPopupSelect = function AsyncPopupSelect(_ref) {
     }
   }, [status]);
   var isLoading = status === 'loading' || status === 'empty';
+  var shouldShowFooter = status === 'resolved' && filterOptions.length > 0;
+  var options = isLoading ? [] : filterOptions; // if not set to [], then on loading, no loading UI will be shown
+
   return /*#__PURE__*/React.createElement(PopupSelect, {
     isMulti: true,
     maxMenuWidth: 300,
@@ -96,24 +123,28 @@ var AsyncPopupSelect = function AsyncPopupSelect(_ref) {
     components: {
       /* @ts-expect-error - This component has stricter OptionType, hence a temp setup untill its made generic */
       Option: CheckboxOption,
-      Control: CustomControl
+      Control: CustomControl,
+      LoadingIndicator: undefined,
+      // disables the three ... indicator in the searchbox when picker is loading
+      DropdownIndicator: CustomDropdownIndicator
     },
-    options: filterOptions,
+    options: options,
     value: selectedOptions,
     filterOption: noFilterOptions,
     formatOptionLabel: formatOptionLabel,
     onChange: handleOptionSelection,
     onInputChange: handleInputChange,
-    target: function target(_ref3) {
-      var isOpen = _ref3.isOpen,
-        triggerProps = _objectWithoutProperties(_ref3, _excluded);
+    target: function target(_ref4) {
+      var isOpen = _ref4.isOpen,
+        triggerProps = _objectWithoutProperties(_ref4, _excluded);
       return /*#__PURE__*/React.createElement(PopupTrigger, _extends({}, triggerProps, {
         filterType: filterType,
         isSelected: isOpen,
-        onClick: handleOpenPopup
+        onClick: handleOpenPopup,
+        isDisabled: isDisabled
       }));
     },
-    footer: /*#__PURE__*/React.createElement(PopupFooter, {
+    footer: shouldShowFooter && /*#__PURE__*/React.createElement(PopupFooter, {
       currentDisplayCount: filterOptions.length,
       totalCount: totalCount
     })

package/dist/esm/ui/jira-issues-modal/basic-filters/ui/async-popup-select/trigger.js

@@ -6,11 +6,13 @@ import { asyncPopupSelectMessages } from './messages';
 var PopupTrigger = /*#__PURE__*/forwardRef(function (_ref, ref) {
   var filterType = _ref.filterType,
     isSelected = _ref.isSelected,
+    isDisabled = _ref.isDisabled,
     onClick = _ref.onClick;
   return /*#__PURE__*/React.createElement(Button, {
     ref: ref,
     appearance: "default",
     isSelected: isSelected,
+    isDisabled: isDisabled,
     onClick: onClick,
     testId: "jlol-basic-filter-".concat(filterType, "-trigger"),
     iconAfter: /*#__PURE__*/React.createElement(ChevronDownIcon, {

package/dist/esm/ui/jira-issues-modal/basic-filters/ui/index.js

@@ -25,6 +25,7 @@ var BasicFilterContainer = function BasicFilterContainer(_ref) {
       filterType: filter,
       key: filter,
       selection: selection,
+      isDisabled: !cloudId,
       onSelectionChange: handleSelectionChange
     });
   }));

package/dist/esm/ui/jira-issues-modal/basic-filters/utils/isClauseTooComplex.js

@@ -0,0 +1,86 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { CLAUSE_TYPE_COMPOUND, CLAUSE_TYPE_TERMINAL, OPERAND_TYPE_VALUE } from '@atlaskit/jql-ast';
+import { fuzzyCharacter } from '../../jira-search-container/buildJQL';
+var removeFuzzyCharacter = function removeFuzzyCharacter(value) {
+  if (value !== null && value !== void 0 && value.endsWith(fuzzyCharacter)) {
+    return value.slice(0, -1);
+  }
+  return value;
+};
+var getValueFromTerminalClause = function getValueFromTerminalClause(clause) {
+  var operand = clause.operand;
+  return operand !== undefined && operand.operandType === OPERAND_TYPE_VALUE && removeFuzzyCharacter(operand.value) || undefined;
+};
+var areClauseFieldValuesEqual = function areClauseFieldValuesEqual(clauseA, clauseB, clauseC) {
+  var valueA = clauseA && getValueFromTerminalClause(clauseA);
+  var valueB = clauseB && getValueFromTerminalClause(clauseB);
+  var valueC = clauseC && getValueFromTerminalClause(clauseC);
+  var values = [valueA, valueB, valueC].filter(Boolean);
+
+  // checks if valid fields, text, summary and key have the same value, if not, its a complex query and cannnot be recreated in basic mode
+  return values.length > 1 && values.every(function (value) {
+    return value === values[0];
+  });
+};
+var areClauseFieldKeysAllowed = function areClauseFieldKeysAllowed(clauseA, clauseB, clauseC) {
+  var fieldA = clauseA.field.value;
+  var fieldB = clauseB.field.value;
+  var fieldC = clauseC === null || clauseC === void 0 ? void 0 : clauseC.field.value; // clauseC only if jql with 3 OR clauses, 'text ~ "EDM-6023*" or summary ~ "EDM-6023*" or key = EDM-6023 ORDER BY created DESC',
+
+  return [fieldA, fieldB, fieldC].filter(Boolean).every(function (field) {
+    return ['summary', 'text', 'key'].includes(field);
+  });
+};
+var doesCompoundClauseContainAllTerminalClauses = function doesCompoundClauseContainAllTerminalClauses(clauses) {
+  return clauses.every(function (clauses) {
+    return clauses.clauseType === CLAUSE_TYPE_TERMINAL;
+  });
+};
+export var isClauseTooComplex = function isClauseTooComplex(clauses, key) {
+  if (key === 'text') {
+    var _clauses = _slicedToArray(clauses, 1),
+      clause = _clauses[0];
+    if (clause.clauseType === CLAUSE_TYPE_COMPOUND) {
+      var textClauses = clause.clauses;
+
+      /**
+       * valid: text ~ "test*" or summary ~ "test*" ORDER BY created DESC
+       * valid: text ~ "EDM-6023*" or summary ~ "EDM-6023*" or key = EDM-6023 ORDER BY created DESC
+       * invalid: assignee = "me" or text ~ "EDM-6023*" or summary ~ "EDM-6023*" or key = EDM-6023 ORDER BY created DESC
+       */
+      if (textClauses.length !== 2 && textClauses.length !== 3) {
+        return true;
+      }
+
+      /**
+       * valid: text ~ "test*" or summary ~ "test*"
+       * invalid: text ~ "test" or (summary ~ "test" or key = "test")
+       */
+      if (!doesCompoundClauseContainAllTerminalClauses(textClauses)) {
+        return true;
+      }
+      var _textClauses = _slicedToArray(textClauses, 3),
+        clauseA = _textClauses[0],
+        clauseB = _textClauses[1],
+        clauseC = _textClauses[2];
+
+      /**
+       * valid: text ~ "EDM-6023*" or summary ~ "EDM-6023*" or key = EDM-6023 ORDER BY created DESC
+       * invalid: text ~ "EDM-6023*" or summary ~ "anotherValue" ORDER BY created DESC
+       * invalid: text ~ "EDM-6023*" or text ~ "anotherValue" ORDER BY created DESC
+       */
+      if (!areClauseFieldValuesEqual(clauseA, clauseB, clauseC)) {
+        return true;
+      }
+
+      /**
+       * valid: text ~ "EDM-6023*" ORDER BY created DESC
+       * invalid: resolution = 40134 ORDER BY created DESC
+       */
+      if (!areClauseFieldKeysAllowed(clauseA, clauseB, clauseC)) {
+        return true;
+      }
+    }
+  }
+  return clauses.length > 1;
+};

package/dist/esm/ui/jira-issues-modal/basic-filters/utils/isQueryTooComplex.js

@@ -0,0 +1,140 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _assertThisInitialized from "@babel/runtime/helpers/assertThisInitialized";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+import mergeWith from 'lodash/mergeWith';
+import { AbstractJastVisitor, COMPOUND_OPERATOR_AND, COMPOUND_OPERATOR_OR, JastBuilder, OPERATOR_EQUALS, OPERATOR_GT_EQUALS, OPERATOR_IN, OPERATOR_LIKE } from '@atlaskit/jql-ast';
+import { getBooleanFF } from '@atlaskit/platform-feature-flags';
+import { ALLOWED_ORDER_BY_KEYS } from '../../jira-search-container';
+import { isClauseTooComplex } from './isClauseTooComplex';
+import { isValidJql } from './index';
+
+// Map of field keys to their respective clauses in the Jast
+
+var allowedFields = [
+// basic filter fields
+'assignee', 'issuetype', 'project', 'status',
+// search input fields
+'text', 'summary', 'key',
+// orderby field
+'created'];
+var fallbackOperators = [OPERATOR_IN];
+var fieldSpecificOperators = {
+  text: [OPERATOR_LIKE, OPERATOR_EQUALS],
+  summary: [OPERATOR_LIKE, OPERATOR_EQUALS],
+  key: [OPERATOR_EQUALS],
+  created: [OPERATOR_GT_EQUALS],
+  project: [OPERATOR_IN, OPERATOR_EQUALS],
+  issuetype: [OPERATOR_IN, OPERATOR_EQUALS],
+  status: [OPERATOR_IN, OPERATOR_EQUALS],
+  assignee: [OPERATOR_IN, OPERATOR_EQUALS]
+};
+var JqlClauseCollectingVisitorError = /*#__PURE__*/function (_Error) {
+  _inherits(JqlClauseCollectingVisitorError, _Error);
+  var _super = _createSuper(JqlClauseCollectingVisitorError);
+  function JqlClauseCollectingVisitorError() {
+    _classCallCheck(this, JqlClauseCollectingVisitorError);
+    return _super.apply(this, arguments);
+  }
+  return _createClass(JqlClauseCollectingVisitorError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+/**
+ * Rather than having to navigate the entire tree structure ourself, we extend AbstractJastVisitor
+ * class and implement visitor functions for node types that we wish to process.
+ * A list of available visitor can be viewed in packages/jql/jql-ast/src/types/api/jast-visitor.ts
+ * more info - https://atlaskit.atlassian.com/packages/jql/jql-ast/docs/traversing-the-ast
+ * */
+var JqlClauseCollectingVisitor = /*#__PURE__*/function (_AbstractJastVisitor) {
+  _inherits(JqlClauseCollectingVisitor, _AbstractJastVisitor);
+  var _super2 = _createSuper(JqlClauseCollectingVisitor);
+  function JqlClauseCollectingVisitor() {
+    var _this;
+    _classCallCheck(this, JqlClauseCollectingVisitor);
+    _this = _super2.call(this);
+    _defineProperty(_assertThisInitialized(_this), "visitNotClause", function () {
+      throw new JqlClauseCollectingVisitorError('Visited an unsupported node while traversing the AST');
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitOrderByField", function (orderByField) {
+      var _orderByField$field$v;
+      var fieldValue = (_orderByField$field$v = orderByField.field.value) === null || _orderByField$field$v === void 0 ? void 0 : _orderByField$field$v.toLowerCase();
+      if (fieldValue && !ALLOWED_ORDER_BY_KEYS.includes(fieldValue)) {
+        throw new JqlClauseCollectingVisitorError("query with order by field '".concat(fieldValue, "' is not supported"));
+      }
+      return {};
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitCompoundClause", function (compoundClause) {
+      var clauseMap = {};
+      var operator = compoundClause.operator.value;
+      if (operator === COMPOUND_OPERATOR_AND) {
+        return compoundClause.clauses.reduce(function (result, clause) {
+          return _this.aggregateResult(clause.accept(_assertThisInitialized(_this)), result);
+        }, clauseMap);
+      }
+      if (operator === COMPOUND_OPERATOR_OR) {
+        // this is delt with in isClauseTooComplex
+        return _this.aggregateResult({
+          text: [compoundClause]
+        }, clauseMap);
+      }
+      throw new JqlClauseCollectingVisitorError("Compound clauses using the operator '".concat(operator, "' is not supported"));
+    });
+    _defineProperty(_assertThisInitialized(_this), "visitTerminalClause", function (terminalClause) {
+      var _terminalClause$opera;
+      var fieldName = terminalClause.field.value.toLowerCase();
+      if (!allowedFields.includes(fieldName)) {
+        throw new JqlClauseCollectingVisitorError("Field with name '".concat(fieldName, "' of type ").concat(terminalClause.clauseType, " is not supported"));
+      }
+      var operator = (_terminalClause$opera = terminalClause.operator) === null || _terminalClause$opera === void 0 ? void 0 : _terminalClause$opera.value;
+      var allowedOperators = fieldSpecificOperators[fieldName] || fallbackOperators;
+      if (operator && !allowedOperators.includes(operator.toLowerCase())) {
+        throw new JqlClauseCollectingVisitorError("Field with name '".concat(fieldName, "' using operator ").concat(operator, " is not supported"));
+      }
+      return _defineProperty({}, terminalClause.field.value.toLowerCase(), [terminalClause]);
+    });
+    return _this;
+  }
+  _createClass(JqlClauseCollectingVisitor, [{
+    key: "aggregateResult",
+    value: function aggregateResult(aggregate, nextResult) {
+      return mergeWith(aggregate, nextResult, function (destValue, srcValue) {
+        return srcValue.concat(destValue !== null && destValue !== void 0 ? destValue : []);
+      });
+    }
+  }, {
+    key: "defaultResult",
+    value: function defaultResult() {
+      return {};
+    }
+  }]);
+  return JqlClauseCollectingVisitor;
+}(AbstractJastVisitor);
+export var isQueryTooComplex = function isQueryTooComplex(jql) {
+  if (!getBooleanFF('platform.linking-platform.datasource.show-jlol-basic-filters') || !jql) {
+    return false;
+  }
+  if (!isValidJql(jql)) {
+    return true;
+  }
+  var jast = new JastBuilder().build(jql);
+  try {
+    var jqlClauseCollectingVisitor = new JqlClauseCollectingVisitor();
+    var clauseMap = jast.query ? jast.query.accept(jqlClauseCollectingVisitor) : {}; // jast.query is defined as void | Query, hence the fallback
+
+    var hasAnyKeyWithComplexClause = Object.entries(clauseMap).some(function (_ref2) {
+      var _ref3 = _slicedToArray(_ref2, 2),
+        key = _ref3[0],
+        clauses = _ref3[1];
+      return isClauseTooComplex(clauses, key);
+    });
+    return hasAnyKeyWithComplexClause;
+  } catch (error) {
+    return true;
+  }
+};

package/dist/esm/ui/jira-issues-modal/jira-search-container/buildJQL.js

@@ -2,6 +2,7 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { COMPOUND_OPERATOR_AND, COMPOUND_OPERATOR_OR, creators, JastBuilder, OPERATOR_EQUALS, OPERATOR_GT_EQUALS, OPERATOR_IN, OPERATOR_LIKE, ORDER_BY_DIRECTION_ASC, ORDER_BY_DIRECTION_DESC, print } from '@atlaskit/jql-ast';
 var fuzzySearchRegExp = /^"(.+)"$/;
 var jiraIssueKeyRegExp = /[A-Z]+-\d+/;
+export var fuzzyCharacter = '*';
 var constructTerminalClause = function constructTerminalClause(field, operator, value) {
   return creators.terminalClause(creators.field(field), creators.operator(operator), creators.valueOperand(value));
 };
@@ -23,7 +24,7 @@ export var buildJQL = function buildJQL(input) {
     return '';
   }
   if (trimmedRawSearch) {
-    var fuzzy = !trimmedRawSearch.match(fuzzySearchRegExp) ? '*' : '';
+    var fuzzy = !trimmedRawSearch.match(fuzzySearchRegExp) ? fuzzyCharacter : '';
     var basicSearch = trimmedRawSearch.replace(/['"?*]+/g, '');
     var text = constructTerminalClause('text', OPERATOR_LIKE, "".concat(basicSearch).concat(fuzzy));
     var summary = constructTerminalClause('summary', OPERATOR_LIKE, "".concat(basicSearch).concat(fuzzy));