@atlaskit/link-datasource 1.15.2 → 1.15.4

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/issue-like-table/render-type/date-time/index.js

@@ -21,8 +21,14 @@ const DateTimeRenderType = ({
   testId = DATETIME_TYPE_TEST_ID,
   display = 'datetime'
 }) => {
-  const date = new Date(value);
   const intl = useIntl();
+  /* In some cases we get a value of `2023-12-20` which when parsed by JS assumes meantime timezone, causing the date
+    to be one day off in some timezones. We want it to display the date without converting timezones and a solution
+   is to replace the hyphens with slashes. So it should be 20th Dec regardless of the timezone in this case.
+    See https://stackoverflow.com/a/31732581
+   */
+  const dateValue = /^\d{4}-\d{2}-\d{2}$/.exec(value) ? value.replace(/-/g, '/') : value;
+  const date = new Date(dateValue);
   if (!value || isNaN(date.getTime())) {
     return /*#__PURE__*/React.createElement(React.Fragment, null);
   }

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.2"
+  packageVersion: "1.15.4"
 };

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

package/dist/esm/services/cmdbService.js

@@ -1,51 +1,151 @@
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 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 _workspaceDetailsResp;
-    var url, workspaceDetailsResponse;
+    var url, _workspaceDetailsResp, workspaceDetailsResponse, error;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
           url = '/rest/servicedesk/cmdb/latest/workspace';
-          _context.next = 3;
+          _context.prev = 1;
+          _context.next = 4;
           return request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
-        case 3:
+        case 4:
           workspaceDetailsResponse = _context.sent;
           if ((_workspaceDetailsResp = workspaceDetailsResponse.results) !== null && _workspaceDetailsResp !== void 0 && _workspaceDetailsResp.length) {
-            _context.next = 6;
+            _context.next = 7;
             break;
           }
-          throw new Error('No workspace results found');
-        case 6:
-          return _context.abrupt("return", workspaceDetailsResponse.results[0].id);
+          throw new PermissionError('No workspace results found');
         case 7:
+          return _context.abrupt("return", workspaceDetailsResponse.results[0].id);
+        case 10:
+          _context.prev = 10;
+          _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
+            if (getStatusCodeGroup(error) !== '5xx' && error.statusCode !== 429) {
+              error = new PermissionError('Failed to fetch workspace');
+            }
+          }
+          throw error;
+        case 15:
         case "end":
           return _context.stop();
       }
-    }, _callee);
+    }, _callee, null, [[1, 10]]);
   }));
   return function getWorkspaceId() {
     return _ref.apply(this, arguments);
   };
 }();
-export var validateAql = function validateAql(workspaceId, data) {
-  var url = "/gateway/api/jsm/assets/workspace/".concat(workspaceId, "/v1/aql/validate");
-  return request('post', url, {
-    qlQuery: data.qlQuery,
-    context: 'SMART_LINKS'
-  }, undefined, [200, 201, 202, 203, 204]);
-};
-export var fetchObjectSchema = function fetchObjectSchema(workspaceId, schemaId) {
-  var url = "/gateway/api/jsm/assets/workspace/".concat(workspaceId, "/v1/objectschema/").concat(schemaId);
-  return request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
-};
-export var fetchObjectSchemas = function fetchObjectSchemas(workspaceId, query) {
-  var queryParams = new URLSearchParams();
-  queryParams.set('maxResults', '20');
-  queryParams.set('includeCounts', 'false');
-  query && queryParams.set('query', query);
-  var url = "/gateway/api/jsm/assets/workspace/".concat(workspaceId, "/v1/objectschema/list?").concat(queryParams);
-  return request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
-};
+export var validateAql = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(workspaceId, data) {
+    var url, error;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          url = "/gateway/api/jsm/assets/workspace/".concat(workspaceId, "/v1/aql/validate");
+          _context2.prev = 1;
+          _context2.next = 4;
+          return request('post', url, {
+            qlQuery: data.qlQuery,
+            context: 'SMART_LINKS'
+          }, undefined, [200, 201, 202, 203, 204]);
+        case 4:
+          return _context2.abrupt("return", _context2.sent);
+        case 7:
+          _context2.prev = 7;
+          _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
+            if (error.statusCode === 401 || error.statusCode === 403) {
+              error = new PermissionError('Failed to fetch object schemas');
+            }
+          }
+          throw error;
+        case 12:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[1, 7]]);
+  }));
+  return function validateAql(_x, _x2) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+export var fetchObjectSchema = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(workspaceId, schemaId) {
+    var url, error;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          url = "/gateway/api/jsm/assets/workspace/".concat(workspaceId, "/v1/objectschema/").concat(schemaId);
+          _context3.prev = 1;
+          _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;
+          _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
+            if (error.statusCode === 401 || error.statusCode === 403) {
+              error = new PermissionError('Failed to fetch object schemas');
+            }
+          }
+          throw error;
+        case 12:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[1, 7]]);
+  }));
+  return function fetchObjectSchema(_x3, _x4) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+export var fetchObjectSchemas = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(workspaceId, query) {
+    var queryParams, url, error;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          queryParams = new URLSearchParams();
+          queryParams.set('maxResults', '20');
+          queryParams.set('includeCounts', 'false');
+          query && queryParams.set('query', query);
+          url = "/gateway/api/jsm/assets/workspace/".concat(workspaceId, "/v1/objectschema/list?").concat(queryParams);
+          _context4.prev = 5;
+          _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;
+          _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
+            if (error.statusCode === 401 || error.statusCode === 403) {
+              error = new PermissionError('Failed to fetch object schemas');
+            }
+          }
+          throw error;
+        case 16:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[5, 11]]);
+  }));
+  return function fetchObjectSchemas(_x5, _x6) {
+    return _ref4.apply(this, arguments);
+  };
+}();

package/dist/esm/services/cmdbService.utils.js

@@ -0,0 +1,57 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+export var mapFetchErrors = function mapFetchErrors(error) {
+  if (error instanceof Response && !error.ok) {
+    return new FetchError(error.status, "Error server response: ".concat(error.status));
+  }
+  return error;
+};
+export var getStatusCodeGroup = function getStatusCodeGroup(error) {
+  if (error instanceof FetchError) {
+    var statusCode = error.statusCode;
+    if (statusCode >= 100 && statusCode < 200) {
+      return '1xx';
+    }
+    if (statusCode >= 300 && statusCode < 400) {
+      return '3xx';
+    }
+    if (statusCode >= 400 && statusCode < 500) {
+      return '4xx';
+    }
+    if (statusCode >= 500 && statusCode < 600) {
+      return '5xx';
+    }
+  }
+  return 'unknown';
+};
+export var PermissionError = /*#__PURE__*/function (_Error) {
+  _inherits(PermissionError, _Error);
+  var _super = _createSuper(PermissionError);
+  function PermissionError(message) {
+    var _this;
+    _classCallCheck(this, PermissionError);
+    _this = _super.call(this, message);
+    _this.name = 'PermissionError';
+    return _this;
+  }
+  return _createClass(PermissionError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export var FetchError = /*#__PURE__*/function (_Error2) {
+  _inherits(FetchError, _Error2);
+  var _super2 = _createSuper(FetchError);
+  function FetchError(statusCode, message) {
+    var _this2;
+    _classCallCheck(this, FetchError);
+    _this2 = _super2.call(this, message || "Fetch call failed with status code: ".concat(statusCode));
+    _this2.name = 'FetchError';
+    _this2.statusCode = statusCode;
+    return _this2;
+  }
+  return _createClass(FetchError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));

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

@@ -24,6 +24,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';
@@ -34,6 +36,9 @@ var modalBodyWrapperStyles = css({
   height: '420px',
   overflow: 'auto'
 });
+var modalBodyErrorWrapperStyles = css({
+  alignItems: 'center'
+});
 var AssetsModalTitle = jsx(ModalTitle, null, jsx(FormattedMessage, modalMessages.insertObjectsTitle));
 var PlainAssetsConfigModal = function PlainAssetsConfigModal(props) {
   var datasourceId = props.datasourceId,
@@ -57,17 +62,53 @@ var PlainAssetsConfigModal = function PlainAssetsConfigModal(props) {
     _useState8 = _slicedToArray(_useState7, 2),
     isNewSearch = _useState8[0],
     setIsNewSearch = _useState8[1];
+  var _useState9 = useState(),
+    _useState10 = _slicedToArray(_useState9, 2),
+    errorState = _useState10[0],
+    setErrorState = _useState10[1];
   var _useDatasourceAnalyti = useDatasourceAnalyticsEvents(),
     fireEvent = _useDatasourceAnalyti.fireEvent;
   var _useRef = useRef(uuidv4()),
     modalRenderInstanceId = _useRef.current;
-
-  // If a workspaceError occurs this is a critical error
   var _useAssetsClient = useAssetsClient(initialParameters),
     workspaceId = _useAssetsClient.workspaceId,
     workspaceError = _useAssetsClient.workspaceError,
-    objectSchema = _useAssetsClient.objectSchema,
+    existingObjectSchema = _useAssetsClient.existingObjectSchema,
+    existingObjectSchemaError = _useAssetsClient.existingObjectSchemaError,
+    objectSchemas = _useAssetsClient.objectSchemas,
+    objectSchemasError = _useAssetsClient.objectSchemasError,
+    totalObjectSchemas = _useAssetsClient.totalObjectSchemas,
     assetsClientLoading = _useAssetsClient.assetsClientLoading;
+
+  /* ------------------------------ PERMISSIONS ------------------------------ */
+  useEffect(function () {
+    if (workspaceError) {
+      // If a workspaceError occurs this is a critical error
+      if (workspaceError instanceof PermissionError) {
+        setErrorState('permission');
+      } else {
+        setErrorState('network');
+      }
+    }
+  }, [workspaceError]);
+  useEffect(function () {
+    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(function () {
+    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 ------------------------------ */
+
   var parameters = useMemo(function () {
     return {
       aql: aql || '',
@@ -105,6 +146,15 @@ var PlainAssetsConfigModal = function PlainAssetsConfigModal(props) {
       destinationObjectTypes: destinationObjectTypes
     };
   }, [destinationObjectTypes, extensionKey]);
+  useEffect(function () {
+    // 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(function () {
     fireEvent('screen.datasourceModalDialog.viewed', {});
   }, [fireEvent]);
@@ -158,7 +208,7 @@ var PlainAssetsConfigModal = function PlainAssetsConfigModal(props) {
       setVisibleColumnKeys(defaultVisibleColumnKeys);
     }
   }, [defaultVisibleColumnKeys, isNewSearch]);
-  var isDisabled = !!workspaceError || status !== 'resolved' || assetsClientLoading || !aql || !schemaId;
+  var isDisabled = !!errorState || status !== 'resolved' || assetsClientLoading || !aql || !schemaId;
   var retrieveUrlForSmartCardRender = useCallback(function () {
     var _data$key;
     var _responseItems = _slicedToArray(responseItems, 1),
@@ -260,8 +310,20 @@ var PlainAssetsConfigModal = function PlainAssetsConfigModal(props) {
       return _ref.apply(this, arguments);
     };
   }(), [aql, reset, schemaId, status]);
+  var renderErrorState = useCallback(function () {
+    if (errorState) {
+      switch (errorState) {
+        case 'permission':
+          return jsx(AccessRequired, null);
+        case 'network':
+          return jsx(ModalLoadingError, null);
+        default:
+          return jsx(ModalLoadingError, null);
+      }
+    }
+  }, [errorState]);
   var renderModalTitleContent = useCallback(function () {
-    if (workspaceError) {
+    if (errorState) {
       return undefined;
     } else {
       if (!workspaceId || assetsClientLoading) {
@@ -273,14 +335,15 @@ var PlainAssetsConfigModal = function PlainAssetsConfigModal(props) {
         workspaceId: workspaceId,
         initialSearchData: {
           aql: aql,
-          objectSchema: objectSchema
+          objectSchema: existingObjectSchema,
+          objectSchemas: 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
@@ -291,8 +354,9 @@ var PlainAssetsConfigModal = function 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,