@wireapp/core 30.5.1 → 30.5.2

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

@@ -1,131 +0,0 @@
-/// <reference types="node" />
-import type { APIClient } from '@wireapp/api-client';
-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 { PayloadBundle, PayloadBundleSource } from '../conversation';
-import { NotificationError } from '../CoreError';
-import type { CryptographyService } from '../cryptography';
-import { GenericMessage } from '@wireapp/protocol-messaging';
-import { AbortHandler } from '@wireapp/api-client/src/tcp';
-import { QualifiedId } from '@wireapp/api-client/src/user';
-import { Conversation } from '@wireapp/api-client/src/conversation';
-import { CommitPendingProposalsParams, LastKeyMaterialUpdateParams } from './types';
-import type { MLSService } from '../mls';
-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, progress: {
-    done: number;
-    total: number;
-}) => Promise<void>;
-export interface NotificationService {
-    on(event: TOPIC.NOTIFICATION_ERROR, listener: (payload: NotificationError) => void): this;
-}
-export declare class NotificationService extends EventEmitter {
-    private readonly mlsService;
-    private readonly apiClient;
-    private readonly backend;
-    private readonly cryptographyService;
-    private readonly database;
-    private readonly logger;
-    static readonly TOPIC: typeof TOPIC;
-    constructor(apiClient: APIClient, cryptographyService: CryptographyService, mlsService: MLSService, storeEngine: CRUDEngine);
-    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, onMissedNotifications: (notificationId: string) => void, abortHandler: AbortHandler): Promise<void>;
-    /**
-     * 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
-     *
-     * @param event
-     * @param source
-     * @param lastEventDate?
-     */
-    private isOutdatedEvent;
-    handleNotification(notification: Notification, source: PayloadBundleSource, dryRun?: boolean): AsyncGenerator<HandledEventPayload>;
-    private cleanupPayloadBundle;
-    private handleEvent;
-    /**
-     * ## MLS only ##
-     * If there is a groupId in the conversation, we need to store the conversationId => groupId pair
-     * in order to find the groupId when decrypting messages
-     * This is a bit hacky but since mls messages do not embed the groupId we need to keep a mapping of those
-     *
-     * @param conversation conversation with group_id
-     */
-    saveConversationGroupId(conversation: Conversation): Promise<void>;
-    /**
-     * ## MLS only ##
-     * If there is a matching conversationId => groupId pair in the database,
-     * we can find the groupId and return it as a Uint8Array
-     *
-     * @param conversationQualifiedId
-     */
-    getUint8ArrayFromConversationGroupId(conversationQualifiedId: QualifiedId): Promise<Uint8Array>;
-    /**
-     * ## MLS only ##
-     * If there are pending proposals, we need to either process them,
-     * or save them in the database for later processing
-     *
-     * @param groupId groupId of the mls conversation
-     * @param delayInMs delay in ms before processing proposals
-     * @param eventTime time of the event that had the proposals
-     */
-    private handlePendingProposals;
-    /**
-     * ## MLS only ##
-     * Commit all pending proposals for a given groupId
-     *
-     * @param groupId groupId of the conversation
-     * @param skipDelete if true, do not delete the pending proposals from the database
-     */
-    commitPendingProposals({ groupId, skipDelete }: CommitPendingProposalsParams): Promise<void>;
-    /**
-     * ## MLS only ##
-     * Get all pending proposals from the database and schedule them
-     * Function must only be called once, after application start
-     *
-     */
-    checkExistingPendingProposals(): Promise<void>;
-    /**
-     * ## MLS only ##
-     * Store groupIds with last key material update dates.
-     *
-     * @param {groupId} params.groupId - groupId of the mls conversation
-     * @param {previousUpdateDate} params.previousUpdateDate - date of the previous key material update
-     */
-    storeLastKeyMaterialUpdateDate(params: LastKeyMaterialUpdateParams): Promise<void>;
-    /**
-     * ## MLS only ##
-     * Renew key material for a given groupId
-     *
-     * @param groupId groupId of the conversation
-     */
-    private renewKeyMaterial;
-    private createKeyMaterialUpdateTaskSchedulerId;
-    private scheduleTaskToRenewKeyMaterial;
-    /**
-     * ## MLS only ##
-     * Get all pending proposals from the database and schedule them
-     * Function must only be called once, after application start
-     *
-     */
-    checkForKeyMaterialsUpdate(): Promise<void>;
-}
-export {};

package/src/main/notification/NotificationService.js

@@ -1,468 +0,0 @@
-"use strict";
-/*
- * Wire
- * Copyright (C) 2018 Wire Swiss GmbH
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/.
- *
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __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 };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotificationService = void 0;
-const commons_1 = require("@wireapp/commons");
-const Events = __importStar(require("@wireapp/api-client/src/event"));
-const store_engine_1 = require("@wireapp/store-engine");
-const events_1 = require("events");
-const logdown_1 = __importDefault(require("logdown"));
-const conversation_1 = require("../conversation");
-const ConversationMapper_1 = require("../conversation/ConversationMapper");
-const CoreError_1 = require("../CoreError");
-const UserMapper_1 = require("../user/UserMapper");
-const NotificationBackendRepository_1 = require("./NotificationBackendRepository");
-const NotificationDatabaseRepository_1 = require("./NotificationDatabaseRepository");
-const protocol_messaging_1 = require("@wireapp/protocol-messaging");
-const bazinga64_1 = require("bazinga64");
-const TaskScheduler_1 = require("../util/TaskScheduler/TaskScheduler");
-const LowPrecisionTaskScheduler_1 = require("../util/LowPrecisionTaskScheduler/LowPrecisionTaskScheduler");
-var TOPIC;
-(function (TOPIC) {
-    TOPIC["NOTIFICATION_ERROR"] = "NotificationService.TOPIC.NOTIFICATION_ERROR";
-})(TOPIC || (TOPIC = {}));
-const DEFAULT_KEYING_MATERIAL_UPDATE_THRESHOLD = 1000 * 60 * 60 * 24 * 30; //30 days
-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', {
-            logger: console,
-            markdown: false,
-        });
-        this.apiClient = apiClient;
-        this.cryptographyService = cryptographyService;
-        this.backend = new NotificationBackendRepository_1.NotificationBackendRepository(this.apiClient);
-        this.database = new NotificationDatabaseRepository_1.NotificationDatabaseRepository(storeEngine);
-    }
-    async getAllNotifications() {
-        const clientId = this.apiClient.clientId;
-        const lastNotificationId = await this.database.getLastNotificationId();
-        return this.backend.getAllNotifications(clientId, lastNotificationId);
-    }
-    /** Should only be called with a completely new client. */
-    async initializeNotificationStream() {
-        const clientId = this.apiClient.clientId;
-        await this.setLastEventDate(new Date(0));
-        const latestNotification = await this.backend.getLastNotification(clientId);
-        return this.setLastNotificationId(latestNotification);
-    }
-    async hasHistory() {
-        const notificationEvents = await this.getNotificationEventList();
-        return !!notificationEvents.length;
-    }
-    getNotificationEventList() {
-        return this.database.getNotificationEventList();
-    }
-    async setLastEventDate(eventDate) {
-        let databaseLastEventDate;
-        try {
-            databaseLastEventDate = await this.database.getLastEventDate();
-        }
-        catch (error) {
-            if (error instanceof store_engine_1.error.RecordNotFoundError ||
-                error.constructor.name === store_engine_1.error.RecordNotFoundError.name) {
-                return this.database.createLastEventDate(eventDate);
-            }
-            throw error;
-        }
-        if (databaseLastEventDate && eventDate > databaseLastEventDate) {
-            return this.database.updateLastEventDate(eventDate);
-        }
-        return databaseLastEventDate;
-    }
-    async setLastNotificationId(lastNotification) {
-        return this.database.updateLastNotificationId(lastNotification);
-    }
-    async handleNotificationStream(notificationHandler, onMissedNotifications, abortHandler) {
-        const { notifications, missedNotification } = await this.getAllNotifications();
-        if (missedNotification) {
-            onMissedNotifications(missedNotification);
-        }
-        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;
-            }
-            await notificationHandler(notification, conversation_1.PayloadBundleSource.NOTIFICATION_STREAM, {
-                done: index + 1,
-                total: notifications.length,
-            }).catch(error => this.logger.error(error));
-        }
-    }
-    /**
-     * 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
-     *
-     * @param event
-     * @param source
-     * @param lastEventDate?
-     */
-    isOutdatedEvent(event, source, lastEventDate) {
-        const isFromNotificationStream = source === conversation_1.PayloadBundleSource.NOTIFICATION_STREAM;
-        const shouldCheckEventDate = !!event.time && isFromNotificationStream && lastEventDate;
-        if (shouldCheckEventDate) {
-            /** This check prevents duplicated "You joined" system messages. */
-            const isOutdated = lastEventDate.getTime() >= new Date(event.time).getTime();
-            return isOutdated;
-        }
-        return false;
-    }
-    handleNotification(notification, source, dryRun = false) {
-        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);
-                let lastEventDate = undefined;
-                try {
-                    lastEventDate = yield __await(this.database.getLastEventDate());
-                }
-                catch (_a) { }
-                if ('time' in event && this.isOutdatedEvent(event, source, lastEventDate)) {
-                    this.logger.info(`Ignored outdated event type: '${event.type}'`);
-                    continue;
-                }
-                try {
-                    const data = yield __await(this.handleEvent(event, source, dryRun));
-                    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 (!dryRun && !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, dryRun = false) {
-        var _a, _b;
-        switch (event.type) {
-            case Events.CONVERSATION_EVENT.MLS_WELCOME_MESSAGE:
-                const data = bazinga64_1.Decoder.fromBase64(event.data).asBytes;
-                // We extract the groupId from the welcome message and let coreCrypto store this group
-                const newGroupId = await this.mlsService.processWelcomeMessage(data);
-                const groupIdStr = bazinga64_1.Encoder.toBase64(newGroupId).asString;
-                // The groupId can then be sent back to the consumer
-                return {
-                    event,
-                    mappedEvent: ConversationMapper_1.ConversationMapper.mapConversationEvent(Object.assign(Object.assign({}, event), { data: groupIdStr }), source),
-                };
-            case Events.CONVERSATION_EVENT.MLS_MESSAGE_ADD:
-                const encryptedData = bazinga64_1.Decoder.fromBase64(event.data).asBytes;
-                const groupId = await this.getUint8ArrayFromConversationGroupId((_a = event.qualified_conversation) !== null && _a !== void 0 ? _a : { id: event.conversation, domain: '' });
-                // Check if the message includes proposals
-                const { proposals, commitDelay, message } = await this.mlsService.decryptMessage(groupId, encryptedData);
-                if (proposals.length > 0) {
-                    await this.handlePendingProposals({
-                        groupId: groupId.toString(),
-                        delayInMs: commitDelay !== null && commitDelay !== void 0 ? commitDelay : 0,
-                        eventTime: event.time,
-                    });
-                }
-                if (!message) {
-                    throw new Error(`MLS message received from ${source} was empty`);
-                }
-                const decryptedData = protocol_messaging_1.GenericMessage.decode(message);
-                /**
-                 * @todo Find a proper solution to add mappedEvent to this return
-                 * otherwise event.data will be base64 raw data of the received event
-                 */
-                return { event, decryptedData };
-            // Encrypted Proteus events
-            case Events.CONVERSATION_EVENT.OTR_MESSAGE_ADD: {
-                if (dryRun) {
-                    // In case of a dry run, we do not want to decrypt messages
-                    // We just return the raw event to the caller
-                    return { event };
-                }
-                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:
-                // As of today (07/07/2022) the backend sends `WELCOME` message to the user's own conversation (not the actual conversation that the welcome should be part of)
-                // So in order to map conversation Ids and groupId together, we need to first fetch the conversation and get the groupId linked to it.
-                const conversation = await this.apiClient.api.conversation.getConversation((_b = event.qualified_conversation) !== null && _b !== void 0 ? _b : { id: event.conversation, domain: '' });
-                if (!conversation) {
-                    throw new Error('no conv');
-                }
-                await this.saveConversationGroupId(conversation);
-            case Events.CONVERSATION_EVENT.MESSAGE_TIMER_UPDATE:
-            case Events.CONVERSATION_EVENT.RENAME:
-            case Events.CONVERSATION_EVENT.TYPING: {
-                const { conversation, from } = event;
-                const metaEvent = Object.assign(Object.assign({}, event), { conversation, from });
-                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 { mappedEvent: UserMapper_1.UserMapper.mapUserEvent(event, this.apiClient.context.userId, source), event };
-            }
-        }
-        return { event };
-    }
-    /**
-     * ## MLS only ##
-     * If there is a groupId in the conversation, we need to store the conversationId => groupId pair
-     * in order to find the groupId when decrypting messages
-     * This is a bit hacky but since mls messages do not embed the groupId we need to keep a mapping of those
-     *
-     * @param conversation conversation with group_id
-     */
-    async saveConversationGroupId(conversation) {
-        if (conversation.group_id) {
-            const { group_id: groupId, qualified_id: { id: conversationId, domain: conversationDomain }, } = conversation;
-            await this.database.addCompoundGroupId({ conversationDomain, conversationId, groupId });
-        }
-    }
-    /**
-     * ## MLS only ##
-     * If there is a matching conversationId => groupId pair in the database,
-     * we can find the groupId and return it as a Uint8Array
-     *
-     * @param conversationQualifiedId
-     */
-    async getUint8ArrayFromConversationGroupId(conversationQualifiedId) {
-        const { id: conversationId, domain: conversationDomain } = conversationQualifiedId;
-        const groupId = await this.database.getCompoundGroupId({
-            conversationId,
-            conversationDomain,
-        });
-        if (!groupId) {
-            throw new Error(`Could not find a group_id for conversation ${conversationId}@${conversationDomain}`);
-        }
-        return bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-    }
-    /**
-     * ## MLS only ##
-     * If there are pending proposals, we need to either process them,
-     * or save them in the database for later processing
-     *
-     * @param groupId groupId of the mls conversation
-     * @param delayInMs delay in ms before processing proposals
-     * @param eventTime time of the event that had the proposals
-     */
-    async handlePendingProposals({ delayInMs, groupId, eventTime }) {
-        if (delayInMs > 0) {
-            const eventDate = new Date(eventTime);
-            const firingDate = eventDate.setTime(eventDate.getTime() + delayInMs);
-            try {
-                await this.database.storePendingProposal({
-                    groupId,
-                    firingDate,
-                });
-            }
-            catch (error) {
-                this.logger.error('Could not store pending proposal', error);
-            }
-            finally {
-                TaskScheduler_1.TaskScheduler.addTask({
-                    task: () => this.commitPendingProposals({ groupId }),
-                    firingDate,
-                    key: groupId,
-                });
-            }
-        }
-        else {
-            await this.commitPendingProposals({ groupId, skipDelete: true });
-        }
-    }
-    /**
-     * ## MLS only ##
-     * Commit all pending proposals for a given groupId
-     *
-     * @param groupId groupId of the conversation
-     * @param skipDelete if true, do not delete the pending proposals from the database
-     */
-    async commitPendingProposals({ groupId, skipDelete = false }) {
-        try {
-            await this.mlsService.commitPendingProposals(bazinga64_1.Decoder.fromBase64(groupId).asBytes);
-            if (!skipDelete) {
-                TaskScheduler_1.TaskScheduler.cancelTask(groupId);
-                await this.database.deletePendingProposal({ groupId });
-            }
-        }
-        catch (error) {
-            this.logger.error(`Error while committing pending proposals for groupId ${groupId}`, error);
-        }
-    }
-    /**
-     * ## MLS only ##
-     * Get all pending proposals from the database and schedule them
-     * Function must only be called once, after application start
-     *
-     */
-    async checkExistingPendingProposals() {
-        try {
-            const pendingProposals = await this.database.getStoredPendingProposals();
-            if (pendingProposals.length > 0) {
-                pendingProposals.forEach(({ groupId, firingDate }) => TaskScheduler_1.TaskScheduler.addTask({
-                    task: () => this.commitPendingProposals({ groupId }),
-                    firingDate,
-                    key: groupId,
-                }));
-            }
-        }
-        catch (error) {
-            this.logger.error('Could not get pending proposals', error);
-        }
-    }
-    /**
-     * ## MLS only ##
-     * Store groupIds with last key material update dates.
-     *
-     * @param {groupId} params.groupId - groupId of the mls conversation
-     * @param {previousUpdateDate} params.previousUpdateDate - date of the previous key material update
-     */
-    async storeLastKeyMaterialUpdateDate(params) {
-        await this.database.storeLastKeyMaterialUpdateDate(params);
-        await this.scheduleTaskToRenewKeyMaterial(params);
-    }
-    /**
-     * ## MLS only ##
-     * Renew key material for a given groupId
-     *
-     * @param groupId groupId of the conversation
-     */
-    async renewKeyMaterial({ groupId }) {
-        try {
-            const groupConversationExists = await this.mlsService.conversationExists(bazinga64_1.Decoder.fromBase64(groupId).asBytes);
-            if (!groupConversationExists) {
-                await this.database.deleteLastKeyMaterialUpdateDate({ groupId });
-                return;
-            }
-            const groupIdDecodedFromBase64 = bazinga64_1.Decoder.fromBase64(groupId).asBytes;
-            await this.mlsService.updateKeyingMaterial(groupIdDecodedFromBase64);
-            const keyRenewalTime = new Date().getTime();
-            const keyMaterialUpdateDate = { groupId, previousUpdateDate: keyRenewalTime };
-            await this.storeLastKeyMaterialUpdateDate(keyMaterialUpdateDate);
-        }
-        catch (error) {
-            this.logger.error(`Error while renewing key material for groupId ${groupId}`, error);
-        }
-    }
-    createKeyMaterialUpdateTaskSchedulerId(groupId) {
-        return `renew-key-material-update-${groupId}`;
-    }
-    async scheduleTaskToRenewKeyMaterial({ groupId, previousUpdateDate }) {
-        var _a;
-        //given period of time (30 days by default) after last update date renew key material
-        const keyingMaterialUpdateThreshold = ((_a = this.mlsService.config) === null || _a === void 0 ? void 0 : _a.keyingMaterialUpdateThreshold) || DEFAULT_KEYING_MATERIAL_UPDATE_THRESHOLD;
-        const firingDate = previousUpdateDate + keyingMaterialUpdateThreshold;
-        const key = this.createKeyMaterialUpdateTaskSchedulerId(groupId);
-        LowPrecisionTaskScheduler_1.LowPrecisionTaskScheduler.addTask({
-            task: () => this.renewKeyMaterial({ groupId }),
-            intervalDelay: commons_1.TimeUtil.TimeInMillis.MINUTE,
-            firingDate,
-            key,
-        });
-    }
-    /**
-     * ## MLS only ##
-     * Get all pending proposals from the database and schedule them
-     * Function must only be called once, after application start
-     *
-     */
-    async checkForKeyMaterialsUpdate() {
-        try {
-            const keyMaterialUpdateDates = await this.database.getStoredLastKeyMaterialUpdateDates();
-            keyMaterialUpdateDates.forEach(date => this.scheduleTaskToRenewKeyMaterial(date));
-        }
-        catch (error) {
-            this.logger.error('Could not get last key material update dates', error);
-        }
-    }
-}
-exports.NotificationService = NotificationService;
-NotificationService.TOPIC = TOPIC;
-//# sourceMappingURL=NotificationService.js.map

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

@@ -1 +0,0 @@
-export * from './NotificationService';

package/src/main/notification/index.js

@@ -1,32 +0,0 @@
-"use strict";
-/*
- * Wire
- * Copyright (C) 2018 Wire Swiss GmbH
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/.
- *
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./NotificationService"), exports);
-//# sourceMappingURL=index.js.map

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

@@ -1,20 +0,0 @@
-export declare type CommonMLS = {
-    groupId: string;
-};
-export declare type CompoundGroupIdParams = {
-    conversationId: string;
-    conversationDomain: string;
-} & CommonMLS;
-export declare type HandlePendingProposalsParams = {
-    delayInMs: number;
-    eventTime: string;
-} & CommonMLS;
-export declare type CommitPendingProposalsParams = {
-    skipDelete?: boolean;
-} & CommonMLS;
-export declare type StorePendingProposalsParams = {
-    firingDate: number;
-} & CommonMLS;
-export declare type LastKeyMaterialUpdateParams = {
-    previousUpdateDate: number;
-} & CommonMLS;

package/src/main/notification/types.js

@@ -1,21 +0,0 @@
-"use strict";
-/*
- * Wire
- * Copyright (C) 2022 Wire Swiss GmbH
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/.
- *
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map