@atlaskit/link-datasource 0.29.3 → 0.29.5

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

@@ -6,9 +6,13 @@ import Button from '@atlaskit/button/standard-button';
 import Modal, { ModalBody, ModalFooter, ModalHeader, ModalTitle, ModalTransition } from '@atlaskit/modal-dialog';
 import { useAssetsClient } from '../../../hooks/useAssetsClient';
 import { useDatasourceTableState } from '../../../hooks/useDatasourceTableState';
+import { ModalLoadingError } from '../../common/error-state/modal-loading-error';
+import { AssetsSearchContainer } from '../search-container';
+import { AssetsSearchContainerLoading } from '../search-container/loading-state';
 import { modalMessages } from './messages';
 import { RenderAssetsContent } from './render-assets-content';
 import { ModalContentContainer } from './styled';
+const AssetsModalTitle = jsx(ModalTitle, null, jsx(FormattedMessage, modalMessages.insertObjectsTitle));
 export const AssetsConfigModal = props => {
   const {
     datasourceId,
@@ -17,16 +21,22 @@ export const AssetsConfigModal = props => {
     onInsert,
     visibleColumnKeys: initialVisibleColumnKeys
   } = props;
-  const [aql] = useState(initialParameters === null || initialParameters === void 0 ? void 0 : initialParameters.aql);
-  const [schemaId] = useState(initialParameters === null || initialParameters === void 0 ? void 0 : initialParameters.schemaId);
+  const [aql, setAql] = useState(initialParameters === null || initialParameters === void 0 ? void 0 : initialParameters.aql);
+  const [schemaId, setSchemaId] = useState(initialParameters === null || initialParameters === void 0 ? void 0 : initialParameters.schemaId);
   const [visibleColumnKeys, setVisibleColumnKeys] = useState(initialVisibleColumnKeys);
+
+  // If a workspaceError occurs this is a critical error
   const {
-    workspaceId
-  } = useAssetsClient();
+    workspaceId,
+    workspaceError,
+    objectSchema,
+    assetsClientLoading
+  } = useAssetsClient(initialParameters);
   const parameters = useMemo(() => ({
     aql: aql || '',
     schemaId: schemaId || '',
-    workspaceId: '' /* TODO FLY-1240: Add workspace Id */
+    workspaceId: '',
+    cloudId: ''
   }), [aql, schemaId]);
   const {
     status,
@@ -40,7 +50,7 @@ export const AssetsConfigModal = props => {
     const newVisibleColumnKeys = !initialVisibleColumnKeys || (initialVisibleColumnKeys || []).length === 0 ? defaultVisibleColumnKeys : initialVisibleColumnKeys;
     setVisibleColumnKeys(newVisibleColumnKeys);
   }, [initialVisibleColumnKeys, defaultVisibleColumnKeys]);
-  const isDisabled = status === 'rejected' || status === 'loading' || status === 'empty' || !aql || !workspaceId || !schemaId;
+  const isDisabled = status === 'rejected' || status === 'loading' || status === 'empty' || !!workspaceError || assetsClientLoading || !aql || !schemaId;
   const retrieveUrlForSmartCardRender = useCallback(() => {
     var _data$key, _data$key$data;
     const [data] = responseItems;
@@ -48,7 +58,7 @@ export const AssetsConfigModal = props => {
     return data === null || data === void 0 ? void 0 : (_data$key = data.key) === null || _data$key === void 0 ? void 0 : (_data$key$data = _data$key.data) === null || _data$key$data === void 0 ? void 0 : _data$key$data.url;
   }, [responseItems]);
   const onInsertPressed = useCallback(() => {
-    if (!aql) {
+    if (!aql || !schemaId) {
       return;
     }
     const firstAssetUrl = retrieveUrlForSmartCardRender();
@@ -84,12 +94,36 @@ export const AssetsConfigModal = props => {
       });
     }
   }, [aql, datasourceId, onInsert, responseItems.length, retrieveUrlForSmartCardRender, schemaId, visibleColumnKeys]);
+  const handleOnSearch = useCallback((aql, schemaId) => {
+    setAql(aql);
+    setSchemaId(schemaId);
+  }, []);
+  const renderModalTitleContent = useCallback(() => {
+    if (workspaceError) {
+      return undefined;
+    } else {
+      if (!workspaceId || assetsClientLoading) {
+        return jsx(AssetsSearchContainerLoading, {
+          modalTitle: AssetsModalTitle
+        });
+      }
+      return jsx(AssetsSearchContainer, {
+        workspaceId: workspaceId,
+        initialSearchData: {
+          aql,
+          objectSchema
+        },
+        onSearch: handleOnSearch,
+        modalTitle: AssetsModalTitle
+      });
+    }
+  }, [aql, assetsClientLoading, handleOnSearch, objectSchema, workspaceError, workspaceId]);
   return jsx(ModalTransition, null, jsx(Modal, {
     testId: 'asset-datasource-modal',
     onClose: onCancel,
     width: "x-large",
     shouldScrollInViewport: true
-  }, jsx(ModalHeader, null, jsx(ModalTitle, null)), jsx(ModalBody, null, jsx(ModalContentContainer, null, jsx(RenderAssetsContent, {
+  }, jsx(ModalHeader, null, renderModalTitleContent()), jsx(ModalBody, null, jsx(ModalContentContainer, null, workspaceError ? jsx(ModalLoadingError, null) : jsx(RenderAssetsContent, {
     status: status,
     responseItems: responseItems
   }))), jsx(ModalFooter, null, jsx(Button, {

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

@@ -9,5 +9,10 @@ export const modalMessages = defineMessages({
     id: 'linkDataSource.assets.configmodal.insertIssuesButtonText',
     description: 'Button text to insert the displayed content',
     defaultMessage: 'Insert objects'
+  },
+  insertObjectsTitle: {
+    id: 'linkDataSource.assets.configmodal.insertObjectsTitle',
+    description: 'Title for the Assets Objects Datasource config modal which prefixes a select picker',
+    defaultMessage: 'Insert objects from'
   }
 });

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

@@ -1,6 +1,6 @@
 import styled from '@emotion/styled';
 export const ModalContentContainer = styled.div`
-  display: 'grid';
-  height: '420px';
-  overflow: 'auto';
+  display: grid;
+  height: 420px;
+  overflow: auto;
 `;

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

@@ -0,0 +1,129 @@
+import _extends from "@babel/runtime/helpers/extends";
+/** @jsx jsx */
+import { useCallback, useRef } from 'react';
+import { css, jsx } from '@emotion/react';
+import { useIntl } from 'react-intl-next';
+import Button from '@atlaskit/button';
+import { Field } from '@atlaskit/form';
+import CheckCircleIcon from '@atlaskit/icon/glyph/check-circle';
+import CrossCircleIcon from '@atlaskit/icon/glyph/cross-circle';
+import SearchIcon from '@atlaskit/icon/glyph/editor/search';
+import Spinner from '@atlaskit/spinner';
+import Textfield from '@atlaskit/textfield';
+import { useValidateAqlText } from '../../../../hooks/useValidateAqlText';
+import { aqlKey } from '../../../../types/assets/types';
+import { FieldContainer } from '../styled';
+import { searchInputMessages } from './messages';
+
+/* Meta isn't exported in @atlaskit/form
+Taken from packages/design-system/form/src/field.tsx */
+
+const searchButtonStyles = css({
+  marginRight: "var(--ds-space-075, 6px)"
+});
+export const SEARCH_DEBOUNCE_MS = 350;
+const renderValidatorIcon = (value, error, meta) => {
+  if (value && meta !== null && meta !== void 0 && meta.validating) {
+    return jsx(Spinner, {
+      size: "medium",
+      testId: "assets-datasource-modal--aql-validating"
+    });
+  }
+  if (value && error) {
+    return jsx(CrossCircleIcon, {
+      label: "label",
+      primaryColor: "red",
+      size: "medium",
+      testId: "assets-datasource-modal--aql-invalid"
+    });
+  }
+  if (value && meta.valid) {
+    return jsx(CheckCircleIcon, {
+      label: "label",
+      primaryColor: "green",
+      size: "medium",
+      testId: "assets-datasource-modal--aql-valid"
+    });
+  }
+  return jsx(SearchIcon, {
+    label: "label",
+    size: "medium",
+    testId: "assets-datasource-modal--aql-idle"
+  });
+};
+export const AqlSearchInput = ({
+  value,
+  workspaceId,
+  testId = 'assets-datasource-modal--aql-search-input'
+}) => {
+  const {
+    formatMessage
+  } = useIntl();
+  const timeout = useRef();
+  const lastValue = useRef(value);
+  const lastResult = useRef(Promise.resolve(undefined));
+  const {
+    validateAqlText
+  } = useValidateAqlText(workspaceId);
+
+  // Validation expects undefined when valid and a string as an error message when invalid
+  const handleValidation = useCallback(async newUnvalidatedQlQuery => {
+    if (!newUnvalidatedQlQuery) {
+      return undefined;
+    }
+    const isValid = await validateAqlText(newUnvalidatedQlQuery);
+    return isValid ? undefined : 'invalid';
+  }, [validateAqlText]);
+
+  /* Debounce async validation for input, validation is also called on every field change
+  in a form so we need to also memoize. The async validate function is expected to either:
+  Immediately return a promise (which is then collected into an array, every single time validation is run),
+  or immediately return either undefined or an error message */
+  const debouncedMemoizedValidation = value => new Promise(resolve => {
+    if (timeout.current) {
+      timeout.current();
+    }
+    if (value !== lastValue.current) {
+      const timerId = setTimeout(() => {
+        lastValue.current = value;
+        lastResult.current = handleValidation(value);
+        resolve(lastResult.current);
+      }, SEARCH_DEBOUNCE_MS);
+      timeout.current = () => {
+        clearTimeout(timerId);
+        resolve('debouncing');
+      };
+    } else {
+      resolve(lastResult.current);
+    }
+  });
+  return jsx(FieldContainer, null, jsx(Field, {
+    name: aqlKey,
+    defaultValue: value,
+    validate: debouncedMemoizedValidation
+  }, ({
+    fieldProps,
+    meta,
+    error
+  }) => jsx(Textfield, _extends({}, fieldProps, {
+    elemBeforeInput: jsx("span", {
+      style: {
+        paddingLeft: 6,
+        width: 24
+      }
+    }, renderValidatorIcon(fieldProps.value, error, meta)),
+    elemAfterInput: jsx(Button, {
+      appearance: "primary",
+      css: searchButtonStyles,
+      iconBefore: jsx(SearchIcon, {
+        label: formatMessage(searchInputMessages.placeholder),
+        size: "medium"
+      }),
+      spacing: "none",
+      testId: "assets-datasource-modal--aql-search-button",
+      type: "submit"
+    }),
+    placeholder: formatMessage(searchInputMessages.placeholder),
+    testId: testId
+  }))));
+};

package/dist/es2019/ui/assets-modal/search-container/aql-search-input/loading-state.js

@@ -0,0 +1,8 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { Skeleton } from '@atlaskit/linking-common';
+export const AssetsAqlSearchInputSkeleton = () => jsx(Skeleton, {
+  width: "100%",
+  height: "40px",
+  testId: "assets-datasource-modal--aql-search-input-skeleton"
+});

package/dist/es2019/ui/assets-modal/search-container/aql-search-input/messages.js

@@ -0,0 +1,8 @@
+import { defineMessages } from 'react-intl-next';
+export const searchInputMessages = defineMessages({
+  placeholder: {
+    id: 'linkDataSource.assets.configModal.aqlSearchInput.placeholder',
+    description: 'Display text for AQL search button',
+    defaultMessage: 'Search via AQL'
+  }
+});

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

@@ -0,0 +1,46 @@
+import _extends from "@babel/runtime/helpers/extends";
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import Form from '@atlaskit/form';
+import { AqlSearchInput } from './aql-search-input';
+import { AssetsObjectSchemaSelect } from './object-schema-select';
+import { FormContainer, FormRowContainer, SchemaSelectContainer } from './styled';
+const DEFAULT_AQL_QUERY = '';
+const SEARCH_FORM_ID = 'linkDataSource.assets.configModal.searchContainer-form';
+export const AssetsSearchContainer = props => {
+  const {
+    onSearch,
+    workspaceId,
+    initialSearchData,
+    modalTitle
+  } = props;
+  const onFormSubmit = searchFormValues => {
+    const {
+      aql,
+      objectSchema
+    } = searchFormValues;
+    if (objectSchema) {
+      // Pass the validated aql and object schema back to modal
+      onSearch(aql, objectSchema.value);
+    }
+  };
+  return jsx(Form, {
+    onSubmit: onFormSubmit
+  }, ({
+    formProps
+  }) => {
+    var _initialSearchData$ob, _initialSearchData$aq;
+    return jsx(FormContainer, _extends({}, formProps, {
+      id: SEARCH_FORM_ID
+    }), jsx(FormRowContainer, {
+      isNarrowGap: true
+    }, modalTitle, jsx(SchemaSelectContainer, null, jsx(AssetsObjectSchemaSelect, {
+      value: (_initialSearchData$ob = initialSearchData.objectSchema) !== null && _initialSearchData$ob !== void 0 ? _initialSearchData$ob : undefined,
+      workspaceId: workspaceId,
+      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,
+      workspaceId: workspaceId
+    })));
+  });
+};

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

@@ -0,0 +1,14 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { AssetsAqlSearchInputSkeleton } from './aql-search-input/loading-state';
+import { AssetsObjectSchemaSelectSkeleton } from './object-schema-select/loading-state';
+import { FormContainer, FormRowContainer, SchemaSelectContainer } from './styled';
+export const AssetsSearchContainerLoading = ({
+  modalTitle
+}) => {
+  return jsx(FormContainer, {
+    "data-testid": "assets-datasource-modal--search-container-skeleton"
+  }, jsx(FormRowContainer, {
+    isNarrowGap: true
+  }, modalTitle, jsx(SchemaSelectContainer, null, jsx(AssetsObjectSchemaSelectSkeleton, null))), jsx(FormRowContainer, null, jsx(AssetsAqlSearchInputSkeleton, null)));
+};

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

@@ -0,0 +1,65 @@
+import _extends from "@babel/runtime/helpers/extends";
+/** @jsx jsx */
+import { 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 { useObjectSchemas } from '../../../../hooks/useObjectSchemas';
+import { objectSchemaKey } from '../../../../types/assets/types';
+import { FieldContainer } from '../styled';
+import { objectSchemaSelectMessages } from './messages';
+import { objectSchemaToSelectOption } from './utils';
+export const SEARCH_DEBOUNCE_MS = 350;
+export const AssetsObjectSchemaSelect = ({
+  value,
+  workspaceId,
+  classNamePrefix = 'assets-datasource-modal--object-schema-select'
+}) => {
+  const {
+    formatMessage
+  } = useIntl();
+  const {
+    fetchObjectSchemas,
+    objectSchemasLoading
+  } = useObjectSchemas(workspaceId);
+  const [defaultOptions, setDefaultOptions] = useState(undefined);
+  const selectedObjectSchema = value ? objectSchemaToSelectOption(value) : undefined;
+  const loadOptions = async inputValue => {
+    const objectSchemas = await fetchObjectSchemas(inputValue);
+    const options = objectSchemas ? objectSchemas.map(objectSchema => objectSchemaToSelectOption(objectSchema)) : [];
+    return options;
+  };
+  const debouncedLoadOptions = debounce(loadOptions, SEARCH_DEBOUNCE_MS);
+  const validateSchema = value => {
+    if (!value || !value.value) {
+      return formatMessage(objectSchemaSelectMessages.schemaRequired);
+    }
+    return undefined;
+  };
+  return jsx(FieldContainer, null, jsx(Field, {
+    name: objectSchemaKey,
+    defaultValue: selectedObjectSchema,
+    validate: value => validateSchema(value)
+  }, ({
+    fieldProps: {
+      onChange,
+      onFocus,
+      ...restFieldProps
+    }
+  }) => jsx(AsyncSelect, _extends({
+    classNamePrefix: classNamePrefix,
+    isLoading: objectSchemasLoading,
+    defaultOptions: defaultOptions || [],
+    isSearchable: true,
+    loadOptions: debouncedLoadOptions,
+    placeholder: formatMessage(objectSchemaSelectMessages.placeholder),
+    onChange: newOption => newOption && onChange(newOption),
+    onFocus: () => {
+      if (!defaultOptions) {
+        loadOptions('').then(setDefaultOptions);
+      }
+    }
+  }, restFieldProps))));
+};

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

@@ -0,0 +1,8 @@
+/** @jsx jsx */
+import { jsx } from '@emotion/react';
+import { Skeleton } from '@atlaskit/linking-common';
+export const AssetsObjectSchemaSelectSkeleton = () => jsx(Skeleton, {
+  width: "100%",
+  height: "40px",
+  testId: "assets-datasource-modal--object-schema-select-skeleton"
+});

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

@@ -0,0 +1,18 @@
+import { defineMessages } from 'react-intl-next';
+export const objectSchemaSelectMessages = defineMessages({
+  label: {
+    id: 'linkDataSource.assets.configModal.objectSchemaSelect.label',
+    description: 'Label text for a select input where users can choose an Assets object schema to use',
+    defaultMessage: 'Select schema'
+  },
+  placeholder: {
+    id: 'linkDataSource.assets.configModal.objectSchemaSelect.placeholder',
+    description: 'Placeholder text for a select input where users can choose an Assets object schema to use',
+    defaultMessage: 'Select schema'
+  },
+  schemaRequired: {
+    id: 'linkDataSource.assets.configModal.objectSchemaSelect.schemaRequired',
+    description: 'Validation message displayed to the user when the select is blank',
+    defaultMessage: 'Schema is required'
+  }
+});

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

@@ -0,0 +1,4 @@
+export const objectSchemaToSelectOption = objectSchema => ({
+  label: objectSchema.name,
+  value: objectSchema.id
+});

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

@@ -0,0 +1,22 @@
+import styled from '@emotion/styled';
+export const FormRowContainer = styled.div`
+  align-items: center;
+  display: flex;
+  gap: ${props => props.isNarrowGap ? "var(--ds-space-100, 8px)" : "var(--ds-space-200, 16px)"};
+  flex-grow: 1;
+  width: 100%;
+`;
+export const FormContainer = styled.form`
+  display: grid;
+  row-gap: ${"var(--ds-space-200, 16px)"};
+  width: 100%;
+`;
+
+// Override the top margin of fields
+export const FieldContainer = styled.div`
+  flex: 1;
+  margin-top: calc(-1 * ${"var(--ds-space-100, 8px)"});
+`;
+export const SchemaSelectContainer = styled.div`
+  width: 200px;
+`;

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/link-datasource",
-	"version": "0.29.3",
+	"version": "0.29.5",
 	"sideEffects": false
 }

package/dist/esm/hooks/useAssetsClient.js

@@ -2,61 +2,80 @@ 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 { fetchObjectSchemas, getWorkspaceId } from '../services/cmdbService';
-// TODO: Pass in localhost:3000 for testing locally - remember to remove this code after
-// You must also have a proxy server running to forward requests from http://localhost:3000 to a JSM premium url
-export var useAssetsClient = function useAssetsClient(hostname) {
-  var _useState = useState(),
+import { fetchObjectSchema, getWorkspaceId } from '../services/cmdbService';
+export var useAssetsClient = function useAssetsClient(initialParameters) {
+  var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
-    objectSchemas = _useState2[0],
-    setObjectSchemas = _useState2[1];
+    loading = _useState2[0],
+    setLoading = _useState2[1];
   var _useState3 = useState(),
     _useState4 = _slicedToArray(_useState3, 2),
     workspaceId = _useState4[0],
     setWorkspaceId = _useState4[1];
   var _useState5 = useState(),
     _useState6 = _slicedToArray(_useState5, 2),
-    error = _useState6[0],
-    setError = _useState6[1];
+    objectSchema = _useState6[0],
+    setObjectSchema = _useState6[1];
+  var _useState7 = useState(),
+    _useState8 = _slicedToArray(_useState7, 2),
+    error = _useState8[0],
+    setError = _useState8[1];
   useEffect(function () {
     _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-      var _workspaceId, objectSchemasResponse;
+      var _workspaceId, fetchedObjectSchema;
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            _context.prev = 0;
-            _context.next = 3;
-            return getWorkspaceId(hostname);
-          case 3:
+            setLoading(true);
+            setError(undefined);
+            _context.prev = 2;
+            _context.next = 5;
+            return getWorkspaceId();
+          case 5:
             _workspaceId = _context.sent;
-            _context.next = 6;
-            return fetchObjectSchemas(_workspaceId, hostname);
-          case 6:
-            objectSchemasResponse = _context.sent;
             setWorkspaceId(_workspaceId);
-            setObjectSchemas(objectSchemasResponse.values);
-            _context.next = 14;
-            break;
+            // Check schema from initial parameters still exists and fetch name for schema select
+            if (!(initialParameters !== null && initialParameters !== void 0 && initialParameters.schemaId)) {
+              _context.next = 17;
+              break;
+            }
+            _context.prev = 8;
+            _context.next = 11;
+            return fetchObjectSchema(_workspaceId, initialParameters === null || initialParameters === void 0 ? void 0 : initialParameters.schemaId);
           case 11:
-            _context.prev = 11;
-            _context.t0 = _context["catch"](0);
-            if (_context.t0 instanceof Error) {
-              setError(_context.t0);
+            fetchedObjectSchema = _context.sent;
+            setObjectSchema(fetchedObjectSchema);
+            _context.next = 17;
+            break;
+          case 15:
+            _context.prev = 15;
+            _context.t0 = _context["catch"](8);
+          case 17:
+            _context.next = 22;
+            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'));
-              // eslint-disable-next-line no-console
-              console.error(_context.t0);
             }
-          case 14:
+          case 22:
+            _context.prev = 22;
+            setLoading(false);
+            return _context.finish(22);
+          case 25:
           case "end":
             return _context.stop();
         }
-      }, _callee, null, [[0, 11]]);
+      }, _callee, null, [[2, 19, 22, 25], [8, 15]]);
     }))();
-  }, [hostname]);
+  }, [initialParameters]);
   return {
     workspaceId: workspaceId,
-    objectSchemas: objectSchemas,
-    error: error
+    workspaceError: error,
+    objectSchema: objectSchema,
+    assetsClientLoading: loading
   };
 };

package/dist/esm/hooks/useObjectSchemas.js

@@ -0,0 +1,66 @@
+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 { fetchObjectSchemas } from '../services/cmdbService';
+export var useObjectSchemas = function useObjectSchemas(workspaceId) {
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    loading = _useState2[0],
+    setLoading = _useState2[1];
+  var _useState3 = useState(),
+    _useState4 = _slicedToArray(_useState3, 2),
+    objectSchemas = _useState4[0],
+    setObjectSchemas = _useState4[1];
+  var _useState5 = useState(),
+    _useState6 = _slicedToArray(_useState5, 2),
+    error = _useState6[0],
+    setError = _useState6[1];
+  var request = useCallback( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(query) {
+      var fetchedObjectSchemas, fetchedObjectSchemasResponse;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            setLoading(true);
+            setError(undefined);
+            _context.prev = 2;
+            _context.next = 5;
+            return fetchObjectSchemas(workspaceId, query);
+          case 5:
+            fetchedObjectSchemasResponse = _context.sent;
+            setObjectSchemas(fetchedObjectSchemasResponse.values);
+            fetchedObjectSchemas = fetchedObjectSchemasResponse.values;
+            _context.next = 13;
+            break;
+          case 10:
+            _context.prev = 10;
+            _context.t0 = _context["catch"](2);
+            if (_context.t0 instanceof Error) {
+              setError(_context.t0);
+            } else {
+              setError(new Error('Unexpected error occured'));
+            }
+          case 13:
+            _context.prev = 13;
+            setLoading(false);
+            return _context.finish(13);
+          case 16:
+            return _context.abrupt("return", fetchedObjectSchemas);
+          case 17:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[2, 10, 13, 16]]);
+    }));
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }(), [workspaceId]);
+  return {
+    objectSchemasLoading: loading,
+    objectSchemasError: error,
+    objectSchemas: objectSchemas,
+    fetchObjectSchemas: request
+  };
+};