@wireapp/core 31.1.3 → 31.2.0

package/src/main/mls/MLSService/MLSService.js

@@ -0,0 +1,181 @@
+"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/.
+ *
+ */
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MLSService = exports.optionalToUint8Array = void 0;
+const bazinga64_1 = require("bazinga64");
+const messageSender_1 = require("../../conversation/message/messageSender");
+const fullyQualifiedClientIdUtils_1 = require("../../util/fullyQualifiedClientIdUtils");
+//@todo: this function is temporary, we wait for the update from core-crypto side
+//they are returning regular array instead of Uint8Array for commit and welcome messages
+const optionalToUint8Array = (array) => {
+    return Array.isArray(array) ? Uint8Array.from(array) : array;
+};
+exports.optionalToUint8Array = optionalToUint8Array;
+class MLSService {
+    constructor(config, apiClient, coreCryptoClientProvider) {
+        this.config = config;
+        this.apiClient = apiClient;
+        this.coreCryptoClientProvider = coreCryptoClientProvider;
+    }
+    getCoreCryptoClient() {
+        const client = this.coreCryptoClientProvider();
+        if (!client) {
+            throw new Error('Could not get coreCryptoClient');
+        }
+        return client;
+    }
+    async uploadCommitBundle(groupId, { commit, welcome }) {
+        const coreCryptoClient = this.getCoreCryptoClient();
+        if (commit) {
+            try {
+                const messageResponse = await this.apiClient.api.conversation.postMlsMessage(
+                //@todo: it's temporary - we wait for core-crypto fix to return the actual Uint8Array instead of regular array
+                (0, exports.optionalToUint8Array)(commit));
+                await coreCryptoClient.commitAccepted(groupId);
+                if (welcome) {
+                    // If the commit went well, we can send the Welcome
+                    //@todo: it's temporary - we wait for core-crypto fix to return the actual Uint8Array instead of regular array
+                    await this.apiClient.api.conversation.postMlsWelcomeMessage((0, exports.optionalToUint8Array)(welcome));
+                }
+                return messageResponse;
+            }
+            catch (error) {
+                await coreCryptoClient.clearPendingCommit(groupId);
+            }
+        }
+        return null;
+    }
+    addUsersToExistingConversation(groupId, invitee) {
+        return (0, messageSender_1.sendMessage)(async () => {
+            const coreCryptoClient = this.getCoreCryptoClient();
+            const memberAddedMessages = await coreCryptoClient.addClientsToConversation(groupId, invitee);
+            return this.uploadCommitBundle(groupId, memberAddedMessages);
+        });
+    }
+    configureMLSCallbacks(_a) {
+        var { groupIdFromConversationId } = _a, coreCryptoCallbacks = __rest(_a, ["groupIdFromConversationId"]);
+        this.getCoreCryptoClient().registerCallbacks(Object.assign(Object.assign({}, coreCryptoCallbacks), { clientIdBelongsToOneOf: (client, otherClients) => {
+                const decoder = new TextDecoder();
+                const { user } = (0, fullyQualifiedClientIdUtils_1.parseFullQualifiedClientId)(decoder.decode(client));
+                return otherClients.some(client => {
+                    const { user: otherUser } = (0, fullyQualifiedClientIdUtils_1.parseFullQualifiedClientId)(decoder.decode(client));
+                    return otherUser === user;
+                });
+            } }));
+        this.groupIdFromConversationId = groupIdFromConversationId;
+    }
+    async getKeyPackagesPayload(qualifiedUsers) {
+        /**
+         * @note We need to fetch key packages for all the users
+         * we want to add to the new MLS conversations,
+         * includes self user too.
+         */
+        const keyPackages = await Promise.all([
+            ...qualifiedUsers.map(({ id, domain, skipOwn }) => this.apiClient.api.client.claimMLSKeyPackages(id, domain, skipOwn)),
+        ]);
+        const coreCryptoKeyPackagesPayload = keyPackages.reduce((previousValue, currentValue) => {
+            // skip users that have not uploaded their MLS key packages
+            if (currentValue.key_packages.length > 0) {
+                return [
+                    ...previousValue,
+                    ...currentValue.key_packages.map(keyPackage => ({
+                        id: bazinga64_1.Encoder.toBase64(keyPackage.client).asBytes,
+                        kp: bazinga64_1.Decoder.fromBase64(keyPackage.key_package).asBytes,
+                    })),
+                ];
+            }
+            return previousValue;
+        }, []);
+        return coreCryptoKeyPackagesPayload;
+    }
+    async newProposal(proposalType, args) {
+        return this.getCoreCryptoClient().newProposal(proposalType, args);
+    }
+    async newExternalProposal(externalProposalType, args) {
+        return this.getCoreCryptoClient().newExternalProposal(externalProposalType, args);
+    }
+    async processWelcomeMessage(welcomeMessage) {
+        return this.getCoreCryptoClient().processWelcomeMessage(welcomeMessage);
+    }
+    async decryptMessage(conversationId, payload) {
+        return this.getCoreCryptoClient().decryptMessage(conversationId, payload);
+    }
+    async encryptMessage(conversationId, message) {
+        return this.getCoreCryptoClient().encryptMessage(conversationId, message);
+    }
+    updateKeyingMaterial(conversationId) {
+        return (0, messageSender_1.sendMessage)(async () => {
+            const commitBundle = await this.getCoreCryptoClient().updateKeyingMaterial(conversationId);
+            return this.uploadCommitBundle(conversationId, commitBundle);
+        });
+    }
+    async createConversation(conversationId, configuration) {
+        return this.getCoreCryptoClient().createConversation(conversationId, configuration);
+    }
+    removeClientsFromConversation(conversationId, clientIds) {
+        return (0, messageSender_1.sendMessage)(async () => {
+            const commitBundle = await this.getCoreCryptoClient().removeClientsFromConversation(conversationId, clientIds);
+            return this.uploadCommitBundle(conversationId, commitBundle);
+        });
+    }
+    async commitPendingProposals(groupId) {
+        const commitBundle = await this.getCoreCryptoClient().commitPendingProposals(groupId);
+        return commitBundle ? void this.uploadCommitBundle(groupId, commitBundle) : undefined;
+    }
+    async conversationExists(conversationId) {
+        return this.getCoreCryptoClient().conversationExists(conversationId);
+    }
+    async clientValidKeypackagesCount() {
+        return this.getCoreCryptoClient().clientValidKeypackagesCount();
+    }
+    async clientKeypackages(amountRequested) {
+        return this.getCoreCryptoClient().clientKeypackages(amountRequested);
+    }
+    /**
+     * Will make the given client mls capable (generate and upload key packages)
+     *
+     * @param mlsClient Intance of the coreCrypto that represents the mls client
+     * @param clientId The id of the client
+     */
+    async uploadMLSPublicKeys(publicKey, clientId) {
+        return this.apiClient.api.client.putClient(clientId, {
+            mls_public_keys: { ed25519: btoa(bazinga64_1.Converter.arrayBufferViewToBaselineString(publicKey)) },
+        });
+    }
+    async uploadMLSKeyPackages(keypackages, clientId) {
+        return this.apiClient.api.client.uploadMLSKeyPackages(clientId, keypackages.map(keypackage => btoa(bazinga64_1.Converter.arrayBufferViewToBaselineString(keypackage))));
+    }
+    async wipeConversation(conversationId) {
+        return this.getCoreCryptoClient().wipeConversation(conversationId);
+    }
+}
+exports.MLSService = MLSService;
+//# sourceMappingURL=MLSService.js.map

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

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

package/src/main/mls/index.js

@@ -0,0 +1,36 @@
+"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/.
+ *
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./MLSService/MLSService"), exports);
+//# sourceMappingURL=index.js.map

package/src/main/mls/keyMaterialUpdatesStore/index.d.ts

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

package/src/main/mls/keyMaterialUpdatesStore/index.js

@@ -0,0 +1,36 @@
+"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/.
+ *
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./keyMaterialUpdatesStore"), exports);
+//# sourceMappingURL=index.js.map

package/src/main/mls/keyMaterialUpdatesStore/keyMaterialUpdatesStore.d.ts

@@ -0,0 +1,9 @@
+import { CommonMLS, LastKeyMaterialUpdateParams } from '../../notification/types';
+export interface KeyMaterialUpdatesStore {
+    [groupId: string]: LastKeyMaterialUpdateParams;
+}
+export declare const keyMaterialUpdatesStore: {
+    getAllUpdateDates: () => LastKeyMaterialUpdateParams[];
+    storeLastKeyMaterialUpdateDate: ({ groupId, previousUpdateDate }: LastKeyMaterialUpdateParams) => void;
+    deleteLastKeyMaterialUpdateDate: ({ groupId }: CommonMLS) => void;
+};

package/src/main/mls/keyMaterialUpdatesStore/keyMaterialUpdatesStore.js

@@ -0,0 +1,51 @@
+"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 });
+exports.keyMaterialUpdatesStore = void 0;
+const storageKey = 'keyMaterialUpdates';
+const getUpdateDatesMap = () => {
+    const storedState = localStorage.getItem(storageKey);
+    if (!storedState) {
+        return {};
+    }
+    return JSON.parse(storedState);
+};
+const getAllUpdateDates = () => {
+    const storedStateMap = getUpdateDatesMap();
+    return Object.values(storedStateMap);
+};
+const storeLastKeyMaterialUpdateDate = ({ groupId, previousUpdateDate }) => {
+    const storedState = getUpdateDatesMap();
+    const newStoredState = Object.assign(Object.assign({}, storedState), { [groupId]: { groupId, previousUpdateDate } });
+    localStorage.setItem(storageKey, JSON.stringify(newStoredState));
+};
+const deleteLastKeyMaterialUpdateDate = ({ groupId }) => {
+    const storedState = getUpdateDatesMap();
+    if (storedState[groupId]) {
+        delete storedState[groupId];
+    }
+    localStorage.setItem(storageKey, JSON.stringify(storedState));
+};
+exports.keyMaterialUpdatesStore = {
+    getAllUpdateDates,
+    storeLastKeyMaterialUpdateDate,
+    deleteLastKeyMaterialUpdateDate,
+};
+//# sourceMappingURL=keyMaterialUpdatesStore.js.map

package/src/main/mls/keyPackagesStatusStore/keyPackagesStatusStore.d.ts

@@ -0,0 +1,7 @@
+export interface KeyPackagesStatusStore {
+    lastQueryDate: number;
+}
+export declare const keyPackagesStatusStore: {
+    getState: () => KeyPackagesStatusStore;
+    saveState: ({ lastQueryDate }: KeyPackagesStatusStore) => void;
+};

package/src/main/mls/keyPackagesStatusStore/keyPackagesStatusStore.js

@@ -0,0 +1,42 @@
+"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 });
+exports.keyPackagesStatusStore = void 0;
+const storageKey = 'keyPackagesStatus';
+const getState = () => {
+    const storedState = localStorage.getItem(storageKey);
+    if (!storedState) {
+        return {
+            lastQueryDate: 0,
+        };
+    }
+    const parsedState = JSON.parse(storedState);
+    return {
+        lastQueryDate: Number(parsedState.lastQueryDate),
+    };
+};
+const saveState = ({ lastQueryDate }) => {
+    localStorage.setItem(storageKey, JSON.stringify({ lastQueryDate }));
+};
+exports.keyPackagesStatusStore = {
+    getState,
+    saveState,
+};
+//# sourceMappingURL=keyPackagesStatusStore.js.map

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

@@ -0,0 +1,33 @@
+import { QualifiedId } from '@wireapp/api-client/src/user';
+import { CoreCryptoCallbacks } from '@wireapp/core-crypto';
+declare type SecretCrypto<T> = {
+    encrypt: (value: Uint8Array) => Promise<T>;
+    decrypt: (payload: T) => Promise<Uint8Array>;
+};
+export interface MLSCallbacks extends Pick<CoreCryptoCallbacks, 'authorize'> {
+    /**
+     * Should return a groupId corresponding to the conversation ID given
+     * Used for the core to know what core-crypto conversation we are dealing with when receiving events
+     * @param conversationId
+     * @returns the bytes of the groupId corresponding to the conversation ID
+     */
+    groupIdFromConversationId: (conversationId: QualifiedId) => Promise<string | undefined>;
+}
+export interface MLSConfig<T = any> {
+    /**
+     * encrypt/decrypt function pair that will be called before storing/fetching secrets in the secrets database.
+     * If not provided will use the built in encryption mechanism
+     */
+    secretsCrypto?: SecretCrypto<T>;
+    /**
+     * path on the public server to the core crypto wasm file.
+     * This file will be downloaded lazily when corecrypto is needed.
+     * It, thus, needs to know where, on the server, the file can be found
+     */
+    coreCrypoWasmFilePath: string;
+    /**
+     * (milliseconds) period of time between automatic updates of the keying material (30 days by default)
+     */
+    keyingMaterialUpdateThreshold?: number;
+}
+export {};

package/src/main/mls/types.js

@@ -0,0 +1,21 @@
+"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

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

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

package/src/main/notification/NotificationBackendRepository.js

@@ -0,0 +1,34 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationBackendRepository = void 0;
+class NotificationBackendRepository {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    async getAllNotifications(clientId, lastNotificationId) {
+        return this.apiClient.api.notification.getAllNotifications(clientId, lastNotificationId);
+    }
+    getLastNotification(clientId) {
+        return this.apiClient.api.notification.getLastNotification(clientId);
+    }
+}
+exports.NotificationBackendRepository = NotificationBackendRepository;
+//# sourceMappingURL=NotificationBackendRepository.js.map

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

@@ -0,0 +1,42 @@
+import { BackendEvent } from '@wireapp/api-client/src/event';
+import { Notification } from '@wireapp/api-client/src/notification/';
+import { CRUDEngine } from '@wireapp/store-engine';
+import { CommonMLS, StorePendingProposalsParams } from './types';
+export declare enum DatabaseStores {
+    EVENTS = "events"
+}
+export declare enum DatabaseKeys {
+    PRIMARY_KEY_LAST_EVENT = "z.storage.StorageKey.EVENT.LAST_DATE",
+    PRIMARY_KEY_LAST_NOTIFICATION = "z.storage.StorageKey.NOTIFICATION.LAST_ID"
+}
+export declare class NotificationDatabaseRepository {
+    private readonly storeEngine;
+    constructor(storeEngine: CRUDEngine);
+    getNotificationEventList(): Promise<BackendEvent[]>;
+    getLastEventDate(): Promise<Date>;
+    updateLastEventDate(eventDate: Date): Promise<Date>;
+    createLastEventDate(eventDate: Date): Promise<Date>;
+    getLastNotificationId(): Promise<string>;
+    updateLastNotificationId(lastNotification: Notification): Promise<string>;
+    /**
+     * ## MLS only ##
+     * Store groupIds with pending proposals and a delay in the DB until the proposals get committed.
+     *
+     * @param groupId groupId of the mls conversation
+     * @param firingDate date when the pending proposals should be committed
+     */
+    storePendingProposal(params: StorePendingProposalsParams): Promise<boolean>;
+    /**
+     * ## MLS only ##
+     * Delete stored entries for pending proposals that have been committed.
+     *
+     * @param groupId groupId of the mls conversation
+     */
+    deletePendingProposal({ groupId }: CommonMLS): Promise<boolean>;
+    /**
+     * ## MLS only ##
+     * Get all stored entries for pending proposals.
+     *
+     */
+    getStoredPendingProposals(): Promise<StorePendingProposalsParams[]>;
+}

package/src/main/notification/NotificationDatabaseRepository.js

@@ -0,0 +1,97 @@
+"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/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationDatabaseRepository = exports.DatabaseKeys = exports.DatabaseStores = void 0;
+const CryptographyDatabaseRepository_1 = require("../cryptography/CryptographyDatabaseRepository");
+var DatabaseStores;
+(function (DatabaseStores) {
+    DatabaseStores["EVENTS"] = "events";
+})(DatabaseStores = exports.DatabaseStores || (exports.DatabaseStores = {}));
+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 = {}));
+const STORES = Object.assign({}, CryptographyDatabaseRepository_1.CryptographyDatabaseRepository.STORES);
+class NotificationDatabaseRepository {
+    constructor(storeEngine) {
+        this.storeEngine = storeEngine;
+    }
+    getNotificationEventList() {
+        return this.storeEngine.readAll(DatabaseStores.EVENTS);
+    }
+    async getLastEventDate() {
+        const { value } = await this.storeEngine.read(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_EVENT);
+        return new Date(value);
+    }
+    async updateLastEventDate(eventDate) {
+        await this.storeEngine.update(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_EVENT, {
+            value: eventDate.toISOString(),
+        });
+        return eventDate;
+    }
+    async createLastEventDate(eventDate) {
+        await this.storeEngine.create(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_EVENT, {
+            value: eventDate.toISOString(),
+        });
+        return eventDate;
+    }
+    async getLastNotificationId() {
+        const { value } = await this.storeEngine.read(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_NOTIFICATION);
+        return value;
+    }
+    async updateLastNotificationId(lastNotification) {
+        await this.storeEngine.updateOrCreate(STORES.AMPLIFY, DatabaseKeys.PRIMARY_KEY_LAST_NOTIFICATION, {
+            value: lastNotification.id,
+        });
+        return lastNotification.id;
+    }
+    /**
+     * ## MLS only ##
+     * Store groupIds with pending proposals and a delay in the DB until the proposals get committed.
+     *
+     * @param groupId groupId of the mls conversation
+     * @param firingDate date when the pending proposals should be committed
+     */
+    async storePendingProposal(params) {
+        await this.storeEngine.updateOrCreate(STORES.PENDING_PROPOSALS, `${params.groupId}`, params);
+        return true;
+    }
+    /**
+     * ## MLS only ##
+     * Delete stored entries for pending proposals that have been committed.
+     *
+     * @param groupId groupId of the mls conversation
+     */
+    async deletePendingProposal({ groupId }) {
+        await this.storeEngine.delete(STORES.PENDING_PROPOSALS, `${groupId}`);
+        return true;
+    }
+    /**
+     * ## MLS only ##
+     * Get all stored entries for pending proposals.
+     *
+     */
+    async getStoredPendingProposals() {
+        return this.storeEngine.readAll(STORES.PENDING_PROPOSALS);
+    }
+}
+exports.NotificationDatabaseRepository = NotificationDatabaseRepository;
+//# sourceMappingURL=NotificationDatabaseRepository.js.map