@wireapp/core 20.7.2 → 21.0.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [21.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@20.7.2...@wireapp/core@21.0.0) (2022-01-18)
+
+
+### Features
+
+* **core:** Send availability status only to directly connected members ([#4213](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4213)) ([73bad2f](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/73bad2fb8f75a473b686fa9273b1c03774afd5c7))
+
+
+### BREAKING CHANGES
+
+* **core:** the setAvailability of the user service will by default now only send to directly connected users. To send to absolutely all the users in the team call `setAvailability` with the `{sendAll: true}` option
+
+
+
+
+
 ## [20.7.2](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@20.7.1...@wireapp/core@20.7.2) (2022-01-12)
 
 **Note:** Version bump only for package @wireapp/core

package/package.json

@@ -69,6 +69,6 @@
     "test:project": "yarn dist && yarn test",
     "test:node": "nyc jasmine --config=jasmine.json"
   },
-  "version": "20.7.2",
-  "gitHead": "57da347406b301aa1d3ea80ab6b53c9740a645ff"
+  "version": "21.0.0",
+  "gitHead": "0c11c749cae20f3a86839385aeb8486170598339"
 }

package/src/main/broadcast/BroadcastService.d.ts

@@ -8,6 +8,13 @@ export declare class BroadcastService {
     private readonly cryptographyService;
     private readonly messageService;
     constructor(apiClient: APIClient, cryptographyService: CryptographyService);
-    getPreKeyBundlesFromTeam(teamId: string, skipOwnClients?: boolean): Promise<UserPreKeyBundleMap>;
+    /**
+     * Will create a key bundle for all the users of the team
+     *
+     * @param teamId
+     * @param skipOwnClients=false
+     * @param onlyDirectConnections=false Will generate a bundle only for directly connected users (users the self user has conversation with). Allows avoiding broadcasting messages to too many people
+     */
+    getPreKeyBundlesFromTeam(teamId: string, skipOwnClients?: boolean, onlyDirectConnections?: boolean): Promise<UserPreKeyBundleMap>;
     broadcastGenericMessage(genericMessage: GenericMessage, recipients: UserPreKeyBundleMap | UserClients, sendAsProtobuf?: boolean): Promise<ClientMismatch>;
 }

package/src/main/broadcast/BroadcastService.js

@@ -27,9 +27,20 @@ class BroadcastService {
         this.cryptographyService = cryptographyService;
         this.messageService = new MessageService_1.MessageService(this.apiClient, this.cryptographyService);
     }
-    async getPreKeyBundlesFromTeam(teamId, skipOwnClients = false) {
-        const { members: teamMembers } = await this.apiClient.teams.member.api.getAllMembers(teamId);
-        let members = teamMembers.map(member => ({ id: member.user }));
+    /**
+     * Will create a key bundle for all the users of the team
+     *
+     * @param teamId
+     * @param skipOwnClients=false
+     * @param onlyDirectConnections=false Will generate a bundle only for directly connected users (users the self user has conversation with). Allows avoiding broadcasting messages to too many people
+     */
+    async getPreKeyBundlesFromTeam(teamId, skipOwnClients = false, onlyDirectConnections = false) {
+        const teamMembers = onlyDirectConnections
+            ? (await this.apiClient.conversation.api.getConversations()).conversations
+                .map(({ members }) => members.others.map(user => user.id).concat(members.self.id))
+                .flat()
+            : (await this.apiClient.teams.member.api.getAllMembers(teamId)).members.map(({ user }) => user);
+        let members = Array.from(new Set(teamMembers)).map(member => ({ id: member }));
         if (skipOwnClients) {
             const selfUser = await this.apiClient.self.api.getSelf();
             members = members.filter(member => member.id !== selfUser.id);

package/src/main/user/UserService.d.ts

@@ -11,5 +11,15 @@ export declare class UserService {
     constructor(apiClient: APIClient, broadcastService: BroadcastService, conversationService: ConversationService, connectionService: ConnectionService);
     getUser(userId: string | QualifiedId): Promise<User>;
     getUsers(userIds: string[] | QualifiedId[]): Promise<User[]>;
-    setAvailability(teamId: string, type: AvailabilityType, sendAsProtobuf?: boolean): Promise<void>;
+    /**
+     * Sends a availability update to members of the same team
+     * @param teamId
+     * @param type
+     * @param options.sendAll=false will broadcast the message to all the members of the team (instead of just direct connections). Should be avoided in a big team
+     * @param options.sendAsProtobuf=false
+     */
+    setAvailability(teamId: string, type: AvailabilityType, { sendAll, sendAsProtobuf }: {
+        sendAll: boolean;
+        sendAsProtobuf?: boolean;
+    }): Promise<void>;
 }

package/src/main/user/UserService.js

@@ -44,9 +44,16 @@ class UserService {
             ? this.apiClient.user.api.postListUsers({ qualified_ids: userIds })
             : this.apiClient.user.api.getUsers({ ids: userIds });
     }
-    async setAvailability(teamId, type, sendAsProtobuf) {
+    /**
+     * Sends a availability update to members of the same team
+     * @param teamId
+     * @param type
+     * @param options.sendAll=false will broadcast the message to all the members of the team (instead of just direct connections). Should be avoided in a big team
+     * @param options.sendAsProtobuf=false
+     */
+    async setAvailability(teamId, type, { sendAll = false, sendAsProtobuf = false }) {
         // Get pre-key bundles for members of your own team
-        const preKeyBundlesFromTeam = await this.broadcastService.getPreKeyBundlesFromTeam(teamId);
+        const preKeyBundlesFromTeam = await this.broadcastService.getPreKeyBundlesFromTeam(teamId, false, !sendAll);
         // Get pre-key bundles for all of your other 1:1 connections
         const connections = await this.connectionService.getConnections();
         const acceptedConnections = connections.filter(connection => connection.status === connection_1.ConnectionStatus.ACCEPTED);