@wireapp/core 23.0.0 → 24.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.
 
+# [24.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@23.0.0...@wireapp/core@24.0.0) (2022-02-22)
+
+
+### Features
+
+* **api-client:** Allow setting a backend version ([#4226](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4226)) ([7cda792](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/7cda792e98ebcf4317dc165d9e027654fb11b78f))
+
+
+### BREAKING CHANGES
+
+* **api-client:** All the methods that were using useFederation do not need this parameter anymore (since the federation state is guessed from the api version number)
+
+
+
+
+
 # [23.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@22.1.3...@wireapp/core@23.0.0) (2022-02-21)
 
 

package/package.json

@@ -5,7 +5,7 @@
   "dependencies": {
     "@types/long": "4.0.1",
     "@types/node": "~14",
-    "@wireapp/api-client": "17.0.0",
+    "@wireapp/api-client": "18.0.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": "23.0.0",
-  "gitHead": "64d590b40155de334291669dfea523f3f9ad5c97"
+  "version": "24.0.0",
+  "gitHead": "60af9b22cf064dec167da40a7e14c8edc8b13aa8"
 }

package/src/main/Account.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { APIClient } from '@wireapp/api-client';
+import { APIClient, BackendFeatures } from '@wireapp/api-client';
 import type { RegisterData } from '@wireapp/api-client/src/auth';
 import { Context, Cookie, LoginData } from '@wireapp/api-client/src/auth/';
 import { ClientType, RegisteredClient } from '@wireapp/api-client/src/client/';
@@ -53,12 +53,7 @@ export interface Account {
     on(event: TOPIC.ERROR, listener: (payload: CoreError) => void): this;
 }
 export declare type StoreEngineProvider = (storeName: string) => Promise<CRUDEngine>;
-declare type AccountConfig = {
-    /** 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 apiClient;
     private readonly logger;
     private readonly storeEngineProvider;
@@ -79,11 +74,12 @@ export declare class Account extends EventEmitter {
         team: TeamService;
         user: UserService;
     };
+    backendFeatures: BackendFeatures;
     /**
      * @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)
      */
-    constructor(apiClient?: APIClient, storeEngineProvider?: StoreEngineProvider, config?: AccountConfig);
+    constructor(apiClient?: APIClient, storeEngineProvider?: StoreEngineProvider);
     private persistCookie;
     get clientId(): string;
     get userId(): string;

package/src/main/Account.js

@@ -72,9 +72,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)
      */
-    constructor(apiClient = new api_client_1.APIClient(), storeEngineProvider, config = {}) {
+    constructor(apiClient = new api_client_1.APIClient(), storeEngineProvider) {
         super();
-        this.config = config;
         this.handlePayload = async (payload) => {
             switch (payload.type) {
                 case conversation_1.PayloadBundleType.TIMER_UPDATE: {
@@ -90,6 +89,7 @@ class Account extends events_1.EventEmitter {
             this.emit(Account.TOPIC.ERROR, accountError);
         };
         this.apiClient = apiClient;
+        this.backendFeatures = this.apiClient.backendFeatures;
         if (storeEngineProvider) {
             this.storeEngineProvider = storeEngineProvider;
         }
@@ -149,14 +149,15 @@ class Account extends events_1.EventEmitter {
         return context;
     }
     async initServices(storeEngine) {
+        const config = { useQualifiedIds: this.apiClient.backendFeatures.federationEndpoints };
         const accountService = new account_1.AccountService(this.apiClient);
         const assetService = new conversation_1.AssetService(this.apiClient);
-        const cryptographyService = new cryptography_1.CryptographyService(this.apiClient, storeEngine, this.config);
+        const cryptographyService = new cryptography_1.CryptographyService(this.apiClient, storeEngine, config);
         const clientService = new client_2.ClientService(this.apiClient, storeEngine, cryptographyService);
         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, this.config);
+        const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService, 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/client/ClientDatabaseRepository.d.ts

@@ -1,25 +1,27 @@
 import type { RegisteredClient } from '@wireapp/api-client/src/client/';
 import type { CRUDEngine } from '@wireapp/store-engine';
+import { CryptographyService } from '../cryptography/';
 import type { MetaClient } from './ClientService';
 export declare enum DatabaseStores {
     CLIENTS = "clients"
 }
 export declare class ClientDatabaseRepository {
     private readonly storeEngine;
+    private readonly cryptographyService;
     static readonly STORES: typeof DatabaseStores;
     static KEYS: {
         LOCAL_IDENTITY: string;
     };
-    constructor(storeEngine: CRUDEngine);
+    constructor(storeEngine: CRUDEngine, cryptographyService: CryptographyService);
     getLocalClient(): Promise<MetaClient>;
     getClient(sessionId: string): Promise<MetaClient>;
     deleteLocalClient(): Promise<string>;
     deleteClient(sessionId: string): Promise<string>;
-    createClientList(userId: string, clientList: RegisteredClient[], domain: string | null): Promise<MetaClient[]>;
-    createLocalClient(client: RegisteredClient, domain: string | null): Promise<MetaClient>;
-    updateLocalClient(client: RegisteredClient, domain: string | null): Promise<MetaClient>;
-    updateClient(userId: string, client: RegisteredClient, domain: string | null): Promise<MetaClient>;
-    createClient(userId: string, client: RegisteredClient, domain: string | null): Promise<MetaClient>;
+    createClientList(userId: string, clientList: RegisteredClient[], domain?: string): Promise<MetaClient[]>;
+    createLocalClient(client: RegisteredClient, domain?: string): Promise<MetaClient>;
+    updateLocalClient(client: RegisteredClient, domain?: string): Promise<MetaClient>;
+    updateClient(userId: string, client: RegisteredClient, domain?: string): Promise<MetaClient>;
+    createClient(userId: string, client: RegisteredClient, domain?: string): Promise<MetaClient>;
     private transformClient;
     private transformLocalClient;
 }

package/src/main/client/ClientDatabaseRepository.js

@@ -19,14 +19,14 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientDatabaseRepository = exports.DatabaseStores = void 0;
-const cryptography_1 = require("../cryptography/");
 var DatabaseStores;
 (function (DatabaseStores) {
     DatabaseStores["CLIENTS"] = "clients";
 })(DatabaseStores = exports.DatabaseStores || (exports.DatabaseStores = {}));
 class ClientDatabaseRepository {
-    constructor(storeEngine) {
+    constructor(storeEngine, cryptographyService) {
         this.storeEngine = storeEngine;
+        this.cryptographyService = cryptographyService;
     }
     getLocalClient() {
         return this.getClient(ClientDatabaseRepository.KEYS.LOCAL_IDENTITY);
@@ -59,16 +59,19 @@ class ClientDatabaseRepository {
     }
     async updateClient(userId, client, domain) {
         const transformedClient = this.transformClient(userId, client, false, domain);
-        await this.storeEngine.update(ClientDatabaseRepository.STORES.CLIENTS, cryptography_1.CryptographyService.constructSessionId(userId, client.id, domain), transformedClient);
+        await this.storeEngine.update(ClientDatabaseRepository.STORES.CLIENTS, this.cryptographyService.constructSessionId(userId, client.id, domain), transformedClient);
         return transformedClient;
     }
     async createClient(userId, client, domain) {
         const transformedClient = this.transformClient(userId, client, false, domain);
-        await this.storeEngine.create(ClientDatabaseRepository.STORES.CLIENTS, cryptography_1.CryptographyService.constructSessionId(userId, client.id, domain), transformedClient);
+        await this.storeEngine.create(ClientDatabaseRepository.STORES.CLIENTS, this.cryptographyService.constructSessionId(userId, client.id, domain), transformedClient);
         return transformedClient;
     }
     transformClient(userId, client, verified, domain) {
-        return Object.assign(Object.assign({}, client), { domain, meta: { is_verified: verified, primary_key: cryptography_1.CryptographyService.constructSessionId(userId, client.id, domain) } });
+        return Object.assign(Object.assign({}, client), { domain, meta: {
+                is_verified: verified,
+                primary_key: this.cryptographyService.constructSessionId(userId, client.id, domain),
+            } });
     }
     transformLocalClient(client, domain) {
         return Object.assign(Object.assign({}, client), { domain, meta: { is_verified: true, primary_key: ClientDatabaseRepository.KEYS.LOCAL_IDENTITY } });

package/src/main/client/ClientService.d.ts

@@ -5,7 +5,7 @@ import type { CRUDEngine } from '@wireapp/store-engine';
 import type { CryptographyService } from '../cryptography/';
 import { ClientInfo } from './';
 export interface MetaClient extends RegisteredClient {
-    domain: string | null;
+    domain?: string;
     meta: {
         is_verified?: boolean;
         primary_key: string;
@@ -21,7 +21,7 @@ export declare class ClientService {
     deleteLocalClient(): Promise<string>;
     getClients(): Promise<RegisteredClient[]>;
     getLocalClient(): Promise<MetaClient>;
-    createLocalClient(client: RegisteredClient, domain: string | null): Promise<MetaClient>;
+    createLocalClient(client: RegisteredClient, domain?: string): Promise<MetaClient>;
     synchronizeClients(): Promise<MetaClient[]>;
     register(loginData: LoginData, clientInfo?: ClientInfo): Promise<RegisteredClient>;
 }

package/src/main/client/ClientService.js

@@ -26,7 +26,7 @@ class ClientService {
         this.apiClient = apiClient;
         this.storeEngine = storeEngine;
         this.cryptographyService = cryptographyService;
-        this.database = new _1.ClientDatabaseRepository(this.storeEngine);
+        this.database = new _1.ClientDatabaseRepository(this.storeEngine, this.cryptographyService);
         this.backend = new _1.ClientBackendRepository(this.apiClient);
     }
     deleteLocalClient() {
@@ -42,9 +42,10 @@ class ClientService {
         return this.database.createLocalClient(client, domain);
     }
     async synchronizeClients() {
+        var _a;
         const registeredClients = await this.backend.getClients();
         const filteredClients = registeredClients.filter(client => client.id !== this.apiClient.context.clientId);
-        return this.database.createClientList(this.apiClient.context.userId, filteredClients, this.apiClient.context.domain || null);
+        return this.database.createClientList(this.apiClient.context.userId, filteredClients, (_a = this.apiClient.context) === null || _a === void 0 ? void 0 : _a.domain);
     }
     // TODO: Split functionality into "create" and "register" client
     async register(loginData, clientInfo = {
@@ -74,7 +75,7 @@ class ClientService {
             type: loginData.clientType,
         };
         const client = await this.backend.postClient(newClient);
-        await this.createLocalClient(client, this.apiClient.context.domain || null);
+        await this.createLocalClient(client, this.apiClient.context.domain);
         await this.cryptographyService.initCryptobox();
         return client;
     }

package/src/main/connection/ConnectionService.d.ts

@@ -1,10 +1,11 @@
 import type { APIClient } from '@wireapp/api-client';
 import { Connection } from '@wireapp/api-client/src/connection/';
+import { QualifiedId } from '@wireapp/api-client/src/user';
 export declare class ConnectionService {
     private readonly apiClient;
     constructor(apiClient: APIClient);
     getConnections(): Promise<Connection[]>;
     acceptConnection(userId: string): Promise<Connection>;
     ignoreConnection(userId: string): Promise<Connection>;
-    createConnection(userId: string): Promise<Connection>;
+    createConnection(userId: QualifiedId): Promise<Connection>;
 }

package/src/main/connection/ConnectionService.js

@@ -38,11 +38,7 @@ class ConnectionService {
         });
     }
     createConnection(userId) {
-        return this.apiClient.api.connection.postConnection({
-            message: ' ',
-            name: ' ',
-            user: userId,
-        });
+        return this.apiClient.api.connection.postConnection(userId, '');
     }
 }
 exports.ConnectionService = ConnectionService;

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

@@ -154,7 +154,7 @@ export declare class ConversationService {
     getConversations(conversationIds?: string[]): Promise<Conversation[]>;
     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>;
+    addUser(conversationId: string, userIds: string | string[] | QualifiedId | QualifiedId[]): Promise<QualifiedId[]>;
     removeUser(conversationId: string, userId: string): Promise<string>;
     /**
      * Sends a message to a conversation

package/src/main/conversation/ConversationService.js

@@ -53,7 +53,7 @@ class ConversationService {
         return genericMessage;
     }
     async getConversationQualifiedMembers(conversationId) {
-        const conversation = await this.apiClient.api.conversation.getConversation(conversationId, true);
+        const conversation = await this.apiClient.api.conversation.getConversation(conversationId);
         /*
          * If you are sending a message to a conversation, you have to include
          * yourself in the list of users if you want to sync a message also to your
@@ -170,7 +170,7 @@ class ConversationService {
         if (targetMode !== MessageTargetMode.NONE && !userIds) {
             throw new Error('Cannot send targetted message when no userIds are given');
         }
-        if (conversationDomain) {
+        if (conversationDomain && this.config.useQualifiedIds) {
             if ((0, TypePredicateUtil_1.isStringArray)(userIds) || (0, TypePredicateUtil_1.isUserClients)(userIds)) {
                 throw new Error('Invalid userIds option for sending to federated backend');
             }
@@ -530,7 +530,7 @@ class ConversationService {
                 // When the mismatch happens, we ask the messageService to cancel the sending
                 return false;
             };
-            if (conversationDomain) {
+            if (conversationDomain && this.config.useQualifiedIds) {
                 await this.messageService.sendFederatedMessage(sendingClientId, recipients, text, {
                     conversationId: { id: conversationId, domain: conversationDomain },
                     onClientMismatch,
@@ -646,13 +646,9 @@ class ConversationService {
     }
     async addUser(conversationId, userIds) {
         const ids = Array.isArray(userIds) ? userIds : [userIds];
-        if ((0, TypePredicateUtil_1.isStringArray)(ids)) {
-            await this.apiClient.api.conversation.postMembers(conversationId, ids);
-        }
-        else if ((0, TypePredicateUtil_1.isQualifiedIdArray)(ids)) {
-            await this.apiClient.api.conversation.postMembersV2(conversationId, ids);
-        }
-        return userIds;
+        const qualifiedIds = (0, TypePredicateUtil_1.isStringArray)(ids) ? ids.map(id => ({ id, domain: '' })) : ids;
+        await this.apiClient.api.conversation.postMembers(conversationId, qualifiedIds);
+        return qualifiedIds;
     }
     async removeUser(conversationId, userId) {
         await this.apiClient.api.conversation.deleteMember(conversationId, userId);

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

@@ -3,7 +3,7 @@ import type { PreKey as SerializedPreKey } from '@wireapp/api-client/src/auth/';
 import type { RegisteredClient } from '@wireapp/api-client/src/client/';
 import type { OTRRecipients, QualifiedOTRRecipients, QualifiedUserClients, UserClients } from '@wireapp/api-client/src/conversation/';
 import type { ConversationOtrMessageAddEvent } from '@wireapp/api-client/src/event';
-import type { QualifiedUserPreKeyBundleMap, UserPreKeyBundleMap } from '@wireapp/api-client/src/user/';
+import type { QualifiedId, QualifiedUserPreKeyBundleMap, UserPreKeyBundleMap } from '@wireapp/api-client/src/user/';
 import { Cryptobox } from '@wireapp/cryptobox';
 import type { CRUDEngine } from '@wireapp/store-engine';
 import { PayloadBundle, PayloadBundleSource } from '../conversation';
@@ -23,7 +23,7 @@ export declare class CryptographyService {
     constructor(apiClient: APIClient, storeEngine: CRUDEngine, config?: {
         useQualifiedIds?: boolean;
     });
-    static constructSessionId(userId: string, clientId: string, domain: string | null): string;
+    constructSessionId(userId: string | QualifiedId, clientId: string, domain?: string): string;
     static convertArrayRecipientsToBase64(recipients: OTRRecipients<Uint8Array>): OTRRecipients<string>;
     static convertBase64RecipientsToArray(recipients: OTRRecipients<string>): OTRRecipients<Uint8Array>;
     createCryptobox(): Promise<SerializedPreKey[]>;

package/src/main/cryptography/CryptographyService.js

@@ -43,9 +43,10 @@ class CryptographyService {
             markdown: false,
         });
     }
-    static constructSessionId(userId, clientId, domain) {
-        const baseId = `${userId}@${clientId}`;
-        return domain ? `${domain}@${baseId}` : baseId;
+    constructSessionId(userId, clientId, domain) {
+        const { id, domain: baseDomain } = typeof userId === 'string' ? { id: userId, domain } : userId;
+        const baseId = `${id}@${clientId}`;
+        return baseDomain && this.config.useQualifiedIds ? `${baseDomain}@${baseId}` : baseId;
     }
     static convertArrayRecipientsToBase64(recipients) {
         return Object.fromEntries(Object.entries(recipients).map(([userId, otrClientMap]) => {
@@ -105,7 +106,7 @@ class CryptographyService {
                     .filter(clientId => !!users[userId][clientId]);
             for (const clientId of clientIds) {
                 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 sessionId = this.constructSessionId(userId, clientId, domain);
                 const result = await this.encryptPayloadForSession(sessionId, plainText, base64PreKey);
                 if (result) {
                     encrypted[userId] || (encrypted[userId] = {});
@@ -152,8 +153,7 @@ class CryptographyService {
     }
     async decodeGenericMessage(otrMessage, source) {
         const { from, qualified_from, data: { sender, text: cipherText }, } = otrMessage;
-        const domain = this.config.useQualifiedIds ? qualified_from.domain : null;
-        const sessionId = CryptographyService.constructSessionId(from, sender, domain);
+        const sessionId = this.constructSessionId(from, sender, qualified_from === null || qualified_from === void 0 ? void 0 : qualified_from.domain);
         const decryptedMessage = await this.decrypt(sessionId, cipherText);
         const genericMessage = protocol_messaging_1.GenericMessage.decode(decryptedMessage);
         if (genericMessage.content === conversation_1.GenericMessageType.EPHEMERAL) {