@wireapp/core 17.34.0 → 20.0.1

package/CHANGELOG.md

@@ -3,6 +3,102 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [20.0.1](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@20.0.0...@wireapp/core@20.0.1) (2021-12-09)
+
+
+### Bug Fixes
+
+* **core:** Generate new session and reencrypt payload when sessionIds are missing ([#4200](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4200)) ([07eab82](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/07eab82ee7512bb4eba71adf20c13c5609dbc024))
+
+
+
+
+
+# [20.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@19.0.0...@wireapp/core@20.0.0) (2021-12-08)
+
+
+### Code Refactoring
+
+* **core:** Harmonize asset param name ([#4199](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4199)) ([f29c825](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/f29c825df427e9fccae164a728f0071fdf1bc3af))
+
+
+### BREAKING CHANGES
+
+* **core:** The `imageAsset` property given to the `MessageBuilder.createImage` function has been renamed `asset` to be coherent with sending files.
+Replace `MessageBuilder.createImage({..., imageAsset: asset})` with `MessageBuilder.createImage({..., asset})`
+
+
+
+
+
+# [19.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@18.0.0...@wireapp/core@19.0.0) (2021-12-08)
+
+
+### Features
+
+* **core:** Ability to cancel asset uploading ([#4198](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4198)) ([e111f46](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/e111f46d06bf2ec22f2002c9a2954cdf0c9e8d09))
+
+
+### BREAKING CHANGES
+
+* **core:** Uploading an asset now return a structure that allow cancelling the upload. Thus instances of `await account.service.asset.uploadAsset(...)` must be replaced by 
+```
+const {cancel, response} = await account.service.asset.uploadAsset(...);
+cancel() // This is how you cancel the upload
+await response// This will contain the uploaded asset once the upload is done
+```
+
+
+
+
+
+# [18.0.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@17.34.0...@wireapp/core@18.0.0) (2021-12-08)
+
+
+### Features
+
+* **core:** Make message builder stateless ([#4197](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4197)) ([95a51a6](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/95a51a614b20730767916885182eb185b46c4c38))
+
+
+### BREAKING CHANGES
+
+* **core:** - `MessageBuilder` has been moved from `account.services.conversation.messageBuilder` to an own stateless class.
+- All method of the `MessageBuilder` now take a required `from` parameter
+- `MessageBuilder` is not uploading files under the hood. Upload must be done in a separate function call
+
+Replace
+
+```
+const textPayload = account.service.conversation.messageBuilder.createText(...);
+```
+
+With
+
+```
+import {MessageBuilder} from '@wireapp/core/src/main/conversation/message/MessageBuilder';
+//...
+const textPayload = MessageBuilder.createText(...);
+```
+
+Replace
+
+```
+const linkPreview = await account.service.conversation.messageBuilder.createLinkPreview(...);
+cons textPayload = account.service.conversation.messageBuilder.createText(...).withLinkPreview([linkPreview]);
+```
+
+With
+
+```
+cons textPayload = account.service.conversation.messageBuilder
+    .createText(...)
+    .withLinkPreview([await this.account.service.linkPreview.uploadLinkPreviewImage(newLinkPreview)]);
+```
+
+
+
+
+
 # [17.34.0](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@17.33.1...@wireapp/core@17.34.0) (2021-12-06)
 
 

package/package.json

@@ -5,7 +5,7 @@
   "dependencies": {
     "@types/long": "4.0.1",
     "@types/node": "~14",
-    "@wireapp/api-client": "15.11.1",
+    "@wireapp/api-client": "16.0.0",
     "@wireapp/cryptobox": "12.7.1",
     "bazinga64": "5.10.0",
     "hash.js": "1.1.7",
@@ -69,6 +69,6 @@
     "test:project": "yarn dist && yarn test",
     "test:node": "nyc jasmine --config=jasmine.json"
   },
-  "version": "17.34.0",
-  "gitHead": "c070dc05ea9e0abbf6bc6837035ea756dcfa5af0"
+  "version": "20.0.1",
+  "gitHead": "3c5496c4f2d17974cd871b65c7882464caec343e"
 }

package/src/main/Account.d.ts

@@ -20,6 +20,7 @@ import { SelfService } from './self/';
 import { TeamService } from './team/';
 import { UserService } from './user/';
 import { AccountService } from './account/';
+import { LinkPreviewService } from './linkPreview';
 declare enum TOPIC {
     ERROR = "Account.TOPIC.ERROR"
 }
@@ -71,6 +72,7 @@ export declare class Account extends EventEmitter {
         conversation: ConversationService;
         cryptography: CryptographyService;
         giphy: GiphyService;
+        linkPreview: LinkPreviewService;
         notification: NotificationService;
         self: SelfService;
         team: TeamService;

package/src/main/Account.js

@@ -62,6 +62,7 @@ const self_1 = require("./self/");
 const team_1 = require("./team/");
 const user_1 = require("./user/");
 const account_1 = require("./account/");
+const linkPreview_1 = require("./linkPreview");
 var TOPIC;
 (function (TOPIC) {
     TOPIC["ERROR"] = "Account.TOPIC.ERROR";
@@ -155,7 +156,8 @@ class Account extends events_1.EventEmitter {
         const clientService = new client_2.ClientService(this.apiClient, storeEngine, cryptographyService);
         const connectionService = new connection_1.ConnectionService(this.apiClient);
         const giphyService = new giphy_1.GiphyService(this.apiClient);
-        const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService, assetService);
+        const linkPreviewService = new linkPreview_1.LinkPreviewService(assetService);
+        const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService);
         const notificationService = new notification_1.NotificationService(this.apiClient, cryptographyService, storeEngine);
         const selfService = new self_1.SelfService(this.apiClient);
         const teamService = new team_1.TeamService(this.apiClient);
@@ -170,6 +172,7 @@ class Account extends events_1.EventEmitter {
             conversation: conversationService,
             cryptography: cryptographyService,
             giphy: giphyService,
+            linkPreview: linkPreviewService,
             notification: notificationService,
             self: selfService,
             team: teamService,

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

@@ -1,11 +1,10 @@
+/// <reference types="node" />
 import type { APIClient } from '@wireapp/api-client';
 import type { AssetOptions } from '@wireapp/api-client/src/asset';
-import type { FileContent, ImageContent } from '../conversation/content/';
+import type { ProgressCallback, RequestCancelable } from '@wireapp/api-client/src/http';
 import type { EncryptedAssetUploaded } from '../cryptography/';
 export declare class AssetService {
     private readonly apiClient;
     constructor(apiClient: APIClient);
-    private postAsset;
-    uploadImageAsset(image: ImageContent, options?: AssetOptions): Promise<EncryptedAssetUploaded>;
-    uploadFileAsset(file: FileContent, options?: AssetOptions): Promise<EncryptedAssetUploaded>;
+    uploadAsset(plainText: Buffer | Uint8Array, options?: AssetOptions, progressCallback?: ProgressCallback): Promise<RequestCancelable<EncryptedAssetUploaded>>;
 }

package/src/main/conversation/AssetService.js

@@ -24,27 +24,23 @@ class AssetService {
     constructor(apiClient) {
         this.apiClient = apiClient;
     }
-    async postAsset(plainText, options, progressCallback) {
+    async uploadAsset(plainText, options, progressCallback) {
         const { cipherText, keyBytes, sha256 } = await (0, AssetCryptography_1.encryptAsset)({
             plainText,
             algorithm: options === null || options === void 0 ? void 0 : options.algorithm,
             hash: options === null || options === void 0 ? void 0 : options.hash,
         });
-        const request = await this.apiClient.asset.api.postAsset(new Uint8Array(cipherText), options, progressCallback);
-        const { key, token } = await request.response;
-        return {
-            cipherText,
-            key,
-            keyBytes,
-            sha256,
-            token,
-        };
-    }
-    uploadImageAsset(image, options) {
-        return this.postAsset(image.data, options);
-    }
-    uploadFileAsset(file, options) {
-        return this.postAsset(file.data, options);
+        const request = this.apiClient.asset.api.postAsset(new Uint8Array(cipherText), options, progressCallback);
+        return Object.assign(Object.assign({}, request), { response: request.response.then(response => {
+                const { key, token } = response;
+                return {
+                    cipherText,
+                    key,
+                    keyBytes,
+                    sha256,
+                    token,
+                };
+            }) });
     }
 }
 exports.AssetService = AssetService;

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

@@ -4,10 +4,9 @@ import { MessageSendingStatus, Conversation, DefaultConversationRoleName, MutedS
 import type { ConversationMemberLeaveEvent } from '@wireapp/api-client/src/event/';
 import type { QualifiedId, UserPreKeyBundleMap } from '@wireapp/api-client/src/user/';
 import { GenericMessage } from '@wireapp/protocol-messaging';
-import { AssetService, MessageTimer } from '../conversation/';
+import { MessageTimer } from '../conversation/';
 import type { RemoteData } from '../conversation/content/';
 import type { CryptographyService } from '../cryptography/';
-import { MessageBuilder } from './message/MessageBuilder';
 import type { ClearConversationMessage, DeleteMessage, HideMessage, OtrMessage } from './message/OtrMessage';
 export declare enum MessageTargetMode {
     NONE = 0,
@@ -62,11 +61,9 @@ export interface MessageSendingCallbacks {
 }
 export declare class ConversationService {
     private readonly apiClient;
-    private readonly assetService;
     readonly messageTimer: MessageTimer;
-    readonly messageBuilder: MessageBuilder;
     private readonly messageService;
-    constructor(apiClient: APIClient, cryptographyService: CryptographyService, assetService: AssetService);
+    constructor(apiClient: APIClient, cryptographyService: CryptographyService);
     private createEphemeral;
     private getConversationQualifiedMembers;
     /**

package/src/main/conversation/ConversationService.js

@@ -35,11 +35,9 @@ var MessageTargetMode;
     MessageTargetMode[MessageTargetMode["USERS_CLIENTS"] = 2] = "USERS_CLIENTS";
 })(MessageTargetMode = exports.MessageTargetMode || (exports.MessageTargetMode = {}));
 class ConversationService {
-    constructor(apiClient, cryptographyService, assetService) {
+    constructor(apiClient, cryptographyService) {
         this.apiClient = apiClient;
-        this.assetService = assetService;
         this.messageTimer = new conversation_2.MessageTimer();
-        this.messageBuilder = new MessageBuilder_1.MessageBuilder(this.apiClient, this.assetService);
         this.messageService = new MessageService_1.MessageService(this.apiClient, cryptographyService);
     }
     createEphemeral(originalGenericMessage, expireAfterMillis) {

package/src/main/conversation/content/LinkPreviewContent.d.ts

@@ -2,9 +2,9 @@ import type { ILinkPreview } from '@wireapp/protocol-messaging';
 import type { ImageAssetContent, ImageContent, LegalHoldStatus } from '../content/';
 export interface LinkPreviewContent extends Omit<ILinkPreview, 'image'> {
     expectsReadConfirmation?: boolean;
-    image?: ImageContent;
     legalHoldStatus?: LegalHoldStatus;
+    image: ImageContent;
 }
-export interface LinkPreviewUploadedContent extends LinkPreviewContent {
+export interface LinkPreviewUploadedContent extends Omit<LinkPreviewContent, 'image'> {
     imageUploaded?: ImageAssetContent;
 }

package/src/main/conversation/message/MessageBuilder.d.ts

@@ -1,26 +1,24 @@
-import type { APIClient } from '@wireapp/api-client';
-import type { CipherOptions } from '@wireapp/api-client/src/asset';
 import { Confirmation } from '@wireapp/protocol-messaging';
 import { AbortReason } from '..';
-import type { AssetService } from '../AssetService';
-import type { ButtonActionConfirmationContent, ButtonActionContent, CallingContent, FileContent, FileMetaDataContent, ImageContent, KnockContent, LegalHoldStatus, LinkPreviewContent, LinkPreviewUploadedContent, LocationContent, ReactionContent } from '../content';
+import { EncryptedAssetUploaded } from '../../cryptography';
+import type { ButtonActionConfirmationContent, ButtonActionContent, CallingContent, FileContent, FileMetaDataContent, ImageContent, KnockContent, LegalHoldStatus, LocationContent, ReactionContent } from '../content';
 import { CompositeContentBuilder } from './CompositeContentBuilder';
 import type { ButtonActionConfirmationMessage, ButtonActionMessage, CallMessage, ConfirmationMessage, FileAssetAbortMessage, FileAssetMessage, FileAssetMetaDataMessage, ImageAssetMessageOutgoing, LocationMessage, PingMessage, ReactionMessage, ResetSessionMessage } from './OtrMessage';
 import { TextContentBuilder } from './TextContentBuilder';
 interface BaseOptions {
     conversationId: string;
+    from: string;
     messageId?: string;
 }
 interface CreateImageOptions extends BaseOptions {
-    cipherOptions?: CipherOptions;
     expectsReadConfirmation?: boolean;
+    asset: EncryptedAssetUploaded;
     image: ImageContent;
     legalHoldStatus?: LegalHoldStatus;
 }
-interface CreateFileOptions {
-    cipherOptions?: CipherOptions;
-    conversationId: string;
+interface CreateFileOptions extends BaseOptions {
     expectsReadConfirmation?: boolean;
+    asset: EncryptedAssetUploaded;
     file: FileContent;
     legalHoldStatus?: LegalHoldStatus;
     originalMessageId: string;
@@ -37,6 +35,7 @@ interface CreateFileMetadataOptions extends BaseOptions {
 interface CreateFileAbortOptions {
     conversationId: string;
     expectsReadConfirmation?: boolean;
+    from: string;
     legalHoldStatus?: LegalHoldStatus;
     originalMessageId: string;
     reason: AbortReason;
@@ -68,26 +67,21 @@ interface CreateActionMessageOptions extends BaseOptions {
     content: ButtonActionContent;
 }
 export declare class MessageBuilder {
-    private readonly apiClient;
-    private readonly assetService;
-    constructor(apiClient: APIClient, assetService: AssetService);
-    createEditedText({ conversationId, messageId, newMessageText, originalMessageId, }: CreateEditedTextOptions): TextContentBuilder;
-    createFileData({ conversationId, cipherOptions, expectsReadConfirmation, file, legalHoldStatus, originalMessageId, }: CreateFileOptions): Promise<FileAssetMessage>;
-    createFileMetadata({ conversationId, expectsReadConfirmation, legalHoldStatus, messageId, metaData, }: CreateFileMetadataOptions): FileAssetMetaDataMessage;
-    createFileAbort({ conversationId, expectsReadConfirmation, legalHoldStatus, originalMessageId, reason, }: CreateFileAbortOptions): Promise<FileAssetAbortMessage>;
-    createImage({ conversationId, cipherOptions, expectsReadConfirmation, image, legalHoldStatus, messageId, }: CreateImageOptions): Promise<ImageAssetMessageOutgoing>;
-    createLocation({ conversationId, location, messageId, }: CreateLocationOptions): LocationMessage;
-    createCall({ content, conversationId, messageId }: CreateCallOptions): CallMessage;
-    createReaction({ conversationId, messageId, reaction, }: CreateReactionOptions): ReactionMessage;
-    createText({ conversationId, messageId, text, }: CreateTextOptions): TextContentBuilder;
-    createConfirmation({ conversationId, firstMessageId, messageId, moreMessageIds, type, }: CreateConfirmationOptions): ConfirmationMessage;
-    createButtonActionMessage({ content, conversationId, messageId, }: CreateActionMessageOptions): ButtonActionMessage;
-    createButtonActionConfirmationMessage({ content, conversationId, messageId, }: CreateButtonActionConfirmationOptions): ButtonActionConfirmationMessage;
-    createComposite({ conversationId, messageId }: BaseOptions): CompositeContentBuilder;
-    createPing({ conversationId, messageId, ping, }: CreatePingOptions): PingMessage;
-    createSessionReset({ conversationId, messageId }: BaseOptions): ResetSessionMessage;
-    createLinkPreview(linkPreview: LinkPreviewContent): Promise<LinkPreviewUploadedContent>;
+    static createEditedText(payload: CreateEditedTextOptions): TextContentBuilder;
+    static createFileData(payload: CreateFileOptions): FileAssetMessage;
+    static createFileMetadata(payload: CreateFileMetadataOptions): FileAssetMetaDataMessage;
+    static createFileAbort(payload: CreateFileAbortOptions): FileAssetAbortMessage;
+    static createImage(payload: CreateImageOptions): ImageAssetMessageOutgoing;
+    static createLocation(payload: CreateLocationOptions): LocationMessage;
+    static createCall(payload: CreateCallOptions): CallMessage;
+    static createReaction(payload: CreateReactionOptions): ReactionMessage;
+    static createText(payload: CreateTextOptions): TextContentBuilder;
+    static createConfirmation(payload: CreateConfirmationOptions): ConfirmationMessage;
+    static createButtonActionMessage(payload: CreateActionMessageOptions): ButtonActionMessage;
+    static createButtonActionConfirmationMessage(payload: CreateButtonActionConfirmationOptions): ButtonActionConfirmationMessage;
+    static createComposite(payload: BaseOptions): CompositeContentBuilder;
+    static createPing(payload: CreatePingOptions): PingMessage;
+    static createSessionReset(payload: BaseOptions): ResetSessionMessage;
     static createId(): string;
-    private getSelfUserId;
 }
 export {};

package/src/main/conversation/message/MessageBuilder.js

@@ -27,249 +27,93 @@ const uuidjs_1 = __importDefault(require("uuidjs"));
 const __1 = require("..");
 const CompositeContentBuilder_1 = require("./CompositeContentBuilder");
 const TextContentBuilder_1 = require("./TextContentBuilder");
+function createCommonProperties(options) {
+    return {
+        id: options.messageId || MessageBuilder.createId(),
+        conversation: options.conversationId,
+        from: options.from,
+        source: __1.PayloadBundleSource.LOCAL,
+        state: __1.PayloadBundleState.OUTGOING_UNSENT,
+        timestamp: Date.now(),
+    };
+}
 class MessageBuilder {
-    constructor(apiClient, assetService) {
-        this.apiClient = apiClient;
-        this.assetService = assetService;
-    }
-    createEditedText({ conversationId, messageId = MessageBuilder.createId(), newMessageText, originalMessageId, }) {
-        const content = {
-            originalMessageId,
-            text: newMessageText,
-        };
-        const payloadBundle = {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.MESSAGE_EDIT,
-        };
-        return new TextContentBuilder_1.TextContentBuilder(payloadBundle);
-    }
-    async createFileData({ conversationId, cipherOptions, expectsReadConfirmation, file, legalHoldStatus, originalMessageId, }) {
-        const imageAsset = await this.assetService.uploadFileAsset(file, Object.assign({}, cipherOptions));
-        const content = {
-            asset: imageAsset,
-            expectsReadConfirmation,
-            file,
-            legalHoldStatus,
-        };
-        return {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: originalMessageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.ASSET,
-        };
-    }
-    createFileMetadata({ conversationId, expectsReadConfirmation, legalHoldStatus, messageId = MessageBuilder.createId(), metaData, }) {
-        const content = {
-            expectsReadConfirmation,
-            legalHoldStatus,
-            metaData,
-        };
-        return {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.ASSET_META,
-        };
-    }
-    async createFileAbort({ conversationId, expectsReadConfirmation, legalHoldStatus, originalMessageId, reason, }) {
-        const content = {
-            expectsReadConfirmation,
-            legalHoldStatus,
-            reason,
-        };
-        return {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: originalMessageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.ASSET_ABORT,
-        };
-    }
-    async createImage({ conversationId, cipherOptions, expectsReadConfirmation, image, legalHoldStatus, messageId = MessageBuilder.createId(), }) {
-        const imageAsset = await this.assetService.uploadImageAsset(image, Object.assign({}, cipherOptions));
-        const content = {
-            asset: imageAsset,
-            expectsReadConfirmation,
-            image,
-            legalHoldStatus,
-        };
-        return {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.ASSET_IMAGE,
-        };
-    }
-    createLocation({ conversationId, location, messageId = MessageBuilder.createId(), }) {
-        return {
-            content: location,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.LOCATION,
-        };
-    }
-    createCall({ content, conversationId, messageId = MessageBuilder.createId() }) {
-        return {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.CALL,
-        };
-    }
-    createReaction({ conversationId, messageId = MessageBuilder.createId(), reaction, }) {
-        return {
-            content: reaction,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.REACTION,
-        };
-    }
-    createText({ conversationId, messageId = MessageBuilder.createId(), text, }) {
-        const content = { text };
-        const payloadBundle = {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.TEXT,
-        };
-        return new TextContentBuilder_1.TextContentBuilder(payloadBundle);
-    }
-    createConfirmation({ conversationId, firstMessageId, messageId = MessageBuilder.createId(), moreMessageIds, type, }) {
-        const content = { firstMessageId, moreMessageIds, type };
-        return {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.CONFIRMATION,
-        };
-    }
-    createButtonActionMessage({ content, conversationId, messageId = MessageBuilder.createId(), }) {
-        return {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.BUTTON_ACTION,
-        };
-    }
-    createButtonActionConfirmationMessage({ content, conversationId, messageId = MessageBuilder.createId(), }) {
-        return {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.BUTTON_ACTION_CONFIRMATION,
-        };
-    }
-    createComposite({ conversationId, messageId = MessageBuilder.createId() }) {
-        const content = {};
-        const payloadBundle = {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.COMPOSITE,
-        };
-        return new CompositeContentBuilder_1.CompositeContentBuilder(payloadBundle);
-    }
-    createPing({ conversationId, messageId = MessageBuilder.createId(), ping = {
-        hotKnock: false,
-    }, }) {
-        return {
-            content: ping,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.PING,
-        };
-    }
-    createSessionReset({ conversationId, messageId = MessageBuilder.createId() }) {
-        const content = {
-            clientAction: protocol_messaging_1.ClientAction.RESET_SESSION,
-        };
-        return {
-            content,
-            conversation: conversationId,
-            from: this.getSelfUserId(),
-            id: messageId,
-            source: __1.PayloadBundleSource.LOCAL,
-            state: __1.PayloadBundleState.OUTGOING_UNSENT,
-            timestamp: Date.now(),
-            type: __1.PayloadBundleType.CLIENT_ACTION,
-        };
-    }
-    async createLinkPreview(linkPreview) {
-        const linkPreviewUploaded = Object.assign({}, linkPreview);
-        const linkPreviewImage = linkPreview.image;
-        if (linkPreviewImage) {
-            const imageAsset = await this.assetService.uploadImageAsset(linkPreviewImage);
-            delete linkPreviewUploaded.image;
-            linkPreviewUploaded.imageUploaded = {
-                asset: imageAsset,
-                image: linkPreviewImage,
-            };
-        }
-        return linkPreviewUploaded;
+    static createEditedText(payload) {
+        return new TextContentBuilder_1.TextContentBuilder(Object.assign(Object.assign({}, createCommonProperties(payload)), { content: {
+                originalMessageId: payload.originalMessageId,
+                text: payload.newMessageText,
+            }, type: __1.PayloadBundleType.MESSAGE_EDIT }));
+    }
+    static createFileData(payload) {
+        const { asset, expectsReadConfirmation, file, legalHoldStatus, originalMessageId } = payload;
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: {
+                asset,
+                expectsReadConfirmation,
+                file,
+                legalHoldStatus,
+            }, id: originalMessageId, type: __1.PayloadBundleType.ASSET });
+    }
+    static createFileMetadata(payload) {
+        const { expectsReadConfirmation, legalHoldStatus, metaData } = payload;
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: {
+                expectsReadConfirmation,
+                legalHoldStatus,
+                metaData,
+            }, type: __1.PayloadBundleType.ASSET_META });
+    }
+    static createFileAbort(payload) {
+        const { expectsReadConfirmation, legalHoldStatus, reason } = payload;
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: {
+                expectsReadConfirmation,
+                legalHoldStatus,
+                reason,
+            }, id: payload.originalMessageId, type: __1.PayloadBundleType.ASSET_ABORT });
+    }
+    static createImage(payload) {
+        const { expectsReadConfirmation, image, asset, legalHoldStatus } = payload;
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: {
+                expectsReadConfirmation,
+                image,
+                asset,
+                legalHoldStatus,
+            }, type: __1.PayloadBundleType.ASSET_IMAGE });
+    }
+    static createLocation(payload) {
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: payload.location, type: __1.PayloadBundleType.LOCATION });
+    }
+    static createCall(payload) {
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: payload.content, type: __1.PayloadBundleType.CALL });
+    }
+    static createReaction(payload) {
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: payload.reaction, type: __1.PayloadBundleType.REACTION });
+    }
+    static createText(payload) {
+        return new TextContentBuilder_1.TextContentBuilder(Object.assign(Object.assign({}, createCommonProperties(payload)), { content: { text: payload.text }, type: __1.PayloadBundleType.TEXT }));
+    }
+    static createConfirmation(payload) {
+        const { firstMessageId, moreMessageIds, type } = payload;
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: { firstMessageId, moreMessageIds, type }, type: __1.PayloadBundleType.CONFIRMATION });
+    }
+    static createButtonActionMessage(payload) {
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: payload.content, type: __1.PayloadBundleType.BUTTON_ACTION });
+    }
+    static createButtonActionConfirmationMessage(payload) {
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: payload.content, type: __1.PayloadBundleType.BUTTON_ACTION_CONFIRMATION });
+    }
+    static createComposite(payload) {
+        return new CompositeContentBuilder_1.CompositeContentBuilder(Object.assign(Object.assign({}, createCommonProperties(payload)), { content: {}, type: __1.PayloadBundleType.COMPOSITE }));
+    }
+    static createPing(payload) {
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: payload.ping || { hotKnock: false }, type: __1.PayloadBundleType.PING });
+    }
+    static createSessionReset(payload) {
+        return Object.assign(Object.assign({}, createCommonProperties(payload)), { content: {
+                clientAction: protocol_messaging_1.ClientAction.RESET_SESSION,
+            }, type: __1.PayloadBundleType.CLIENT_ACTION });
     }
     static createId() {
         return uuidjs_1.default.genV4().toString();
     }
-    getSelfUserId() {
-        return this.apiClient.context.userId;
-    }
 }
 exports.MessageBuilder = MessageBuilder;
 //# sourceMappingURL=MessageBuilder.js.map

package/src/main/conversation/message/MessageService.js

@@ -59,7 +59,10 @@ class MessageService {
             plainTextPayload = externalPayload.text;
             cipherText = externalPayload.cipherText;
         }
-        const encryptedPayload = await this.cryptographyService.encrypt(plainTextPayload, recipients);
+        const { encrypted, missing } = await this.cryptographyService.encrypt(plainTextPayload, recipients);
+        const encryptedPayload = Object.keys(missing).length
+            ? await this.reencryptAfterMismatch({ missing, deleted: {} }, encrypted, plainText)
+            : encrypted;
         const send = (payload) => {
             return options.sendAsProtobuf
                 ? this.sendOTRProtobufMessage(sendingClientId, payload, Object.assign(Object.assign({}, options), { assetData: cipherText }))
@@ -97,7 +100,10 @@ class MessageService {
         const send = (payload) => {
             return this.sendFederatedOtrMessage(sendingClientId, payload, options);
         };
-        const encryptedPayload = await this.cryptographyService.encryptQualified(plainText, recipients);
+        const { encrypted, missing } = await this.cryptographyService.encryptQualified(plainText, recipients);
+        const encryptedPayload = Object.keys(missing).length
+            ? await this.reencryptAfterFederatedMismatch({ missing, deleted: {} }, encrypted, plainText)
+            : encrypted;
         try {
             return await send(encryptedPayload);
         }
@@ -216,8 +222,8 @@ class MessageService {
         deleted.forEach(({ userId, data }) => data.forEach(clientId => delete recipients[userId.id][clientId]));
         if (missing.length) {
             const missingPreKeyBundles = await this.apiClient.user.api.postMultiPreKeyBundles(mismatch.missing);
-            const reEncrypted = await this.cryptographyService.encrypt(plainText, missingPreKeyBundles);
-            const reEncryptedPayloads = (0, UserClientsUtil_1.flattenUserClients)(reEncrypted);
+            const { encrypted } = await this.cryptographyService.encrypt(plainText, missingPreKeyBundles);
+            const reEncryptedPayloads = (0, UserClientsUtil_1.flattenUserClients)(encrypted);
             // add missing clients to the recipients
             reEncryptedPayloads.forEach(({ data, userId }) => (recipients[userId.id] = Object.assign(Object.assign({}, recipients[userId.id]), data)));
         }
@@ -238,8 +244,8 @@ class MessageService {
         deleted.forEach(({ userId, data }) => data.forEach(clientId => delete recipients[userId.domain][userId.id][clientId]));
         if (Object.keys(missing).length) {
             const missingPreKeyBundles = await this.apiClient.user.api.postQualifiedMultiPreKeyBundles(mismatch.missing);
-            const reEncrypted = await this.cryptographyService.encryptQualified(plainText, missingPreKeyBundles);
-            const reEncryptedPayloads = (0, UserClientsUtil_1.flattenQualifiedUserClients)(reEncrypted);
+            const { encrypted } = await this.cryptographyService.encryptQualified(plainText, missingPreKeyBundles);
+            const reEncryptedPayloads = (0, UserClientsUtil_1.flattenQualifiedUserClients)(encrypted);
             reEncryptedPayloads.forEach(({ data, userId }) => (recipients[userId.domain][userId.id] = Object.assign(Object.assign({}, recipients[userId.domain][userId.id]), data)));
         }
         return recipients;

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

@@ -29,9 +29,14 @@ export declare class CryptographyService {
     static convertBase64RecipientsToArray(recipients: OTRRecipients<string>): OTRRecipients<Uint8Array>;
     createCryptobox(): Promise<SerializedPreKey[]>;
     decrypt(sessionId: string, encodedCiphertext: string): Promise<Uint8Array>;
-    private static dismantleSessionId;
-    encryptQualified(plainText: Uint8Array, preKeyBundles: QualifiedUserPreKeyBundleMap | QualifiedUserClients): Promise<QualifiedOTRRecipients>;
-    encrypt(plainText: Uint8Array, users: UserPreKeyBundleMap | UserClients, domain?: string): Promise<OTRRecipients<Uint8Array>>;
+    encryptQualified(plainText: Uint8Array, preKeyBundles: QualifiedUserPreKeyBundleMap | QualifiedUserClients): Promise<{
+        missing: QualifiedUserClients;
+        encrypted: QualifiedOTRRecipients;
+    }>;
+    encrypt(plainText: Uint8Array, users: UserPreKeyBundleMap | UserClients, domain?: string): Promise<{
+        missing: UserClients;
+        encrypted: OTRRecipients<Uint8Array>;
+    }>;
     private encryptPayloadForSession;
     initCryptobox(): Promise<void>;
     deleteCryptographyStores(): Promise<boolean[]>;

package/src/main/cryptography/CryptographyService.js

@@ -81,41 +81,39 @@ class CryptographyService {
         const messageBytes = bazinga64_1.Decoder.fromBase64(encodedCiphertext).asBytes;
         return this.cryptobox.decrypt(sessionId, messageBytes.buffer);
     }
-    static dismantleSessionId(sessionId) {
-        // see https://regex101.com/r/c8FtCw/1
-        const regex = /((?<domain>.+)@)?(?<userId>.+)@(?<clientId>.+)$/g;
-        const match = regex.exec(sessionId);
-        const { domain, userId, clientId } = (match === null || match === void 0 ? void 0 : match.groups) || {};
-        return { clientId, domain, userId };
-    }
     async encryptQualified(plainText, preKeyBundles) {
         const qualifiedOTRRecipients = {};
+        const missing = {};
         for (const [domain, preKeyBundleMap] of Object.entries(preKeyBundles)) {
-            qualifiedOTRRecipients[domain] = await this.encrypt(plainText, preKeyBundleMap, domain);
+            const result = await this.encrypt(plainText, preKeyBundleMap, domain);
+            qualifiedOTRRecipients[domain] = result.encrypted;
+            missing[domain] = result.missing;
         }
-        return qualifiedOTRRecipients;
+        return {
+            encrypted: qualifiedOTRRecipients,
+            missing,
+        };
     }
     async encrypt(plainText, users, domain) {
-        const bundles = [];
+        const encrypted = {};
+        const missing = {};
         for (const userId in users) {
             const clientIds = (0, util_1.isUserClients)(users) ? users[userId] : Object.keys(users[userId]);
             for (const clientId of clientIds) {
                 const base64PreKey = (0, util_1.isUserClients)(users) ? undefined : users[userId][clientId].key;
                 const sessionId = CryptographyService.constructSessionId(userId, clientId, domain || null);
-                bundles.push(this.encryptPayloadForSession(sessionId, plainText, base64PreKey));
+                const result = await this.encryptPayloadForSession(sessionId, plainText, base64PreKey);
+                if (result) {
+                    encrypted[userId] || (encrypted[userId] = {});
+                    encrypted[userId][clientId] = result.encryptedPayload;
+                }
+                else {
+                    missing[userId] || (missing[userId] = []);
+                    missing[userId].push(clientId);
+                }
             }
         }
-        const payloads = await Promise.all(bundles);
-        return payloads.reduce((recipients, payload) => {
-            if (!payload) {
-                return recipients;
-            }
-            const { encryptedPayload, sessionId } = payload;
-            const { userId, clientId } = CryptographyService.dismantleSessionId(sessionId);
-            recipients[userId] || (recipients[userId] = {});
-            recipients[userId][clientId] = encryptedPayload;
-            return recipients;
-        }, {});
+        return { encrypted, missing };
     }
     async encryptPayloadForSession(sessionId, plainText, base64EncodedPreKey) {
         this.logger.log(`Encrypting payload for session ID "${sessionId}"`);

package/src/main/index.d.ts

@@ -4,8 +4,10 @@ import * as conversation from './conversation/';
 import { CoreError } from './CoreError';
 import * as cryptography from './cryptography/';
 import * as util from './util';
+import { MessageBuilder } from './conversation/message/MessageBuilder';
 declare const _default: {
     Account: typeof Account;
+    MessageBuilder: typeof MessageBuilder;
     CoreError: typeof CoreError;
     auth: typeof auth;
     conversation: typeof conversation;

package/src/main/index.js

@@ -42,8 +42,10 @@ const conversation = __importStar(require("./conversation/"));
 const CoreError_1 = require("./CoreError");
 const cryptography = __importStar(require("./cryptography/"));
 const util = __importStar(require("./util"));
+const MessageBuilder_1 = require("./conversation/message/MessageBuilder");
 module.exports = {
     Account: Account_1.Account,
+    MessageBuilder: MessageBuilder_1.MessageBuilder,
     CoreError: CoreError_1.CoreError,
     auth,
     conversation,

package/src/main/linkPreview/LinkPreviewService.d.ts

@@ -0,0 +1,7 @@
+import { AssetService } from '../conversation';
+import { LinkPreviewContent, LinkPreviewUploadedContent } from '../conversation/content';
+export declare class LinkPreviewService {
+    private readonly assetService;
+    constructor(assetService: AssetService);
+    uploadLinkPreviewImage(linkPreview: LinkPreviewContent): Promise<LinkPreviewUploadedContent>;
+}

package/src/main/linkPreview/LinkPreviewService.js

@@ -0,0 +1,52 @@
+"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 __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.LinkPreviewService = void 0;
+class LinkPreviewService {
+    constructor(assetService) {
+        this.assetService = assetService;
+    }
+    async uploadLinkPreviewImage(linkPreview) {
+        const { image } = linkPreview, preview = __rest(linkPreview, ["image"]);
+        if (!image) {
+            return preview;
+        }
+        const uploadedLinkPreview = preview;
+        const asset = await (await this.assetService.uploadAsset(linkPreview.image.data)).response;
+        uploadedLinkPreview.imageUploaded = {
+            asset,
+            image,
+        };
+        return uploadedLinkPreview;
+    }
+}
+exports.LinkPreviewService = LinkPreviewService;
+//# sourceMappingURL=LinkPreviewService.js.map

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

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

package/src/main/linkPreview/index.js

@@ -0,0 +1,32 @@
+"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("./LinkPreviewService"), exports);
+//# sourceMappingURL=index.js.map