refactor to Visible and ControlMessage types

js/views/invite_contacts_dialog_view.js

@@ -30,7 +30,7 @@
       this.chatName = convo.get('name');
       this.chatServer = convo.get('server');
       this.channelId = convo.get('channelId');
-      this.isPublic = !!convo.cachedProps.isPublic;
+      this.isPublic = !!convo.isPublic();
       this.convo = convo;
 
       this.$el.focus();

ts/components/conversation/InviteContactsDialog.tsx

@@ -44,7 +44,7 @@ class InviteContactsDialogInner extends React.Component<Props, State> {
         id: d.id,
         authorPhoneNumber: d.id,
         authorProfileName: name,
-        authorAvatarPath: d?.cachedProps?.avatarPath,
+        authorAvatarPath: d?.getAvatarPath(),
         selected: false,
         authorName: name,
         checkmarked: false,

ts/components/conversation/UpdateGroupMembersDialog.tsx

@@ -53,7 +53,7 @@ export class UpdateGroupMembersDialog extends React.Component<Props, State> {
         id: d.id,
         authorPhoneNumber: d.id,
         authorProfileName: name,
-        authorAvatarPath: d?.cachedProps?.avatarPath,
+        authorAvatarPath: d?.getAvatarPath(),
         selected: false,
         authorName: name, // different from ProfileName?
         checkmarked: false,

ts/models/conversation.ts

@@ -3,23 +3,14 @@ import _ from 'lodash';
 import { ConversationType } from '../receiver/common';
 import { getMessageQueue } from '../session';
 import { ConversationController } from '../session/conversations';
-import {
+import { ClosedGroupVisibleMessage } from '../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
-  ChatMessage,
-  ChatMessageParams,
-  ExpirationTimerUpdateMessage,
-  GroupInvitationMessage,
-  OpenGroupMessage,
-  ReadReceiptMessage,
-  TypingMessage,
-} from '../session/messages/outgoing';
-import { ClosedGroupChatMessage } from '../session/messages/outgoing/content/data/group/ClosedGroupChatMessage';
 import { OpenGroup, PubKey } from '../session/types';
 import { ToastUtils, UserUtils } from '../session/utils';
 import { BlockedNumberController } from '../util';
 import { MessageController } from '../session/messages';
 import { leaveClosedGroup } from '../session/group';
 import { SignalService } from '../protobuf';
-import { MessageCollection, MessageModel } from './message';
+import { MessageModel } from './message';
 import { MessageAttributesOptionals, MessageModelType } from './messageType';
 import autoBind from 'auto-bind';
 import {
@@ -40,6 +31,15 @@ import {
   ConversationType as ReduxConversationType,
   LastMessageStatusType,
 } from '../state/ducks/conversations';
+import { OpenGroupMessage } from '../session/messages/outgoing';
+import { ExpirationTimerUpdateMessage } from '../session/messages/outgoing/controlMessage/ExpirationTimerUpdateMessage';
+import { TypingMessage } from '../session/messages/outgoing/controlMessage/TypingMessage';
+import {
+  VisibleMessage,
+  VisibleMessageParams,
+} from '../session/messages/outgoing/visibleMessage/VisibleMessage';
+import { GroupInvitationMessage } from '../session/messages/outgoing/visibleMessage/GroupInvitationMessage';
+import { ReadReceiptMessage } from '../session/messages/outgoing/controlMessage/receipt/ReadReceiptMessage';
 
 export interface ConversationAttributes {
   profileName?: string;
@@ -633,7 +633,7 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
         await getMessageQueue().sendToOpenGroup(openGroupMessage);
         return;
       }
-      const chatMessageParams: ChatMessageParams = {
+      const chatMessageParams: VisibleMessageParams = {
         body: uploads.body,
         identifier: id,
         timestamp: sentAt,
@@ -648,7 +648,7 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
       if (this.isPrivate()) {
         if (this.isMe()) {
           chatMessageParams.syncTarget = this.id;
-          const chatMessageMe = new ChatMessage(chatMessageParams);
+          const chatMessageMe = new VisibleMessage(chatMessageParams);
 
           await getMessageQueue().sendSyncMessage(chatMessageMe);
           return;
@@ -671,7 +671,7 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
           );
           return;
         }
-        const chatMessagePrivate = new ChatMessage(chatMessageParams);
+        const chatMessagePrivate = new VisibleMessage(chatMessageParams);
 
         await getMessageQueue().sendToPubKey(
           destinationPubkey,
@@ -681,14 +681,14 @@ export class ConversationModel extends Backbone.Model<ConversationAttributes> {
       }
 
       if (this.isMediumGroup()) {
-        const chatMessageMediumGroup = new ChatMessage(chatMessageParams);
+        const chatMessageMediumGroup = new VisibleMessage(chatMessageParams);
-        const closedGroupChatMessage = new ClosedGroupChatMessage({
+        const closedGroupVisibleMessage = new ClosedGroupVisibleMessage({
           chatMessage: chatMessageMediumGroup,
           groupId: destination,
         });
 
         // we need the return await so that errors are caught in the catch {}
-        await getMessageQueue().sendToGroup(closedGroupChatMessage);
+        await getMessageQueue().sendToGroup(closedGroupVisibleMessage);
         return;
       }
 

ts/models/message.ts

@@ -7,12 +7,11 @@ import { getMessageQueue, Types, Utils } from '../../ts/session';
 import { ConversationController } from '../../ts/session/conversations';
 import { MessageController } from '../../ts/session/messages';
 import {
-  ChatMessage,
   DataMessage,
   OpenGroupMessage,
 } from '../../ts/session/messages/outgoing';
-import { ClosedGroupChatMessage } from '../../ts/session/messages/outgoing/content/data/group/ClosedGroupChatMessage';
+import { ClosedGroupVisibleMessage } from '../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
-import { EncryptionType, PubKey, RawMessage } from '../../ts/session/types';
+import { PubKey } from '../../ts/session/types';
 import { ToastUtils, UserUtils } from '../../ts/session/utils';
 import {
   fillMessageAttributesWithDefaults,
@@ -24,6 +23,7 @@ import autoBind from 'auto-bind';
 import { saveMessage } from '../../ts/data/data';
 import { ConversationModel } from './conversation';
 import { actions as conversationActions } from '../state/ducks/conversations';
+import { VisibleMessage } from '../session/messages/outgoing/visibleMessage/VisibleMessage';
 
 export class MessageModel extends Backbone.Model<MessageAttributes> {
   public propsForTimerNotification: any;
@@ -889,7 +889,7 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
         delete chatParams.lokiProfile;
       }
 
-      const chatMessage = new ChatMessage(chatParams);
+      const chatMessage = new VisibleMessage(chatParams);
 
       // Special-case the self-send case - we send only a sync message
       if (conversation.isMe()) {
@@ -912,13 +912,13 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
         );
       }
 
-      const closedGroupChatMessage = new ClosedGroupChatMessage({
+      const closedGroupVisibleMessage = new ClosedGroupVisibleMessage({
         identifier: this.id,
         chatMessage,
         groupId: this.get('conversationId'),
       });
 
-      return getMessageQueue().sendToGroup(closedGroupChatMessage);
+      return getMessageQueue().sendToGroup(closedGroupVisibleMessage);
     } catch (e) {
       await this.saveErrors(e);
       return null;
@@ -1033,7 +1033,7 @@ export class MessageModel extends Backbone.Model<MessageAttributes> {
       if (!conversation) {
         throw new Error('Cannot trigger syncMessage with unknown convo.');
       }
-      const syncMessage = ChatMessage.buildSyncMessage(
+      const syncMessage = VisibleMessage.buildSyncMessage(
         this.id,
         dataMessage,
         conversation.id,

ts/receiver/closedGroups.ts

@@ -22,7 +22,7 @@ import {
 import {
   ClosedGroupNewMessage,
   ClosedGroupNewMessageParams,
-} from '../session/messages/outgoing/content/data/group/ClosedGroupNewMessage';
+} from '../session/messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
 
 import { ECKeyPair, HexKeyPair } from './keypairs';
 import { UserUtils } from '../session/utils';
@@ -30,7 +30,7 @@ import { ConversationModel } from '../models/conversation';
 import _ from 'lodash';
 import { forceSyncConfigurationNowIfNeeded } from '../session/utils/syncUtils';
 import { MessageController } from '../session/messages';
-import { ClosedGroupEncryptionPairReplyMessage } from '../session/messages/outgoing/content/data/group';
+import { ClosedGroupEncryptionPairReplyMessage } from '../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairReplyMessage';
 import { queueAllCachedFromSource } from './receiver';
 import { actions as conversationActions } from '../state/ducks/conversations';
 

ts/receiver/dataMessage.ts

@@ -8,7 +8,6 @@ import { handleMessageJob } from './queuedJob';
 import { downloadAttachment } from './attachments';
 import _ from 'lodash';
 import { StringUtils, UserUtils } from '../session/utils';
-import { DeliveryReceiptMessage } from '../session/messages/outgoing';
 import { getMessageQueue } from '../session';
 import { ConversationController } from '../session/conversations';
 import { handleClosedGroupControlMessage } from './closedGroups';
@@ -16,6 +15,7 @@ import { MessageModel } from '../models/message';
 import { MessageModelType } from '../models/messageType';
 import { getMessageBySender } from '../../ts/data/data';
 import { ConversationModel } from '../models/conversation';
+import { DeliveryReceiptMessage } from '../session/messages/outgoing/controlMessage/receipt/DeliveryReceiptMessage';
 
 export async function updateProfile(
   conversation: ConversationModel,

ts/receiver/receiver.ts

@@ -295,10 +295,10 @@ export async function handlePublicMessage(messageData: any) {
     await updateProfile(conversation, profile, profileKey);
   }
 
-  const isPublicChatMessage =
+  const isPublicVisibleMessage =
     group && group.id && !!group.id.match(/^publicChat:/);
 
-  if (!isPublicChatMessage) {
+  if (!isPublicVisibleMessage) {
     throw new Error(
       'handlePublicMessage Should only be called with public message groups'
     );

ts/session/group/index.ts

@@ -18,21 +18,19 @@ import { generateCurve25519KeyPairWithoutPrefix } from '../crypto';
 import { encryptUsingSessionProtocol } from '../crypto/MessageEncrypter';
 import { ECKeyPair } from '../../receiver/keypairs';
 import { UserUtils } from '../utils';
-import { ClosedGroupMemberLeftMessage } from '../messages/outgoing/content/data/group/ClosedGroupMemberLeftMessage';
+import { ClosedGroupMemberLeftMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupMemberLeftMessage';
-import {
-  ClosedGroupAddedMembersMessage,
-  ClosedGroupEncryptionPairMessage,
-  ClosedGroupEncryptionPairRequestMessage,
-  ClosedGroupNameChangeMessage,
-  ClosedGroupNewMessage,
-  ClosedGroupRemovedMembersMessage,
-} from '../messages/outgoing/content/data/group';
 import { ConversationModel } from '../../models/conversation';
 import { MessageModel } from '../../models/message';
 import { MessageModelType } from '../../models/messageType';
 import { MessageController } from '../messages';
 import { distributingClosedGroupEncryptionKeyPairs } from '../../receiver/closedGroups';
 import { getMessageQueue } from '..';
+import { ClosedGroupAddedMembersMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupAddedMembersMessage';
+import { ClosedGroupEncryptionPairMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairMessage';
+import { ClosedGroupEncryptionPairRequestMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairRequestMessage';
+import { ClosedGroupNameChangeMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNameChangeMessage';
+import { ClosedGroupNewMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
+import { ClosedGroupRemovedMembersMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupRemovedMembersMessage';
 
 export interface GroupInfo {
   id: string;

ts/session/messages/outgoing/ContentMessage.ts

@@ -1,5 +1,5 @@
-import { Message } from '../Message';
+import { Message } from '.';
-import { SignalService } from '../../../../protobuf';
+import { SignalService } from '../../../protobuf';
 
 export abstract class ContentMessage extends Message {
   public plainTextBuffer(): Uint8Array {

ts/session/messages/outgoing/DataMessage.ts

@@ -1,6 +1,6 @@
-import { ContentMessage } from '../ContentMessage';
+import { ContentMessage } from '.';
-import { SignalService } from '../../../../../protobuf';
+import { SignalService } from '../../../protobuf';
-import { TTL_DEFAULT } from '../../../../constants';
+import { TTL_DEFAULT } from '../../constants';
 
 export abstract class DataMessage extends ContentMessage {
   public abstract dataProto(): SignalService.DataMessage;

ts/session/messages/outgoing/OpenGroupMessage.ts

@@ -1,6 +1,10 @@
 import { Message, MessageParams } from './Message';
-import { AttachmentPointer, Preview, Quote } from './content';
 import { OpenGroup } from '../../types/OpenGroup';
+import {
+  AttachmentPointer,
+  Preview,
+  Quote,
+} from './visibleMessage/VisibleMessage';
 
 interface OpenGroupMessageParams extends MessageParams {
   group: OpenGroup;

ts/session/messages/outgoing/content/data/group/ClosedGroupUpdateMessage.ts

@@ -1,51 +0,0 @@
-import { SignalService } from '../../../../../../protobuf';
-import {
-  ClosedGroupMessage,
-  ClosedGroupMessageParams,
-} from './ClosedGroupMessage';
-import { fromHexToArray } from '../../../../../utils/String';
-
-export interface ClosedGroupUpdateMessageParams
-  extends ClosedGroupMessageParams {
-  name: string;
-  members: Array<string>;
-  expireTimer: number;
-}
-
-export class ClosedGroupUpdateMessage extends ClosedGroupMessage {
-  private readonly name: string;
-  private readonly members: Array<string>;
-
-  constructor(params: ClosedGroupUpdateMessageParams) {
-    super({
-      timestamp: params.timestamp,
-      identifier: params.identifier,
-      groupId: params.groupId,
-      expireTimer: params.expireTimer,
-    });
-    this.name = params.name;
-    this.members = params.members;
-
-    // members can be empty. It means noone is in the group anymore and it happens when an admin leaves the group
-    if (!params.members) {
-      throw new Error('Members must be set');
-    }
-    if (!params.name || params.name.length === 0) {
-      throw new Error('Name must cannot be empty');
-    }
-  }
-
-  public dataProto(): SignalService.DataMessage {
-    const dataMessage = new SignalService.DataMessage();
-
-    dataMessage.closedGroupControlMessage = new SignalService.DataMessage.ClosedGroupControlMessage();
-    dataMessage.closedGroupControlMessage.type =
-      SignalService.DataMessage.ClosedGroupControlMessage.Type.UPDATE;
-    dataMessage.closedGroupControlMessage.name = this.name;
-    dataMessage.closedGroupControlMessage.members = this.members.map(
-      fromHexToArray
-    );
-
-    return dataMessage;
-  }
-}

ts/session/messages/outgoing/content/data/group/index.ts

@@ -1,8 +0,0 @@
-export * from './ClosedGroupEncryptionPairMessage';
-export * from './ClosedGroupEncryptionPairRequestMessage';
-export * from './ClosedGroupEncryptionPairReplyMessage';
-export * from './ClosedGroupNewMessage';
-export * from './ClosedGroupAddedMembersMessage';
-export * from './ClosedGroupNameChangeMessage';
-export * from './ClosedGroupRemovedMembersMessage';
-export * from './ClosedGroupUpdateMessage';

ts/session/messages/outgoing/content/data/index.ts

@@ -1,9 +0,0 @@
-export * from './DataMessage';
-export * from './GroupInvitationMessage';
-export * from './ChatMessage';
-export * from './group/ClosedGroupMessage';
-export * from './group/ClosedGroupChatMessage';
-export * from './group/ClosedGroupEncryptionPairMessage';
-export * from './group/ClosedGroupNewMessage';
-export * from './group/ClosedGroupMessage';
-export * from './ExpirationTimerUpdateMessage';

ts/session/messages/outgoing/content/index.ts

@@ -1,4 +0,0 @@
-export * from './ContentMessage';
-export * from './TypingMessage';
-export * from './data';
-export * from './receipt';

ts/session/messages/outgoing/content/receipt/index.ts

@@ -1,3 +0,0 @@
-export * from './ReceiptMessage';
-export * from './DeliveryReceiptMessage';
-export * from './ReadReceiptMessage';

ts/session/messages/outgoing/controlMessage/ConfigurationMessage.ts

@@ -1,12 +1,12 @@
 // this is not a very good name, but a configuration message is a message sent to our other devices so sync our current public and closed groups
 
-import { ContentMessage } from './ContentMessage';
 import { SignalService } from '../../../../protobuf';
 import { MessageParams } from '../Message';
 import { Constants } from '../../..';
 import { ECKeyPair } from '../../../../receiver/keypairs';
 import { fromHexToArray } from '../../../utils/String';
 import { PubKey } from '../../../types';
+import { ContentMessage } from '..';
 
 interface ConfigurationMessageParams extends MessageParams {
   activeClosedGroups: Array<ConfigurationMessageClosedGroup>;

ts/session/messages/outgoing/controlMessage/ExpirationTimerUpdateMessage.ts

@@ -1,25 +1,28 @@
-import { SignalService } from '../../../../../protobuf';
+import { DataMessage } from '..';
-import { MessageParams } from '../../Message';
+import { Constants } from '../../..';
-import { StringUtils } from '../../../../utils';
+import { SignalService } from '../../../../protobuf';
-import { DataMessage } from './DataMessage';
+import { PubKey } from '../../../types';
-import { PubKey } from '../../../../types';
+import { StringUtils } from '../../../utils';
-import { Constants } from '../../../..';
+import { MessageParams } from '../Message';
 
 interface ExpirationTimerUpdateMessageParams extends MessageParams {
   groupId?: string | PubKey;
+  syncTarget?: string | PubKey;
   expireTimer: number | null;
 }
 
 export class ExpirationTimerUpdateMessage extends DataMessage {
   public readonly groupId?: PubKey;
+  public readonly syncTarget?: PubKey;
   public readonly expireTimer: number | null;
 
   constructor(params: ExpirationTimerUpdateMessageParams) {
     super({ timestamp: params.timestamp, identifier: params.identifier });
     this.expireTimer = params.expireTimer;
 
-    const { groupId } = params;
+    const { groupId, syncTarget } = params;
     this.groupId = groupId ? PubKey.cast(groupId) : undefined;
+    this.syncTarget = syncTarget ? PubKey.cast(syncTarget) : undefined;
   }
 
   public ttl(): number {
@@ -46,6 +49,10 @@ export class ExpirationTimerUpdateMessage extends DataMessage {
       data.group = groupMessage;
     }
 
+    if (this.syncTarget) {
+      data.syncTarget = this.syncTarget.key;
+    }
+
     if (this.expireTimer) {
       data.expireTimer = this.expireTimer;
     }

ts/session/messages/outgoing/controlMessage/TypingMessage.ts

@@ -1,7 +1,7 @@
-import { ContentMessage } from './ContentMessage';
 import { SignalService } from '../../../../protobuf';
 import { MessageParams } from '../Message';
 import { Constants } from '../../..';
+import { ContentMessage } from '..';
 
 interface TypingMessageParams extends MessageParams {
   isTyping: boolean;

ts/session/messages/outgoing/controlMessage/group/ClosedGroupAddedMembersMessage.ts

@@ -1,7 +1,7 @@
 import { fromHex } from 'bytebuffer';
-import { Constants } from '../../../../..';
+import { Constants } from '../../../..';
-import { SignalService } from '../../../../../../protobuf';
+import { SignalService } from '../../../../../protobuf';
-import { fromHexToArray } from '../../../../../utils/String';
+import { fromHexToArray } from '../../../../utils/String';
 import {
   ClosedGroupMessage,
   ClosedGroupMessageParams,

ts/session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairMessage.ts

@@ -1,6 +1,5 @@
-import { Constants } from '../../../../..';
+import { Constants } from '../../../..';
-import { SignalService } from '../../../../../../protobuf';
+import { SignalService } from '../../../../../protobuf';
-import { fromHexToArray } from '../../../../../utils/String';
 import {
   ClosedGroupMessage,
   ClosedGroupMessageParams,

ts/session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairReplyMessage.ts

@@ -1,5 +1,5 @@
-import { SignalService } from '../../../../../../protobuf';
+import { SignalService } from '../../../../../protobuf';
-import { fromHexToArray } from '../../../../../utils/String';
+import { fromHexToArray } from '../../../../utils/String';
 import { ClosedGroupEncryptionPairMessage } from './ClosedGroupEncryptionPairMessage';
 
 /**

ts/session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairRequestMessage.ts

@@ -1,9 +1,12 @@
-import { Constants } from '../../../../..';
+import { Constants } from '../../../..';
-import { SignalService } from '../../../../../../protobuf';
+import { SignalService } from '../../../../../protobuf';
 import { ClosedGroupMessage } from './ClosedGroupMessage';
 
 export class ClosedGroupEncryptionPairRequestMessage extends ClosedGroupMessage {
   public dataProto(): SignalService.DataMessage {
+    throw new Error(
+      'ClosedGroupEncryptionPairRequestMessage: This is unused for now '
+    );
     const dataMessage = super.dataProto();
 
     // tslint:disable: no-non-null-assertion

ts/session/messages/outgoing/controlMessage/group/ClosedGroupMemberLeftMessage.ts

@@ -1,20 +1,8 @@
-import { Constants } from '../../../../..';
+import { Constants } from '../../../..';
-import { SignalService } from '../../../../../../protobuf';
+import { SignalService } from '../../../../../protobuf';
-import {
+import { ClosedGroupMessage } from './ClosedGroupMessage';
-  ClosedGroupMessage,
-  ClosedGroupMessageParams,
-} from './ClosedGroupMessage';
 
 export class ClosedGroupMemberLeftMessage extends ClosedGroupMessage {
-  constructor(params: ClosedGroupMessageParams) {
-    super({
-      timestamp: params.timestamp,
-      identifier: params.identifier,
-      groupId: params.groupId,
-      expireTimer: params.expireTimer,
-    });
-  }
-
   public dataProto(): SignalService.DataMessage {
     const dataMessage = super.dataProto();
 

ts/session/messages/outgoing/controlMessage/group/ClosedGroupMessage.ts

@@ -1,7 +1,7 @@
-import { DataMessage } from '../DataMessage';
+import { SignalService } from '../../../../../protobuf';
-import { MessageParams } from '../../../Message';
+import { PubKey } from '../../../../types';
-import { SignalService } from '../../../../../../protobuf';
+import { DataMessage } from '../../DataMessage';
-import { PubKey } from '../../../../../types/PubKey';
+import { MessageParams } from '../../Message';
 
 export interface ClosedGroupMessageParams extends MessageParams {
   groupId: string | PubKey;

ts/session/messages/outgoing/controlMessage/group/ClosedGroupNameChangeMessage.ts

@@ -1,5 +1,5 @@
-import { Constants } from '../../../../..';
+import { Constants } from '../../../..';
-import { SignalService } from '../../../../../../protobuf';
+import { SignalService } from '../../../../../protobuf';
 import {
   ClosedGroupMessage,
   ClosedGroupMessageParams,

ts/session/messages/outgoing/controlMessage/group/ClosedGroupNewMessage.ts

@@ -1,10 +1,10 @@
-import { SignalService } from '../../../../../../protobuf';
+import { SignalService } from '../../../../../protobuf';
 import {
   ClosedGroupMessage,
   ClosedGroupMessageParams,
 } from './ClosedGroupMessage';
-import { fromHexToArray } from '../../../../../utils/String';
+import { fromHexToArray } from '../../../../utils/String';
-import { ECKeyPair } from '../../../../../../receiver/keypairs';
+import { ECKeyPair } from '../../../../../receiver/keypairs';
 
 export interface ClosedGroupNewMessageParams extends ClosedGroupMessageParams {
   name: string;

ts/session/messages/outgoing/controlMessage/group/ClosedGroupRemovedMembersMessage.ts

@@ -1,6 +1,6 @@
-import { Constants } from '../../../../..';
+import { Constants } from '../../../..';
-import { SignalService } from '../../../../../../protobuf';
+import { SignalService } from '../../../../../protobuf';
-import { fromHexToArray } from '../../../../../utils/String';
+import { fromHexToArray } from '../../../../utils/String';
 import {
   ClosedGroupMessage,
   ClosedGroupMessageParams,

ts/session/messages/outgoing/controlMessage/receipt/ReceiptMessage.ts

@@ -1,7 +1,7 @@
-import { ContentMessage } from '../ContentMessage';
 import { SignalService } from '../../../../../protobuf';
 import { MessageParams } from '../../Message';
 import { Constants } from '../../../..';
+import { ContentMessage } from '../..';
 
 interface ReceiptMessageParams extends MessageParams {
   timestamps: Array<number>;

ts/session/messages/outgoing/index.ts

@@ -1,5 +1,7 @@
 import { Message } from './Message';
 import { OpenGroupMessage } from './OpenGroupMessage';
 
-export * from './content/';
+export * from './ContentMessage';
+export * from './DataMessage';
+
 export { Message, OpenGroupMessage };

ts/session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage.ts

@@ -1,20 +1,20 @@
-import { SignalService } from '../../../../../../protobuf';
+import { Constants } from '../../..';
-import { ChatMessage } from '../ChatMessage';
+import { SignalService } from '../../../../protobuf';
-import { ClosedGroupMessage } from './ClosedGroupMessage';
+import { PubKey } from '../../../types';
-import { PubKey } from '../../../../../types';
+import { StringUtils } from '../../../utils';
-import { Constants } from '../../../../..';
+import { VisibleMessage } from './VisibleMessage';
-import { StringUtils } from '../../../../../utils';
+import { ClosedGroupMessage } from '../controlMessage/group/ClosedGroupMessage';
-
+
-interface ClosedGroupChatMessageParams {
+interface ClosedGroupVisibleMessageParams {
   identifier?: string;
   groupId: string | PubKey;
-  chatMessage: ChatMessage;
+  chatMessage: VisibleMessage;
 }
 
-export class ClosedGroupChatMessage extends ClosedGroupMessage {
+export class ClosedGroupVisibleMessage extends ClosedGroupMessage {
-  private readonly chatMessage: ChatMessage;
+  private readonly chatMessage: VisibleMessage;
 
-  constructor(params: ClosedGroupChatMessageParams) {
+  constructor(params: ClosedGroupVisibleMessageParams) {
     super({
       timestamp: params.chatMessage.timestamp,
       identifier: params.identifier ?? params.chatMessage.identifier,

ts/session/messages/outgoing/visibleMessage/GroupInvitationMessage.ts

@@ -1,7 +1,7 @@
-import { DataMessage } from './DataMessage';
+import { DataMessage } from '..';
-import { SignalService } from '../../../../../protobuf';
+import { Constants } from '../../..';
-import { MessageParams } from '../../Message';
+import { SignalService } from '../../../../protobuf';
-import { Constants } from '../../../..';
+import { MessageParams } from '../Message';
 
 interface GroupInvitationMessageParams extends MessageParams {
   serverAddress: string;

ts/session/messages/outgoing/visibleMessage/VisibleMessage.ts

@@ -1,10 +1,11 @@
-import { DataMessage } from './DataMessage';
-import { SignalService } from '../../../../../protobuf';
-import { MessageParams } from '../../Message';
-import { LokiProfile } from '../../../../../types/Message';
 import ByteBuffer from 'bytebuffer';
-import { Constants } from '../../../..';
+
 import { isNumber, toNumber } from 'lodash';
+import { DataMessage } from '..';
+import { Constants } from '../../..';
+import { SignalService } from '../../../../protobuf';
+import { LokiProfile } from '../../../../types/Message';
+import { MessageParams } from '../Message';
 
 export interface AttachmentPointer {
   id?: number;
@@ -40,7 +41,7 @@ export interface Quote {
   attachments?: Array<QuotedAttachment>;
 }
 
-export interface ChatMessageParams extends MessageParams {
+export interface VisibleMessageParams extends MessageParams {
   attachments?: Array<AttachmentPointer>;
   body?: string;
   quote?: Quote;
@@ -50,7 +51,7 @@ export interface ChatMessageParams extends MessageParams {
   syncTarget?: string; // null means it is not a synced message
 }
 
-export class ChatMessage extends DataMessage {
+export class VisibleMessage extends DataMessage {
   public readonly expireTimer?: number;
 
   private readonly attachments?: Array<AttachmentPointer>;
@@ -65,7 +66,7 @@ export class ChatMessage extends DataMessage {
   /// - Note: `null or undefined` if this isn't a sync message.
   private readonly syncTarget?: string;
 
-  constructor(params: ChatMessageParams) {
+  constructor(params: VisibleMessageParams) {
     super({ timestamp: params.timestamp, identifier: params.identifier });
     this.attachments = params.attachments;
     this.body = params.body;
@@ -135,7 +136,7 @@ export class ChatMessage extends DataMessage {
     const quote = (dataMessage.quote as Quote) || undefined;
     const preview = (dataMessage.preview as Array<Preview>) || [];
 
-    return new ChatMessage({
+    return new VisibleMessage({
       identifier,
       timestamp,
       attachments,
@@ -232,7 +233,7 @@ export class ChatMessage extends DataMessage {
     return dataMessage;
   }
 
-  public isEqual(comparator: ChatMessage): boolean {
+  public isEqual(comparator: VisibleMessage): boolean {
     return (
       this.identifier === comparator.identifier &&
       this.timestamp === comparator.timestamp

ts/session/sending/MessageQueue.ts

@@ -1,34 +1,28 @@
-import {
-  ClosedGroupChatMessage,
-  ClosedGroupNewMessage,
-  ContentMessage,
-  ExpirationTimerUpdateMessage,
-  OpenGroupMessage,
-} from '../messages/outgoing';
 import { PendingMessageCache } from './PendingMessageCache';
 import { JobQueue, UserUtils } from '../utils';
 import { PubKey, RawMessage } from '../types';
 import { MessageSender } from '.';
-import { ClosedGroupMessage } from '../messages/outgoing/content/data/group/ClosedGroupMessage';
+import { ClosedGroupMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupMessage';
-import { ConfigurationMessage } from '../messages/outgoing/content/ConfigurationMessage';
+import { ConfigurationMessage } from '../messages/outgoing/controlMessage/ConfigurationMessage';
-import { ClosedGroupNameChangeMessage } from '../messages/outgoing/content/data/group/ClosedGroupNameChangeMessage';
+import { ClosedGroupNameChangeMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNameChangeMessage';
-import {
+
-  ClosedGroupAddedMembersMessage,
+import { ClosedGroupMemberLeftMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupMemberLeftMessage';
-  ClosedGroupEncryptionPairMessage,
-  ClosedGroupEncryptionPairRequestMessage,
-  ClosedGroupRemovedMembersMessage,
-  ClosedGroupUpdateMessage,
-} from '../messages/outgoing/content/data/group';
-import { ClosedGroupMemberLeftMessage } from '../messages/outgoing/content/data/group/ClosedGroupMemberLeftMessage';
 import { MessageSentHandler } from './MessageSentHandler';
+import { ContentMessage, OpenGroupMessage } from '../messages/outgoing';
+import { ExpirationTimerUpdateMessage } from '../messages/outgoing/controlMessage/ExpirationTimerUpdateMessage';
+import { ClosedGroupAddedMembersMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupAddedMembersMessage';
+import { ClosedGroupEncryptionPairMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairMessage';
+import { ClosedGroupEncryptionPairRequestMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairRequestMessage';
+import { ClosedGroupNewMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
+import { ClosedGroupRemovedMembersMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupRemovedMembersMessage';
+import { ClosedGroupVisibleMessage } from '../messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
 
 type ClosedGroupMessageType =
-  | ClosedGroupChatMessage
+  | ClosedGroupVisibleMessage
   | ClosedGroupAddedMembersMessage
   | ClosedGroupRemovedMembersMessage
   | ClosedGroupNameChangeMessage
   | ClosedGroupMemberLeftMessage
-  | ClosedGroupUpdateMessage
   | ExpirationTimerUpdateMessage
   | ClosedGroupEncryptionPairMessage
   | ClosedGroupEncryptionPairRequestMessage;

ts/session/utils/Attachments.ts

@@ -1,13 +1,14 @@
 import * as crypto from 'crypto';
 import { Attachment } from '../../types/Attachment';
 import { OpenGroup } from '../types';
+
+import { LokiAppDotNetServerInterface } from '../../../js/modules/loki_app_dot_net_api';
 import {
   AttachmentPointer,
   Preview,
   Quote,
   QuotedAttachment,
-} from '../messages/outgoing';
+} from '../messages/outgoing/visibleMessage/VisibleMessage';
-import { LokiAppDotNetServerInterface } from '../../../js/modules/loki_app_dot_net_api';
 
 interface UploadParams {
   attachment: Attachment;

ts/session/utils/Messages.ts

@@ -1,14 +1,12 @@
 import { RawMessage } from '../types/RawMessage';
-import {
+
-  ContentMessage,
-  ExpirationTimerUpdateMessage,
-} from '../messages/outgoing';
 import { EncryptionType, PubKey } from '../types';
-import { ClosedGroupMessage } from '../messages/outgoing/content/data/group/ClosedGroupMessage';
+import { ClosedGroupMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupMessage';
-import { ClosedGroupNewMessage } from '../messages/outgoing/content/data/group/ClosedGroupNewMessage';
+import { ClosedGroupNewMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
 import _ from 'lodash';
-import { ConversationModel } from '../../models/conversation';
+import { ClosedGroupEncryptionPairReplyMessage } from '../messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairReplyMessage';
-import { ClosedGroupEncryptionPairReplyMessage } from '../messages/outgoing/content/data/group/ClosedGroupEncryptionPairReplyMessage';
+import { ContentMessage } from '../messages/outgoing';
+import { ExpirationTimerUpdateMessage } from '../messages/outgoing/controlMessage/ExpirationTimerUpdateMessage';
 
 function getEncryptionTypeFromMessageType(
   message: ContentMessage

ts/session/utils/syncUtils.ts

@@ -13,7 +13,7 @@ import {
   ConfigurationMessage,
   ConfigurationMessageClosedGroup,
   ConfigurationMessageContact,
-} from '../messages/outgoing/content/ConfigurationMessage';
+} from '../messages/outgoing/controlMessage/ConfigurationMessage';
 import { ConversationModel } from '../../models/conversation';
 import {
   fromBase64ToArray,

ts/test/session/unit/messages/ChatMessage_test.ts

@@ -1,19 +1,19 @@
 import { expect } from 'chai';
 
-import {
-  AttachmentPointer,
-  ChatMessage,
-  Preview,
-  Quote,
-} from '../../../../session/messages/outgoing';
 import { SignalService } from '../../../../protobuf';
 import { TextEncoder } from 'util';
 import { toNumber } from 'lodash';
 import { Constants } from '../../../../session';
+import {
+  AttachmentPointer,
+  Preview,
+  Quote,
+  VisibleMessage,
+} from '../../../../session/messages/outgoing/visibleMessage/VisibleMessage';
 
-describe('ChatMessage', () => {
+describe('VisibleMessage', () => {
   it('can create empty message with just a timestamp', () => {
-    const message = new ChatMessage({
+    const message = new VisibleMessage({
       timestamp: Date.now(),
     });
     const plainText = message.plainTextBuffer();
@@ -23,7 +23,7 @@ describe('ChatMessage', () => {
   });
 
   it('can create message with a body', () => {
-    const message = new ChatMessage({
+    const message = new VisibleMessage({
       timestamp: Date.now(),
       body: 'body',
     });
@@ -33,7 +33,7 @@ describe('ChatMessage', () => {
   });
 
   it('can create message with a expire timer', () => {
-    const message = new ChatMessage({
+    const message = new VisibleMessage({
       timestamp: Date.now(),
       expireTimer: 3600,
     });
@@ -50,7 +50,7 @@ describe('ChatMessage', () => {
       avatarPointer: 'avatarPointer',
       profileKey,
     };
-    const message = new ChatMessage({
+    const message = new VisibleMessage({
       timestamp: Date.now(),
       lokiProfile: lokiProfile,
     });
@@ -71,7 +71,7 @@ describe('ChatMessage', () => {
     let quote: Quote;
 
     quote = { id: 1234, author: 'author', text: 'text' };
-    const message = new ChatMessage({
+    const message = new VisibleMessage({
       timestamp: Date.now(),
       quote,
     });
@@ -93,7 +93,7 @@ describe('ChatMessage', () => {
     const previews = new Array<Preview>();
     previews.push(preview);
 
-    const message = new ChatMessage({
+    const message = new VisibleMessage({
       timestamp: Date.now(),
       preview: previews,
     });
@@ -115,7 +115,7 @@ describe('ChatMessage', () => {
     const attachments = new Array<AttachmentPointer>();
     attachments.push(attachment);
 
-    const message = new ChatMessage({
+    const message = new VisibleMessage({
       timestamp: Date.now(),
       attachments: attachments,
     });
@@ -130,14 +130,14 @@ describe('ChatMessage', () => {
   });
 
   it('correct ttl', () => {
-    const message = new ChatMessage({
+    const message = new VisibleMessage({
       timestamp: Date.now(),
     });
     expect(message.ttl()).to.equal(Constants.TTL_DEFAULT.REGULAR_MESSAGE);
   });
 
   it('has an identifier', () => {
-    const message = new ChatMessage({
+    const message = new VisibleMessage({
       timestamp: Date.now(),
     });
     expect(message.identifier).to.not.equal(null, 'identifier cannot be null');

ts/test/session/unit/messages/ClosedGroupChatMessage_test.ts

@@ -1,26 +1,24 @@
 import { expect } from 'chai';
 
-import {
-  ChatMessage,
-  ClosedGroupChatMessage,
-} from '../../../../session/messages/outgoing';
 import { SignalService } from '../../../../protobuf';
 import { TestUtils } from '../../../test-utils';
 import { StringUtils } from '../../../../session/utils';
 import { PubKey } from '../../../../session/types';
 import { Constants } from '../../../../session';
+import { ClosedGroupVisibleMessage } from '../../../../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
+import { VisibleMessage } from '../../../../session/messages/outgoing/visibleMessage/VisibleMessage';
 
-describe('ClosedGroupChatMessage', () => {
+describe('ClosedGroupVisibleMessage', () => {
   let groupId: PubKey;
   beforeEach(() => {
     groupId = TestUtils.generateFakePubKey();
   });
   it('can create empty message with timestamp, groupId and chatMessage', () => {
-    const chatMessage = new ChatMessage({
+    const chatMessage = new VisibleMessage({
       timestamp: Date.now(),
       body: 'body',
     });
-    const message = new ClosedGroupChatMessage({
+    const message = new ClosedGroupVisibleMessage({
       groupId,
       chatMessage,
     });
@@ -50,10 +48,10 @@ describe('ClosedGroupChatMessage', () => {
   });
 
   it('correct ttl', () => {
-    const chatMessage = new ChatMessage({
+    const chatMessage = new VisibleMessage({
       timestamp: Date.now(),
     });
-    const message = new ClosedGroupChatMessage({
+    const message = new ClosedGroupVisibleMessage({
       groupId,
       chatMessage,
     });
@@ -61,10 +59,10 @@ describe('ClosedGroupChatMessage', () => {
   });
 
   it('has an identifier', () => {
-    const chatMessage = new ChatMessage({
+    const chatMessage = new VisibleMessage({
       timestamp: Date.now(),
     });
-    const message = new ClosedGroupChatMessage({
+    const message = new ClosedGroupVisibleMessage({
       groupId,
       chatMessage,
     });
@@ -76,12 +74,12 @@ describe('ClosedGroupChatMessage', () => {
   });
 
   it('should use the identifier passed into it over the one set in chatMessage', () => {
-    const chatMessage = new ChatMessage({
+    const chatMessage = new VisibleMessage({
       timestamp: Date.now(),
       body: 'body',
       identifier: 'chatMessage',
     });
-    const message = new ClosedGroupChatMessage({
+    const message = new ClosedGroupVisibleMessage({
       groupId,
       chatMessage,
       identifier: 'closedGroupMessage',
@@ -90,12 +88,12 @@ describe('ClosedGroupChatMessage', () => {
   });
 
   it('should use the identifier of the chatMessage if one is not specified on the closed group message', () => {
-    const chatMessage = new ChatMessage({
+    const chatMessage = new VisibleMessage({
       timestamp: Date.now(),
       body: 'body',
       identifier: 'chatMessage',
     });
-    const message = new ClosedGroupChatMessage({
+    const message = new ClosedGroupVisibleMessage({
       groupId,
       chatMessage,
     });

ts/test/session/unit/messages/ConfigurationMessage_test.ts

@@ -5,7 +5,7 @@ import {
   ConfigurationMessage,
   ConfigurationMessageClosedGroup,
   ConfigurationMessageContact,
-} from '../../../../session/messages/outgoing/content/ConfigurationMessage';
+} from '../../../../session/messages/outgoing/controlMessage/ConfigurationMessage';
 import { TestUtils } from '../../../test-utils';
 
 // tslint:disable-next-line: max-func-body-length

ts/test/session/unit/messages/GroupInvitationMessage_test.ts

@@ -1,9 +1,9 @@
 import { expect } from 'chai';
 import { beforeEach } from 'mocha';
 
-import { GroupInvitationMessage } from '../../../../session/messages/outgoing';
 import { SignalService } from '../../../../protobuf';
 import { Constants } from '../../../../session';
+import { GroupInvitationMessage } from '../../../../session/messages/outgoing/visibleMessage/GroupInvitationMessage';
 
 describe('GroupInvitationMessage', () => {
   let message: GroupInvitationMessage;

ts/test/session/unit/messages/OpenGroupMessage_test.ts

@@ -1,11 +1,9 @@
 import { expect } from 'chai';
 
-import {
+import { OpenGroupMessage } from '../../../../session/messages/outgoing';
-  AttachmentPointer,
-  OpenGroupMessage,
-} from '../../../../session/messages/outgoing';
 import * as MIME from '../../../../../ts/types/MIME';
 import { OpenGroup } from '../../../../session/types';
+import { AttachmentPointer } from '../../../../session/messages/outgoing/visibleMessage/VisibleMessage';
 
 describe('OpenGroupMessage', () => {
   const group = new OpenGroup({

ts/test/session/unit/messages/ReceiptMessage_test.ts

@@ -1,13 +1,11 @@
 import { expect } from 'chai';
 import { beforeEach } from 'mocha';
 
-import {
-  DeliveryReceiptMessage,
-  ReadReceiptMessage,
-} from '../../../../session/messages/outgoing';
 import { SignalService } from '../../../../protobuf';
 import { toNumber } from 'lodash';
 import { Constants } from '../../../../session';
+import { DeliveryReceiptMessage } from '../../../../session/messages/outgoing/controlMessage/receipt/DeliveryReceiptMessage';
+import { ReadReceiptMessage } from '../../../../session/messages/outgoing/controlMessage/receipt/ReadReceiptMessage';
 
 describe('ReceiptMessage', () => {
   let readMessage: ReadReceiptMessage;

ts/test/session/unit/messages/TypingMessage_test.ts

@@ -1,12 +1,10 @@
 import { expect } from 'chai';
 
-import { TypingMessage } from '../../../../session/messages/outgoing';
 import { SignalService } from '../../../../protobuf';
 import Long from 'long';
 import { toNumber } from 'lodash';
-import { StringUtils } from '../../../../session/utils';
-import { TestUtils } from '../../../test-utils';
 import { Constants } from '../../../../session';
+import { TypingMessage } from '../../../../session/messages/outgoing/controlMessage/TypingMessage';
 
 describe('TypingMessage', () => {
   it('has Action.STARTED if isTyping = true', () => {

ts/test/session/unit/receiving/ConfigurationMessage_test.ts

@@ -3,7 +3,7 @@
 import { SignalService } from '../../../../protobuf';
 import chai from 'chai';
 
-import { ConfigurationMessage } from '../../../../session/messages/outgoing/content/ConfigurationMessage';
+import { ConfigurationMessage } from '../../../../session/messages/outgoing/controlMessage/ConfigurationMessage';
 import { UserUtils } from '../../../../session/utils';
 import { TestUtils } from '../../../test-utils';
 

ts/test/session/unit/sending/MessageQueue_test.ts

@@ -15,7 +15,7 @@ import {
 import { PubKey, RawMessage } from '../../../../session/types';
 import { MessageSender } from '../../../../session/sending';
 import { PendingMessageCacheStub } from '../../../test-utils/stubs';
-import { ClosedGroupMessage } from '../../../../session/messages/outgoing/content/data/group/ClosedGroupMessage';
+import { ClosedGroupMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupMessage';
 
 import chaiAsPromised from 'chai-as-promised';
 import { MessageSentHandler } from '../../../../session/sending/MessageSentHandler';
@@ -87,7 +87,7 @@ describe('MessageQueue', () => {
       void pendingMessageCache
         .add(
           device,
-          TestUtils.generateChatMessage(),
+          TestUtils.generateVisibleMessage(),
           waitForMessageSentEvent as any
         )
         .then(async () => {
@@ -108,7 +108,10 @@ describe('MessageQueue', () => {
         }
 
         const device = TestUtils.generateFakePubKey();
-        await pendingMessageCache.add(device, TestUtils.generateChatMessage());
+        await pendingMessageCache.add(
+          device,
+          TestUtils.generateVisibleMessage()
+        );
 
         const initialMessages = await pendingMessageCache.getForDevice(device);
         expect(initialMessages).to.have.length(1);
@@ -125,7 +128,7 @@ describe('MessageQueue', () => {
     describe('events', () => {
       it('should send a success event if message was sent', done => {
         const device = TestUtils.generateFakePubKey();
-        const message = TestUtils.generateChatMessage();
+        const message = TestUtils.generateVisibleMessage();
         const waitForMessageSentEvent = async () =>
           new Promise<void>(resolve => {
             resolve();
@@ -149,7 +152,7 @@ describe('MessageQueue', () => {
         sendStub.throws(new Error('failure'));
 
         const device = TestUtils.generateFakePubKey();
-        const message = TestUtils.generateChatMessage();
+        const message = TestUtils.generateVisibleMessage();
         void pendingMessageCache
           .add(device, message)
           .then(() => messageQueueStub.processPending(device));
@@ -180,7 +183,7 @@ describe('MessageQueue', () => {
       const device = TestUtils.generateFakePubKey();
       const stub = sandbox.stub(messageQueueStub as any, 'process').resolves();
 
-      const message = TestUtils.generateChatMessage();
+      const message = TestUtils.generateVisibleMessage();
       await messageQueueStub.sendToPubKey(device, message);
 
       const args = stub.lastCall.args as [Array<PubKey>, ContentMessage];
@@ -191,7 +194,7 @@ describe('MessageQueue', () => {
 
   describe('sendToGroup', () => {
     it('should throw an error if invalid non-group message was passed', async () => {
-      const chatMessage = TestUtils.generateChatMessage();
+      const chatMessage = TestUtils.generateVisibleMessage();
       return expect(
         messageQueueStub.sendToGroup(chatMessage as any)
       ).to.be.rejectedWith('Invalid group message passed in sendToGroup.');

ts/test/session/unit/sending/PendingMessageCache_test.ts

@@ -56,7 +56,7 @@ describe('PendingMessageCache', () => {
 
   it('can add to cache', async () => {
     const device = TestUtils.generateFakePubKey();
-    const message = TestUtils.generateChatMessage();
+    const message = TestUtils.generateVisibleMessage();
     const rawMessage = await MessageUtils.toRawMessage(device, message);
 
     await pendingMessageCacheStub.add(device, message);
@@ -74,12 +74,21 @@ describe('PendingMessageCache', () => {
   it('can add multiple messages belonging to the same user', async () => {
     const device = TestUtils.generateFakePubKey();
 
-    await pendingMessageCacheStub.add(device, TestUtils.generateChatMessage());
+    await pendingMessageCacheStub.add(
+      device,
+      TestUtils.generateVisibleMessage()
+    );
     // We have to timeout here otherwise it's processed too fast and messages start having the same timestamp
     await TestUtils.timeout(5);
-    await pendingMessageCacheStub.add(device, TestUtils.generateChatMessage());
+    await pendingMessageCacheStub.add(
+      device,
+      TestUtils.generateVisibleMessage()
+    );
     await TestUtils.timeout(5);
-    await pendingMessageCacheStub.add(device, TestUtils.generateChatMessage());
+    await pendingMessageCacheStub.add(
+      device,
+      TestUtils.generateVisibleMessage()
+    );
 
     // Verify that the message is in the cache
     const finalCache = await pendingMessageCacheStub.getAllPending();
@@ -89,7 +98,7 @@ describe('PendingMessageCache', () => {
 
   it('can remove from cache', async () => {
     const device = TestUtils.generateFakePubKey();
-    const message = TestUtils.generateChatMessage();
+    const message = TestUtils.generateVisibleMessage();
     const rawMessage = await MessageUtils.toRawMessage(device, message);
 
     await pendingMessageCacheStub.add(device, message);
@@ -108,14 +117,14 @@ describe('PendingMessageCache', () => {
 
   it('should only remove messages with different timestamp and device', async () => {
     const device = TestUtils.generateFakePubKey();
-    const message = TestUtils.generateChatMessage();
+    const message = TestUtils.generateVisibleMessage();
     const rawMessage = await MessageUtils.toRawMessage(device, message);
 
     await pendingMessageCacheStub.add(device, message);
     await TestUtils.timeout(5);
     const one = await pendingMessageCacheStub.add(
       device,
-      TestUtils.generateChatMessage(message.identifier)
+      TestUtils.generateVisibleMessage(message.identifier)
     );
     const two = await pendingMessageCacheStub.add(
       TestUtils.generateFakePubKey(),
@@ -139,15 +148,15 @@ describe('PendingMessageCache', () => {
     const cacheItems = [
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
     ];
 
@@ -171,11 +180,11 @@ describe('PendingMessageCache', () => {
     const cacheItems = [
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
     ];
 
@@ -198,7 +207,7 @@ describe('PendingMessageCache', () => {
 
   it('can find nothing when empty', async () => {
     const device = TestUtils.generateFakePubKey();
-    const message = TestUtils.generateChatMessage();
+    const message = TestUtils.generateVisibleMessage();
     const rawMessage = await MessageUtils.toRawMessage(device, message);
 
     const foundMessage = pendingMessageCacheStub.find(rawMessage);
@@ -207,7 +216,7 @@ describe('PendingMessageCache', () => {
 
   it('can find message in cache', async () => {
     const device = TestUtils.generateFakePubKey();
-    const message = TestUtils.generateChatMessage();
+    const message = TestUtils.generateVisibleMessage();
     const rawMessage = await MessageUtils.toRawMessage(device, message);
 
     await pendingMessageCacheStub.add(device, message);
@@ -224,15 +233,15 @@ describe('PendingMessageCache', () => {
     const cacheItems = [
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
     ];
 
@@ -254,15 +263,15 @@ describe('PendingMessageCache', () => {
     const cacheItems = [
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
       {
         device: TestUtils.generateFakePubKey(),
-        message: TestUtils.generateChatMessage(),
+        message: TestUtils.generateVisibleMessage(),
       },
     ];
 

ts/test/session/unit/utils/Messages_test.ts

@@ -5,25 +5,21 @@ import * as sinon from 'sinon';
 import { TestUtils } from '../../../test-utils';
 import { MessageUtils, UserUtils } from '../../../../session/utils';
 import { EncryptionType, PubKey } from '../../../../session/types';
-import { ClosedGroupChatMessage } from '../../../../session/messages/outgoing/content/data/group/ClosedGroupChatMessage';
+import { ClosedGroupVisibleMessage } from '../../../../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
-import {
-  ClosedGroupEncryptionPairMessage,
-  ClosedGroupNewMessage,
-} from '../../../../session/messages/outgoing';
-import { SignalService } from '../../../../protobuf';
-import {
-  ClosedGroupAddedMembersMessage,
-  ClosedGroupNameChangeMessage,
-  ClosedGroupRemovedMembersMessage,
-} from '../../../../session/messages/outgoing/content/data/group';
 import { MockConversation } from '../../../test-utils/utils';
-import { ConfigurationMessage } from '../../../../session/messages/outgoing/content/ConfigurationMessage';
+import { ConfigurationMessage } from '../../../../session/messages/outgoing/controlMessage/ConfigurationMessage';
 
 import { ConversationModel } from '../../../../models/conversation';
 
 import chaiAsPromised from 'chai-as-promised';
 chai.use(chaiAsPromised as any);
-import { ClosedGroupEncryptionPairReplyMessage } from '../../../../session/messages/outgoing/content/data/group/ClosedGroupEncryptionPairReplyMessage';
+import { ClosedGroupEncryptionPairReplyMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairReplyMessage';
+import { SignalService } from '../../../../protobuf';
+import { ClosedGroupAddedMembersMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupAddedMembersMessage';
+import { ClosedGroupEncryptionPairMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupEncryptionPairMessage';
+import { ClosedGroupNameChangeMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupNameChangeMessage';
+import { ClosedGroupNewMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupNewMessage';
+import { ClosedGroupRemovedMembersMessage } from '../../../../session/messages/outgoing/controlMessage/group/ClosedGroupRemovedMembersMessage';
 
 const { expect } = chai;
 
@@ -38,7 +34,7 @@ describe('Message Utils', () => {
   describe('toRawMessage', () => {
     it('can convert to raw message', async () => {
       const device = TestUtils.generateFakePubKey();
-      const message = TestUtils.generateChatMessage();
+      const message = TestUtils.generateVisibleMessage();
 
       const rawMessage = await MessageUtils.toRawMessage(device, message);
 
@@ -61,7 +57,7 @@ describe('Message Utils', () => {
 
     it('should generate valid plainTextBuffer', async () => {
       const device = TestUtils.generateFakePubKey();
-      const message = TestUtils.generateChatMessage();
+      const message = TestUtils.generateVisibleMessage();
 
       const rawMessage = await MessageUtils.toRawMessage(device, message);
 
@@ -81,7 +77,7 @@ describe('Message Utils', () => {
 
     it('should maintain pubkey', async () => {
       const device = TestUtils.generateFakePubKey();
-      const message = TestUtils.generateChatMessage();
+      const message = TestUtils.generateVisibleMessage();
 
       const rawMessage = await MessageUtils.toRawMessage(device, message);
       const derivedPubKey = PubKey.from(rawMessage.device);
@@ -93,11 +89,11 @@ describe('Message Utils', () => {
       );
     });
 
-    it('should set encryption to ClosedGroup if a ClosedGroupChatMessage is passed in', async () => {
+    it('should set encryption to ClosedGroup if a ClosedGroupVisibleMessage is passed in', async () => {
       const device = TestUtils.generateFakePubKey();
       const groupId = TestUtils.generateFakePubKey();
-      const chatMessage = TestUtils.generateChatMessage();
+      const chatMessage = TestUtils.generateVisibleMessage();
-      const message = new ClosedGroupChatMessage({ chatMessage, groupId });
+      const message = new ClosedGroupVisibleMessage({ chatMessage, groupId });
 
       const rawMessage = await MessageUtils.toRawMessage(device, message);
       expect(rawMessage.encryption).to.equal(EncryptionType.ClosedGroup);
@@ -105,7 +101,7 @@ describe('Message Utils', () => {
 
     it('should set encryption to Fallback on other messages', async () => {
       const device = TestUtils.generateFakePubKey();
-      const message = TestUtils.generateChatMessage();
+      const message = TestUtils.generateVisibleMessage();
       const rawMessage = await MessageUtils.toRawMessage(device, message);
 
       expect(rawMessage.encryption).to.equal(EncryptionType.Fallback);

ts/test/test-utils/utils/message.ts

@@ -1,15 +1,13 @@
-import {
-  ChatMessage,
-  OpenGroupMessage,
-} from '../../../session/messages/outgoing';
 import { v4 as uuid } from 'uuid';
 import { OpenGroup } from '../../../session/types';
 import { generateFakePubKey, generateFakePubKeys } from './pubkey';
-import { ClosedGroupChatMessage } from '../../../session/messages/outgoing/content/data/group/ClosedGroupChatMessage';
+import { ClosedGroupVisibleMessage } from '../../../session/messages/outgoing/visibleMessage/ClosedGroupVisibleMessage';
 import { ConversationAttributes } from '../../../models/conversation';
+import { OpenGroupMessage } from '../../../session/messages/outgoing';
+import { VisibleMessage } from '../../../session/messages/outgoing/visibleMessage/VisibleMessage';
 
-export function generateChatMessage(identifier?: string): ChatMessage {
+export function generateVisibleMessage(identifier?: string): VisibleMessage {
-  return new ChatMessage({
+  return new VisibleMessage({
     body: 'Lorem ipsum dolor sit amet, consectetur adipiscing elit',
     identifier: identifier ?? uuid(),
     timestamp: Date.now(),
@@ -40,11 +38,11 @@ export function generateOpenGroupMessage(): OpenGroupMessage {
 
 export function generateClosedGroupMessage(
   groupId?: string
-): ClosedGroupChatMessage {
+): ClosedGroupVisibleMessage {
-  return new ClosedGroupChatMessage({
+  return new ClosedGroupVisibleMessage({
     identifier: uuid(),
     groupId: groupId ?? generateFakePubKey().key,
-    chatMessage: generateChatMessage(),
+    chatMessage: generateVisibleMessage(),
   });
 }