@atlaskit/teams-client 4.0.0

package/dist/es2019/services/main.js

@@ -0,0 +1,541 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { TEAMS_CLIENT_EXPERIENCES } from '../common/utils/ufo/constants';
+import { aggClient } from './agg-client';
+import collaborationGraphClient from './collaborationgraph-client';
+import { directoryClient } from './directory-client';
+import identityClient from './identity-client';
+import invitationsClient from './invitations-client';
+import { defaultLegionClient } from './legion-client';
+import mutabilityClient from './mutability-client';
+import objectResolverClient from './object-resolver-client';
+import permsClient from './perms-client';
+import publicApiClient from './public-api-client';
+import teamsInSlackClient from './teams-in-slack-client';
+import userPreferencesClient from './user-preferences-client';
+
+/**
+ * This solves error TS1055:
+ * Type 'ReturnType' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value
+ */
+
+/**
+ * The Teams Client is an used for fetching data related to Atlas teams.
+ * It is an abstraction over the various clients that are used to fetch data related to teams.
+ * Find out more about the APIs here - [https://developer.atlassian.com/platform/teams-internal/](https://developer.atlassian.com/platform/teams-internal/)
+ */
+export class TeamsClient {
+  constructor(
+  /**
+   * @param {ClientContextProps} context - Context including CloudId & OrgId to be used for all requests
+   */
+  context) {
+    _defineProperty(this, "_aggClient", aggClient);
+    _defineProperty(this, "_directoryClient", directoryClient);
+    _defineProperty(this, "_legionClient", defaultLegionClient);
+    _defineProperty(this, "_mutabilityClient", mutabilityClient);
+    _defineProperty(this, "_permsClient", permsClient);
+    _defineProperty(this, "_publicApiClient", publicApiClient);
+    _defineProperty(this, "_invitationsClient", invitationsClient);
+    _defineProperty(this, "_userPreferencesClient", userPreferencesClient);
+    _defineProperty(this, "_objectResolverClient", objectResolverClient);
+    _defineProperty(this, "_teamsInSlackClient", teamsInSlackClient);
+    _defineProperty(this, "_collaborationGraphClient", collaborationGraphClient);
+    _defineProperty(this, "_identityClient", identityClient);
+    if (context) {
+      this.setContext(context);
+    }
+  }
+  async measurePerformance(name, fn) {
+    const exp = TEAMS_CLIENT_EXPERIENCES.get(name);
+    if (!exp) {
+      return fn();
+    }
+    exp.start();
+    try {
+      const result = await fn();
+      exp.success();
+      return result;
+    } catch (e) {
+      exp.failWithError(e);
+      throw e;
+    }
+  }
+
+  /**
+   * Sets the base URL to be used in the client requests
+   * @param {string} baseUrl - The new base URL
+   */
+  setBaseUrl(baseUrl) {
+    this._aggClient.setBaseUrl(baseUrl);
+    this._directoryClient.setBaseUrl(baseUrl);
+  }
+
+  /**
+   * Sets context including CloudId & OrgId to be used for all requests
+   */
+  setContext(context) {
+    this._aggClient.setContext(context);
+    this._directoryClient.setContext(context);
+    this._legionClient.setContext(context);
+    this._permsClient.setContext(context);
+    this._mutabilityClient.setContext(context);
+    this._publicApiClient.setContext(context);
+    this._invitationsClient.setContext(context);
+  }
+
+  /**
+   * @private
+   * @deprecated use setBaseUrl instead
+   */
+  setDirectoryBaseUrl(baseUrl) {
+    // eslint-disable-next-line no-console
+    console.warn('setDirectoryBaseUrl is deprecated, use setBaseUrl instead');
+    return this._directoryClient.setBaseUrl(baseUrl);
+  }
+
+  /**
+   * Fetches Browse user settings
+   */
+  async querySettings(cloudId, product) {
+    if (cloudId) {
+      this.setContext({
+        cloudId
+      });
+    }
+    return this.measurePerformance('querySettings', async () => {
+      if (!product) {
+        throw new Error('Product is required');
+      }
+      const response = await this._legionClient.retrieveBrowseUserPermission(product);
+      return {
+        'internal.browse-users-allowed': response.canSearchUsers
+      };
+    });
+  }
+
+  /**
+   * This will return all of the teams-related permissions that your user has for the org and site in the client context.
+   */
+  async getPermissions() {
+    return this.measurePerformance('getPermissions', () => this._legionClient.getPermissions());
+  }
+
+  /**
+   * Fetches feature flags from Directory
+   * @deprecated As part of decommisioning pf-directoy
+   */
+  async queryFeatureFlags(...args) {
+    return this.measurePerformance('queryFeatureFlags', () => this._directoryClient.queryFeatureFlags(...args));
+  }
+
+  /**
+   * Get user information of members of a team, paginated
+   * @param {string} teamId
+   * @returns {Promise}
+   */
+  async queryTeamMemberships(teamId, membershipState = ['FULL_MEMBER'], pageInfo = {
+    first: 100
+  }) {
+    return this._aggClient.queryTeamMemberships(teamId, membershipState, pageInfo);
+  }
+
+  /**
+   * Get user information given an user id
+   * @param {string} userId
+   * @returns {Promise}
+   */
+  async queryAGGUser(userId) {
+    return this._aggClient.queryAGGUser(userId);
+  }
+
+  /**
+   * Get user information of a member of a team
+   * @param {string} userId
+   * @returns {Promise<CloudUser>}
+   */
+  queryUser(...args) {
+    return this.measurePerformance('queryUser', () => this._directoryClient.queryUser(...args));
+  }
+  setLegionRootUrl(url) {
+    return this._legionClient.setRootUrl(url);
+  }
+
+  /**
+   *
+   * @param teamId
+   * @returns {Promise<TeamWithImageUrls>}
+   */
+  async getTeamById(teamId) {
+    return this.measurePerformance('getTeamById', () => this._legionClient.getTeamById(teamId));
+  }
+
+  /**
+   * Search teams based on query
+   */
+  async getAllTeams(...args) {
+    return this.measurePerformance('getAllTeams', () => this._legionClient.getAllTeams(...args));
+  }
+
+  /**
+   * Update team details
+   */
+  async updateTeamById(...args) {
+    return this.measurePerformance('updateTeamById', () => this._legionClient.updateTeamById(...args));
+  }
+
+  /**
+   * @private
+   * @deprecated use addUsersToTeam instead
+   */
+  async inviteUsersToTeam(...args) {
+    return this.measurePerformance('inviteUsersToTeam', () => this._legionClient.inviteUsersToTeam(...args));
+  }
+
+  /**
+   * Get the current user's team membership
+   */
+  async getMyTeamMembership(...args) {
+    return this.measurePerformance('getMyTeamMembership', () => this._legionClient.getMyTeamMembership(...args));
+  }
+
+  /**
+   * Get a teams "Links"
+   */
+  async getTeamLinksByTeamId(teamId) {
+    return this.measurePerformance('getTeamLinksByTeamId', () => this._legionClient.getTeamLinksByTeamId(teamId));
+  }
+
+  /**
+   * Create a team link
+   */
+  async createTeamLink(...args) {
+    return this.measurePerformance('createTeamLink', () => this._legionClient.createTeamLink(...args));
+  }
+
+  /**
+   * Update a team link
+   */
+  async updateTeamLink(...args) {
+    return this.measurePerformance('updateTeamLink', () => this._legionClient.updateTeamLink(...args));
+  }
+
+  /**
+   * Delete a team link
+   */
+  async deleteTeamLink(...args) {
+    return this.measurePerformance('deleteTeamLink', () => this._legionClient.deleteTeamLink(...args));
+  }
+
+  /**
+   * Reorder a team link
+   */
+  async reorderTeamLink(...args) {
+    return this.measurePerformance('reorderTeamLink', () => this._legionClient.reorderTeamLink(...args));
+  }
+
+  /**
+   * Get org's eligibility for managed teams
+   */
+  async getOrgEligibilityForManagedTeams() {
+    return this.measurePerformance('getOrgEligibilityForManagedTeams', () => this._legionClient.getOrgEligibilityForManagedTeams());
+  }
+
+  /**
+   * @deprecated Invitation status no longer exists
+   * Accept a team invitation
+   */
+  async acceptTeamInvitation(...args) {
+    return this.measurePerformance('acceptTeamInvitation', () => this._legionClient.acceptTeamInvitation(...args));
+  }
+
+  /**
+   * @deprecated Invitation status no longer exists
+   * Decline a team invitation
+   */
+  async declineTeamInvitation(...args) {
+    return this.measurePerformance('declineTeamInvitation', () => this._legionClient.declineTeamInvitation(...args));
+  }
+
+  /**
+   * Add current user to a team
+   */
+  async selfJoinTeam(...args) {
+    return this.measurePerformance('selfJoinTeam', () => this._legionClient.selfJoinTeam(...args));
+  }
+
+  /**
+   * Cancel a join request to a private team
+   */
+  async cancelJoinRequest(teamId) {
+    return this.measurePerformance('cancelJoinRequest', () => this._legionClient.cancelJoinRequest(teamId));
+  }
+
+  /**
+   * Accept a join request to a private team
+   */
+  async acceptJoinRequest(...args) {
+    return this.measurePerformance('acceptJoinRequest', () => this._legionClient.acceptJoinRequest(...args));
+  }
+
+  /**
+   * Decline a join request to a private team
+   */
+  async declineJoinRequest(...args) {
+    return this.measurePerformance('declineJoinRequest', () => this._legionClient.declineJoinRequest(...args));
+  }
+
+  /**
+   * @deprecated use removeTeamMemberships instead
+   */
+  async deleteTeamMembership(...args) {
+    return this.measurePerformance('deleteTeamMembership', () => this._legionClient.deleteTeamMembership(...args));
+  }
+
+  /**
+   * @deprecated INVITED status has been deprecated
+   */
+  async revokeTeamInvite(...args) {
+    return this.measurePerformance('revokeTeamInvite', () => this._legionClient.revokeTeamInvite(...args));
+  }
+
+  /**
+   * Delete a team
+   */
+  async deleteTeam(teamId) {
+    return this.measurePerformance('deleteTeam', () => this._legionClient.deleteTeam(teamId));
+  }
+
+  /**
+   * @private
+   * @deprecated should be other means to solve this issue
+   */
+  async isSingleFullMemberTeam(teamId) {
+    return this._legionClient.isSingleFullMemberTeam(teamId);
+  }
+
+  /**
+   * Create a team
+   */
+  async createTeam(...args) {
+    return this.measurePerformance('createTeam', () => this._legionClient.createTeam(...args));
+  }
+
+  /**
+   * Create a external team
+   * @param {string} groupDescription - The description of the group, which will be used as the team description. The group name will be fetched from the identity service, so it does not need to be provided.
+   * @param {ExternalReference} externalReference
+   */
+  async createExternalTeam(...args) {
+    return this.measurePerformance('createExternalTeam', () => this._legionClient.createExternalTeam(...args));
+  }
+
+  /**
+   * Get linked teams for a groups in bulk
+   * @param {string} groupIds - The group ids to fetch linked teams for
+   */
+  async getLinkedTeamsBulk(...args) {
+    return this.measurePerformance('getLinkedTeamsBulk', () => this._legionClient.getLinkedTeamsBulk(...args));
+  }
+
+  /**
+   * Get Org scope
+   */
+  async getOrgScope(...args) {
+    return this.measurePerformance('getOrgScope', () => this._legionClient.getOrgScope(...args));
+  }
+
+  /**
+   * Restore soft-deleted team and sync to group
+   */
+  async restoreTeamToSyncedGroup(...args) {
+    return this.measurePerformance('restoreTeamToSyncedGroup', () => this._legionClient.restoreTeamToSyncedGroup(...args));
+  }
+
+  /**
+   * Get the difference between a team and a group
+   * @param teamId
+   * @param {ExternalReference} externalReference
+   * @returns {Promise<TeamAndGroupDifference>}
+   */
+  async getTeamAndGroupDiff(...args) {
+    return this.measurePerformance('getTeamAndGroupDiff', () => this._legionClient.getTeamAndGroupDiff(...args));
+  }
+
+  /**
+   * Link an existing team to a group
+   * @param teamId
+   * @param {ExternalReference} externalReference
+   */
+  async linkExistingTeamToGroup(...args) {
+    return this.measurePerformance('linkExistingTeamToGroup', () => this._legionClient.linkExistingTeamToGroup(...args));
+  }
+
+  /**
+   *
+   * @param teamId
+   * @returns {Promise<LinkedTeamsProfileDetails>}
+   */
+  async getTeamProfileDetailsByTeamId(...args) {
+    return this.measurePerformance('getTeamProfileDetails', () => this._legionClient.getTeamProfileDetails(...args));
+  }
+
+  /**
+   *
+   * @param teamId
+   * @returns {Promise<SoftDeletedTeam>}
+   */
+  async getSoftDeletdTeamById(teamId) {
+    return this.measurePerformance('getSoftDeletedTeamById', () => this._legionClient.getSoftDeletedTeamById(teamId));
+  }
+
+  /**
+   * Shoud only be used within Teams (P&T) packages
+   * @param userId
+   * @returns {Promise<SoftDeletedTeam>}
+   */
+  async getUserInSiteUserBase(userId) {
+    return this.measurePerformance('getUserInSiteUserBase', () => this._legionClient.getUserInSiteUserBase(userId));
+  }
+  trimTeamARI(teamId = '') {
+    return this._legionClient.trimTeamARI(teamId);
+  }
+
+  /**
+   * Get user profile with mutability constraints
+   */
+  async getProfileWithMutability(...args) {
+    return this.measurePerformance('getProfileWithMutability', () => this._mutabilityClient.getProfileWithMutability(...args));
+  }
+
+  /**
+   * Is the current user a site admin
+   */
+  getIsSiteAdmin(...args) {
+    return this.measurePerformance('getIsSiteAdmin', () => this._permsClient.getIsSiteAdmin(...args));
+  }
+
+  /**
+   * Add users to a team
+   */
+  addUsersToTeam(...args) {
+    return this.measurePerformance('addUsersToTeam', () => this._publicApiClient.addUsersToTeam(...args));
+  }
+
+  /**
+   * Remove users from a team
+   */
+  removeTeamMemberships(...args) {
+    return this.measurePerformance('removeTeamMemberships', () => this._publicApiClient.removeTeamMemberships(...args));
+  }
+
+  /**
+   * Restore a deleted team
+   */
+  restoreTeam(...args) {
+    return this.measurePerformance('restoreTeam', () => this._publicApiClient.restoreTeam(...args));
+  }
+  getRecommendedProducts(...args) {
+    return this.measurePerformance('getRecommendedProducts', () => this._invitationsClient.getProductRecommendations(...args));
+  }
+  joinOrRequestDefaultAccessToProductsBulk(...args) {
+    return this.measurePerformance('joinOrRequestDefaultAccessToProductsBulk', () => this._invitationsClient.joinOrRequestDefaultAccessToProductsBulk(...args));
+  }
+
+  /**
+   * Get token to upload media for a team
+   */
+  async getWriteTeamMediaToken() {
+    return this.measurePerformance('getWriteTeamMediaToken', () => this._legionClient.getWriteMediaToken());
+  }
+
+  /**
+   * Get token to read media for a user
+   */
+  async getReadMediaToken(...args) {
+    return this.measurePerformance('getReadMediaToken', () => this._userPreferencesClient.getReadMediaToken(...args));
+  }
+
+  /**
+   * Get token to upload media for a user
+   */
+  async getWriteUserMediaToken() {
+    return this.measurePerformance('getWriteUserMediaToken', () => this._userPreferencesClient.getWriteMediaToken());
+  }
+
+  /**
+   * Update header image for a user
+   */
+  async updateUserHeaderImage(headerImageId) {
+    return this.measurePerformance('updateUserHeaderImage', () => this._userPreferencesClient.updateUserHeaderImage(headerImageId));
+  }
+
+  /**
+   * Fetch user containers from collboration graph
+   */
+  async getUserContainers(...args) {
+    return this.measurePerformance('getUserContainers', () => this._collaborationGraphClient.getUserContainers(...args));
+  }
+
+  /**
+   * Fetch mutatability of external managed user fields
+   */
+  async getUserManageConfig(...args) {
+    return this.measurePerformance('getUserManageConfig', () => this._identityClient.getUserManageConfig(...args));
+  }
+
+  /**
+   * Fetch user avatar uploaded status
+   */
+  async getMyAvatarUploadedStatus(...args) {
+    return this.measurePerformance('getMyAvatarUploadedStatus', () => this._identityClient.getMyAvatarUploadedStatus(...args));
+  }
+
+  /**
+   * Delete user avatar
+   */
+  async deleteAvatar(...args) {
+    return this.measurePerformance('deleteUserAvatar', () => this._identityClient.deleteAvatar(...args));
+  }
+  async fetchUserAvatarInfo(...args) {
+    return this.measurePerformance('fetchUserAvatarInfo', () => this._identityClient.fetchUserAvatarInfo(...args));
+  }
+
+  /**
+   * Fetch Team link icons
+   */
+  async getTeamLinkIcons(...args) {
+    return this.measurePerformance('getTeamLinkIcons', () => this._objectResolverClient.getTeamLinkIcons(...args));
+  }
+
+  /**
+   * Fetch team in slack details
+   */
+  async getTeamInSlack(...args) {
+    return this.measurePerformance('getTeamInSlack', () => this._teamsInSlackClient.getTeamInSlack(...args));
+  }
+
+  /**
+   * Delete team in slack
+   */
+  async disconnectTeamInSlack(...args) {
+    return this.measurePerformance('disconnectTeamInSlack', () => this._teamsInSlackClient.disconnectTeamInSlack(...args));
+  }
+
+  /**
+   * Update team in slack
+   */
+  async updateTeamInSlack(...args) {
+    return this.measurePerformance('updateTeamInSlack', () => this._teamsInSlackClient.updateTeamInSlack(...args));
+  }
+
+  /**
+   * Update user details
+   */
+  async updateUser(...args) {
+    return this.measurePerformance('updateUser', () => this._identityClient.updateUser(...args));
+  }
+  async updateUserAvatar(...args) {
+    return this.measurePerformance('updateUserAvatar', () => this._identityClient.updateUserAvatar(...args));
+  }
+}
+export const teamsClient = new TeamsClient();

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

@@ -0,0 +1,49 @@
+import { DefaultError } from '../../common/utils/error';
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+const defaultConfig = {
+  serviceUrl: `${DEFAULT_CONFIG.stargateRoot}/users/manage`
+};
+const NOT_EDITABLE = 'not_editable';
+const NOT_EDITABLE_FIELD = 'field';
+const NOT_EDITABLE_REASON = 'reason';
+export class MutabilityClient extends RestClient {
+  constructor(config = {}) {
+    super({
+      ...defaultConfig,
+      ...config
+    });
+  }
+  async getProfileWithMutability(userId) {
+    return this.getResource(`/${userId}/profile`).then(resp => {
+      return mapToMutabilityConstraints(resp);
+    });
+  }
+}
+function mapToMutabilityConstraints(json) {
+  let constraints = [];
+  if (json[NOT_EDITABLE] != null) {
+    for (const value of json[NOT_EDITABLE]) {
+      constraints = constraints.concat({
+        field: value[NOT_EDITABLE_FIELD],
+        reason: determineReason(value[NOT_EDITABLE_REASON])
+      });
+    }
+  }
+  return constraints;
+}
+function determineReason(value) {
+  switch (value) {
+    case 'managed':
+    case 'ext.dir.scim':
+    case 'ext.dir.google':
+      return value;
+    default:
+      throw new DefaultError({
+        message: `Unknown mutability constraint reason: ${value}`
+      });
+  }
+}
+
+// eslint-disable-next-line import/no-anonymous-default-export
+export default new MutabilityClient();

package/dist/es2019/services/object-resolver-client/index.js

@@ -0,0 +1,21 @@
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+import { transformIconData } from './utils';
+const defaultConfig = {
+  serviceUrl: `${DEFAULT_CONFIG.stargateRoot}`
+};
+export class ObjectResolverClient extends RestClient {
+  constructor(config = {}) {
+    super({
+      ...defaultConfig,
+      ...config
+    });
+  }
+  async getTeamLinkIcons(teamLinkUrls) {
+    const requestBody = teamLinkUrls.map(url => ({
+      resourceUrl: url
+    }));
+    return this.postResourceRaw(`/object-resolver/resolve/batch`, JSON.stringify(requestBody)).then(transformIconData);
+  }
+}
+export default new ObjectResolverClient();

package/dist/es2019/services/object-resolver-client/types.js

@@ -0,0 +1,12 @@
+/**
+ * This type matches the props for the TeamLinkIcon component in embeddable-directory
+ */
+
+/**
+ * These names match the Provider Name in the JSON-LD response from respective resolvers
+ */
+export let ProviderNames = /*#__PURE__*/function (ProviderNames) {
+  ProviderNames["CONFLUENCE"] = "Confluence";
+  ProviderNames["JIRA"] = "Jira";
+  return ProviderNames;
+}({});

package/dist/es2019/services/object-resolver-client/utils.js

@@ -0,0 +1,53 @@
+import { ProviderNames } from './types';
+
+/**
+ * Formats data into LinkIconData with appropriate Jira/Confluence favicon urls.
+ * Undefined icons remain undefined.
+ * Exported for testing purposes.
+ *
+ * Confluence favicon extension: /wiki/favicon.ico
+ * Jira favicon extension: /favicon.ico
+ *
+ * @param jsonLd - raw JSON-LD data for an individual link
+ */
+export const formatLinkIconData = jsonLd => {
+  const {
+    url,
+    generator: {
+      name,
+      icon
+    }
+  } = jsonLd;
+  switch (name) {
+    case ProviderNames.CONFLUENCE:
+      return {
+        linkUrl: url,
+        iconUrl: getConfluenceFavicon(url),
+        productName: name
+      };
+    case ProviderNames.JIRA:
+      return {
+        linkUrl: url,
+        iconUrl: getJiraFavicon(url),
+        productName: name
+      };
+    default:
+      return {
+        linkUrl: url,
+        iconUrl: typeof icon === 'object' ? icon['url'] : icon,
+        productName: name
+      };
+  }
+};
+const isIconItemSuccess = response => {
+  return response.status === 200;
+};
+
+/**
+ * Converts batched list of json-ld responses into list of formatted LinkIconData { url, icon_url }
+ *
+ * @param batchResp - list of json-ld responses { body, status }
+ */
+export const transformIconData = batchResp => batchResp.filter(isIconItemSuccess).map(resp => resp.body.data).map(formatLinkIconData).filter(linkIconData => linkIconData.iconUrl !== undefined);
+const getConfluenceFavicon = url => `https://${new URL(url).hostname}/wiki/favicon.ico`;
+const getJiraFavicon = url => `https://${new URL(url).hostname}/favicon.ico`;

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

@@ -0,0 +1,25 @@
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+export class PermsClient extends RestClient {
+  getIsSiteAdmin(
+  /**
+   * @private
+   * @deprecated don't need to pass param, value is taken from `this.getCloudId()` instead
+   */
+  cloudId) {
+    return this.postResource('/permitted', {
+      permissionId: 'manage',
+      resourceId: `ari:cloud:platform::site/${this.getCloudId(cloudId)}`
+    }).then(response => response.permitted);
+  }
+}
+
+/**
+ * REST Client to make calls to resources on the activity service.
+ *
+ * @type {RestClient}
+ */
+// eslint-disable-next-line import/no-anonymous-default-export
+export default new PermsClient({
+  serviceUrl: DEFAULT_CONFIG.permsServiceUrl
+});