@wireapp/core 27.0.5 → 27.2.1

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [27.2.1](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@27.2.0...@wireapp/core@27.2.1) (2022-05-31)
+
+**Note:** Version bump only for package @wireapp/core
+
+
+
+
+
+# [27.2.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@27.1.0...@wireapp/core@27.2.0) (2022-05-30)
+
+
+### Features
+
+* Add missed notifications hook ([#4275](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4275)) ([f81217b](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/f81217bad53fed2e4fb163c6ae871b39ca16cf58))
+
+
+
+
+
+# [27.1.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@27.0.5...@wireapp/core@27.1.0) (2022-05-30)
+
+
+### Features
+
+* Improve websocket connection API ([#4268](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4268)) ([a6eb884](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/a6eb884ddf42915157c8d6c846b0a8a989c3fc04))
+
+
+
+
+
 ## [27.0.5](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@27.0.4...@wireapp/core@27.0.5) (2022-05-30)
 
 **Note:** Version bump only for package @wireapp/core

package/package.json

@@ -5,7 +5,7 @@
   "dependencies": {
     "@types/long": "4.0.1",
     "@types/node": "~14",
-    "@wireapp/api-client": "19.2.5",
+    "@wireapp/api-client": "19.3.1",
     "@wireapp/cryptobox": "12.8.0",
     "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": "27.0.5",
-  "gitHead": "4a9e90c8c5c46e4d3cc3f24ee83d2a5ed1673aef"
+  "version": "27.2.1",
+  "gitHead": "97d45ca6fbd2c9f72871882b3cd0b92b26d49cf3"
 }

package/src/main/Account.d.ts

@@ -9,18 +9,20 @@ import { EventEmitter } from 'events';
 import { BroadcastService } from './broadcast/';
 import { ClientInfo, ClientService } from './client/';
 import { ConnectionService } from './connection/';
-import { AssetService, ConversationService, PayloadBundleType } from './conversation/';
+import { AssetService, ConversationService, PayloadBundleSource, PayloadBundleType } from './conversation/';
 import * as OtrMessage from './conversation/message/OtrMessage';
 import * as UserMessage from './conversation/message/UserMessage';
 import type { CoreError } from './CoreError';
 import { CryptographyService } from './cryptography/';
 import { GiphyService } from './giphy/';
-import { NotificationHandler, NotificationService } from './notification/';
+import { HandledEventPayload, NotificationService } from './notification/';
 import { SelfService } from './self/';
 import { TeamService } from './team/';
 import { UserService } from './user/';
 import { AccountService } from './account/';
 import { LinkPreviewService } from './linkPreview';
+import { WEBSOCKET_STATE } from '@wireapp/api-client/src/tcp/ReconnectingWebsocket';
+export declare type ProcessedEventPayload = HandledEventPayload;
 declare enum TOPIC {
     ERROR = "Account.TOPIC.ERROR"
 }
@@ -141,9 +143,44 @@ export declare class Account extends EventEmitter {
     private registerClient;
     private resetContext;
     logout(): Promise<void>;
-    listen(notificationHandler?: NotificationHandler): Promise<Account>;
-    private readonly handlePayload;
-    private readonly handleError;
+    /**
+     * Will download and handle the notification stream since last stored notification id.
+     * Once the notification stream has been handled from backend, will then connect to the websocket and start listening to incoming events
+     *
+     * @param callbacks callbacks that will be called to handle different events
+     * @returns close a function that will disconnect from the websocket
+     */
+    listen({ onEvent, onConnected, onConnectionStateChanged, onNotificationStreamProgress, onMissedNotifications, }?: {
+        /**
+         * Called when a new event arrives from backend
+         * @param payload the payload of the event. Contains the raw event received and the decrypted data (if event was encrypted)
+         * @param source where the message comes from (either websocket or notification stream)
+         */
+        onEvent?: (payload: HandledEventPayload, source: PayloadBundleSource) => void;
+        /**
+         * During the notification stream processing, this function will be called whenever a new notification has been processed
+         */
+        onNotificationStreamProgress?: ({ done, total }: {
+            done: number;
+            total: number;
+        }) => void;
+        /**
+         * called when the connection to the websocket is established and the notification stream has been processed
+         */
+        onConnected?: () => void;
+        /**
+         * called when the connection stateh with the backend has changed
+         */
+        onConnectionStateChanged?: (state: WEBSOCKET_STATE) => void;
+        /**
+         * called when we detect lost notification from backend.
+         * When a client doesn't log in for a while (28 days, as of now) notifications that are older than 28 days will be deleted from backend.
+         * If the client query the backend for the notifications since a particular notification ID and this ID doesn't exist anymore on the backend, we deduce that some messages were not sync before they were removed from backend.
+         * We can then detect that something was wrong and warn the consumer that there might be some missing old messages
+         * @param  {string} notificationId
+         */
+        onMissedNotifications?: (notificationId: string) => void;
+    }): Promise<() => void>;
     private initEngine;
 }
 export {};

package/src/main/Account.js

@@ -36,6 +36,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -79,20 +86,6 @@ class Account extends events_1.EventEmitter {
      */
     constructor(apiClient = new api_client_1.APIClient(), { createStore = () => undefined, nbPrekeys = 2 } = {}) {
         super();
-        this.handlePayload = async (payload) => {
-            switch (payload.type) {
-                case conversation_1.PayloadBundleType.TIMER_UPDATE: {
-                    const { data: { message_timer }, conversation, } = payload;
-                    const expireAfterMillis = Number(message_timer);
-                    this.service.conversation.messageTimer.setConversationLevelTimer(conversation, expireAfterMillis);
-                    break;
-                }
-            }
-            this.emit(payload.type, payload);
-        };
-        this.handleError = (accountError) => {
-            this.emit(Account.TOPIC.ERROR, accountError);
-        };
         this.apiClient = apiClient;
         this.backendFeatures = this.apiClient.backendFeatures;
         this.nbPrekeys = nbPrekeys;
@@ -284,25 +277,68 @@ class Account extends events_1.EventEmitter {
         await this.apiClient.logout();
         this.resetContext();
     }
-    async listen(notificationHandler = this.service.notification.handleNotification) {
+    /**
+     * Will download and handle the notification stream since last stored notification id.
+     * Once the notification stream has been handled from backend, will then connect to the websocket and start listening to incoming events
+     *
+     * @param callbacks callbacks that will be called to handle different events
+     * @returns close a function that will disconnect from the websocket
+     */
+    async listen({ onEvent = () => { }, onConnected = () => { }, onConnectionStateChanged = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, } = {}) {
         if (!this.apiClient.context) {
             throw new Error('Context is not set - please login first');
         }
-        this.apiClient.transport.ws.removeAllListeners(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE);
-        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE, notification => {
-            notificationHandler(notification, conversation_1.PayloadBundleSource.WEBSOCKET).catch(error => {
+        const handleEvent = async (payload, source) => {
+            const { mappedEvent } = payload;
+            switch (mappedEvent === null || mappedEvent === void 0 ? void 0 : mappedEvent.type) {
+                case conversation_1.PayloadBundleType.TIMER_UPDATE: {
+                    const { data: { message_timer }, conversation, } = payload.event;
+                    const expireAfterMillis = Number(message_timer);
+                    this.service.conversation.messageTimer.setConversationLevelTimer(conversation, expireAfterMillis);
+                    break;
+                }
+            }
+            onEvent(payload, source);
+            if (mappedEvent) {
+                this.emit(mappedEvent.type, payload.mappedEvent);
+            }
+        };
+        const handleNotification = async (notification, source) => {
+            var e_1, _a;
+            try {
+                const messages = this.service.notification.handleNotification(notification, conversation_1.PayloadBundleSource.WEBSOCKET);
+                try {
+                    for (var messages_1 = __asyncValues(messages), messages_1_1; messages_1_1 = await messages_1.next(), !messages_1_1.done;) {
+                        const message = messages_1_1.value;
+                        await handleEvent(message, source);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (messages_1_1 && !messages_1_1.done && (_a = messages_1.return)) await _a.call(messages_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (error) {
                 this.logger.error(`Failed to handle notification ID "${notification.id}": ${error.message}`, error);
-            });
-        });
-        this.service.notification.removeAllListeners(notification_1.NotificationService.TOPIC.NOTIFICATION_ERROR);
-        this.service.notification.on(notification_1.NotificationService.TOPIC.NOTIFICATION_ERROR, this.handleError);
-        for (const payloadType of Object.values(conversation_1.PayloadBundleType)) {
-            this.service.notification.removeAllListeners(payloadType);
-            this.service.notification.on(payloadType, this.handlePayload);
-        }
-        const onBeforeConnect = async () => this.service.notification.handleNotificationStream(notificationHandler);
+            }
+        };
+        this.apiClient.transport.ws.removeAllListeners(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE);
+        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE, notification => handleNotification(notification, conversation_1.PayloadBundleSource.WEBSOCKET));
+        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_STATE_CHANGE, onConnectionStateChanged);
+        const onBeforeConnect = async () => {
+            await this.service.notification.handleNotificationStream(async (notification, source, progress) => {
+                await handleNotification(notification, source);
+                onNotificationStreamProgress(progress);
+            }, onMissedNotifications);
+            onConnected();
+        };
         await this.apiClient.connect(onBeforeConnect);
-        return this;
+        return () => {
+            this.apiClient.disconnect();
+        };
     }
     async initEngine(context) {
         const clientType = context.clientType === client_1.ClientType.NONE ? '' : `@${context.clientType}`;

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

@@ -5,8 +5,13 @@ import type { OTRRecipients, QualifiedOTRRecipients, QualifiedUserClients, UserC
 import type { ConversationOtrMessageAddEvent } from '@wireapp/api-client/src/event';
 import type { QualifiedId, QualifiedUserPreKeyBundleMap, UserPreKeyBundleMap } from '@wireapp/api-client/src/user/';
 import { Cryptobox } from '@wireapp/cryptobox';
+import { GenericMessage } from '@wireapp/protocol-messaging';
 import type { CRUDEngine } from '@wireapp/store-engine';
 import { PayloadBundle, PayloadBundleSource } from '../conversation';
+export declare type DecryptionError = {
+    code: number;
+    message: string;
+};
 export interface MetaClient extends RegisteredClient {
     meta: {
         is_verified?: boolean;
@@ -41,5 +46,7 @@ export declare class CryptographyService {
     initCryptobox(): Promise<void>;
     deleteCryptographyStores(): Promise<boolean[]>;
     resetSession(sessionId: string): Promise<void>;
-    decodeGenericMessage(otrMessage: ConversationOtrMessageAddEvent, source: PayloadBundleSource): Promise<PayloadBundle>;
+    decryptMessage(otrMessage: ConversationOtrMessageAddEvent): Promise<GenericMessage>;
+    mapGenericMessage(otrMessage: ConversationOtrMessageAddEvent, genericMessage: GenericMessage, source: PayloadBundleSource): PayloadBundle;
+    private generateDecryptionError;
 }

package/src/main/cryptography/CryptographyService.js

@@ -151,11 +151,18 @@ class CryptographyService {
         await this.cryptobox.session_delete(sessionId);
         this.logger.log(`Deleted session ID "${sessionId}".`);
     }
-    async decodeGenericMessage(otrMessage, source) {
+    async decryptMessage(otrMessage) {
         const { from, qualified_from, data: { sender, text: cipherText }, } = otrMessage;
         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);
+        try {
+            const decryptedMessage = await this.decrypt(sessionId, cipherText);
+            return protocol_messaging_1.GenericMessage.decode(decryptedMessage);
+        }
+        catch (error) {
+            throw this.generateDecryptionError(otrMessage, error);
+        }
+    }
+    mapGenericMessage(otrMessage, genericMessage, source) {
         if (genericMessage.content === conversation_1.GenericMessageType.EPHEMERAL) {
             const unwrappedMessage = GenericMessageMapper_1.GenericMessageMapper.mapGenericMessage(genericMessage.ephemeral, otrMessage, source);
             unwrappedMessage.id = genericMessage.messageId;
@@ -168,6 +175,31 @@ class CryptographyService {
         }
         return GenericMessageMapper_1.GenericMessageMapper.mapGenericMessage(genericMessage, otrMessage, source);
     }
+    generateDecryptionError(event, error) {
+        var _a;
+        const errorCode = (_a = error.code) !== null && _a !== void 0 ? _a : 999;
+        let message = 'Unknown decryption error';
+        const { data: eventData, from: remoteUserId, time: formattedTime } = event;
+        const remoteClientId = eventData.sender;
+        const isDuplicateMessage = error instanceof proteus_1.errors.DecryptError.DuplicateMessage;
+        const isOutdatedMessage = error instanceof proteus_1.errors.DecryptError.OutdatedMessage;
+        // We don't need to show these message errors to the user
+        if (isDuplicateMessage || isOutdatedMessage) {
+            message = `Message from user ID "${remoteUserId}" at "${formattedTime}" will not be handled because it is outdated or a duplicate.`;
+        }
+        const isInvalidMessage = error instanceof proteus_1.errors.DecryptError.InvalidMessage;
+        const isInvalidSignature = error instanceof proteus_1.errors.DecryptError.InvalidSignature;
+        const isRemoteIdentityChanged = error instanceof proteus_1.errors.DecryptError.RemoteIdentityChanged;
+        // Session is broken, let's see what's really causing it...
+        if (isInvalidMessage || isInvalidSignature) {
+            message = `Session with user '${remoteUserId}' (${remoteClientId}) is broken.\nReset the session for possible fix.`;
+        }
+        else if (isRemoteIdentityChanged) {
+            message = `Remote identity of client '${remoteClientId}' from user '${remoteUserId}' changed`;
+        }
+        this.logger.warn(`Failed to decrypt event from client '${remoteClientId}' of user '${remoteUserId}' (${formattedTime}).\nError Code: '${errorCode}'\nError Message: ${error.message}`, error);
+        return { code: errorCode, message };
+    }
 }
 exports.CryptographyService = CryptographyService;
 //# sourceMappingURL=CryptographyService.js.map

package/src/main/notification/NotificationBackendRepository.d.ts

@@ -3,6 +3,9 @@ import type { Notification } from '@wireapp/api-client/src/notification/';
 export declare class NotificationBackendRepository {
     private readonly apiClient;
     constructor(apiClient: APIClient);
-    getAllNotifications(clientId?: string, lastNotificationId?: string): Promise<Notification[]>;
+    getAllNotifications(clientId?: string, lastNotificationId?: string): Promise<{
+        notifications: Notification[];
+        missedNotification?: string | undefined;
+    }>;
     getLastNotification(clientId?: string): Promise<Notification>;
 }

package/src/main/notification/NotificationService.d.ts

@@ -4,41 +4,27 @@ import * as Events from '@wireapp/api-client/src/event';
 import type { Notification } from '@wireapp/api-client/src/notification/';
 import { CRUDEngine } from '@wireapp/store-engine';
 import { EventEmitter } from 'events';
-import { PayloadBundleSource, PayloadBundleType } from '../conversation';
-import * as OtrMessage from '../conversation/message/OtrMessage';
-import * as UserMessage from '../conversation/message/UserMessage';
+import { PayloadBundle, PayloadBundleSource } from '../conversation';
 import { NotificationError } from '../CoreError';
 import type { CryptographyService } from '../cryptography';
+import { GenericMessage } from '@wireapp/protocol-messaging';
+export declare type HandledEventPayload = {
+    event: Events.BackendEvent;
+    mappedEvent?: PayloadBundle;
+    decryptedData?: GenericMessage;
+    decryptionError?: {
+        code: number;
+        message: string;
+    };
+};
 declare enum TOPIC {
     NOTIFICATION_ERROR = "NotificationService.TOPIC.NOTIFICATION_ERROR"
 }
-export declare type NotificationHandler = (notification: Notification, source: PayloadBundleSource) => Promise<void>;
+export declare type NotificationHandler = (notification: Notification, source: PayloadBundleSource, progress: {
+    done: number;
+    total: number;
+}) => Promise<void>;
 export interface NotificationService {
-    on(event: PayloadBundleType.ASSET, listener: (payload: OtrMessage.FileAssetMessage) => void): this;
-    on(event: PayloadBundleType.BUTTON_ACTION, listener: (payload: OtrMessage.ButtonActionMessage) => void): this;
-    on(event: PayloadBundleType.ASSET_ABORT, listener: (payload: OtrMessage.FileAssetAbortMessage) => void): this;
-    on(event: PayloadBundleType.ASSET_IMAGE, listener: (payload: OtrMessage.ImageAssetMessage) => void): this;
-    on(event: PayloadBundleType.ASSET_META, listener: (payload: OtrMessage.FileAssetMetaDataMessage) => void): this;
-    on(event: PayloadBundleType.CALL, listener: (payload: OtrMessage.CallMessage) => void): this;
-    on(event: PayloadBundleType.CLIENT_ACTION, listener: (payload: OtrMessage.ResetSessionMessage) => void): this;
-    on(event: PayloadBundleType.CLIENT_ADD, listener: (payload: UserMessage.UserClientAddMessage) => void): this;
-    on(event: PayloadBundleType.CLIENT_REMOVE, listener: (payload: UserMessage.UserClientRemoveMessage) => void): this;
-    on(event: PayloadBundleType.CONFIRMATION, listener: (payload: OtrMessage.ConfirmationMessage) => void): this;
-    on(event: PayloadBundleType.CONNECTION_REQUEST, listener: (payload: UserMessage.UserConnectionMessage) => void): this;
-    on(event: PayloadBundleType.USER_UPDATE, listener: (payload: UserMessage.UserUpdateMessage) => void): this;
-    on(event: PayloadBundleType.CONVERSATION_CLEAR, listener: (payload: OtrMessage.ClearConversationMessage) => void): this;
-    on(event: PayloadBundleType.CONVERSATION_RENAME, listener: (payload: Events.ConversationRenameEvent) => void): this;
-    on(event: PayloadBundleType.LOCATION, listener: (payload: OtrMessage.LocationMessage) => void): this;
-    on(event: PayloadBundleType.MEMBER_JOIN, listener: (payload: Events.TeamMemberJoinEvent) => void): this;
-    on(event: PayloadBundleType.MESSAGE_DELETE, listener: (payload: OtrMessage.DeleteMessage) => void): this;
-    on(event: PayloadBundleType.MESSAGE_EDIT, listener: (payload: OtrMessage.EditedTextMessage) => void): this;
-    on(event: PayloadBundleType.MESSAGE_HIDE, listener: (payload: OtrMessage.HideMessage) => void): this;
-    on(event: PayloadBundleType.PING, listener: (payload: OtrMessage.PingMessage) => void): this;
-    on(event: PayloadBundleType.REACTION, listener: (payload: OtrMessage.ReactionMessage) => void): this;
-    on(event: PayloadBundleType.TEXT, listener: (payload: OtrMessage.TextMessage) => void): this;
-    on(event: PayloadBundleType.TIMER_UPDATE, listener: (payload: Events.ConversationMessageTimerUpdateEvent) => void): this;
-    on(event: PayloadBundleType.TYPING, listener: (payload: Events.ConversationTypingEvent) => void): this;
-    on(event: PayloadBundleType.UNKNOWN, listener: (payload: any) => void): this;
     on(event: TOPIC.NOTIFICATION_ERROR, listener: (payload: NotificationError) => void): this;
 }
 export declare class NotificationService extends EventEmitter {
@@ -49,15 +35,16 @@ export declare class NotificationService extends EventEmitter {
     private readonly logger;
     static readonly TOPIC: typeof TOPIC;
     constructor(apiClient: APIClient, cryptographyService: CryptographyService, storeEngine: CRUDEngine);
-    getAllNotifications(): Promise<Notification[]>;
+    private getAllNotifications;
     /** Should only be called with a completely new client. */
     initializeNotificationStream(): Promise<string>;
     hasHistory(): Promise<boolean>;
     getNotificationEventList(): Promise<Events.BackendEvent[]>;
     setLastEventDate(eventDate: Date): Promise<Date>;
     setLastNotificationId(lastNotification: Notification): Promise<string>;
-    handleNotificationStream(notificationHandler: NotificationHandler): Promise<void>;
-    readonly handleNotification: NotificationHandler;
+    handleNotificationStream(notificationHandler: NotificationHandler, onMissedNotifications: (notificationId: string) => void): Promise<void>;
+    handleNotification(notification: Notification, source: PayloadBundleSource): AsyncGenerator<HandledEventPayload>;
+    private cleanupPayloadBundle;
     private handleEvent;
 }
 export {};

package/src/main/notification/NotificationService.js

@@ -36,6 +36,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -62,80 +74,6 @@ class NotificationService extends events_1.EventEmitter {
             logger: console,
             markdown: false,
         });
-        this.handleNotification = async (notification, source) => {
-            for (const event of notification.payload) {
-                let data;
-                try {
-                    this.logger.log(`Handling event of type "${event.type}" for notification with ID "${notification.id}"`, event);
-                    data = await this.handleEvent(event, source);
-                    if (!notification.transient) {
-                        await this.setLastNotificationId(notification);
-                    }
-                }
-                catch (error) {
-                    this.logger.error(`There was an error with notification ID "${notification.id}": ${error.message}`, error);
-                    const notificationError = {
-                        error: error,
-                        notification,
-                        type: CoreError_1.CoreError.NOTIFICATION_ERROR,
-                    };
-                    this.emit(NotificationService.TOPIC.NOTIFICATION_ERROR, notificationError);
-                    continue;
-                }
-                if (data) {
-                    switch (data.type) {
-                        case conversation_1.PayloadBundleType.ASSET_IMAGE:
-                        case conversation_1.PayloadBundleType.BUTTON_ACTION:
-                        case conversation_1.PayloadBundleType.CALL:
-                        case conversation_1.PayloadBundleType.CLIENT_ACTION:
-                        case conversation_1.PayloadBundleType.CLIENT_ADD:
-                        case conversation_1.PayloadBundleType.CLIENT_REMOVE:
-                        case conversation_1.PayloadBundleType.CONFIRMATION:
-                        case conversation_1.PayloadBundleType.CONNECTION_REQUEST:
-                        case conversation_1.PayloadBundleType.LOCATION:
-                        case conversation_1.PayloadBundleType.MESSAGE_DELETE:
-                        case conversation_1.PayloadBundleType.MESSAGE_EDIT:
-                        case conversation_1.PayloadBundleType.MESSAGE_HIDE:
-                        case conversation_1.PayloadBundleType.PING:
-                        case conversation_1.PayloadBundleType.REACTION:
-                        case conversation_1.PayloadBundleType.TEXT:
-                        case conversation_1.PayloadBundleType.USER_UPDATE:
-                            this.emit(data.type, data);
-                            break;
-                        case conversation_1.PayloadBundleType.ASSET: {
-                            const assetContent = data.content;
-                            const isMetaData = !!assetContent && !!assetContent.original && !assetContent.uploaded;
-                            const isAbort = !!assetContent.abortReason || (!assetContent.original && !assetContent.uploaded);
-                            if (isMetaData) {
-                                data.type = conversation_1.PayloadBundleType.ASSET_META;
-                                this.emit(conversation_1.PayloadBundleType.ASSET_META, data);
-                            }
-                            else if (isAbort) {
-                                data.type = conversation_1.PayloadBundleType.ASSET_ABORT;
-                                this.emit(conversation_1.PayloadBundleType.ASSET_ABORT, data);
-                            }
-                            else {
-                                this.emit(conversation_1.PayloadBundleType.ASSET, data);
-                            }
-                            break;
-                        }
-                        case conversation_1.PayloadBundleType.TIMER_UPDATE:
-                        case conversation_1.PayloadBundleType.CONVERSATION_RENAME:
-                        case conversation_1.PayloadBundleType.CONVERSATION_CLEAR:
-                        case conversation_1.PayloadBundleType.MEMBER_JOIN:
-                        case conversation_1.PayloadBundleType.TYPING:
-                            this.emit(data.type, event);
-                            break;
-                    }
-                }
-                else {
-                    const { type, conversation, from } = event;
-                    const conversationText = conversation ? ` in conversation "${conversation}"` : '';
-                    const fromText = from ? ` from user "${from}".` : '';
-                    this.logger.log(`Received unsupported event "${type}"${conversationText}${fromText}`, { event });
-                }
-            }
-        };
         this.apiClient = apiClient;
         this.cryptographyService = cryptographyService;
         this.backend = new NotificationBackendRepository_1.NotificationBackendRepository(this.apiClient);
@@ -180,17 +118,79 @@ class NotificationService extends events_1.EventEmitter {
     async setLastNotificationId(lastNotification) {
         return this.database.updateLastNotificationId(lastNotification);
     }
-    async handleNotificationStream(notificationHandler) {
-        const notifications = await this.getAllNotifications();
-        for (const notification of notifications) {
-            await notificationHandler(notification, conversation_1.PayloadBundleSource.NOTIFICATION_STREAM).catch(error => this.logger.error(error));
+    async handleNotificationStream(notificationHandler, onMissedNotifications) {
+        const { notifications, missedNotification } = await this.getAllNotifications();
+        if (missedNotification) {
+            onMissedNotifications(missedNotification);
+        }
+        for (const [index, notification] of notifications.entries()) {
+            await notificationHandler(notification, conversation_1.PayloadBundleSource.NOTIFICATION_STREAM, {
+                done: index + 1,
+                total: notifications.length,
+            }).catch(error => this.logger.error(error));
+        }
+    }
+    handleNotification(notification, source) {
+        return __asyncGenerator(this, arguments, function* handleNotification_1() {
+            for (const event of notification.payload) {
+                this.logger.log(`Handling event of type "${event.type}" for notification with ID "${notification.id}"`, event);
+                try {
+                    const data = yield __await(this.handleEvent(event, source));
+                    if (!notification.transient) {
+                        // keep track of the last handled notification for next time we fetch the notification stream
+                        yield __await(this.setLastNotificationId(notification));
+                    }
+                    yield yield __await(Object.assign(Object.assign({}, data), { mappedEvent: data.mappedEvent ? this.cleanupPayloadBundle(data.mappedEvent) : undefined }));
+                }
+                catch (error) {
+                    this.logger.error(`There was an error with notification ID "${notification.id}": ${error.message}`, error);
+                    const notificationError = {
+                        error: error,
+                        notification,
+                        type: CoreError_1.CoreError.NOTIFICATION_ERROR,
+                    };
+                    this.emit(NotificationService.TOPIC.NOTIFICATION_ERROR, notificationError);
+                }
+            }
+            if (!notification.transient) {
+                // keep track of the last handled notification for next time we fetch the notification stream
+                yield __await(this.setLastNotificationId(notification));
+            }
+        });
+    }
+    cleanupPayloadBundle(payload) {
+        switch (payload.type) {
+            case conversation_1.PayloadBundleType.ASSET: {
+                const assetContent = payload.content;
+                const isMetaData = !!(assetContent === null || assetContent === void 0 ? void 0 : assetContent.original) && !(assetContent === null || assetContent === void 0 ? void 0 : assetContent.uploaded);
+                const isAbort = !!assetContent.abortReason || (!assetContent.original && !assetContent.uploaded);
+                if (isMetaData) {
+                    payload.type = conversation_1.PayloadBundleType.ASSET_META;
+                }
+                else if (isAbort) {
+                    payload.type = conversation_1.PayloadBundleType.ASSET_ABORT;
+                }
+                return payload;
+            }
+            default:
+                return payload;
         }
     }
     async handleEvent(event, source) {
         switch (event.type) {
             // Encrypted events
             case Events.CONVERSATION_EVENT.OTR_MESSAGE_ADD: {
-                return this.cryptographyService.decodeGenericMessage(event, source);
+                try {
+                    const decryptedData = await this.cryptographyService.decryptMessage(event);
+                    return {
+                        mappedEvent: this.cryptographyService.mapGenericMessage(event, decryptedData, source),
+                        event,
+                        decryptedData,
+                    };
+                }
+                catch (error) {
+                    return { event, decryptionError: error };
+                }
             }
             // Meta events
             case Events.CONVERSATION_EVENT.MEMBER_JOIN:
@@ -199,16 +199,17 @@ class NotificationService extends events_1.EventEmitter {
             case Events.CONVERSATION_EVENT.TYPING: {
                 const { conversation, from } = event;
                 const metaEvent = Object.assign(Object.assign({}, event), { conversation, from });
-                return ConversationMapper_1.ConversationMapper.mapConversationEvent(metaEvent, source);
+                return { mappedEvent: ConversationMapper_1.ConversationMapper.mapConversationEvent(metaEvent, source), event };
             }
             // User events
             case Events.USER_EVENT.CONNECTION:
             case Events.USER_EVENT.CLIENT_ADD:
             case Events.USER_EVENT.UPDATE:
             case Events.USER_EVENT.CLIENT_REMOVE: {
-                return UserMapper_1.UserMapper.mapUserEvent(event, this.apiClient.context.userId, source);
+                return { mappedEvent: UserMapper_1.UserMapper.mapUserEvent(event, this.apiClient.context.userId, source), event };
             }
         }
+        return { event };
     }
 }
 exports.NotificationService = NotificationService;

package/src/main/user/UserMapper.d.ts

@@ -1,5 +1,5 @@
 import { UserEvent } from '@wireapp/api-client/src/event';
 import { PayloadBundle, PayloadBundleSource } from '../conversation';
 export declare class UserMapper {
-    static mapUserEvent(event: UserEvent, selfUserId: string, source: PayloadBundleSource): PayloadBundle | void;
+    static mapUserEvent(event: UserEvent, selfUserId: string, source: PayloadBundleSource): PayloadBundle | undefined;
 }

package/src/main/user/UserMapper.js

@@ -81,6 +81,7 @@ class UserMapper {
                 };
             }
         }
+        return undefined;
     }
 }
 exports.UserMapper = UserMapper;