@discordeno/rest 19.0.0-next.c9c510b → 19.0.0-next.cb4f097

package/dist/manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../src/manager.ts"],"names":[],"mappings":"AAkDA,OAAO,KAAK,EAA4B,wBAAwB,EAAE,WAAW,EAAsB,MAAM,YAAY,CAAA;AAKrH,eAAO,MAAM,mBAAmB,KAAK,CAAA;AACrC,eAAO,MAAM,eAAe,4BAA4B,CAAA;AAExD,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,2BAA2B,0BAA0B,CAAA;AAClE,eAAO,MAAM,6BAA6B,4BAA4B,CAAA;AACtE,eAAO,MAAM,wBAAwB,uBAAuB,CAAA;AAC5D,eAAO,MAAM,wBAAwB,uBAAuB,CAAA;AAC5D,eAAO,MAAM,uBAAuB,sBAAsB,CAAA;AAC1D,eAAO,MAAM,uBAAuB,sBAAsB,CAAA;AAE1D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,WAAW,CAuqChF"}
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../src/manager.ts"],"names":[],"mappings":"AAyDA,OAAO,KAAK,EAA4B,wBAAwB,EAAsB,WAAW,EAAsB,MAAM,YAAY,CAAA;AAKzI,eAAO,MAAM,mBAAmB,KAAK,CAAA;AACrC,eAAO,MAAM,eAAe,4BAA4B,CAAA;AAExD,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,2BAA2B,0BAA0B,CAAA;AAClE,eAAO,MAAM,6BAA6B,4BAA4B,CAAA;AACtE,eAAO,MAAM,wBAAwB,uBAAuB,CAAA;AAC5D,eAAO,MAAM,wBAAwB,uBAAuB,CAAA;AAC5D,eAAO,MAAM,uBAAuB,sBAAsB,CAAA;AAC1D,eAAO,MAAM,uBAAuB,sBAAsB,CAAA;AAE1D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,WAAW,CAk3ChF"}

package/dist/manager.js

@@ -1,4 +1,5 @@
-/* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable no-const-assign */ import { calculateBits, camelToSnakeCase, camelize, delay, getBotIdFromToken, logger, processReactionString, urlToBase64 } from '@discordeno/utils';
+/* eslint-disable @typescript-eslint/restrict-template-expressions */ /* eslint-disable no-const-assign */ import { Buffer } from 'node:buffer';
+import { calculateBits, camelToSnakeCase, camelize, delay, getBotIdFromToken, logger, processReactionString, urlToBase64 } from '@discordeno/utils';
 import { createInvalidRequestBucket } from './invalidBucket.js';
 import { Queue } from './queue.js';
 import { InteractionResponseTypes } from '@discordeno/types';
@@ -35,8 +36,14 @@ export function createRestManager(options) {
         token: options.token,
         version: options.version ?? DISCORD_API_VERSION,
         routes: createRoutes(),
-        checkRateLimits (url) {
-            const ratelimited = rest.rateLimitedPaths.get(url);
+        createBaseHeaders () {
+            return {
+                'user-agent': `DiscordBot (https://github.com/discordeno/discordeno, v${version})`
+            };
+        },
+        checkRateLimits (url, headers) {
+            const authHeader = headers?.authorization ?? '';
+            const ratelimited = rest.rateLimitedPaths.get(`${authHeader}${url}`);
             const global = rest.rateLimitedPaths.get('global');
             const now = Date.now();
             if (ratelimited && now < ratelimited.resetTimestamp) {
@@ -62,10 +69,10 @@ export function createRestManager(options) {
                             case 'permissions':
                             case 'allow':
                             case 'deny':
-                                newObj[key] = calculateBits(value);
+                                newObj[key] = typeof value === 'string' ? value : calculateBits(value);
                                 continue;
                             case 'defaultMemberPermissions':
-                                newObj.default_member_permissions = calculateBits(value);
+                                newObj.default_member_permissions = typeof value === 'string' ? value : calculateBits(value);
                                 continue;
                             case 'nameLocalizations':
                                 newObj.name_localizations = value;
@@ -83,10 +90,8 @@ export function createRestManager(options) {
             return obj;
         },
         createRequestBody (method, options) {
-            const headers = {
-                'user-agent': `DiscordBot (https://github.com/discordeno/discordeno, v${version})`
-            };
-            if (options?.unauthorized !== false) headers.authorization = `Bot ${rest.token}`;
+            const headers = this.createBaseHeaders();
+            if (options?.unauthorized !== true) headers.authorization = `Bot ${rest.token}`;
             // IF A REASON IS PROVIDED ENCODE IT IN HEADERS
             if (options?.reason !== undefined) {
                 headers[AUDIT_LOG_REASON_HEADER] = encodeURIComponent(options?.reason);
@@ -100,12 +105,21 @@ export function createRestManager(options) {
                 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({
+                // Have to use changeToDiscordFormat or else JSON.stringify may throw an error for the presence of BigInt(s) in the json
+                form.append('payload_json', JSON.stringify(rest.changeToDiscordFormat({
                     ...options.body,
                     files: undefined
-                }));
+                })));
+                // No need to set the `content-type` header since `fetch` does that automatically for us when we use a `FormData` object.
                 body = form;
-            // 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 && options.headers && options.headers['content-type'] === 'application/x-www-form-urlencoded') {
+                // OAuth2 body handling
+                const formBody = [];
+                const discordBody = rest.changeToDiscordFormat(options.body);
+                for(const prop in discordBody){
+                    formBody.push(`${encodeURIComponent(prop)}=${encodeURIComponent(discordBody[prop])}`);
+                }
+                body = formBody.join('&');
             } else if (options?.body !== undefined) {
                 if (options.body instanceof FormData) {
                     body = options.body;
@@ -152,7 +166,7 @@ export function createRestManager(options) {
                 }, 1000);
             }
         },
-        /** Processes the rate limit headers and determines if it needs to be rate limited and returns the bucket id if available */ processHeaders (url, headers) {
+        /** Processes the rate limit headers and determines if it needs to be rate limited and returns the bucket id if available */ processHeaders (url, headers, requestAuthorization) {
             let rateLimited = false;
             // GET ALL NECESSARY HEADERS
             const remaining = headers.get(RATE_LIMIT_REMAINING_HEADER);
@@ -162,7 +176,7 @@ export function createRestManager(options) {
             // undefined override null needed for typings
             const bucketId = headers.get(RATE_LIMIT_BUCKET_HEADER) ?? undefined;
             const limit = headers.get(RATE_LIMIT_LIMIT_HEADER);
-            rest.queues.get(url)?.handleCompletedRequest({
+            rest.queues.get(`${requestAuthorization}${url}`)?.handleCompletedRequest({
                 remaining: remaining ? Number(remaining) : undefined,
                 interval: retryAfter ? Number(retryAfter) * 1000 : undefined,
                 max: limit ? Number(limit) : undefined
@@ -171,14 +185,14 @@ export function createRestManager(options) {
             if (remaining === '0') {
                 rateLimited = true;
                 // SAVE THE URL AS LIMITED, IMPORTANT FOR NEW REQUESTS BY USER WITHOUT BUCKET
-                rest.rateLimitedPaths.set(url, {
+                rest.rateLimitedPaths.set(`${requestAuthorization}${url}`, {
                     url,
                     resetTimestamp: reset,
                     bucketId
                 });
                 // SAVE THE BUCKET AS LIMITED SINCE DIFFERENT URLS MAY SHARE A BUCKET
                 if (bucketId) {
-                    rest.rateLimitedPaths.set(bucketId, {
+                    rest.rateLimitedPaths.set(`${requestAuthorization}${bucketId}`, {
                         url,
                         resetTimestamp: reset,
                         bucketId
@@ -187,8 +201,8 @@ export function createRestManager(options) {
             }
             // IF THERE IS NO REMAINING GLOBAL LIMIT, MARK IT RATE LIMITED GLOBALLY
             if (global) {
-                const retryAfter = headers.get('retry-after');
-                const globalReset = Date.now() + Number(retryAfter) * 1000;
+                const retryAfter = Number(headers.get('retry-after')) * 1000;
+                const globalReset = Date.now() + retryAfter;
                 //   rest.debug(
                 // `[REST = Globally Rate Limited] URL: ${url} | Global Rest: ${globalReset}`
                 //   )
@@ -196,14 +210,14 @@ export function createRestManager(options) {
                 rateLimited = true;
                 setTimeout(()=>{
                     rest.globallyRateLimited = false;
-                }, globalReset);
+                }, retryAfter);
                 rest.rateLimitedPaths.set('global', {
                     url: 'global',
                     resetTimestamp: globalReset,
                     bucketId
                 });
                 if (bucketId) {
-                    rest.rateLimitedPaths.set(bucketId, {
+                    rest.rateLimitedPaths.set(`${requestAuthorization}${bucketId}`, {
                         url: 'global',
                         resetTimestamp: globalReset,
                         bucketId
@@ -218,12 +232,16 @@ export function createRestManager(options) {
         async sendRequest (options) {
             const url = `${rest.baseUrl}/v${rest.version}${options.route}`;
             const payload = rest.createRequestBody(options.method, options.requestBodyOptions);
+            const loggingHeaders = {
+                ...payload.headers
+            };
+            const authenticationScheme = payload.headers.authorization?.split(' ')[0];
+            if (payload.headers.authorization) {
+                loggingHeaders.authorization = `${authenticationScheme} tokenhere`;
+            }
             logger.debug(`sending request to ${url}`, 'with payload:', {
                 ...payload,
-                headers: {
-                    ...payload.headers,
-                    authorization: 'Bot tokenhere'
-                }
+                headers: loggingHeaders
             });
             const response = await fetch(url, payload).catch(async (error)=>{
                 logger.error(error);
@@ -240,7 +258,7 @@ export function createRestManager(options) {
             // Mark request and completed
             rest.invalidBucket.handleCompletedRequest(response.status, response.headers.get(RATE_LIMIT_SCOPE_HEADER) === 'shared');
             // Set the bucket id if it was available on the headers
-            const bucketId = rest.processHeaders(rest.simplifyUrl(options.route, options.method), response.headers);
+            const bucketId = rest.processHeaders(rest.simplifyUrl(options.route, options.method), response.headers, authenticationScheme === 'Bearer' ? payload.headers.authorization : '');
             if (bucketId) options.bucketId = bucketId;
             if (response.status < 200 || response.status >= 400) {
                 logger.debug(`Request to ${url} failed.`);
@@ -305,19 +323,21 @@ export function createRestManager(options) {
                 await rest.sendRequest(request);
                 return;
             }
-            const queue = rest.queues.get(url);
+            const authHeader = request.requestBodyOptions?.headers?.authorization ?? '';
+            const queue = rest.queues.get(`${authHeader}${url}`);
             if (queue !== undefined) {
                 queue.makeRequest(request);
             } else {
                 // CREATES A NEW QUEUE
                 const bucketQueue = new Queue(rest, {
                     url,
-                    deleteQueueDelay: rest.deleteQueueDelay
+                    deleteQueueDelay: rest.deleteQueueDelay,
+                    authentication: authHeader
                 });
                 // Add request to queue
                 bucketQueue.makeRequest(request);
                 // Save queue
-                rest.queues.set(url, bucketQueue);
+                rest.queues.set(`${authHeader}${url}`, bucketQueue);
             }
         },
         async makeRequest (method, route, options) {
@@ -393,6 +413,11 @@ export function createRestManager(options) {
         async addThreadMember (channelId, userId) {
             await rest.put(rest.routes.channels.threads.user(channelId, userId));
         },
+        async addDmRecipient (channelId, userId, body) {
+            await rest.put(rest.routes.channels.dmRecipient(channelId, userId), {
+                body
+            });
+        },
         async createAutomodRule (guildId, body, reason) {
             return await rest.post(rest.routes.guilds.automod.rules(guildId), {
                 body,
@@ -411,20 +436,34 @@ export function createRestManager(options) {
                 reason
             });
         },
-        async createGlobalApplicationCommand (body) {
-            return await rest.post(rest.routes.interactions.commands.commands(rest.applicationId), {
+        async createGlobalApplicationCommand (body, options) {
+            const restOptions = {
                 body
-            });
+            };
+            if (options?.bearerToken) {
+                restOptions.unauthorized = true;
+                restOptions.headers = {
+                    authorization: `Bearer ${options.bearerToken}`
+                };
+            }
+            return await rest.post(rest.routes.interactions.commands.commands(rest.applicationId), restOptions);
         },
         async createGuild (body) {
             return await rest.post(rest.routes.guilds.all(), {
                 body
             });
         },
-        async createGuildApplicationCommand (body, guildId) {
-            return await rest.post(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), {
+        async createGuildApplicationCommand (body, guildId, options) {
+            const restOptions = {
                 body
-            });
+            };
+            if (options?.bearerToken) {
+                restOptions.unauthorized = true;
+                restOptions.headers = {
+                    authorization: `Bearer ${options.bearerToken}`
+                };
+            }
+            return await rest.post(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions);
         },
         async createGuildFromTemplate (templateCode, body) {
             if (body.icon) {
@@ -617,7 +656,7 @@ export function createRestManager(options) {
         },
         async editBotProfile (options) {
             const avatar = options?.botAvatarURL ? await urlToBase64(options?.botAvatarURL) : options?.botAvatarURL;
-            return await rest.patch(rest.routes.userBot(), {
+            return await rest.patch(rest.routes.currentUser(), {
                 body: {
                     username: options.username?.trim(),
                     avatar
@@ -691,7 +730,8 @@ export function createRestManager(options) {
         },
         async editMessage (channelId, messageId, body) {
             return await rest.patch(rest.routes.channels.message(channelId, messageId), {
-                body
+                body,
+                files: body.files
             });
         },
         async editOriginalInteractionResponse (token, body) {
@@ -793,14 +833,60 @@ export function createRestManager(options) {
         async getActiveThreads (guildId) {
             return await rest.get(rest.routes.channels.threads.active(guildId));
         },
-        async getApplicationCommandPermission (guildId, commandId) {
-            return await rest.get(rest.routes.interactions.commands.permission(rest.applicationId, guildId, commandId));
-        },
-        async getApplicationCommandPermissions (guildId) {
-            return await rest.get(rest.routes.interactions.commands.permissions(rest.applicationId, guildId));
+        async getApplicationCommandPermission (guildId, commandId, options) {
+            const restOptions = {};
+            if (options?.accessToken) {
+                restOptions.unauthorized = true;
+                restOptions.headers = {
+                    authorization: `Bearer ${options.accessToken}`
+                };
+            }
+            return await rest.get(rest.routes.interactions.commands.permission(options?.applicationId ?? rest.applicationId, guildId, commandId), restOptions);
+        },
+        async getApplicationCommandPermissions (guildId, options) {
+            const restOptions = {};
+            if (options?.accessToken) {
+                restOptions.unauthorized = true;
+                restOptions.headers = {
+                    authorization: `Bearer ${options.accessToken}`
+                };
+            }
+            return await rest.get(rest.routes.interactions.commands.permissions(options?.applicationId ?? rest.applicationId, guildId), restOptions);
         },
         async getApplicationInfo () {
-            return await rest.get(rest.routes.oauth2Application());
+            return await rest.get(rest.routes.oauth2.application());
+        },
+        async getCurrentAuthenticationInfo (token) {
+            return await rest.get(rest.routes.oauth2.currentAuthorization(), {
+                headers: {
+                    authorization: `Bearer ${token}`
+                },
+                unauthorized: true
+            });
+        },
+        async exchangeToken (body) {
+            const restOptions = {
+                body,
+                headers: {
+                    'content-type': 'application/x-www-form-urlencoded'
+                },
+                unauthorized: true
+            };
+            if (body.grantType === 'client_credentials') {
+                const basicCredentials = Buffer.from(`${body.clientId}:${body.clientSecret}`);
+                restOptions.headers.authorization = `Basic ${basicCredentials.toString('base64')}`;
+                restOptions.body.scope = body.scope.join(' ');
+            }
+            return await rest.post(rest.routes.oauth2.tokenExchange(), restOptions);
+        },
+        async revokeToken (body) {
+            await rest.post(rest.routes.oauth2.tokenRevoke(), {
+                body,
+                headers: {
+                    'content-type': 'application/x-www-form-urlencoded'
+                },
+                unauthorized: true
+            });
         },
         async getAuditLog (guildId, options) {
             return await rest.get(rest.routes.guilds.auditlogs(guildId, options));
@@ -839,6 +925,11 @@ export function createRestManager(options) {
                 }
             });
         },
+        async getGroupDmChannel (body) {
+            return await rest.post(rest.routes.channels.dm(), {
+                body
+            });
+        },
         async getEmoji (guildId, emojiId) {
             return await rest.get(rest.routes.guilds.emoji(guildId, emojiId));
         },
@@ -864,6 +955,14 @@ export function createRestManager(options) {
         }) {
             return await rest.get(rest.routes.guilds.guild(guildId, options.counts));
         },
+        async getGuilds (token, options) {
+            return await rest.get(rest.routes.guilds.userGuilds(options), {
+                headers: {
+                    authorization: `Bearer ${token}`
+                },
+                unauthorized: true
+            });
+        },
         async getGuildApplicationCommand (commandId, guildId) {
             return await rest.get(rest.routes.interactions.commands.guilds.one(rest.applicationId, guildId, commandId));
         },
@@ -959,6 +1058,30 @@ export function createRestManager(options) {
         async getUser (id) {
             return await rest.get(rest.routes.user(id));
         },
+        async getCurrentUser (token) {
+            return await rest.get(rest.routes.currentUser(), {
+                headers: {
+                    authorization: `Bearer ${token}`
+                },
+                unauthorized: true
+            });
+        },
+        async getUserConnections (token) {
+            return await rest.get(rest.routes.oauth2.connections(), {
+                headers: {
+                    authorization: `Bearer ${token}`
+                },
+                unauthorized: true
+            });
+        },
+        async getUserApplicationRoleConnection (token, applicationId) {
+            return await rest.get(rest.routes.oauth2.roleConnections(applicationId), {
+                headers: {
+                    authorization: `Bearer ${token}`
+                },
+                unauthorized: true
+            });
+        },
         async getVanityUrl (guildId) {
             return await rest.get(rest.routes.guilds.vanity(guildId));
         },
@@ -1003,6 +1126,9 @@ export function createRestManager(options) {
         async removeThreadMember (channelId, userId) {
             await rest.delete(rest.routes.channels.threads.user(channelId, userId));
         },
+        async removeDmRecipient (channelId, userId) {
+            await rest.delete(rest.routes.channels.dmRecipient(channelId, userId));
+        },
         async sendFollowupMessage (token, options) {
             return await rest.post(rest.routes.webhooks.webhook(rest.applicationId, token), {
                 body: options,
@@ -1060,6 +1186,14 @@ export function createRestManager(options) {
         async getMember (guildId, userId) {
             return await rest.get(rest.routes.guilds.members.member(guildId, userId));
         },
+        async getCurrentMember (guildId, token) {
+            return await rest.get(rest.routes.guilds.members.currentMember(guildId), {
+                headers: {
+                    authorization: `Bearer ${token}`
+                },
+                unauthorized: true
+            });
+        },
         async getMembers (guildId, options) {
             return await rest.get(rest.routes.guilds.members.members(guildId, options));
         },
@@ -1095,13 +1229,41 @@ export function createRestManager(options) {
         async triggerTypingIndicator (channelId) {
             await rest.post(rest.routes.channels.typing(channelId));
         },
-        async upsertGlobalApplicationCommands (body) {
-            return await rest.put(rest.routes.interactions.commands.commands(rest.applicationId), {
+        async upsertGlobalApplicationCommands (body, options) {
+            const restOptions = {
                 body
+            };
+            if (options?.bearerToken) {
+                restOptions.unauthorized = true;
+                restOptions.headers = {
+                    authorization: `Bearer ${options.bearerToken}`
+                };
+            }
+            return await rest.put(rest.routes.interactions.commands.commands(rest.applicationId), restOptions);
+        },
+        async upsertGuildApplicationCommands (guildId, body, options) {
+            const restOptions = {
+                body
+            };
+            if (options?.bearerToken) {
+                restOptions.unauthorized = true;
+                restOptions.headers = {
+                    authorization: `Bearer ${options.bearerToken}`
+                };
+            }
+            return await rest.put(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), restOptions);
+        },
+        async editUserApplicationRoleConnection (token, applicationId, body) {
+            return await rest.put(rest.routes.oauth2.roleConnections(applicationId), {
+                body,
+                headers: {
+                    authorization: `Bearer ${token}`
+                },
+                unauthorized: true
             });
         },
-        async upsertGuildApplicationCommands (guildId, body) {
-            return await rest.put(rest.routes.interactions.commands.guilds.all(rest.applicationId, guildId), {
+        async addGuildMember (guildId, userId, body) {
+            return await rest.put(rest.routes.guilds.members.member(guildId, userId), {
                 body
             });
         },