@atlaskit/link-datasource 1.15.3 → 1.16.0

package/dist/es2019/ui/assets-modal/modal/index.js

@@ -18,6 +18,8 @@ import { fetchMessagesForLocale } from '../../../common/utils/locale/fetch-messa
 import { useAssetsClient } from '../../../hooks/useAssetsClient';
 import { useDatasourceTableState } from '../../../hooks/useDatasourceTableState';
 import i18nEN from '../../../i18n/en';
+import { PermissionError } from '../../../services/cmdbService.utils';
+import { AccessRequired } from '../../../ui/common/error-state/access-required';
 import { ModalLoadingError } from '../../common/error-state/modal-loading-error';
 import { AssetsSearchContainer } from '../search-container';
 import { AssetsSearchContainerLoading } from '../search-container/loading-state';
@@ -28,6 +30,9 @@ const modalBodyWrapperStyles = css({
   height: '420px',
   overflow: 'auto'
 });
+const modalBodyErrorWrapperStyles = css({
+  alignItems: 'center'
+});
 const AssetsModalTitle = jsx(ModalTitle, null, jsx(FormattedMessage, modalMessages.insertObjectsTitle));
 const PlainAssetsConfigModal = props => {
   const {
@@ -41,20 +46,53 @@ const PlainAssetsConfigModal = props => {
   const [schemaId, setSchemaId] = useState(initialParameters === null || initialParameters === void 0 ? void 0 : initialParameters.schemaId);
   const [visibleColumnKeys, setVisibleColumnKeys] = useState(initialVisibleColumnKeys);
   const [isNewSearch, setIsNewSearch] = useState(false);
+  const [errorState, setErrorState] = useState();
   const {
     fireEvent
   } = useDatasourceAnalyticsEvents();
   const {
     current: modalRenderInstanceId
   } = useRef(uuidv4());
-
-  // If a workspaceError occurs this is a critical error
   const {
     workspaceId,
     workspaceError,
-    objectSchema,
+    existingObjectSchema,
+    existingObjectSchemaError,
+    objectSchemas,
+    objectSchemasError,
+    totalObjectSchemas,
     assetsClientLoading
   } = useAssetsClient(initialParameters);
+
+  /* ------------------------------ PERMISSIONS ------------------------------ */
+  useEffect(() => {
+    if (workspaceError) {
+      // If a workspaceError occurs this is a critical error
+      if (workspaceError instanceof PermissionError) {
+        setErrorState('permission');
+      } else {
+        setErrorState('network');
+      }
+    }
+  }, [workspaceError]);
+  useEffect(() => {
+    if (objectSchemasError) {
+      // We only care about permission errors for objectSchemas fetching as the user can retry this action
+      if (objectSchemasError instanceof PermissionError) {
+        setErrorState('permission');
+      }
+    }
+  }, [objectSchemasError]);
+  useEffect(() => {
+    if (existingObjectSchemaError) {
+      // We only care about permission errors for existingObjectSchema fetching as the user can retry this action
+      if (existingObjectSchemaError instanceof PermissionError) {
+        setErrorState('permission');
+      }
+    }
+  }, [existingObjectSchemaError]);
+  /* ------------------------------ END PERMISSIONS ------------------------------ */
+
   const parameters = useMemo(() => ({
     aql: aql || '',
     schemaId: schemaId || '',
@@ -90,6 +128,15 @@ const PlainAssetsConfigModal = props => {
       destinationObjectTypes: destinationObjectTypes
     };
   }, [destinationObjectTypes, extensionKey]);
+  useEffect(() => {
+    // We only want to send modal ready event once after we've fetched the schema count
+    if (totalObjectSchemas !== undefined) {
+      fireEvent('ui.modal.ready.datasource', {
+        schemasCount: totalObjectSchemas,
+        instancesCount: null
+      });
+    }
+  }, [fireEvent, totalObjectSchemas]);
   useEffect(() => {
     fireEvent('screen.datasourceModalDialog.viewed', {});
   }, [fireEvent]);
@@ -144,7 +191,7 @@ const PlainAssetsConfigModal = props => {
       setVisibleColumnKeys(defaultVisibleColumnKeys);
     }
   }, [defaultVisibleColumnKeys, isNewSearch]);
-  const isDisabled = !!workspaceError || status !== 'resolved' || assetsClientLoading || !aql || !schemaId;
+  const isDisabled = !!errorState || status !== 'resolved' || assetsClientLoading || !aql || !schemaId;
   const retrieveUrlForSmartCardRender = useCallback(() => {
     var _data$key, _data$key$data;
     const [data] = responseItems;
@@ -232,8 +279,20 @@ const PlainAssetsConfigModal = props => {
       setIsNewSearch(true);
     }
   }, [aql, reset, schemaId, status]);
+  const renderErrorState = useCallback(() => {
+    if (errorState) {
+      switch (errorState) {
+        case 'permission':
+          return jsx(AccessRequired, null);
+        case 'network':
+          return jsx(ModalLoadingError, null);
+        default:
+          return jsx(ModalLoadingError, null);
+      }
+    }
+  }, [errorState]);
   const renderModalTitleContent = useCallback(() => {
-    if (workspaceError) {
+    if (errorState) {
       return undefined;
     } else {
       if (!workspaceId || assetsClientLoading) {
@@ -245,14 +304,15 @@ const PlainAssetsConfigModal = props => {
         workspaceId: workspaceId,
         initialSearchData: {
           aql,
-          objectSchema
+          objectSchema: existingObjectSchema,
+          objectSchemas
         },
         onSearch: handleOnSearch,
         modalTitle: AssetsModalTitle,
         isSearching: status === 'loading'
       });
     }
-  }, [aql, assetsClientLoading, handleOnSearch, objectSchema, status, workspaceError, workspaceId]);
+  }, [errorState, workspaceId, assetsClientLoading, aql, existingObjectSchema, objectSchemas, handleOnSearch, status]);
   return jsx(IntlMessagesProvider, {
     defaultMessages: i18nEN,
     loaderFn: fetchMessagesForLocale
@@ -263,8 +323,9 @@ const PlainAssetsConfigModal = props => {
     shouldScrollInViewport: true,
     shouldCloseOnOverlayClick: false
   }, jsx(ModalHeader, null, renderModalTitleContent()), jsx(ModalBody, null, jsx("div", {
-    css: modalBodyWrapperStyles
-  }, workspaceError ? jsx(ModalLoadingError, null) : jsx(RenderAssetsContent, {
+    css: [modalBodyWrapperStyles, errorState && modalBodyErrorWrapperStyles]
+  }, errorState ? renderErrorState() : jsx(RenderAssetsContent, {
+    isFetchingInitialData: assetsClientLoading,
     status: status,
     responseItems: responseItems,
     visibleColumnKeys: visibleColumnKeys,

package/dist/es2019/ui/assets-modal/modal/render-assets-content/index.js

@@ -1,9 +1,16 @@
-import React, { useMemo } from 'react';
+/** @jsx jsx */
+import { useMemo } from 'react';
+import { css, jsx } from '@emotion/react';
 import { AccessRequired } from '../../../common/error-state/access-required';
 import { ModalLoadingError } from '../../../common/error-state/modal-loading-error';
 import { NoResults } from '../../../common/error-state/no-results';
 import { EmptyState, IssueLikeDataTableView } from '../../../issue-like-table';
 import { InitialStateView } from './initial-state-view';
+// This is to prevent y scrollbar when initially fetching data
+const emptyStateOverrideStyles = css({
+  height: '420px',
+  overflow: 'hidden'
+});
 export const RenderAssetsContent = props => {
   const {
     status,
@@ -15,10 +22,11 @@ export const RenderAssetsContent = props => {
     columns,
     defaultVisibleColumnKeys,
     onVisibleColumnKeysChange,
-    modalRenderInstanceId
+    modalRenderInstanceId,
+    isFetchingInitialData
   } = props;
   const resolvedWithNoResults = status === 'resolved' && !responseItems.length;
-  const issueLikeDataTableView = useMemo(() => /*#__PURE__*/React.createElement(IssueLikeDataTableView, {
+  const issueLikeDataTableView = useMemo(() => jsx(IssueLikeDataTableView, {
     testId: "asset-datasource-table",
     status: status,
     columns: columns,
@@ -30,16 +38,23 @@ export const RenderAssetsContent = props => {
     onVisibleColumnKeysChange: onVisibleColumnKeysChange,
     parentContainerRenderInstanceId: modalRenderInstanceId
   }), [columns, defaultVisibleColumnKeys, hasNextPage, loadDatasourceDetails, onNextPage, onVisibleColumnKeysChange, responseItems, status, visibleColumnKeys, modalRenderInstanceId]);
-  if (status === 'rejected') {
-    return /*#__PURE__*/React.createElement(ModalLoadingError, null);
+  if (isFetchingInitialData) {
+    // Placing this check first as it's a priority before all others
+    return jsx("div", {
+      css: emptyStateOverrideStyles
+    }, jsx(EmptyState, {
+      testId: "assets-aql-datasource-modal--loading-state"
+    }));
+  } else if (status === 'rejected') {
+    return jsx(ModalLoadingError, null);
   } else if (status === 'unauthorized') {
-    return /*#__PURE__*/React.createElement(AccessRequired, null);
+    return jsx(AccessRequired, null);
   } else if (status === 'empty') {
-    return /*#__PURE__*/React.createElement(InitialStateView, null);
+    return jsx(InitialStateView, null);
   } else if (resolvedWithNoResults) {
-    return /*#__PURE__*/React.createElement(NoResults, null);
+    return jsx(NoResults, null);
   } else if (status === 'loading' && !columns.length) {
-    return /*#__PURE__*/React.createElement(EmptyState, {
+    return jsx(EmptyState, {
       testId: "assets-aql-datasource-modal--loading-state"
     });
   }

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

@@ -35,7 +35,7 @@ export const AssetsSearchContainer = props => {
   }, ({
     formProps
   }) => {
-    var _initialSearchData$ob, _initialSearchData$aq;
+    var _initialSearchData$ob, _initialSearchData$ob2, _initialSearchData$aq;
     return jsx(FormContainer, _extends({}, formProps, {
       id: SEARCH_FORM_ID
     }), jsx(FormRowContainer, {
@@ -43,6 +43,7 @@ export const AssetsSearchContainer = props => {
     }, modalTitle, jsx(SchemaSelectContainer, null, jsx(AssetsObjectSchemaSelect, {
       value: (_initialSearchData$ob = initialSearchData.objectSchema) !== null && _initialSearchData$ob !== void 0 ? _initialSearchData$ob : undefined,
       workspaceId: workspaceId,
+      initialObjectSchemas: (_initialSearchData$ob2 = initialSearchData.objectSchemas) !== null && _initialSearchData$ob2 !== void 0 ? _initialSearchData$ob2 : undefined,
       classNamePrefix: "assets-datasource-modal--object-schema-select"
     }))), jsx(FormRowContainer, null, jsx(AqlSearchInput, {
       value: (_initialSearchData$aq = initialSearchData.aql) !== null && _initialSearchData$aq !== void 0 ? _initialSearchData$aq : DEFAULT_AQL_QUERY,

package/dist/es2019/ui/assets-modal/search-container/object-schema-select/index.js

@@ -1,14 +1,12 @@
 import _extends from "@babel/runtime/helpers/extends";
 /** @jsx jsx */
 
-import { useEffect, useState } from 'react';
 import { jsx } from '@emotion/react';
 import debounce from 'debounce-promise';
 import { useIntl } from 'react-intl-next';
 import { Field } from '@atlaskit/form';
 import { AsyncSelect } from '@atlaskit/select';
 import { layers } from '@atlaskit/theme/constants';
-import { useDatasourceAnalyticsEvents } from '../../../../analytics';
 import { useObjectSchemas } from '../../../../hooks/useObjectSchemas';
 import { objectSchemaKey } from '../../../../types/assets/types';
 import { FieldContainer } from '../styled';
@@ -35,12 +33,9 @@ export const selectInAModalStyleFixProps = {
 export const AssetsObjectSchemaSelect = ({
   value,
   workspaceId,
+  initialObjectSchemas,
   classNamePrefix = 'assets-datasource-modal--object-schema-select'
 }) => {
-  const [defaultOptions, setDefaultOptions] = useState(null);
-  const {
-    fireEvent
-  } = useDatasourceAnalyticsEvents();
   const {
     formatMessage
   } = useIntl();
@@ -49,24 +44,6 @@ export const AssetsObjectSchemaSelect = ({
     objectSchemasLoading
   } = useObjectSchemas(workspaceId);
   const selectedObjectSchema = value ? objectSchemaToSelectOption(value) : undefined;
-  useEffect(() => {
-    const fetchInitialData = async () => {
-      const {
-        objectSchemas,
-        totalObjectSchemas
-      } = await fetchObjectSchemas('');
-      // We only want to send modal ready event once after we've fetched the schema count
-      fireEvent('ui.modal.ready.datasource', {
-        schemasCount: totalObjectSchemas !== null && totalObjectSchemas !== void 0 ? totalObjectSchemas : 0,
-        instancesCount: null
-      });
-      setDefaultOptions(mapObjectSchemasToOptions(objectSchemas));
-    };
-    if (defaultOptions === null) {
-      fetchInitialData();
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
   const loadOptions = async inputValue => {
     const {
       objectSchemas
@@ -94,7 +71,7 @@ export const AssetsObjectSchemaSelect = ({
     autoFocus: true,
     classNamePrefix: classNamePrefix,
     isLoading: objectSchemasLoading,
-    defaultOptions: defaultOptions !== null && defaultOptions !== void 0 ? defaultOptions : [],
+    defaultOptions: mapObjectSchemasToOptions(initialObjectSchemas),
     isSearchable: true,
     loadOptions: debouncedLoadOptions,
     placeholder: formatMessage(objectSchemaSelectMessages.placeholder),

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

@@ -17,7 +17,8 @@ export const useFilterOptions = ({
     pageCursor,
     searchString
   } = {}) => {
-    setStatus('loading');
+    const isNewSearch = !pageCursor;
+    isNewSearch ? setStatus('loading') : setStatus('loadingMore');
     const isRequestLikeInitialSearch = !pageCursor && !searchString;
     const {
       current: initialResponseData
@@ -34,7 +35,6 @@ export const useFilterOptions = ({
         setStatus('rejected');
         return;
       }
-      const isNewSearch = !pageCursor;
       if (isNewSearch) {
         setFilterOptions(mapFieldValuesToFilterOptions(response));
         if (isRequestLikeInitialSearch) {

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

@@ -31,7 +31,8 @@ const AsyncPopupSelect = ({
     filterOptions,
     fetchFilterOptions,
     totalCount,
-    status
+    status,
+    pageCursor
   } = useFilterOptions({
     filterType,
     cloudId
@@ -59,6 +60,14 @@ const AsyncPopupSelect = ({
       });
     }
   }, [fetchFilterOptions, searchTerm, status]);
+  const handleShowMore = useCallback(() => {
+    if (pageCursor) {
+      fetchFilterOptions({
+        pageCursor,
+        searchString: searchTerm
+      });
+    }
+  }, [fetchFilterOptions, pageCursor, searchTerm]);
   useEffect(() => {
     if (status === 'resolved') {
       var _pickerRef$current, _pickerRef$current$se, _pickerRef$current$se2;
@@ -69,8 +78,11 @@ const AsyncPopupSelect = ({
   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 shouldShowFooter = status === 'resolved' && filterOptionsLength > 0;
+  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 shouldDisplayShowMoreButton = status === 'resolved' && !!pageCursor && !areAllResultsLoaded;
   const options = isLoading || isError ? [] : filterOptions; // if not set to [], for eg: on loading, no loading UI will be shown
 
   return /*#__PURE__*/React.createElement(PopupSelect, {
@@ -98,7 +110,10 @@ const AsyncPopupSelect = ({
       MenuList: props => /*#__PURE__*/React.createElement(CustomMenuList, _extends({}, props, {
         isError: isError,
         isEmpty: isEmpty,
-        isLoading: isLoading
+        isLoading: isLoading,
+        isLoadingMore: isLoadingMore,
+        showMore: shouldDisplayShowMoreButton,
+        handleShowMore: handleShowMore
       })),
       DropdownIndicator: CustomDropdownIndicator,
       LoadingIndicator: undefined,

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

@@ -28,5 +28,10 @@ export const asyncPopupSelectMessages = {
     id: 'linkDataSource.basic-filter.assignee.label',
     description: 'Label to be displayed for assignee filter dropdown button.',
     defaultMessage: 'Assignee'
+  },
+  showMoreMessage: {
+    id: 'linkDataSource.basic-filter.showMoreButton',
+    defaultMessage: 'Show more',
+    description: 'The text to show more options in dropdown'
   }
 };

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

@@ -0,0 +1,17 @@
+import React from 'react';
+import { useIntl } from 'react-intl-next';
+import Button from '@atlaskit/button';
+import { asyncPopupSelectMessages } from './messages';
+const ShowMoreButton = ({
+  onShowMore
+}) => {
+  const {
+    formatMessage
+  } = useIntl();
+  return /*#__PURE__*/React.createElement(Button, {
+    onClick: onShowMore,
+    appearance: "link",
+    testId: "jlol-basic-filter-popup-select--show-more-button"
+  }, formatMessage(asyncPopupSelectMessages.showMoreMessage));
+};
+export default ShowMoreButton;

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

@@ -1,16 +1,29 @@
 import React from 'react';
+import { Flex } from '@atlaskit/primitives';
 import { components } from '@atlaskit/select';
+import Spinner from '@atlaskit/spinner';
+import ShowMoreButton from '../async-popup-select/showMoreButton';
 import CustomErrorMessage from './errorMessage';
 import CustomDropdownLoadingMessage from './loadingMessage';
 import CustomNoOptionsMessage from './noOptionsMessage';
 const CustomMenuList = ({
   isLoading,
+  isLoadingMore,
   isError,
   isEmpty,
+  showMore,
+  handleShowMore,
   children,
   ...props
 }) => {
-  const getChildComponent = () => {
+  const shouldDisplayShowMore = showMore && !isLoadingMore;
+  const isLoadingMoreData = !shouldDisplayShowMore && isLoadingMore;
+  const InlineSpinner = () => /*#__PURE__*/React.createElement(Flex, {
+    justifyContent: "center"
+  }, /*#__PURE__*/React.createElement(Spinner, {
+    size: "medium"
+  }));
+  const renderChildren = () => {
     if (isLoading) {
       return /*#__PURE__*/React.createElement(CustomDropdownLoadingMessage, null);
     }
@@ -20,8 +33,10 @@ const CustomMenuList = ({
     if (isEmpty) {
       return /*#__PURE__*/React.createElement(CustomNoOptionsMessage, null);
     }
-    return children;
+    return /*#__PURE__*/React.createElement(React.Fragment, null, children, shouldDisplayShowMore && /*#__PURE__*/React.createElement(ShowMoreButton, {
+      onShowMore: handleShowMore
+    }), isLoadingMoreData && /*#__PURE__*/React.createElement(InlineSpinner, null));
   };
-  return /*#__PURE__*/React.createElement(components.MenuList, props, getChildComponent());
+  return /*#__PURE__*/React.createElement(components.MenuList, props, renderChildren());
 };
 export default CustomMenuList;

package/dist/esm/analytics/constants.js

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

package/dist/esm/hooks/useAssetsClient.js

@@ -2,7 +2,14 @@ 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 { fetchObjectSchema, getWorkspaceId } from '../services/cmdbService';
+import { fetchObjectSchema, fetchObjectSchemas, getWorkspaceId } from '../services/cmdbService';
+var handleAssetsClientErrors = function handleAssetsClientErrors(errorSetter, error) {
+  if (error instanceof Error) {
+    errorSetter(error);
+  } else {
+    errorSetter(new Error('Unexpected error occured'));
+  }
+};
 export var useAssetsClient = function useAssetsClient(initialParameters) {
   var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
@@ -14,29 +21,51 @@ export var useAssetsClient = function useAssetsClient(initialParameters) {
     setWorkspaceId = _useState4[1];
   var _useState5 = useState(),
     _useState6 = _slicedToArray(_useState5, 2),
-    objectSchema = _useState6[0],
-    setObjectSchema = _useState6[1];
+    workspaceError = _useState6[0],
+    setWorkspaceError = _useState6[1];
   var _useState7 = useState(),
     _useState8 = _slicedToArray(_useState7, 2),
-    error = _useState8[0],
-    setError = _useState8[1];
+    existingObjectSchema = _useState8[0],
+    setExistingObjectSchema = _useState8[1];
+  var _useState9 = useState(),
+    _useState10 = _slicedToArray(_useState9, 2),
+    existingObjectSchemaError = _useState10[0],
+    setExistingObjectSchemaError = _useState10[1];
+  var _useState11 = useState(),
+    _useState12 = _slicedToArray(_useState11, 2),
+    objectSchemas = _useState12[0],
+    setObjectSchemas = _useState12[1];
+  var _useState13 = useState(),
+    _useState14 = _slicedToArray(_useState13, 2),
+    totalObjectSchemas = _useState14[0],
+    setTotalObjectSchemas = _useState14[1];
+  var _useState15 = useState(),
+    _useState16 = _slicedToArray(_useState15, 2),
+    objectSchemasError = _useState16[0],
+    setObjectSchemasError = _useState16[1];
+
+  /*
+   * We wrap this in nested try/catch blocks because we want to handle
+   * workspaceError/existingObjectSchemaError/objectSchemasError differently
+   * if we need to implement more initial data fetching/errors we should look at a store
+   */
   useEffect(function () {
     _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var _workspaceId, fetchedObjectSchema;
+      var _workspaceId, fetchedObjectSchema, fetchedObjectSchemasResponse;
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
             setLoading(true);
-            setError(undefined);
+            setWorkspaceError(undefined);
             _context.prev = 2;
             _context.next = 5;
             return getWorkspaceId();
           case 5:
             _workspaceId = _context.sent;
             setWorkspaceId(_workspaceId);
-            // Check schema from initial parameters still exists and fetch name for schema select
+            // Check schema from initial parameters still exists and fetch name/permissions for schema select
             if (!(initialParameters !== null && initialParameters !== void 0 && initialParameters.schemaId)) {
-              _context.next = 17;
+              _context.next = 18;
               break;
             }
             _context.prev = 8;
@@ -44,38 +73,53 @@ export var useAssetsClient = function useAssetsClient(initialParameters) {
             return fetchObjectSchema(_workspaceId, initialParameters === null || initialParameters === void 0 ? void 0 : initialParameters.schemaId);
           case 11:
             fetchedObjectSchema = _context.sent;
-            setObjectSchema(fetchedObjectSchema);
-            _context.next = 17;
+            setExistingObjectSchema(fetchedObjectSchema);
+            _context.next = 18;
             break;
           case 15:
             _context.prev = 15;
             _context.t0 = _context["catch"](8);
-          case 17:
-            _context.next = 22;
+            handleAssetsClientErrors(setExistingObjectSchemaError, _context.t0);
+          case 18:
+            _context.prev = 18;
+            _context.next = 21;
+            return fetchObjectSchemas(_workspaceId);
+          case 21:
+            fetchedObjectSchemasResponse = _context.sent;
+            setObjectSchemas(fetchedObjectSchemasResponse.values);
+            setTotalObjectSchemas(fetchedObjectSchemasResponse.total);
+            _context.next = 29;
             break;
-          case 19:
-            _context.prev = 19;
-            _context.t1 = _context["catch"](2);
-            if (_context.t1 instanceof Error) {
-              setError(_context.t1);
-            } else {
-              setError(new Error('Unexpected error occured'));
-            }
-          case 22:
-            _context.prev = 22;
+          case 26:
+            _context.prev = 26;
+            _context.t1 = _context["catch"](18);
+            handleAssetsClientErrors(setObjectSchemasError, _context.t1);
+          case 29:
+            _context.next = 34;
+            break;
+          case 31:
+            _context.prev = 31;
+            _context.t2 = _context["catch"](2);
+            handleAssetsClientErrors(setWorkspaceError, _context.t2);
+          case 34:
+            _context.prev = 34;
             setLoading(false);
-            return _context.finish(22);
-          case 25:
+            return _context.finish(34);
+          case 37:
           case "end":
             return _context.stop();
         }
-      }, _callee, null, [[2, 19, 22, 25], [8, 15]]);
+      }, _callee, null, [[2, 31, 34, 37], [8, 15], [18, 26]]);
     }))();
   }, [initialParameters]);
   return {
     workspaceId: workspaceId,
-    workspaceError: error,
-    objectSchema: objectSchema,
+    workspaceError: workspaceError,
+    existingObjectSchema: existingObjectSchema,
+    existingObjectSchemaError: existingObjectSchemaError,
+    objectSchemas: objectSchemas,
+    totalObjectSchemas: totalObjectSchemas,
+    objectSchemasError: objectSchemasError,
     assetsClientLoading: loading
   };
 };