@wireapp/core 21.0.2 → 22.1.2

package/CHANGELOG.md

@@ -3,6 +3,52 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [22.1.2](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@22.1.1...@wireapp/core@22.1.2) (2022-02-01)
+
+**Note:** Version bump only for package @wireapp/core
+
+
+
+
+
+## [22.1.1](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@22.1.0...@wireapp/core@22.1.1) (2022-02-01)
+
+
+### Bug Fixes
+
+* **core:** Do not try to encrypt for clients without prekeys ([#4220](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4220)) ([1adea26](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/1adea2652de6fd7833a3f1ae99b488f2d25e9817))
+
+
+
+
+
+# [22.1.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@22.0.0...@wireapp/core@22.1.0) (2022-02-01)
+
+
+### Features
+
+* **core:** Enable mismatch hook into broadcast messages ([#4219](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4219)) ([55d8aad](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/55d8aad4519d708af7ed67a6a591d3f6ccd7f55a))
+
+
+
+
+
+# [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)
 
 

package/package.json

@@ -5,7 +5,7 @@
   "dependencies": {
     "@types/long": "4.0.1",
     "@types/node": "~14",
-    "@wireapp/api-client": "16.6.0",
+    "@wireapp/api-client": "16.7.0",
     "@wireapp/cryptobox": "12.7.1",
     "bazinga64": "5.10.0",
     "hash.js": "1.1.7",
@@ -69,6 +69,6 @@
     "test:project": "yarn dist && yarn test",
     "test:node": "nyc jasmine --config=jasmine.json"
   },
-  "version": "21.0.2",
-  "gitHead": "9838da9b1a1dcb702154c73c28a15e53fc35af9f"
+  "version": "22.1.2",
+  "gitHead": "c1934516b62e0a6a8e85cb48908b4df8cfb752e8"
 }

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

@@ -16,5 +16,5 @@ export declare class BroadcastService {
      * @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>;
+    broadcastGenericMessage(genericMessage: GenericMessage, recipients: UserPreKeyBundleMap | UserClients, sendAsProtobuf?: boolean, onClientMismatch?: (mismatch: ClientMismatch) => void | boolean | Promise<boolean>): Promise<ClientMismatch>;
 }

package/src/main/broadcast/BroadcastService.js

@@ -54,11 +54,12 @@ class BroadcastService {
             return bundleMap;
         }, {});
     }
-    async broadcastGenericMessage(genericMessage, recipients, sendAsProtobuf) {
+    async broadcastGenericMessage(genericMessage, recipients, sendAsProtobuf, onClientMismatch) {
         const plainTextArray = protocol_messaging_1.GenericMessage.encode(genericMessage).finish();
         return this.messageService.sendMessage(this.apiClient.validatedClientId, recipients, plainTextArray, {
             sendAsProtobuf,
             reportMissing: Object.keys(recipients),
+            onClientMismatch,
         });
     }
 }

package/src/main/conversation/ConversationService.d.ts

@@ -60,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;
     /**

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;
     }

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}`;
@@ -95,12 +94,17 @@ class CryptographyService {
         };
     }
     async encrypt(plainText, users, domain) {
+        var _a;
         const encrypted = {};
         const missing = {};
         for (const userId in users) {
-            const clientIds = (0, util_1.isUserClients)(users) ? users[userId] : Object.keys(users[userId]);
+            const clientIds = (0, util_1.isUserClients)(users)
+                ? users[userId]
+                : Object.keys(users[userId])
+                    // We filter out clients that have `null` prekey
+                    .filter(clientId => !!users[userId][clientId]);
             for (const clientId of clientIds) {
-                const base64PreKey = (0, util_1.isUserClients)(users) ? undefined : users[userId][clientId].key;
+                const base64PreKey = (0, util_1.isUserClients)(users) ? undefined : (_a = users[userId][clientId]) === null || _a === void 0 ? void 0 : _a.key;
                 const sessionId = CryptographyService.constructSessionId(userId, clientId, domain || null);
                 const result = await this.encryptPayloadForSession(sessionId, plainText, base64PreKey);
                 if (result) {
@@ -147,9 +151,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);