@wireapp/core 31.1.3 → 31.2.0

package/src/main/util/LowPrecisionTaskScheduler/LowPrecisionTaskScheduler.d.ts

@@ -0,0 +1,21 @@
+interface IntervalTask {
+    key: string;
+    firingDate: number;
+    task: () => Promise<any>;
+}
+interface ScheduleLowPrecisionTaskParams extends IntervalTask {
+    intervalDelay: number;
+}
+interface CancelLowPrecisionTaskParams {
+    key: string;
+    intervalDelay: number;
+}
+interface CancelLowPrecisionTaskParams {
+    key: string;
+    intervalDelay: number;
+}
+export declare const LowPrecisionTaskScheduler: {
+    addTask: ({ key, firingDate, task, intervalDelay }: ScheduleLowPrecisionTaskParams) => void;
+    cancelTask: ({ intervalDelay, key }: CancelLowPrecisionTaskParams) => void;
+};
+export {};

package/src/main/util/LowPrecisionTaskScheduler/LowPrecisionTaskScheduler.js

@@ -0,0 +1,62 @@
+"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.LowPrecisionTaskScheduler = void 0;
+const intervals = {};
+const addTask = ({ key, firingDate, task, intervalDelay }) => {
+    var _a, _b;
+    const existingIntervalId = (_a = intervals[intervalDelay]) === null || _a === void 0 ? void 0 : _a.timeoutId;
+    if (existingIntervalId) {
+        clearInterval(existingIntervalId);
+    }
+    const tasks = ((_b = intervals[intervalDelay]) === null || _b === void 0 ? void 0 : _b.tasks) || [];
+    tasks.push({ key, firingDate, task });
+    const timeoutId = setInterval(async () => {
+        var _a;
+        const nowTime = new Date().getTime();
+        const tasks = (_a = intervals[intervalDelay]) === null || _a === void 0 ? void 0 : _a.tasks;
+        if ((tasks === null || tasks === void 0 ? void 0 : tasks.length) !== 0) {
+            const tasksToExecute = await tasks.reduce(async (accPromise, { firingDate, task }) => {
+                const acc = await accPromise;
+                if (nowTime >= firingDate) {
+                    const taskPromise = task();
+                    acc.push(taskPromise);
+                    cancelTask({ intervalDelay, key });
+                }
+                return acc;
+            }, Promise.resolve([]));
+            await Promise.all(tasksToExecute);
+        }
+    }, intervalDelay);
+    intervals[intervalDelay] = { timeoutId, tasks };
+};
+const cancelTask = ({ intervalDelay, key }) => {
+    if (intervals[intervalDelay]) {
+        const tasks = intervals[intervalDelay].tasks || [];
+        const newTasks = tasks.filter(task => task.key !== key);
+        intervals[intervalDelay].tasks = newTasks;
+        if (newTasks.length === 0) {
+            clearInterval(intervals[intervalDelay].timeoutId);
+            delete intervals[intervalDelay];
+        }
+    }
+};
+exports.LowPrecisionTaskScheduler = { addTask, cancelTask };
+//# sourceMappingURL=LowPrecisionTaskScheduler.js.map

package/src/main/util/TaskScheduler/TaskScheduler.d.ts

@@ -0,0 +1,10 @@
+declare type ScheduleTaskParams = {
+    task: () => Promise<void>;
+    firingDate: number;
+    key: string;
+};
+export declare const TaskScheduler: {
+    addTask: ({ task, firingDate, key }: ScheduleTaskParams) => void;
+    cancelTask: (key: string) => void;
+};
+export {};

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

@@ -0,0 +1,70 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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', {
+    logger: console,
+    markdown: false,
+});
+const activeTimeouts = {};
+/**
+ * Execute a task at a given time.
+ *
+ * @param task function to be executed
+ * @param firingDate execution date
+ * @param key unique key for the task
+ */
+const addTask = ({ task, firingDate, key }) => {
+    const now = new Date();
+    const execute = new Date(firingDate);
+    const delay = execute.getTime() - now.getTime();
+    if (activeTimeouts[key]) {
+        cancelTask(key);
+    }
+    const timeout = setTimeout(async () => {
+        await task();
+        delete activeTimeouts[key];
+    }, delay > 0 ? delay : 0);
+    // add the task to the list of active tasks
+    activeTimeouts[key] = timeout;
+    logger.info(`New scheduled task to be executed at "${execute}" with key "${key}"`);
+};
+/**
+ * Cancel a scheduled task early
+ *
+ * @param key unique key for the task
+ */
+const cancelTask = (key) => {
+    const timeout = activeTimeouts[key];
+    if (timeout) {
+        clearTimeout(timeout);
+        delete activeTimeouts[key];
+        logger.info(`Scheduled task with key "${key}" prematurely cleared`);
+    }
+};
+exports.TaskScheduler = {
+    addTask,
+    cancelTask,
+};
+//# sourceMappingURL=TaskScheduler.js.map

package/src/main/util/TypePredicateUtil.d.ts

@@ -0,0 +1,7 @@
+import { QualifiedUserClients, UserClients } from '@wireapp/api-client/src/conversation/';
+import { QualifiedId } from '@wireapp/api-client/src/user/';
+export declare function isStringArray(obj: any): obj is string[];
+export declare function isQualifiedId(obj: any): obj is QualifiedId;
+export declare function isQualifiedIdArray(obj: any): obj is QualifiedId[];
+export declare function isQualifiedUserClients(obj: any): obj is QualifiedUserClients;
+export declare function isUserClients(obj: any): obj is UserClients;

package/src/main/util/TypePredicateUtil.js

@@ -0,0 +1,55 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2021 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.isUserClients = exports.isQualifiedUserClients = exports.isQualifiedIdArray = exports.isQualifiedId = exports.isStringArray = void 0;
+function isStringArray(obj) {
+    return Array.isArray(obj) && (obj.length === 0 || typeof obj[0] === 'string');
+}
+exports.isStringArray = isStringArray;
+function isQualifiedId(obj) {
+    return typeof obj === 'object' && typeof obj['domain'] === 'string';
+}
+exports.isQualifiedId = isQualifiedId;
+function isQualifiedIdArray(obj) {
+    return Array.isArray(obj) && isQualifiedId(obj[0]);
+}
+exports.isQualifiedIdArray = isQualifiedIdArray;
+function isQualifiedUserClients(obj) {
+    var _a;
+    if (typeof obj === 'object') {
+        const firstUserClientObject = (_a = Object.values(obj)) === null || _a === void 0 ? void 0 : _a[0];
+        if (typeof firstUserClientObject === 'object') {
+            const firstClientIdArray = Object.values(firstUserClientObject)[0];
+            return isStringArray(firstClientIdArray);
+        }
+    }
+    return false;
+}
+exports.isQualifiedUserClients = isQualifiedUserClients;
+function isUserClients(obj) {
+    var _a;
+    if (typeof obj === 'object') {
+        const firstUserClientArray = (_a = Object.values(obj)) === null || _a === void 0 ? void 0 : _a[0];
+        return isStringArray(firstUserClientArray);
+    }
+    return false;
+}
+exports.isUserClients = isUserClients;
+//# sourceMappingURL=TypePredicateUtil.js.map

package/src/main/util/encryptedStore.d.ts

@@ -0,0 +1,45 @@
+import { DBSchema, IDBPDatabase } from 'idb';
+interface DefaultEncryptedPayload {
+    iv: Uint8Array | ArrayBuffer;
+    value: Uint8Array | ArrayBuffer;
+}
+interface EncryptedDB<EncryptedPayload> extends DBSchema {
+    key: {
+        key: string;
+        value: CryptoKey;
+    };
+    secrets: {
+        key: string;
+        value: EncryptedPayload;
+    };
+}
+declare type DecryptFn<EncryptedPayload> = (payload: EncryptedPayload) => Promise<Uint8Array>;
+declare type EncryptFn<EncryptedPayload> = (value: Uint8Array) => Promise<EncryptedPayload>;
+declare type EncryptedStoreConfig<EncryptedPayload> = {
+    encrypt: EncryptFn<EncryptedPayload>;
+    decrypt: DecryptFn<EncryptedPayload>;
+};
+declare class EncryptedStore<EncryptedPayload> {
+    #private;
+    private readonly db;
+    constructor(db: IDBPDatabase<EncryptedDB<EncryptedPayload>>, { encrypt, decrypt }: EncryptedStoreConfig<EncryptedPayload>);
+    saveSecretValue(primaryKey: string, value: Uint8Array): Promise<void>;
+    getsecretValue(primaryKey: string): Promise<Uint8Array | undefined>;
+}
+/**
+ * Will create a database that uses the built in encryption/decryption functions.
+ * The master key will be created and stored inside the database
+ *
+ * @param dbName the name of the database to create
+ */
+export declare function createEncryptedStore(dbName: string): Promise<EncryptedStore<DefaultEncryptedPayload>>;
+/**
+ * Will create a database that uses a custom encryption method. It needs the encrypt and decrypt function to be able to process the values stored.
+ * It's the responsability of the consumer to store the encryption key
+ *
+ * @param dbName the name of the database to create
+ * @param config contains the encrypt and decrypt methods
+ */
+export declare function createCustomEncryptedStore<EncryptedPayload>(dbName: string, config: EncryptedStoreConfig<EncryptedPayload>): Promise<EncryptedStore<EncryptedPayload>>;
+export declare function deleteEncryptedStore(dbName: string): Promise<void>;
+export {};

package/src/main/util/encryptedStore.js

@@ -0,0 +1,116 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EncryptedStore_decrypt, _EncryptedStore_encrypt;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteEncryptedStore = exports.createCustomEncryptedStore = exports.createEncryptedStore = void 0;
+const idb_1 = require("idb");
+class EncryptedStore {
+    constructor(db, { encrypt, decrypt }) {
+        this.db = db;
+        _EncryptedStore_decrypt.set(this, void 0);
+        _EncryptedStore_encrypt.set(this, void 0);
+        __classPrivateFieldSet(this, _EncryptedStore_encrypt, encrypt, "f");
+        __classPrivateFieldSet(this, _EncryptedStore_decrypt, decrypt, "f");
+    }
+    async saveSecretValue(primaryKey, value) {
+        const encrypted = await __classPrivateFieldGet(this, _EncryptedStore_encrypt, "f").call(this, value);
+        await this.db.put('secrets', encrypted, primaryKey);
+    }
+    async getsecretValue(primaryKey) {
+        const result = await this.db.get('secrets', primaryKey);
+        if (!result) {
+            return undefined;
+        }
+        return __classPrivateFieldGet(this, _EncryptedStore_decrypt, "f").call(this, result);
+    }
+}
+_EncryptedStore_decrypt = new WeakMap(), _EncryptedStore_encrypt = new WeakMap();
+async function generateKey() {
+    return crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, //whether the key is extractable (i.e. can be used in exportKey)
+    ['encrypt', 'decrypt']);
+}
+async function defaultDecrypt({ value, iv }, key) {
+    const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, value);
+    return new Uint8Array(decrypted);
+}
+async function defaultEncrypt(data, key) {
+    const iv = await crypto.getRandomValues(new Uint8Array(12));
+    return {
+        iv,
+        value: await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, data),
+    };
+}
+/**
+ * Will create a database that uses the built in encryption/decryption functions.
+ * The master key will be created and stored inside the database
+ *
+ * @param dbName the name of the database to create
+ */
+async function createEncryptedStore(dbName) {
+    const db = await (0, idb_1.openDB)(dbName, 1, {
+        upgrade: async (database) => {
+            database.createObjectStore('key');
+            database.createObjectStore('secrets');
+        },
+    });
+    const keyPrimaryKey = 'dbKey';
+    let key = await db.get('key', keyPrimaryKey);
+    if (!key) {
+        key = await generateKey();
+        await db.put('key', key, keyPrimaryKey);
+    }
+    return new EncryptedStore(db, {
+        encrypt: value => defaultEncrypt(value, key),
+        decrypt: payload => defaultDecrypt(payload, key),
+    });
+}
+exports.createEncryptedStore = createEncryptedStore;
+/**
+ * Will create a database that uses a custom encryption method. It needs the encrypt and decrypt function to be able to process the values stored.
+ * It's the responsability of the consumer to store the encryption key
+ *
+ * @param dbName the name of the database to create
+ * @param config contains the encrypt and decrypt methods
+ */
+async function createCustomEncryptedStore(dbName, config) {
+    const db = await (0, idb_1.openDB)(dbName, 1, {
+        upgrade: async (database) => {
+            database.createObjectStore('secrets');
+        },
+    });
+    return new EncryptedStore(db, config);
+}
+exports.createCustomEncryptedStore = createCustomEncryptedStore;
+async function deleteEncryptedStore(dbName) {
+    return (0, idb_1.deleteDB)(dbName);
+}
+exports.deleteEncryptedStore = deleteEncryptedStore;
+//# sourceMappingURL=encryptedStore.js.map

package/src/main/util/fullyQualifiedClientIdUtils.d.ts

@@ -0,0 +1,13 @@
+import { QualifiedUserClientMap } from '@wireapp/api-client/src/client';
+declare type UserId = string;
+declare type ClientId = string;
+declare type Domain = string;
+export declare type ClientIdStringType = `${UserId}:${ClientId}@${Domain}`;
+export declare const constructFullyQualifiedClientId: (userId: UserId, clientId: ClientId, domain: Domain) => ClientIdStringType;
+export declare const parseFullQualifiedClientId: (qualifiedId: string) => {
+    user: UserId;
+    client: ClientId;
+    domain: Domain;
+};
+export declare const mapQualifiedUserClientIdsToFullyQualifiedClientIds: (qualifiedUserMap: QualifiedUserClientMap) => Uint8Array[];
+export {};

package/src/main/util/fullyQualifiedClientIdUtils.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.mapQualifiedUserClientIdsToFullyQualifiedClientIds = exports.parseFullQualifiedClientId = exports.constructFullyQualifiedClientId = void 0;
+const constructFullyQualifiedClientId = (userId, clientId, domain) => `${userId}:${clientId}@${domain}`;
+exports.constructFullyQualifiedClientId = constructFullyQualifiedClientId;
+const parseFullQualifiedClientId = (qualifiedId) => {
+    var _a;
+    const regexp = /([a-zA-Z0-9\-]+):([a-zA-Z0-9\-]+)@([a-zA-Z0-9\-.]+)/;
+    const [, user, client, domain] = (_a = qualifiedId.match(regexp)) !== null && _a !== void 0 ? _a : [];
+    if (!user || !client || !domain) {
+        throw new Error(`given client fully qualified ID is corrupted (${qualifiedId})`);
+    }
+    return { user, client, domain };
+};
+exports.parseFullQualifiedClientId = parseFullQualifiedClientId;
+const mapQualifiedUserClientIdsToFullyQualifiedClientIds = (qualifiedUserMap) => {
+    const encoder = new TextEncoder();
+    return Object.entries(qualifiedUserMap).flatMap(([domain, users]) => {
+        const clients = Object.entries(users);
+        return clients.flatMap(([userId, clients]) => clients.map(client => encoder.encode((0, exports.constructFullyQualifiedClientId)(userId, client.id, domain))));
+    });
+};
+exports.mapQualifiedUserClientIdsToFullyQualifiedClientIds = mapQualifiedUserClientIdsToFullyQualifiedClientIds;
+//# sourceMappingURL=fullyQualifiedClientIdUtils.js.map

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

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

package/src/main/util/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2021 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("./TypePredicateUtil"), exports);
+//# sourceMappingURL=index.js.map