@wireapp/core 32.0.6 → 32.0.8

package/package.json

@@ -43,13 +43,14 @@
     "jest": "29.0.3",
     "jest-babel": "1.0.1",
     "jest-jasmine2": "29.0.3",
+    "jest-websocket-mock": "2.4.0",
     "karma": "6.4.1",
     "karma-chrome-launcher": "3.1.1",
     "karma-jasmine": "4.0.2",
     "karma-jasmine-diff-reporter": "2.0.1",
     "karma-sourcemap-loader": "0.3.8",
     "karma-spec-reporter": "0.0.34",
-    "mock-socket": "9.0.3",
+    "mock-socket": "9.1.5",
     "nock": "13.1.1",
     "nyc": "15.1.0",
     "rimraf": "3.0.2",
@@ -81,6 +82,6 @@
     "test": "jest",
     "watch": "tsc ---watch"
   },
-  "version": "32.0.6",
-  "gitHead": "b7e78c5c3923cd10386056cdeff94c74a56030a2"
+  "version": "32.0.8",
+  "gitHead": "9b39965aa991efec2376de9b40118be153d803f6"
 }

package/src/main/Account.d.ts

@@ -211,7 +211,7 @@ export declare class Account<T = any> extends EventEmitter {
          * When set will not decrypt and not store the last notification ID. This is useful if you only want to subscribe to unencrypted backend events
          */
         dryRun?: boolean;
-    }): Promise<() => void>;
+    }): () => void;
     private generateDbName;
     private generateSecretsDbName;
     private initEngine;

package/src/main/Account.js

@@ -377,7 +377,7 @@ class Account extends events_1.EventEmitter {
      * @param callbacks callbacks that will be called to handle different events
      * @returns close a function that will disconnect from the websocket
      */
-    async listen({ onEvent = () => { }, onConnectionStateChanged = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, dryRun = false, } = {}) {
+    listen({ onEvent = () => { }, onConnectionStateChanged = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, dryRun = false, } = {}) {
         if (!this.apiClient.context) {
             throw new Error('Context is not set - please login first');
         }
@@ -432,19 +432,24 @@ class Account extends events_1.EventEmitter {
         });
         const processNotificationStream = async (abortHandler) => {
             // Lock websocket in order to buffer any message that arrives while we handle the notification stream
-            onConnectionStateChanged(ConnectionState.PROCESSING_NOTIFICATIONS);
             this.apiClient.transport.ws.lock();
-            await this.service.notification.handleNotificationStream(async (notification, source, progress) => {
+            onConnectionStateChanged(ConnectionState.PROCESSING_NOTIFICATIONS);
+            const results = await this.service.notification.processNotificationStream(async (notification, source, progress) => {
                 await handleNotification(notification, source);
                 onNotificationStreamProgress(progress);
             }, onMissedNotifications, abortHandler);
+            this.logger.log(`Finished processing notifications ${JSON.stringify(results)}`, results);
+            if (abortHandler.isAborted()) {
+                this.logger.warn('Ending connection process as websocket was closed');
+                return;
+            }
+            onConnectionStateChanged(ConnectionState.LIVE);
             // We can now unlock the websocket and let the new messages being handled and decrypted
             this.apiClient.transport.ws.unlock();
             // We need to wait for the notification stream to be fully handled before releasing the message sending queue.
             // This is due to the nature of how message are encrypted, any change in mls epoch needs to happen before we start encrypting any kind of messages
-            this.logger.log(`resume message sending. ${(0, messageSender_1.getQueueLength)()} messages to be sent`);
+            this.logger.info(`Resuming message sending. ${(0, messageSender_1.getQueueLength)()} messages to be sent`);
             (0, messageSender_1.resumeMessageSending)();
-            onConnectionStateChanged(ConnectionState.LIVE);
         };
         this.apiClient.connect(processNotificationStream);
         return () => {

package/src/main/cryptography/CryptographyService.js

@@ -38,7 +38,7 @@ class CryptographyService {
         this.config = config;
         this.cryptobox = new cryptobox_1.Cryptobox(this.storeEngine, config.nbPrekeys);
         this.database = new CryptographyDatabaseRepository_1.CryptographyDatabaseRepository(this.storeEngine);
-        this.logger = (0, logdown_1.default)('@wireapp/core/cryptography/CryptographyService', {
+        this.logger = (0, logdown_1.default)('@wireapp/core/CryptographyService', {
             logger: console,
             markdown: false,
         });

package/src/main/cryptography/GenericMessageMapper.js

@@ -153,7 +153,7 @@ class GenericMessageMapper {
     }
 }
 exports.GenericMessageMapper = GenericMessageMapper;
-GenericMessageMapper.logger = (0, logdown_1.default)('@wireapp/core/cryptography/GenericMessageMapper', {
+GenericMessageMapper.logger = (0, logdown_1.default)('@wireapp/core/GenericMessageMapper', {
     logger: console,
     markdown: false,
 });

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

@@ -46,7 +46,11 @@ export declare class NotificationService extends EventEmitter {
     getNotificationEventList(): Promise<Events.BackendEvent[]>;
     setLastEventDate(eventDate: Date): Promise<Date>;
     setLastNotificationId(lastNotification: Notification): Promise<string>;
-    handleNotificationStream(notificationHandler: NotificationHandler, onMissedNotifications: (notificationId: string) => void, abortHandler: AbortHandler): Promise<void>;
+    processNotificationStream(notificationHandler: NotificationHandler, onMissedNotifications: (notificationId: string) => void, abortHandler: AbortHandler): Promise<{
+        total: number;
+        error: number;
+        success: number;
+    }>;
     /**
      * Checks if an event should be ignored.
      * An event that has a date prior to that last event that we have parsed should be ignored

package/src/main/notification/NotificationService.js

@@ -84,7 +84,7 @@ class NotificationService extends events_1.EventEmitter {
     constructor(apiClient, cryptographyService, mlsService, storeEngine) {
         super();
         this.mlsService = mlsService;
-        this.logger = (0, logdown_1.default)('@wireapp/core/notification/NotificationService', {
+        this.logger = (0, logdown_1.default)('@wireapp/core/NotificationService', {
             logger: console,
             markdown: false,
         });
@@ -93,10 +93,9 @@ class NotificationService extends events_1.EventEmitter {
         this.backend = new NotificationBackendRepository_1.NotificationBackendRepository(this.apiClient);
         this.database = new NotificationDatabaseRepository_1.NotificationDatabaseRepository(storeEngine);
     }
-    async getAllNotifications() {
+    async getAllNotifications(since) {
         const clientId = this.apiClient.clientId;
-        const lastNotificationId = await this.database.getLastNotificationId();
-        return this.backend.getAllNotifications(clientId, lastNotificationId);
+        return this.backend.getAllNotifications(clientId, since);
     }
     /** Should only be called with a completely new client. */
     async initializeNotificationStream() {
@@ -132,23 +131,39 @@ class NotificationService extends events_1.EventEmitter {
     async setLastNotificationId(lastNotification) {
         return this.database.updateLastNotificationId(lastNotification);
     }
-    async handleNotificationStream(notificationHandler, onMissedNotifications, abortHandler) {
-        const { notifications, missedNotification } = await this.getAllNotifications();
+    async processNotificationStream(notificationHandler, onMissedNotifications, abortHandler) {
+        const lastNotificationId = await this.database.getLastNotificationId();
+        const { notifications, missedNotification } = await this.getAllNotifications(lastNotificationId);
         if (missedNotification) {
             onMissedNotifications(missedNotification);
         }
+        const results = { total: notifications.length, error: 0, success: 0 };
+        const logMessage = notifications.length > 0
+            ? `Start processing ${notifications.length} notifications since notification id ${lastNotificationId}`
+            : `No notification to process from the stream`;
+        this.logger.log(logMessage);
         for (const [index, notification] of notifications.entries()) {
             if (abortHandler.isAborted()) {
                 /* Stop handling notifications if the websocket has been disconnected.
                  * Upon reconnecting we are going to restart handling the notification stream for where we left of
                  */
-                return;
+                this.logger.warn(`Stop processing notifications as connection to websocket was closed`);
+                return results;
+            }
+            try {
+                await notificationHandler(notification, conversation_1.PayloadBundleSource.NOTIFICATION_STREAM, {
+                    done: index + 1,
+                    total: notifications.length,
+                });
+                results.success++;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : error;
+                this.logger.error(`Error while processing notification ${notification.id}: ${message}`, error);
+                results.error++;
             }
-            await notificationHandler(notification, conversation_1.PayloadBundleSource.NOTIFICATION_STREAM, {
-                done: index + 1,
-                total: notifications.length,
-            }).catch(error => this.logger.error(error));
         }
+        return results;
     }
     /**
      * Checks if an event should be ignored.

package/src/main/util/TaskScheduler/TaskScheduler.js

@@ -23,7 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskScheduler = void 0;
 const logdown_1 = __importDefault(require("logdown"));
-const logger = (0, logdown_1.default)('@wireapp/core/util/TaskScheduler/TaskScheduler', {
+const logger = (0, logdown_1.default)('@wireapp/core/TaskScheduler', {
     logger: console,
     markdown: false,
 });