web/revolt: move methods to the Client struct

Signed-off-by: Xe Iaso <me@xeiaso.net>

9 files changed, 192 insertions, 234 deletions

diff --git a/web/revolt/bot.go b/web/revolt/bot.go
index de29081..147dfed 100644
--- a/web/revolt/bot.go
+++ b/web/revolt/bot.go
@@ -1,6 +1,7 @@
 package revolt
 
 import (
+	"context"
 	"encoding/json"
 	"time"
 
@@ -9,7 +10,6 @@ import (
 
 // Bot struct.
 type Bot struct {
-	Client    *Client
 	CreatedAt time.Time
 
 	Id              string `json:"_id"`
@@ -37,20 +37,23 @@ func (b *Bot) CalculateCreationDate() error {
 	return nil
 }
 
-// Edit the bot.
-func (b *Bot) Edit(eb *EditBot) error {
+func (c *Client) BotEdit(ctx context.Context, id string, eb *EditBot) error {
 	data, err := json.Marshal(eb)
-
 	if err != nil {
 		return err
 	}
 
-	_, err = b.Client.Request("PATCH", "/bots/"+b.Id, data)
-	return err
+	if _, err := c.Request(ctx, "PATCH", "/bots/"+id, data); err != nil {
+		return err
+	}
+
+	return nil
 }
 
-// Delete the bot.
-func (b *Bot) Delete() error {
-	_, err := b.Client.Request("DELETE", "/bots/"+b.Id, []byte{})
-	return err
+func (c *Client) BotDelete(ctx context.Context, id string) error {
+	if _, err := c.Request(ctx, "DELETE", "/bots/"+id, []byte{}); err != nil {
+		return err
+	}
+
+	return nil
 }
diff --git a/web/revolt/channel.go b/web/revolt/channel.go
index a00ec9d..34b0913 100644
--- a/web/revolt/channel.go
+++ b/web/revolt/channel.go
@@ -1,9 +1,10 @@
 package revolt
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
-	"reflect"
+	"net/url"
 	"time"
 
 	"github.com/oklog/ulid/v2"
@@ -11,7 +12,6 @@ import (
 
 // Channel struct.
 type Channel struct {
-	Client    *Client
 	CreatedAt time.Time
 
 	Id                 string      `json:"_id"`
@@ -46,60 +46,46 @@ func (c *Channel) CalculateCreationDate() error {
 	return nil
 }
 
-// Send a message to the channel.
-func (c Channel) SendMessage(message *SendMessage) (*Message, error) {
-	if message.Nonce == "" {
-		message.CreateNonce()
-	}
-
-	respMessage := &Message{}
-	respMessage.Client = c.Client
-	msgData, err := json.Marshal(message)
+// SendMessage sends a message to a channel.
+func (c *Client) ChannelSendMessage(ctx context.Context, channelID string, message *SendMessage) (*Message, error) {
+	data, err := json.Marshal(message)
 
 	if err != nil {
-		return respMessage, err
+		return nil, err
 	}
 
-	resp, err := c.Client.Request("POST", "/channels/"+c.Id+"/messages", msgData)
-
+	resp, err := c.Request(ctx, "POST", "/channels/"+channelID+"/messages", data)
 	if err != nil {
-		return respMessage, err
+		return nil, err
 	}
 
-	err = json.Unmarshal(resp, respMessage)
+	msg := &Message{}
+	err = json.Unmarshal(resp, msg)
 
 	if err != nil {
-		return respMessage, err
+		return nil, err
 	}
 
 	if message.DeleteAfter != 0 {
 		go func() {
 			time.Sleep(time.Second * time.Duration(message.DeleteAfter))
-			respMessage.Delete()
+			c.MessageDelete(ctx, channelID, msg.ID)
 		}()
 	}
 
-	return respMessage, nil
+	return msg, nil
 }
 
 // Fetch messages from channel.
 // Check: https://developers.revolt.chat/api/#tag/Messaging/paths/~1channels~1:channel~1messages/get for map parameters.
-func (c Channel) FetchMessages(options map[string]interface{}) (*FetchedMessages, error) {
+func (c *Client) ChannelFetchMessages(ctx context.Context, channelID string, options url.Values) (*FetchedMessages, error) {
 	// Format url
-	url := "/channels/" + c.Id + "/messages?"
-
-	for key, value := range options {
-		if !reflect.ValueOf(value).IsZero() {
-			url += fmt.Sprintf("%s=%v&", key, value)
-		}
-	}
-
-	url = url[:len(url)-1]
+	url := "/channels/" + channelID + "/messages?" + options.Encode()
 
 	fetchedMsgs := &FetchedMessages{}
 
 	// Send request
-	resp, err := c.Client.Request("GET", url, []byte{})
+	resp, err := c.Request(ctx, "GET", url, []byte{})
 
 	if err != nil {
 		return fetchedMsgs, err
@@ -115,26 +101,14 @@ func (c Channel) FetchMessages(options map[string]interface{}) (*FetchedMessages
 		}
 	}
 
-	// Add client to users & messages
-	for _, msg := range fetchedMsgs.Messages {
-		msg.Client = c.Client
-	}
-
-	if fetchedMsgs.Users != nil {
-		for _, msg := range fetchedMsgs.Users {
-			msg.Client = c.Client
-		}
-	}
-
 	return fetchedMsgs, nil
 }
 
 // Fetch a message from channel by Id.
-func (c Channel) FetchMessage(id string) (*Message, error) {
+func (c *Client) ChannelFetchMessage(ctx context.Context, channelID, id string) (*Message, error) {
 	msg := &Message{}
-	msg.Client = c.Client
 
-	resp, err := c.Client.Request("GET", "/channels/"+c.Id+"/messages/"+id, []byte{})
+	resp, err := c.Request(ctx, "GET", "/channels/"+channelID+"/messages/"+id, []byte{})
 
 	if err != nil {
 		return msg, err
@@ -145,27 +119,26 @@ func (c Channel) FetchMessage(id string) (*Message, error) {
 }
 
 // Edit channel.
-func (c Channel) Edit(ec *EditChannel) error {
+func (c *Client) ChannelEdit(ctx context.Context, channelID string, ec *EditChannel) error {
 	data, err := json.Marshal(ec)
-
 	if err != nil {
 		return err
 	}
 
-	_, err = c.Client.Request("PATCH", "/channels/"+c.Id, data)
+	_, err = c.Request(ctx, "PATCH", "/channels/"+channelID, data)
 	return err
 }
 
 // Delete channel.
-func (c Channel) Delete() error {
-	_, err := c.Client.Request("DELETE", "/channels/"+c.Id, []byte{})
+func (c *Client) ChannelDelete(ctx context.Context, channelID string) error {
+	_, err := c.Request(ctx, "DELETE", "/channels/"+channelID, []byte{})
 	return err
 }
 
 // Create a new invite.
 // Returns a string (invite code) and error (nil if not exists).
-func (c Channel) CreateInvite() (string, error) {
-	data, err := c.Client.Request("POST", "/channels/"+c.Id+"/invites", []byte{})
+func (c *Client) ChannelCreateInvite(ctx context.Context, channelID string) (string, error) {
+	data, err := c.Request(ctx, "POST", "/channels/"+channelID+"/invites", []byte{})
 
 	if err != nil {
 		return "", err
@@ -181,21 +154,28 @@ func (c Channel) CreateInvite() (string, error) {
 
 // Set channel permissions for a role.
 // Leave role field empty if you want to edit default permissions
-func (c Channel) SetPermissions(role_id string, permissions uint) error {
-	if role_id == "" {
-		role_id = "default"
+func (c *Client) ChannelSetPermissions(ctx context.Context, channelID, roleID string, permissions uint) error {
+	if roleID == "" {
+		roleID = "default"
+	}
+
+	data, err := json.Marshal(struct {
+		Permissions uint `json:"permissions"`
+	}{Permissions: permissions})
+	if err != nil {
+		return err
 	}
 
-	_, err := c.Client.Request("PUT", "/channels/"+c.Id+"/permissions/"+role_id, []byte(fmt.Sprintf("{\"permissions\":%d}", permissions)))
+	_, err = c.Request(ctx, "PUT", "/channels/"+channelID+"/permissions/"+roleID, data)
 	return err
 }
 
-// Send a typing start event to the channel.
-func (c *Channel) BeginTyping() {
-	c.Client.Socket.SendText(fmt.Sprintf("{\"type\":\"BeginTyping\",\"channel\":\"%s\"}", c.Id))
-}
+// // Send a typing start event to the channel.
+// func (c *Channel) BeginTyping() {
+// 	c.Client.Socket.SendText(fmt.Sprintf("{\"type\":\"BeginTyping\",\"channel\":\"%s\"}", c.Id))
+// }
 
-// End the typing event in the channel.
-func (c *Channel) EndTyping() {
-	c.Client.Socket.SendText(fmt.Sprintf("{\"type\":\"EndTyping\",\"channel\":\"%s\"}", c.Id))
-}
+// // End the typing event in the channel.
+// func (c *Channel) EndTyping() {
+// 	c.Client.Socket.SendText(fmt.Sprintf("{\"type\":\"EndTyping\",\"channel\":\"%s\"}", c.Id))
+// }
diff --git a/web/revolt/client.go b/web/revolt/client.go
index 5ab47f1..c68a090 100644
--- a/web/revolt/client.go
+++ b/web/revolt/client.go
@@ -1,6 +1,7 @@
 package revolt
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -53,11 +54,10 @@ type SelfBot struct {
 }
 
 // Fetch a channel by Id.
-func (c *Client) FetchChannel(id string) (*Channel, error) {
+func (c *Client) FetchChannel(ctx context.Context, id string) (*Channel, error) {
 	channel := &Channel{}
-	channel.Client = c
 
-	data, err := c.Request("GET", "/channels/"+id, []byte{})
+	data, err := c.Request(ctx, "GET", "/channels/"+id, []byte{})
 
 	if err != nil {
 		return channel, err
@@ -68,11 +68,10 @@ func (c *Client) FetchChannel(id string) (*Channel, error) {
 }
 
 // Fetch an user by Id.
-func (c *Client) FetchUser(id string) (*User, error) {
+func (c *Client) FetchUser(ctx context.Context, id string) (*User, error) {
 	user := &User{}
-	user.Client = c
 
-	data, err := c.Request("GET", "/users/"+id, []byte{})
+	data, err := c.Request(ctx, "GET", "/users/"+id, []byte{})
 
 	if err != nil {
 		return user, err
@@ -83,11 +82,10 @@ func (c *Client) FetchUser(id string) (*User, error) {
 }
 
 // Fetch a server by Id.
-func (c *Client) FetchServer(id string) (*Server, error) {
+func (c *Client) FetchServer(ctx context.Context, id string) (*Server, error) {
 	server := &Server{}
-	server.Client = c
 
-	data, err := c.Request("GET", "/servers/"+id, []byte{})
+	data, err := c.Request(ctx, "GET", "/servers/"+id, []byte{})
 
 	if err != nil {
 		return server, err
@@ -98,11 +96,10 @@ func (c *Client) FetchServer(id string) (*Server, error) {
 }
 
 // Create a server.
-func (c *Client) CreateServer(name, description string) (*Server, error) {
+func (c *Client) CreateServer(ctx context.Context, name, description string) (*Server, error) {
 	server := &Server{}
-	server.Client = c
 
-	data, err := c.Request("POST", "/servers/create", []byte("{\"name\":\""+name+"\",\"description\":\""+description+"\",\"nonce\":\""+genULID()+"\"}"))
+	data, err := c.Request(ctx, "POST", "/servers/create", []byte("{\"name\":\""+name+"\",\"description\":\""+description+"\",\"nonce\":\""+genULID()+"\"}"))
 
 	if err != nil {
 		return server, err
@@ -113,12 +110,12 @@ func (c *Client) CreateServer(name, description string) (*Server, error) {
 }
 
 // Auth client user.
-func (c *Client) Auth(friendlyName string) error {
+func (c *Client) Auth(ctx context.Context, friendlyName string) error {
 	if c.SelfBot == nil {
 		return fmt.Errorf("can't auth user (not a self-bot.)")
 	}
 
-	resp, err := c.Request("POST", "/auth/session/login", []byte("{\"email\":\""+c.SelfBot.Email+"\",\"password\":\""+c.SelfBot.Password+"\",\"friendly_name\":\""+friendlyName+"\"}"))
+	resp, err := c.Request(ctx, "POST", "/auth/session/login", []byte("{\"email\":\""+c.SelfBot.Email+"\",\"password\":\""+c.SelfBot.Password+"\",\"friendly_name\":\""+friendlyName+"\"}"))
 
 	if err != nil {
 		return err
@@ -129,10 +126,10 @@ func (c *Client) Auth(friendlyName string) error {
 }
 
 // Fetch all of the DMs.
-func (c *Client) FetchDirectMessages() ([]*Channel, error) {
+func (c *Client) FetchDirectMessages(ctx context.Context) ([]*Channel, error) {
 	var dmChannels []*Channel
 
-	resp, err := c.Request("GET", "/users/dms", []byte{})
+	resp, err := c.Request(ctx, "GET", "/users/dms", []byte{})
 
 	if err != nil {
 		return dmChannels, err
@@ -144,31 +141,25 @@ func (c *Client) FetchDirectMessages() ([]*Channel, error) {
 		return dmChannels, err
 	}
 
-	// Prepare channels.
-	for _, i := range dmChannels {
-		i.Client = c
-	}
-
 	return dmChannels, nil
 }
 
 // Edit client user.
-func (c Client) Edit(eu *EditUser) error {
+func (c Client) Edit(ctx context.Context, eu *EditUser) error {
 	data, err := json.Marshal(eu)
 
 	if err != nil {
 		return err
 	}
 
-	_, err = c.Request("PATCH", "/users/@me", data)
+	_, err = c.Request(ctx, "PATCH", "/users/@me", data)
 	return err
 }
 
 // Create a new group.
 // Users parameter is a list of users will be added.
-func (c *Client) CreateGroup(name, description string, users []string) (*Channel, error) {
+func (c *Client) CreateGroup(ctx context.Context, name, description string, users []string) (*Channel, error) {
 	groupChannel := &Channel{}
-	groupChannel.Client = c
 
 	dataStruct := &struct {
 		Name        string   `json:"name"`
@@ -188,7 +179,7 @@ func (c *Client) CreateGroup(name, description string, users []string) (*Channel
 		return groupChannel, err
 	}
 
-	resp, err := c.Request("POST", "/channels/create", data)
+	resp, err := c.Request(ctx, "POST", "/channels/create", data)
 
 	if err != nil {
 		return groupChannel, err
@@ -199,10 +190,10 @@ func (c *Client) CreateGroup(name, description string, users []string) (*Channel
 }
 
 // Fetch relationships.
-func (c Client) FetchRelationships() ([]*UserRelations, error) {
+func (c Client) FetchRelationships(ctx context.Context) ([]*UserRelations, error) {
 	relationshipDatas := []*UserRelations{}
 
-	resp, err := c.Request("GET", "/users/relationships", []byte{})
+	resp, err := c.Request(ctx, "GET", "/users/relationships", []byte{})
 
 	if err != nil {
 		return relationshipDatas, err
@@ -214,10 +205,10 @@ func (c Client) FetchRelationships() ([]*UserRelations, error) {
 
 // Send friend request. / Accept friend request.
 // User relations struct only will have status. id is not defined for this function.
-func (c Client) AddFriend(username string) (*UserRelations, error) {
+func (c Client) AddFriend(ctx context.Context, username string) (*UserRelations, error) {
 	relationshipData := &UserRelations{}
 
-	resp, err := c.Request("PUT", "/users/"+username+"/friend", []byte{})
+	resp, err := c.Request(ctx, "PUT", "/users/"+username+"/friend", []byte{})
 
 	if err != nil {
 		return relationshipData, err
@@ -229,10 +220,10 @@ func (c Client) AddFriend(username string) (*UserRelations, error) {
 
 // Deny friend request. / Remove friend.
 // User relations struct only will have status. id is not defined for this function.
-func (c Client) RemoveFriend(username string) (*UserRelations, error) {
+func (c Client) RemoveFriend(ctx context.Context, username string) (*UserRelations, error) {
 	relationshipData := &UserRelations{}
 
-	resp, err := c.Request("DELETE", "/users/"+username+"/friend", []byte{})
+	resp, err := c.Request(ctx, "DELETE", "/users/"+username+"/friend", []byte{})
 
 	if err != nil {
 		return relationshipData, err
@@ -243,11 +234,10 @@ func (c Client) RemoveFriend(username string) (*UserRelations, error) {
 }
 
 // Create a new bot.
-func (c *Client) CreateBot(name string) (*Bot, error) {
+func (c *Client) CreateBot(ctx context.Context, name string) (*Bot, error) {
 	botData := &Bot{}
-	botData.Client = c
 
-	resp, err := c.Request("POST", "/bots/create", []byte("{\"name\":\""+name+"\"}"))
+	resp, err := c.Request(ctx, "POST", "/bots/create", []byte("{\"name\":\""+name+"\"}"))
 
 	if err != nil {
 		return botData, err
@@ -259,10 +249,10 @@ func (c *Client) CreateBot(name string) (*Bot, error) {
 }
 
 // Fetch client bots.
-func (c *Client) FetchBots() (*FetchedBots, error) {
+func (c *Client) FetchBots(ctx context.Context) (*FetchedBots, error) {
 	bots := &FetchedBots{}
 
-	resp, err := c.Request("GET", "/bots/@me", []byte{})
+	resp, err := c.Request(ctx, "GET", "/bots/@me", []byte{})
 
 	if err != nil {
 		return bots, err
@@ -274,30 +264,18 @@ func (c *Client) FetchBots() (*FetchedBots, error) {
 		return bots, err
 	}
 
-	// Add client for bots.
-	for _, i := range bots.Bots {
-		i.Client = c
-	}
-
-	// Add client for users.
-	for _, i := range bots.Users {
-		i.Client = c
-	}
-
 	return bots, nil
 }
 
 // Fetch a bot.
-func (c *Client) FetchBot(id string) (*Bot, error) {
+func (c *Client) FetchBot(ctx context.Context, id string) (*Bot, error) {
 	bot := &struct {
 		Bot *Bot `json:"bot"`
 	}{
-		Bot: &Bot{
-			Client: c,
-		},
+		Bot: &Bot{},
 	}
 
-	resp, err := c.Request("GET", "/bots/"+id, []byte{})
+	resp, err := c.Request(ctx, "GET", "/bots/"+id, []byte{})
 
 	if err != nil {
 		return bot.Bot, err
diff --git a/web/revolt/group.go b/web/revolt/group.go
index 6d3179d..17e33c4 100644
--- a/web/revolt/group.go
+++ b/web/revolt/group.go
@@ -1,6 +1,7 @@
 package revolt
 
 import (
+	"context"
 	"encoding/json"
 	"time"
 
@@ -9,10 +10,9 @@ import (
 
 // Group channel struct.
 type Group struct {
-	Client    *Client
 	CreatedAt time.Time
 
-	Id          string   `json:"_id"`	
+	Id          string   `json:"_id"`
 	Nonce       string   `json:"nonce"`
 	OwnerId     string   `json:"owner"`
 	Name        string   `json:"name"`
@@ -28,8 +28,8 @@ type FetchedGroupMembers struct {
 
 // System messages struct.
 type GroupSystemMessages struct {
-	UserJoined  string `json:"user_joined,omitempty"`
-	UserLeft    string `json:"user_left,omitempty"`
+	UserJoined string `json:"user_joined,omitempty"`
+	UserLeft   string `json:"user_left,omitempty"`
 }
 
 // Calculate creation date and edit the struct.
@@ -45,10 +45,10 @@ func (c *Group) CalculateCreationDate() error {
 }
 
 // Fetch all of the members from group.
-func (c Channel) FetchMembers() ([]*User, error) {
+func (c *Client) GroupFetchMembers(ctx context.Context, groupID string) ([]*User, error) {
 	var groupMembers []*User
 
-	resp, err := c.Client.Request("GET", "/channels/"+c.Id+"/members", []byte{})
+	resp, err := c.Request(ctx, "GET", "/channels/"+groupID+"/members", []byte{})
 
 	if err != nil {
 		return groupMembers, err
@@ -59,13 +59,13 @@ func (c Channel) FetchMembers() ([]*User, error) {
 }
 
 // Add a new group recipient.
-func (c Channel) AddGroupRecipient(user_id string) error {
-	_, err := c.Client.Request("PUT", "/channels/"+c.Id+"/recipients/"+user_id, []byte{})
+func (c *Client) AddGroupRecipient(ctx context.Context, groupID, userID string) error {
+	_, err := c.Request(ctx, "PUT", "/channels/"+groupID+"/recipients/"+userID, []byte{})
 	return err
 }
 
 // Delete a group recipient.
-func (c Channel) DeleteGroupRecipient(user_id string) error {
-	_, err := c.Client.Request("DELETE", "/channels/"+c.Id+"/recipients/"+user_id, []byte{})
+func (c *Client) DeleteGroupRecipient(ctx context.Context, groupID, userID string) error {
+	_, err := c.Request(ctx, "DELETE", "/channels/"+groupID+"/recipients/"+userID, []byte{})
 	return err
-}
\ No newline at end of file
+}
diff --git a/web/revolt/http.go b/web/revolt/http.go
index a2eb2df..6be6853 100644
--- a/web/revolt/http.go
+++ b/web/revolt/http.go
@@ -2,17 +2,18 @@ package revolt
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"io"
 	"net/http"
 )
 
 // Send http request
-func (c Client) Request(method, path string, data []byte) ([]byte, error) {
+func (c Client) Request(ctx context.Context, method, path string, data []byte) ([]byte, error) {
 	reqBody := bytes.NewBuffer(data)
 
 	// Prepare request
-	req, err := http.NewRequest(method, c.BaseURL+path, reqBody)
+	req, err := http.NewRequestWithContext(ctx, method, c.BaseURL+path, reqBody)
 	if err != nil {
 		return []byte{}, err
 	}
diff --git a/web/revolt/message.go b/web/revolt/message.go
index bf4651a..fa1bbd8 100644
--- a/web/revolt/message.go
+++ b/web/revolt/message.go
@@ -1,6 +1,7 @@
 package revolt
 
 import (
+	"context"
 	"encoding/json"
 	"time"
 
@@ -9,10 +10,9 @@ import (
 
 // Message struct
 type Message struct {
-	Client    *Client
 	CreatedAt time.Time
 
-	Id          string          `json:"_id"`
+	ID          string          `json:"_id"`
 	Nonce       string          `json:"nonce"`
 	ChannelId   string          `json:"channel"`
 	AuthorId    string          `json:"author"`
@@ -94,7 +94,7 @@ type MessageEmbeddedVideo struct {
 
 // Calculate creation date and edit the struct.
 func (c *Message) CalculateCreationDate() error {
-	ulid, err := ulid.Parse(c.Id)
+	ulid, err := ulid.Parse(c.ID)
 
 	if err != nil {
 		return err
@@ -105,40 +105,44 @@ func (c *Message) CalculateCreationDate() error {
 }
 
 // Edit message content.
-func (m *Message) Edit(content string) error {
-	_, err := m.Client.Request("PATCH", "/channels/"+m.ChannelId+"/messages/"+m.Id, []byte("{\"content\": \""+content+"\"}"))
+func (c *Client) MessageEdit(ctx context.Context, channelID, messageID, content string) error {
+	data, err := json.Marshal(map[string]string{
+		"content": content,
+	})
+	if err != nil {
+		return err
+	}
 
+	_, err = c.Request(ctx, "PATCH", "/channels/"+channelID+"/messages/"+messageID, data)
 	if err != nil {
 		return err
 	}
 
-	m.Content = content
 	return nil
 }
 
 // Delete the message.
-func (m Message) Delete() error {
-	_, err := m.Client.Request("DELETE", "/channels/"+m.ChannelId+"/messages/"+m.Id, []byte{})
+func (c *Client) MessageDelete(ctx context.Context, channelID, messageID string) error {
+	_, err := c.Request(ctx, "DELETE", "/channels/"+channelID+"/messages/"+messageID, []byte{})
 	return err
 }
 
 // Reply to the message.
-func (m Message) Reply(mention bool, sm *SendMessage) (*Message, error) {
+func (c *Client) MessageReply(ctx context.Context, channelID, messageID string, mention bool, sm *SendMessage) (*Message, error) {
 	if sm.Nonce == "" {
 		sm.CreateNonce()
 	}
 
-	sm.AddReply(m.Id, mention)
+	sm.AddReply(messageID, mention)
 
 	respMessage := &Message{}
-	respMessage.Client = m.Client
 	msgData, err := json.Marshal(sm)
 
 	if err != nil {
 		return respMessage, err
 	}
 
-	resp, err := m.Client.Request("POST", "/channels/"+m.ChannelId+"/messages", msgData)
+	resp, err := c.Request(ctx, "POST", "/channels/"+channelID+"/messages", msgData)
 
 	if err != nil {
 		return respMessage, err
@@ -153,7 +157,7 @@ func (m Message) Reply(mention bool, sm *SendMessage) (*Message, error) {
 	if sm.DeleteAfter != 0 {
 		go func() {
 			time.Sleep(time.Second * time.Duration(sm.DeleteAfter))
-			respMessage.Delete()
+			c.MessageDelete(ctx, channelID, respMessage.ID)
 		}()
 	}
 
diff --git a/web/revolt/server.go b/web/revolt/server.go
index 001fe6a..06652d2 100644
--- a/web/revolt/server.go
+++ b/web/revolt/server.go
@@ -1,8 +1,8 @@
 package revolt
 
 import (
+	"context"
 	"encoding/json"
-	"fmt"
 	"time"
 
 	"github.com/oklog/ulid/v2"
@@ -10,7 +10,6 @@ import (
 
 // Server struct.
 type Server struct {
-	Client    *Client
 	CreatedAt time.Time
 
 	Id                 string                 `json:"_id"`
@@ -93,14 +92,14 @@ func (s *Server) CalculateCreationDate() error {
 }
 
 // Edit server.
-func (s Server) Edit(es *EditServer) error {
+func (c *Client) ServerEdit(ctx context.Context, serverID string, es *EditServer) error {
 	data, err := json.Marshal(es)
 
 	if err != nil {
 		return err
 	}
 
-	_, err = s.Client.Request("PATCH", "/servers/"+s.Id, data)
+	_, err = c.Request(ctx, "PATCH", "/servers/"+serverID, data)
 
 	if err != nil {
 		return err
@@ -112,8 +111,8 @@ func (s Server) Edit(es *EditServer) error {
 // Delete / leave server.
 // If the server not created by client, it will leave.
 // Otherwise it will be deleted.
-func (s Server) Delete() error {
-	_, err := s.Client.Request("DELETE", "/servers/"+s.Id, []byte{})
+func (c *Client) ServerDelete(ctx context.Context, serverID string) error {
+	_, err := c.Request(ctx, "DELETE", "/servers/"+serverID, []byte{})
 
 	if err != nil {
 		return err
@@ -123,11 +122,10 @@ func (s Server) Delete() error {
 }
 
 // Create a new text-channel.
-func (s Server) CreateTextChannel(name, description string) (*Channel, error) {
+func (c *Client) CreateTextChannel(ctx context.Context, serverID, name, description string) (*Channel, error) {
 	channel := &Channel{}
-	channel.Client = s.Client
 
-	data, err := s.Client.Request("POST", "/servers/"+s.Id+"/channels", []byte("{\"type\":\"Text\",\"name\":\""+name+"\",\"description\":\""+description+"\",\"nonce\":\""+genULID()+"\"}"))
+	data, err := c.Request(ctx, "POST", "/servers/"+serverID+"/channels", []byte("{\"type\":\"Text\",\"name\":\""+name+"\",\"description\":\""+description+"\",\"nonce\":\""+genULID()+"\"}"))
 
 	if err != nil {
 		return channel, err
@@ -143,11 +141,10 @@ func (s Server) CreateTextChannel(name, description string) (*Channel, error) {
 }
 
 // Create a new voice-channel.
-func (s Server) CreateVoiceChannel(name, description string) (*Channel, error) {
+func (c *Client) CreateVoiceChannel(ctx context.Context, serverID, name, description string) (*Channel, error) {
 	channel := &Channel{}
-	channel.Client = s.Client
 
-	data, err := s.Client.Request("POST", "/servers/"+s.Id+"/channels", []byte("{\"type\":\"Voice\",\"name\":\""+name+"\",\"description\":\""+description+"\",\"nonce\":\""+genULID()+"\"}"))
+	data, err := c.Request(ctx, "POST", "/servers/"+serverID+"/channels", []byte("{\"type\":\"Voice\",\"name\":\""+name+"\",\"description\":\""+description+"\",\"nonce\":\""+genULID()+"\"}"))
 
 	if err != nil {
 		return channel, err
@@ -163,10 +160,10 @@ func (s Server) CreateVoiceChannel(name, description string) (*Channel, error) {
 }
 
 // Fetch a member from Server.
-func (s Server) FetchMember(id string) (*Member, error) {
+func (c *Client) ServerFetchMember(ctx context.Context, serverID, id string) (*Member, error) {
 	member := &Member{}
 
-	data, err := s.Client.Request("GET", "/servers/"+s.Id+"/members/"+id, []byte{})
+	data, err := c.Request(ctx, "GET", "/servers/"+serverID+"/members/"+id, []byte{})
 
 	if err != nil {
 		return member, err
@@ -182,10 +179,10 @@ func (s Server) FetchMember(id string) (*Member, error) {
 }
 
 // Fetch all of the members from Server.
-func (s Server) FetchMembers() (*FetchedMembers, error) {
+func (c *Client) ServerFetchMembers(ctx context.Context, serverID string) (*FetchedMembers, error) {
 	members := &FetchedMembers{}
 
-	data, err := s.Client.Request("GET", "/servers/"+s.Id+"/members", []byte{})
+	data, err := c.Request(ctx, "GET", "/servers/"+serverID+"/members", []byte{})
 
 	if err != nil {
 		return members, err
@@ -197,23 +194,18 @@ func (s Server) FetchMembers() (*FetchedMembers, error) {
 		return members, err
 	}
 
-	// Add client to the user
-	for _, i := range members.Users {
-		i.Client = s.Client
-	}
-
 	return members, nil
 }
 
 // Edit a member.
-func (s Server) EditMember(id string, em *EditMember) error {
+func (c *Client) ServerEditMember(ctx context.Context, serverID, id string, em *EditMember) error {
 	data, err := json.Marshal(em)
 
 	if err != nil {
 		return err
 	}
 
-	_, err = s.Client.Request("PATCH", "/servers/"+s.Id+"/members/"+id, data)
+	_, err = c.Request(ctx, "PATCH", "/servers/"+serverID+"/members/"+id, data)
 
 	if err != nil {
 		return err
@@ -223,8 +215,8 @@ func (s Server) EditMember(id string, em *EditMember) error {
 }
 
 // Kick a member from server.
-func (s Server) KickMember(id string) error {
-	_, err := s.Client.Request("DELETE", "/servers/"+s.Id+"/members/"+id, []byte{})
+func (c *Client) ServerKickMember(ctx context.Context, serverID, id string) error {
+	_, err := c.Request(ctx, "DELETE", "/servers/"+serverID+"/members/"+id, []byte{})
 
 	if err != nil {
 		return err
@@ -234,8 +226,12 @@ func (s Server) KickMember(id string) error {
 }
 
 // Ban a member from server.
-func (s Server) BanMember(id, reason string) error {
-	_, err := s.Client.Request("PUT", "/servers/"+s.Id+"/bans/"+id, []byte("{\"reason\":\""+reason+"\"}"))
+func (c *Client) ServerBanMember(ctx context.Context, serverID, id, reason string) error {
+	data, err := json.Marshal(map[string]string{"reason": reason})
+	if err != nil {
+		return err
+	}
+	_, err = c.Request(ctx, "PUT", "/servers/"+serverID+"/bans/"+id, data)
 
 	if err != nil {
 		return err
@@ -245,9 +241,8 @@ func (s Server) BanMember(id, reason string) error {
 }
 
 // Unban a member from server.
-func (s Server) UnbanMember(id string) error {
-	_, err := s.Client.Request("DELETE", "/servers/"+s.Id+"/bans/"+id, []byte{})
-
+func (c *Client) ServerUnbanMember(ctx context.Context, serverID, id string) error {
+	_, err := c.Request(ctx, "DELETE", "/servers/"+serverID+"/bans/"+id, []byte{})
 	if err != nil {
 		return err
 	}
@@ -256,44 +251,41 @@ func (s Server) UnbanMember(id string) error {
 }
 
 // Fetch server bans.
-func (s Server) FetchBans() (*FetchedBans, error) {
+func (c *Client) ServerFetchBans(ctx context.Context, serverID string) (*FetchedBans, error) {
 	bans := &FetchedBans{}
 
-	data, err := s.Client.Request("GET", "/servers/"+s.Id+"/bans", []byte{})
-
+	data, err := c.Request(ctx, "GET", "/servers/"+serverID+"/bans", []byte{})
 	if err != nil {
 		return bans, err
 	}
 
 	err = json.Unmarshal(data, bans)
-
 	if err != nil {
 		return bans, err
 	}
 
-	// Add client to the user
-	for _, i := range bans.Users {
-		i.Client = s.Client
-	}
-
 	return bans, nil
 }
 
-// Timeout a member from server.
-func (s Server) TimeoutMember(id string) error {
-	// Placeholder for timeout.
-
+// Timeout a member from server. Placeholder.
+func (c *Client) ServerTimeoutMember(ctx context.Context, serverID, id string) error {
 	return nil
 }
 
 // Set server permissions for a role.
 // Leave role field empty if you want to edit default permissions
-func (s Server) SetPermissions(role_id string, channel_permissions, server_permissions uint) error {
-	if role_id == "" {
-		role_id = "default"
+func (c *Client) ServerSetRolePermissions(ctx context.Context, serverID, roleID string, channelPermissions, serverPermissions uint) error {
+	data, err := json.Marshal(map[string]any{
+		"permissions": map[string]any{
+			"server":  serverPermissions,
+			"channel": channelPermissions,
+		},
+	})
+	if roleID == "" {
+		roleID = "default"
 	}
 
-	_, err := s.Client.Request("PUT", "/servers/"+s.Id+"/permissions/"+role_id, []byte(fmt.Sprintf("{\"permissions\":{\"server\":%d,\"channel\":%d}}", channel_permissions, server_permissions)))
+	_, err = c.Request(ctx, "PUT", "/servers/"+serverID+"/permissions/"+roleID, data)
 
 	if err != nil {
 		return err
@@ -304,37 +296,40 @@ func (s Server) SetPermissions(role_id string, channel_permissions, server_permi
 
 // Create a new role for server.
 // Returns string (role id), uint (server perms), uint (channel perms) and error.
-func (s Server) CreateRole(name string) (string, uint, uint, error) {
+func (c *Client) ServerCreateRole(ctx context.Context, serverID, name string) (string, uint, uint, error) {
 	role := &struct {
-		Id          string `json:"id"`
+		ID          string `json:"id"`
 		Permissions []uint `json:"permissions"`
 	}{}
 
-	data, err := s.Client.Request("POST", "/servers/"+s.Id+"/roles", []byte("{\"name\":\""+name+"\"}"))
+	data, err := json.Marshal(map[string]string{
+		"name": name,
+	})
+	if err != nil {
+		return role.ID, 0, 0, err
+	}
 
+	data, err = c.Request(ctx, "POST", "/servers/"+serverID+"/roles", data)
 	if err != nil {
-		return role.Id, 0, 0, err
+		return role.ID, 0, 0, err
 	}
 
 	err = json.Unmarshal(data, role)
-
 	if err != nil {
-		return role.Id, 0, 0, err
+		return role.ID, 0, 0, err
 	}
 
-	return role.Id, role.Permissions[0], role.Permissions[1], nil
+	return role.ID, role.Permissions[0], role.Permissions[1], nil
 }
 
 // Edit a server role.
-func (s Server) EditRole(id string, er *EditRole) error {
+func (c *Client) ServerEditRole(ctx context.Context, serverID, id string, er *EditRole) error {
 	data, err := json.Marshal(er)
-
 	if err != nil {
 		return err
 	}
 
-	_, err = s.Client.Request("PATCH", "/servers/"+s.Id+"/roles/"+id, data)
-
+	_, err = c.Request(ctx, "PATCH", "/servers/"+serverID+"/roles/"+id, data)
 	if err != nil {
 		return err
 	}
@@ -343,9 +338,8 @@ func (s Server) EditRole(id string, er *EditRole) error {
 }
 
 // Delete a server role.
-func (s Server) DeleteRole(id string) error {
-	_, err := s.Client.Request("DELETE", "/servers/"+s.Id+"/roles/"+id, []byte{})
-
+func (c *Client) ServerDeleteRole(ctx context.Context, serverID, id string) error {
+	_, err := c.Request(ctx, "DELETE", "/servers/"+serverID+"/roles/"+id, []byte{})
 	if err != nil {
 		return err
 	}
@@ -354,9 +348,8 @@ func (s Server) DeleteRole(id string) error {
 }
 
 // Fetch server invite.
-func (s Server) FetchInvites(id string) error {
-	_, err := s.Client.Request("GET", "/servers/"+id+"/invites", []byte{})
-
+func (c *Client) ServerFetchInvites(ctx context.Context, serverID string) error {
+	_, err := c.Request(ctx, "GET", "/servers/"+serverID+"/invites", []byte{})
 	if err != nil {
 		return err
 	}
@@ -365,8 +358,8 @@ func (s Server) FetchInvites(id string) error {
 }
 
 // Mark a server as read.
-func (s Server) MarkServerAsRead(id string) error {
-	_, err := s.Client.Request("PUT", "/servers/"+id+"/ack", []byte{})
+func (c *Client) MarkServerAsRead(ctx context.Context, id string) error {
+	_, err := c.Request(ctx, "PUT", "/servers/"+id+"/ack", []byte{})
 
 	if err != nil {
 		return err
diff --git a/web/revolt/user.go b/web/revolt/user.go
index ccfcc81..6fd004e 100644
--- a/web/revolt/user.go
+++ b/web/revolt/user.go
@@ -1,6 +1,7 @@
 package revolt
 
 import (
+	"context"
 	"encoding/json"
 	"time"
 
@@ -59,11 +60,10 @@ func (u User) FormatMention() string {
 }
 
 // Open a DM with the user.
-func (u User) OpenDirectMessage() (*Channel, error) {
+func (c *Client) UserOpenDirectMessage(ctx context.Context, uid