@wireapp/core 20.7.2 → 22.0.0

package/CHANGELOG.md

@@ -3,6 +3,61 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [22.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@21.0.2...@wireapp/core@22.0.0) (2022-01-31)
+
+
+### Features
+
+* **core:** Remove the need to give a domain to use qualified Ids ([#4217](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4217)) ([8ce58ea](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/8ce58eae8dcf86f66baccab3acfca7e3ba472e3c))
+
+
+### BREAKING CHANGES
+
+* **core:** If you were using the Account with a federationDomain, you need to replace federationDomain: 'the.domain' to useQualifiedIds: true. The domain will be found automatically by the core
+
+
+
+
+
+## [21.0.2](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@21.0.1...@wireapp/core@21.0.2) (2022-01-19)
+
+
+### Bug Fixes
+
+* **core:** Use Uint8Array in place of Buffer ([#4214](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4214)) ([d9c8692](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/d9c869291e60325411070b87f71d8803561bde49))
+
+
+
+
+
+## [21.0.1](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@21.0.0...@wireapp/core@21.0.1) (2022-01-18)
+
+
+### Bug Fixes
+
+* **core:** Improve types for setAvailability ([26da881](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/26da88113adf9eaba987ad22265df758231e5dc1))
+* **core:** Improve types for setAvailability ([dcbada4](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/dcbada4e353296e17307baeac8d4b775158a1436))
+
+
+
+
+
+# [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": "22.0.0",
+  "gitHead": "6f85fe1a8bc2dfe0ef0db6dfe094916aa00dc1f7"
 }

package/src/main/Account.d.ts

@@ -54,10 +54,11 @@ export interface Account {
 }
 export declare type StoreEngineProvider = (storeName: string) => Promise<CRUDEngine>;
 declare type AccountConfig = {
-    federationDomain?: string;
+    /** If set to true, will use fully qualified ids and federated endpoints */
+    useQualifiedIds?: boolean;
 };
 export declare class Account extends EventEmitter {
-    private readonly config?;
+    private readonly config;
     private readonly apiClient;
     private readonly logger;
     private readonly storeEngineProvider;
@@ -81,9 +82,8 @@ export declare class Account extends EventEmitter {
     /**
      * @param apiClient The apiClient instance to use in the core (will create a new new one if undefined)
      * @param storeEngineProvider Used to store info in the database (will create a inMemory engine if undefined)
-     * @param config.federationDomain If using a federated backend this will set the default domain for qualified ids. Do not set if using a regular backend
      */
-    constructor(apiClient?: APIClient, storeEngineProvider?: StoreEngineProvider, config?: AccountConfig | undefined);
+    constructor(apiClient?: APIClient, storeEngineProvider?: StoreEngineProvider, config?: AccountConfig);
     private persistCookie;
     get clientId(): string;
     get userId(): string;

package/src/main/Account.js

@@ -71,9 +71,8 @@ class Account extends events_1.EventEmitter {
     /**
      * @param apiClient The apiClient instance to use in the core (will create a new new one if undefined)
      * @param storeEngineProvider Used to store info in the database (will create a inMemory engine if undefined)
-     * @param config.federationDomain If using a federated backend this will set the default domain for qualified ids. Do not set if using a regular backend
      */
-    constructor(apiClient = new api_client_1.APIClient(), storeEngineProvider, config) {
+    constructor(apiClient = new api_client_1.APIClient(), storeEngineProvider, config = {}) {
         super();
         this.config = config;
         this.handlePayload = async (payload) => {
@@ -157,7 +156,7 @@ class Account extends events_1.EventEmitter {
         const connectionService = new connection_1.ConnectionService(this.apiClient);
         const giphyService = new giphy_1.GiphyService(this.apiClient);
         const linkPreviewService = new linkPreview_1.LinkPreviewService(assetService);
-        const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService);
+        const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService, this.config);
         const notificationService = new notification_1.NotificationService(this.apiClient, cryptographyService, storeEngine);
         const selfService = new self_1.SelfService(this.apiClient);
         const teamService = new team_1.TeamService(this.apiClient);

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/conversation/ConversationService.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { APIClient } from '@wireapp/api-client';
 import { MessageSendingStatus, Conversation, DefaultConversationRoleName, MutedStatus, QualifiedUserClients, UserClients, ClientMismatch } from '@wireapp/api-client/src/conversation';
 import type { ConversationMemberLeaveEvent } from '@wireapp/api-client/src/event';
@@ -61,10 +60,13 @@ export interface MessageSendingCallbacks {
 }
 export declare class ConversationService {
     private readonly apiClient;
+    private readonly config;
     readonly messageTimer: MessageTimer;
     private readonly messageService;
     private selfConversationId?;
-    constructor(apiClient: APIClient, cryptographyService: CryptographyService);
+    constructor(apiClient: APIClient, cryptographyService: CryptographyService, config: {
+        useQualifiedIds?: boolean;
+    });
     private createEphemeral;
     private getConversationQualifiedMembers;
     /**
@@ -150,7 +152,7 @@ export declare class ConversationService {
     createConversation(name: string, otherUserIds?: string | string[]): Promise<Conversation>;
     getConversations(conversationId: string): Promise<Conversation>;
     getConversations(conversationIds?: string[]): Promise<Conversation[]>;
-    getAsset({ assetId, assetToken, otrKey, sha256 }: RemoteData): Promise<Buffer>;
+    getAsset({ assetId, assetToken, otrKey, sha256 }: RemoteData): Promise<Uint8Array>;
     getUnencryptedAsset(assetId: string, assetToken?: string): Promise<ArrayBuffer>;
     addUser<T extends string | string[] | QualifiedId | QualifiedId[]>(conversationId: string, userIds: T): Promise<T>;
     removeUser(conversationId: string, userId: string): Promise<string>;

package/src/main/conversation/ConversationService.js

@@ -35,8 +35,9 @@ var MessageTargetMode;
     MessageTargetMode[MessageTargetMode["USERS_CLIENTS"] = 2] = "USERS_CLIENTS";
 })(MessageTargetMode = exports.MessageTargetMode || (exports.MessageTargetMode = {}));
 class ConversationService {
-    constructor(apiClient, cryptographyService) {
+    constructor(apiClient, cryptographyService, config) {
         this.apiClient = apiClient;
+        this.config = config;
         this.messageTimer = new conversation_2.MessageTimer();
         this.messageService = new MessageService_1.MessageService(this.apiClient, cryptographyService);
     }
@@ -138,7 +139,8 @@ class ConversationService {
         if (!this.selfConversationId) {
             const { userId } = this.apiClient.context;
             const { qualified_id, id } = await this.apiClient.conversation.api.getConversation(userId);
-            this.selfConversationId = qualified_id || { id, domain: '' };
+            const domain = this.config.useQualifiedIds ? qualified_id.domain : '';
+            this.selfConversationId = { id, domain };
         }
         return this.selfConversationId;
     }
@@ -633,9 +635,9 @@ class ConversationService {
         const request = this.apiClient.asset.api.getAssetV3(assetId, assetToken);
         const encryptedBuffer = (await request.response).buffer;
         return (0, AssetCryptography_1.decryptAsset)({
-            cipherText: Buffer.from(encryptedBuffer),
-            keyBytes: Buffer.from(otrKey),
-            sha256: Buffer.from(sha256),
+            cipherText: new Uint8Array(encryptedBuffer),
+            keyBytes: otrKey,
+            sha256: sha256,
         });
     }
     async getUnencryptedAsset(assetId, assetToken) {

package/src/main/cryptography/AssetCryptography/EncryptedAsset.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 export interface EncryptedAsset {
-    cipherText: Buffer;
-    keyBytes: Buffer;
+    cipherText: Uint8Array;
+    keyBytes: Uint8Array;
     /** The SHA-256 sum of `cipherText` */
-    sha256: Buffer;
+    sha256: Uint8Array;
 }
 export interface EncryptedAssetUploaded extends EncryptedAsset {
     key: string;

package/src/main/cryptography/AssetCryptography/crypto.browser.js

@@ -23,22 +23,22 @@ const cryptoLib = window.crypto;
 exports.crypto = {
     async digest(cipherText) {
         const checksum = await cryptoLib.subtle.digest('SHA-256', cipherText);
-        return Buffer.from(checksum);
+        return new Uint8Array(checksum);
     },
     async decrypt(cipherText, keyBytes) {
         const key = await cryptoLib.subtle.importKey('raw', keyBytes, 'AES-CBC', false, ['decrypt']);
         const initializationVector = cipherText.slice(0, 16);
         const assetCipherText = cipherText.slice(16);
         const decipher = await cryptoLib.subtle.decrypt({ iv: initializationVector, name: 'AES-CBC' }, key, assetCipherText);
-        return Buffer.from(decipher);
+        return new Uint8Array(decipher);
     },
     getRandomValues(size) {
-        return Buffer.from(cryptoLib.getRandomValues(new Uint8Array(size)));
+        return cryptoLib.getRandomValues(new Uint8Array(size));
     },
     async encrypt(plainText, keyBytes, initializationVector) {
         const key = await cryptoLib.subtle.importKey('raw', keyBytes, 'AES-CBC', true, ['encrypt']);
         return {
-            key: Buffer.from(await cryptoLib.subtle.exportKey('raw', key)),
+            key: new Uint8Array(await cryptoLib.subtle.exportKey('raw', key)),
             cipher: await cryptoLib.subtle.encrypt({ iv: initializationVector, name: 'AES-CBC' }, key, plainText),
         };
     },

package/src/main/cryptography/AssetCryptography/index.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 import { CipherOptions } from '@wireapp/api-client/src/asset';
 import type { EncryptedAsset } from './EncryptedAsset';
 interface EncryptOptions extends CipherOptions {
-    plainText: Buffer | Uint8Array;
+    plainText: Uint8Array;
 }
-export declare const decryptAsset: ({ cipherText, keyBytes, sha256: referenceSha256, }: EncryptedAsset) => Promise<Buffer>;
+export declare const decryptAsset: ({ cipherText, keyBytes, sha256: referenceSha256, }: EncryptedAsset) => Promise<Uint8Array>;
 export declare const encryptAsset: ({ plainText, algorithm }: EncryptOptions) => Promise<EncryptedAsset>;
 export {};

package/src/main/cryptography/AssetCryptography/index.js

@@ -44,7 +44,7 @@ const encryptAsset = async ({ plainText, algorithm = 'AES-256-CBC' }) => {
     ivCipherText.set(new Uint8Array(cipher), initializationVector.byteLength);
     const sha256 = await crypto_node_1.crypto.digest(ivCipherText);
     return {
-        cipherText: Buffer.from(ivCipherText.buffer),
+        cipherText: ivCipherText,
         keyBytes: key,
         sha256,
     };

package/src/main/cryptography/AssetCryptography/interfaces.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="node" />
 export interface Crypto {
-    digest(cipherText: Buffer | Uint8Array): Promise<Buffer>;
-    decrypt(cipherText: Buffer | Uint8Array, keyBytes: Buffer): Promise<Buffer>;
-    getRandomValues(size: number): Buffer;
-    encrypt(plainText: Buffer | Uint8Array, keyBytes: Buffer, initializationVector: Buffer, algorithm: string): Promise<{
-        key: Buffer;
-        cipher: Buffer;
+    digest(cipherText: Uint8Array): Promise<Uint8Array>;
+    decrypt(cipherText: Uint8Array, keyBytes: Uint8Array): Promise<Uint8Array>;
+    getRandomValues(size: number): Uint8Array;
+    encrypt(plainText: Uint8Array, keyBytes: Uint8Array, initializationVector: Uint8Array, algorithm: string): Promise<{
+        key: Uint8Array;
+        cipher: Uint8Array;
     }>;
 }

package/src/main/cryptography/CryptographyService.d.ts

@@ -13,17 +13,16 @@ export interface MetaClient extends RegisteredClient {
         primary_key: string;
     };
 }
-declare type CryptographyServiceOptions = {
-    federationDomain?: string;
-};
 export declare class CryptographyService {
     readonly apiClient: APIClient;
     private readonly storeEngine;
-    private readonly options?;
+    private readonly config;
     private readonly logger;
     cryptobox: Cryptobox;
     private readonly database;
-    constructor(apiClient: APIClient, storeEngine: CRUDEngine, options?: CryptographyServiceOptions | undefined);
+    constructor(apiClient: APIClient, storeEngine: CRUDEngine, config?: {
+        useQualifiedIds?: boolean;
+    });
     static constructSessionId(userId: string, clientId: string, domain: string | null): string;
     static convertArrayRecipientsToBase64(recipients: OTRRecipients<Uint8Array>): OTRRecipients<string>;
     static convertBase64RecipientsToArray(recipients: OTRRecipients<string>): OTRRecipients<Uint8Array>;
@@ -43,4 +42,3 @@ export declare class CryptographyService {
     resetSession(sessionId: string): Promise<void>;
     decodeGenericMessage(otrMessage: ConversationOtrMessageAddEvent, source: PayloadBundleSource): Promise<PayloadBundle>;
 }
-export {};

package/src/main/cryptography/CryptographyService.js

@@ -32,17 +32,16 @@ const util_1 = require("../util");
 const CryptographyDatabaseRepository_1 = require("./CryptographyDatabaseRepository");
 const GenericMessageMapper_1 = require("./GenericMessageMapper");
 class CryptographyService {
-    constructor(apiClient, storeEngine, options) {
+    constructor(apiClient, storeEngine, config = {}) {
         this.apiClient = apiClient;
         this.storeEngine = storeEngine;
-        this.options = options;
+        this.config = config;
         this.cryptobox = new cryptobox_1.Cryptobox(this.storeEngine);
         this.database = new CryptographyDatabaseRepository_1.CryptographyDatabaseRepository(this.storeEngine);
         this.logger = (0, logdown_1.default)('@wireapp/core/cryptography/CryptographyService', {
             logger: console,
             markdown: false,
         });
-        this.options = options;
     }
     static constructSessionId(userId, clientId, domain) {
         const baseId = `${userId}@${clientId}`;
@@ -147,9 +146,8 @@ class CryptographyService {
         this.logger.log(`Deleted session ID "${sessionId}".`);
     }
     async decodeGenericMessage(otrMessage, source) {
-        var _a;
         const { from, qualified_from, data: { sender, text: cipherText }, } = otrMessage;
-        const domain = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.federationDomain) ? (qualified_from === null || qualified_from === void 0 ? void 0 : qualified_from.domain) || this.options.federationDomain : null;
+        const domain = this.config.useQualifiedIds ? qualified_from.domain : null;
         const sessionId = CryptographyService.constructSessionId(from, sender, domain);
         const decryptedMessage = await this.decrypt(sessionId, cipherText);
         const genericMessage = protocol_messaging_1.GenericMessage.decode(decryptedMessage);

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 | undefined;
+        sendAsProtobuf?: boolean | undefined;
+    }): 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);