@discordeno/rest 19.0.0-next.65f60af → 19.0.0-next.66869ce

package/dist/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../src/manager.ts"],"names":[],"mappings":"AAmEA,OAAO,KAAK,EAA4B,wBAAwB,EAAE,WAAW,EAAsB,MAAM,YAAY,CAAA;AAKrH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,WAAW,CA2rDhF"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../src/manager.ts"],"names":[],"mappings":"AAiEA,OAAO,KAAK,EAA4B,wBAAwB,EAAE,WAAW,EAAsB,MAAM,YAAY,CAAA;AAKrH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,WAAW,CAwqDhF"}

package/dist/manager.js

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable no-const-assign */ import { InteractionResponseTypes } from '@discordeno/types';
-import { calculateBits, camelize, camelToSnakeCase, delay, encode, getBotIdFromToken, isGetMessagesAfter, isGetMessagesAround, isGetMessagesBefore, isGetMessagesLimit, logger, processReactionString, urlToBase64 } from '@discordeno/utils';
+import { calculateBits, camelize, camelToSnakeCase, delay, 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';
@@ -545,46 +545,47 @@ export function createRestManager(options) {
             if (typeof obj === 'bigint') return obj.toString();
             return obj;
         },
-        createRequest (options) {
+        createRequestBody (method, options) {
             const headers = {
                 'user-agent': `DiscordBot (https://github.com/discordeno/discordeno, v${version})`
             };
-            if (!options.unauthorized) headers.authorization = `Bot ${rest.token}`;
+            if (!options?.unauthorized) headers.authorization = `Bot ${rest.token}`;
             // IF A REASON IS PROVIDED ENCODE IT IN HEADERS
-            if (options.reason !== undefined) {
-                headers['x-audit-log-reason'] = encodeURIComponent(options.reason);
+            if (options?.reason !== undefined) {
+                headers['x-audit-log-reason'] = encodeURIComponent(options?.reason);
             }
             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) {
+            if (options?.files !== 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);
+                for(let i = 0; i < options.files.length; ++i){
+                    form.append(`file${i}`, options.files[i].blob, options.files[i].name);
                 }
-                form.append('payload_json', JSON.stringify(options.body));
+                form.append('payload_json', JSON.stringify({
+                    ...options.body,
+                    files: undefined
+                }));
                 body = form;
-                // TODO: boundary?
-                // `multipart/form-data; boundary=${form.getBoundary()}`
-                headers['content-type'] = `multipart/form-data`;
-            } else if (options.body !== undefined) {
+            // No need to set the `content-type` header since `fetch` does that automatically for us when we use a `FormData` object.
+            } else if (options?.body !== undefined) {
                 if (options.body instanceof FormData) {
                     body = options.body;
-                    headers['content-type'] = `multipart/form-data`;
+                // No need to set the `content-type` header since `fetch` does that automatically for us when we use a `FormData` object.
                 } else {
-                    body = JSON.stringify(options.body);
+                    body = JSON.stringify(rest.changeToDiscordFormat(options.body));
                     headers['content-type'] = `application/json`;
                 }
             }
             // SOMETIMES SPECIAL HEADERS (E.G. CUSTOM AUTHORIZATION) NEED TO BE USED
-            if (options.headers) {
+            if (options?.headers) {
                 Object.assign(headers, options.headers);
             }
             return {
                 body,
                 headers,
-                method: options.method
+                method
             };
         },
         processRateLimitedPaths () {
@@ -679,12 +680,7 @@ export function createRestManager(options) {
         },
         async sendRequest (options) {
             const url = options.url.startsWith('https://') ? options.url : `${rest.baseUrl}/v${rest.version}${options.url}`;
-            const payload = rest.createRequest({
-                method: options.method,
-                url: options.url,
-                body: options.options?.body,
-                ...options.options
-            });
+            const payload = rest.createRequestBody(options.method, options.requestBodyOptions);
             logger.debug(`sending request to ${url}`, 'with payload:', {
                 ...payload,
                 headers: {
@@ -785,34 +781,7 @@ export function createRestManager(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
-                });
+                const result = await fetch(`${rest.baseUrl}${url}`, rest.createRequestBody(method, options));
                 if (!result.ok) {
                     const err = await result.json().catch(()=>{});
                     // Legacy Handling to not break old code or when body is missing
@@ -825,7 +794,7 @@ export function createRestManager(options) {
                 const payload = {
                     url,
                     method,
-                    options,
+                    requestBodyOptions: options,
                     retryCount: 0,
                     retryRequest: async function(payload) {
                         rest.processRequest(payload);
@@ -838,30 +807,20 @@ export function createRestManager(options) {
                 rest.processRequest(payload);
             });
         },
-        async get (url, body) {
-            return camelize(await rest.makeRequest('GET', url, {
-                body
-            }));
+        async get (url, options) {
+            return camelize(await rest.makeRequest('GET', url, options));
         },
-        async post (url, body) {
-            return camelize(await rest.makeRequest('POST', url, {
-                body
-            }));
+        async post (url, options) {
+            return camelize(await rest.makeRequest('POST', url, options));
         },
-        async delete (url, body) {
-            camelize(await rest.makeRequest('DELETE', url, {
-                body
-            }));
+        async delete (url, options) {
+            camelize(await rest.makeRequest('DELETE', url, options));
         },
-        async patch (url, body) {
-            return camelize(await rest.makeRequest('PATCH', url, {
-                body
-            }));
+        async patch (url, options) {
+            return camelize(await rest.makeRequest('PATCH', url, options));
         },
-        async put (url, body) {
-            return camelize(await rest.makeRequest('PUT', url, {
-                body
-            }));
+        async put (url, options) {
+            return camelize(await rest.makeRequest('PUT', url, options));
         },
         async addReaction (channelId, messageId, reaction) {
             reaction = processReactionString(reaction);
@@ -886,19 +845,22 @@ export function createRestManager(options) {
         async addThreadMember (channelId, userId) {
             await rest.put(rest.routes.channels.threads.user(channelId, userId));
         },
-        async createAutomodRule (guildId, body) {
+        async createAutomodRule (guildId, body, reason) {
             return await rest.post(rest.routes.guilds.automod.rules(guildId), {
-                body
+                body,
+                reason
             });
         },
-        async createChannel (guildId, body) {
+        async createChannel (guildId, body, reason) {
             return await rest.post(rest.routes.guilds.channels(guildId), {
-                body
+                body,
+                reason
             });
         },
-        async createEmoji (guildId, body) {
+        async createEmoji (guildId, body, reason) {
             return await rest.post(rest.routes.guilds.emojis(guildId), {
-                body
+                body,
+                reason
             });
         },
         async createGlobalApplicationCommand (body) {
@@ -924,14 +886,15 @@ export function createRestManager(options) {
                 body
             });
         },
-        async createGuildSticker (guildId, options) {
+        async createGuildSticker (guildId, options, reason) {
             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
+                body: form,
+                reason
             });
         },
         async createGuildTemplate (guildId, body) {
@@ -939,14 +902,17 @@ export function createRestManager(options) {
                 body
             });
         },
-        async createForumThread (channelId, body) {
+        async createForumThread (channelId, body, reason) {
             return await rest.post(rest.routes.channels.forum(channelId), {
-                body
+                body,
+                files: body.files,
+                reason
             });
         },
-        async createInvite (channelId, body = {}) {
+        async createInvite (channelId, body = {}, reason) {
             return await rest.post(rest.routes.channels.invites(channelId), {
-                body
+                body,
+                reason
             });
         },
         async createRole (guildId, body, reason) {
@@ -955,14 +921,16 @@ export function createRestManager(options) {
                 reason
             });
         },
-        async createScheduledEvent (guildId, body) {
+        async createScheduledEvent (guildId, body, reason) {
             return await rest.post(rest.routes.guilds.events.events(guildId), {
-                body
+                body,
+                reason
             });
         },
-        async createStageInstance (body) {
+        async createStageInstance (body, reason) {
             return await rest.post(rest.routes.channels.stages(), {
-                body
+                body,
+                reason
             });
         },
         async createWebhook (channelId, options, reason) {
@@ -1014,8 +982,10 @@ export function createRestManager(options) {
         async deleteGuildTemplate (guildId, templateCode) {
             await rest.delete(rest.routes.guilds.templates.guild(guildId, templateCode));
         },
-        async deleteIntegration (guildId, integrationId) {
-            await rest.delete(rest.routes.guilds.integration(guildId, integrationId));
+        async deleteIntegration (guildId, integrationId, reason) {
+            await rest.delete(rest.routes.guilds.integration(guildId, integrationId), {
+                reason
+            });
         },
         async deleteInvite (inviteCode, reason) {
             await rest.delete(rest.routes.guilds.invite(inviteCode), {
@@ -1049,8 +1019,10 @@ export function createRestManager(options) {
             reaction = processReactionString(reaction);
             await rest.delete(rest.routes.channels.reactions.emoji(channelId, messageId, reaction));
         },
-        async deleteRole (guildId, roleId) {
-            await rest.delete(rest.routes.guilds.roles.one(guildId, roleId));
+        async deleteRole (guildId, roleId, reason) {
+            await rest.delete(rest.routes.guilds.roles.one(guildId, roleId), {
+                reason
+            });
         },
         async deleteScheduledEvent (guildId, eventId) {
             await rest.delete(rest.routes.guilds.events.event(guildId, eventId));
@@ -1085,9 +1057,10 @@ export function createRestManager(options) {
                 }
             });
         },
-        async editAutomodRule (guildId, ruleId, body) {
+        async editAutomodRule (guildId, ruleId, body, reason) {
             return await rest.patch(rest.routes.guilds.automod.rule(guildId, ruleId), {
-                body
+                body,
+                reason
             });
         },
         async editBotProfile (options) {
@@ -1099,14 +1072,16 @@ export function createRestManager(options) {
                 }
             });
         },
-        async editChannel (channelId, body) {
+        async editChannel (channelId, body, reason) {
             return await rest.patch(rest.routes.channels.channel(channelId), {
-                body
+                body,
+                reason
             });
         },
-        async editChannelPermissionOverrides (channelId, body) {
+        async editChannelPermissionOverrides (channelId, body, reason) {
             await rest.put(rest.routes.channels.overwrite(channelId, body.id), {
-                body
+                body,
+                reason
             });
         },
         async editChannelPositions (guildId, body) {
@@ -1114,14 +1089,16 @@ export function createRestManager(options) {
                 body
             });
         },
-        async editEmoji (guildId, id, body) {
+        async editEmoji (guildId, id, body, reason) {
             return await rest.patch(rest.routes.guilds.emoji(guildId, id), {
-                body
+                body,
+                reason
             });
         },
         async editFollowupMessage (token, messageId, body) {
             return await rest.patch(rest.routes.interactions.responses.message(rest.applicationId, token, messageId), {
-                body
+                body,
+                files: body.files
             });
         },
         async editGlobalApplicationCommand (commandId, body) {
@@ -1129,9 +1106,10 @@ export function createRestManager(options) {
                 body
             });
         },
-        async editGuild (guildId, body) {
+        async editGuild (guildId, body, reason) {
             return await rest.patch(rest.routes.guilds.guild(guildId), {
-                body
+                body,
+                reason
             });
         },
         async editGuildApplicationCommand (commandId, guildId, body) {
@@ -1147,9 +1125,10 @@ export function createRestManager(options) {
                 reason
             });
         },
-        async editGuildSticker (guildId, stickerId, body) {
+        async editGuildSticker (guildId, stickerId, body, reason) {
             return await rest.patch(rest.routes.guilds.sticker(guildId, stickerId), {
-                body
+                body,
+                reason
             });
         },
         async editGuildTemplate (guildId, templateCode, body) {
@@ -1164,7 +1143,8 @@ export function createRestManager(options) {
         },
         async editOriginalInteractionResponse (token, body) {
             return await rest.patch(rest.routes.interactions.responses.original(rest.applicationId, token), {
-                body
+                body,
+                files: body.files
             });
         },
         async editOriginalWebhookMessage (webhookId, token, options) {
@@ -1172,7 +1152,8 @@ export function createRestManager(options) {
                 body: {
                     type: InteractionResponseTypes.UpdateMessage,
                     data: options
-                }
+                },
+                files: options.files
             });
         },
         async editOwnVoiceState (guildId, options) {
@@ -1183,19 +1164,22 @@ export function createRestManager(options) {
                 }
             });
         },
-        async editScheduledEvent (guildId, eventId, body) {
+        async editScheduledEvent (guildId, eventId, body, reason) {
             return await rest.patch(rest.routes.guilds.events.event(guildId, eventId), {
-                body
+                body,
+                reason
             });
         },
-        async editRole (guildId, roleId, body) {
+        async editRole (guildId, roleId, body, reason) {
             return await rest.patch(rest.routes.guilds.roles.one(guildId, roleId), {
-                body
+                body,
+                reason
             });
         },
-        async editRolePositions (guildId, body) {
+        async editRolePositions (guildId, body, reason) {
             return await rest.patch(rest.routes.guilds.roles.all(guildId), {
-                body
+                body,
+                reason
             });
         },
         async editStageInstance (channelId, topic, reason) {
@@ -1211,14 +1195,16 @@ export function createRestManager(options) {
                 body: options
             });
         },
-        async editWebhook (webhookId, body) {
+        async editWebhook (webhookId, body, reason) {
             return await rest.patch(rest.routes.webhooks.id(webhookId), {
-                body
+                body,
+                reason
             });
         },
         async editWebhookMessage (webhookId, token, messageId, options) {
             return await rest.patch(rest.routes.webhooks.message(webhookId, token, messageId, options), {
-                body: options
+                body: options,
+                files: options.files
             });
         },
         async editWebhookWithToken (webhookId, token, body) {
@@ -1226,14 +1212,16 @@ export function createRestManager(options) {
                 body
             });
         },
-        async editWelcomeScreen (guildId, body) {
+        async editWelcomeScreen (guildId, body, reason) {
             return await rest.patch(rest.routes.guilds.welcome(guildId), {
-                body
+                body,
+                reason
             });
         },
-        async editWidgetSettings (guildId, body) {
+        async editWidgetSettings (guildId, body, reason) {
             return await rest.patch(rest.routes.guilds.widget(guildId), {
-                body
+                body,
+                reason
             });
         },
         async executeWebhook (webhookId, token, options) {
@@ -1463,8 +1451,9 @@ export function createRestManager(options) {
                 rest.sendRequest({
                     url: rest.routes.webhooks.webhook(rest.applicationId, token),
                     method: 'POST',
-                    options: {
-                        body: options
+                    requestBodyOptions: {
+                        body: options,
+                        files: options.files
                     },
                     retryCount: 0,
                     retryRequest: async function(options) {
@@ -1484,7 +1473,7 @@ export function createRestManager(options) {
                 rest.sendRequest({
                     url: rest.routes.interactions.responses.callback(interactionId, token),
                     method: 'POST',
-                    options: {
+                    requestBodyOptions: {
                         body: options
                     },
                     retryCount: 0,
@@ -1501,35 +1490,41 @@ export function createRestManager(options) {
         },
         async sendMessage (channelId, body) {
             return await rest.post(rest.routes.channels.messages(channelId), {
-                body
+                body,
+                files: body.files
             });
         },
-        async startThreadWithMessage (channelId, messageId, body) {
+        async startThreadWithMessage (channelId, messageId, body, reason) {
             return await rest.post(rest.routes.channels.threads.message(channelId, messageId), {
-                body
+                body,
+                reason
             });
         },
-        async startThreadWithoutMessage (channelId, body) {
+        async startThreadWithoutMessage (channelId, body, reason) {
             return await rest.post(rest.routes.channels.threads.all(channelId), {
-                body
+                body,
+                reason
             });
         },
         async syncGuildTemplate (guildId) {
             return await rest.put(rest.routes.guilds.templates.all(guildId));
         },
-        async banMember (guildId, userId, body) {
+        async banMember (guildId, userId, body, reason) {
             await rest.put(rest.routes.guilds.members.ban(guildId, userId), {
-                body
+                body,
+                reason
             });
         },
-        async editBotMember (guildId, body) {
+        async editBotMember (guildId, body, reason) {
             return await rest.patch(rest.routes.guilds.members.bot(guildId), {
-                body
+                body,
+                reason
             });
         },
-        async editMember (guildId, userId, body) {
+        async editMember (guildId, userId, body, reason) {
             return await rest.patch(rest.routes.guilds.members.member(guildId, userId), {
-                body
+                body,
+                reason
             });
         },
         async getMember (guildId, userId) {
@@ -1548,16 +1543,19 @@ export function createRestManager(options) {
                 reason
             });
         },
-        async pruneMembers (guildId, body) {
+        async pruneMembers (guildId, body, reason) {
             return await rest.post(rest.routes.guilds.members.prune(guildId), {
-                body
+                body,
+                reason
             });
         },
         async searchMembers (guildId, query, options) {
             return await rest.get(rest.routes.guilds.members.search(guildId, query, options));
         },
-        async unbanMember (guildId, userId) {
-            await rest.delete(rest.routes.guilds.members.ban(guildId, userId));
+        async unbanMember (guildId, userId, reason) {
+            await rest.delete(rest.routes.guilds.members.ban(guildId, userId), {
+                reason
+            });
         },
         async unpinMessage (channelId, messageId, reason) {
             await rest.delete(rest.routes.channels.pin(channelId, messageId), {