@discordeno/rest 19.0.0-next.fc13bdf → 19.0.0-next.fdf0d53

package/dist/manager.js

@@ -1,9 +1,11 @@
 /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable no-const-assign */ import { InteractionResponseTypes } from '@discordeno/types';
-import { calculateBits, camelize, camelToSnakeCase, delay, findFiles, getBotIdFromToken, isGetMessagesAfter, isGetMessagesAround, isGetMessagesBefore, isGetMessagesLimit, logger, processReactionString, urlToBase64 } from '@discordeno/utils';
+import { calculateBits, camelize, camelToSnakeCase, delay, encode, getBotIdFromToken, isGetMessagesAfter, isGetMessagesAround, isGetMessagesBefore, isGetMessagesLimit, logger, processReactionString, urlToBase64 } from '@discordeno/utils';
+import fetch from 'node-fetch';
 import { createInvalidRequestBucket } from './invalidBucket.js';
 import { Queue } from './queue.js';
 // TODO: make dynamic based on package.json file
 const version = '19.0.0-alpha.1';
+const URL_PARTS_REGEX = /([a-z]+)\/(?:[0-9]{17,}(\/@me)?)/g;
 export function createRestManager(options) {
     // Falsy token string check
     if (!options.token) throw new Error('You must provide a valid token.');
@@ -11,7 +13,7 @@ export function createRestManager(options) {
         token: options.token,
         applicationId: options.applicationId ? BigInt(options.applicationId) : getBotIdFromToken(options.token),
         version: options.version ?? 10,
-        baseUrl: options.baseUrl ?? 'https://discord.com/api',
+        baseUrl: options.proxy?.baseUrl ?? 'https://discord.com/api',
         maxRetryCount: Infinity,
         globallyRateLimited: false,
         processingRateLimitedPaths: false,
@@ -19,6 +21,7 @@ export function createRestManager(options) {
         queues: new Map(),
         rateLimitedPaths: new Map(),
         invalidBucket: createInvalidRequestBucket({}),
+        authorization: options.proxy?.authorization,
         routes: {
             webhooks: {
                 id: (webhookId)=>{
@@ -216,6 +219,8 @@ export function createRestManager(options) {
                         // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
                         if (options.before) url += `&before=${options.before}`;
                         // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                        if (options.after) url += `&after=${options.after}`;
+                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
                         if (options.limit) url += `&limit=${options.limit}`;
                         // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
                         if (options.userId) url += `&user_id=${options.userId}`;
@@ -546,50 +551,40 @@ export function createRestManager(options) {
                 'user-agent': `DiscordBot (https://github.com/discordeno/discordeno, v${version})`
             };
             if (!options.unauthorized) headers.authorization = `Bot ${rest.token}`;
-            // SOMETIMES SPECIAL HEADERS (E.G. CUSTOM AUTHORIZATION) NEED TO BE USED
-            if (options.headers) {
-                for(const key in options.headers){
-                    headers[key.toLowerCase()] = options.headers[key];
-                }
-            }
-            // GET METHODS SHOULD NOT HAVE A BODY
-            if (options.method === 'GET') {
-                options.body = undefined;
-            }
             // IF A REASON IS PROVIDED ENCODE IT IN HEADERS
-            if (options.body?.reason) {
-                headers['X-Audit-Log-Reason'] = encodeURIComponent(options.body.reason);
-                options.body.reason = undefined;
+            if (options.reason !== undefined) {
+                headers['x-audit-log-reason'] = encodeURIComponent(options.reason);
             }
-            if (options.body) {
-                const { file  } = options.body;
-                if (file) {
-                    const files = findFiles(file);
-                    const form = new FormData();
-                    // WHEN CREATING A STICKER, DISCORD WANTS FORM DATA ONLY
-                    if (options.url?.endsWith('/stickers') && options.method === 'POST') {
-                        form.append('file', files[0].blob, files[0].name);
-                        form.append('name', options.body.name);
-                        form.append('description', options.body.description);
-                        form.append('tags', options.body.tags);
-                    } else {
-                        for(let i = 0; i < files.length; i++){
-                            form.append(`file${i}`, files[i].blob, files[i].name);
-                        }
-                        if (file) options.body.file = undefined;
-                        form.append('payload_json', JSON.stringify(rest.changeToDiscordFormat(options.body)));
-                    }
-                    options.body.file = form;
-                } else if (options.body && ![
-                    'GET',
-                    'DELETE'
-                ].includes(options.method)) {
-                    headers['Content-Type'] = 'application/json';
+            let body;
+            // TODO: check if we need to add specific check for GET method
+            // Since GET does not allow bodies
+            // Have to check for attachments first, since body then has to be send in a different way.
+            if (options.attachments !== undefined) {
+                const form = new FormData();
+                for(let i = 0; i < options.attachments.length; ++i){
+                    form.append(`file${i}`, options.attachments[i].blob, options.attachments[i].name);
                 }
+                form.append('payload_json', JSON.stringify(options.body));
+                body = form;
+                // TODO: boundary?
+                // `multipart/form-data; boundary=${form.getBoundary()}`
+                headers['content-type'] = `multipart/form-data`;
+            } else if (options.body !== undefined) {
+                if (options.body instanceof FormData) {
+                    body = options.body;
+                    headers['content-type'] = `multipart/form-data`;
+                } else {
+                    body = JSON.stringify(options.body);
+                    headers['content-type'] = `application/json`;
+                }
+            }
+            // SOMETIMES SPECIAL HEADERS (E.G. CUSTOM AUTHORIZATION) NEED TO BE USED
+            if (options.headers) {
+                Object.assign(headers, options.headers);
             }
             return {
+                body,
                 headers,
-                body: options.body?.file ?? JSON.stringify(rest.changeToDiscordFormat(options.body)),
                 method: options.method
             };
         },
@@ -655,8 +650,8 @@ export function createRestManager(options) {
             }
             // IF THERE IS NO REMAINING GLOBAL LIMIT, MARK IT RATE LIMITED GLOBALLY
             if (global) {
-                const retryAfter1 = headers.get('retry-after');
-                const globalReset = Date.now() + Number(retryAfter1) * 1000;
+                const retryAfter = headers.get('retry-after');
+                const globalReset = Date.now() + Number(retryAfter) * 1000;
                 //   rest.debug(
                 // `[REST = Globally Rate Limited] URL: ${url} | Global Rest: ${globalReset}`
                 //   )
@@ -688,7 +683,7 @@ export function createRestManager(options) {
             const payload = rest.createRequest({
                 method: options.method,
                 url: options.url,
-                body: options.body,
+                body: options.options?.body,
                 ...options.options
             });
             logger.debug(`sending request to ${url}`, 'with payload:', {
@@ -712,11 +707,12 @@ export function createRestManager(options) {
                         logger.debug(`Request to ${url} exceeded the maximum allowed retries.`, 'with payload:', payload);
                         // rest.debug(`[REST - RetriesMaxed] ${JSON.stringify(options)}`)
                         // Remove item from queue to prevent retry
-                        return options.reject({
+                        options.reject({
                             ok: false,
                             status: response.status,
                             error: 'The options was rate limited and it maxed out the retries limit.'
                         });
+                        return;
                     }
                     // Rate limited, add back to queue
                     rest.invalidBucket.handleCompletedRequest(response.status, response.headers.get('X-RateLimit-Scope') === 'shared');
@@ -726,16 +722,17 @@ export function createRestManager(options) {
                     await response.json();
                     return await options.retryRequest?.(options);
                 }
-                return options.reject({
+                options.reject({
                     ok: false,
                     status: response.status,
                     body: JSON.stringify(await response.json())
                 });
+                return;
             }
             const is204 = response.status === 204;
             const json = is204 ? undefined : await response.json();
             // Discord sometimes sends no response with 204 code
-            return options.resolve({
+            options.resolve({
                 ok: true,
                 status: response.status,
                 body: JSON.stringify(json)
@@ -744,19 +741,23 @@ export function createRestManager(options) {
         // Credits: github.com/abalabahaha/eris lib/rest/RequestHandler.js#L397
         // Modified for our use-case
         simplifyUrl (url, method) {
-            let route = url.replace(/\/([a-z-]+)\/(?:[0-9]{17,19})/g, function(match, p) {
-                return [
-                    'channels',
-                    'guilds'
-                ].includes(p) ? match : `/${p}/x`;
-            }).replace(/\/reactions\/[^/]+/g, '/reactions/x');
-            // GENERAL /reactions and /reactions/emoji/@me share the buckets
+            let route = url.replace(URL_PARTS_REGEX, function(match, pattern) {
+                if (pattern.startsWith('channels') || pattern.startsWith('guilds')) {
+                    return match;
+                }
+                // GENERAL /reactions and /reactions/emoji/@me share the buckets
+                if (pattern.startsWith('reactions')) {
+                    return 'reactions';
+                }
+                return `${pattern}/x`;
+            });
             if (route.includes('/reactions')) {
-                route = route.substring(0, route.indexOf('/reactions') + '/reactions'.length);
+                // 10 is the length of `/reactions`
+                route = route.substring(0, route.indexOf('/reactions') + 10);
             }
             // Delete Message endpoint has its own rate limit
             if (method === 'DELETE' && route.endsWith('/messages/x')) {
-                route = method + route;
+                route = 'D' + route;
             }
             return route;
         },
@@ -785,45 +786,95 @@ export function createRestManager(options) {
                 rest.queues.set(url, bucketQueue);
             }
         },
-        async makeRequest (method, url, body, options) {
+        async makeRequest (method, url, options) {
+            if (!rest.baseUrl.startsWith('https://discord.com') && url[0] === '/') {
+                // Special handling for sending blobs across http to proxy
+                // TODO: fix this hacky handling
+                if (!(options?.body instanceof FormData) && !Array.isArray(options?.body) && options?.body?.file) {
+                    if (!Array.isArray(options.body.file)) {
+                        options.body.file = [
+                            options.body.file
+                        ];
+                    }
+                    // convert blobs to string before sending to proxy
+                    options.body.file = await Promise.all(options.body.file.map(async (f)=>{
+                        const url = encode(await f.blob.arrayBuffer());
+                        return {
+                            name: f.name,
+                            blob: `data:${f.blob.type};base64,${url}`
+                        };
+                    }));
+                }
+                const headers = {
+                    Authorization: rest.authorization ?? ''
+                };
+                if (options?.body) {
+                    headers['Content-Type'] = 'application/json';
+                }
+                const result = await fetch(`${rest.baseUrl}${url}`, {
+                    body: options?.body ? JSON.stringify(options.body) : undefined,
+                    headers,
+                    method
+                });
+                if (!result.ok) {
+                    const err = await result.json().catch(()=>{});
+                    // Legacy Handling to not break old code or when body is missing
+                    if (!err?.body) throw new Error(`Error: ${err.message ?? result.statusText}`);
+                    throw new Error(JSON.stringify(err));
+                }
+                return result.status !== 204 ? await result.json() : undefined;
+            }
             return await new Promise((resolve, reject)=>{
                 const payload = {
                     url,
                     method,
-                    body,
+                    options,
                     retryCount: 0,
-                    retryRequest: async function(options) {
+                    retryRequest: async function(payload) {
                         rest.processRequest(payload);
                     },
-                    resolve: (data)=>resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined),
-                    reject,
-                    options
+                    resolve: (data)=>{
+                        resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined);
+                    },
+                    reject
                 };
                 rest.processRequest(payload);
             });
         },
-        async get (url) {
-            return camelize(await rest.makeRequest('GET', url));
+        async get (url, body) {
+            return camelize(await rest.makeRequest('GET', url, {
+                body
+            }));
         },
         async post (url, body) {
-            return camelize(await rest.makeRequest('POST', url, body));
+            return camelize(await rest.makeRequest('POST', url, {
+                body
+            }));
         },
         async delete (url, body) {
-            return camelize(await rest.makeRequest('DELETE', url, body));
+            camelize(await rest.makeRequest('DELETE', url, {
+                body
+            }));
         },
         async patch (url, body) {
-            return camelize(await rest.makeRequest('PATCH', url, body));
+            return camelize(await rest.makeRequest('PATCH', url, {
+                body
+            }));
         },
-        async put (url, body, options) {
-            return camelize(await rest.makeRequest('PUT', url, body, options));
+        async put (url, body) {
+            return camelize(await rest.makeRequest('PUT', url, {
+                body
+            }));
         },
         async addReaction (channelId, messageId, reaction) {
             reaction = processReactionString(reaction);
-            return await rest.put(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
+            await rest.put(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
         },
         async addReactions (channelId, messageId, reactions, ordered = false) {
             if (!ordered) {
-                await Promise.all(reactions.map(async (reaction)=>await rest.addReaction(channelId, messageId, reaction)));
+                await Promise.all(reactions.map(async (reaction)=>{
+                    await rest.addReaction(channelId, messageId, reaction);
+                }));
                 return;
             }
             for (const reaction of reactions){
@@ -831,283 +882,373 @@ export function createRestManager(options) {
             }
         },
         async addRole (guildId, userId, roleId, reason) {
-            return await rest.put(rest.routes.guilds.roles.member(guildId, userId, roleId), {
+            await rest.put(rest.routes.guilds.roles.member(guildId, userId, roleId), {
                 reason
             });
         },
         async addThreadMember (channelId, userId) {
-            return await rest.put(rest.routes.channels.threads.user(channelId, userId));
+            await rest.put(rest.routes.channels.threads.user(channelId, userId));
         },
-        async createAutomodRule (guildId, options) {
-            return await rest.post(rest.routes.guilds.automod.rules(guildId), options);
+        async createAutomodRule (guildId, body) {
+            return await rest.post(rest.routes.guilds.automod.rules(guildId), {
+                body
+            });
         },
-        async createChannel (guildId, options) {
-            return await rest.post(rest.routes.guilds.channels(guildId), options);
+        async createChannel (guildId, body) {
+            return await rest.post(rest.routes.guilds.channels(guildId), {
+                body
+            });
         },
-        async createEmoji (guildId, options) {
-            return await rest.post(rest.routes.guilds.emojis(guildId), options);
+        async createEmoji (guildId, body) {
+            return await rest.post(rest.routes.guilds.emojis(guildId), {
+                body
+            });
         },
-        async createGlobalApplicationCommand (command) {
-            return await rest.post(rest.routes.interactions.commands.commands(rest.applicationId), command);
+        async createGlobalApplicationCommand (body) {
+            return await rest.post(rest.routes.interactions.commands.commands(rest.applicationId), {
+                body
+            });
         },
-        async createGuild (options) {
-            return await rest.post(rest.routes.guilds.all(), options);
+        async createGuild (body) {
+            return await rest.post(rest.routes.guilds.all(), {
+                body
+            });
         },
-        async createGuildApplicationCommand (command, guildId) {
-            return await rest.post(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), command);
+        async createGuildApplicationCommand (body, guildId) {
+            return await rest.post(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), {
+                body
+            });
         },
-        async createGuildFromTemplate (templateCode, options) {
-            if (options.icon) {
-                options.icon = await urlToBase64(options.icon);
+        async createGuildFromTemplate (templateCode, body) {
+            if (body.icon) {
+                body.icon = await urlToBase64(body.icon);
             }
-            return await rest.post(rest.routes.guilds.templates.code(templateCode), options);
+            return await rest.post(rest.routes.guilds.templates.code(templateCode), {
+                body
+            });
         },
         async createGuildSticker (guildId, options) {
-            return await rest.post(rest.routes.guilds.stickers(guildId), options);
+            const form = new FormData();
+            form.append('file', options.file.blob, options.file.name);
+            form.append('name', options.name);
+            form.append('description', options.description);
+            form.append('tags', options.tags);
+            return await rest.post(rest.routes.guilds.stickers(guildId), {
+                body: form
+            });
         },
-        async createGuildTemplate (guildId, options) {
-            return await rest.post(rest.routes.guilds.templates.all(guildId), options);
+        async createGuildTemplate (guildId, body) {
+            return await rest.post(rest.routes.guilds.templates.all(guildId), {
+                body
+            });
         },
-        async createForumThread (channelId, options) {
-            return await rest.post(rest.routes.channels.forum(channelId), options);
+        async createForumThread (channelId, body) {
+            return await rest.post(rest.routes.channels.forum(channelId), {
+                body
+            });
         },
-        async createInvite (channelId, options = {}) {
-            return await rest.post(rest.routes.channels.invites(channelId), options);
+        async createInvite (channelId, body = {}) {
+            return await rest.post(rest.routes.channels.invites(channelId), {
+                body
+            });
         },
-        async createRole (guildId, options, reason) {
+        async createRole (guildId, body, reason) {
             return await rest.post(rest.routes.guilds.roles.all(guildId), {
-                ...options,
+                body,
                 reason
             });
         },
-        async createScheduledEvent (guildId, options) {
-            return await rest.post(rest.routes.guilds.events.events(guildId), options);
+        async createScheduledEvent (guildId, body) {
+            return await rest.post(rest.routes.guilds.events.events(guildId), {
+                body
+            });
         },
-        async createStageInstance (options) {
-            return await rest.post(rest.routes.channels.stages(), options);
+        async createStageInstance (body) {
+            return await rest.post(rest.routes.channels.stages(), {
+                body
+            });
         },
-        async createWebhook (channelId, options) {
+        async createWebhook (channelId, options, reason) {
             return await rest.post(rest.routes.channels.webhooks(channelId), {
-                name: options.name,
-                avatar: options.avatar ? await urlToBase64(options.avatar) : undefined,
-                reason: options.reason
+                body: {
+                    name: options.name,
+                    avatar: options.avatar ? await urlToBase64(options.avatar) : undefined
+                },
+                reason
             });
         },
         async deleteAutomodRule (guildId, ruleId, reason) {
-            return await rest.delete(rest.routes.guilds.automod.rule(guildId, ruleId), {
+            await rest.delete(rest.routes.guilds.automod.rule(guildId, ruleId), {
                 reason
             });
         },
         async deleteChannel (channelId, reason) {
-            return await rest.delete(rest.routes.channels.channel(channelId), {
+            await rest.delete(rest.routes.channels.channel(channelId), {
                 reason
             });
         },
         async deleteChannelPermissionOverride (channelId, overwriteId, reason) {
-            return await rest.delete(rest.routes.channels.overwrite(channelId, overwriteId), reason ? {
+            await rest.delete(rest.routes.channels.overwrite(channelId, overwriteId), {
                 reason
-            } : undefined);
+            });
         },
         async deleteEmoji (guildId, id, reason) {
-            return await rest.delete(rest.routes.guilds.emoji(guildId, id), {
+            await rest.delete(rest.routes.guilds.emoji(guildId, id), {
                 reason
             });
         },
         async deleteFollowupMessage (token, messageId) {
-            return await rest.delete(rest.routes.interactions.responses.message(rest.applicationId, token, messageId));
+            await rest.delete(rest.routes.interactions.responses.message(rest.applicationId, token, messageId));
         },
         async deleteGlobalApplicationCommand (commandId) {
-            return await rest.delete(rest.routes.interactions.commands.command(rest.applicationId, commandId));
+            await rest.delete(rest.routes.interactions.commands.command(rest.applicationId, commandId));
         },
         async deleteGuild (guildId) {
-            return await rest.delete(rest.routes.guilds.guild(guildId));
+            await rest.delete(rest.routes.guilds.guild(guildId));
         },
         async deleteGuildApplicationCommand (commandId, guildId) {
-            return await rest.delete(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));
+            await rest.delete(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));
         },
         async deleteGuildSticker (guildId, stickerId, reason) {
-            return await rest.delete(rest.routes.guilds.sticker(guildId, stickerId), reason ? {
+            await rest.delete(rest.routes.guilds.sticker(guildId, stickerId), {
                 reason
-            } : undefined);
+            });
         },
         async deleteGuildTemplate (guildId, templateCode) {
-            return await rest.delete(rest.routes.guilds.templates.guild(guildId, templateCode));
+            await rest.delete(rest.routes.guilds.templates.guild(guildId, templateCode));
         },
         async deleteIntegration (guildId, integrationId) {
-            return await rest.delete(rest.routes.guilds.integration(guildId, integrationId));
+            await rest.delete(rest.routes.guilds.integration(guildId, integrationId));
         },
         async deleteInvite (inviteCode, reason) {
-            return await rest.delete(rest.routes.guilds.invite(inviteCode), reason ? {
+            await rest.delete(rest.routes.guilds.invite(inviteCode), {
                 reason
-            } : undefined);
+            });
         },
         async deleteMessage (channelId, messageId, reason) {
-            return await rest.delete(rest.routes.channels.message(channelId, messageId), {
+            await rest.delete(rest.routes.channels.message(channelId, messageId), {
                 reason
             });
         },
         async deleteMessages (channelId, messageIds, reason) {
-            return await rest.post(rest.routes.channels.bulk(channelId), {
-                messages: messageIds.slice(0, 100).map((id)=>id.toString()),
+            await rest.post(rest.routes.channels.bulk(channelId), {
+                body: {
+                    messages: messageIds.slice(0, 100).map((id)=>id.toString())
+                },
                 reason
             });
         },
         async deleteOriginalInteractionResponse (token) {
-            return await rest.delete(rest.routes.interactions.responses.original(rest.applicationId, token));
+            await rest.delete(rest.routes.interactions.responses.original(rest.applicationId, token));
         },
         async deleteOwnReaction (channelId, messageId, reaction) {
             reaction = processReactionString(reaction);
-            return await rest.delete(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
+            await rest.delete(rest.routes.channels.reactions.bot(channelId, messageId, reaction));
         },
         async deleteReactionsAll (channelId, messageId) {
-            return await rest.delete(rest.routes.channels.reactions.all(channelId, messageId));
+            await rest.delete(rest.routes.channels.reactions.all(channelId, messageId));
         },
         async deleteReactionsEmoji (channelId, messageId, reaction) {
             reaction = processReactionString(reaction);
-            return await rest.delete(rest.routes.channels.reactions.emoji(channelId, messageId, reaction));
+            await rest.delete(rest.routes.channels.reactions.emoji(channelId, messageId, reaction));
         },
         async deleteRole (guildId, roleId) {
-            return await rest.delete(rest.routes.guilds.roles.one(guildId, roleId));
+            await rest.delete(rest.routes.guilds.roles.one(guildId, roleId));
         },
         async deleteScheduledEvent (guildId, eventId) {
-            return await rest.delete(rest.routes.guilds.events.event(guildId, eventId));
+            await rest.delete(rest.routes.guilds.events.event(guildId, eventId));
         },
         async deleteStageInstance (channelId, reason) {
-            return await rest.delete(rest.routes.channels.stage(channelId), reason ? {
+            await rest.delete(rest.routes.channels.stage(channelId), {
                 reason
-            } : undefined);
+            });
         },
         async deleteUserReaction (channelId, messageId, userId, reaction) {
             reaction = processReactionString(reaction);
-            return await rest.delete(rest.routes.channels.reactions.user(channelId, messageId, reaction, userId));
+            await rest.delete(rest.routes.channels.reactions.user(channelId, messageId, reaction, userId));
         },
         async deleteWebhook (webhookId, reason) {
-            return await rest.delete(rest.routes.webhooks.id(webhookId), {
+            await rest.delete(rest.routes.webhooks.id(webhookId), {
                 reason
             });
         },
         async deleteWebhookMessage (webhookId, token, messageId, options) {
-            return await rest.delete(rest.routes.webhooks.message(webhookId, token, messageId, options));
+            await rest.delete(rest.routes.webhooks.message(webhookId, token, messageId, options));
         },
         async deleteWebhookWithToken (webhookId, token) {
-            return await rest.delete(rest.routes.webhooks.webhook(webhookId, token));
+            await rest.delete(rest.routes.webhooks.webhook(webhookId, token));
         },
-        async editApplicationCommandPermissions (guildId, commandId, bearerToken, options) {
+        async editApplicationCommandPermissions (guildId, commandId, bearerToken, permissions) {
             return await rest.put(rest.routes.interactions.commands.permission(rest.applicationId, guildId, commandId), {
-                permissions: options
-            }, {
+                body: {
+                    permissions
+                },
                 headers: {
                     authorization: `Bearer ${bearerToken}`
                 }
             });
         },
-        async editAutomodRule (guildId, ruleId, options) {
-            return await rest.patch(rest.routes.guilds.automod.rule(guildId, ruleId), options);
+        async editAutomodRule (guildId, ruleId, body) {
+            return await rest.patch(rest.routes.guilds.automod.rule(guildId, ruleId), {
+                body
+            });
         },
         async editBotProfile (options) {
             const avatar = options?.botAvatarURL ? await urlToBase64(options?.botAvatarURL) : options?.botAvatarURL;
             return await rest.patch(rest.routes.userBot(), {
-                username: options.username?.trim(),
-                avatar
+                body: {
+                    username: options.username?.trim(),
+                    avatar
+                }
             });
         },
-        async editChannel (channelId, options) {
-            return await rest.patch(rest.routes.channels.channel(channelId), options);
+        async editChannel (channelId, body) {
+            return await rest.patch(rest.routes.channels.channel(channelId), {
+                body
+            });
         },
-        async editChannelPermissionOverrides (channelId, options) {
-            return await rest.put(rest.routes.channels.overwrite(channelId, options.id), options);
+        async editChannelPermissionOverrides (channelId, body) {
+            await rest.put(rest.routes.channels.overwrite(channelId, body.id), {
+                body
+            });
         },
-        async editChannelPositions (guildId, channelPositions) {
-            return await rest.patch(rest.routes.guilds.channels(guildId), channelPositions);
+        async editChannelPositions (guildId, body) {
+            await rest.patch(rest.routes.guilds.channels(guildId), {
+                body
+            });
         },
-        async editEmoji (guildId, id, options) {
-            return await rest.patch(rest.routes.guilds.emoji(guildId, id), options);
+        async editEmoji (guildId, id, body) {
+            return await rest.patch(rest.routes.guilds.emoji(guildId, id), {
+                body
+            });
         },
-        async editFollowupMessage (token, messageId, options) {
-            return await rest.patch(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), options);
+        async editFollowupMessage (token, messageId, body) {
+            return await rest.patch(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
+                body
+            });
         },
-        async editGlobalApplicationCommand (commandId, options) {
-            return await rest.patch(rest.routes.interactions.commands.command(rest.applicationId, commandId), options);
+        async editGlobalApplicationCommand (commandId, body) {
+            return await rest.patch(rest.routes.interactions.commands.command(rest.applicationId, commandId), {
+                body
+            });
         },
-        async editGuild (guildId, options) {
-            return await rest.patch(rest.routes.guilds.guild(guildId), options);
+        async editGuild (guildId, body) {
+            return await rest.patch(rest.routes.guilds.guild(guildId), {
+                body
+            });
         },
-        async editGuildApplicationCommand (commandId, guildId, options) {
-            return await rest.patch(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId), options);
+        async editGuildApplicationCommand (commandId, guildId, body) {
+            return await rest.patch(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId), {
+                body
+            });
         },
         async editGuildMfaLevel (guildId, mfaLevel, reason) {
-            return await rest.post(rest.routes.guilds.mfa(guildId), {
-                level: mfaLevel,
+            await rest.post(rest.routes.guilds.mfa(guildId), {
+                body: {
+                    level: mfaLevel
+                },
                 reason
             });
         },
-        async editGuildSticker (guildId, stickerId, options) {
-            return await rest.patch(rest.routes.guilds.sticker(guildId, stickerId), options);
+        async editGuildSticker (guildId, stickerId, body) {
+            return await rest.patch(rest.routes.guilds.sticker(guildId, stickerId), {
+                body
+            });
         },
-        async editGuildTemplate (guildId, templateCode, options) {
-            return await rest.patch(rest.routes.guilds.templates.guild(guildId, templateCode), options);
+        async editGuildTemplate (guildId, templateCode, body) {
+            return await rest.patch(rest.routes.guilds.templates.guild(guildId, templateCode), {
+                body
+            });
         },
-        async editMessage (channelId, messageId, options) {
-            return await rest.patch(rest.routes.channels.message(channelId, messageId), options);
+        async editMessage (channelId, messageId, body) {
+            return await rest.patch(rest.routes.channels.message(channelId, messageId), {
+                body
+            });
         },
-        async editOriginalInteractionResponse (token, options) {
-            return await rest.patch(rest.routes.interactions.responses.original(rest.applicationId, token), options);
+        async editOriginalInteractionResponse (token, body) {
+            return await rest.patch(rest.routes.interactions.responses.original(rest.applicationId, token), {
+                body
+            });
         },
         async editOriginalWebhookMessage (webhookId, token, options) {
             return await rest.patch(rest.routes.webhooks.original(webhookId, token, options), {
-                type: InteractionResponseTypes.UpdateMessage,
-                data: options
+                body: {
+                    type: InteractionResponseTypes.UpdateMessage,
+                    data: options
+                }
             });
         },
         async editOwnVoiceState (guildId, options) {
-            return await rest.patch(rest.routes.guilds.voice(guildId), {
-                channel_id: options.channelId,
-                suppress: options.suppress,
-                request_to_speak_timestamp: options.requestToSpeakTimestamp ? new Date(options.requestToSpeakTimestamp).toISOString() : options.requestToSpeakTimestamp
+            await rest.patch(rest.routes.guilds.voice(guildId), {
+                body: {
+                    ...options,
+                    request_to_speak_timestamp: options.requestToSpeakTimestamp ? new Date(options.requestToSpeakTimestamp).toISOString() : options.requestToSpeakTimestamp
+                }
             });
         },
-        async editScheduledEvent (guildId, eventId, options) {
-            return await rest.patch(rest.routes.guilds.events.event(guildId, eventId), options);
+        async editScheduledEvent (guildId, eventId, body) {
+            return await rest.patch(rest.routes.guilds.events.event(guildId, eventId), {
+                body
+            });
         },
-        async editRole (guildId, roleId, options) {
-            return await rest.patch(rest.routes.guilds.roles.one(guildId, roleId), options);
+        async editRole (guildId, roleId, body) {
+            return await rest.patch(rest.routes.guilds.roles.one(guildId, roleId), {
+                body
+            });
         },
-        async editRolePositions (guildId, options) {
-            return await rest.patch(rest.routes.guilds.roles.all(guildId), options);
+        async editRolePositions (guildId, body) {
+            return await rest.patch(rest.routes.guilds.roles.all(guildId), {
+                body
+            });
         },
-        async editStageInstance (channelId, data) {
+        async editStageInstance (channelId, topic, reason) {
             return await rest.patch(rest.routes.channels.stage(channelId), {
-                topic: data.topic
+                body: {
+                    topic
+                },
+                reason
             });
         },
         async editUserVoiceState (guildId, options) {
-            return await rest.patch(rest.routes.guilds.voice(guildId, options.userId), {
-                channel_id: options.channelId,
-                suppress: options.suppress,
-                user_id: options.userId
+            await rest.patch(rest.routes.guilds.voice(guildId, options.userId), {
+                body: options
             });
         },
-        async editWebhook (webhookId, options) {
-            return await rest.patch(rest.routes.webhooks.id(webhookId), options);
+        async editWebhook (webhookId, body) {
+            return await rest.patch(rest.routes.webhooks.id(webhookId), {
+                body
+            });
         },
         async editWebhookMessage (webhookId, token, messageId, options) {
-            return await rest.patch(rest.routes.webhooks.message(webhookId, token, messageId, options), options);
+            return await rest.patch(rest.routes.webhooks.message(webhookId, token, messageId, options), {
+                body: options
+            });
         },
-        async editWebhookWithToken (webhookId, token, options) {
-            return await rest.patch(rest.routes.webhooks.webhook(webhookId, token), options);
+        async editWebhookWithToken (webhookId, token, body) {
+            return await rest.patch(rest.routes.webhooks.webhook(webhookId, token), {
+                body
+            });
         },
-        async editWelcomeScreen (guildId, options) {
-            return await rest.patch(rest.routes.guilds.welcome(guildId), options);
+        async editWelcomeScreen (guildId, body) {
+            return await rest.patch(rest.routes.guilds.welcome(guildId), {
+                body
+            });
         },
-        async editWidgetSettings (guildId, options) {
-            return await rest.patch(rest.routes.guilds.widget(guildId), options);
+        async editWidgetSettings (guildId, body) {
+            return await rest.patch(rest.routes.guilds.widget(guildId), {
+                body
+            });
         },
         async executeWebhook (webhookId, token, options) {
-            return await rest.post(rest.routes.webhooks.webhook(webhookId, token, options), options);
+            return await rest.post(rest.routes.webhooks.webhook(webhookId, token, options), {
+                body: options
+            });
         },
         async followAnnouncement (sourceChannelId, targetChannelId) {
             return await rest.post(rest.routes.channels.follow(sourceChannelId), {
-                webhook_channel_id: targetChannelId
+                body: {
+                    webhook_channel_id: targetChannelId
+                }
             });
         },
         async getActiveThreads (guildId) {
@@ -1154,7 +1295,9 @@ export function createRestManager(options) {
         },
         async getDmChannel (userId) {
             return await rest.post(rest.routes.channels.dm(), {
-                recipient_id: userId.toString()
+                body: {
+                    recipient_id: userId
+                }
             });
         },
         async getEmoji (guildId, emojiId) {
@@ -1298,77 +1441,99 @@ export function createRestManager(options) {
             return await rest.get(rest.routes.guilds.widget(guildId));
         },
         async joinThread (channelId) {
-            return await rest.put(rest.routes.channels.threads.me(channelId));
+            await rest.put(rest.routes.channels.threads.me(channelId));
         },
         async leaveGuild (guildId) {
-            return await rest.delete(rest.routes.guilds.leave(guildId));
+            await rest.delete(rest.routes.guilds.leave(guildId));
         },
         async leaveThread (channelId) {
-            return await rest.delete(rest.routes.channels.threads.me(channelId));
+            await rest.delete(rest.routes.channels.threads.me(channelId));
         },
         async publishMessage (channelId, messageId) {
             return await rest.post(rest.routes.channels.crosspost(channelId, messageId));
         },
         async removeRole (guildId, userId, roleId, reason) {
-            return await rest.delete(rest.routes.guilds.roles.member(guildId, userId, roleId), {
+            await rest.delete(rest.routes.guilds.roles.member(guildId, userId, roleId), {
                 reason
             });
         },
         async removeThreadMember (channelId, userId) {
-            return await rest.delete(rest.routes.channels.threads.user(channelId, userId));
+            await rest.delete(rest.routes.channels.threads.user(channelId, userId));
         },
+        // TODO: why that
         async sendFollowupMessage (token, options) {
             return await new Promise((resolve, reject)=>{
                 rest.sendRequest({
                     url: rest.routes.webhooks.webhook(rest.applicationId, token),
                     method: 'POST',
-                    body: options,
+                    options: {
+                        body: options
+                    },
                     retryCount: 0,
                     retryRequest: async function(options) {
                         // TODO: should change to reprocess queue item
                         await rest.sendRequest(options);
                     },
-                    resolve: (data)=>resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined),
+                    resolve: (data)=>{
+                        resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined);
+                    },
                     reject
                 });
             });
         },
+        // TODO: why that
         async sendInteractionResponse (interactionId, token, options) {
-            return await new Promise((resolve, reject)=>{
+            await new Promise((resolve, reject)=>{
                 rest.sendRequest({
                     url: rest.routes.interactions.responses.callback(interactionId, token),
                     method: 'POST',
-                    body: options,
+                    options: {
+                        body: options
+                    },
                     retryCount: 0,
                     retryRequest: async function(options) {
                         // TODO: should change to reprocess queue item
                         await rest.sendRequest(options);
                     },
-                    resolve: (data)=>resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined),
+                    resolve: (data)=>{
+                        resolve(data.status !== 204 ? JSON.parse(data.body ?? '{}') : undefined);
+                    },
                     reject
                 });
             });
         },
-        async sendMessage (channelId, options) {
-            return await rest.post(rest.routes.channels.messages(channelId), options);
+        async sendMessage (channelId, body) {
+            return await rest.post(rest.routes.channels.messages(channelId), {
+                body
+            });
         },
-        async startThreadWithMessage (channelId, messageId, options) {
-            return await rest.post(rest.routes.channels.threads.message(channelId, messageId), options);
+        async startThreadWithMessage (channelId, messageId, body) {
+            return await rest.post(rest.routes.channels.threads.message(channelId, messageId), {
+                body
+            });
         },
-        async startThreadWithoutMessage (channelId, options) {
-            return await rest.post(rest.routes.channels.threads.all(channelId), options);
+        async startThreadWithoutMessage (channelId, body) {
+            return await rest.post(rest.routes.channels.threads.all(channelId), {
+                body
+            });
         },
         async syncGuildTemplate (guildId) {
             return await rest.put(rest.routes.guilds.templates.all(guildId));
         },
-        async banMember (guildId, userId, options) {
-            return await rest.put(rest.routes.guilds.members.ban(guildId, userId), options);
+        async banMember (guildId, userId, body) {
+            await rest.put(rest.routes.guilds.members.ban(guildId, userId), {
+                body
+            });
         },
-        async editBotMember (guildId, options) {
-            return await rest.patch(rest.routes.guilds.members.bot(guildId), options);
+        async editBotMember (guildId, body) {
+            return await rest.patch(rest.routes.guilds.members.bot(guildId), {
+                body
+            });
         },
-        async editMember (guildId, userId, options) {
-            return await rest.patch(rest.routes.guilds.members.member(guildId, userId), options);
+        async editMember (guildId, userId, body) {
+            return await rest.patch(rest.routes.guilds.members.member(guildId, userId), {
+                body
+            });
         },
         async getMember (guildId, userId) {
             return await rest.get(rest.routes.guilds.members.member(guildId, userId));
@@ -1377,37 +1542,43 @@ export function createRestManager(options) {
             return await rest.get(rest.routes.guilds.members.members(guildId, options));
         },
         async kickMember (guildId, userId, reason) {
-            return await rest.delete(rest.routes.guilds.members.member(guildId, userId), {
+            await rest.delete(rest.routes.guilds.members.member(guildId, userId), {
                 reason
             });
         },
         async pinMessage (channelId, messageId, reason) {
-            return await rest.put(rest.routes.channels.pin(channelId, messageId), reason ? {
+            await rest.put(rest.routes.channels.pin(channelId, messageId), {
                 reason
-            } : undefined);
+            });
         },
-        async pruneMembers (guildId, options) {
-            return await rest.post(rest.routes.guilds.members.prune(guildId), options);
+        async pruneMembers (guildId, body) {
+            return await rest.post(rest.routes.guilds.members.prune(guildId), {
+                body
+            });
         },
         async searchMembers (guildId, query, options) {
             return await rest.get(rest.routes.guilds.members.search(guildId, query, options));
         },
         async unbanMember (guildId, userId) {
-            return await rest.delete(rest.routes.guilds.members.ban(guildId, userId));
+            await rest.delete(rest.routes.guilds.members.ban(guildId, userId));
         },
         async unpinMessage (channelId, messageId, reason) {
-            return await rest.delete(rest.routes.channels.pin(channelId, messageId), reason ? {
+            await rest.delete(rest.routes.channels.pin(channelId, messageId), {
                 reason
-            } : undefined);
+            });
         },
         async triggerTypingIndicator (channelId) {
-            return await rest.post(rest.routes.channels.typing(channelId));
+            await rest.post(rest.routes.channels.typing(channelId));
         },
-        async upsertGlobalApplicationCommands (commands) {
-            return await rest.put(rest.routes.interactions.commands.commands(rest.applicationId), commands);
+        async upsertGlobalApplicationCommands (body) {
+            return await rest.put(rest.routes.interactions.commands.commands(rest.applicationId), {
+                body
+            });
         },
-        async upsertGuildApplicationCommands (guildId, commands) {
-            return await rest.put(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), commands);
+        async upsertGuildApplicationCommands (guildId, body) {
+            return await rest.put(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), {
+                body
+            });
         }
     };
     return rest;