[CHA-941]: update channel to accept ChannelMembers too (#336)

* [CHA-941]: update channel to accept ChannelMembers too

* remove unused code

* add unit tests

* adding new method to add channel members with the ChannelMember object

* adding unit tests

* fix unit test

* unexport method

* unexport method

* fix unit test

---------

Co-authored-by: Rafael Marinho <[email protected]>

Author: rafaelmf3

channel.go

@@ -42,6 +42,17 @@ type ChannelMember struct {
 	UpdatedAt time.Time `json:"updated_at,omitempty"`
 }
 
+// newChannelMembersFromStrings creates a ChannelMembers from a slice of strings
+func newChannelMembersFromStrings(members []string) []*ChannelMember {
+	channelMembers := make([]*ChannelMember, len(members))
+	for i, m := range members {
+		channelMembers[i] = &ChannelMember{
+			UserID: m,
+		}
+	}
+	return channelMembers
+}
+
 type channelMemberForJSON ChannelMember
 
 // UnmarshalJSON implements json.Unmarshaler.
@@ -155,7 +166,8 @@ type ChannelRequest struct {
 	AutoTranslationLanguage string                 `json:"auto_translation_language,omitempty"`
 	Frozen                  *bool                  `json:"frozen,omitempty"`
 	Disabled                *bool                  `json:"disabled,omitempty"`
-	Members                 []string               `json:"members,omitempty"`
+	ChannelMembers          []*ChannelMember       `json:"members,omitempty"`
+	Members                 []string               `json:"-"`
 	Invites                 []string               `json:"invites,omitempty"`
 	ExtraData               map[string]interface{} `json:"-"`
 }
@@ -374,7 +386,8 @@ func (ch *Channel) GetMessages(ctx context.Context, messageIDs []string) (*GetMe
 }
 
 type addMembersOptions struct {
-	MemberIDs []string `json:"add_members"`
+	MemberIDs      []string         `json:"-"`
+	ChannelMembers []*ChannelMember `json:"add_members"`
 
 	RolesAssignement []*RoleAssignment `json:"assign_roles"`
 	HideHistory      bool              `json:"hide_history"`
@@ -401,14 +414,35 @@ func AddMembersWithRolesAssignment(assignements []*RoleAssignment) func(*addMemb
 	}
 }
 
-// AddMembers adds members with given user IDs to the channel.
+// AddMembers adds members with given user IDs to the channel. If you want to add members with ChannelMember objects, use AddChannelMembers instead.
 func (ch *Channel) AddMembers(ctx context.Context, userIDs []string, options ...AddMembersOptions) (*Response, error) {
 	if len(userIDs) == 0 {
 		return nil, errors.New("user IDs are empty")
 	}
 
 	opts := &addMembersOptions{
-		MemberIDs: userIDs,
+		ChannelMembers: newChannelMembersFromStrings(userIDs),
+	}
+
+	for _, fn := range options {
+		fn(opts)
+	}
+
+	p := path.Join("channels", url.PathEscape(ch.Type), url.PathEscape(ch.ID))
+
+	var resp Response
+	err := ch.client.makeRequest(ctx, http.MethodPost, p, nil, opts, &resp)
+	return &resp, err
+}
+
+// AddChannelMembers adds members with given []*ChannelMember to the channel.
+func (ch *Channel) AddChannelMembers(ctx context.Context, members []*ChannelMember, options ...AddMembersOptions) (*Response, error) {
+	if len(members) == 0 {
+		return nil, errors.New("members are empty")
+	}
+
+	opts := &addMembersOptions{
+		ChannelMembers: members,
 	}
 
 	for _, fn := range options {
@@ -770,7 +804,7 @@ func (c *Client) CreateChannel(ctx context.Context, chanType, chanID, userID str
 	switch {
 	case chanType == "":
 		return nil, errors.New("channel type is empty")
-	case chanID == "" && (data == nil || len(data.Members) == 0):
+	case chanID == "" && (data == nil || (len(data.Members) == 0 && len(data.ChannelMembers) == 0)):
 		return nil, errors.New("either channel ID or members must be provided")
 	case userID == "":
 		return nil, errors.New("user ID is empty")
@@ -792,6 +826,9 @@ func (c *Client) CreateChannel(ctx context.Context, chanType, chanID, userID str
 		data = &ChannelRequest{CreatedBy: &User{ID: userID}}
 	} else {
 		data.CreatedBy = &User{ID: userID}
+		if len(data.ChannelMembers) == 0 {
+			data.ChannelMembers = newChannelMembersFromStrings(data.Members)
+		}
 	}
 
 	q := &QueryRequest{

channel_test.go

@@ -86,6 +86,14 @@ func TestClient_CreateChannel(t *testing.T) {
 			[]CreateChannelOptionFunc{HideForCreator(true)},
 			false,
 		},
+		{"create channel with ChannelMembers", "messaging", "", userID,
+			&ChannelRequest{
+				ChannelMembers: []*ChannelMember{
+					{UserID: userID},
+					{UserID: randomUsersID(t, c, 1)[0]},
+				},
+			}, nil, false,
+		},
 	}
 
 	for _, tt := range tests {
@@ -152,6 +160,99 @@ func TestChannel_AddMembers(t *testing.T) {
 	assert.Equal(t, user.ID, ch.Members[0].User.ID, "members contain user id")
 }
 
+func TestChannel_AddChannelMembers(t *testing.T) {
+	c := initClient(t)
+	ctx := context.Background()
+	AddChannelMemberUser := randomUser(t, c)
+
+	channelModeratorID := randomUser(t, c).ID
+	channelAdminID := randomUser(t, c).ID
+
+	tests := []struct {
+		name          string
+		members       []*ChannelMember
+		options       []AddMembersOptions
+		expectedCount int
+		expectedRoles map[string]string // userID -> expected role
+		expectedUsers []string          // expected user IDs
+	}{
+		{
+			name: "Add members with ID only",
+			members: []*ChannelMember{
+				{UserID: randomUser(t, c).ID},
+				{UserID: randomUser(t, c).ID},
+			},
+			options: []AddMembersOptions{
+				AddMembersWithMessage(&Message{Text: "adding members with ID only", User: AddChannelMemberUser}),
+				AddMembersWithHideHistory(),
+			},
+			expectedCount: 2,
+			expectedRoles: map[string]string{},
+			expectedUsers: []string{},
+		},
+		{
+			name: "Add members with ID and role",
+			members: []*ChannelMember{
+				{UserID: randomUser(t, c).ID, ChannelRole: "channel_moderator"},
+				{UserID: randomUser(t, c).ID, ChannelRole: "channel_member"},
+			},
+			options: []AddMembersOptions{
+				AddMembersWithMessage(&Message{Text: "adding members with roles", User: AddChannelMemberUser}),
+			},
+			expectedCount: 2,
+			expectedRoles: map[string]string{
+				channelModeratorID: "channel_moderator",
+				channelAdminID:     "channel_member",
+			},
+			expectedUsers: []string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Store user IDs for verification
+			userIDs := make([]string, len(tt.members))
+			for i, member := range tt.members {
+				userIDs[i] = member.UserID
+			}
+
+			chanID := randomString(12)
+			resp, err := c.CreateChannel(ctx, "messaging", chanID, AddChannelMemberUser.ID, nil)
+			require.NoError(t, err, "create channel")
+			ch := resp.Channel
+			assert.Empty(t, ch.Members, "members are empty")
+
+			// Add members
+			_, err = ch.AddChannelMembers(ctx, tt.members, tt.options...)
+			require.NoError(t, err, "add channel members")
+
+			// Refresh channel state
+			require.NoError(t, ch.refresh(ctx), "refresh channel")
+
+			// Verify member count
+			assert.Len(t, ch.Members, tt.expectedCount, "member count should match")
+
+			// Verify each member
+			for i, userID := range userIDs {
+				found := false
+				for _, member := range ch.Members {
+					if member.User.ID == userID {
+						found = true
+
+						// Check role if expected
+						if tt.members[i].ChannelRole != "" {
+							assert.Equal(t, tt.members[i].ChannelRole, member.ChannelRole,
+								"user %s should have role %s", userID, tt.members[i].ChannelRole)
+						}
+						break
+					}
+				}
+				assert.True(t, found, "user %s should be found in members", userID)
+			}
+		})
+	}
+}
+
 func TestChannel_AssignRoles(t *testing.T) {
 	c := initClient(t)
 	ctx := context.Background()