@atlaskit/link-datasource 0.14.4

package/dist/es2019/ui/issue-like-table/render-type/boolean/index.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import { useIntl } from 'react-intl-next';
+import TextRenderType from '../text';
+import { booleanTypeMessages } from './messages';
+export const BOOLEAN_TYPE_TEST_ID = 'link-datasource-render-type--boolean';
+const BooleanRenderType = ({
+  value,
+  testId = BOOLEAN_TYPE_TEST_ID
+}) => {
+  const intl = useIntl();
+  if (typeof value !== 'boolean') {
+    return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+  const TRUTHY_TEXT = intl.formatMessage(booleanTypeMessages.booleanTruthyValue);
+  const FALSY_TEXT = intl.formatMessage(booleanTypeMessages.booleanFalsyValue);
+  return /*#__PURE__*/React.createElement(TextRenderType, {
+    text: value ? TRUTHY_TEXT : FALSY_TEXT,
+    testId: testId
+  });
+};
+export default BooleanRenderType;

package/dist/es2019/ui/issue-like-table/render-type/boolean/messages.js

@@ -0,0 +1,13 @@
+import { defineMessages } from 'react-intl-next';
+export const booleanTypeMessages = defineMessages({
+  booleanTruthyValue: {
+    id: 'linkDataSource.render-type.boolean.true',
+    description: 'Text to display for the boolean type when the value is true',
+    defaultMessage: 'Yes'
+  },
+  booleanFalsyValue: {
+    id: 'linkDataSource.render-type.boolean.false',
+    description: 'Text to display for the boolean type when the value is false',
+    defaultMessage: 'No'
+  }
+});

package/dist/es2019/ui/issue-like-table/render-type/date-time/index.js

@@ -0,0 +1,37 @@
+import React from 'react';
+import { useIntl } from 'react-intl-next';
+export const DATETIME_TYPE_TEST_ID = 'link-datasource-render-type--datetime';
+const dateOptions = {
+  month: 'short',
+  day: 'numeric',
+  year: 'numeric'
+};
+const timeOptions = {
+  hour12: false,
+  hour: '2-digit',
+  minute: '2-digit'
+};
+const DateTimeRenderType = ({
+  value,
+  testId = DATETIME_TYPE_TEST_ID,
+  display = 'datetime'
+}) => {
+  const date = new Date(value);
+  const intl = useIntl();
+  if (!value || isNaN(date.getTime())) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+  const options = {
+    date: dateOptions,
+    time: timeOptions,
+    datetime: {
+      ...dateOptions,
+      ...timeOptions
+    }
+  };
+  const formattedString = intl.formatDate(date, options[display] || options['date']);
+  return /*#__PURE__*/React.createElement("span", {
+    "data-testid": testId
+  }, formattedString);
+};
+export default DateTimeRenderType;

package/dist/es2019/ui/issue-like-table/render-type/icon/index.js

@@ -0,0 +1,27 @@
+import React from 'react';
+import styled from '@emotion/styled';
+import Image from '@atlaskit/image';
+const IconWrapper = styled.div`
+  display: flex;
+  align-items: center;
+  justify-content: center;
+`;
+export const ICON_TYPE_TEST_ID = 'link-datasource-render-type--icon';
+const IconRenderType = ({
+  label,
+  source,
+  testId = ICON_TYPE_TEST_ID
+}) => {
+  const style = /svg/i.test(source) ? {
+    minWidth: '20px',
+    maxWidth: '20px'
+  } // having just width: '20px' shriks it when table width is reduced
+  : {};
+  return /*#__PURE__*/React.createElement(IconWrapper, null, /*#__PURE__*/React.createElement(Image, {
+    src: source,
+    alt: label,
+    "data-testid": testId,
+    style: style
+  }));
+};
+export default IconRenderType;

package/dist/es2019/ui/issue-like-table/render-type/index.js

@@ -0,0 +1,55 @@
+import React from 'react';
+import BooleanRenderType from './boolean';
+import DateTimeRenderType from './date-time';
+import IconRenderType from './icon';
+import LinkRenderType from './link';
+import NumberRenderType from './number';
+import StatusRenderType from './status';
+import TagRenderType from './tag';
+import StringRenderType from './text';
+import UserRenderType from './user';
+export const fallbackRenderType = item => {
+  switch (item.type) {
+    case 'boolean':
+      return /*#__PURE__*/React.createElement(BooleanRenderType, {
+        value: item.value
+      });
+    case 'date':
+      return /*#__PURE__*/React.createElement(DateTimeRenderType, {
+        value: item.value,
+        display: "date"
+      });
+    case 'datetime':
+      return /*#__PURE__*/React.createElement(DateTimeRenderType, {
+        value: item.value,
+        display: "datetime"
+      });
+    case 'icon':
+      return /*#__PURE__*/React.createElement(IconRenderType, item.value);
+    case 'link':
+      return /*#__PURE__*/React.createElement(LinkRenderType, item.value);
+    case 'number':
+      return /*#__PURE__*/React.createElement(NumberRenderType, {
+        number: item.value
+      });
+    case 'status':
+      return /*#__PURE__*/React.createElement(StatusRenderType, item.value);
+    case 'string':
+      return /*#__PURE__*/React.createElement(StringRenderType, {
+        text: item.value
+      });
+    case 'tag':
+      return /*#__PURE__*/React.createElement(TagRenderType, {
+        text: item.value
+      });
+    case 'time':
+      return /*#__PURE__*/React.createElement(DateTimeRenderType, {
+        value: item.value,
+        display: "time"
+      });
+    case 'user':
+      return /*#__PURE__*/React.createElement(UserRenderType, item.value);
+    default:
+      return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+};

package/dist/es2019/ui/issue-like-table/render-type/link/index.js

@@ -0,0 +1,38 @@
+import React, { useMemo } from 'react';
+import { ErrorBoundary } from 'react-error-boundary';
+import { Card } from '@atlaskit/smart-card';
+import LinkUrl from '@atlaskit/smart-card/link-url';
+import { N300 } from '@atlaskit/theme/colors';
+import { h300 } from '@atlaskit/theme/typography';
+const linkStyles = {
+  key: {
+    ...h300(),
+    color: `var(--ds-text-subtlest, ${N300})`,
+    fontWeight: 600
+  }
+};
+export const LINK_TYPE_TEST_ID = 'link-datasource-render-type--link';
+const LinkRenderType = ({
+  linkType,
+  url,
+  text,
+  testId = LINK_TYPE_TEST_ID
+}) => {
+  const style = useMemo(() => {
+    return linkType && linkStyles[linkType] || {};
+  }, [linkType]);
+  const anchor = useMemo(() => /*#__PURE__*/React.createElement(LinkUrl, {
+    href: url,
+    style: style,
+    "data-testid": testId
+  }, text || url), [style, url, text, testId]);
+  const SmartCard = () => /*#__PURE__*/React.createElement(ErrorBoundary, {
+    fallback: anchor
+  }, /*#__PURE__*/React.createElement(Card, {
+    appearance: "inline",
+    url: url,
+    testId: testId
+  }));
+  return text ? anchor : /*#__PURE__*/React.createElement(SmartCard, null);
+};
+export default /*#__PURE__*/React.memo(LinkRenderType);

package/dist/es2019/ui/issue-like-table/render-type/number/index.js

@@ -0,0 +1,15 @@
+import React from 'react';
+export const NUMBER_TYPE_TEST_ID = 'link-datasource-render-type--number';
+const NumberRenderType = ({
+  number,
+  testId = NUMBER_TYPE_TEST_ID
+}) => {
+  if (typeof number !== 'number') {
+    return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+  const formattedNumber = Number.isInteger(number) ? number : `${number.toFixed(2)}`;
+  return /*#__PURE__*/React.createElement("span", {
+    "data-testid": testId
+  }, formattedNumber);
+};
+export default NumberRenderType;

package/dist/es2019/ui/issue-like-table/render-type/status/index.js

@@ -0,0 +1,19 @@
+import React from 'react';
+import Lozenge from '@atlaskit/lozenge';
+export const STATUS_TYPE_TEST_ID = 'link-datasource-render-type--status';
+const StatusRenderType = ({
+  text,
+  status,
+  testId = STATUS_TYPE_TEST_ID,
+  style
+}) => {
+  if (!text) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+  return /*#__PURE__*/React.createElement(Lozenge, {
+    appearance: status,
+    testId: testId,
+    style: style
+  }, text);
+};
+export default StatusRenderType;

package/dist/es2019/ui/issue-like-table/render-type/tag/index.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { SimpleTag as Tag } from '@atlaskit/tag';
+export const TAG_TYPE_TEST_ID = 'link-datasource-render-type--tag';
+const TagRenderType = ({
+  text,
+  testId = TAG_TYPE_TEST_ID
+}) => {
+  if (!text) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+  return /*#__PURE__*/React.createElement(Tag, {
+    text: text,
+    testId: testId,
+    appearance: 'default',
+    color: 'standard'
+  });
+};
+export default TagRenderType;

package/dist/es2019/ui/issue-like-table/render-type/text/index.js

@@ -0,0 +1,14 @@
+import React from 'react';
+export const TEXT_TYPE_TEST_ID = 'link-datasource-render-type--text';
+const TextRenderType = ({
+  text,
+  testId = TEXT_TYPE_TEST_ID
+}) => {
+  if (!text) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null);
+  }
+  return /*#__PURE__*/React.createElement("span", {
+    "data-testid": testId
+  }, text);
+};
+export default TextRenderType;

package/dist/es2019/ui/issue-like-table/render-type/user/index.js

@@ -0,0 +1,29 @@
+import React from 'react';
+import styled from '@emotion/styled';
+import { FormattedMessage } from 'react-intl-next';
+import Avatar from '@atlaskit/avatar';
+import { userTypeMessages } from './messages';
+const UserWrapper = styled.div`
+  display: flex;
+  align-items: center;
+`;
+const AvatarWrapper = styled.div`
+  margin-right: 5px;
+`;
+export const USER_TYPE_TEST_ID = 'link-datasource-render-type--user';
+const UserType = ({
+  avatarSource,
+  avatarSize = 'small',
+  displayName,
+  testId = USER_TYPE_TEST_ID,
+  children
+}) => {
+  return /*#__PURE__*/React.createElement(UserWrapper, {
+    "data-testid": testId
+  }, /*#__PURE__*/React.createElement(AvatarWrapper, null, /*#__PURE__*/React.createElement(Avatar, {
+    appearance: "circle",
+    size: avatarSize,
+    src: avatarSource
+  })), children || displayName || /*#__PURE__*/React.createElement(FormattedMessage, userTypeMessages.userDefaultdisplayNameValue));
+};
+export default UserType;

package/dist/es2019/ui/issue-like-table/render-type/user/messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export const userTypeMessages = defineMessages({
+  userDefaultdisplayNameValue: {
+    id: 'linkDataSource.render-type.user.default.display.name',
+    description: 'Text to display for the user type when no display value is provided',
+    defaultMessage: 'Unassigned'
+  }
+});

package/dist/es2019/ui/issue-like-table/styled.js

@@ -0,0 +1,6 @@
+import styled from '@emotion/styled';
+export const TableHeading = styled.th`
+  position: relative;
+  padding-block: ${"var(--ds-space-100, 8px)"};
+  line-height: ${"var(--ds-font-lineHeight-300, 24px)"};
+`;

package/dist/es2019/ui/issue-like-table/types.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/ui/issue-like-table/useIsOnScreen.js

@@ -0,0 +1,17 @@
+import { useEffect, useMemo, useState } from 'react';
+
+// Hook which tracks if a ref is visible or not. Taken from: https://stackoverflow.com/a/65008608
+export const useIsOnScreen = el => {
+  const [isIntersecting, setIntersecting] = useState(false);
+  const observer = useMemo(() => new IntersectionObserver(([entry]) => {
+    return setIntersecting(entry.isIntersecting);
+  }), []);
+  useEffect(() => {
+    el && observer.observe(el);
+    return () => {
+      setIntersecting(false);
+      return observer.disconnect();
+    };
+  }, [observer, el]);
+  return isIntersecting;
+};

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

@@ -0,0 +1,42 @@
+/** @jsx jsx */
+import { css, jsx } from '@emotion/react';
+import { useIntl } from 'react-intl-next';
+import { LoadingButton } from '@atlaskit/button';
+import SearchIcon from '@atlaskit/icon/glyph/editor/search';
+import Textfield from '@atlaskit/textfield';
+import { basicSearchInputMessages } from './messages';
+const searchButtonStyles = css({
+  marginRight: "var(--ds-space-075, 6px)"
+});
+export const BasicSearchInput = ({
+  isDisabled,
+  isSearching,
+  onChange,
+  onSearch,
+  searchTerm,
+  testId = 'jira-jql-datasource-modal--basic-search-input'
+}) => {
+  const {
+    formatMessage
+  } = useIntl();
+  return jsx(Textfield, {
+    elemAfterInput: jsx(LoadingButton, {
+      appearance: "primary",
+      css: searchButtonStyles,
+      iconBefore: jsx(SearchIcon, {
+        label: formatMessage(basicSearchInputMessages.basicTextSearchLabel),
+        size: "medium"
+      }),
+      isDisabled: isDisabled,
+      isLoading: isSearching,
+      onClick: () => onSearch(searchTerm),
+      spacing: "none",
+      testId: "jira-jql-datasource-modal--basic-search-button"
+    }),
+    autoFocus: true,
+    onChange: onChange,
+    placeholder: formatMessage(basicSearchInputMessages.basicTextSearchLabel),
+    testId: testId,
+    value: searchTerm
+  });
+};

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

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export const basicSearchInputMessages = defineMessages({
+  basicTextSearchLabel: {
+    id: 'linkDataSource.jira-issues.configmodal.basicTextSearchPlaceholder',
+    description: 'Placeholder text for the search input box',
+    defaultMessage: 'Search'
+  }
+});

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

@@ -0,0 +1,227 @@
+import _extends from "@babel/runtime/helpers/extends";
+/** @jsx jsx */
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { css, jsx } from '@emotion/react';
+import { FormattedMessage, IntlProvider, useIntl } from 'react-intl-next';
+import Button from '@atlaskit/button/standard-button';
+import Modal, { ModalBody, ModalFooter, ModalHeader, ModalTitle, ModalTransition } from '@atlaskit/modal-dialog';
+import { B400, N0 } from '@atlaskit/theme/colors';
+import { useDatasourceTableState } from '../../../hooks/useDatasourceTableState';
+import { getAvailableJiraSites } from '../../../services/getAvailableJiraSites';
+import { EmptyState, IssueLikeDataTableView } from '../../issue-like-table';
+import LinkRenderType from '../../issue-like-table/render-type/link';
+import { JiraSearchContainer } from './jira-search-container';
+import { modalMessages } from './messages';
+import { ModeSwitcher } from './mode-switcher';
+import { JiraSiteSelector } from './site-selector';
+const dropdownContainerStyles = css({
+  display: 'flex',
+  gap: "var(--ds-space-100, 0.5rem)"
+});
+const contentContainerStyles = css({
+  height: '420px',
+  overflow: 'auto'
+});
+const placeholderSmartLinkStyles = css({
+  backgroundColor: `var(--ds-surface-raised, ${N0})`,
+  borderRadius: '3px',
+  boxShadow: '0px 1px 1px rgba(9, 30, 66, 0.25), 0px 0px 1px rgba(9, 30, 66, 0.31)',
+  color: `var(--ds-text-brand, ${B400})`,
+  padding: '0px 2px'
+});
+export const JiraIssuesConfigModal = props => {
+  const [availableSites, setAvailableSites] = useState([]);
+  const [currentViewMode, setCurrentViewMode] = useState('issue');
+  const {
+    datasourceId,
+    parameters,
+    visibleColumnKeys,
+    onCancel,
+    onInsert,
+    onUpdateParameters,
+    onVisibleColumnKeysChange
+  } = props;
+  const isParametersSet = !!(parameters && parameters.value && parameters.cloudId);
+  const {
+    cloudId,
+    value: jql
+  } = parameters || {};
+  const {
+    reset,
+    status,
+    onNextPage,
+    responseItems,
+    hasNextPage,
+    columns,
+    defaultVisibleColumnKeys
+  } = useDatasourceTableState(datasourceId, parameters, ['key']);
+  const {
+    formatMessage
+  } = useIntl();
+  useEffect(() => {
+    const fetchSiteDisplayNames = async () => {
+      const jiraSites = await getAvailableJiraSites();
+      setAvailableSites(jiraSites);
+    };
+    void fetchSiteDisplayNames();
+  }, []);
+  const onSearch = useCallback(parameters => {
+    onUpdateParameters(parameters);
+    reset();
+  }, [reset, onUpdateParameters]);
+  const onSiteSelection = useCallback(site => {
+    onUpdateParameters({
+      cloudId: site.cloudId
+    });
+    reset();
+  }, [reset, onUpdateParameters]);
+  const selectedJiraSite = useMemo(() => availableSites.find(jiraSite => jiraSite.cloudId === cloudId) || availableSites[0], [availableSites, cloudId]);
+  useEffect(() => {
+    if (!cloudId && selectedJiraSite) {
+      onUpdateParameters({
+        cloudId: selectedJiraSite.cloudId
+      });
+    }
+  }, [cloudId, onUpdateParameters, selectedJiraSite]);
+  useEffect(() => {
+    if ((visibleColumnKeys || []).length === 0 && defaultVisibleColumnKeys.length > 0) {
+      onVisibleColumnKeysChange(defaultVisibleColumnKeys);
+    }
+  }, [visibleColumnKeys, defaultVisibleColumnKeys, onVisibleColumnKeysChange]);
+  const retrieveUrlForSmartCardRender = useCallback(() => {
+    var _data$key;
+    const [data] = responseItems;
+    // agrement with BE that we will use `key` for rendering smartlink
+    return data === null || data === void 0 ? void 0 : (_data$key = data.key) === null || _data$key === void 0 ? void 0 : _data$key.url;
+  }, [responseItems]);
+  const onInsertPressed = useCallback(() => {
+    if (!isParametersSet || !jql || !selectedJiraSite) {
+      return;
+    }
+    const firstIssueUrl = retrieveUrlForSmartCardRender();
+    if (currentViewMode === 'count') {
+      onInsert({
+        type: 'inlineCard',
+        attrs: {
+          url: `${selectedJiraSite.url}/issues/${encodeURI(jql)}`
+        }
+      });
+    } else if (responseItems.length === 1 && firstIssueUrl) {
+      onInsert({
+        type: 'inlineCard',
+        attrs: {
+          url: firstIssueUrl
+        }
+      });
+    } else {
+      onInsert({
+        type: 'blockCard',
+        attrs: {
+          datasource: {
+            id: datasourceId,
+            parameters: {
+              cloudId,
+              jql // TODO support non JQL type
+            },
+
+            views: [{
+              type: 'table',
+              properties: {
+                columnKeys: visibleColumnKeys
+              }
+            }]
+          }
+        }
+      });
+    }
+  }, [isParametersSet, jql, selectedJiraSite, retrieveUrlForSmartCardRender, currentViewMode, responseItems.length, onInsert, datasourceId, cloudId, visibleColumnKeys]);
+  const handleViewModeChange = selectedMode => {
+    setCurrentViewMode(selectedMode);
+  };
+  useEffect(() => {
+    if (status === 'empty' && isParametersSet) {
+      void onNextPage();
+    }
+  }, [status, isParametersSet, onNextPage, reset]);
+  const issueLikeDataTableView = useMemo(() => jsx(IssueLikeDataTableView, {
+    testId: "jira-jql-datasource-table",
+    status: status,
+    columns: columns,
+    items: responseItems,
+    hasNextPage: hasNextPage,
+    visibleColumnKeys: visibleColumnKeys || defaultVisibleColumnKeys,
+    onNextPage: onNextPage,
+    onVisibleColumnKeysChange: onVisibleColumnKeysChange
+  }), [columns, defaultVisibleColumnKeys, hasNextPage, onNextPage, onVisibleColumnKeysChange, responseItems, status, visibleColumnKeys]);
+  const renderCountModeContent = useCallback(() => {
+    const url = selectedJiraSite === null || selectedJiraSite === void 0 ? void 0 : selectedJiraSite.url;
+    if (status === 'empty' || !jql || !url) {
+      return jsx("span", {
+        "data-testid": `jira-jql-datasource-modal--smart-card-placeholder`,
+        css: placeholderSmartLinkStyles
+      }, jsx(FormattedMessage, modalMessages.issuesCountSmartCardPlaceholderText));
+    } else {
+      const urlWithEncodedJql = `${url}/issues/?jql=${encodeURI(jql)}`;
+      return jsx(LinkRenderType, {
+        url: urlWithEncodedJql
+      });
+    }
+  }, [jql, selectedJiraSite === null || selectedJiraSite === void 0 ? void 0 : selectedJiraSite.url, status]);
+  const renderIssuesModeContent = useCallback(() => {
+    if (status === 'empty' || columns.length === 0) {
+      return jsx(EmptyState, {
+        testId: `jira-jql-datasource-modal--empty-state`
+      });
+    }
+    const firstIssueUrl = retrieveUrlForSmartCardRender();
+    if (responseItems.length === 1 && firstIssueUrl) {
+      return jsx(LinkRenderType, {
+        url: firstIssueUrl
+      });
+    }
+    return issueLikeDataTableView;
+  }, [columns.length, issueLikeDataTableView, responseItems.length, retrieveUrlForSmartCardRender, status]);
+  return jsx(IntlProvider, {
+    locale: "en"
+  }, jsx(ModalTransition, null, jsx(Modal, {
+    testId: 'jira-jql-datasource-modal',
+    onClose: onCancel,
+    width: "x-large",
+    shouldScrollInViewport: true
+  }, jsx(ModalHeader, null, jsx(ModalTitle, null, availableSites.length < 2 ? jsx(FormattedMessage, modalMessages.insertIssuesTitle) : jsx("div", {
+    css: dropdownContainerStyles
+  }, jsx(FormattedMessage, _extends({}, modalMessages.insertIssuesTitleManySites, {
+    values: {
+      siteName: selectedJiraSite === null || selectedJiraSite === void 0 ? void 0 : selectedJiraSite.displayName
+    }
+  })), jsx(JiraSiteSelector, {
+    testId: `jira-jql-datasource-modal--site-selector`,
+    availableSites: availableSites,
+    onSiteSelection: onSiteSelection,
+    selectedJiraSite: selectedJiraSite
+  }))), jsx(ModeSwitcher, {
+    isCompact: true,
+    options: [{
+      label: formatMessage(modalMessages.issueViewModeLabel),
+      value: 'issue'
+    }, {
+      label: formatMessage(modalMessages.countViewModeLabel),
+      value: 'count'
+    }],
+    onOptionValueChange: handleViewModeChange,
+    selectedOptionValue: currentViewMode
+  })), jsx(ModalBody, null, jsx(JiraSearchContainer, {
+    parameters: parameters,
+    onSearch: onSearch
+  }), jsx("div", {
+    css: contentContainerStyles
+  }, currentViewMode === 'count' ? renderCountModeContent() : renderIssuesModeContent())), jsx(ModalFooter, null, jsx(Button, {
+    appearance: "default",
+    onClick: onCancel
+  }, jsx(FormattedMessage, modalMessages.cancelButtonText)), jsx(Button, {
+    appearance: "primary",
+    onClick: onInsertPressed,
+    isDisabled: !isParametersSet,
+    testId: 'jira-jql-datasource-modal--insert-button'
+  }, jsx(FormattedMessage, modalMessages.insertIssuesButtonText))))));
+};

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

@@ -0,0 +1,20 @@
+const fuzzySearchRegExp = /^"(.+)"$/;
+const jiraIssueKeyRegExp = /[A-Z]+-\d+/;
+export const buildJQL = input => {
+  const {
+    rawSearch,
+    orderDirection = 'DESC',
+    orderKey = 'created'
+  } = input;
+  const fuzzy = !rawSearch.match(fuzzySearchRegExp) ? '*' : '';
+  const basicSearch = rawSearch.replace(/['"?*]+/g, '');
+  const baseQueryParts = rawSearch.trim() ? [`text ~ "${basicSearch}${fuzzy}"`, `summary ~ "${basicSearch}${fuzzy}"`] : [];
+  if (jiraIssueKeyRegExp.test(rawSearch)) {
+    baseQueryParts.push(`key = "${basicSearch}"`);
+  }
+  const baseQueryContent = baseQueryParts.join(' OR ');
+  const baseQuery = baseQueryContent ? `(${baseQueryContent})` : '';
+  const limiter = rawSearch !== null && rawSearch !== void 0 && rawSearch.trim() ? '' : `created >= -30d`;
+  const query = [baseQuery, limiter].filter(Boolean).join(' AND ');
+  return `${query} order by ${orderKey} ${orderDirection.toUpperCase()}`;
+};