@atlaskit/link-datasource 1.17.0 → 1.17.2

package/dist/es2019/services/cmdbService.js

@@ -1,6 +1,6 @@
 import { request } from '@atlaskit/linking-common';
 import { FetchError, getStatusCodeGroup, mapFetchErrors, PermissionError } from './cmdbService.utils';
-export const getWorkspaceId = async () => {
+export const getWorkspaceId = async fireEvent => {
   const url = '/rest/servicedesk/cmdb/latest/workspace';
   try {
     var _workspaceDetailsResp;
@@ -8,12 +8,15 @@ export const getWorkspaceId = async () => {
     if (!((_workspaceDetailsResp = workspaceDetailsResponse.results) !== null && _workspaceDetailsResp !== void 0 && _workspaceDetailsResp.length)) {
       throw new PermissionError('No workspace results found');
     }
+    fireEvent && fireEvent('operational.getWorkspaceId.success', {});
     return workspaceDetailsResponse.results[0].id;
   } catch (err) {
     let error = mapFetchErrors(err);
     if (error instanceof FetchError) {
-      // TODO Fire error operational event for workspace here before remapping to PermissionError
-      // Only 429 and 5xx errors will be treated as FetchErrors otherwise PermissionError
+      fireEvent && fireEvent('operational.getWorkspaceId.failed', {
+        statusCodeGroup: getStatusCodeGroup(error)
+      });
+      // Only 429 and5xx errors will be treated as FetchErrors otherwise PermissionError
       if (getStatusCodeGroup(error) !== '5xx' && error.statusCode !== 429) {
         error = new PermissionError('Failed to fetch workspace');
       }
@@ -21,17 +24,21 @@ export const getWorkspaceId = async () => {
     throw error;
   }
 };
-export const validateAql = async (workspaceId, data) => {
+export const validateAql = async (workspaceId, data, fireEvent) => {
   const url = `/gateway/api/jsm/assets/workspace/${workspaceId}/v1/aql/validate`;
   try {
-    return await request('post', url, {
+    const response = await request('post', url, {
       qlQuery: data.qlQuery,
       context: 'SMART_LINKS'
     }, undefined, [200, 201, 202, 203, 204]);
+    fireEvent && fireEvent('operational.validateAql.success', {});
+    return response;
   } catch (err) {
     let error = mapFetchErrors(err);
     if (error instanceof FetchError) {
-      // TODO Fire error operational event for aql here before remapping to PermissionError
+      fireEvent && fireEvent('operational.validateAql.failed', {
+        statusCodeGroup: getStatusCodeGroup(error)
+      });
       if (error.statusCode === 401 || error.statusCode === 403) {
         error = new PermissionError('Failed to fetch object schemas');
       }
@@ -39,14 +46,18 @@ export const validateAql = async (workspaceId, data) => {
     throw error;
   }
 };
-export const fetchObjectSchema = async (workspaceId, schemaId) => {
+export const fetchObjectSchema = async (workspaceId, schemaId, fireEvent) => {
   const url = `/gateway/api/jsm/assets/workspace/${workspaceId}/v1/objectschema/${schemaId}`;
   try {
-    return await request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
+    const response = await request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
+    fireEvent && fireEvent('operational.objectSchema.success', {});
+    return response;
   } catch (err) {
     let error = mapFetchErrors(err);
     if (error instanceof FetchError) {
-      // TODO Fire error operational event for object schema here before remapping to PermissionError
+      fireEvent && fireEvent('operational.objectSchema.failed', {
+        statusCodeGroup: getStatusCodeGroup(error)
+      });
       if (error.statusCode === 401 || error.statusCode === 403) {
         error = new PermissionError('Failed to fetch object schemas');
       }
@@ -54,18 +65,22 @@ export const fetchObjectSchema = async (workspaceId, schemaId) => {
     throw error;
   }
 };
-export const fetchObjectSchemas = async (workspaceId, query) => {
+export const fetchObjectSchemas = async (workspaceId, query, fireEvent) => {
   const queryParams = new URLSearchParams();
   queryParams.set('maxResults', '20');
   queryParams.set('includeCounts', 'false');
   query && queryParams.set('query', query);
   const url = `/gateway/api/jsm/assets/workspace/${workspaceId}/v1/objectschema/list?${queryParams}`;
   try {
-    return await request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
+    const response = await request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
+    fireEvent && fireEvent('operational.objectSchemas.success', {});
+    return response;
   } catch (err) {
     let error = mapFetchErrors(err);
     if (error instanceof FetchError) {
-      // TODO Fire error operational event for object schemas here before remapping to PermissionError
+      fireEvent && fireEvent('operational.objectSchemas.failed', {
+        statusCodeGroup: getStatusCodeGroup(error)
+      });
       if (error.statusCode === 401 || error.statusCode === 403) {
         error = new PermissionError('Failed to fetch object schemas');
       }

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

@@ -57,12 +57,20 @@ export const useFilterOptions = ({
       setStatus('rejected');
     }
   }, [cloudId, filterOptions, filterType, getFieldValues]);
+  const reset = useCallback(() => {
+    setStatus('empty');
+    setFilterOptions([]);
+    setTotalCount(0);
+    setNextPageCursor(undefined);
+    initialData.current = undefined;
+  }, []);
   return {
     filterOptions,
     fetchFilterOptions,
     totalCount,
     pageCursor: nextPageCursor,
     status,
+    reset,
     errors: status === 'rejected' ? errors : []
   };
 };

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

@@ -1,5 +1,6 @@
 import _extends from "@babel/runtime/helpers/extends";
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import isEqual from 'lodash/isEqual';
 import { useIntl } from 'react-intl-next';
 import { useDebouncedCallback } from 'use-debounce';
 import { CheckboxOption, PopupSelect } from '@atlaskit/select';
@@ -19,6 +20,7 @@ const AsyncPopupSelect = ({
   cloudId,
   selection,
   onSelectionChange = () => {},
+  onReset: resetSelection = () => {},
   isDisabled = false
 }) => {
   const {
@@ -26,13 +28,17 @@ const AsyncPopupSelect = ({
   } = useIntl();
   const [searchTerm, setSearchTerm] = useState('');
   const [selectedOptions, setSelectedOptions] = useState(selection);
-  const [sortedOptions, setSortedOptions] = useState(selectedOptions);
+  const [sortedOptions, setSortedOptions] = useState([]);
+  const currentSiteCloudId = useRef(cloudId);
+  const sortPaginatedResults = useRef(false); // this is to track pagination for sorting purpose
+
   const {
     filterOptions,
     fetchFilterOptions,
     totalCount,
     status,
     pageCursor,
+    reset: resetHook,
     errors
   } = useFilterOptions({
     filterType,
@@ -49,38 +55,46 @@ const AsyncPopupSelect = ({
       handleDebouncedFetchFilterOptions(newSearchTerm);
     }
   }, [handleDebouncedFetchFilterOptions, searchTerm]);
-  const handleOptionSelection = newValue => {
-    setSelectedOptions(newValue);
+  const handleOptionSelection = useCallback(newValue => {
     onSelectionChange(newValue);
-  };
+  }, [onSelectionChange]);
   const sortOptionsOnPopupOpen = useCallback(() => {
     if (selectedOptions.length === 0) {
-      setSortedOptions(filterOptions);
-      return;
+      return setSortedOptions(filterOptions);
     }
     const nonSelectedOptions = filterOptions.filter(option => !selectedOptions.find(selectedOption => selectedOption.value === option.value));
     const newOptions = [...selectedOptions, ...nonSelectedOptions];
-    setSortedOptions(newOptions);
-  }, [selectedOptions, filterOptions]);
+    if (!isEqual(newOptions, sortedOptions)) {
+      setSortedOptions(newOptions);
+    }
+  }, [selectedOptions, filterOptions, sortedOptions]);
   const sortOptionsOnResolve = useCallback(() => {
-    const newOptions = filterOptions.filter(option => !sortedOptions.find(sortedOption => sortedOption.value === option.value));
-    let shouldSetSortOptions = false;
-    if (sortedOptions.length !== filterOptions.length) {
-      shouldSetSortOptions = true;
-    } else {
-      sortedOptions.forEach(sortedOption => {
-        if (!filterOptions.some(filterOption => filterOption.value === sortedOption.value)) {
-          shouldSetSortOptions = true;
-        }
-      });
+    // sortedOptions is empty initially, this will take care of setting the initial value and bring the selected items to the top
+    if (sortedOptions.length === 0) {
+      return sortOptionsOnPopupOpen();
     }
-    if (shouldSetSortOptions) {
-      const sortedOptionsFiltered = sortedOptions.filter(sortedOption => filterOptions.some(filterOption => filterOption.value === sortedOption.value));
-      setSortedOptions([...sortedOptionsFiltered, ...newOptions]);
+
+    // when the user is searching, we want the search result to be displayed as it is, and the select component will take care of marking the selected items
+    if (searchTerm) {
+      sortPaginatedResults.current = false; // set to false to indicate pagination resolve action is completed from the sorting perspective
+      return setSortedOptions(filterOptions);
     }
-  }, [filterOptions, sortedOptions]);
+
+    // this block handles the pagination, where on pagination, we will just append newOptions to the current list
+    if (sortPaginatedResults.current) {
+      const newOptions = filterOptions.filter(option => !sortedOptions.find(sortedOption => sortedOption.value === option.value));
+      if (newOptions.length > 0) {
+        setSortedOptions([...sortedOptions, ...newOptions]);
+      }
+      sortPaginatedResults.current = false; // set to false to indicate pagination resolve action is completed from the sorting perspective
+      return;
+    }
+    sortPaginatedResults.current = false; // set to false to indicate pagination resolve action is completed from the sorting perspective
+    sortOptionsOnPopupOpen();
+  }, [filterOptions, searchTerm, sortOptionsOnPopupOpen, sortedOptions]);
   const handleShowMore = useCallback(() => {
     if (pageCursor) {
+      sortPaginatedResults.current = true;
       fetchFilterOptions({
         pageCursor,
         searchString: searchTerm
@@ -101,15 +115,31 @@ const AsyncPopupSelect = ({
     if (status === 'resolved') {
       sortOptionsOnResolve();
     }
-  }, [sortOptionsOnResolve, status]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [status]); // we only want the sortOptionsOnResolve to run when there is a status change
+
+  useEffect(() => {
+    if (currentSiteCloudId.current !== cloudId) {
+      currentSiteCloudId.current = cloudId;
+      setSortedOptions([]);
+      setSearchTerm('');
+      resetHook();
+      resetSelection();
+    }
+  }, [cloudId, resetHook, resetSelection]);
+  useEffect(() => {
+    if (!isEqual(selection, selectedOptions)) {
+      setSelectedOptions(selection);
+    }
+  }, [selectedOptions, selection]);
   const filterOptionsLength = filterOptions.length;
   const isError = status === 'rejected';
   const isLoading = status === 'loading' || status === 'empty';
   const isLoadingMore = status === 'loadingMore';
   const isEmpty = status === 'resolved' && filterOptionsLength === 0;
   const popupSelectOptions = isLoading || isError ? [] : sortedOptions; // if not set to [], then on loading, no loading UI will be shown
-  const areAllResultsLoaded = filterOptions.length === totalCount;
-  const shouldShowFooter = (status === 'resolved' || isLoadingMore) && filterOptions.length > 0; // footer should not disappear when there is an inline spinner for loading more data
+  const areAllResultsLoaded = filterOptionsLength === totalCount;
+  const shouldShowFooter = (status === 'resolved' || isLoadingMore) && filterOptionsLength > 0; // footer should not disappear when there is an inline spinner for loading more data
   const shouldDisplayShowMoreButton = status === 'resolved' && !!pageCursor && !areAllResultsLoaded;
   return /*#__PURE__*/React.createElement(PopupSelect, {
     isMulti: true,
@@ -165,7 +195,7 @@ const AsyncPopupSelect = ({
       isDisabled: isDisabled
     })),
     footer: shouldShowFooter && /*#__PURE__*/React.createElement(PopupFooter, {
-      currentDisplayCount: filterOptionsLength,
+      currentDisplayCount: popupSelectOptions.length,
       totalCount: totalCount
     })
   });

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

@@ -10,15 +10,24 @@ const BasicFilterContainer = ({
   jql,
   cloudId
 }) => {
-  const [selection, setSelection] = useState([]);
+  const [selection, setSelection] = useState({});
   useEffect(() => {
     if (isValidJql(jql)) {
       // hydrate hook call goes in here
     }
   }, [jql]);
-  const handleSelectionChange = useCallback(options => {
-    setSelection(options);
-  }, [setSelection]);
+  const handleSelectionChange = useCallback((options, filter) => {
+    const updatedSelection = {
+      ...selection,
+      [filter]: options
+    };
+    setSelection(updatedSelection);
+  }, [selection]);
+  const handleReset = useCallback(() => {
+    if (Object.keys(selection).length > 0) {
+      setSelection({});
+    }
+  }, [selection]);
   return /*#__PURE__*/React.createElement(Flex, {
     xcss: basicFilterContainerStyles,
     gap: "space.100",
@@ -27,9 +36,10 @@ const BasicFilterContainer = ({
     cloudId: cloudId,
     filterType: filter,
     key: filter,
-    selection: selection,
+    selection: selection[filter] || [],
     isDisabled: !cloudId,
-    onSelectionChange: handleSelectionChange
+    onSelectionChange: options => handleSelectionChange(options, filter),
+    onReset: handleReset
   })));
 };
 export default BasicFilterContainer;

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

@@ -1,5 +1,6 @@
 import { JastBuilder } from '@atlaskit/jql-ast';
 export const isValidJql = jql => {
+  var _jast$errors;
   const jast = new JastBuilder().build(jql);
-  return jast.errors.length === 0;
+  return (jast === null || jast === void 0 ? void 0 : (_jast$errors = jast.errors) === null || _jast$errors === void 0 ? void 0 : _jast$errors.length) === 0;
 };

package/dist/esm/analytics/constants.js

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

package/dist/esm/hooks/useAssetsClient.js

@@ -2,6 +2,7 @@ import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { useEffect, useState } from 'react';
+import { useDatasourceAnalyticsEvents } from '../analytics';
 import { fetchObjectSchema, fetchObjectSchemas, getWorkspaceId } from '../services/cmdbService';
 var handleAssetsClientErrors = function handleAssetsClientErrors(errorSetter, error) {
   if (error instanceof Error) {
@@ -43,6 +44,8 @@ export var useAssetsClient = function useAssetsClient(initialParameters) {
     _useState16 = _slicedToArray(_useState15, 2),
     objectSchemasError = _useState16[0],
     setObjectSchemasError = _useState16[1];
+  var _useDatasourceAnalyti = useDatasourceAnalyticsEvents(),
+    fireEvent = _useDatasourceAnalyti.fireEvent;
 
   /*
    * We wrap this in nested try/catch blocks because we want to handle
@@ -59,7 +62,7 @@ export var useAssetsClient = function useAssetsClient(initialParameters) {
             setWorkspaceError(undefined);
             _context.prev = 2;
             _context.next = 5;
-            return getWorkspaceId();
+            return getWorkspaceId(fireEvent);
           case 5:
             _workspaceId = _context.sent;
             setWorkspaceId(_workspaceId);
@@ -70,7 +73,7 @@ export var useAssetsClient = function useAssetsClient(initialParameters) {
             }
             _context.prev = 8;
             _context.next = 11;
-            return fetchObjectSchema(_workspaceId, initialParameters === null || initialParameters === void 0 ? void 0 : initialParameters.schemaId);
+            return fetchObjectSchema(_workspaceId, initialParameters === null || initialParameters === void 0 ? void 0 : initialParameters.schemaId, fireEvent);
           case 11:
             fetchedObjectSchema = _context.sent;
             setExistingObjectSchema(fetchedObjectSchema);
@@ -83,7 +86,7 @@ export var useAssetsClient = function useAssetsClient(initialParameters) {
           case 18:
             _context.prev = 18;
             _context.next = 21;
-            return fetchObjectSchemas(_workspaceId);
+            return fetchObjectSchemas(_workspaceId, undefined, fireEvent);
           case 21:
             fetchedObjectSchemasResponse = _context.sent;
             setObjectSchemas(fetchedObjectSchemasResponse.values);
@@ -111,7 +114,7 @@ export var useAssetsClient = function useAssetsClient(initialParameters) {
         }
       }, _callee, null, [[2, 31, 34, 37], [8, 15], [18, 26]]);
     }))();
-  }, [initialParameters]);
+  }, [initialParameters, fireEvent]);
   return {
     workspaceId: workspaceId,
     workspaceError: workspaceError,

package/dist/esm/hooks/useValidateAqlText.js

@@ -2,6 +2,7 @@ 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 { useDatasourceAnalyticsEvents } from '../analytics';
 import { validateAql } from '../services/cmdbService';
 export var useValidateAqlText = function useValidateAqlText(workspaceId) {
   var _useState = useState(false),
@@ -16,6 +17,8 @@ export var useValidateAqlText = function useValidateAqlText(workspaceId) {
     _useState6 = _slicedToArray(_useState5, 2),
     error = _useState6[0],
     setError = _useState6[1];
+  var _useDatasourceAnalyti = useDatasourceAnalyticsEvents(),
+    fireEvent = _useDatasourceAnalyti.fireEvent;
   var validateAqlText = useCallback( /*#__PURE__*/function () {
     var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(aql) {
       var isValid, message, _validateAqlResponse$, validateAqlResponse;
@@ -30,7 +33,7 @@ export var useValidateAqlText = function useValidateAqlText(workspaceId) {
             _context.next = 7;
             return validateAql(workspaceId, {
               qlQuery: aql
-            });
+            }, fireEvent);
           case 7:
             validateAqlResponse = _context.sent;
             setIsValidAqlText(validateAqlResponse.isValid);
@@ -64,7 +67,7 @@ export var useValidateAqlText = function useValidateAqlText(workspaceId) {
     return function (_x) {
       return _ref.apply(this, arguments);
     };
-  }(), [workspaceId]);
+  }(), [workspaceId, fireEvent]);
   return {
     isValidAqlText: isValidAqlText,
     validateAqlText: validateAqlText,

package/dist/esm/services/cmdbService.js

@@ -3,7 +3,7 @@ import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { request } from '@atlaskit/linking-common';
 import { FetchError, getStatusCodeGroup, mapFetchErrors, PermissionError } from './cmdbService.utils';
 export var getWorkspaceId = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(fireEvent) {
     var url, _workspaceDetailsResp, workspaceDetailsResponse, error;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
@@ -20,32 +20,35 @@ export var getWorkspaceId = /*#__PURE__*/function () {
           }
           throw new PermissionError('No workspace results found');
         case 7:
+          fireEvent && fireEvent('operational.getWorkspaceId.success', {});
           return _context.abrupt("return", workspaceDetailsResponse.results[0].id);
-        case 10:
-          _context.prev = 10;
+        case 11:
+          _context.prev = 11;
           _context.t0 = _context["catch"](1);
           error = mapFetchErrors(_context.t0);
           if (error instanceof FetchError) {
-            // TODO Fire error operational event for workspace here before remapping to PermissionError
-            // Only 429 and 5xx errors will be treated as FetchErrors otherwise PermissionError
+            fireEvent && fireEvent('operational.getWorkspaceId.failed', {
+              statusCodeGroup: getStatusCodeGroup(error)
+            });
+            // Only 429 and5xx errors will be treated as FetchErrors otherwise PermissionError
             if (getStatusCodeGroup(error) !== '5xx' && error.statusCode !== 429) {
               error = new PermissionError('Failed to fetch workspace');
             }
           }
           throw error;
-        case 15:
+        case 16:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[1, 10]]);
+    }, _callee, null, [[1, 11]]);
   }));
-  return function getWorkspaceId() {
+  return function getWorkspaceId(_x) {
     return _ref.apply(this, arguments);
   };
 }();
 export var validateAql = /*#__PURE__*/function () {
-  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(workspaceId, data) {
-    var url, error;
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(workspaceId, data, fireEvent) {
+    var url, response, error;
     return _regeneratorRuntime.wrap(function _callee2$(_context2) {
       while (1) switch (_context2.prev = _context2.next) {
         case 0:
@@ -57,31 +60,35 @@ export var validateAql = /*#__PURE__*/function () {
             context: 'SMART_LINKS'
           }, undefined, [200, 201, 202, 203, 204]);
         case 4:
-          return _context2.abrupt("return", _context2.sent);
-        case 7:
-          _context2.prev = 7;
+          response = _context2.sent;
+          fireEvent && fireEvent('operational.validateAql.success', {});
+          return _context2.abrupt("return", response);
+        case 9:
+          _context2.prev = 9;
           _context2.t0 = _context2["catch"](1);
           error = mapFetchErrors(_context2.t0);
           if (error instanceof FetchError) {
-            // TODO Fire error operational event for aql here before remapping to PermissionError
+            fireEvent && fireEvent('operational.validateAql.failed', {
+              statusCodeGroup: getStatusCodeGroup(error)
+            });
             if (error.statusCode === 401 || error.statusCode === 403) {
               error = new PermissionError('Failed to fetch object schemas');
             }
           }
           throw error;
-        case 12:
+        case 14:
         case "end":
           return _context2.stop();
       }
-    }, _callee2, null, [[1, 7]]);
+    }, _callee2, null, [[1, 9]]);
   }));
-  return function validateAql(_x, _x2) {
+  return function validateAql(_x2, _x3, _x4) {
     return _ref2.apply(this, arguments);
   };
 }();
 export var fetchObjectSchema = /*#__PURE__*/function () {
-  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(workspaceId, schemaId) {
-    var url, error;
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(workspaceId, schemaId, fireEvent) {
+    var url, response, error;
     return _regeneratorRuntime.wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
@@ -90,31 +97,35 @@ export var fetchObjectSchema = /*#__PURE__*/function () {
           _context3.next = 4;
           return request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
         case 4:
-          return _context3.abrupt("return", _context3.sent);
-        case 7:
-          _context3.prev = 7;
+          response = _context3.sent;
+          fireEvent && fireEvent('operational.objectSchema.success', {});
+          return _context3.abrupt("return", response);
+        case 9:
+          _context3.prev = 9;
           _context3.t0 = _context3["catch"](1);
           error = mapFetchErrors(_context3.t0);
           if (error instanceof FetchError) {
-            // TODO Fire error operational event for object schema here before remapping to PermissionError
+            fireEvent && fireEvent('operational.objectSchema.failed', {
+              statusCodeGroup: getStatusCodeGroup(error)
+            });
             if (error.statusCode === 401 || error.statusCode === 403) {
               error = new PermissionError('Failed to fetch object schemas');
             }
           }
           throw error;
-        case 12:
+        case 14:
         case "end":
           return _context3.stop();
       }
-    }, _callee3, null, [[1, 7]]);
+    }, _callee3, null, [[1, 9]]);
   }));
-  return function fetchObjectSchema(_x3, _x4) {
+  return function fetchObjectSchema(_x5, _x6, _x7) {
     return _ref3.apply(this, arguments);
   };
 }();
 export var fetchObjectSchemas = /*#__PURE__*/function () {
-  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(workspaceId, query) {
-    var queryParams, url, error;
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(workspaceId, query, fireEvent) {
+    var queryParams, url, response, error;
     return _regeneratorRuntime.wrap(function _callee4$(_context4) {
       while (1) switch (_context4.prev = _context4.next) {
         case 0:
@@ -127,25 +138,29 @@ export var fetchObjectSchemas = /*#__PURE__*/function () {
           _context4.next = 8;
           return request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
         case 8:
-          return _context4.abrupt("return", _context4.sent);
-        case 11:
-          _context4.prev = 11;
+          response = _context4.sent;
+          fireEvent && fireEvent('operational.objectSchemas.success', {});
+          return _context4.abrupt("return", response);
+        case 13:
+          _context4.prev = 13;
           _context4.t0 = _context4["catch"](5);
           error = mapFetchErrors(_context4.t0);
           if (error instanceof FetchError) {
-            // TODO Fire error operational event for object schemas here before remapping to PermissionError
+            fireEvent && fireEvent('operational.objectSchemas.failed', {
+              statusCodeGroup: getStatusCodeGroup(error)
+            });
             if (error.statusCode === 401 || error.statusCode === 403) {
               error = new PermissionError('Failed to fetch object schemas');
             }
           }
           throw error;
-        case 16:
+        case 18:
         case "end":
           return _context4.stop();
       }
-    }, _callee4, null, [[5, 11]]);
+    }, _callee4, null, [[5, 13]]);
   }));
-  return function fetchObjectSchemas(_x5, _x6) {
+  return function fetchObjectSchemas(_x8, _x9, _x10) {
     return _ref4.apply(this, arguments);
   };
 }();

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

@@ -105,12 +105,20 @@ export var useFilterOptions = function useFilterOptions(_ref) {
       }
     }, _callee, null, [[5, 24]]);
   })), [cloudId, filterOptions, filterType, getFieldValues]);
+  var reset = useCallback(function () {
+    setStatus('empty');
+    setFilterOptions([]);
+    setTotalCount(0);
+    setNextPageCursor(undefined);
+    initialData.current = undefined;
+  }, []);
   return {
     filterOptions: filterOptions,
     fetchFilterOptions: fetchFilterOptions,
     totalCount: totalCount,
     pageCursor: nextPageCursor,
     status: status,
+    reset: reset,
     errors: status === 'rejected' ? errors : []
   };
 };