@wireapp/core 22.1.1 → 24.0.0

package/CHANGELOG.md

@@ -3,6 +3,54 @@
 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)
+
+
+### Code Refactoring
+
+* **api-client:** Move all the specific apis to an `api` namespace of the ApiClient ([#4228](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4228)) ([d18b348](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/d18b34841822eea20114d99db67dc376b1311f15))
+
+
+### BREAKING CHANGES
+
+* **api-client:** All the specific api accessible from the apiClient have moved from `apiClient.<specificApi>.api` to `apiClient.api.<specificApi>` (eg. `apiClient.user.api` needs to be replaced with `apiClient.api.user`)
+
+
+
+
+
+## [22.1.3](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@22.1.2...@wireapp/core@22.1.3) (2022-02-17)
+
+**Note:** Version bump only for package @wireapp/core
+
+
+
+
+
+## [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)
 
 

package/package.json

@@ -5,7 +5,7 @@
   "dependencies": {
     "@types/long": "4.0.1",
     "@types/node": "~14",
-    "@wireapp/api-client": "16.6.1",
+    "@wireapp/api-client": "18.0.0",
     "@wireapp/cryptobox": "12.7.1",
     "bazinga64": "5.10.0",
     "hash.js": "1.1.7",
@@ -20,14 +20,14 @@
     "@types/jasmine": "3.8.2",
     "@types/karma": "6.3.1",
     "@wireapp/commons": "4.2.13",
-    "@wireapp/store-engine-dexie": "1.6.7",
+    "@wireapp/store-engine-dexie": "1.6.8",
     "commander": "8.0.0",
     "cross-env": "7.0.3",
     "dotenv-defaults": "2.0.2",
     "faker": "5.5.3",
     "istanbul": "1.1.0-alpha.1",
     "jasmine": "3.8.0",
-    "karma": "6.3.4",
+    "karma": "6.3.14",
     "karma-chrome-launcher": "3.1.0",
     "karma-jasmine": "4.0.1",
     "karma-jasmine-diff-reporter": "2.0.1",
@@ -69,6 +69,6 @@
     "test:project": "yarn dist && yarn test",
     "test:node": "nyc jasmine --config=jasmine.json"
   },
-  "version": "22.1.1",
-  "gitHead": "805541bf8ba66031d424c4b9d14bead16b165c33"
+  "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);
@@ -238,7 +239,7 @@ class Account extends events_1.EventEmitter {
     async loadAndValidateLocalClient() {
         await this.service.cryptography.initCryptobox();
         const loadedClient = await this.service.client.getLocalClient();
-        await this.apiClient.client.api.getClient(loadedClient.id);
+        await this.apiClient.api.client.getClient(loadedClient.id);
         this.apiClient.context.clientId = loadedClient.id;
         return loadedClient;
     }

package/src/main/account/AccountService.js

@@ -26,7 +26,7 @@ class AccountService {
     }
     getCallConfig() {
         const iceCandidateLimit = commons_1.Runtime.isFirefox() ? 3 : undefined;
-        return this.apiClient.account.api.getCallConfig(iceCandidateLimit);
+        return this.apiClient.api.account.getCallConfig(iceCandidateLimit);
     }
 }
 exports.AccountService = AccountService;

package/src/main/account/AccountService.js.map

@@ -1 +1 @@
-{"version":3,"file":"AccountService.js","sourceRoot":"","sources":["AccountService.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AAGH,8CAAyC;AAGzC,MAAa,cAAc;IACzB,YAA6B,SAAoB;QAApB,cAAS,GAAT,SAAS,CAAW;IAAG,CAAC;IAErD,aAAa;QACX,MAAM,iBAAiB,GAAG,iBAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9D,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACrE,CAAC;CACF;AAPD,wCAOC"}
+{"version":3,"file":"AccountService.js","sourceRoot":"","sources":["AccountService.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AAGH,8CAAyC;AAGzC,MAAa,cAAc;IACzB,YAA6B,SAAoB;QAApB,cAAS,GAAT,SAAS,CAAW;IAAG,CAAC;IAErD,aAAa;QACX,MAAM,iBAAiB,GAAG,iBAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9D,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACrE,CAAC;CACF;AAPD,wCAOC"}

package/src/main/account/AccountService.ts

@@ -26,6 +26,6 @@ export class AccountService {
 
   getCallConfig(): Promise<CallConfigData> {
     const iceCandidateLimit = Runtime.isFirefox() ? 3 : undefined;
-    return this.apiClient.account.api.getCallConfig(iceCandidateLimit);
+    return this.apiClient.api.account.getCallConfig(iceCandidateLimit);
   }
 }

package/src/main/broadcast/BroadcastService.js

@@ -36,16 +36,16 @@ class BroadcastService {
      */
     async getPreKeyBundlesFromTeam(teamId, skipOwnClients = false, onlyDirectConnections = false) {
         const teamMembers = onlyDirectConnections
-            ? (await this.apiClient.conversation.api.getConversations()).conversations
+            ? (await this.apiClient.api.conversation.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);
+            : (await this.apiClient.api.teams.member.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();
+            const selfUser = await this.apiClient.api.self.getSelf();
             members = members.filter(member => member.id !== selfUser.id);
         }
-        const preKeys = await Promise.all(members.map(member => this.apiClient.user.api.getUserPreKeys(member.id)));
+        const preKeys = await Promise.all(members.map(member => this.apiClient.api.user.getUserPreKeys(member.id)));
         return preKeys.reduce((bundleMap, bundle) => {
             bundleMap[bundle.user] = {};
             for (const client of bundle.clients) {

package/src/main/client/ClientBackendRepository.js

@@ -24,10 +24,10 @@ class ClientBackendRepository {
         this.apiClient = apiClient;
     }
     getClients() {
-        return this.apiClient.client.api.getClients();
+        return this.apiClient.api.client.getClients();
     }
     postClient(client) {
-        return this.apiClient.client.api.postClient(client);
+        return this.apiClient.api.client.postClient(client);
     }
 }
 exports.ClientBackendRepository = ClientBackendRepository;

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

@@ -25,24 +25,20 @@ class ConnectionService {
         this.apiClient = apiClient;
     }
     getConnections() {
-        return this.apiClient.connection.api.getAllConnections();
+        return this.apiClient.api.connection.getAllConnections();
     }
     acceptConnection(userId) {
-        return this.apiClient.connection.api.putConnection(userId, {
+        return this.apiClient.api.connection.putConnection(userId, {
             status: connection_1.ConnectionStatus.ACCEPTED,
         });
     }
     ignoreConnection(userId) {
-        return this.apiClient.connection.api.putConnection(userId, {
+        return this.apiClient.api.connection.putConnection(userId, {
             status: connection_1.ConnectionStatus.IGNORED,
         });
     }
     createConnection(userId) {
-        return this.apiClient.connection.api.postConnection({
-            message: ' ',
-            name: ' ',
-            user: userId,
-        });
+        return this.apiClient.api.connection.postConnection(userId, '');
     }
 }
 exports.ConnectionService = ConnectionService;

package/src/main/conversation/AssetService.js

@@ -36,13 +36,13 @@ class AssetService {
         const { forceCaching } = assetData;
         switch (assetData.version) {
             case 1:
-                return this.apiClient.asset.api.getAssetV1(assetData.assetId, assetData.conversationId, forceCaching, progressCallback);
+                return this.apiClient.api.asset.getAssetV1(assetData.assetId, assetData.conversationId, forceCaching, progressCallback);
             case 2:
-                return this.apiClient.asset.api.getAssetV2(assetData.assetId, assetData.conversationId, forceCaching, progressCallback);
+                return this.apiClient.api.asset.getAssetV2(assetData.assetId, assetData.conversationId, forceCaching, progressCallback);
             case 3:
-                return this.apiClient.asset.api.getAssetV3(assetData.assetKey, assetData.assetToken, forceCaching, progressCallback);
+                return this.apiClient.api.asset.getAssetV3(assetData.assetKey, assetData.assetToken, forceCaching, progressCallback);
             case 4:
-                return this.apiClient.asset.api.getAssetV4(assetData.assetKey, assetData.assetDomain, assetData.assetToken, forceCaching, progressCallback);
+                return this.apiClient.api.asset.getAssetV4(assetData.assetKey, assetData.assetDomain, assetData.assetToken, forceCaching, progressCallback);
         }
     }
     /**
@@ -54,7 +54,7 @@ class AssetService {
      * @return cancellable request that resolves with the uploaded image
      */
     uploadRawAsset(asset, options, progressCallback) {
-        return this.apiClient.asset.api.postAsset(new Uint8Array(asset), options, progressCallback);
+        return this.apiClient.api.asset.postAsset(new Uint8Array(asset), options, progressCallback);
     }
     /**
      * Will encrypt and upload an asset to the backend

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.conversation.api.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
@@ -89,7 +89,7 @@ class ConversationService {
             }
         }
         const preKeys = await Promise.all(targets.map(async ({ id: userId, clients }) => {
-            const prekeyBundle = await this.apiClient.user.api.getUserPreKeys(userId);
+            const prekeyBundle = await this.apiClient.api.user.getUserPreKeys(userId);
             // We filter the clients that should not receive the message (if a QualifiedUserClients was given as parameter)
             const userClients = clients
                 ? prekeyBundle.clients.filter(client => clients.includes(client.client))
@@ -117,7 +117,7 @@ class ConversationService {
             }
         }
         if (!members.length) {
-            const conversation = await this.apiClient.conversation.api.getConversation(conversationId);
+            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
@@ -125,7 +125,7 @@ class ConversationService {
              */
             members = conversation.members.others.map(member => member.id).concat(conversation.members.self.id);
         }
-        const preKeys = await Promise.all(members.map(member => this.apiClient.user.api.getUserPreKeys(member)));
+        const preKeys = await Promise.all(members.map(member => this.apiClient.api.user.getUserPreKeys(member)));
         return preKeys.reduce((bundleMap, bundle) => {
             const userId = bundle.user;
             bundleMap[userId] || (bundleMap[userId] = {});
@@ -138,7 +138,7 @@ class ConversationService {
     async getSelfConversationId() {
         if (!this.selfConversationId) {
             const { userId } = this.apiClient.context;
-            const { qualified_id, id } = await this.apiClient.conversation.api.getConversation(userId);
+            const { qualified_id, id } = await this.apiClient.api.conversation.getConversation(userId);
             const domain = this.config.useQualifiedIds ? qualified_id.domain : '';
             this.selfConversationId = { id, domain };
         }
@@ -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,
@@ -602,7 +602,7 @@ class ConversationService {
         };
     }
     leaveConversation(conversationId) {
-        return this.apiClient.conversation.api.deleteMember(conversationId, this.apiClient.context.userId);
+        return this.apiClient.api.conversation.deleteMember(conversationId, this.apiClient.context.userId);
     }
     async leaveConversations(conversationIds) {
         if (!conversationIds) {
@@ -620,19 +620,19 @@ class ConversationService {
             receipt_mode: null,
             users: ids,
         };
-        return this.apiClient.conversation.api.postConversation(newConversation);
+        return this.apiClient.api.conversation.postConversation(newConversation);
     }
     async getConversations(conversationIds) {
         if (!conversationIds || !conversationIds.length) {
-            return this.apiClient.conversation.api.getAllConversations();
+            return this.apiClient.api.conversation.getAllConversations();
         }
         if (typeof conversationIds === 'string') {
-            return this.apiClient.conversation.api.getConversation(conversationIds);
+            return this.apiClient.api.conversation.getConversation(conversationIds);
         }
-        return this.apiClient.conversation.api.getConversationsByIds(conversationIds);
+        return this.apiClient.api.conversation.getConversationsByIds(conversationIds);
     }
     async getAsset({ assetId, assetToken, otrKey, sha256 }) {
-        const request = this.apiClient.asset.api.getAssetV3(assetId, assetToken);
+        const request = this.apiClient.api.asset.getAssetV3(assetId, assetToken);
         const encryptedBuffer = (await request.response).buffer;
         return (0, AssetCryptography_1.decryptAsset)({
             cipherText: new Uint8Array(encryptedBuffer),
@@ -641,21 +641,17 @@ class ConversationService {
         });
     }
     async getUnencryptedAsset(assetId, assetToken) {
-        const request = await this.apiClient.asset.api.getAssetV3(assetId, assetToken);
+        const request = await this.apiClient.api.asset.getAssetV3(assetId, assetToken);
         return (await request.response).buffer;
     }
     async addUser(conversationId, userIds) {
         const ids = Array.isArray(userIds) ? userIds : [userIds];
-        if ((0, TypePredicateUtil_1.isStringArray)(ids)) {
-            await this.apiClient.conversation.api.postMembers(conversationId, ids);
-        }
-        else if ((0, TypePredicateUtil_1.isQualifiedIdArray)(ids)) {
-            await this.apiClient.conversation.api.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.conversation.api.deleteMember(conversationId, userId);
+        await this.apiClient.api.conversation.deleteMember(conversationId, userId);
         return userId;
     }
     /**
@@ -750,10 +746,10 @@ class ConversationService {
         return Object.assign(Object.assign({}, payloadBundle), { content: processedContent || payloadBundle.content, messageTimer: ((_d = genericMessage.ephemeral) === null || _d === void 0 ? void 0 : _d.expireAfterMillis) || 0, state: response.errored ? conversation_2.PayloadBundleState.CANCELLED : conversation_2.PayloadBundleState.OUTGOING_SENT });
     }
     sendTypingStart(conversationId) {
-        return this.apiClient.conversation.api.postTyping(conversationId, { status: data_1.CONVERSATION_TYPING.STARTED });
+        return this.apiClient.api.conversation.postTyping(conversationId, { status: data_1.CONVERSATION_TYPING.STARTED });
     }
     sendTypingStop(conversationId) {
-        return this.apiClient.conversation.api.postTyping(conversationId, { status: data_1.CONVERSATION_TYPING.STOPPED });
+        return this.apiClient.api.conversation.postTyping(conversationId, { status: data_1.CONVERSATION_TYPING.STOPPED });
     }
     setConversationMutedStatus(conversationId, status, muteTimestamp) {
         if (typeof muteTimestamp === 'number') {
@@ -763,7 +759,7 @@ class ConversationService {
             otr_muted_ref: muteTimestamp.toISOString(),
             otr_muted_status: status,
         };
-        return this.apiClient.conversation.api.putMembershipProperties(conversationId, payload);
+        return this.apiClient.api.conversation.putMembershipProperties(conversationId, payload);
     }
     toggleArchiveConversation(conversationId, archived, archiveTimestamp = new Date()) {
         if (typeof archiveTimestamp === 'number') {
@@ -773,10 +769,10 @@ class ConversationService {
             otr_archived: archived,
             otr_archived_ref: archiveTimestamp.toISOString(),
         };
-        return this.apiClient.conversation.api.putMembershipProperties(conversationId, payload);
+        return this.apiClient.api.conversation.putMembershipProperties(conversationId, payload);
     }
     setMemberConversationRole(conversationId, userId, conversationRole) {
-        return this.apiClient.conversation.api.putOtherMember(userId, conversationId, {
+        return this.apiClient.api.conversation.putOtherMember(userId, conversationId, {
             conversation_role: conversationRole,
         });
     }

package/src/main/conversation/message/MessageService.js

@@ -166,7 +166,7 @@ class MessageService {
             throw new Error('Unimplemented federated broadcast');
         }
         const { id, domain } = options.conversationId;
-        return this.apiClient.conversation.api.postOTRMessageV2(id, domain, protoMessage);
+        return this.apiClient.api.conversation.postOTRMessageV2(id, domain, protoMessage);
     }
     async sendOTRMessage(sendingClientId, recipients, options) {
         const message = {
@@ -184,8 +184,8 @@ class MessageService {
             ignoreMissing = typeof options.reportMissing === 'boolean' ? !options.reportMissing : false;
         }
         return !options.conversationId
-            ? this.apiClient.broadcast.api.postBroadcastMessage(sendingClientId, message, ignoreMissing)
-            : this.apiClient.conversation.api.postOTRMessage(sendingClientId, options.conversationId, message, ignoreMissing);
+            ? this.apiClient.api.broadcast.postBroadcastMessage(sendingClientId, message, ignoreMissing)
+            : this.apiClient.api.conversation.postOTRMessage(sendingClientId, options.conversationId, message, ignoreMissing);
     }
     async generateExternalPayload(plainText) {
         const asset = await (0, AssetCryptography_1.encryptAsset)({ plainText });
@@ -221,7 +221,7 @@ class MessageService {
         // remove deleted clients to the recipients
         deleted.forEach(({ userId, data }) => data.forEach(clientId => delete recipients[userId.id][clientId]));
         if (missing.length) {
-            const missingPreKeyBundles = await this.apiClient.user.api.postMultiPreKeyBundles(mismatch.missing);
+            const missingPreKeyBundles = await this.apiClient.api.user.postMultiPreKeyBundles(mismatch.missing);
             const { encrypted } = await this.cryptographyService.encrypt(plainText, missingPreKeyBundles);
             const reEncryptedPayloads = (0, UserClientsUtil_1.flattenUserClients)(encrypted);
             // add missing clients to the recipients
@@ -243,7 +243,7 @@ class MessageService {
         // remove deleted clients to the recipients
         deleted.forEach(({ userId, data }) => data.forEach(clientId => delete recipients[userId.domain][userId.id][clientId]));
         if (Object.keys(missing).length) {
-            const missingPreKeyBundles = await this.apiClient.user.api.postQualifiedMultiPreKeyBundles(mismatch.missing);
+            const missingPreKeyBundles = await this.apiClient.api.user.postQualifiedMultiPreKeyBundles(mismatch.missing);
             const { encrypted } = await this.cryptographyService.encryptQualified(plainText, missingPreKeyBundles);
             const reEncryptedPayloads = (0, UserClientsUtil_1.flattenQualifiedUserClients)(encrypted);
             reEncryptedPayloads.forEach(({ data, userId }) => (recipients[userId.domain][userId.id] = Object.assign(Object.assign({}, recipients[userId.domain][userId.id]), data)));
@@ -286,8 +286,8 @@ class MessageService {
             protoMessage.blob = options.assetData;
         }
         return !options.conversationId
-            ? this.apiClient.broadcast.api.postBroadcastProtobufMessage(sendingClientId, protoMessage, ignoreMissing)
-            : this.apiClient.conversation.api.postOTRProtobufMessage(sendingClientId, options.conversationId, protoMessage, ignoreMissing);
+            ? this.apiClient.api.broadcast.postBroadcastProtobufMessage(sendingClientId, protoMessage, ignoreMissing)
+            : this.apiClient.api.conversation.postOTRProtobufMessage(sendingClientId, options.conversationId, protoMessage, ignoreMissing);
     }
 }
 exports.MessageService = MessageService;

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) {

package/src/main/giphy/GiphyService.js

@@ -24,13 +24,13 @@ class GiphyService {
         this.apiClient = apiClient;
     }
     getRandomGif(tag, rating) {
-        return this.apiClient.giphy.api.getGiphyRandom({ rating, tag });
+        return this.apiClient.api.giphy.getGiphyRandom({ rating, tag });
     }
     getTrendingGif(rating) {
-        return this.apiClient.giphy.api.getGiphyTrending({ rating });
+        return this.apiClient.api.giphy.getGiphyTrending({ rating });
     }
     searchGif(options) {
-        return this.apiClient.giphy.api.getGiphySearch(options);
+        return this.apiClient.api.giphy.getGiphySearch(options);
     }
 }
 exports.GiphyService = GiphyService;

package/src/main/notification/NotificationBackendRepository.js

@@ -24,10 +24,10 @@ class NotificationBackendRepository {
         this.apiClient = apiClient;
     }
     async getAllNotifications(clientId, lastNotificationId) {
-        return this.apiClient.notification.api.getAllNotifications(clientId, lastNotificationId);
+        return this.apiClient.api.notification.getAllNotifications(clientId, lastNotificationId);
     }
     getLastNotification(clientId) {
-        return this.apiClient.notification.api.getLastNotification(clientId);
+        return this.apiClient.api.notification.getLastNotification(clientId);
     }
 }
 exports.NotificationBackendRepository = NotificationBackendRepository;

package/src/main/self/SelfService.js

@@ -28,16 +28,16 @@ class SelfService {
         return !!availableUsername;
     }
     checkUsernames(usernames) {
-        return this.apiClient.user.api.postHandles({
+        return this.apiClient.api.user.postHandles({
             handles: usernames,
         });
     }
     async getName() {
-        const { name } = await this.apiClient.self.api.getName();
+        const { name } = await this.apiClient.api.self.getName();
         return name;
     }
     async getSelf() {
-        const selfData = await this.apiClient.self.api.getSelf();
+        const selfData = await this.apiClient.api.self.getSelf();
         return selfData;
     }
     async getUsername() {
@@ -45,10 +45,10 @@ class SelfService {
         return handle;
     }
     setName(name) {
-        return this.apiClient.self.api.putSelf({ name });
+        return this.apiClient.api.self.putSelf({ name });
     }
     setUsername(username) {
-        return this.apiClient.self.api.putHandle({ handle: username });
+        return this.apiClient.api.self.putHandle({ handle: username });
     }
 }
 exports.SelfService = SelfService;

package/src/main/team/TeamService.js

@@ -24,31 +24,31 @@ class TeamService {
         this.apiClient = apiClient;
     }
     addMember(teamId, memberData) {
-        return this.apiClient.teams.member.api.postMembers(teamId, memberData);
+        return this.apiClient.api.teams.member.postMembers(teamId, memberData);
     }
     createTeam(teamData) {
-        return this.apiClient.teams.team.api.postTeam(teamData);
+        return this.apiClient.api.teams.team.postTeam(teamData);
     }
     deleteTeam(teamId, password) {
-        return this.apiClient.teams.team.api.deleteTeam(teamId, password);
+        return this.apiClient.api.teams.team.deleteTeam(teamId, password);
     }
     getAllMembers(teamId) {
-        return this.apiClient.teams.member.api.getAllMembers(teamId);
+        return this.apiClient.api.teams.member.getAllMembers(teamId);
     }
     getTeam(teamId) {
-        return this.apiClient.teams.team.api.getTeam(teamId);
+        return this.apiClient.api.teams.team.getTeam(teamId);
     }
     getTeams() {
-        return this.apiClient.teams.team.api.getTeams();
+        return this.apiClient.api.teams.team.getTeams();
     }
     removeMember(teamId, userId, password) {
-        return this.apiClient.teams.member.api.deleteMember(teamId, userId, password);
+        return this.apiClient.api.teams.member.deleteMember(teamId, userId, password);
     }
     updateMember(teamId, memberData) {
-        return this.apiClient.teams.member.api.putMembers(teamId, memberData);
+        return this.apiClient.api.teams.member.putMembers(teamId, memberData);
     }
     updateTeam(teamId, teamData) {
-        return this.apiClient.teams.team.api.putTeam(teamId, teamData);
+        return this.apiClient.api.teams.team.putTeam(teamId, teamData);
     }
 }
 exports.TeamService = TeamService;

package/src/main/user/UserService.js

@@ -34,15 +34,15 @@ class UserService {
         this.conversationService = conversationService;
     }
     getUser(userId) {
-        return this.apiClient.user.api.getUser(userId);
+        return this.apiClient.api.user.getUser(userId);
     }
     async getUsers(userIds) {
         if (!userIds.length) {
             return [];
         }
         return (0, TypePredicateUtil_1.isQualifiedIdArray)(userIds)
-            ? this.apiClient.user.api.postListUsers({ qualified_ids: userIds })
-            : this.apiClient.user.api.getUsers({ ids: userIds });
+            ? this.apiClient.api.user.postListUsers({ qualified_ids: userIds })
+            : this.apiClient.api.user.getUsers({ ids: userIds });
     }
     /**
      * Sends a availability update to members of the same team