@wireapp/core 25.3.1 → 27.0.0

package/CHANGELOG.md

@@ -3,6 +3,57 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [27.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@26.1.0...@wireapp/core@27.0.0) (2022-05-17)
+
+
+### Bug Fixes
+
+* Avoid silently creating client when initializing core ([#4264](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4264)) ([65a843a](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/65a843a2052dad2543e6cf046aca55ce85cc7c5e))
+
+
+### BREAKING CHANGES
+
+* if you were relying on account.init() to also create a new client, this behavior now change and will throw an error instead. If you also want to create a device (if it doesn't exist already), you should use the account.login() or account.initClient() methods instead
+
+
+
+
+
+# [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

package/package.json

@@ -69,6 +69,6 @@
     "test:project": "yarn dist && yarn test",
     "test:node": "nyc jasmine --config=jasmine.json"
   },
-  "version": "25.3.1",
-  "gitHead": "53e7ce7b1e5d68e425b128555e19e3203a5292c9"
+  "version": "27.0.0",
+  "gitHead": "35f51e328c1ad095a8f07a61b176054952d58e21"
 }

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,22 +92,51 @@ 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;
+    /**
+     * Will register a new user to the backend
+     *
+     * @param registration The user's data
+     * @param clientType Type of client to create (temporary or permanent)
+     */
     register(registration: RegisterData, clientType: ClientType): Promise<Context>;
+    /**
+     * Will init the core with an aleady existing client (both on backend and local)
+     * Will fail if local client cannot be found
+     *
+     * @param clientType The type of client the user is using (temporary or permanent)
+     * @param cookie The cookie to identify the user against backend (will use the browser's one if not given)
+     */
     init(clientType: ClientType, cookie?: Cookie, initClient?: boolean): Promise<Context>;
-    initServices(context: Context): Promise<void>;
+    /**
+     * Will log the user in with the given credential.
+     * Will also create the local client and store it in DB
+     *
+     * @param loginData The credentials of the user
+     * @param initClient Should the call also create the local client
+     * @param clientInfo Info about the client to create (name, type...)
+     */
     login(loginData: LoginData, initClient?: boolean, clientInfo?: ClientInfo): Promise<Context>;
+    /**
+     * Will try to get the load the local client from local DB.
+     * If clientInfo are provided, will also create the client on backend and DB
+     * If clientInfo are not provideo, the method will fail if local client cannot be found
+     *
+     * @param loginData User's credentials
+     * @param clientInfo Will allow creating the client if the local client cannot be found (else will fail if local client is not found)
+     * @param entropyData Additional entropy data
+     * @returns The local existing client or newly created client
+     */
     initClient(loginData: LoginData, clientInfo?: ClientInfo, entropyData?: Uint8Array): Promise<{
         isNewClient: boolean;
         localClient: RegisteredClient;
     }>;
+    initServices(context: Context): Promise<void>;
     loadAndValidateLocalClient(): Promise<RegisteredClient>;
     private registerClient;
     private resetContext;

package/src/main/Account.js

@@ -67,12 +67,17 @@ var TOPIC;
 (function (TOPIC) {
     TOPIC["ERROR"] = "Account.TOPIC.ERROR";
 })(TOPIC || (TOPIC = {}));
+const coreDefaultClient = {
+    classification: client_1.ClientClassification.DESKTOP,
+    cookieLabel: 'default',
+    model: '@wireapp/core',
+};
 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 +95,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) {
@@ -116,11 +122,24 @@ class Account extends events_1.EventEmitter {
     get userId() {
         return this.apiClient.validatedUserId;
     }
+    /**
+     * Will register a new user to the backend
+     *
+     * @param registration The user's data
+     * @param clientType Type of client to create (temporary or permanent)
+     */
     async register(registration, clientType) {
         const context = await this.apiClient.register(registration, clientType);
         await this.initServices(context);
         return context;
     }
+    /**
+     * Will init the core with an aleady existing client (both on backend and local)
+     * Will fail if local client cannot be found
+     *
+     * @param clientType The type of client the user is using (temporary or permanent)
+     * @param cookie The cookie to identify the user against backend (will use the browser's one if not given)
+     */
     async init(clientType, cookie, initClient = true) {
         const context = await this.apiClient.init(clientType, cookie);
         await this.initServices(context);
@@ -129,44 +148,15 @@ class Account extends events_1.EventEmitter {
         }
         return context;
     }
-    async initServices(context) {
-        this.storeEngine = await this.initEngine(context);
-        const accountService = new account_1.AccountService(this.apiClient);
-        const assetService = new conversation_1.AssetService(this.apiClient);
-        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,
-        });
-        const clientService = new client_2.ClientService(this.apiClient, this.storeEngine, cryptographyService);
-        const connectionService = new connection_1.ConnectionService(this.apiClient);
-        const giphyService = new giphy_1.GiphyService(this.apiClient);
-        const linkPreviewService = new linkPreview_1.LinkPreviewService(assetService);
-        const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService, {
-            // We can use qualified ids to send messages as long as the backend supports federated endpoints
-            useQualifiedIds: this.backendFeatures.federationEndpoints,
-        });
-        const notificationService = new notification_1.NotificationService(this.apiClient, cryptographyService, this.storeEngine);
-        const selfService = new self_1.SelfService(this.apiClient);
-        const teamService = new team_1.TeamService(this.apiClient);
-        const broadcastService = new broadcast_1.BroadcastService(this.apiClient, cryptographyService);
-        const userService = new user_1.UserService(this.apiClient, broadcastService, conversationService, connectionService);
-        this.service = {
-            account: accountService,
-            asset: assetService,
-            broadcast: broadcastService,
-            client: clientService,
-            connection: connectionService,
-            conversation: conversationService,
-            cryptography: cryptographyService,
-            giphy: giphyService,
-            linkPreview: linkPreviewService,
-            notification: notificationService,
-            self: selfService,
-            team: teamService,
-            user: userService,
-        };
-    }
-    async login(loginData, initClient = true, clientInfo) {
+    /**
+     * Will log the user in with the given credential.
+     * Will also create the local client and store it in DB
+     *
+     * @param loginData The credentials of the user
+     * @param initClient Should the call also create the local client
+     * @param clientInfo Info about the client to create (name, type...)
+     */
+    async login(loginData, initClient = true, clientInfo = coreDefaultClient) {
         this.resetContext();
         auth_2.LoginSanitizer.removeNonPrintableCharacters(loginData);
         const context = await this.apiClient.login(loginData);
@@ -176,6 +166,16 @@ class Account extends events_1.EventEmitter {
         }
         return context;
     }
+    /**
+     * Will try to get the load the local client from local DB.
+     * If clientInfo are provided, will also create the client on backend and DB
+     * If clientInfo are not provideo, the method will fail if local client cannot be found
+     *
+     * @param loginData User's credentials
+     * @param clientInfo Will allow creating the client if the local client cannot be found (else will fail if local client is not found)
+     * @param entropyData Additional entropy data
+     * @returns The local existing client or newly created client
+     */
     async initClient(loginData, clientInfo, entropyData) {
         var _a, _b;
         if (!this.service) {
@@ -186,6 +186,10 @@ class Account extends events_1.EventEmitter {
             return { isNewClient: false, localClient };
         }
         catch (error) {
+            if (!clientInfo) {
+                // If no client info provided, the client should not be created
+                throw error;
+            }
             // There was no client so we need to "create" and "register" a client
             const notFoundInDatabase = error instanceof cryptobox.error.CryptoboxError ||
                 error.constructor.name === 'CryptoboxError' ||
@@ -216,6 +220,44 @@ class Account extends events_1.EventEmitter {
             throw error;
         }
     }
+    async initServices(context) {
+        this.storeEngine = await this.initEngine(context);
+        const accountService = new account_1.AccountService(this.apiClient);
+        const assetService = new conversation_1.AssetService(this.apiClient);
+        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);
+        const giphyService = new giphy_1.GiphyService(this.apiClient);
+        const linkPreviewService = new linkPreview_1.LinkPreviewService(assetService);
+        const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService, {
+            // We can use qualified ids to send messages as long as the backend supports federated endpoints
+            useQualifiedIds: this.backendFeatures.federationEndpoints,
+        });
+        const notificationService = new notification_1.NotificationService(this.apiClient, cryptographyService, this.storeEngine);
+        const selfService = new self_1.SelfService(this.apiClient);
+        const teamService = new team_1.TeamService(this.apiClient);
+        const broadcastService = new broadcast_1.BroadcastService(this.apiClient, cryptographyService);
+        const userService = new user_1.UserService(this.apiClient, broadcastService, conversationService, connectionService);
+        this.service = {
+            account: accountService,
+            asset: assetService,
+            broadcast: broadcastService,
+            client: clientService,
+            connection: connectionService,
+            conversation: conversationService,
+            cryptography: cryptographyService,
+            giphy: giphyService,
+            linkPreview: linkPreviewService,
+            notification: notificationService,
+            self: selfService,
+            team: teamService,
+            user: userService,
+        };
+    }
     async loadAndValidateLocalClient() {
         await this.service.cryptography.initCryptobox();
         const loadedClient = await this.service.client.getLocalClient();
@@ -223,7 +265,7 @@ class Account extends events_1.EventEmitter {
         this.apiClient.context.clientId = loadedClient.id;
         return loadedClient;
     }
-    async registerClient(loginData, clientInfo, entropyData) {
+    async registerClient(loginData, clientInfo = coreDefaultClient, entropyData) {
         if (!this.service) {
             throw new Error('Services are not set.');
         }

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

@@ -36,5 +36,5 @@ export declare class ClientService {
     getLocalClient(): Promise<MetaClient>;
     createLocalClient(client: RegisteredClient, domain?: string): Promise<MetaClient>;
     synchronizeClients(): Promise<MetaClient[]>;
-    register(loginData: LoginData, clientInfo?: ClientInfo, entropyData?: Uint8Array): Promise<RegisteredClient>;
+    register(loginData: LoginData, clientInfo: ClientInfo, entropyData?: Uint8Array): Promise<RegisteredClient>;
 }

package/src/main/client/ClientService.js

@@ -71,11 +71,7 @@ class ClientService {
         return this.database.createClientList(this.apiClient.context.userId, filteredClients, (_a = this.apiClient.context) === null || _a === void 0 ? void 0 : _a.domain);
     }
     // TODO: Split functionality into "create" and "register" client
-    async register(loginData, clientInfo = {
-        classification: client_1.ClientClassification.DESKTOP,
-        cookieLabel: 'default',
-        model: '@wireapp/core',
-    }, entropyData) {
+    async register(loginData, clientInfo, entropyData) {
         if (!this.apiClient.context) {
             throw new Error('Context is not set.');
         }

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,