@wireapp/core 40.5.3-draft-20-cc.3 → 40.5.3-draft-20-cc.0

package/lib/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.js

@@ -21,11 +21,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildEncryptedPayloads = exports.deleteSession = exports.initSessions = exports.initSession = exports.constructSessionId = void 0;
 const bazinga64_1 = require("bazinga64");
 const UserClientsUtil_1 = require("../../../../conversation/message/UserClientsUtil");
-const constructSessionId = ({ userId, clientId, useQualifiedIds, domain }) => {
-    const id = typeof userId === 'string' ? userId : userId.id;
-    const baseDomain = typeof userId === 'string' ? domain : userId.domain;
+const constructSessionId = ({ userId, clientId }) => {
+    const { id, domain } = userId;
     const baseId = `${id}@${clientId}`;
-    return baseDomain && useQualifiedIds ? `${baseDomain}@${baseId}` : baseId;
+    return domain ? `${domain}@${baseId}` : baseId;
 };
 exports.constructSessionId = constructSessionId;
 const isSessionId = (object) => {
@@ -43,55 +42,16 @@ const parseSessionId = (sessionId) => {
     }
     return match.groups;
 };
-const createLegacySessions = async ({ userClients, apiClient, cryptoClient, logger, }) => {
-    const preKeyBundleMap = await apiClient.api.user.postMultiPreKeyBundles(userClients);
-    const sessions = await createSessionsFromPreKeys({
-        preKeyBundleMap,
-        useQualifiedIds: false,
-        cryptoClient,
-        logger,
-    });
-    return sessions;
-};
-/**
- * Create sessions for the qualified clients.
- * @param {userClientMap} map of domain to (map of user IDs to client IDs)
- */
-const createQualifiedSessions = async ({ userClientMap, domain, apiClient, cryptoClient, logger, }) => {
-    const prekeyBundleMap = await apiClient.api.user.postQualifiedMultiPreKeyBundles({ [domain]: userClientMap });
-    const sessions = [];
-    for (const domain in prekeyBundleMap) {
-        const domainUsers = prekeyBundleMap[domain];
-        const domainSessions = await createSessionsFromPreKeys({
-            preKeyBundleMap: domainUsers,
-            domain,
-            useQualifiedIds: true,
-            cryptoClient,
-            logger,
-        });
-        sessions.push(...domainSessions);
-    }
-    return sessions;
-};
 /**
  * Will make sure the session is available in cryptoClient
  * @param sessionId the session to init
  */
 const initSession = async ({ userId, clientId, initialPrekey }, { cryptoClient, apiClient }) => {
-    const sessionId = constructSessionId({ userId, clientId, useQualifiedIds: !!userId.domain });
-    const sessionExists = await cryptoClient.sessionExists(sessionId);
-    if (sessionExists) {
-        return sessionId;
-    }
-    if (initialPrekey) {
-        const prekeyBuffer = bazinga64_1.Decoder.fromBase64(initialPrekey.key).asBytes;
-        await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
-        await cryptoClient.saveSession(sessionId);
-        return sessionId;
-    }
-    const sessions = await initSessions({
-        recipients: { [userId.id]: [clientId] },
-        domain: userId.domain,
+    const recipients = initialPrekey
+        ? { [userId.domain]: { [userId.id]: { [clientId]: initialPrekey } } }
+        : { [userId.domain]: { [userId.id]: [clientId] } };
+    const { sessions } = await initSessions({
+        recipients,
         apiClient,
         cryptoClient,
     });
@@ -100,51 +60,67 @@ const initSession = async ({ userId, clientId, initialPrekey }, { cryptoClient,
 exports.initSession = initSession;
 /**
  * Create sessions for legacy/qualified clients (umberella function).
- * Will call createQualifiedSessions or createLegacySessions based on passed userClientMap.
  * @param {userClientMap} map of domain to (map of user IDs to client IDs) or map of user IDs containg the lists of clients
  */
-const createSessions = async ({ userClientMap, domain, apiClient, cryptoClient, logger, }) => {
-    if (domain) {
-        return await createQualifiedSessions({ userClientMap, domain, apiClient, cryptoClient, logger });
-    }
-    return await createLegacySessions({
-        userClients: userClientMap,
-        apiClient,
+const createSessions = async ({ recipients, apiClient, cryptoClient }) => {
+    const { qualified_user_client_prekeys: prekeysBundle, failed_to_list: failed } = await apiClient.api.user.postMultiPreKeyBundles(recipients);
+    const result = await createSessionsFromPreKeys({
+        recipients: prekeysBundle,
         cryptoClient,
-        logger,
     });
+    return Object.assign(Object.assign({}, result), { failed: (failed === null || failed === void 0 ? void 0 : failed.length) ? failed : undefined });
 };
 /**
  * Will make sure all the sessions need to encrypt for those user/clients pair are set
  */
-const initSessions = async ({ recipients, domain = '', apiClient, cryptoClient, logger, }) => {
-    const missingUserClients = {};
+const initSessions = async ({ recipients, apiClient, cryptoClient, logger, }) => {
+    var _a, _b, _c;
+    const missingClients = {};
+    const missingClientsWithPrekeys = {};
     const existingSessions = [];
-    const users = (0, UserClientsUtil_1.flattenUserClients)(recipients, domain);
+    const users = (0, UserClientsUtil_1.flattenUserMap)(recipients);
     for (const user of users) {
         const { userId, data } = user;
         const clients = Array.isArray(data) ? data : Object.keys(data);
         for (const clientId of clients) {
-            const sessionId = constructSessionId({ userId, clientId, useQualifiedIds: !!domain });
+            const sessionId = constructSessionId({ userId, clientId });
             if (await cryptoClient.sessionExists(sessionId)) {
                 existingSessions.push(sessionId);
                 continue;
             }
-            missingUserClients[userId.id] = missingUserClients[userId.id] || [];
-            missingUserClients[userId.id].push(clientId);
+            if (!Array.isArray(data)) {
+                const domainMissingWithPrekey = (_a = missingClientsWithPrekeys[userId.domain]) !== null && _a !== void 0 ? _a : {};
+                domainMissingWithPrekey[userId.id] = (_b = domainMissingWithPrekey[userId.id]) !== null && _b !== void 0 ? _b : {};
+                domainMissingWithPrekey[userId.id][clientId] = data[clientId];
+                missingClientsWithPrekeys[userId.domain] = domainMissingWithPrekey;
+                continue;
+            }
+            const domainMissing = (_c = missingClients[userId.domain]) !== null && _c !== void 0 ? _c : {};
+            domainMissing[userId.id] = domainMissing[userId.id] || [];
+            domainMissing[userId.id].push(clientId);
+            missingClients[userId.domain] = domainMissing;
         }
     }
-    if (Object.keys(missingUserClients).length === 0) {
-        return existingSessions;
-    }
-    const newSessions = await createSessions({
-        userClientMap: missingUserClients,
-        domain,
-        apiClient,
-        cryptoClient,
-        logger,
-    });
-    return [...existingSessions, ...newSessions];
+    const { sessions: prekeyCreated, unknowns: prekeyUnknows } = Object.keys(missingClientsWithPrekeys).length > 0
+        ? await createSessionsFromPreKeys({
+            recipients: missingClientsWithPrekeys,
+            cryptoClient,
+        })
+        : { sessions: [], unknowns: {} };
+    const { sessions: created, failed, unknowns, } = Object.keys(missingClients).length > 0
+        ? await createSessions({
+            recipients: missingClients,
+            apiClient,
+            cryptoClient,
+            logger,
+        })
+        : { sessions: [], failed: undefined, unknowns: undefined };
+    const allUnknowns = Object.assign(Object.assign({}, prekeyUnknows), unknowns);
+    return {
+        sessions: [...existingSessions, ...prekeyCreated, ...created],
+        failed,
+        unknowns: Object.keys(allUnknowns).length > 0 ? allUnknowns : undefined,
+    };
 };
 exports.initSessions = initSessions;
 async function deleteSession(params) {
@@ -152,34 +128,46 @@ async function deleteSession(params) {
     await params.cryptoClient.deleteSession(sessionId);
 }
 exports.deleteSession = deleteSession;
-const createSessionsFromPreKeys = async ({ preKeyBundleMap, domain = '', useQualifiedIds, cryptoClient, logger, }) => {
+const createSessionsFromPreKeys = async ({ recipients, cryptoClient, }) => {
+    var _a, _b;
     const sessions = [];
-    for (const userId in preKeyBundleMap) {
-        const userClients = preKeyBundleMap[userId];
-        for (const clientId in userClients) {
-            const sessionId = constructSessionId({ userId, clientId, domain, useQualifiedIds });
-            const prekey = userClients[clientId];
-            if (!prekey) {
-                logger === null || logger === void 0 ? void 0 : logger.warn(`A prekey for client ${clientId} of user ${userId}${domain ? ` on domain ${domain}` : ''} was not found, session won't be created.`);
-                continue;
+    const unknowns = {};
+    for (const domain in recipients) {
+        for (const userId in recipients[domain]) {
+            const userClients = recipients[domain][userId];
+            for (const clientId in userClients) {
+                const sessionId = constructSessionId({ userId: { id: userId, domain }, clientId });
+                const prekey = userClients[clientId];
+                if (!prekey) {
+                    const domainUnknowns = (_a = unknowns[domain]) !== null && _a !== void 0 ? _a : {};
+                    domainUnknowns[userId] = (_b = domainUnknowns[userId]) !== null && _b !== void 0 ? _b : [];
+                    domainUnknowns[userId].push(clientId);
+                    unknowns[domain] = domainUnknowns;
+                    continue;
+                }
+                const prekeyBuffer = bazinga64_1.Decoder.fromBase64(prekey.key).asBytes;
+                await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
+                await cryptoClient.saveSession(sessionId);
+                sessions.push(sessionId);
             }
-            const prekeyBuffer = bazinga64_1.Decoder.fromBase64(prekey.key).asBytes;
-            await cryptoClient.sessionFromPrekey(sessionId, prekeyBuffer);
-            await cryptoClient.saveSession(sessionId);
-            sessions.push(sessionId);
         }
     }
-    return sessions;
+    return { sessions, unknowns };
 };
 /**
  * creates an encrypted payload that can be sent to backend from a bunch of sessionIds/encrypted payload
  */
 const buildEncryptedPayloads = (payloads) => {
     return [...payloads].reduce((acc, [sessionId, payload]) => {
-        var _a;
-        const { userId, clientId } = parseSessionId(sessionId);
-        acc[userId] = (_a = acc[userId]) !== null && _a !== void 0 ? _a : {};
-        acc[userId][clientId] = payload;
+        var _a, _b;
+        const { userId, domain, clientId } = parseSessionId(sessionId);
+        if (!domain) {
+            throw new Error('Invalid session ID');
+        }
+        const domainPayloads = (_a = acc[domain]) !== null && _a !== void 0 ? _a : {};
+        domainPayloads[userId] = (_b = domainPayloads[userId]) !== null && _b !== void 0 ? _b : {};
+        domainPayloads[userId][clientId] = payload;
+        acc[domain] = domainPayloads;
         return acc;
     }, {});
 };

package/lib/messagingProtocols/proteus/Utility/SessionHandler/SessionHandler.test.js

@@ -20,16 +20,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const api_client_1 = require("@wireapp/api-client");
 const SessionHandler_1 = require("./SessionHandler");
-function generatePrekeys(userId, clientIds) {
-    const clients = clientIds.reduce((prekeys, clientId, index) => {
-        return Object.assign(Object.assign({}, prekeys), { [clientId]: {
-                id: index,
-                key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
-            } });
-    }, {});
-    return {
-        [userId.id]: Object.assign({}, clients),
-    };
+function generatePrekeys(recipients) {
+    const prekeys = {};
+    const failed = [];
+    Object.entries(recipients).forEach(([domain, userClients]) => {
+        Object.entries(userClients).forEach(([userId, clientIds]) => {
+            if (domain.startsWith('offline:')) {
+                failed.push({ id: userId, domain });
+                return;
+            }
+            const domainUsers = prekeys[domain] || {};
+            domainUsers[userId] = clientIds.reduce((acc, clientId, index) => {
+                const payload = clientId.startsWith('deleted:')
+                    ? null
+                    : {
+                        id: index,
+                        key: 'pQABARn//wKhAFggJ1Fbpg5l6wnzKOJE+vXpRnkqUYhIvVnR5lNXEbO2o/0DoQChAFggHxZvgvtDktY/vqBcpjjo6rQnXvcNQhfwmy8AJQJKlD0E9g==',
+                    };
+                return Object.assign(Object.assign({}, acc), { [clientId]: payload });
+            }, {});
+            prekeys[domain] = domainUsers;
+        });
+    });
+    return Promise.resolve({ qualified_user_client_prekeys: prekeys, failed_to_list: failed });
 }
 describe('SessionHandler', () => {
     const cryptoClient = {
@@ -40,43 +53,26 @@ describe('SessionHandler', () => {
         deleteSession: jest.fn(),
     };
     const apiClient = new api_client_1.APIClient({ urls: api_client_1.APIClient.BACKEND.STAGING });
+    beforeAll(() => {
+        jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockImplementation(generatePrekeys);
+    });
     describe('constructSessionId', () => {
         describe('constructs a session ID', () => {
             it('without a domain', () => {
-                const sessionId = (0, SessionHandler_1.constructSessionId)({ userId: 'user-id', clientId: 'client-id', useQualifiedIds: true });
+                const sessionId = (0, SessionHandler_1.constructSessionId)({ userId: { id: 'user-id', domain: '' }, clientId: 'client-id' });
                 expect(sessionId).toBe('user-id@client-id');
             });
             it('with a domain', () => {
-                const sessionId = (0, SessionHandler_1.constructSessionId)({
-                    userId: 'user-id',
-                    clientId: 'client-id',
-                    domain: 'domain',
-                    useQualifiedIds: true,
-                });
-                expect(sessionId).toBe('domain@user-id@client-id');
-            });
-            it('with a domain and useQualifiedIds', () => {
-                const sessionId = (0, SessionHandler_1.constructSessionId)({
-                    userId: 'user-id',
-                    clientId: 'client-id',
-                    domain: 'domain',
-                    useQualifiedIds: true,
-                });
-                expect(sessionId).toBe('domain@user-id@client-id');
-            });
-            it('with a qualified ID', () => {
                 const sessionId = (0, SessionHandler_1.constructSessionId)({
                     userId: { id: 'user-id', domain: 'domain' },
                     clientId: 'client-id',
-                    useQualifiedIds: true,
                 });
                 expect(sessionId).toBe('domain@user-id@client-id');
             });
-            it('with a qualified ID and useQualifiedIds', () => {
+            it('with a qualified ID', () => {
                 const sessionId = (0, SessionHandler_1.constructSessionId)({
                     userId: { id: 'user-id', domain: 'domain' },
                     clientId: 'client-id',
-                    useQualifiedIds: true,
                 });
                 expect(sessionId).toBe('domain@user-id@client-id');
             });
@@ -92,27 +88,9 @@ describe('SessionHandler', () => {
             const userId = { id: 'user1', domain: 'domain' };
             const clientId = 'client1';
             jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
-            jest
-                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
-                .mockResolvedValue({ domain: generatePrekeys(userId, [clientId]) });
-            const sessionId = (0, SessionHandler_1.constructSessionId)({
-                userId,
-                clientId,
-                useQualifiedIds: true,
-            });
-            await (0, SessionHandler_1.initSession)({ userId, clientId }, { apiClient, cryptoClient });
-            expect(cryptoClient.sessionFromPrekey).toHaveBeenCalledWith(sessionId, expect.any(Object));
-        });
-        it('indicates the consumer if a session could not be created', async () => {
-            const userId = { id: 'user1', domain: 'domain' };
-            const clientId = 'client1';
-            jest
-                .spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles')
-                .mockResolvedValue({ domain: generatePrekeys(userId, [clientId]) });
             const sessionId = (0, SessionHandler_1.constructSessionId)({
                 userId,
                 clientId,
-                useQualifiedIds: true,
             });
             await (0, SessionHandler_1.initSession)({ userId, clientId }, { apiClient, cryptoClient });
             expect(cryptoClient.sessionFromPrekey).toHaveBeenCalledWith(sessionId, expect.any(Object));
@@ -128,19 +106,57 @@ describe('SessionHandler', () => {
                 'missing-user1': ['client1'],
                 'missing-user2': ['client1', 'client2'],
             };
-            jest.spyOn(apiClient.api.user, 'postQualifiedMultiPreKeyBundles').mockResolvedValue({});
-            jest.spyOn(apiClient.api.user, 'postMultiPreKeyBundles').mockResolvedValue(Object.assign(Object.assign({}, generatePrekeys({ id: 'missing-user1', domain: '' }, ['client1'])), generatePrekeys({ id: 'missing-user2', domain: '' }, ['client1', 'client2'])));
             jest
                 .spyOn(cryptoClient, 'sessionExists')
                 .mockImplementation(sessionId => Promise.resolve(sessionId.includes('missing')));
             const sessionFromPrekeySpy = jest.spyOn(cryptoClient, 'sessionFromPrekey');
-            const sessions = await (0, SessionHandler_1.initSessions)({
-                recipients: Object.assign(Object.assign({}, existingUserClients), missingUserClients),
+            const { sessions } = await (0, SessionHandler_1.initSessions)({
+                recipients: { domain: Object.assign(Object.assign({}, existingUserClients), missingUserClients) },
                 apiClient,
                 cryptoClient,
             });
             expect(sessionFromPrekeySpy).toHaveBeenCalledTimes(3);
             expect(sessions).toHaveLength(6);
         });
+        it('returns the list of deleted clients (clients with null prekeys)', async () => {
+            const userClients = {
+                'existing-user1': ['client1', 'deleted:client2'],
+            };
+            const { sessions, unknowns } = await (0, SessionHandler_1.initSessions)({
+                recipients: { domain: userClients },
+                apiClient,
+                cryptoClient,
+            });
+            expect(sessions).toEqual(['domain@existing-user1@client1']);
+            expect(unknowns).toEqual({ domain: { 'existing-user1': ['deleted:client2'] } });
+        });
+        it('initializes sessions across multiple domains', async () => {
+            const userClients = {
+                domain1: { 'existing-user1': ['client11'] },
+                domain2: { 'existing-user2': ['client21'] },
+            };
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(true);
+            const { sessions, unknowns } = await (0, SessionHandler_1.initSessions)({
+                recipients: userClients,
+                apiClient,
+                cryptoClient,
+            });
+            expect(sessions).toEqual(['domain1@existing-user1@client11', 'domain2@existing-user2@client21']);
+            expect(unknowns).toBeUndefined();
+        });
+        it('returns failed session creation', async () => {
+            const recipients = {
+                domain1: { 'existing-user1': ['client1'] },
+                'offline:domain': { user2: ['client12'] },
+            };
+            jest.spyOn(cryptoClient, 'sessionExists').mockResolvedValue(false);
+            const { sessions, failed } = await (0, SessionHandler_1.initSessions)({
+                recipients,
+                apiClient,
+                cryptoClient,
+            });
+            expect(sessions).toEqual(['domain1@existing-user1@client1']);
+            expect(failed).toEqual([{ id: 'user2', domain: 'offline:domain' }]);
+        });
     });
 });

package/lib/messagingProtocols/proteus/Utility/getGenericMessageParams.d.ts

@@ -1,10 +1,9 @@
 import { APIClient } from '@wireapp/api-client/lib/APIClient';
-import { QualifiedUserClients, UserClients } from '@wireapp/api-client/lib/conversation';
-import { QualifiedId, QualifiedUserPreKeyBundleMap, UserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
+import { QualifiedUserClients } from '@wireapp/api-client/lib/conversation';
+import { QualifiedId, QualifiedUserPreKeyBundleMap } from '@wireapp/api-client/lib/user';
 import { GenericMessage } from '@wireapp/protocol-messaging';
 import { MessageSendingOptions } from '../../../conversation';
-export type FederatedMessageParams = {
-    federated: true;
+export type MessageParams = {
     sendingClientId: string;
     recipients: QualifiedUserClients | QualifiedUserPreKeyBundleMap;
     plainText: Uint8Array;
@@ -14,22 +13,14 @@ export type FederatedMessageParams = {
         reportMissing: boolean | QualifiedId[] | undefined;
     };
 };
-export type MessageParams = Omit<FederatedMessageParams, 'recipients' | 'options' | 'federated'> & {
-    federated: false;
-    recipients: UserClients | UserPreKeyBundleMap;
-    options: Omit<FederatedMessageParams['options'], 'reportMissing'> & {
-        reportMissing: boolean | string[] | undefined;
-    };
-};
 interface GetGenericMessageParamsParams {
     sendingClientId: string;
     conversationId: QualifiedId;
     genericMessage: GenericMessage;
     options: MessageSendingOptions;
-    useQualifiedIds: boolean;
     apiClient: APIClient;
 }
-type GetGenericMessageParamsReturnType = Promise<MessageParams | FederatedMessageParams>;
-declare const getGenericMessageParams: ({ sendingClientId, conversationId, genericMessage, options: { targetMode, userIds, nativePush }, useQualifiedIds, apiClient, }: GetGenericMessageParamsParams) => GetGenericMessageParamsReturnType;
+type GetGenericMessageParamsReturnType = Promise<MessageParams>;
+declare const getGenericMessageParams: ({ sendingClientId, conversationId, genericMessage, options: { targetMode, userIds, nativePush }, apiClient, }: GetGenericMessageParamsParams) => GetGenericMessageParamsReturnType;
 export { getGenericMessageParams };
 //# sourceMappingURL=getGenericMessageParams.d.ts.map

package/lib/messagingProtocols/proteus/Utility/getGenericMessageParams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getGenericMessageParams.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/Utility/getGenericMessageParams.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AAC5D,OAAO,EAAC,oBAAoB,EAAE,WAAW,EAAC,MAAM,sCAAsC,CAAC;AACvF,OAAO,EAAC,WAAW,EAAE,4BAA4B,EAAE,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAE5G,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAK3D,OAAO,EAAoB,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAG/E,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,IAAI,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,oBAAoB,GAAG,4BAA4B,CAAC;IAChE,SAAS,EAAE,UAAU,CAAC;IACtB,OAAO,EAAE;QACP,cAAc,EAAE,WAAW,CAAC;QAC5B,UAAU,EAAE,OAAO,GAAG,SAAS,CAAC;QAChC,aAAa,EAAE,OAAO,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC;KACpD,CAAC;CACH,CAAC;AACF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,EAAE,YAAY,GAAG,SAAS,GAAG,WAAW,CAAC,GAAG;IACjG,SAAS,EAAE,KAAK,CAAC;IACjB,UAAU,EAAE,WAAW,GAAG,mBAAmB,CAAC;IAC9C,OAAO,EAAE,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC,GAAG;QAClE,aAAa,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;KAC/C,CAAC;CACH,CAAC;AACF,UAAU,6BAA6B;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC;IAC5B,cAAc,EAAE,cAAc,CAAC;IAC/B,OAAO,EAAE,qBAAqB,CAAC;IAC/B,eAAe,EAAE,OAAO,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;CACtB;AACD,KAAK,iCAAiC,GAAG,OAAO,CAAC,aAAa,GAAG,sBAAsB,CAAC,CAAC;AAEzF,QAAA,MAAM,uBAAuB,mIAO1B,6BAA6B,sCAyD/B,CAAC;AAEF,OAAO,EAAC,uBAAuB,EAAC,CAAC"}
+{"version":3,"file":"getGenericMessageParams.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/Utility/getGenericMessageParams.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,SAAS,EAAC,MAAM,mCAAmC,CAAC;AAC5D,OAAO,EAAC,oBAAoB,EAAC,MAAM,sCAAsC,CAAC;AAC1E,OAAO,EAAC,WAAW,EAAE,4BAA4B,EAAC,MAAM,8BAA8B,CAAC;AAEvF,OAAO,EAAC,cAAc,EAAC,MAAM,6BAA6B,CAAC;AAK3D,OAAO,EAAoB,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAG/E,MAAM,MAAM,aAAa,GAAG;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,oBAAoB,GAAG,4BAA4B,CAAC;IAChE,SAAS,EAAE,UAAU,CAAC;IACtB,OAAO,EAAE;QACP,cAAc,EAAE,WAAW,CAAC;QAC5B,UAAU,EAAE,OAAO,GAAG,SAAS,CAAC;QAChC,aAAa,EAAE,OAAO,GAAG,WAAW,EAAE,GAAG,SAAS,CAAC;KACpD,CAAC;CACH,CAAC;AACF,UAAU,6BAA6B;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,WAAW,CAAC;IAC5B,cAAc,EAAE,cAAc,CAAC;IAC/B,OAAO,EAAE,qBAAqB,CAAC;IAC/B,SAAS,EAAE,SAAS,CAAC;CACtB;AACD,KAAK,iCAAiC,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;AAEhE,QAAA,MAAM,uBAAuB,kHAM1B,6BAA6B,sCA0B/B,CAAC;AAEF,OAAO,EAAC,uBAAuB,EAAC,CAAC"}

package/lib/messagingProtocols/proteus/Utility/getGenericMessageParams.js

@@ -24,56 +24,24 @@ const Recipients_1 = require("./Recipients");
 const UserIds_1 = require("./UserIds");
 const conversation_1 = require("../../../conversation");
 const util_1 = require("../../../util");
-const getGenericMessageParams = async ({ sendingClientId, conversationId, genericMessage, options: { targetMode = conversation_1.MessageTargetMode.NONE, userIds, nativePush }, useQualifiedIds, apiClient, }) => {
+const getGenericMessageParams = async ({ sendingClientId, conversationId, genericMessage, options: { targetMode = conversation_1.MessageTargetMode.NONE, userIds, nativePush }, apiClient, }) => {
     const plainText = protocol_messaging_1.GenericMessage.encode(genericMessage).finish();
     if (targetMode !== conversation_1.MessageTargetMode.NONE && !userIds) {
         throw new Error('Cannot send targetted message when no userIds are given');
     }
-    if (conversationId.domain && useQualifiedIds) {
-        if ((0, util_1.isStringArray)(userIds) || (0, util_1.isUserClients)(userIds)) {
-            throw new Error('Invalid userIds option for sending to federated backend');
-        }
-        const recipients = await (0, Recipients_1.getQualifiedRecipientsForConversation)({ apiClient, conversationId, userIds });
-        let reportMissing;
-        if (targetMode === conversation_1.MessageTargetMode.NONE) {
-            reportMissing = (0, util_1.isQualifiedUserClients)(userIds); // we want to check mismatch in case the consumer gave an exact list of users/devices
-        }
-        else if (targetMode === conversation_1.MessageTargetMode.USERS) {
-            reportMissing = (0, UserIds_1.extractQualifiedUserIds)({ userIds });
-        }
-        else {
-            // in case the message is fully targetted at user/client pairs, we do not want to report the missing clients or users at all
-            reportMissing = false;
-        }
-        return {
-            federated: true,
-            sendingClientId,
-            recipients,
-            plainText,
-            options: {
-                conversationId,
-                nativePush,
-                reportMissing,
-            },
-        };
-    }
-    if ((0, util_1.isQualifiedIdArray)(userIds) || (0, util_1.isQualifiedUserClients)(userIds)) {
-        throw new Error('Invalid userIds option for sending');
-    }
     const recipients = await (0, Recipients_1.getRecipientsForConversation)({ apiClient, conversationId, userIds });
     let reportMissing;
     if (targetMode === conversation_1.MessageTargetMode.NONE) {
-        reportMissing = (0, util_1.isUserClients)(userIds); // we want to check mismatch in case the consumer gave an exact list of users/devices
+        reportMissing = (0, util_1.isQualifiedUserClients)(userIds); // we want to check mismatch in case the consumer gave an exact list of users/devices
     }
     else if (targetMode === conversation_1.MessageTargetMode.USERS) {
-        reportMissing = (0, UserIds_1.extractUserIds)({ userIds });
+        reportMissing = (0, UserIds_1.extractQualifiedUserIds)({ userIds });
     }
     else {
         // in case the message is fully targetted at user/client pairs, we do not want to report the missing clients or users at all
         reportMissing = false;
     }
     return {
-        federated: false,
         sendingClientId,
         recipients,
         plainText,

package/lib/messagingProtocols/proteus/Utility/isClearFromMismatch.d.ts

@@ -1,4 +1,4 @@
-import { ClientMismatch, MessageSendingStatus } from '@wireapp/api-client/lib/conversation';
-declare const isClearFromMismatch: (mismatch: ClientMismatch | MessageSendingStatus) => boolean;
+import { MessageSendingStatus } from '@wireapp/api-client/lib/conversation';
+declare const isClearFromMismatch: (mismatch: MessageSendingStatus) => boolean;
 export { isClearFromMismatch };
 //# sourceMappingURL=isClearFromMismatch.d.ts.map

package/lib/messagingProtocols/proteus/Utility/isClearFromMismatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isClearFromMismatch.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/Utility/isClearFromMismatch.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,cAAc,EAAE,oBAAoB,EAAC,MAAM,sCAAsC,CAAC;AAE1F,QAAA,MAAM,mBAAmB,aAAc,cAAc,GAAG,oBAAoB,KAAG,OAM9E,CAAC;AAEF,OAAO,EAAC,mBAAmB,EAAC,CAAC"}
+{"version":3,"file":"isClearFromMismatch.d.ts","sourceRoot":"","sources":["../../../../src/messagingProtocols/proteus/Utility/isClearFromMismatch.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,oBAAoB,EAAC,MAAM,sCAAsC,CAAC;AAE1E,QAAA,MAAM,mBAAmB,aAAc,oBAAoB,KAAG,OAM7D,CAAC;AAEF,OAAO,EAAC,mBAAmB,EAAC,CAAC"}

package/lib/notification/NotificationDatabaseRepository.js

@@ -27,7 +27,7 @@ var DatabaseKeys;
 (function (DatabaseKeys) {
     DatabaseKeys["PRIMARY_KEY_LAST_EVENT"] = "z.storage.StorageKey.EVENT.LAST_DATE";
     DatabaseKeys["PRIMARY_KEY_LAST_NOTIFICATION"] = "z.storage.StorageKey.NOTIFICATION.LAST_ID";
-})(DatabaseKeys = exports.DatabaseKeys || (exports.DatabaseKeys = {}));
+})(DatabaseKeys || (exports.DatabaseKeys = DatabaseKeys = {}));
 const STORES = {
     AMPLIFY: 'amplify',
 };

package/lib/notification/Notifications.types.js

@@ -24,4 +24,4 @@ var NotificationSource;
     NotificationSource["LOCAL"] = "LOCAL";
     NotificationSource["NOTIFICATION_STREAM"] = "NOTIFICATION_STREAM";
     NotificationSource["WEBSOCKET"] = "WEBSOCKET";
-})(NotificationSource = exports.NotificationSource || (exports.NotificationSource = {}));
+})(NotificationSource || (exports.NotificationSource = NotificationSource = {}));

package/lib/user/UserService.d.ts

@@ -1,24 +1,13 @@
 import { QualifiedId, User } from '@wireapp/api-client/lib/user/';
 import { APIClient } from '@wireapp/api-client';
-import { AvailabilityType, BroadcastService } from '../broadcast/';
-import { ConnectionService } from '../connection';
 export declare class UserService {
     private readonly apiClient;
-    private readonly broadcastService;
-    private readonly connectionService;
-    constructor(apiClient: APIClient, broadcastService: BroadcastService, connectionService: ConnectionService);
+    constructor(apiClient: APIClient);
     getUser(userId: string | QualifiedId): Promise<User>;
-    getUsers(userIds: string[] | QualifiedId[]): Promise<User[]>;
-    /**
-     * 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>;
+    getUsers(userIds: QualifiedId[]): Promise<{
+        found: User[];
+        failed?: QualifiedId[] | undefined;
+        not_found?: QualifiedId[] | undefined;
+    } | never[]>;
 }
 //# sourceMappingURL=UserService.d.ts.map

package/lib/user/UserService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UserService.d.ts","sourceRoot":"","sources":["../../src/user/UserService.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,WAAW,EAAE,IAAI,EAAsB,MAAM,+BAA+B,CAAC;AAErF,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAG9C,OAAO,EAAC,gBAAgB,EAAE,gBAAgB,EAAC,MAAM,eAAe,CAAC;AACjE,OAAO,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAKhD,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IACpD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;gBAE1C,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB;IAMnG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9C,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IASzE;;;;;;OAMG;IACU,eAAe,CAC1B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,gBAAgB,EACtB,EAAC,OAAe,EAAE,cAAsB,EAAC;;;KAAK,GAC7C,OAAO,CAAC,IAAI,CAAC;CAuCjB"}
+{"version":3,"file":"UserService.d.ts","sourceRoot":"","sources":["../../src/user/UserService.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAC,WAAW,EAAE,IAAI,EAAC,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAAC,SAAS,EAAC,MAAM,qBAAqB,CAAC;AAE9C,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;gBAE1B,SAAS,EAAE,SAAS;IAIzB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9C,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE;;;;;CAM7C"}