@atlaskit/link-datasource 1.12.4 → 1.13.1

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

@@ -5,7 +5,7 @@ var _typeof = require("@babel/runtime/helpers/typeof");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.JiraSearchContainer = void 0;
+exports.JiraSearchContainer = exports.ALLOWED_ORDER_BY_KEYS = void 0;
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _react = _interopRequireWildcard(require("react"));
 var _react2 = require("@emotion/react");
@@ -13,6 +13,7 @@ var _reactIntlNext = require("react-intl-next");
 var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _analytics = require("../../../analytics");
 var _basicFilters = require("../basic-filters");
+var _isQueryTooComplex = require("../basic-filters/utils/isQueryTooComplex");
 var _basicSearchInput = require("../basic-search-input");
 var _jqlEditor = require("../jql-editor");
 var _modeSwitcher = require("../mode-switcher");
@@ -29,6 +30,7 @@ var inputContainerStyles = (0, _react2.css)({
   minHeight: '60px'
 });
 var DEFAULT_JQL_QUERY = 'created >= -30d order by created DESC';
+var ALLOWED_ORDER_BY_KEYS = exports.ALLOWED_ORDER_BY_KEYS = ['key', 'summary', 'assignee', 'status', 'created'];
 var JiraSearchMethodSwitcher = _modeSwitcher.ModeSwitcher;
 var JiraSearchContainer = exports.JiraSearchContainer = function JiraSearchContainer(props) {
   var isSearching = props.isSearching,
@@ -53,14 +55,18 @@ var JiraSearchContainer = exports.JiraSearchContainer = function JiraSearchConta
     _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
     jql = _useState6[0],
     setJql = _useState6[1];
-  var _useState7 = (0, _react.useState)(),
+  var _useState7 = (0, _react.useState)(false),
     _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
-    orderKey = _useState8[0],
-    setOrderKey = _useState8[1];
+    isComplexQuery = _useState8[0],
+    setIsComplexQuery = _useState8[1];
   var _useState9 = (0, _react.useState)(),
     _useState10 = (0, _slicedToArray2.default)(_useState9, 2),
-    orderDirection = _useState10[0],
-    setOrderDirection = _useState10[1];
+    orderKey = _useState10[0],
+    setOrderKey = _useState10[1];
+  var _useState11 = (0, _react.useState)(),
+    _useState12 = (0, _slicedToArray2.default)(_useState11, 2),
+    orderDirection = _useState12[0],
+    setOrderDirection = _useState12[1];
   var _useDatasourceAnalyti = (0, _analytics.useDatasourceAnalyticsEvents)(),
     fireEvent = _useDatasourceAnalyti.fireEvent;
   var onSearchMethodChange = (0, _react.useCallback)(function (searchMethod) {
@@ -87,7 +93,7 @@ var JiraSearchContainer = exports.JiraSearchContainer = function JiraSearchConta
     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);
     }
@@ -97,6 +103,7 @@ var JiraSearchContainer = exports.JiraSearchContainer = function JiraSearchConta
     onSearch({
       jql: jql
     }, currentSearchMethod);
+    setIsComplexQuery((0, _isQueryTooComplex.isQueryTooComplex)(jql));
     if (currentSearchMethod === 'basic') {
       fireEvent('ui.form.submitted.basicSearch', {});
     } else if (currentSearchMethod === 'jql') {
@@ -109,6 +116,10 @@ var JiraSearchContainer = exports.JiraSearchContainer = function JiraSearchConta
     }
     return false;
   }, []);
+  (0, _react.useEffect)(function () {
+    setIsComplexQuery((0, _isQueryTooComplex.isQueryTooComplex)(jql));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
   return (0, _react2.jsx)("div", {
     css: inputContainerStyles
   }, currentSearchMethod === 'basic' && (0, _react2.jsx)(_react.default.Fragment, null, (0, _react2.jsx)(_basicSearchInput.BasicSearchInput, {
@@ -133,7 +144,9 @@ var JiraSearchContainer = exports.JiraSearchContainer = function JiraSearchConta
       value: 'jql'
     }, {
       label: formatMessage(_messages.modeSwitcherMessages.basicTextSearchLabel),
-      value: 'basic'
+      value: 'basic',
+      disabled: isComplexQuery,
+      tooltipText: isComplexQuery ? formatMessage(_messages.modeSwitcherMessages.basicModeSwitchDisabledTooltipText) : ''
     }]
   }));
 };

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

@@ -10,5 +10,10 @@ var modeSwitcherMessages = exports.modeSwitcherMessages = (0, _reactIntlNext.def
     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/cjs/ui/jira-issues-modal/mode-switcher/index.js

@@ -5,9 +5,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ModeSwitcher = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _react = _interopRequireDefault(require("react"));
 var _react2 = require("@emotion/react");
 var _colors = require("@atlaskit/theme/colors");
+var _tooltip = _interopRequireDefault(require("@atlaskit/tooltip"));
 /** @jsx jsx */
 
 var modeSwitcherStyles = (0, _react2.css)({
@@ -52,8 +54,12 @@ var modeSwitcherLabelSelectedStyles = (0, _react2.css)({
   }
 });
 var modeSwitcherLabelDisabledStyles = (0, _react2.css)({
+  color: "var(--ds-text-disabled, ".concat(_colors.N60, ")")
+});
+var modeSwitcherDisabledStyles = (0, _react2.css)({
   ':hover': {
-    cursor: 'not-allowed'
+    cursor: 'not-allowed',
+    background: 'transparent'
   }
 });
 var compactModeSwitcherLabelStyles = (0, _react2.css)({
@@ -76,21 +82,27 @@ var ModeSwitcher = exports.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 (0, _react2.jsx)("label", {
-      key: value,
-      css: [modeSwitcherLabelStyles, isCompact && compactModeSwitcherLabelStyles, isSelected && modeSwitcherLabelSelectedStyles, isDisabled && modeSwitcherLabelDisabledStyles],
-      "data-testid": "mode-toggle-".concat(value)
-    }, label, (0, _react2.jsx)("input", {
-      "aria-checked": isSelected,
-      "aria-disabled": isDisabled,
-      checked: isSelected,
-      css: modeInputStyles,
-      disabled: isDisabled,
-      onChange: handleModeChange,
-      type: "radio",
-      value: value
-    }));
+    return (0, _react2.jsx)(_tooltip.default, {
+      content: tooltipText
+    }, function (tooltipProps) {
+      return (0, _react2.jsx)("label", (0, _extends2.default)({}, tooltipProps, {
+        key: value,
+        css: [modeSwitcherLabelStyles, isCompact && compactModeSwitcherLabelStyles, isSelected && modeSwitcherLabelSelectedStyles, isDisabled && modeSwitcherDisabledStyles, isOptionDisabled && [modeSwitcherLabelDisabledStyles, modeSwitcherDisabledStyles]],
+        "data-testid": "mode-toggle-".concat(value)
+      }), label, (0, _react2.jsx)("input", {
+        "aria-checked": isSelected,
+        "aria-disabled": isOptionDisabled,
+        checked: isSelected,
+        css: modeInputStyles,
+        disabled: isOptionDisabled,
+        onChange: handleModeChange,
+        type: "radio",
+        value: value
+      }));
+    });
   })) : null;
 };

package/dist/es2019/analytics/constants.js

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

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

@@ -1,4 +1,4 @@
-import { useCallback, useState } from 'react';
+import { useCallback, useRef, useState } from 'react';
 import { useBasicFilterAGG } from '../../../../services/useBasicFilterAGG';
 import { mapFieldValuesToFilterOptions, mapFieldValuesToPageCursor, mapFieldValuesToTotalCount } from '../utils/transformers';
 export const useFilterOptions = ({
@@ -9,6 +9,7 @@ export const useFilterOptions = ({
   const [totalCount, setTotalCount] = useState(0);
   const [status, setStatus] = useState('empty');
   const [nextPageCursor, setNextPageCursor] = useState(undefined);
+  const initialData = useRef();
   const {
     getFieldValues
   } = useBasicFilterAGG();
@@ -17,8 +18,12 @@ export const useFilterOptions = ({
     searchString
   } = {}) => {
     setStatus('loading');
+    const isRequestLikeInitialSearch = !pageCursor && !searchString;
+    const {
+      current: initialResponseData
+    } = initialData;
     try {
-      const response = await getFieldValues({
+      const response = isRequestLikeInitialSearch && initialResponseData ? initialResponseData : await getFieldValues({
         cloudId,
         jql: '',
         jqlTerm: filterType,
@@ -32,6 +37,13 @@ export const useFilterOptions = ({
       const 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([...filterOptions, ...mapFieldValuesToFilterOptions(response)]);
       }

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

@@ -0,0 +1,34 @@
+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';
+const customDropdownIndicatorStyles = xcss({
+  display: 'flex',
+  cursor: 'pointer',
+  justifyContent: 'center',
+  width: "var(--ds-space-400, 32px)"
+});
+const CustomDropdownIndicator = props => {
+  const {
+    selectProps
+  } = props;
+  return /*#__PURE__*/React.createElement(components.DropdownIndicator, props, /*#__PURE__*/React.createElement(Box, {
+    xcss: customDropdownIndicatorStyles,
+    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/es2019/ui/jira-issues-modal/basic-filters/ui/async-popup-select/index.js

@@ -1,20 +1,24 @@
 import _extends from "@babel/runtime/helpers/extends";
-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';
 import PopupTrigger from './trigger';
 // Needed to disable filtering from react-select
 const noFilterOptions = () => true;
+const SEARCH_DEBOUNCE_MS = 350;
 const AsyncPopupSelect = ({
   filterType,
   cloudId,
   selection,
-  onSelectionChange = () => {}
+  onSelectionChange = () => {},
+  isDisabled = false
 }) => {
   const {
     formatMessage
@@ -31,11 +35,15 @@ const AsyncPopupSelect = ({
     filterType,
     cloudId
   });
-  const handleInputChange = useCallback((searchString, actionMeta) => {
-    if (actionMeta.action === 'input-change' && searchString !== searchTerm) {
-      setSearchTerm(searchString);
+  const handleDebouncedFetchFilterOptions = useMemo(() => debounce(fetchFilterOptions, SEARCH_DEBOUNCE_MS), [fetchFilterOptions]);
+  const handleInputChange = useCallback(async (newSearchTerm, actionMeta) => {
+    if (actionMeta.action === 'input-change' && newSearchTerm !== searchTerm) {
+      setSearchTerm(newSearchTerm);
+      handleDebouncedFetchFilterOptions({
+        searchString: newSearchTerm
+      });
     }
-  }, [searchTerm]);
+  }, [handleDebouncedFetchFilterOptions, searchTerm]);
   const handleOptionSelection = newValue => {
     setSelectedOptions(newValue);
     onSelectionChange(newValue);
@@ -53,6 +61,9 @@ const AsyncPopupSelect = ({
     }
   }, [status]);
   const isLoading = status === 'loading' || status === 'empty';
+  const shouldShowFooter = status === 'resolved' && filterOptions.length > 0;
+  const 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,
@@ -74,9 +85,12 @@ const AsyncPopupSelect = ({
     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,
@@ -88,9 +102,10 @@ const AsyncPopupSelect = ({
     }) => /*#__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/es2019/ui/jira-issues-modal/basic-filters/ui/async-popup-select/trigger.js

@@ -6,12 +6,14 @@ import { asyncPopupSelectMessages } from './messages';
 const PopupTrigger = /*#__PURE__*/forwardRef(({
   filterType,
   isSelected,
+  isDisabled,
   onClick
 }, ref) => {
   return /*#__PURE__*/React.createElement(Button, {
     ref: ref,
     appearance: "default",
     isSelected: isSelected,
+    isDisabled: isDisabled,
     onClick: onClick,
     testId: `jlol-basic-filter-${filterType}-trigger`,
     iconAfter: /*#__PURE__*/React.createElement(ChevronDownIcon, {

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

@@ -22,6 +22,7 @@ const BasicFilterContainer = ({
     filterType: filter,
     key: filter,
     selection: selection,
+    isDisabled: !cloudId,
     onSelectionChange: handleSelectionChange
   })));
 };

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

@@ -0,0 +1,77 @@
+import { CLAUSE_TYPE_COMPOUND, CLAUSE_TYPE_TERMINAL, OPERAND_TYPE_VALUE } from '@atlaskit/jql-ast';
+import { fuzzyCharacter } from '../../jira-search-container/buildJQL';
+const removeFuzzyCharacter = value => {
+  if (value !== null && value !== void 0 && value.endsWith(fuzzyCharacter)) {
+    return value.slice(0, -1);
+  }
+  return value;
+};
+const getValueFromTerminalClause = clause => {
+  const {
+    operand
+  } = clause;
+  return operand !== undefined && operand.operandType === OPERAND_TYPE_VALUE && removeFuzzyCharacter(operand.value) || undefined;
+};
+const areClauseFieldValuesEqual = (clauseA, clauseB, clauseC) => {
+  const valueA = clauseA && getValueFromTerminalClause(clauseA);
+  const valueB = clauseB && getValueFromTerminalClause(clauseB);
+  const valueC = clauseC && getValueFromTerminalClause(clauseC);
+  const 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(value => value === values[0]);
+};
+const areClauseFieldKeysAllowed = (clauseA, clauseB, clauseC) => {
+  const fieldA = clauseA.field.value;
+  const fieldB = clauseB.field.value;
+  const 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(field => ['summary', 'text', 'key'].includes(field));
+};
+const doesCompoundClauseContainAllTerminalClauses = clauses => {
+  return clauses.every(clauses => clauses.clauseType === CLAUSE_TYPE_TERMINAL);
+};
+export const isClauseTooComplex = (clauses, key) => {
+  if (key === 'text') {
+    const [clause] = clauses;
+    if (clause.clauseType === CLAUSE_TYPE_COMPOUND) {
+      const 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;
+      }
+      const [clauseA, clauseB, clauseC] = textClauses;
+
+      /**
+       * 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/es2019/ui/jira-issues-modal/basic-filters/utils/isQueryTooComplex.js

@@ -0,0 +1,105 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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
+
+const allowedFields = [
+// basic filter fields
+'assignee', 'issuetype', 'project', 'status',
+// search input fields
+'text', 'summary', 'key',
+// orderby field
+'created'];
+const fallbackOperators = [OPERATOR_IN];
+const 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]
+};
+class JqlClauseCollectingVisitorError extends 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
+ * */
+class JqlClauseCollectingVisitor extends AbstractJastVisitor {
+  constructor() {
+    super();
+    _defineProperty(this, "visitNotClause", () => {
+      throw new JqlClauseCollectingVisitorError('Visited an unsupported node while traversing the AST');
+    });
+    _defineProperty(this, "visitOrderByField", orderByField => {
+      var _orderByField$field$v;
+      const 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 '${fieldValue}' is not supported`);
+      }
+      return {};
+    });
+    _defineProperty(this, "visitCompoundClause", compoundClause => {
+      const clauseMap = {};
+      const operator = compoundClause.operator.value;
+      if (operator === COMPOUND_OPERATOR_AND) {
+        return compoundClause.clauses.reduce((result, clause) => this.aggregateResult(clause.accept(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 '${operator}' is not supported`);
+    });
+    _defineProperty(this, "visitTerminalClause", terminalClause => {
+      var _terminalClause$opera;
+      const fieldName = terminalClause.field.value.toLowerCase();
+      if (!allowedFields.includes(fieldName)) {
+        throw new JqlClauseCollectingVisitorError(`Field with name '${fieldName}' of type ${terminalClause.clauseType} is not supported`);
+      }
+      const operator = (_terminalClause$opera = terminalClause.operator) === null || _terminalClause$opera === void 0 ? void 0 : _terminalClause$opera.value;
+      const allowedOperators = fieldSpecificOperators[fieldName] || fallbackOperators;
+      if (operator && !allowedOperators.includes(operator.toLowerCase())) {
+        throw new JqlClauseCollectingVisitorError(`Field with name '${fieldName}' using operator ${operator} is not supported`);
+      }
+      return {
+        [terminalClause.field.value.toLowerCase()]: [terminalClause]
+      };
+    });
+  }
+  aggregateResult(aggregate, nextResult) {
+    return mergeWith(aggregate, nextResult, (destValue, srcValue) => srcValue.concat(destValue !== null && destValue !== void 0 ? destValue : []));
+  }
+  defaultResult() {
+    return {};
+  }
+}
+export const isQueryTooComplex = jql => {
+  if (!getBooleanFF('platform.linking-platform.datasource.show-jlol-basic-filters') || !jql) {
+    return false;
+  }
+  if (!isValidJql(jql)) {
+    return true;
+  }
+  const jast = new JastBuilder().build(jql);
+  try {
+    const jqlClauseCollectingVisitor = new JqlClauseCollectingVisitor();
+    const clauseMap = jast.query ? jast.query.accept(jqlClauseCollectingVisitor) : {}; // jast.query is defined as void | Query, hence the fallback
+
+    const hasAnyKeyWithComplexClause = Object.entries(clauseMap).some(([key, clauses]) => isClauseTooComplex(clauses, key));
+    return hasAnyKeyWithComplexClause;
+  } catch (error) {
+    return true;
+  }
+};

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

@@ -1,6 +1,7 @@
 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';
 const fuzzySearchRegExp = /^"(.+)"$/;
 const jiraIssueKeyRegExp = /[A-Z]+-\d+/;
+export const fuzzyCharacter = '*';
 const constructTerminalClause = (field, operator, value) => creators.terminalClause(creators.field(field), creators.operator(operator), creators.valueOperand(value));
 export const buildJQL = input => {
   /**
@@ -22,7 +23,7 @@ export const buildJQL = input => {
     return '';
   }
   if (trimmedRawSearch) {
-    const fuzzy = !trimmedRawSearch.match(fuzzySearchRegExp) ? '*' : '';
+    const fuzzy = !trimmedRawSearch.match(fuzzySearchRegExp) ? fuzzyCharacter : '';
     const basicSearch = trimmedRawSearch.replace(/['"?*]+/g, '');
     const text = constructTerminalClause('text', OPERATOR_LIKE, `${basicSearch}${fuzzy}`);
     const summary = constructTerminalClause('summary', OPERATOR_LIKE, `${basicSearch}${fuzzy}`);

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

@@ -1,10 +1,11 @@
 /** @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';
@@ -17,6 +18,7 @@ const inputContainerStyles = css({
   minHeight: '60px'
 });
 const DEFAULT_JQL_QUERY = 'created >= -30d order by created DESC';
+export const ALLOWED_ORDER_BY_KEYS = ['key', 'summary', 'assignee', 'status', 'created'];
 const JiraSearchMethodSwitcher = ModeSwitcher;
 export const JiraSearchContainer = props => {
   const {
@@ -36,6 +38,7 @@ export const JiraSearchContainer = props => {
   const [basicSearchTerm, setBasicSearchTerm] = useState('');
   const [currentSearchMethod, setCurrentSearchMethod] = useState(initialSearchMethod);
   const [jql, setJql] = useState(initialJql || DEFAULT_JQL_QUERY);
+  const [isComplexQuery, setIsComplexQuery] = useState(false);
   const [orderKey, setOrderKey] = useState();
   const [orderDirection, setOrderDirection] = useState();
   const {
@@ -63,7 +66,7 @@ export const JiraSearchContainer = props => {
     const 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);
     }
@@ -73,6 +76,7 @@ export const JiraSearchContainer = props => {
     onSearch({
       jql
     }, currentSearchMethod);
+    setIsComplexQuery(isQueryTooComplex(jql));
     if (currentSearchMethod === 'basic') {
       fireEvent('ui.form.submitted.basicSearch', {});
     } else if (currentSearchMethod === 'jql') {
@@ -85,6 +89,10 @@ export const JiraSearchContainer = props => {
     }
     return false;
   }, []);
+  useEffect(() => {
+    setIsComplexQuery(isQueryTooComplex(jql));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
   return jsx("div", {
     css: inputContainerStyles
   }, currentSearchMethod === 'basic' && jsx(React.Fragment, null, jsx(BasicSearchInput, {
@@ -109,7 +117,9 @@ export const JiraSearchContainer = props => {
       value: 'jql'
     }, {
       label: formatMessage(modeSwitcherMessages.basicTextSearchLabel),
-      value: 'basic'
+      value: 'basic',
+      disabled: isComplexQuery,
+      tooltipText: isComplexQuery ? formatMessage(modeSwitcherMessages.basicModeSwitchDisabledTooltipText) : ''
     }]
   }));
 };

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

@@ -4,5 +4,10 @@ export const 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."
   }
 });