@atlaskit/teams-client 4.0.0

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

@@ -0,0 +1,142 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _GraphQLError;
+export let ErrorCategory = /*#__PURE__*/function (ErrorCategory) {
+  ErrorCategory["NotFound"] = "NotFound";
+  ErrorCategory["NotPermitted"] = "NotPermitted";
+  ErrorCategory["MalformedInput"] = "MalformedInput";
+  ErrorCategory["Internal"] = "Internal";
+  return ErrorCategory;
+}({});
+export let 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;
+  }
+  const reg = new RegExp(`status (code)?.*(${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) {
+  const reg = new RegExp(`status .*(${statusCode})`);
+  return reg.test(message);
+}
+export let 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
+
+class CommonError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    this.message = message || 'UnknownError';
+    this.stack = new Error(message).stack || '';
+  }
+}
+export class DefaultError extends CommonError {
+  constructor({
+    message
+  }) {
+    super(message || 'UnknownError');
+    Object.setPrototypeOf(this, DefaultError.prototype);
+  }
+}
+
+/**
+ * These errors will not fail UFO experiences
+ */
+export class SLOIgnoreError extends CommonError {
+  constructor({
+    message
+  }) {
+    super(`SentryIgnore: ${message || 'UnknownError'}`);
+    Object.setPrototypeOf(this, SLOIgnoreError.prototype);
+  }
+}
+// Http Errors
+export class HttpError extends CommonError {
+  constructor({
+    message,
+    status,
+    traceId,
+    path
+  }) {
+    super(message);
+    Object.setPrototypeOf(this, HttpError.prototype);
+    this.status = status;
+    this.traceId = traceId;
+    this.path = path;
+  }
+}
+
+/**
+ * These errors will not fail UFO experiences
+ */
+export class SLOIgnoreHttpError extends HttpError {
+  constructor(props) {
+    super(props);
+    Object.setPrototypeOf(this, SLOIgnoreHttpError.prototype);
+  }
+}
+
+// Graphql Errors
+
+export class GraphQLError extends CommonError {
+  // tslint:disable-line no-any
+
+  constructor({
+    message,
+    category = 'default',
+    fields
+  }) {
+    super(message);
+    Object.setPrototypeOf(this, GraphQLError.prototype);
+    this.category = category;
+    if (fields) {
+      this.fields = fields;
+    }
+  }
+}
+_GraphQLError = GraphQLError;
+_defineProperty(GraphQLError, "from", rawErrors => {
+  const firstError = rawErrors[0];
+  const errorData = {
+    category: firstError.category,
+    message: firstError.message
+  };
+  if (firstError.fields) {
+    errorData.fields = firstError.fields.reduce((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/es2019/common/utils/filter-null.js

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

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

@@ -0,0 +1,82 @@
+export const 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
+const defaultRetryIfCallback = a => !a;
+const 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, hofOptions = defaultOptions) {
+  const {
+    initial,
+    jitter,
+    max,
+    retryIf
+  } = hofOptions;
+
+  // Initialize max retry decrementing counter (range of max...0)
+  let attemptsRemaining = max;
+
+  // Initialize delay. This will exponentially increase each retry (delay = intial * 2^n)
+  let 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 async function tryWithExponentialBackoff(...args) {
+    // "An attempt was made"
+    const result = await toTry(...args);
+    --attemptsRemaining;
+
+    // If tried function was unsuccessful and there are still retries remaining, retry!
+    if (retryIf && retryIf(result) && attemptsRemaining > 0) {
+      // Wait for delay
+      await new Promise(resolve => setTimeout(resolve, jitter ? Math.random() * delay : delay));
+
+      // Exponentially increase delay
+      delay *= 2;
+
+      // Initiate retry
+      return tryWithExponentialBackoff(...args);
+    }
+
+    // Return result of tried function if it is successful or if the retry limit
+    // was reached regardless of success.
+    return result;
+  };
+}
+export const fetchWithExponentialBackoff = withExponentialBackoff((url, init) => fetch(url, init), {
+  initial: EXPONENTIAL_BACKOFF_RETRY_POLICY.INITIAL_DELAY,
+  jitter: EXPONENTIAL_BACKOFF_RETRY_POLICY.JITTER,
+  max: EXPONENTIAL_BACKOFF_RETRY_POLICY.MAX_RETRIES,
+  retryIf: response => is5xx(response.status)
+});

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

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

package/dist/es2019/common/utils/permissions/constants.js

@@ -0,0 +1,59 @@
+import { fg } from '@atlaskit/platform-feature-flags';
+export const allPermissions = (defaultPermission, isMember) => ({
+  ADD_MEMBER_TO_TEAM: defaultPermission,
+  JOIN_TEAM: defaultPermission,
+  REQUEST_TO_JOIN: defaultPermission,
+  CANCEL_JOIN_REQUEST: defaultPermission,
+  APPROVE_JOIN_REQUEST: defaultPermission,
+  REJECT_JOIN_REQUEST: defaultPermission,
+  REMOVE_MEMBER_FROM_TEAM: defaultPermission,
+  CANCEL_INVITE: defaultPermission,
+  LEAVE_TEAM: defaultPermission && isMember,
+  EDIT_DESCRIPTION: defaultPermission,
+  EDIT_TEAM_NAME: defaultPermission,
+  EDIT_PROFILE_HEADER: defaultPermission,
+  EDIT_TEAM_LINK: defaultPermission,
+  DELETE_TEAM: defaultPermission,
+  EDIT_TEAM_SETTINGS: defaultPermission,
+  EDIT_TEAM_MEMBERSHIP: defaultPermission,
+  REMOVE_AGENT_FROM_TEAM: defaultPermission,
+  ADD_AGENT_TO_TEAM: defaultPermission
+});
+export const vanityActions = ['EDIT_DESCRIPTION', 'EDIT_TEAM_NAME', 'EDIT_PROFILE_HEADER', 'EDIT_TEAM_LINK'];
+export const openPermissions = permission => ({
+  JOIN_TEAM: permission === 'FULL_READ' || permission === 'FULL_WRITE',
+  REQUEST_TO_JOIN: false,
+  CANCEL_JOIN_REQUEST: false,
+  APPROVE_JOIN_REQUEST: false,
+  REJECT_JOIN_REQUEST: false
+});
+export const inviteOnlyPermissions = permission => ({
+  REQUEST_TO_JOIN: permission === 'FULL_READ',
+  CANCEL_JOIN_REQUEST: permission === 'FULL_READ'
+});
+export const SCIMSyncTeamPermissions = (isMember, isOrgAdmin) => ({
+  EDIT_DESCRIPTION: isMember || isOrgAdmin,
+  EDIT_TEAM_SETTINGS: isMember || isOrgAdmin,
+  EDIT_TEAM_LINK: isMember || isOrgAdmin,
+  EDIT_TEAM_NAME: (isMember || isOrgAdmin) && fg('enable_edit_team_name_external_type_teams')
+});
+export const getPermissionMap = (settings, permission, isMember, isOrgAdmin) => {
+  if (settings === 'OPEN') {
+    return {
+      ...allPermissions(permission === 'FULL_WRITE', isMember),
+      ...openPermissions(permission)
+    };
+  }
+  if (settings === 'MEMBER_INVITE') {
+    return {
+      ...allPermissions(permission === 'FULL_WRITE', isMember),
+      ...inviteOnlyPermissions(permission)
+    };
+  } else if (settings === 'EXTERNAL') {
+    return {
+      ...allPermissions(false, isMember),
+      ...SCIMSyncTeamPermissions(isMember, isOrgAdmin)
+    };
+  }
+  return allPermissions(false, false);
+};

package/dist/es2019/common/utils/permissions/has-permission.js

@@ -0,0 +1,33 @@
+import { isMember } from '../team';
+import { getPermissionMap, vanityActions } from './constants';
+export function hasPermission(action, settings, permission, isPeopleBrowseEnabled, currentUserMembership, teamVisibilityPermissions) {
+  if (!isPeopleBrowseEnabled && !vanityActions.includes(action)) {
+    return false;
+  }
+  const isMemberOfTeam = isMember(currentUserMembership);
+  const isOrgAdmin = Boolean(teamVisibilityPermissions === null || teamVisibilityPermissions === void 0 ? void 0 : teamVisibilityPermissions.canAdminTeams);
+  return userCan(action, {
+    membershipSettings: settings,
+    teamPermission: permission,
+    isMemberOfTeam,
+    isOrgAdmin
+  });
+}
+/**
+ * Determines if a user has permission perform a given action on a team
+ */
+export function userCan(action, options) {
+  return getPermissionMap(options.membershipSettings, options.teamPermission, options.isMemberOfTeam, options.isOrgAdmin)[action];
+}
+
+/**
+ * @deprecated Use `userCan` instead, it gives better visibility into the option mappings
+ */
+export function hasPermissionForAction(action, settings, permission, isMemberOfTeam, isOrgAdmin = false) {
+  return userCan(action, {
+    membershipSettings: settings,
+    teamPermission: permission,
+    isMemberOfTeam,
+    isOrgAdmin
+  });
+}

package/dist/es2019/common/utils/permissions/index.js

@@ -0,0 +1,2 @@
+export { hasPermission, hasPermissionForAction, userCan } from './has-permission';
+export { AllTeamActions } from './types';

package/dist/es2019/common/utils/permissions/types.js

@@ -0,0 +1,5 @@
+export const AllTeamActions = ['ADD_MEMBER_TO_TEAM', 'JOIN_TEAM', 'REQUEST_TO_JOIN', 'CANCEL_JOIN_REQUEST', 'APPROVE_JOIN_REQUEST', 'REJECT_JOIN_REQUEST', 'REMOVE_MEMBER_FROM_TEAM', 'CANCEL_INVITE', 'LEAVE_TEAM', 'REMOVE_AGENT_FROM_TEAM', 'ADD_AGENT_TO_TEAM',
+// Visual
+'EDIT_TEAM_NAME', 'EDIT_DESCRIPTION', 'EDIT_PROFILE_HEADER', 'EDIT_TEAM_LINK', 'EDIT_TEAM_SETTINGS', 'EDIT_TEAM_MEMBERSHIP',
+// Serious
+'DELETE_TEAM'];

package/dist/es2019/common/utils/sort-teams.js

@@ -0,0 +1,45 @@
+var MemberType = /*#__PURE__*/function (MemberType) {
+  MemberType[MemberType["CURRENT_USER"] = 0] = "CURRENT_USER";
+  MemberType[MemberType["MEMBER"] = 1] = "MEMBER";
+  MemberType[MemberType["INVITED"] = 2] = "INVITED";
+  MemberType[MemberType["INACTIVE"] = 3] = "INACTIVE";
+  MemberType[MemberType["DELETED"] = 4] = "DELETED";
+  return MemberType;
+}(MemberType || {});
+const checkType = (member, currentAccountId) => {
+  var _member$user, _member$user2;
+  if (member.membershipId.memberId === currentAccountId) {
+    return MemberType.CURRENT_USER;
+  } else if (member && member.state === 'INVITED') {
+    return MemberType.INVITED;
+  } else if (((_member$user = member.user) === null || _member$user === void 0 ? void 0 : _member$user.status) === 'inactive') {
+    return MemberType.INACTIVE;
+  } else if (((_member$user2 = member.user) === null || _member$user2 === void 0 ? void 0 : _member$user2.status) === 'closed') {
+    return MemberType.DELETED;
+  } else {
+    return MemberType.MEMBER;
+  }
+};
+export const sortMembersByType = (members, currentAccountId) => {
+  const newMembers = members.map(member => ({
+    member,
+    type: checkType(member, currentAccountId)
+  }));
+  newMembers.sort(({
+    member: memberA,
+    type: typeA
+  }, {
+    member: memberB,
+    type: typeB
+  }) => {
+    if (typeA === typeB) {
+      var _memberA$user, _memberB$user;
+      return ((_memberA$user = memberA.user) === null || _memberA$user === void 0 ? void 0 : _memberA$user.fullName.localeCompare(((_memberB$user = memberB.user) === null || _memberB$user === void 0 ? void 0 : _memberB$user.fullName) || '')) || 0;
+    } else {
+      return typeA - typeB;
+    }
+  });
+  return newMembers.map(({
+    member
+  }) => member);
+};

package/dist/es2019/common/utils/status-code-handlers-provider.js

@@ -0,0 +1,25 @@
+/**
+ * Our REST clients are initialised when their module loads which makes it tricky for them to consume the `statusCodeHandlers` prop passed to App from the host application.
+ * This is a temporary measure to enable the clients to consume `statusCodeHandlers`.
+ * The long term solution is to replace our REST clients with Apollo client custom resolvers
+ * This will unify all remote data handling under the apollo-client module which is able to easily receive `statusCodeHandlers` as it is initialised within the React portion of our app.
+ */
+
+export const statusCodeHandlersProvider = {
+  handlers: {},
+  get() {
+    return statusCodeHandlersProvider.handlers;
+  },
+  setHandlers(handlers) {
+    statusCodeHandlersProvider.handlers = handlers;
+  }
+};
+export function handleResponse(response) {
+  const {
+    status
+  } = response;
+  const handler = statusCodeHandlersProvider.get()[status];
+  if (typeof handler === 'function') {
+    handler(response);
+  }
+}

package/dist/es2019/common/utils/team.js

@@ -0,0 +1,6 @@
+export function isInvited(member) {
+  return !!member && member.state === 'INVITED';
+}
+export const isNonMember = member => !member || member.state === 'ALUMNI';
+export const isRequestingJoin = member => !!member && member.state === 'REQUESTING_TO_JOIN';
+export const isMember = member => !!member && member.state === 'FULL_MEMBER';

package/dist/es2019/common/utils/ufo/constants.js

@@ -0,0 +1,12 @@
+import { ExperiencePerformanceTypes, ExperienceTypes } from '@atlaskit/ufo';
+import { TeamsUFOExperience } from './index';
+const TeamsClientExperienceKeyList = ['getAllTeams', 'getTeamById', 'updateTeamById', 'querySettings', 'queryFeatureFlags', 'queryTeamMemberships', 'queryUser', 'inviteUsersToTeam', 'getMyTeamMembership', 'getTeamLinksByTeamId', 'createTeamLink', 'updateTeamLink', 'deleteTeamLink', 'reorderTeamLink', 'acceptTeamInvitation', 'declineTeamInvitation', 'selfJoinTeam', 'cancelJoinRequest', 'acceptJoinRequest', 'declineJoinRequest', 'deleteTeamMembership', 'revokeTeamInvite', 'deleteTeam', 'isSingleFullMemberTeam', 'createTeam', 'createExternalTeam', 'getProfileWithMutability', 'getIsSiteAdmin', 'addUsersToTeam', 'removeTeamMemberships', 'getRecommendedProducts', 'joinOrRequestDefaultAccessToProductsBulk', 'getReadMediaToken', 'getWriteUserMediaToken', 'updateUserHeaderImage', 'getWriteTeamMediaToken', 'getSoftDeletedTeamById', 'restoreTeam', 'getUserInSiteUserBase', 'getLinkedTeamsBulk', 'getTeamProfileDetails', 'getUserContainers', 'getPermissions', 'getUserManageConfig', 'getMyAvatarUploadedStatus', 'deleteUserAvatar', 'getTeamLinkIcons', 'getTeamInSlack', 'getOrgScope', 'restoreTeamToSyncedGroup', 'getTeamAndGroupDiff', 'linkExistingTeamToGroup', 'fetchUserAvatarInfo', 'getOrgEligibilityForManagedTeams', 'updateUser', 'updateUserAvatar', 'disconnectTeamInSlack', 'updateTeamInSlack'];
+export const TEAMS_CLIENT_EXPERIENCES = new Map([...TeamsClientExperienceKeyList.map(key => [key,
+// camelCase to kebab-case
+new TeamsUFOExperience(`teams-client-${key.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase()}`, {
+  type: ExperienceTypes.Operation,
+  performanceType: ExperiencePerformanceTypes.Custom,
+  platform: {
+    component: 'people'
+  }
+})])]);

package/dist/es2019/common/utils/ufo/index.js

@@ -0,0 +1,43 @@
+import { UFOExperience } from '@atlaskit/ufo';
+import { isAuthError, isErrorStatusCode, isNetworkError, StatusCode } from '../error';
+import { createErrorMetadata, isIgnoredError } from './utils';
+export class TeamsUFOExperience extends UFOExperience {
+  abortWithError(error, reason) {
+    return super.abort({
+      metadata: {
+        error: createErrorMetadata(error),
+        reason
+      }
+    });
+  }
+  failWithError(error) {
+    if (error instanceof Error) {
+      if (isAuthError(error)) {
+        return this.abortWithError(error, 'Abort due to user unauthenticated');
+      }
+      if (isErrorStatusCode(StatusCode.GONE, error)) {
+        return this.abortWithError(error, 'Abort due to unavailable resource');
+      }
+      if (isIgnoredError(error)) {
+        return this.abortWithError(error, 'Abort due to an error in ignore list');
+      }
+      if (isNetworkError(error)) {
+        return this.abortWithError(error, 'Abort due to network error');
+      }
+      return super.failure({
+        metadata: {
+          error: createErrorMetadata(error),
+          packageVersion: "4.0.0",
+          packageName: "@atlaskit/teams-client"
+        }
+      });
+    }
+    return super.failure({
+      metadata: {
+        error: 'unknown error',
+        packageVersion: "4.0.0",
+        packageName: "@atlaskit/teams-client"
+      }
+    });
+  }
+}

package/dist/es2019/common/utils/ufo/utils.js

@@ -0,0 +1,18 @@
+import { HttpError } from '../error';
+export const createErrorMetadata = error => ({
+  error: {
+    name: error.name,
+    message: error.message,
+    stack: error.stack,
+    traceId: error instanceof HttpError ? error.traceId : undefined,
+    status: error instanceof HttpError ? error.status : undefined
+  }
+});
+const ignoredErrors = ['SLOIgnoreError', 'SLOIgnoreHttpError'];
+export const isIgnoredError = error => {
+  const errorName = error === null || error === void 0 ? void 0 : error.constructor.name;
+  if (!errorName) {
+    return false;
+  }
+  return ignoredErrors.includes(errorName);
+};

package/dist/es2019/index.js

@@ -0,0 +1,19 @@
+export { HttpError } from './common/utils/error';
+export { isTeamMembershipWithUser } from './types/membership';
+
+// /client
+export { teamsClient, TeamsClient } from './services';
+export { useTeamsClientSetup, useTeamsClientSetupNext } from './services/hooks/use-teams-client-setup';
+
+// /permissions
+export { AllTeamActions, hasPermission } from './common/utils/permissions';
+// /sentry
+export { initialiseSentry } from './services/sentry/utils/initialise-sentry';
+export { logException, logInfoMessage } from './services/sentry/main';
+// /user-info-provider
+export { userInfoProvider, UserInfoProvider } from './services/user-info-provider';
+
+// /utils
+export { sortMembersByType, isInvited, isMember, isNonMember, isRequestingJoin } from './common/utils';
+export { toUserARI, toUserId, toTeamARI, toTeamId } from './common/utils/ari';
+export { useLazyQueryLight, useQueryLight, UseQueryLightError } from './services/use-query-light';