@wireapp/core 25.3.0 → 26.1.0

package/CHANGELOG.md

@@ -3,6 +3,49 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [26.1.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@26.0.0...@wireapp/core@26.1.0) (2022-05-16)
+
+
+### Features
+
+* Allow consumer to set number of prekeys generated ([#4263](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4263)) ([648ecda](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/648ecdad260488e1d07965a84a28c346d6f015c3))
+
+
+
+
+
+# [26.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@25.3.1...@wireapp/core@26.0.0) (2022-05-16)
+
+
+### Bug Fixes
+
+* Allow sending targeted lastRead and Countly messages ([#4262](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4262)) ([69c7d98](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/69c7d98272dc9beea6e5d9a99d6392177f0be361))
+
+
+### BREAKING CHANGES
+
+* To send `lastRead` and `countly` as protobuf message, you now need to provide a `MessageSendingOptions` object as last parameter. 
+
+```js
+core.service.conversation.sendLastRead(conversation, timestamp, true);
+
+// Becomes
+
+core.service.converstaion.sendLastRead(conversation, timestamp, {sendAsProtobuf: true});
+```
+
+
+
+
+
+## [25.3.1](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@25.3.0...@wireapp/core@25.3.1) (2022-05-16)
+
+**Note:** Version bump only for package @wireapp/core
+
+
+
+
+
 # [25.3.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@25.2.1...@wireapp/core@25.3.0) (2022-05-16)
 
 

package/package.json

@@ -69,6 +69,6 @@
     "test:project": "yarn dist && yarn test",
     "test:node": "nyc jasmine --config=jasmine.json"
   },
-  "version": "25.3.0",
-  "gitHead": "a8bf270b2a73f44d611bcb9bb2965dc24e6918a1"
+  "version": "26.1.0",
+  "gitHead": "3b458a889a4e5ebebf2c66429c8fac7f39119891"
 }

package/src/main/Account.d.ts

@@ -53,11 +53,26 @@ export interface Account {
     on(event: TOPIC.ERROR, listener: (payload: CoreError) => void): this;
 }
 export declare type CreateStoreFn = (storeName: string, context: Context) => undefined | Promise<CRUDEngine | undefined>;
+interface AccountOptions {
+    /** Used to store info in the database (will create a inMemory engine if returns undefined) */
+    createStore?: CreateStoreFn;
+    /** Number of prekeys to generate when creating a new device (defaults to 2)
+     * Prekeys are Diffie-Hellmann public keys which allow offline initiation of a secure Proteus session between two devices.
+     * Having a high value will:
+     *    - make creating a new device consuming more CPU resources
+     *    - make it less likely that all prekeys get consumed while the device is offline and the last resort prekey will not be used to create new session
+     * Having a low value will:
+     *    - make creating a new device fast
+     *    - make it likely that all prekeys get consumed while the device is offline and the last resort prekey will be used to create new session
+     */
+    nbPrekeys?: number;
+}
 export declare class Account extends EventEmitter {
     private readonly apiClient;
     private readonly logger;
     private readonly createStore;
     private storeEngine?;
+    private readonly nbPrekeys;
     static readonly TOPIC: typeof TOPIC;
     service?: {
         account: AccountService;
@@ -77,11 +92,9 @@ export declare class Account extends EventEmitter {
     backendFeatures: BackendFeatures;
     /**
      * @param apiClient The apiClient instance to use in the core (will create a new new one if undefined)
-     * @param storeEngineProvider Used to store info in the database (will create a inMemory engine if returns undefined)
+     * @param storeEngineProvider
      */
-    constructor(apiClient?: APIClient, { createStore }?: {
-        createStore?: CreateStoreFn;
-    });
+    constructor(apiClient?: APIClient, { createStore, nbPrekeys }?: AccountOptions);
     private persistCookie;
     get clientId(): string;
     get userId(): string;

package/src/main/Account.js

@@ -70,9 +70,9 @@ var TOPIC;
 class Account extends events_1.EventEmitter {
     /**
      * @param apiClient The apiClient instance to use in the core (will create a new new one if undefined)
-     * @param storeEngineProvider Used to store info in the database (will create a inMemory engine if returns undefined)
+     * @param storeEngineProvider
      */
-    constructor(apiClient = new api_client_1.APIClient(), { createStore = () => undefined } = {}) {
+    constructor(apiClient = new api_client_1.APIClient(), { createStore = () => undefined, nbPrekeys = 2 } = {}) {
         super();
         this.handlePayload = async (payload) => {
             switch (payload.type) {
@@ -90,6 +90,7 @@ class Account extends events_1.EventEmitter {
         };
         this.apiClient = apiClient;
         this.backendFeatures = this.apiClient.backendFeatures;
+        this.nbPrekeys = nbPrekeys;
         this.createStore = createStore;
         apiClient.on(api_client_1.APIClient.TOPIC.COOKIE_REFRESH, async (cookie) => {
             if (cookie && this.storeEngine) {
@@ -136,6 +137,7 @@ class Account extends events_1.EventEmitter {
         const cryptographyService = new cryptography_1.CryptographyService(this.apiClient, this.storeEngine, {
             // We want to encrypt with fully qualified session ids, only if the backend is federated with other backends
             useQualifiedIds: this.backendFeatures.isFederated,
+            nbPrekeys: this.nbPrekeys,
         });
         const clientService = new client_2.ClientService(this.apiClient, this.storeEngine, cryptographyService);
         const connectionService = new connection_1.ConnectionService(this.apiClient);

package/src/main/client/ClientBackendRepository.d.ts

@@ -6,6 +6,6 @@ export declare class ClientBackendRepository {
     getClients(): Promise<RegisteredClient[]>;
     postClient(client: CreateClientPayload): Promise<RegisteredClient>;
     putClient(clientId: string, updates: UpdateClientPayload): Promise<void>;
-    deleteClient(clientId: string, password: string): Promise<void>;
+    deleteClient(clientId: string, password?: string): Promise<void>;
     uploadMLSKeyPackages(clientId: string, keyPackages: string[]): Promise<void>;
 }

package/src/main/client/ClientDatabaseRepository.js

@@ -35,7 +35,7 @@ class ClientDatabaseRepository {
         return this.storeEngine.read(ClientDatabaseRepository.STORES.CLIENTS, sessionId);
     }
     deleteLocalClient() {
-        return this.storeEngine.delete(ClientDatabaseRepository.STORES.CLIENTS, ClientDatabaseRepository.KEYS.LOCAL_IDENTITY);
+        return this.deleteClient(ClientDatabaseRepository.KEYS.LOCAL_IDENTITY);
     }
     deleteClient(sessionId) {
         return this.storeEngine.delete(ClientDatabaseRepository.STORES.CLIENTS, sessionId);

package/src/main/client/ClientService.d.ts

@@ -18,16 +18,21 @@ export declare class ClientService {
     private readonly database;
     private readonly backend;
     constructor(apiClient: APIClient, storeEngine: CRUDEngine, cryptographyService: CryptographyService);
-    deleteLocalClient(): Promise<string>;
     getClients(): Promise<RegisteredClient[]>;
     /**
      * Will delete the given client from backend and will also delete it from the local database
+     *
+     * note: use deleteLocalClient if you wish to delete the client currently used by the user
+     *
      * @param clientId The id of the client to delete
-     * @param password Password of the owning user
-     * @param isLocalClient Is the client also the client currently used by the app (as opposed to a client the user owns but not currenly in use)
-     * @returns Promise
+     * @param password? Password of the owning user. Can be omitted for temporary devices
      */
-    deleteClient(clientId: string, password: string, isLocalClient?: boolean): Promise<unknown>;
+    deleteClient(clientId: string, password?: string): Promise<unknown>;
+    /**
+     * Will delete the local client (client currently in use by the user) from backend and will also delete it from the local database
+     * @param password? Password of the owning user. Can be omitted for temporary devices
+     */
+    deleteLocalClient(password?: string): Promise<string>;
     getLocalClient(): Promise<MetaClient>;
     createLocalClient(client: RegisteredClient, domain?: string): Promise<MetaClient>;
     synchronizeClients(): Promise<MetaClient[]>;

package/src/main/client/ClientService.js

@@ -29,25 +29,34 @@ class ClientService {
         this.database = new _1.ClientDatabaseRepository(this.storeEngine, this.cryptographyService);
         this.backend = new _1.ClientBackendRepository(this.apiClient);
     }
-    deleteLocalClient() {
-        return this.database.deleteLocalClient();
-    }
     getClients() {
         return this.backend.getClients();
     }
     /**
      * Will delete the given client from backend and will also delete it from the local database
+     *
+     * note: use deleteLocalClient if you wish to delete the client currently used by the user
+     *
      * @param clientId The id of the client to delete
-     * @param password Password of the owning user
-     * @param isLocalClient Is the client also the client currently used by the app (as opposed to a client the user owns but not currenly in use)
-     * @returns Promise
+     * @param password? Password of the owning user. Can be omitted for temporary devices
      */
-    async deleteClient(clientId, password, isLocalClient = false) {
+    async deleteClient(clientId, password) {
         const userId = { id: this.apiClient.userId, domain: this.apiClient.domain || '' };
         await this.backend.deleteClient(clientId, password);
-        return isLocalClient
-            ? this.database.deleteLocalClient()
-            : this.database.deleteClient(this.cryptographyService.constructSessionId(userId, clientId));
+        return this.database.deleteClient(this.cryptographyService.constructSessionId(userId, clientId));
+    }
+    /**
+     * Will delete the local client (client currently in use by the user) from backend and will also delete it from the local database
+     * @param password? Password of the owning user. Can be omitted for temporary devices
+     */
+    async deleteLocalClient(password) {
+        var _a;
+        const localClientId = (_a = this.apiClient.context) === null || _a === void 0 ? void 0 : _a.clientId;
+        if (!localClientId) {
+            throw new Error('Trying to delete local client, but local client has not been set');
+        }
+        await this.backend.deleteClient(localClientId, password);
+        return this.database.deleteLocalClient();
     }
     getLocalClient() {
         return this.database.getLocalClient();

package/src/main/conversation/ConversationService.d.ts

@@ -115,10 +115,10 @@ export declare class ConversationService {
      *
      * @param conversationId The conversation which has been read
      * @param lastReadTimestamp The timestamp at which the conversation was read
-     * @param sendAsProtobuf?
+     * @param sendingOptions?
      * @return Resolves when the message has been sent
      */
-    sendLastRead(conversationId: string, lastReadTimestamp: number, sendAsProtobuf?: boolean): Promise<(MessageSendingStatus & {
+    sendLastRead(conversationId: string, lastReadTimestamp: number, sendingOptions?: MessageSendingOptions): Promise<(MessageSendingStatus & {
         errored?: boolean | undefined;
     }) | (ClientMismatch & {
         errored?: boolean | undefined;
@@ -127,10 +127,10 @@ export declare class ConversationService {
      * Syncs all self user's devices with the countly id
      *
      * @param countlyId The countly id of the current device
-     * @param sendAsProtobuf?
+     * @param sendingOptions?
      * @return Resolves when the message has been sent
      */
-    sendCountlySync(countlyId: string, sendAsProtobuf?: boolean): Promise<(MessageSendingStatus & {
+    sendCountlySync(countlyId: string, sendingOptions: MessageSendingOptions): Promise<(MessageSendingStatus & {
         errored?: boolean | undefined;
     }) | (ClientMismatch & {
         errored?: boolean | undefined;

package/src/main/conversation/ConversationService.js

@@ -470,10 +470,10 @@ class ConversationService {
      *
      * @param conversationId The conversation which has been read
      * @param lastReadTimestamp The timestamp at which the conversation was read
-     * @param sendAsProtobuf?
+     * @param sendingOptions?
      * @return Resolves when the message has been sent
      */
-    async sendLastRead(conversationId, lastReadTimestamp, sendAsProtobuf) {
+    async sendLastRead(conversationId, lastReadTimestamp, sendingOptions) {
         const lastRead = new protocol_messaging_1.LastRead({
             conversationId,
             lastReadTimestamp,
@@ -483,19 +483,16 @@ class ConversationService {
             messageId: MessageBuilder_1.MessageBuilder.createId(),
         });
         const { id: selfConversationId, domain: selfConversationDomain } = await this.getSelfConversationId();
-        return this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, {
-            conversationDomain: selfConversationDomain,
-            sendAsProtobuf,
-        });
+        return this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, Object.assign({ conversationDomain: selfConversationDomain }, sendingOptions));
     }
     /**
      * Syncs all self user's devices with the countly id
      *
      * @param countlyId The countly id of the current device
-     * @param sendAsProtobuf?
+     * @param sendingOptions?
      * @return Resolves when the message has been sent
      */
-    async sendCountlySync(countlyId, sendAsProtobuf) {
+    async sendCountlySync(countlyId, sendingOptions) {
         const { id: selfConversationId, domain: selfConversationDomain } = await this.getSelfConversationId();
         const dataTransfer = new protocol_messaging_1.DataTransfer({
             trackingIdentifier: {
@@ -506,10 +503,7 @@ class ConversationService {
             [conversation_2.GenericMessageType.DATA_TRANSFER]: dataTransfer,
             messageId: MessageBuilder_1.MessageBuilder.createId(),
         });
-        return this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, {
-            conversationDomain: selfConversationDomain,
-            sendAsProtobuf,
-        });
+        return this.sendGenericMessage(this.apiClient.validatedClientId, selfConversationId, genericMessage, Object.assign({ conversationDomain: selfConversationDomain }, sendingOptions));
     }
     /**
      * Get a fresh list from backend of clients for all the participants of the conversation.

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

@@ -20,8 +20,9 @@ export declare class CryptographyService {
     private readonly logger;
     cryptobox: Cryptobox;
     private readonly database;
-    constructor(apiClient: APIClient, storeEngine: CRUDEngine, config?: {
-        useQualifiedIds?: boolean;
+    constructor(apiClient: APIClient, storeEngine: CRUDEngine, config: {
+        useQualifiedIds: boolean;
+        nbPrekeys: number;
     });
     constructSessionId(userId: string | QualifiedId, clientId: string, domain?: string): string;
     static convertArrayRecipientsToBase64(recipients: OTRRecipients<Uint8Array>): OTRRecipients<string>;

package/src/main/cryptography/CryptographyService.js

@@ -32,11 +32,11 @@ const util_1 = require("../util");
 const CryptographyDatabaseRepository_1 = require("./CryptographyDatabaseRepository");
 const GenericMessageMapper_1 = require("./GenericMessageMapper");
 class CryptographyService {
-    constructor(apiClient, storeEngine, config = {}) {
+    constructor(apiClient, storeEngine, config) {
         this.apiClient = apiClient;
         this.storeEngine = storeEngine;
         this.config = config;
-        this.cryptobox = new cryptobox_1.Cryptobox(this.storeEngine);
+        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', {
             logger: console,