@atlaskit/teams-client 4.0.0

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

@@ -0,0 +1,484 @@
+import { DEFAULT_CONFIG } from '../constants';
+import { RestClient } from '../rest-client';
+
+/**
+ * @type AllTeamsQuery
+ * Query type for the getAllTeams API
+ * @property {string} orgId - Organization ID
+ * @property {string} cursor - Cursor to fetch the next page of results
+ * @property {number} limit - Number of teams to fetch
+ * @property {string} searchQuery - Search query to filter teams
+ * @property {string[]} memberAccountIds - List of member account IDs to filter teams
+ * @property {boolean} useDefaultSort - Whether to use the default sort order
+ * @property {boolean} showEmptyTeams - Whether to return empty teams in the search
+ */
+
+/**
+ * @type AllTeamsResponse
+ * Response type for the getAllTeams API
+ * @property {TeamWithMemberships[]} teams - List of teams
+ * @property {string} cursor - Cursor to fetch the next page of results
+ * @property {Error} error - Error object if the API call fails
+ */
+
+/**
+ * @type AllTeamsPayload
+ * Payload type for the getAllTeams API
+ * @property {TeamWithMemberships[]} entities - List of teams
+ * @property {string} cursor - Cursor to fetch the next page of results
+ */
+
+const v3UrlPath = `/v3/teams`;
+const v4UrlPath = `/v4/teams`;
+
+/**
+ * REST Client to make calls to Legion.
+ *
+ * Redirects to the instance login screen when a response returns a 401.
+ * It should probably redirect to Aa, but this is what the existing clients
+ * do so I'm going to follow suite.
+ */
+export class LegionClient extends RestClient {
+  constructor(serviceUrl) {
+    super({
+      serviceUrl
+    });
+    this.serviceUrlRoot = serviceUrl;
+  }
+  setRootUrl(url) {
+    if (url === this.serviceUrlRoot) {
+      return;
+    }
+    this.serviceUrlRoot = url;
+    this.setServiceUrl(url);
+  }
+  async getTeamById(teamId) {
+    const siteId = this.getCloudId();
+    const teamResponse = await this.getResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}?siteId=${siteId}`);
+    return this.mapTeamResponseV4ToTeam(teamResponse);
+  }
+  async getAllTeams(allTeamsQuery) {
+    try {
+      const orgId = this.getOrgId(allTeamsQuery.orgId);
+      const siteId = this.getCloudId();
+      const {
+        entities,
+        cursor
+      } = await this.postResource(`${v4UrlPath}/search`, {
+        organizationId: orgId,
+        siteId: siteId,
+        limit: allTeamsQuery.limit,
+        query: allTeamsQuery.searchQuery,
+        cursor: allTeamsQuery.cursor || '',
+        sortBy: allTeamsQuery.useDefaultSort ? null : [{
+          field: 'displayName',
+          order: 'asc'
+        }],
+        membership: {
+          memberAccountIds: allTeamsQuery.memberAccountIds
+        },
+        showEmptyTeams: allTeamsQuery.showEmptyTeams
+      });
+      const teams = entities.map(t => this.mapTeamSearchResponseV4ToTeamWithMembership(t));
+      return {
+        cursor,
+        teams: teams
+      };
+    } catch (error) {
+      this.logException(error, 'getAllTeams');
+      return {
+        cursor: '',
+        teams: [],
+        error: error instanceof Error ? error : undefined
+      };
+    }
+  }
+  async updateTeamById(teamId, data) {
+    const teamResponse = await this.patchResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}`, data);
+    return this.mapTeamResponseV4ToTeam(teamResponse);
+  }
+
+  /**
+   * @private
+   * @deprecated use publicApiClient.addUsersToTeam instead
+   */
+  async inviteUsersToTeam(teamId, users, originQuery) {
+    if (!users || users.length === 0) {
+      return Promise.resolve([]);
+    }
+    const emails = [];
+    const ids = [];
+    users.forEach(user => {
+      if (user.id) {
+        ids.push(user.id);
+      } else if (user.email) {
+        emails.push(user.email);
+      }
+    });
+    const url = `${v3UrlPath}/ui/${this.trimTeamARI(teamId)}/membership/invite?${this.constructProductOriginParams(originQuery)}`;
+    return this.postResource(url, {
+      emailAddresses: emails,
+      atlassianAccounts: ids
+    });
+  }
+  async getMyTeamMembership(teamId) {
+    return this.getResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/membership/me?siteId=${this.getCloudId()}`, {
+      shouldLogError: e => e.status !== 400
+    });
+  }
+  async getTeamLinksByTeamId(teamId) {
+    let siteId = this.getCloudId();
+    let response = await this.getResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/links?siteId=${siteId}`);
+    return this.mapLegionTeamLinksResponseV4ToTeamLinkResponse(response);
+  }
+  async createTeamLink(teamId, link) {
+    const sanitisedTeamLink = {
+      contentTitle: link.contentTitle.trim(),
+      linkUri: link.linkUri.trim(),
+      description: link.description.trim(),
+      ...(link.creationTime ? {
+        creationTime: link.creationTime.trim()
+      } : {}),
+      ...(link.teamId ? {
+        teamId: link.teamId.trim()
+      } : {})
+    };
+    const response = await this.postResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/links`, sanitisedTeamLink);
+    return this.mapLegionTeamLinkResponseV4ToTeamLink(response);
+  }
+  async updateTeamLink(teamId, linkId, {
+    linkUri,
+    ...linkFields
+  }) {
+    const response = await this.putResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/links/${linkId}`, {
+      linkUri: linkUri.trim(),
+      ...linkFields
+    });
+    return this.mapLegionTeamLinkResponseV4ToTeamLink(response);
+  }
+  async deleteTeamLink(teamId, linkId) {
+    return this.deleteResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/links/${linkId}`);
+  }
+  async reorderTeamLink(teamId, linkId, newPosition) {
+    const queryArgs = `?linkId=${linkId}&newPosition=${newPosition}`;
+    return this.postResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/links/order${queryArgs}`);
+  }
+  async getOrgEligibilityForManagedTeams() {
+    const orgId = this.getOrgId();
+    if (!orgId) {
+      const err = new Error('Organization ID is required');
+      this.logException(err, 'getOrgEligibilityForManagedTeams');
+      throw err;
+    }
+    return this.getResourceCached(`${v4UrlPath}/org/${orgId}/premium/eligibility`);
+  }
+
+  /**
+   * @private
+   * @deprecated in V4, as no invitation status for team membership anymore.
+   */
+  async acceptTeamInvitation(teamId) {
+    return this.postResource(`${v3UrlPath}/ui/${this.trimTeamARI(teamId)}/membership/accept`);
+  }
+
+  /**
+   * @private
+   * @deprecated in V4, as no invitation status for team membership anymore.
+   */
+  async declineTeamInvitation(teamId) {
+    return this.postResource(`${v3UrlPath}/ui/${this.trimTeamARI(teamId)}/membership/decline`);
+  }
+  async selfJoinTeam(
+  // TODO Test me
+  teamId, originQuery) {
+    const url = `${v4UrlPath}/${this.trimTeamARI(teamId)}/membership/join?${this.constructProductOriginParams(originQuery)}`;
+    return this.postResource(url);
+  }
+  async cancelJoinRequest(teamId) {
+    return this.deleteResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/membership/request`);
+  }
+  async acceptJoinRequest(teamId, memberId) {
+    return this.postResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/membership/${memberId}/request/accept`);
+  }
+  async declineJoinRequest(teamId, memberId) {
+    return this.postResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/membership/${memberId}/request/decline`);
+  }
+
+  /**
+   * @private
+   * @deprecated use publicApiClient.removeTeamMemberships instead
+   */
+  async deleteTeamMembership(teamId, memberId) {
+    return this.deleteResource(`${v3UrlPath}/${this.trimTeamARI(teamId)}/members/${memberId}`);
+  }
+
+  /**
+   * @private
+   * @deprecated INVITED status has been deprecated
+   */
+  async revokeTeamInvite(teamId, memberId) {
+    return this.deleteResource(`${v3UrlPath}/ui/${this.trimTeamARI(teamId)}/membership/${memberId}/revoke`);
+  }
+  async deleteTeam(teamId) {
+    return this.deleteResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}`);
+  }
+
+  /**
+   * @private
+   * @deprecated should be other means to solve this issue
+   */
+  async isSingleFullMemberTeam(teamId) {
+    // This is still not working...
+    const members = await this.getResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/members?size=2&membershipState=FULL_MEMBER&siteId=${this.getCloudId()}`);
+    return members.entities.length === 1;
+  }
+  async createTeam(displayName, originQuery, members, membershipSettings = 'OPEN') {
+    const organizationId = this.getContext().orgId;
+    if (!organizationId) {
+      const err = new Error('Organization ID is required');
+      this.logException(err, 'createTeam');
+      throw err;
+    }
+    const url = `${v4UrlPath}?${this.constructProductOriginParams(originQuery)}`;
+    const legionTeam = await this.postResource(url, {
+      displayName,
+      description: '',
+      membershipSettings: membershipSettings,
+      siteId: this.getCloudId(),
+      organizationId: organizationId,
+      members: [...new Set(members)]
+    });
+    return this.mapTeamCreateResponseV4ToTeam(legionTeam);
+  }
+  async createExternalTeam(description, externalReference, teamName, siteId) {
+    const organizationId = this.getContext().orgId;
+    const cloudId = this.getContext().cloudId;
+    if (!organizationId) {
+      const err = new Error('Organization ID is required');
+      this.logException(err, 'createTeam');
+      throw err;
+    }
+    const url = `${v4UrlPath}/external?origin.cloudId=${encodeURIComponent(this.getCloudId(siteId || cloudId))}`;
+    const legionExternalTeam = await this.postResource(url, {
+      description,
+      externalReference,
+      organizationId,
+      siteId: siteId || cloudId,
+      displayName: teamName
+    });
+    return this.mapTeamCreateResponseV4ToTeam(legionExternalTeam);
+  }
+  async getTeamAndGroupDiff(teamId, externalReference) {
+    const siteId = this.getCloudId();
+    return this.postResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/external/diff`, {
+      siteId,
+      externalReference
+    });
+  }
+  async linkExistingTeamToGroup(teamId, externalReference) {
+    const siteId = this.getCloudId();
+    return this.postResource(`${v4UrlPath}/${this.trimTeamARI(teamId)}/external/link`, {
+      externalReference,
+      siteId
+    });
+  }
+  async getWriteMediaToken() {
+    return this.getResource('/v4/teams/header-image/media-upload').then(response => {
+      var _response$baseUrl;
+      return {
+        ...response,
+        baseUrl: (_response$baseUrl = response.baseUrl) !== null && _response$baseUrl !== void 0 && _response$baseUrl.endsWith('/') ? response.baseUrl.slice(0, -1) : response.baseUrl
+      };
+    });
+  }
+  async getSoftDeletedTeamById(teamId) {
+    const orgId = this.getOrgId();
+    const siteId = this.getCloudId();
+    return this.getResource(`${v4UrlPath}/org/${orgId}/soft-deleted/${this.trimTeamARI(teamId)}?siteId=${siteId}`).then(response => ({
+      ...response.teamResponse,
+      id: teamId
+    }));
+  }
+
+  /**
+   * Shoud only be used within Teams (P&T) packages
+   */
+  async getUserInSiteUserBase(userId) {
+    const siteId = this.getCloudId();
+    return this.getResource(`/teams/site/${siteId}/users/${userId}/exists`, {
+      headers: {
+        Accept: 'application/json',
+        'X-header-client-id': 'ptc-fe'
+      }
+    });
+  }
+  async retrieveBrowseUserPermission(product) {
+    return this.getResourceCached(`/teams/site/${this.getCloudId()}/canSearchUsers?product=${product}`, undefined,
+    // 2 minute expiration, resolves duplicate calls in initial load
+    {
+      expiration: 1000 * 60 * 2
+    });
+  }
+  async getPermissions() {
+    const orgId = this.getContext().orgId;
+    const siteId = this.getCloudId();
+    if (!orgId) {
+      const err = new Error('Organization ID is required');
+      this.logException(err, 'getPermissions');
+      throw err;
+    }
+    return this.getResourceCached(`${v4UrlPath}/permission/self/organization/${orgId}?siteId=${siteId}`);
+  }
+  async getLinkedTeamsBulk(groupIds) {
+    const organizationId = this.getContext().orgId;
+    if (!organizationId) {
+      const err = new Error('Organization ID is required');
+      this.logException(err, 'getLinkedTeamsBulk');
+      throw err;
+    }
+    const legionExternalTeam = await this.postResource(`${v4UrlPath}/external/bulk`, {
+      organizationId,
+      source: 'ATLASSIAN_GROUP',
+      externalIds: groupIds
+    });
+    return legionExternalTeam;
+  }
+  async getTeamProfileDetails(teamId) {
+    const siteId = this.getCloudId();
+    if (!siteId) {
+      const err = new Error('Site ID is required');
+      this.logException(err, 'getTeamProfileDetails');
+      throw err;
+    }
+    const linkedTeamsProfileDetails = await this.getResource(`${v4UrlPath}/${teamId}/profile?siteId=${this.getCloudId()}`);
+    return linkedTeamsProfileDetails;
+  }
+  async getOrgScope() {
+    const orgId = this.getContext().orgId;
+    if (!orgId) {
+      const err = new Error('Organization ID is required');
+      this.logException(err, 'getOrgScope');
+      throw err;
+    }
+    const orgScope = await this.getResourceCached(`${v4UrlPath}/org/${orgId}/scope`);
+    return orgScope;
+  }
+  async restoreTeamToSyncedGroup(teamId, externalReference) {
+    const siteId = this.getCloudId();
+    return await this.postResource(`${v4UrlPath}/${teamId}/external/restore`, {
+      externalReference: externalReference,
+      siteId
+    });
+  }
+
+  // some Legion APIs return team id with the team ARI
+  trimTeamARI(teamId = '') {
+    const OLD_TEAM_ARI_PREFIX = 'ari:cloud:teams::team/';
+    const TEAM_ARI_PREFIX = 'ari:cloud:identity::team/';
+    return teamId.replace(TEAM_ARI_PREFIX, '').replace(OLD_TEAM_ARI_PREFIX, ''); // PTC-4213 will remove the references to the old team ARI
+  }
+  constructProductOriginParams(originQuery) {
+    const product = (originQuery.product || '').toUpperCase();
+    const queries = [`origin.cloudId=${encodeURIComponent(this.getCloudId(originQuery.cloudId))}`];
+    if (product) {
+      queries.push(`origin.product=${encodeURIComponent(product)}`);
+    }
+    return queries.join('&');
+  }
+  mapTeamResponseV4ToTeam(teamResponse) {
+    return {
+      id: teamResponse.id,
+      displayName: teamResponse.displayName,
+      description: teamResponse.description,
+      state: teamResponse.state,
+      membershipSettings: teamResponse.membershipSettings,
+      organizationId: teamResponse.organizationId,
+      restriction: 'ORG_MEMBERS',
+      // Deprecated field, not used in UI - this is the safest default
+      creatorId: teamResponse.creatorId,
+      permission: teamResponse.permission,
+      orgId: teamResponse.organizationId,
+      smallHeaderImageUrl: teamResponse.smallHeaderImageUrl,
+      largeHeaderImageUrl: teamResponse.largeHeaderImageUrl,
+      smallAvatarImageUrl: teamResponse.smallAvatarImageUrl,
+      largeAvatarImageUrl: teamResponse.largeAvatarImageUrl,
+      scopeMode: teamResponse.scopeMode,
+      isVerified: teamResponse.isVerified
+    };
+  }
+  mapTeamCreateResponseV4ToTeam(teamResponse) {
+    var _teamResponse$members, _teamResponse$members2;
+    return {
+      id: teamResponse.id,
+      displayName: teamResponse.displayName,
+      description: teamResponse.description,
+      state: teamResponse.state,
+      membershipSettings: teamResponse.membershipSettings,
+      organizationId: teamResponse.organizationId,
+      restriction: 'ORG_MEMBERS',
+      // Deprecated field, not used in UI - this is the safest default
+      creatorId: teamResponse.creatorId,
+      permission: teamResponse.permission,
+      orgId: teamResponse.organizationId,
+      memberIds: ((_teamResponse$members = teamResponse.membership) === null || _teamResponse$members === void 0 ? void 0 : (_teamResponse$members2 = _teamResponse$members.members) === null || _teamResponse$members2 === void 0 ? void 0 : _teamResponse$members2.map(m => m.membershipId.memberId)) || [],
+      membership: teamResponse.membership
+    };
+  }
+  mapTeamSearchResponseV4ToTeamWithMembership(teamResponse) {
+    return {
+      id: teamResponse.id,
+      displayName: teamResponse.displayName,
+      description: teamResponse.description,
+      state: teamResponse.state,
+      membershipSettings: teamResponse.membershipSettings,
+      organizationId: teamResponse.organizationId,
+      restriction: 'ORG_MEMBERS',
+      // Deprecated field, not used in UI - this is the safest default
+      smallHeaderImageUrl: teamResponse.smallHeaderImageUrl,
+      largeAvatarImageUrl: teamResponse.largeAvatarImageUrl,
+      smallAvatarImageUrl: teamResponse.smallAvatarImageUrl,
+      largeHeaderImageUrl: teamResponse.largeHeaderImageUrl,
+      memberCount: teamResponse.memberCount,
+      includesYou: teamResponse.includesYou,
+      memberIds: [],
+      // Team Search API does not return members
+      members: [],
+      // Team Search API does not return members
+      membership: {
+        members: [],
+        errors: []
+      },
+      isVerified: teamResponse.isVerified
+    };
+  }
+  mapLegionTeamLinksResponseV3ToTeamLinkResponse(response) {
+    return {
+      entities: response.entities.map(this.mapLegionTeamLinkResponseV3ToTeamLink)
+    };
+  }
+  mapLegionTeamLinksResponseV4ToTeamLinkResponse(response) {
+    return {
+      entities: response.entities.map(this.mapLegionTeamLinkResponseV4ToTeamLink)
+    };
+  }
+  mapLegionTeamLinkResponseV3ToTeamLink(legionLinkResponseV3) {
+    return {
+      contentTitle: legionLinkResponseV3.contentTitle,
+      description: legionLinkResponseV3.description,
+      creationTime: legionLinkResponseV3.creationTime,
+      linkUri: legionLinkResponseV3.linkUri,
+      linkId: legionLinkResponseV3.linkId,
+      teamId: legionLinkResponseV3.teamId
+    };
+  }
+  mapLegionTeamLinkResponseV4ToTeamLink(legionLinkResponseV4) {
+    return {
+      contentTitle: legionLinkResponseV4.contentTitle,
+      description: legionLinkResponseV4.description,
+      linkUri: legionLinkResponseV4.linkUri,
+      linkId: legionLinkResponseV4.linkId,
+      teamId: legionLinkResponseV4.teamId
+    };
+  }
+}
+export const defaultLegionClient = new LegionClient(DEFAULT_CONFIG.stargateRoot);

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

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