@atlaskit/link-datasource 1.12.3 → 1.13.0

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

@@ -7,7 +7,7 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { useIntl } from 'react-intl-next';
 import { CheckboxOption, PopupSelect } from '@atlaskit/select';
-import { useFieldValues } from '../../hooks/useFieldValues';
+import { useFilterOptions } from '../../hooks/useFilterOptions';
 import CustomControl from './control';
 import PopupFooter from './footer';
 import formatOptionLabel from './formatOptionLabel';
@@ -19,6 +19,7 @@ var noFilterOptions = function noFilterOptions() {
 };
 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;
@@ -33,13 +34,14 @@ var AsyncPopupSelect = function AsyncPopupSelect(_ref) {
     _useState4 = _slicedToArray(_useState3, 2),
     selectedOptions = _useState4[0],
     setSelectedOptions = _useState4[1];
-  var _useFieldValues = useFieldValues({
-      filterType: filterType
+  var _useFilterOptions = useFilterOptions({
+      filterType: filterType,
+      cloudId: cloudId
     }),
-    filterOptions = _useFieldValues.filterOptions,
-    fetchFilterOptions = _useFieldValues.fetchFilterOptions,
-    totalCount = _useFieldValues.totalCount,
-    status = _useFieldValues.status;
+    filterOptions = _useFilterOptions.filterOptions,
+    fetchFilterOptions = _useFilterOptions.fetchFilterOptions,
+    totalCount = _useFilterOptions.totalCount,
+    status = _useFilterOptions.status;
   var handleInputChange = useCallback(function (searchString, actionMeta) {
     if (actionMeta.action === 'input-change' && searchString !== searchTerm) {
       setSearchTerm(searchString);
@@ -53,10 +55,13 @@ var AsyncPopupSelect = function AsyncPopupSelect(_ref) {
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
-          if (status === 'empty') {
-            fetchFilterOptions();
+          if (!(status === 'empty')) {
+            _context.next = 3;
+            break;
           }
-        case 1:
+          _context.next = 3;
+          return fetchFilterOptions();
+        case 3:
         case "end":
           return _context.stop();
       }
@@ -69,18 +74,24 @@ var AsyncPopupSelect = function AsyncPopupSelect(_ref) {
       pickerRef === null || pickerRef === void 0 || (_pickerRef$current = pickerRef.current) === null || _pickerRef$current === void 0 || (_pickerRef$current = _pickerRef$current.selectRef) === null || _pickerRef$current === void 0 || (_pickerRef$current = _pickerRef$current.inputRef) === null || _pickerRef$current === void 0 || _pickerRef$current.focus();
     }
   }, [status]);
+  var isLoading = status === 'loading' || status === 'empty';
   return /*#__PURE__*/React.createElement(PopupSelect, {
     isMulti: true,
     maxMenuWidth: 300,
     minMenuWidth: 300,
     ref: pickerRef,
     testId: "jlol-basic-filter-popup-select",
-    inputId: "jlol-basic-filter-popup-select--input",
-    searchThreshold: 0,
+    inputId: "jlol-basic-filter-popup-select--input"
+    /*
+      this threshold controls the display of the search control (input field for search)
+      if this threshold is less than 0, when typing a search string that returns no results it will not remove the search control
+      if this threshold is 0 or higher, it will remove the search control when there are no results, the user will be unable to clear the search to see more results
+    */,
+    searchThreshold: -1,
     inputValue: searchTerm,
     closeMenuOnSelect: false,
     hideSelectedOptions: false,
-    isLoading: status === 'loading',
+    isLoading: isLoading,
     placeholder: formatMessage(asyncPopupSelectMessages.selectPlaceholder),
     components: {
       /* @ts-expect-error - This component has stricter OptionType, hence a temp setup untill its made generic */

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

@@ -5,7 +5,8 @@ import { isValidJql } from '../utils';
 import AsyncPopupSelect from './async-popup-select';
 var availableBasicFilterTypes = ['project', 'issuetype', 'status', 'assignee'];
 var BasicFilterContainer = function BasicFilterContainer(_ref) {
-  var jql = _ref.jql;
+  var jql = _ref.jql,
+    cloudId = _ref.cloudId;
   var _useState = useState([]),
     _useState2 = _slicedToArray(_useState, 1),
     selection = _useState2[0];
@@ -20,6 +21,7 @@ var BasicFilterContainer = function BasicFilterContainer(_ref) {
     testId: "jlol-basic-filter-container"
   }, availableBasicFilterTypes.map(function (filter) {
     return /*#__PURE__*/React.createElement(AsyncPopupSelect, {
+      cloudId: cloudId,
       filterType: filter,
       key: filter,
       selection: selection,

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/basic-filters/utils/transformers.js

@@ -30,7 +30,7 @@ function mapNodeToOption(_ref) {
       return _objectSpread(_objectSpread({}, baseProps), {}, {
         optionType: 'avatarLabel',
         avatar: user.picture,
-        isSquare: true
+        isSquare: false
       });
     }
     if (group) {
@@ -80,10 +80,20 @@ export function mapHydrateResponseData(_ref2) {
   });
   return transformedHydrateResponseData;
 }
-export function mapFieldValuesResponseData(_ref5) {
+export function mapFieldValuesToFilterOptions(_ref5) {
   var _data$jira2;
   var data = _ref5.data;
   return (data === null || data === void 0 || (_data$jira2 = data.jira) === null || _data$jira2 === void 0 || (_data$jira2 = _data$jira2.jqlBuilder) === null || _data$jira2 === void 0 || (_data$jira2 = _data$jira2.fieldValues) === null || _data$jira2 === void 0 || (_data$jira2 = _data$jira2.edges) === null || _data$jira2 === void 0 ? void 0 : _data$jira2.map(function (edge) {
     return edge.node ? mapNodeToOption(edge.node) : null;
   }).filter(isNonNullSelectOption)) || [];
+}
+export function mapFieldValuesToTotalCount(_ref6) {
+  var _data$jira3;
+  var data = _ref6.data;
+  return (data === null || data === void 0 || (_data$jira3 = data.jira) === null || _data$jira3 === void 0 || (_data$jira3 = _data$jira3.jqlBuilder) === null || _data$jira3 === void 0 || (_data$jira3 = _data$jira3.fieldValues) === null || _data$jira3 === void 0 ? void 0 : _data$jira3.totalCount) || 0;
+}
+export function mapFieldValuesToPageCursor(_ref7) {
+  var _data$jira4;
+  var data = _ref7.data;
+  return data === null || data === void 0 || (_data$jira4 = data.jira) === null || _data$jira4 === void 0 || (_data$jira4 = _data$jira4.jqlBuilder) === null || _data$jira4 === void 0 || (_data$jira4 = _data$jira4.fieldValues) === null || _data$jira4 === void 0 || (_data$jira4 = _data$jira4.pageInfo) === null || _data$jira4 === void 0 ? void 0 : _data$jira4.endCursor;
 }

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));

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

@@ -1,11 +1,12 @@
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 /** @jsx jsx */
-import React, { useCallback, useMemo, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { css, jsx } from '@emotion/react';
 import { useIntl } from 'react-intl-next';
 import { getBooleanFF } from '@atlaskit/platform-feature-flags';
 import { useDatasourceAnalyticsEvents } from '../../../analytics';
 import { BasicFilters } from '../basic-filters';
+import { isQueryTooComplex } from '../basic-filters/utils/isQueryTooComplex';
 import { BasicSearchInput } from '../basic-search-input';
 import { JiraJQLEditor } from '../jql-editor';
 import { ModeSwitcher } from '../mode-switcher';
@@ -18,6 +19,7 @@ var inputContainerStyles = css({
   minHeight: '60px'
 });
 var DEFAULT_JQL_QUERY = 'created >= -30d order by created DESC';
+export var ALLOWED_ORDER_BY_KEYS = ['key', 'summary', 'assignee', 'status', 'created'];
 var JiraSearchMethodSwitcher = ModeSwitcher;
 export var JiraSearchContainer = function JiraSearchContainer(props) {
   var isSearching = props.isSearching,
@@ -42,14 +44,18 @@ export var JiraSearchContainer = function JiraSearchContainer(props) {
     _useState6 = _slicedToArray(_useState5, 2),
     jql = _useState6[0],
     setJql = _useState6[1];
-  var _useState7 = useState(),
+  var _useState7 = useState(false),
     _useState8 = _slicedToArray(_useState7, 2),
-    orderKey = _useState8[0],
-    setOrderKey = _useState8[1];
+    isComplexQuery = _useState8[0],
+    setIsComplexQuery = _useState8[1];
   var _useState9 = useState(),
     _useState10 = _slicedToArray(_useState9, 2),
-    orderDirection = _useState10[0],
-    setOrderDirection = _useState10[1];
+    orderKey = _useState10[0],
+    setOrderKey = _useState10[1];
+  var _useState11 = useState(),
+    _useState12 = _slicedToArray(_useState11, 2),
+    orderDirection = _useState12[0],
+    setOrderDirection = _useState12[1];
   var _useDatasourceAnalyti = useDatasourceAnalyticsEvents(),
     fireEvent = _useDatasourceAnalyti.fireEvent;
   var onSearchMethodChange = useCallback(function (searchMethod) {
@@ -76,7 +82,7 @@ export var JiraSearchContainer = function JiraSearchContainer(props) {
     var order = hasOrder ? (_fragments$at3 = fragments.at(-1)) === null || _fragments$at3 === void 0 ? void 0 : _fragments$at3.split(' ').at(-1) : undefined;
 
     // TODO: confirm if these are the only order keys we want to preserve - existing whiteboard logic
-    if (key && ['key', 'summary', 'assignee', 'status'].includes(key)) {
+    if (key && ALLOWED_ORDER_BY_KEYS.includes(key)) {
       setOrderKey(key);
       setOrderDirection(order);
     }
@@ -86,6 +92,7 @@ export var JiraSearchContainer = function JiraSearchContainer(props) {
     onSearch({
       jql: jql
     }, currentSearchMethod);
+    setIsComplexQuery(isQueryTooComplex(jql));
     if (currentSearchMethod === 'basic') {
       fireEvent('ui.form.submitted.basicSearch', {});
     } else if (currentSearchMethod === 'jql') {
@@ -98,6 +105,10 @@ export var JiraSearchContainer = function JiraSearchContainer(props) {
     }
     return false;
   }, []);
+  useEffect(function () {
+    setIsComplexQuery(isQueryTooComplex(jql));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
   return jsx("div", {
     css: inputContainerStyles
   }, currentSearchMethod === 'basic' && jsx(React.Fragment, null, jsx(BasicSearchInput, {
@@ -106,7 +117,8 @@ export var JiraSearchContainer = function JiraSearchContainer(props) {
     onSearch: handleSearch,
     searchTerm: basicSearchTerm
   }), showBasicFilters && jsx(BasicFilters, {
-    jql: jql
+    jql: jql,
+    cloudId: cloudId || ''
   })), currentSearchMethod === 'jql' && jsx(JiraJQLEditor, {
     cloudId: cloudId || '',
     isSearching: isSearching,
@@ -121,7 +133,9 @@ export var JiraSearchContainer = function JiraSearchContainer(props) {
       value: 'jql'
     }, {
       label: formatMessage(modeSwitcherMessages.basicTextSearchLabel),
-      value: 'basic'
+      value: 'basic',
+      disabled: isComplexQuery,
+      tooltipText: isComplexQuery ? formatMessage(modeSwitcherMessages.basicModeSwitchDisabledTooltipText) : ''
     }]
   }));
 };

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

@@ -4,5 +4,10 @@ export var modeSwitcherMessages = defineMessages({
     id: 'linkDataSource.jira-issues.configmodal.basicModeText',
     description: 'Display text for basic text search toggle button',
     defaultMessage: 'Basic'
+  },
+  basicModeSwitchDisabledTooltipText: {
+    id: 'linkDataSource.jira-issues.configmodal.basicModeSwitchDisabledTooltipText',
+    description: 'Display tooltip text when basic mode switch is disabled',
+    defaultMessage: "You can't switch to basic for this query."
   }
 });

package/dist/esm/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';
 var modeSwitcherStyles = css({
   alignItems: 'center',
   background: "var(--ds-background-neutral, ".concat(N20, ")"),
@@ -44,8 +46,12 @@ var modeSwitcherLabelSelectedStyles = css({
   }
 });
 var modeSwitcherLabelDisabledStyles = css({
+  color: "var(--ds-text-disabled, ".concat(N60, ")")
+});
+var modeSwitcherDisabledStyles = css({
   ':hover': {
-    cursor: 'not-allowed'
+    cursor: 'not-allowed',
+    background: 'transparent'
   }
 });
 var compactModeSwitcherLabelStyles = css({
@@ -68,21 +74,27 @@ export var ModeSwitcher = function ModeSwitcher(props) {
     disabled: isDisabled
   }, options.map(function (_ref) {
     var value = _ref.value,
-      label = _ref.label;
+      label = _ref.label,
+      isOptionDisabled = _ref.disabled,
+      tooltipText = _ref.tooltipText;
     var isSelected = value === selectedOptionValue;
-    return jsx("label", {
-      key: value,
-      css: [modeSwitcherLabelStyles, isCompact && compactModeSwitcherLabelStyles, isSelected && modeSwitcherLabelSelectedStyles, isDisabled && modeSwitcherLabelDisabledStyles],
-      "data-testid": "mode-toggle-".concat(value)
-    }, label, jsx("input", {
-      "aria-checked": isSelected,
-      "aria-disabled": isDisabled,
-      checked: isSelected,
-      css: modeInputStyles,
-      disabled: isDisabled,
-      onChange: handleModeChange,
-      type: "radio",
-      value: value
-    }));
+    return jsx(Tooltip, {
+      content: tooltipText
+    }, function (tooltipProps) {
+      return jsx("label", _extends({}, tooltipProps, {
+        key: value,
+        css: [modeSwitcherLabelStyles, isCompact && compactModeSwitcherLabelStyles, isSelected && modeSwitcherLabelSelectedStyles, isDisabled && modeSwitcherDisabledStyles, isOptionDisabled && [modeSwitcherLabelDisabledStyles, modeSwitcherDisabledStyles]],
+        "data-testid": "mode-toggle-".concat(value)
+      }), label, jsx("input", {
+        "aria-checked": isSelected,
+        "aria-disabled": isOptionDisabled,
+        checked: isSelected,
+        css: modeInputStyles,
+        disabled: isOptionDisabled,
+        onChange: handleModeChange,
+        type: "radio",
+        value: value
+      }));
+    });
   })) : null;
 };

package/dist/types/services/useBasicFilterAGG.d.ts

@@ -1,5 +1,13 @@
 import { BasicFilterFieldType, FieldValuesResponse, HydrateResponse } from '../ui/jira-issues-modal/basic-filters/types';
+interface GetFieldValuesProps {
+    cloudId: string;
+    jql: string;
+    jqlTerm: BasicFilterFieldType;
+    searchString: string;
+    pageCursor?: string;
+}
 export declare const useBasicFilterAGG: () => {
     getHydratedJQL: (cloudId: string, jql: string) => Promise<HydrateResponse>;
-    getFieldValues: (cloudId: string, jql: string, jqlTerm: BasicFilterFieldType, searchString: string, pageCursor?: string) => Promise<FieldValuesResponse>;
+    getFieldValues: ({ cloudId, jql, jqlTerm, searchString, pageCursor, }: GetFieldValuesProps) => Promise<FieldValuesResponse>;
 };
+export {};

package/dist/types/services/utils.d.ts

@@ -1,2 +1,2 @@
 export declare const hydrateJQLQuery = "query hydrate($cloudId: ID!, $jql: String!) {\n  jira {\n    jqlBuilder(cloudId: $cloudId) {\n      hydrateJqlQuery(query: $jql) {\n        ... on JiraJqlHydratedQuery {\n          fields {\n            ... on JiraJqlQueryHydratedField {\n              jqlTerm\n              values {\n                ... on JiraJqlQueryHydratedValue {\n                  values {\n                    ... on JiraJqlProjectFieldValue {\n                      jqlTerm\n                      displayName\n                      project {\n                        avatar {\n                          small\n                        }\n                      }\n                    }\n                    ... on JiraJqlStatusFieldValue {\n                      jqlTerm\n                      displayName\n                      statusCategory {\n                        colorName\n                      }\n                    }\n                    ... on JiraJqlIssueTypeFieldValue {\n                      jqlTerm\n                      displayName\n                      issueTypes {\n                        avatar {\n                          small\n                        }\n                      }\n                    }\n                    ... on JiraJqlUserFieldValue {\n                      jqlTerm\n                      displayName\n                      user {\n                        picture\n                      }\n                    }\n                    ... on JiraJqlGroupFieldValue {\n                      jqlTerm\n                      displayName\n                      group {\n                        name\n                      }\n                    }\n                  }\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n}";
-export declare const fieldValuesQuery = "query fieldValues($cloudId: ID!, $first: Int = 10, $jqlTerm: String!, $jql: String!, $searchString: String!, $after: String, $projectOptions: JiraProjectOptions) {\n  jira {\n    jqlBuilder(cloudId: $cloudId) {\n      fieldValues(\n        first: $first\n        jqlTerm: $jqlTerm\n        jqlContext: $jql\n        searchString: $searchString\n        after: $after\n      ) {\n        totalCount\n        pageInfo {\n          endCursor\n        }\n        edges {\n          node {\n            jqlTerm\n            displayName\n            ... on JiraJqlProjectFieldValue {\n              project {\n                avatar {\n                  small\n                }\n              }\n            }\n            ... on JiraJqlIssueTypeFieldValue {\n              issueTypes {\n                avatar {\n                  small\n                }\n              }\n            }\n            ... on JiraJqlStatusFieldValue {\n              statusCategory {\n                colorName\n              }\n            }\n            ... on JiraJqlUserFieldValue {\n              user {\n                picture\n              }\n            }\n            ... on JiraJqlGroupFieldValue {\n              group {\n                name\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n}";
+export declare const fieldValuesQuery = "query fieldValues($cloudId: ID!, $first: Int = 10, $jqlTerm: String!, $jql: String!, $searchString: String!, $after: String) {\n  jira {\n    jqlBuilder(cloudId: $cloudId) {\n      fieldValues(\n        first: $first\n        jqlTerm: $jqlTerm\n        jqlContext: $jql\n        searchString: $searchString\n        after: $after\n      ) {\n        totalCount\n        pageInfo {\n          endCursor\n        }\n        edges {\n          node {\n            jqlTerm\n            displayName\n            ... on JiraJqlProjectFieldValue {\n              project {\n                avatar {\n                  small\n                }\n              }\n            }\n            ... on JiraJqlIssueTypeFieldValue {\n              issueTypes {\n                avatar {\n                  small\n                }\n              }\n            }\n            ... on JiraJqlStatusFieldValue {\n              statusCategory {\n                colorName\n              }\n            }\n            ... on JiraJqlUserFieldValue {\n              user {\n                picture\n              }\n            }\n            ... on JiraJqlGroupFieldValue {\n              group {\n                name\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n}";

package/dist/types/ui/jira-issues-modal/basic-filters/hooks/useFilterOptions.d.ts

@@ -0,0 +1,18 @@
+import { BasicFilterFieldType, SelectOption } from '../types';
+interface FilterOptionsProps {
+    filterType: BasicFilterFieldType;
+    cloudId: string;
+}
+export interface FetchFilterOptionsProps {
+    pageCursor?: string;
+    searchString?: string;
+}
+export interface FilterOptionsState {
+    filterOptions: SelectOption[];
+    fetchFilterOptions: (prop?: FetchFilterOptionsProps) => Promise<void>;
+    totalCount: number;
+    pageCursor?: string;
+    status: 'empty' | 'loading' | 'resolved' | 'rejected';
+}
+export declare const useFilterOptions: ({ filterType, cloudId, }: FilterOptionsProps) => FilterOptionsState;
+export {};

package/dist/types/ui/jira-issues-modal/basic-filters/ui/async-popup-select/index.d.ts

@@ -2,8 +2,9 @@
 import { BasicFilterFieldType, SelectOption } from '../../types';
 export interface AsyncPopupSelectProps {
     filterType: BasicFilterFieldType;
+    cloudId: string;
     selection: SelectOption[];
     onSelectionChange?: (selection: SelectOption[]) => void;
 }
-declare const AsyncPopupSelect: ({ filterType, selection, onSelectionChange, }: AsyncPopupSelectProps) => JSX.Element;
+declare const AsyncPopupSelect: ({ filterType, cloudId, selection, onSelectionChange, }: AsyncPopupSelectProps) => JSX.Element;
 export default AsyncPopupSelect;

package/dist/types/ui/jira-issues-modal/basic-filters/ui/index.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="react" />
 interface BasicFilterContainerProps {
     jql: string;
+    cloudId: string;
 }
-declare const BasicFilterContainer: ({ jql }: BasicFilterContainerProps) => JSX.Element;
+declare const BasicFilterContainer: ({ jql, cloudId }: BasicFilterContainerProps) => JSX.Element;
 export default BasicFilterContainer;

package/dist/types/ui/jira-issues-modal/basic-filters/utils/isClauseTooComplex.d.ts

@@ -0,0 +1,2 @@
+import { Clause } from '@atlaskit/jql-ast';
+export declare const isClauseTooComplex: (clauses: Clause[], key: string) => boolean;

package/dist/types/ui/jira-issues-modal/basic-filters/utils/isQueryTooComplex.d.ts

@@ -0,0 +1 @@
+export declare const isQueryTooComplex: (jql: string) => boolean;

package/dist/types/ui/jira-issues-modal/basic-filters/utils/transformers.d.ts

@@ -5,4 +5,6 @@ export declare function mapHydrateResponseData({ data }: HydrateResponse): {
     project?: SelectOption[] | undefined;
     issuetype?: SelectOption[] | undefined;
 };
-export declare function mapFieldValuesResponseData({ data, }: FieldValuesResponse): SelectOption[];
+export declare function mapFieldValuesToFilterOptions({ data, }: FieldValuesResponse): SelectOption[];
+export declare function mapFieldValuesToTotalCount({ data, }: FieldValuesResponse): number;
+export declare function mapFieldValuesToPageCursor({ data, }: FieldValuesResponse): string | undefined;

package/dist/types/ui/jira-issues-modal/jira-search-container/buildJQL.d.ts

@@ -7,5 +7,6 @@ type BuildJQLInput = {
         [key in BasicFilterFieldType]?: SelectOption[];
     };
 };
+export declare const fuzzyCharacter = "*";
 export declare const buildJQL: (input: BuildJQLInput) => string;
 export {};