@atlaskit/teams-client 4.0.0

package/dist/es2019/services/use-query-light/main.js

@@ -0,0 +1,162 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { print } from 'graphql';
+import isEqual from 'lodash/isEqual';
+import { fetchWithExponentialBackoff } from '../../common/utils/http';
+import { logException } from '../sentry';
+import { UseQueryLightError } from './types';
+const transformError = ({
+  error,
+  graphQLErrors
+}) => {
+  const reducedGraphqlErrorMessage = graphQLErrors && graphQLErrors.reduce((acc, gqlError) => acc + (acc ? '\n' : '') + (gqlError.message ? gqlError.message : ''), '');
+  const reducedGraphqlErrorName = graphQLErrors && graphQLErrors.reduce((acc, gqlError) => acc + (acc ? '\n' : '') + (gqlError.name ? gqlError.name : ''), '');
+  return new UseQueryLightError(
+  // Network error would lead to no graphqlErrors as the query would not be fired. Hence at the front.
+  (error === null || error === void 0 ? void 0 : error.message) || reducedGraphqlErrorMessage || 'Unknown error', (error === null || error === void 0 ? void 0 : error.name) || reducedGraphqlErrorName,
+  // graphQLErrors in Apollo error is empty array when there is no error.
+  // So we follow the same to make sure error handlers are working as expected.
+  graphQLErrors || [], error);
+};
+export const useQueryLight = (query, options) => {
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(undefined);
+  const [data, setData] = useState(undefined);
+  const variablesRef = useRef(options.variables);
+
+  // Need this to deep compare variables to avoid infinite loops in useEffect
+  if (!isEqual(variablesRef.current, options.variables)) {
+    variablesRef.current = options.variables;
+  }
+
+  // Initial fetch, and refetch
+  const fetchData = useCallback(async () => {
+    try {
+      setLoading(true);
+      const response = await fetchWithExponentialBackoff(`${options.serviceUrl}?q=${options.operationName}`, {
+        method: 'POST',
+        headers: new Headers({
+          'Content-Type': 'application/json',
+          ...options.customHeaders
+        }),
+        credentials: 'include',
+        body: JSON.stringify({
+          query: print(query),
+          variables: {
+            ...variablesRef.current
+          }
+        })
+      });
+      const responseData = await response.json();
+      if (response.ok) {
+        if (responseData.errors) {
+          setError(transformError({
+            graphQLErrors: responseData.errors
+          }));
+        }
+        setData(responseData.data);
+        setLoading(false);
+      } else {
+        throw new Error(`Generic fetch error within useQueryLight, status ${response.status}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        setError(transformError({
+          error
+        }));
+      } else {
+        setError(transformError({
+          error: new Error('Unknown error')
+        }));
+        logException(error, `useQueryLight - ${options.operationName}`);
+      }
+      setData(undefined);
+      setLoading(false);
+    }
+  }, [query, options.serviceUrl, options.operationName, options.customHeaders]);
+
+  // Fetch more
+  const fetchMore = useCallback(async ({
+    variables,
+    handleDataMerge
+  }) => {
+    try {
+      // reset errors to catch new ones
+      setError(undefined);
+      const response = await fetchWithExponentialBackoff(`${options.serviceUrl}?q=${options.operationName}`, {
+        method: 'POST',
+        headers: new Headers({
+          'Content-Type': 'application/json',
+          ...options.customHeaders
+        }),
+        credentials: 'include',
+        body: JSON.stringify({
+          query: print(query),
+          variables: {
+            ...variablesRef.current,
+            ...variables
+          }
+        })
+      });
+      const responseData = await response.json();
+      if (response.ok) {
+        if (responseData.errors) {
+          setError(transformError({
+            graphQLErrors: responseData.errors
+          }));
+        }
+        setData(prevData => handleDataMerge(prevData, responseData.data));
+      } else {
+        throw new Error(`Generic fetch error within useQueryLight, status ${response.status}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        setError(transformError({
+          error
+        }));
+      } else {
+        setError(transformError({
+          error: new Error('Unknown error')
+        }));
+        logException(error, `useQueryLight fetchMore - ${options.operationName}`);
+      }
+    }
+  }, [query, options.serviceUrl, options.operationName, options.customHeaders]);
+  useEffect(() => {
+    if (!options.skip) {
+      fetchData();
+    } else {
+      setLoading(false);
+    }
+  }, [options.skip, variablesRef.current]); // eslint-disable-line react-hooks/exhaustive-deps
+
+  return {
+    loading,
+    error,
+    data,
+    refetch: fetchData,
+    fetchMore
+  };
+};
+export const useLazyQueryLight = (query, options) => {
+  const [fetchTriggered, setFetchTriggered] = useState(false);
+  const {
+    loading,
+    error,
+    data,
+    refetch,
+    fetchMore
+  } = useQueryLight(query, {
+    ...options,
+    skip: !fetchTriggered
+  });
+  const triggerFetch = useCallback(() => {
+    setFetchTriggered(true);
+  }, []);
+  return [triggerFetch, {
+    loading,
+    error,
+    data,
+    refetch,
+    fetchMore
+  }];
+};

package/dist/es2019/services/use-query-light/types.js

@@ -0,0 +1,27 @@
+export let ErrorCategory = /*#__PURE__*/function (ErrorCategory) {
+  ErrorCategory["NotFound"] = "NotFound";
+  ErrorCategory["NotPermitted"] = "NotPermitted";
+  ErrorCategory["MalformedInput"] = "MalformedInput";
+  ErrorCategory["Internal"] = "Internal";
+  return ErrorCategory;
+}({});
+export class ActualGraphQLError extends Error {
+  // AGG standard
+
+  constructor(message) {
+    super(message);
+    this.message = message;
+  }
+}
+export class UseQueryLightError extends Error {
+  constructor(message, name, graphQLErrors, networkError, extensions, extraInfo) {
+    super(message);
+    this.graphQLErrors = graphQLErrors;
+    this.networkError = networkError;
+    this.extensions = extensions;
+    this.extraInfo = extraInfo;
+    if (name) {
+      this.name = name;
+    }
+  }
+}

package/dist/es2019/services/user-info-provider/index.js

@@ -0,0 +1 @@
+export { userInfoProvider, UserInfoProvider } from './main';

package/dist/es2019/services/user-info-provider/main.js

@@ -0,0 +1,44 @@
+import { DEFAULT_CONFIG } from '../constants';
+
+// Needs to be declared here to avoid blowing up this earlyInit bundle
+class FetchError extends Error {
+  constructor(response) {
+    super(`Request failed with status ${response.status}`);
+    this.response = response;
+    this.name = this.constructor.name;
+  }
+}
+// export for testing
+export class UserInfoProvider {
+  get(fetchOp = fetch) {
+    if (this.promise) {
+      return this.promise;
+    }
+    const getJson = url => fetchOp(url, {
+      method: 'GET',
+      mode: 'cors',
+      credentials: 'include',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }).then(response => {
+      if (!response.ok) {
+        throw new FetchError(response);
+      }
+      return response.json();
+    });
+    this.promise = getJson(`${DEFAULT_CONFIG.stargateRoot}/me`).then(me => {
+      var _me$extended_profile;
+      return {
+        userId: me.account_id,
+        locale: me.locale,
+        fullName: me.name,
+        avatarUrl: me.picture,
+        email: me.email,
+        title: (_me$extended_profile = me.extended_profile) === null || _me$extended_profile === void 0 ? void 0 : _me$extended_profile.job_title
+      };
+    });
+    return this.promise;
+  }
+}
+export const userInfoProvider = new UserInfoProvider();

package/dist/es2019/services/user-preferences-client/index.js

@@ -0,0 +1,19 @@
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+const buildGetReadTokenURL = accountId => `/api/user-image/${accountId}/header-image/read`;
+export class UserPreferencesClient extends RestClient {
+  async getReadMediaToken(accountId) {
+    return this.getResource(buildGetReadTokenURL(accountId)).then(response => response);
+  }
+  async getWriteMediaToken() {
+    return this.getResource('/api/user-image/header-image/write').then(response => response);
+  }
+  async updateUserHeaderImage(headerImageId) {
+    return await this.putResource('/api/user-image/self/header-image', {
+      headerImageId
+    });
+  }
+}
+export default new UserPreferencesClient({
+  serviceUrl: DEFAULT_CONFIG.stargateRoot
+});

package/dist/es2019/types/index.js

@@ -0,0 +1,2 @@
+export { isEditableUserField } from './user';
+export { isResultWithPageInfo } from '../services/agg-client/types';

package/dist/es2019/types/links.js

@@ -0,0 +1,16 @@
+/**
+ * Used to synchronise these field names to forms used to create/edit links e.g. TeamLinkForm
+ */
+export const LINK_FIELDS = {
+  CONTENT_TITLE: 'contentTitle',
+  DESCRIPTION: 'description',
+  LINK_URI: 'linkUri'
+};
+
+/**
+ * Type for uncreated team links. These don't have link IDs
+ */
+
+/**
+ * Type for order of team links.
+ */

package/dist/es2019/types/membership.js

@@ -0,0 +1,16 @@
+/**
+ * @private
+ * @deprecated INVITED is deprecated
+ */
+
+/**
+ * @param membershipId - The team IDZ
+ */
+
+// Currently an agent is just a user, they may diverge if we need more agent specific fields
+
+// The minimal user required to invited someone
+
+export function isTeamMembershipWithUser(membership) {
+  return typeof membership.user === 'object';
+}

package/dist/es2019/types/team.js

@@ -0,0 +1 @@
+export {};

package/dist/es2019/types/user.js

@@ -0,0 +1,4 @@
+const EditableUserFieldList = ['title', 'department', 'companyName', 'location', 'phoneNumber', 'fullName', 'nickname', 'locale', 'email'];
+export const isEditableUserField = key => {
+  return EditableUserFieldList.includes(key);
+};

package/dist/esm/common/types.js

@@ -0,0 +1,2 @@
+export var USER_ARI_PREFIX = 'ari:cloud:identity::user/';
+export var TEAM_ARI_PREFIX = 'ari:cloud:identity::team/';

package/dist/esm/common/utils/ari.js

@@ -0,0 +1,25 @@
+import { TEAM_ARI_PREFIX, USER_ARI_PREFIX } from '../types';
+export var isUserARI = function isUserARI(ari) {
+  return ari.startsWith(USER_ARI_PREFIX);
+};
+export var toUserId = function toUserId(ari) {
+  if (isUserARI(ari)) {
+    return ari.replace(USER_ARI_PREFIX, '');
+  }
+  throw new Error('Invalid UserARI');
+};
+export var toUserARI = function toUserARI(userId) {
+  return isUserARI(userId) ? userId : "".concat(USER_ARI_PREFIX).concat(userId);
+};
+export var isTeamARI = function isTeamARI(ari) {
+  return ari.startsWith(TEAM_ARI_PREFIX);
+};
+export var toTeamId = function toTeamId(ari) {
+  if (isTeamARI(ari)) {
+    return ari.replace(TEAM_ARI_PREFIX, '');
+  }
+  throw new Error('Invalid TeamARI');
+};
+export var toTeamARI = function toTeamARI(teamId) {
+  return isTeamARI(teamId) ? teamId : "".concat(TEAM_ARI_PREFIX).concat(teamId);
+};

package/dist/esm/common/utils/error/index.js

@@ -0,0 +1,176 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+var _GraphQLError;
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+export var ErrorCategory = /*#__PURE__*/function (ErrorCategory) {
+  ErrorCategory["NotFound"] = "NotFound";
+  ErrorCategory["NotPermitted"] = "NotPermitted";
+  ErrorCategory["MalformedInput"] = "MalformedInput";
+  ErrorCategory["Internal"] = "Internal";
+  return ErrorCategory;
+}({});
+export var StatusCode = /*#__PURE__*/function (StatusCode) {
+  StatusCode[StatusCode["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  StatusCode[StatusCode["FORBIDDEN"] = 403] = "FORBIDDEN";
+  StatusCode[StatusCode["TIMEOUT"] = 408] = "TIMEOUT";
+  StatusCode[StatusCode["GONE"] = 410] = "GONE";
+  StatusCode[StatusCode["PAYLOAD_TOO_LARGE"] = 413] = "PAYLOAD_TOO_LARGE";
+  return StatusCode;
+}({});
+export function isAuthError(error) {
+  return isErrorStatusCode(StatusCode.UNAUTHORIZED, error) || isErrorStatusCode(StatusCode.FORBIDDEN, error);
+}
+export function isErrorStatusCode(statusCode, error) {
+  var _error$message;
+  if (!error) {
+    return false;
+  }
+  if (error['status'] === statusCode ||
+  // error can be `ProperNetworkError` from `packages/graphql-client/src/links/error.ts`
+  error['statusCode'] === statusCode) {
+    return true;
+  }
+  var reg = new RegExp("status (code)?.*(".concat(statusCode, ")"));
+  return !!(error !== null && error !== void 0 && (_error$message = error.message) !== null && _error$message !== void 0 && _error$message.match(reg));
+}
+export function doesErrorContainStatus(statusCode, message) {
+  var reg = new RegExp("status .*(".concat(statusCode, ")"));
+  return reg.test(message);
+}
+export var TeamErrorType = /*#__PURE__*/function (TeamErrorType) {
+  TeamErrorType["TEAM_NOT_ACTIVE"] = "Team must be active";
+  return TeamErrorType;
+}({});
+// Extending new custom Error types with `Object.setPrototypeOf`
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
+var CommonError = /*#__PURE__*/function (_Error) {
+  function CommonError(message) {
+    var _this;
+    _classCallCheck(this, CommonError);
+    _this = _callSuper(this, CommonError, [message]);
+    _this.name = _this.constructor.name;
+    _this.message = message || 'UnknownError';
+    _this.stack = new Error(message).stack || '';
+    return _this;
+  }
+  _inherits(CommonError, _Error);
+  return _createClass(CommonError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export var DefaultError = /*#__PURE__*/function (_CommonError) {
+  function DefaultError(_ref) {
+    var _this2;
+    var message = _ref.message;
+    _classCallCheck(this, DefaultError);
+    _this2 = _callSuper(this, DefaultError, [message || 'UnknownError']);
+    Object.setPrototypeOf(_this2, DefaultError.prototype);
+    return _this2;
+  }
+  _inherits(DefaultError, _CommonError);
+  return _createClass(DefaultError);
+}(CommonError);
+
+/**
+ * These errors will not fail UFO experiences
+ */
+export var SLOIgnoreError = /*#__PURE__*/function (_CommonError2) {
+  function SLOIgnoreError(_ref2) {
+    var _this3;
+    var message = _ref2.message;
+    _classCallCheck(this, SLOIgnoreError);
+    _this3 = _callSuper(this, SLOIgnoreError, ["SentryIgnore: ".concat(message || 'UnknownError')]);
+    Object.setPrototypeOf(_this3, SLOIgnoreError.prototype);
+    return _this3;
+  }
+  _inherits(SLOIgnoreError, _CommonError2);
+  return _createClass(SLOIgnoreError);
+}(CommonError);
+// Http Errors
+export var HttpError = /*#__PURE__*/function (_CommonError3) {
+  function HttpError(_ref3) {
+    var _this4;
+    var message = _ref3.message,
+      status = _ref3.status,
+      traceId = _ref3.traceId,
+      path = _ref3.path;
+    _classCallCheck(this, HttpError);
+    _this4 = _callSuper(this, HttpError, [message]);
+    Object.setPrototypeOf(_this4, HttpError.prototype);
+    _this4.status = status;
+    _this4.traceId = traceId;
+    _this4.path = path;
+    return _this4;
+  }
+  _inherits(HttpError, _CommonError3);
+  return _createClass(HttpError);
+}(CommonError);
+
+/**
+ * These errors will not fail UFO experiences
+ */
+export var SLOIgnoreHttpError = /*#__PURE__*/function (_HttpError) {
+  function SLOIgnoreHttpError(props) {
+    var _this5;
+    _classCallCheck(this, SLOIgnoreHttpError);
+    _this5 = _callSuper(this, SLOIgnoreHttpError, [props]);
+    Object.setPrototypeOf(_this5, SLOIgnoreHttpError.prototype);
+    return _this5;
+  }
+  _inherits(SLOIgnoreHttpError, _HttpError);
+  return _createClass(SLOIgnoreHttpError);
+}(HttpError);
+
+// Graphql Errors
+
+export var GraphQLError = /*#__PURE__*/function (_CommonError4) {
+  // tslint:disable-line no-any
+
+  function GraphQLError(_ref4) {
+    var _this6;
+    var message = _ref4.message,
+      _ref4$category = _ref4.category,
+      category = _ref4$category === void 0 ? 'default' : _ref4$category,
+      fields = _ref4.fields;
+    _classCallCheck(this, GraphQLError);
+    _this6 = _callSuper(this, GraphQLError, [message]);
+    Object.setPrototypeOf(_this6, GraphQLError.prototype);
+    _this6.category = category;
+    if (fields) {
+      _this6.fields = fields;
+    }
+    return _this6;
+  }
+  _inherits(GraphQLError, _CommonError4);
+  return _createClass(GraphQLError);
+}(CommonError);
+_GraphQLError = GraphQLError;
+_defineProperty(GraphQLError, "from", function (rawErrors) {
+  var firstError = rawErrors[0];
+  var errorData = {
+    category: firstError.category,
+    message: firstError.message
+  };
+  if (firstError.fields) {
+    errorData.fields = firstError.fields.reduce(function (obj, item) {
+      obj[item.field] = item.message;
+      return obj;
+    }, {});
+  }
+  return new _GraphQLError(errorData);
+});
+export function isNetworkError(error) {
+  return error && !!error.message && (
+  // Firefox
+  error.message.includes('NetworkError') ||
+  // Chrome
+  error.message.startsWith('Failed to fetch') || error.message.includes('GraphQL error: Failed to fetch') ||
+  // cancel by users or unknown reason
+  error.message.includes('GraphQL error: The operation was aborted') || error.message.includes('GraphQL error: cancelled') || error.message.includes('Abgebrochen') || error.message.includes('отменено') || error.message.includes('Сетевое соединение потеряно.') || error.message.includes('anulowane') || error.message.includes('annulé') || error.message.includes('已取消') || error.message.includes('cancelado') || error.message.includes('キャンセルしました') || error.message.includes('cancelled') || error.message.includes('Network error') ||
+  // GraphQL-wrapping network error
+  !!(error['graphQLErrors'] && error['networkError']));
+}

package/dist/esm/common/utils/filter-null.js

@@ -0,0 +1,3 @@
+export function filterNull(x) {
+  return !!x;
+}

package/dist/esm/common/utils/http.js

@@ -0,0 +1,109 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+export var EXPONENTIAL_BACKOFF_RETRY_POLICY = {
+  INITIAL_DELAY: 200,
+  MAX_RETRIES: 5,
+  JITTER: true
+};
+
+/**
+ * Checks whether a status code is a 5xx HTTP code.
+ * @param {number} status HTTP status code
+ */
+export function is5xx(status) {
+  return 500 <= status && status <= 599;
+}
+export function isFetchResponse(data) {
+  if (!data || !data.hasOwnProperty('response')) {
+    return false;
+  }
+  return data.response instanceof Response;
+}
+
+// tslint:disable-next-line no-any
+
+// tslint:disable-next-line no-any
+var defaultRetryIfCallback = function defaultRetryIfCallback(a) {
+  return !a;
+};
+var defaultOptions = {
+  initial: 200,
+  jitter: false,
+  max: 5,
+  retryIf: defaultRetryIfCallback
+};
+/**
+ * Transparently wrap a function so that it is retried until it succeeds or reaches a max retry limit.
+ * The returned function has the same signature as the wrapped function.
+ *
+ * Modified from https://jsfiddle.net/pajtai/pLka0ow9/
+ */
+export function withExponentialBackoff(toTry) {
+  var hofOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOptions;
+  var initial = hofOptions.initial,
+    jitter = hofOptions.jitter,
+    max = hofOptions.max,
+    retryIf = hofOptions.retryIf;
+
+  // Initialize max retry decrementing counter (range of max...0)
+  var attemptsRemaining = max;
+
+  // Initialize delay. This will exponentially increase each retry (delay = intial * 2^n)
+  var delay = initial;
+
+  /**
+   * This function calls itself recursively until `retryIf` evaluates false or the retry limit is reached.
+   * The functioned-to-be-retried is called on each recursion.
+   */
+  return /*#__PURE__*/function () {
+    var _tryWithExponentialBackoff = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var result,
+        _args = arguments;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return toTry.apply(void 0, _args);
+          case 2:
+            result = _context.sent;
+            --attemptsRemaining;
+
+            // If tried function was unsuccessful and there are still retries remaining, retry!
+            if (!(retryIf && retryIf(result) && attemptsRemaining > 0)) {
+              _context.next = 9;
+              break;
+            }
+            _context.next = 7;
+            return new Promise(function (resolve) {
+              return setTimeout(resolve, jitter ? Math.random() * delay : delay);
+            });
+          case 7:
+            // Exponentially increase delay
+            delay *= 2;
+
+            // Initiate retry
+            return _context.abrupt("return", tryWithExponentialBackoff.apply(void 0, _args));
+          case 9:
+            return _context.abrupt("return", result);
+          case 10:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    function tryWithExponentialBackoff() {
+      return _tryWithExponentialBackoff.apply(this, arguments);
+    }
+    return tryWithExponentialBackoff;
+  }();
+}
+export var fetchWithExponentialBackoff = withExponentialBackoff(function (url, init) {
+  return fetch(url, init);
+}, {
+  initial: EXPONENTIAL_BACKOFF_RETRY_POLICY.INITIAL_DELAY,
+  jitter: EXPONENTIAL_BACKOFF_RETRY_POLICY.JITTER,
+  max: EXPONENTIAL_BACKOFF_RETRY_POLICY.MAX_RETRIES,
+  retryIf: function retryIf(response) {
+    return is5xx(response.status);
+  }
+});

package/dist/esm/common/utils/index.js

@@ -0,0 +1,2 @@
+export { sortMembersByType } from './sort-teams';
+export { isInvited, isMember, isNonMember, isRequestingJoin } from './team';