@atlaskit/teams-client 4.0.0

package/dist/es2019/mocks/with-faker.js

@@ -0,0 +1,8 @@
+import { randomBasicTeam, randomFullTeam, randomTeamWithMemberships } from './team';
+import { randomTeamLinks } from './team-link';
+export const teamsClientMocks = config => ({
+  randomBasicTeam: randomBasicTeam(config),
+  randomFullTeam: randomFullTeam(config),
+  randomTeamWithMemberships: randomTeamWithMemberships(config),
+  randomTeamLinks: randomTeamLinks(config)
+});

package/dist/es2019/services/agg-client/index.js

@@ -0,0 +1,70 @@
+import { toUserId } from '../../common/utils/ari';
+import { DEFAULT_CONFIG } from '../constants';
+import { BaseGraphQlClient } from '../graphql-client';
+import { logException } from '../sentry/main';
+import TeamMembershipsQuery from './utils/queries/team-membership-query';
+import { TeamsUserQuery } from './utils/queries/user-query';
+import { toUserType } from './utils/user-type';
+export class AGGClient extends BaseGraphQlClient {
+  constructor(baseUrl, config) {
+    super(`${baseUrl}/graphql`, config);
+  }
+  setBaseUrl(baseUrl) {
+    this.setServiceUrl(`${baseUrl}/graphql`);
+  }
+  async queryTeamMemberships(teamId, membershipState = ['FULL_MEMBER'], pageInfo = {
+    first: 100
+  }) {
+    const response = await this.makeGraphQLRequest({
+      query: TeamMembershipsQuery,
+      variables: {
+        teamId,
+        membershipState,
+        siteId: this.getCloudId(),
+        ...pageInfo
+      }
+    }, {
+      operationName: 'TeamMembership'
+    });
+    return {
+      edges: response.team.teamV2.members.edges.map(({
+        node
+      }) => {
+        var _node$member$extended, _node$member$extended2;
+        return {
+          membershipId: {
+            teamId,
+            memberId: toUserId(node.member.id)
+          },
+          state: node.state,
+          role: node.role,
+          user: {
+            id: toUserId(node.member.id),
+            fullName: node.member.name,
+            avatarUrl: node.member.picture,
+            status: node.member.accountStatus,
+            title: (_node$member$extended = (_node$member$extended2 = node.member.extendedProfile) === null || _node$member$extended2 === void 0 ? void 0 : _node$member$extended2.jobTitle) !== null && _node$member$extended !== void 0 ? _node$member$extended : undefined,
+            userType: toUserType({
+              appType: node.member.appType
+            })
+          }
+        };
+      }),
+      pageInfo: response.team.teamV2.members.pageInfo
+    };
+  }
+  async queryAGGUser(userId) {
+    const response = await this.makeGraphQLRequest({
+      query: TeamsUserQuery,
+      variables: {
+        userId
+      }
+    }, {
+      operationName: 'TeamsUserQuery'
+    });
+    return response.user;
+  }
+}
+export const aggClient = new AGGClient(DEFAULT_CONFIG.stargateRoot, {
+  logException
+});

package/dist/es2019/services/agg-client/mocks/index.js

@@ -0,0 +1,64 @@
+import faker from 'faker';
+export const MOCK_TEAM = {
+  team: {
+    teamV2: {
+      members: {
+        edges: [{
+          node: {
+            member: {
+              id: 'ari:cloud:identity::user/1',
+              name: 'user1',
+              picture: 'url1',
+              accountStatus: 'active',
+              extendedProfile: {
+                jobTitle: 'CPA - Chief Party Animal'
+              }
+            },
+            state: 'FULL_MEMBER',
+            role: 'REGULAR'
+          }
+        }, {
+          node: {
+            member: {
+              id: 'ari:cloud:identity::user/2',
+              name: 'user2',
+              picture: 'url2',
+              accountStatus: 'active',
+              extendedProfile: {
+                jobTitle: 'Deputy Party Animal'
+              }
+            },
+            state: 'FULL_MEMBER',
+            role: 'REGULAR'
+          }
+        }],
+        pageInfo: {
+          hasNextPage: false,
+          endCursor: 'end'
+        }
+      }
+    }
+  }
+};
+export const MOCK_USER = {
+  user: {
+    name: faker.name.findName(),
+    picture: faker.image.avatar(),
+    accountStatus: 'active',
+    __typename: 'AtlassianAccountUser',
+    email: 'test_user@atlassian.com',
+    nickname: faker.name.findName(),
+    locale: 'en-GB',
+    zoneinfo: 'Australia/Sydney',
+    extendedProfile: {
+      jobTitle: faker.name.jobTitle(),
+      organization: faker.company.companyName(),
+      department: faker.company.companyName(),
+      location: faker.address.city(),
+      phoneNumbers: faker.phone.phoneNumber(),
+      closedDate: faker.date.past(),
+      inactiveDate: faker.date.past()
+    },
+    id: faker.random.uuid()
+  }
+};

package/dist/es2019/services/agg-client/types.js

@@ -0,0 +1,4 @@
+// We should remove this function after cleaning up site scoped flag & migrating to AGG
+export function isResultWithPageInfo(result) {
+  return result.pageInfo !== undefined;
+}

package/dist/es2019/services/agg-client/utils/queries/team-membership-query.js

@@ -0,0 +1,36 @@
+const TeamMembershipQuery = `query app_user_characteristics($teamId: ID!, $siteId: String!, $membershipState: [TeamMembershipState!]!, $first: Int!, $after: String) {
+    team {
+      teamV2(
+        id: $teamId
+        siteId: $siteId
+      ) @optIn(to: "Team-v2") {
+        members(state: $membershipState, first: $first, after: $after) {
+          edges {
+            node {
+              member {
+                id
+                name
+                picture
+                accountStatus
+                ... on AtlassianAccountUser {
+                  extendedProfile {
+                    jobTitle
+                  }
+                }
+                ... on AppUser {
+                  appType
+                }
+              }
+              role
+              state
+            }
+          }
+          pageInfo {
+            endCursor
+            hasNextPage
+          }
+        }
+      }
+    }
+  }`;
+export default TeamMembershipQuery;

package/dist/es2019/services/agg-client/utils/queries/user-query.js

@@ -0,0 +1,39 @@
+import { print } from 'graphql';
+import gql from 'graphql-tag';
+export const TeamsUserQuery = print(gql`
+	query TeamsUserQuery($userId: ID!) {
+		user(accountId: $userId) {
+			id
+			name
+			picture
+			accountStatus
+			__typename
+			... on AtlassianAccountUser {
+				email
+				nickname
+				locale
+				zoneinfo
+				extendedProfile {
+					jobTitle
+					organization
+					department
+					location
+					phoneNumbers {
+						type
+						value
+					}
+					closedDate
+					inactiveDate
+				}
+			}
+			... on CustomerUser {
+				email
+				locale
+				zoneinfo
+			}
+			... on AppUser {
+				appType
+			}
+		}
+	}
+`);

package/dist/es2019/services/agg-client/utils/user-type.js

@@ -0,0 +1,13 @@
+export function toUserType({
+  isBot,
+  appType
+}) {
+  // Note, the order of these checks is important
+  if ((appType === null || appType === void 0 ? void 0 : appType.toLocaleLowerCase()) === 'agent') {
+    return 'agent';
+  }
+  if (isBot) {
+    return 'bot';
+  }
+  return 'user';
+}

package/dist/es2019/services/base-client/index.js

@@ -0,0 +1,66 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { logException } from '../sentry';
+export class BaseClient {
+  constructor(config) {
+    _defineProperty(this, "cache", {});
+    _defineProperty(this, "logException", (ex, name, context) => {
+      logException(ex, name, context);
+      this.config.logException(ex, name, context);
+    });
+    this.config = config;
+    this.context = {
+      cloudId: 'None'
+    };
+  }
+  setContext(context) {
+    this.context = {
+      ...context,
+      cloudId: context.cloudId || 'None'
+    };
+  }
+  getContext() {
+    return this.context;
+  }
+
+  /**
+   *
+   * @param localValue is used for backwards compatibility
+   * @returns
+   */
+  getOrgId(localValue) {
+    const orgId = localValue || this.getContext().orgId;
+    if (!orgId) {
+      const err = new Error('No orgId set');
+      this.logException(err, 'No orgId set');
+      throw err;
+    }
+    return orgId;
+  }
+  /**
+   *
+   * @param localValue is used for backwards compatibility
+   * @returns
+   */
+  getCloudId(localValue) {
+    return localValue || this.getContext().cloudId;
+  }
+  keyWithContext(key) {
+    var _this$getContext$orgI, _this$getContext$user;
+    return `${this.getContext().cloudId}-${(_this$getContext$orgI = this.getContext().orgId) !== null && _this$getContext$orgI !== void 0 ? _this$getContext$orgI : 'no-org-id'}-${(_this$getContext$user = this.getContext().userId) !== null && _this$getContext$user !== void 0 ? _this$getContext$user : 'no-user-id'}-${key}`;
+  }
+
+  // Default expiration is 5 minutes
+  cacheValue(key, value, expiryMs = 1000 * 60 * 5) {
+    this.cache[this.keyWithContext(key)] = {
+      data: value,
+      expiration: Date.now() + expiryMs
+    };
+  }
+  getCachedValue(key) {
+    const record = this.cache[this.keyWithContext(key)];
+    if (record && record.expiration > Date.now()) {
+      return record.data;
+    }
+    return undefined;
+  }
+}

package/dist/es2019/services/collaborationgraph-client/index.js

@@ -0,0 +1,37 @@
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+var CONTAINER_TYPE = /*#__PURE__*/function (CONTAINER_TYPE) {
+  CONTAINER_TYPE["JIRA_PROJECT"] = "jiraProject";
+  CONTAINER_TYPE["CONFLUENCE_SPACE"] = "confluenceSpace";
+  return CONTAINER_TYPE;
+}(CONTAINER_TYPE || {});
+var ENTITY_TYPE = /*#__PURE__*/function (ENTITY_TYPE) {
+  ENTITY_TYPE["CONTAINER"] = "CONTAINER";
+  ENTITY_TYPE["USER"] = "USER";
+  return ENTITY_TYPE;
+}(ENTITY_TYPE || {});
+export class CollaborationGraphClient extends RestClient {
+  getUserContainers({
+    userId,
+    principalId,
+    siteId,
+    sessionId,
+    maxNumberOfResults
+  }) {
+    return this.postResource('/v1/collaborationgraph/user/container', {
+      context: {
+        contextType: 'atlassianDirectory',
+        principalId,
+        siteId,
+        sessionId
+      },
+      containerTypes: ['confluenceSpace', 'jiraProject'],
+      maxNumberOfResults,
+      userId,
+      expanded: true
+    });
+  }
+}
+export default new CollaborationGraphClient({
+  serviceUrl: DEFAULT_CONFIG.collaborationGraphUrl
+});

package/dist/es2019/services/constants.js

@@ -0,0 +1,7 @@
+export const DEFAULT_CONFIG = {
+  stargateRoot: '/gateway/api',
+  permsServiceUrl: '/gateway/api/permissions',
+  publicApiRoot: '/gateway/api/public',
+  invitationsServiceUrl: '/gateway/api/invitations',
+  collaborationGraphUrl: '/gateway/api/collaboration'
+};

package/dist/es2019/services/directory-client/index.js

@@ -0,0 +1,155 @@
+import { DEFAULT_CONFIG } from '../constants';
+import { BaseGraphQlClient } from '../graphql-client';
+import { logException } from '../sentry/main';
+export const BROWSE_USER_SETTINGS_KEY = 'internal.browse-users-allowed';
+const buildTeamMembershipQuery = (teamId, membershipState) => ({
+  query: `query TeamMembership($teamId: String!, $membershipState: [TeamMembershipStatus]) {
+    TeamMembership: TeamMembership(teamId: $teamId, membershipStates: $membershipState) {
+      user: profile {
+        id,
+        fullName,
+        title,
+        avatarUrl,
+        timezone,
+        status
+      },
+      state:membershipStatus,
+      role,
+      membershipId {
+        teamId, memberId
+      }
+    }
+  }`,
+  variables: {
+    teamId,
+    membershipState
+  }
+});
+
+/**
+ * @type CloudUser
+ * @property {string} avatarUrl
+ * @property {string} id
+ * @property {string} fullName
+ * @property {string} title
+ */
+
+const buildUserQuery = (userId, cloudId) => ({
+  query: `query CloudUser($userId: String!, $cloudId: String!) {
+    CloudUser(userId: $userId, cloudId: $cloudId) {
+      avatarUrl
+      id
+      fullName
+      title
+    }
+  }`,
+  variables: {
+    userId,
+    cloudId
+  }
+});
+const delay = millis => new Promise(resolve => {
+  setTimeout(resolve, millis);
+});
+export class DirectoryClient extends BaseGraphQlClient {
+  constructor(baseUrl, config) {
+    super(`${baseUrl}/directory/graphql`, config);
+  }
+  setBaseUrl(baseUrl) {
+    this.setServiceUrl(`${baseUrl}/directory/graphql`);
+  }
+  async queryFeatureFlags(
+  /**
+   * @private
+   * @deprecated don't need to pass param, value is taken from `this.getCloudId()` instead
+   */
+  cloudId, flags) {
+    const queryFeatureFlags = {
+      query: `query FeatureFlags($cloudId: String!, $flags: [String]!) {
+        FeatureFlags(cloudId: $cloudId, flags: $flags) {
+          flag
+          enabled
+        }
+      }`,
+      variables: {
+        cloudId: this.getCloudId(cloudId),
+        flags
+      }
+    };
+    const {
+      FeatureFlags
+    } = await this.makeGraphQLRequest(queryFeatureFlags, {
+      operationName: 'FeatureFlags'
+    });
+    return FeatureFlags.map(({
+      flag,
+      enabled
+    }) => [flag, enabled]).reduce((acc, val) => (acc[val[0]] = val[1], acc), {});
+  }
+  canRetryError(pendingRetries, error) {
+    return pendingRetries > 0 && !!error && typeof error === 'object' && 'category' in error && error.category === 'NotFound';
+  }
+
+  /**
+   * Get user information of all members of a team
+   * @param {string} teamId
+   * @returns {Promise}
+   * @private
+   * @deprecated use AGG instead
+   */
+  queryTeamMemberships(teamId, membershipStatus = ['FULL_MEMBER']) {
+    // eslint-disable-next-line no-console
+    console.warn('Directory queryTeamMemberships is deprecated, use AGG instead');
+    const teamMembershipsQuery = buildTeamMembershipQuery(teamId, membershipStatus);
+    const performRequest = async (pendingRetries = 3, backoffMaxDelay = 2000) => {
+      try {
+        return await this.makeGraphQLRequest(teamMembershipsQuery, {
+          operationName: 'TeamMembership'
+        });
+      } catch (error) {
+        if (this.canRetryError(pendingRetries, error)) {
+          await delay(backoffMaxDelay / pendingRetries);
+          return performRequest(pendingRetries - 1);
+        }
+        throw error;
+      }
+    };
+    return performRequest().then(({
+      TeamMembership
+    }) => TeamMembership);
+  }
+
+  /**
+   * Get user information of all members of a team
+   * @param {string} userId
+   * @returns {Promise}
+   */
+  queryUser(userId,
+  /**
+   * @private
+   * @deprecated don't need to pass param, value is taken from `this.getCloudId()` instead
+   */
+  cloudId) {
+    const userQuery = buildUserQuery(userId, this.getCloudId(cloudId));
+    const performRequest = async (pendingRetries = 3, backoffMaxDelay = 2000) => {
+      try {
+        return await this.makeGraphQLRequest(userQuery, {
+          operationName: 'CloudUser'
+        });
+      } catch (error) {
+        if (this.canRetryError(pendingRetries, error)) {
+          await delay(backoffMaxDelay / pendingRetries);
+          return performRequest(pendingRetries - 1);
+        }
+        throw error;
+      }
+    };
+    return performRequest();
+  }
+}
+/**
+ * @deprecated As part of decommisioning pf-directoy
+ */
+export const directoryClient = new DirectoryClient(DEFAULT_CONFIG.stargateRoot, {
+  logException
+});

package/dist/es2019/services/graphql-client/index.js

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

package/dist/es2019/services/graphql-client/main.js

@@ -0,0 +1,23 @@
+import { DefaultError, GraphQLError } from '../../common/utils/error';
+import { BaseClient } from '../base-client';
+import { handleGraphQLRequest } from './utils';
+export class BaseGraphQlClient extends BaseClient {
+  constructor(serviceUrl, config) {
+    super(config);
+    this.serviceUrl = serviceUrl;
+  }
+  setServiceUrl(serviceUrl) {
+    this.serviceUrl = serviceUrl;
+  }
+  async makeGraphQLRequest(body, options = {}) {
+    try {
+      return handleGraphQLRequest(this.serviceUrl, body, options);
+    } catch (error) {
+      if (error instanceof GraphQLError) {
+        throw error;
+      }
+      this.logException(error, 'UnknownError in GraphQLClient.makeGraphQLRequestWithoutRetries');
+      throw new DefaultError({});
+    }
+  }
+}

package/dist/es2019/services/graphql-client/types.js

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

package/dist/es2019/services/graphql-client/utils/index.js

@@ -0,0 +1,76 @@
+import { GraphQLError, HttpError } from '../../../common/utils/error';
+import { EXPONENTIAL_BACKOFF_RETRY_POLICY, is5xx, isFetchResponse, withExponentialBackoff } from '../../../common/utils/http';
+import { handleResponse } from '../../../common/utils/status-code-handlers-provider';
+export async function makeGraphQLRequestWithoutRetries(serviceUrl, body, options = {}) {
+  const operationNameQuery = options.operationName ? `?q=${options.operationName}` : '';
+  const errorPolicy = options.errorPolicy || 'none';
+  const url = serviceUrl + operationNameQuery;
+  const request = fetch(url, {
+    method: 'POST',
+    headers: new Headers({
+      'Content-Type': 'application/json'
+    }),
+    credentials: 'include',
+    body: JSON.stringify(body)
+  }).then(res => {
+    if (res.status < 300 || res.status === 400) {
+      return res.json();
+    } else {
+      throw res;
+    }
+  });
+  try {
+    const response = await request;
+    const errors = response.errors;
+    if (errors) {
+      if (errorPolicy === 'none') {
+        throw GraphQLError.from(errors);
+      } else if (errorPolicy === 'all') {
+        // Set timeout will postpone error throwing and de-touch it to another event loop,
+        // so we can return data along with throwing error
+        return new Promise((resolve, reject) => {
+          setTimeout(() => {
+            reject(GraphQLError.from(errors));
+          }, 0);
+        });
+      }
+    }
+    return response.data;
+  } catch (error) {
+    if (error instanceof Response) {
+      return {
+        response: error
+      };
+    }
+    if (Object(error).hasOwnProperty('response')) {
+      throw error;
+    }
+    return error;
+  }
+}
+export async function handleGraphQLRequest(serviceUrl, body, options = {}) {
+  const makeGraphQLRequestWithRetries = withExponentialBackoff(makeGraphQLRequestWithoutRetries, {
+    initial: EXPONENTIAL_BACKOFF_RETRY_POLICY.INITIAL_DELAY,
+    jitter: EXPONENTIAL_BACKOFF_RETRY_POLICY.JITTER,
+    max: EXPONENTIAL_BACKOFF_RETRY_POLICY.MAX_RETRIES,
+    retryIf: data => {
+      return isFetchResponse(data) && is5xx(data.response.status);
+    }
+  });
+  const result = await makeGraphQLRequestWithRetries(serviceUrl, body, options);
+  const response = result === null || result === void 0 ? void 0 : result.response;
+  if (response) {
+    const status = response.status;
+    const statusText = response.statusText;
+    const traceId = response.headers.get('atl-traceid');
+    handleResponse(response);
+    if (status > 400 && status <= 599) {
+      throw new HttpError({
+        message: statusText,
+        status,
+        traceId: traceId !== null && traceId !== void 0 ? traceId : undefined
+      });
+    }
+  }
+  return result;
+}

package/dist/es2019/services/hooks/use-teams-client-setup.js

@@ -0,0 +1,40 @@
+import { useEffect } from 'react';
+import { teamsClient } from '../main';
+import { logInfoMessage } from '../sentry/main';
+
+/**
+ * @deprecated use useTeamsClientSetupNext for named parameters
+ */
+export const useTeamsClientSetup = (stargateRoot, cloudId, orgId, principalUserId) => {
+  useTeamsClientSetupNext({
+    stargateRoot,
+    cloudId,
+    orgId,
+    principalUserId
+  });
+};
+export const useTeamsClientSetupNext = ({
+  stargateRoot,
+  cloudId,
+  orgId,
+  principalUserId
+}) => {
+  useEffect(() => {
+    if (!stargateRoot) {
+      return;
+    }
+    teamsClient.setBaseUrl(stargateRoot);
+  }, [stargateRoot]);
+  useEffect(() => {
+    teamsClient.setContext({
+      cloudId,
+      orgId,
+      userId: principalUserId
+    });
+    if (!orgId) {
+      logInfoMessage(`No orgId set - useTeamsClientSetup`, {
+        cloudId
+      });
+    }
+  }, [cloudId, orgId, principalUserId]);
+};