@atlaskit/link-datasource 0.29.4 → 0.29.5

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.4",
+	"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
+  };
+};

package/dist/esm/hooks/useValidateAqlText.js

@@ -6,35 +6,64 @@ import { validateAql } from '../services/cmdbService';
 export var useValidateAqlText = function useValidateAqlText(workspaceId, hostname) {
   var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
-    isLoading = _useState2[0],
-    setIsLoading = _useState2[1];
+    loading = _useState2[0],
+    setLoading = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isValidAqlText = _useState4[0],
+    setIsValidAqlText = _useState4[1];
+  var _useState5 = useState(),
+    _useState6 = _slicedToArray(_useState5, 2),
+    error = _useState6[0],
+    setError = _useState6[1];
   var validateAqlText = useCallback( /*#__PURE__*/function () {
     var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(aql) {
-      var validateAqlResponse;
+      var isValid, validateAqlResponse;
       return _regeneratorRuntime.wrap(function _callee$(_context) {
         while (1) switch (_context.prev = _context.next) {
           case 0:
-            setIsLoading(true);
-            _context.next = 3;
+            setLoading(true);
+            setError(undefined);
+            isValid = false;
+            _context.prev = 3;
+            _context.next = 6;
             return validateAql(workspaceId, {
               qlQuery: aql
-            }, hostname);
-          case 3:
-            validateAqlResponse = _context.sent;
-            setIsLoading(false);
-            return _context.abrupt("return", validateAqlResponse.isValid);
+            });
           case 6:
+            validateAqlResponse = _context.sent;
+            setIsValidAqlText(validateAqlResponse.isValid);
+            isValid = validateAqlResponse.isValid;
+            _context.next = 14;
+            break;
+          case 11:
+            _context.prev = 11;
+            _context.t0 = _context["catch"](3);
+            if (_context.t0 instanceof Error) {
+              setError(_context.t0);
+            } else {
+              setError(new Error('Unexpected error occured'));
+            }
+          case 14:
+            _context.prev = 14;
+            setLoading(false);
+            return _context.finish(14);
+          case 17:
+            return _context.abrupt("return", isValid);
+          case 18:
           case "end":
             return _context.stop();
         }
-      }, _callee);
+      }, _callee, null, [[3, 11, 14, 17]]);
     }));
     return function (_x) {
       return _ref.apply(this, arguments);
     };
-  }(), [hostname, workspaceId]);
+  }(), [workspaceId]);
   return {
+    isValidAqlText: isValidAqlText,
     validateAqlText: validateAqlText,
-    isLoading: isLoading
+    validateAqlTextLoading: loading,
+    validateAqlTextError: error
   };
 };

package/dist/esm/services/cmdbService.js

@@ -2,13 +2,13 @@ import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 import { request } from '@atlaskit/linking-common';
 export var getWorkspaceId = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(hostname) {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
     var _workspaceDetailsResp;
     var url, workspaceDetailsResponse;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) switch (_context.prev = _context.next) {
         case 0:
-          url = "".concat(hostname || '', "/rest/servicedesk/cmdb/latest/workspace");
+          url = '/rest/servicedesk/cmdb/latest/workspace';
           _context.next = 3;
           return request('get', url, undefined, undefined, [200, 201, 202, 203, 204]);
         case 3:
@@ -26,18 +26,26 @@ export var getWorkspaceId = /*#__PURE__*/function () {
       }
     }, _callee);
   }));
-  return function getWorkspaceId(_x) {
+  return function getWorkspaceId() {
     return _ref.apply(this, arguments);
   };
 }();
-export var validateAql = function validateAql(workspaceId, data, hostname) {
-  var url = "".concat(hostname || '', "/gateway/api/jsm/assets/workspace/").concat(workspaceId, "/v1/aql/validate");
+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 fetchObjectSchemas = function fetchObjectSchemas(workspaceId, hostname) {
-  var url = "".concat(hostname || '', "/gateway/api/jsm/assets/workspace/").concat(workspaceId, "/v1/objectschema/list?maxResults=100");
+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]);
 };

package/dist/esm/types/assets/types.js

@@ -1 +1,3 @@
-export {};
+// These are to enforce the field "name" property and keep everything typed
+export var objectSchemaKey = 'objectSchema';
+export var aqlKey = 'aql';