oceanic.js 1.10.3-dev.c6c9f52 → 1.10.3-dev.ca8b6e8

package/dist/lib/rest/Bucket.d.ts

@@ -0,0 +1,33 @@
+/** @module Bucket */
+/**
+ * lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/util/Bucket.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+/// <reference types="node" />
+/** A bucket. */
+export default class Bucket {
+    private _queue;
+    interval: number;
+    lastReset: number;
+    lastSend: number;
+    latencyRef: {
+        latency: number;
+    };
+    reservedTokens: number;
+    timeout: NodeJS.Timeout | null;
+    tokenLimit: number;
+    tokens: number;
+    constructor(tokenLimit: number, interval: number, options?: {
+        latencyRef?: {
+            latency: number;
+        };
+        reservedTokens?: number;
+    });
+    private check;
+    /**
+     * Add an item to the queue.
+     * @param func The function to queue.
+     * @param priority If true, the item will be added to the front of the queue.
+     */
+    queue(func: () => void, priority?: boolean): void;
+}

package/dist/lib/rest/Bucket.js

@@ -0,0 +1,78 @@
+"use strict";
+/** @module Bucket */
+/**
+ * lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/util/Bucket.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/** A bucket. */
+class Bucket {
+    _queue = [];
+    interval;
+    lastReset;
+    lastSend;
+    latencyRef;
+    reservedTokens;
+    timeout;
+    tokenLimit;
+    tokens;
+    constructor(tokenLimit, interval, options) {
+        this.tokenLimit = tokenLimit;
+        this.interval = interval;
+        this.latencyRef = options?.latencyRef ?? { latency: 0 };
+        this.lastReset = this.tokens = this.lastSend = 0;
+        this.reservedTokens = options?.reservedTokens ?? 0;
+        this.timeout = null;
+    }
+    check() {
+        if (this.timeout || this._queue.length === 0) {
+            return;
+        }
+        if (this.lastReset + this.interval + this.tokenLimit * this.latencyRef.latency < Date.now()) {
+            this.lastReset = Date.now();
+            this.tokens = Math.max(0, this.tokens - this.tokenLimit);
+        }
+        let val;
+        let tokensAvailable = this.tokens < this.tokenLimit;
+        let unreservedTokensAvailable = this.tokens < (this.tokenLimit - this.reservedTokens);
+        while (this._queue.length !== 0 && (unreservedTokensAvailable || (tokensAvailable && this._queue[0].priority))) {
+            this.tokens++;
+            tokensAvailable = this.tokens < this.tokenLimit;
+            unreservedTokensAvailable = this.tokens < (this.tokenLimit - this.reservedTokens);
+            const item = this._queue.shift();
+            val = this.latencyRef.latency - Date.now() + this.lastSend;
+            if (this.latencyRef.latency === 0 || val <= 0) {
+                item.func();
+                this.lastSend = Date.now();
+            }
+            else {
+                setTimeout(() => {
+                    item.func();
+                }, val);
+                this.lastSend = Date.now() + val;
+            }
+        }
+        if (this._queue.length !== 0 && !this.timeout) {
+            this.timeout = setTimeout(() => {
+                this.timeout = null;
+                this.check();
+            }, this.tokens < this.tokenLimit ? this.latencyRef.latency : Math.max(0, this.lastReset + this.interval + this.tokenLimit * this.latencyRef.latency - Date.now()));
+        }
+    }
+    /**
+     * Add an item to the queue.
+     * @param func The function to queue.
+     * @param priority If true, the item will be added to the front of the queue.
+     */
+    queue(func, priority = false) {
+        if (priority) {
+            this._queue.unshift({ func, priority });
+        }
+        else {
+            this._queue.push({ func, priority });
+        }
+        this.check();
+    }
+}
+exports.default = Bucket;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/rest/DiscordHTTPError.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import type { RESTMethod } from "../Constants";
+import type { JSONDiscordHTTPError } from "../types/json";
+/** An HTTP error received from Discord. */
+export default class DiscordHTTPError extends Error {
+    method: RESTMethod;
+    name: string;
+    resBody: Record<string, unknown> | null;
+    response: Response;
+    constructor(res: Response, resBody: unknown, method: RESTMethod, stack?: string);
+    get headers(): Headers;
+    get path(): string;
+    get status(): number;
+    get statusText(): string;
+    toJSON(): JSONDiscordHTTPError;
+}

package/dist/lib/rest/DiscordHTTPError.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/** @module DiscordHTTPError */
+const DiscordRESTError_1 = tslib_1.__importDefault(require("./DiscordRESTError"));
+/** An HTTP error received from Discord. */
+class DiscordHTTPError extends Error {
+    method;
+    name = "DiscordHTTPError";
+    resBody;
+    response;
+    constructor(res, resBody, method, stack) {
+        // eslint-disable-next-line unicorn/custom-error-definition
+        super();
+        Object.defineProperties(this, {
+            method: {
+                value: method,
+                enumerable: false
+            },
+            response: {
+                value: res,
+                enumerable: false
+            },
+            resBody: {
+                value: resBody,
+                enumerable: false
+            }
+        });
+        let message = `${res.status} ${res.statusText} on ${this.method} ${this.path}`;
+        const errors = DiscordRESTError_1.default.flattenErrors(resBody);
+        if (errors.length !== 0) {
+            message += `\n  ${errors.join("\n  ")}`;
+        }
+        this.message = message;
+        if (stack) {
+            this.stack = this.name + ": " + this.message + "\n" + stack;
+        }
+        else {
+            Error.captureStackTrace(this, DiscordHTTPError);
+        }
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get path() {
+        return new URL(this.response.url).pathname;
+    }
+    get status() {
+        return this.response.status;
+    }
+    get statusText() {
+        return this.response.statusText;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            method: this.method,
+            name: this.name,
+            resBody: this.resBody,
+            stack: this.stack ?? ""
+        };
+    }
+}
+exports.default = DiscordHTTPError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/rest/DiscordRESTError.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+/** @module DiscordRESTError */
+import type { RESTMethod } from "../Constants";
+import type { JSONDiscordRESTError } from "../types/json";
+/** A REST error received from Discord. */
+export default class DiscordRESTError extends Error {
+    code: number;
+    method: RESTMethod;
+    name: string;
+    resBody: Record<string, unknown> | null;
+    response: Response;
+    constructor(res: Response, resBody: Record<string, unknown>, method: RESTMethod, stack?: string);
+    static flattenErrors(errors: Record<string, unknown>, keyPrefix?: string): Array<string>;
+    get headers(): Headers;
+    get path(): string;
+    get status(): number;
+    get statusText(): string;
+    toJSON(): JSONDiscordRESTError;
+}

package/dist/lib/rest/DiscordRESTError.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/** A REST error received from Discord. */
+class DiscordRESTError extends Error {
+    code;
+    method;
+    name = "DiscordRESTError";
+    resBody;
+    response;
+    constructor(res, resBody, method, stack) {
+        // eslint-disable-next-line unicorn/custom-error-definition
+        super();
+        this.code = Number(resBody.code);
+        Object.defineProperties(this, {
+            method: {
+                value: method,
+                enumerable: false
+            },
+            response: {
+                value: res,
+                enumerable: false
+            },
+            resBody: {
+                value: resBody,
+                enumerable: false
+            }
+        });
+        let message = "message" in resBody ? `${resBody.message} on ${this.method} ${this.path}` : `Unknown Error on ${this.method} ${this.path}`;
+        if ("errors" in resBody) {
+            message += `\n ${DiscordRESTError.flattenErrors(resBody.errors).join("\n ")}`;
+        }
+        else {
+            const errors = DiscordRESTError.flattenErrors(resBody);
+            if (errors.length !== 0) {
+                message += `\n ${errors.join("\n ")}`;
+            }
+        }
+        this.message = message;
+        if (stack) {
+            this.stack = `${this.name}: ${this.message}\n${stack}`;
+        }
+        else {
+            Error.captureStackTrace(this, DiscordRESTError);
+        }
+    }
+    static flattenErrors(errors, keyPrefix = "") {
+        let messages = [];
+        for (const fieldName in errors) {
+            if (!Object.hasOwn(errors, fieldName) || fieldName === "message" || fieldName === "code") {
+                continue;
+            }
+            if (typeof errors[fieldName] === "object" && errors[fieldName] !== null) {
+                if ("_errors" in errors[fieldName]) {
+                    messages = messages.concat(errors[fieldName]._errors.map((err) => `${`${keyPrefix}${fieldName}`}: ${err.message}`));
+                }
+                else if (Array.isArray(errors[fieldName])) {
+                    messages = messages.concat(errors[fieldName].map(str => `${`${keyPrefix}${fieldName}`}: ${typeof str === "object" && "message" in str ? str.message : str}`));
+                }
+                else {
+                    messages = messages.concat(DiscordRESTError.flattenErrors(errors[fieldName], `${keyPrefix}${fieldName}.`));
+                }
+            }
+        }
+        return messages;
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get path() {
+        return new URL(this.response.url).pathname;
+    }
+    get status() {
+        return this.response.status;
+    }
+    get statusText() {
+        return this.response.statusText;
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            method: this.method,
+            name: this.name,
+            resBody: this.resBody,
+            stack: this.stack ?? ""
+        };
+    }
+}
+exports.default = DiscordRESTError;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/rest/OAuthHelper.d.ts

@@ -0,0 +1,62 @@
+/** @module OAuthHelper */
+import type RESTManager from "./RESTManager";
+import OAuthApplication from "../structures/OAuthApplication";
+import type { AuthorizationInformation, Connection, OAuthURLOptions, RevokeTokenOptions } from "../types/oauth";
+import Member from "../structures/Member";
+import OAuthGuild from "../structures/OAuthGuild";
+import ExtendedUser from "../structures/ExtendedUser";
+import type { AddMemberOptions, RoleConnection, UpdateUserApplicationRoleConnectionOptions } from "../types";
+/** A helper to make using authenticated oauth requests without needing a new client instance. */
+export default class OAuthHelper {
+    private _manager;
+    private _token;
+    constructor(manager: RESTManager, token: string);
+    /**
+     * Construct an oauth authorization url.
+     * @param options The options to construct the url with.
+     */
+    static constructURL(options: OAuthURLOptions): string;
+    addGuildMember(guildID: string, userID: string, options?: Omit<AddMemberOptions, "accessToken">): Promise<Member | undefined>;
+    /**
+     * Get the current OAuth2 application's information.
+     */
+    getApplication(): Promise<OAuthApplication>;
+    /**
+     * Get information about the current authorization.
+     */
+    getCurrentAuthorizationInformation(): Promise<AuthorizationInformation>;
+    /**
+     * Get the connections of the currently authenticated user.
+     *
+     * Note: Requires the `connections` scope.
+     */
+    getCurrentConnections(): Promise<Array<Connection>>;
+    /**
+     * Get the guild member information about the currently authenticated user.
+     *
+     * Note: Requires the `guilds.members.read` scope.
+     * @param guild the ID of the guild
+     */
+    getCurrentGuildMember(guild: string): Promise<Member>;
+    /**
+     * Get the currently authenticated user's guilds. Note these are missing several properties gateway guilds have.
+     */
+    getCurrentGuilds(): Promise<Array<OAuthGuild>>;
+    /**
+     * Get the currently authenticated user's information.
+     *
+     * Note: This does not touch the client's cache in any way.
+     */
+    getCurrentUser(): Promise<ExtendedUser>;
+    /**
+     * Revoke the used access token.
+     * @param options The options for revoking the token.
+     */
+    revokeToken(options: Omit<RevokeTokenOptions, "token">): Promise<void>;
+    /**
+     * Update the authenticated user's role connection object for an application. This requires the `role_connections.write` scope.
+     * @param applicationID The ID of the application.
+     * @param data The metadata to update.
+     */
+    updateRoleConnection(applicationID: string, data: UpdateUserApplicationRoleConnectionOptions): Promise<RoleConnection>;
+}

package/dist/lib/rest/OAuthHelper.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const OAuthApplication_1 = tslib_1.__importDefault(require("../structures/OAuthApplication"));
+const Routes = tslib_1.__importStar(require("../util/Routes"));
+const PartialApplication_1 = tslib_1.__importDefault(require("../structures/PartialApplication"));
+const Integration_1 = tslib_1.__importDefault(require("../structures/Integration"));
+const Member_1 = tslib_1.__importDefault(require("../structures/Member"));
+const OAuthGuild_1 = tslib_1.__importDefault(require("../structures/OAuthGuild"));
+const ExtendedUser_1 = tslib_1.__importDefault(require("../structures/ExtendedUser"));
+const Constants_1 = require("../Constants");
+/** A helper to make using authenticated oauth requests without needing a new client instance. */
+class OAuthHelper {
+    _manager;
+    _token;
+    constructor(manager, token) {
+        this._token = token;
+        this._manager = manager;
+    }
+    /**
+     * Construct an oauth authorization url.
+     * @param options The options to construct the url with.
+     */
+    static constructURL(options) {
+        const params = [
+            `client_id=${options.clientID}`,
+            `response_type=${options.responseType ?? "code"}`,
+            `scope=${options.scopes.join("%20")}`
+        ];
+        if (options.redirectURI) {
+            params.push(`redirect_uri=${options.redirectURI}`);
+        }
+        if (options.disableGuildSelect !== undefined) {
+            params.push(`disable_guild_select=${String(options.disableGuildSelect)}`);
+        }
+        if (options.prompt) {
+            params.push(`prompt=${options.prompt}`);
+        }
+        if (options.permissions) {
+            params.push(`permissions=${options.permissions}`);
+        }
+        if (options.guildID) {
+            params.push(`guild_id=${options.guildID}`);
+        }
+        if (options.state) {
+            params.push(`state=${options.state}`);
+        }
+        return `${Constants_1.BASE_URL}${Routes.OAUTH_AUTHORIZE}?${params.join("&")}`;
+    }
+    async addGuildMember(guildID, userID, options) {
+        return this._manager.guilds.addMember(guildID, userID, { accessToken: this._token.split(" ").slice(1).join(" "), ...options });
+    }
+    /**
+     * Get the current OAuth2 application's information.
+     */
+    async getApplication() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_APPLICATION,
+            auth: this._token
+        }).then(data => new OAuthApplication_1.default(data, this._manager.client));
+    }
+    /**
+     * Get information about the current authorization.
+     */
+    async getCurrentAuthorizationInformation() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_INFO,
+            auth: this._token
+        }).then(data => ({
+            application: new PartialApplication_1.default(data.application, this._manager.client),
+            expires: new Date(data.expires),
+            scopes: data.scopes,
+            user: this._manager.client.users.update(data.user)
+        }));
+    }
+    /**
+     * Get the connections of the currently authenticated user.
+     *
+     * Note: Requires the `connections` scope.
+     */
+    async getCurrentConnections() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_CONNECTIONS,
+            auth: this._token
+        }).then(data => data.map(connection => ({
+            friendSync: connection.friend_sync,
+            id: connection.id,
+            integrations: connection.integrations?.map(integration => new Integration_1.default(integration, this._manager.client)),
+            name: connection.name,
+            revoked: connection.revoked,
+            showActivity: connection.show_activity,
+            twoWayLink: connection.two_way_link,
+            type: connection.type,
+            verified: connection.verified,
+            visibility: connection.visibility
+        })));
+    }
+    /**
+     * Get the guild member information about the currently authenticated user.
+     *
+     * Note: Requires the `guilds.members.read` scope.
+     * @param guild the ID of the guild
+     */
+    async getCurrentGuildMember(guild) {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_GUILD_MEMBER(guild),
+            auth: this._token
+        }).then(data => new Member_1.default(data, this._manager.client, guild));
+    }
+    /**
+     * Get the currently authenticated user's guilds. Note these are missing several properties gateway guilds have.
+     */
+    async getCurrentGuilds() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_GUILDS,
+            auth: this._token
+        }).then(data => data.map(d => new OAuthGuild_1.default(d, this._manager.client)));
+    }
+    /**
+     * Get the currently authenticated user's information.
+     *
+     * Note: This does not touch the client's cache in any way.
+     */
+    async getCurrentUser() {
+        return this._manager.request({
+            method: "GET",
+            path: Routes.OAUTH_CURRENT_USER,
+            auth: this._token
+        }).then(data => new ExtendedUser_1.default(data, this._manager.client));
+    }
+    /**
+     * Revoke the used access token.
+     * @param options The options for revoking the token.
+     */
+    async revokeToken(options) {
+        const form = new FormData();
+        form.append("client_id", options.clientID);
+        form.append("client_secret", options.clientSecret);
+        form.append("token", this._token);
+        await this._manager.authRequest({
+            method: "POST",
+            path: Routes.OAUTH_TOKEN_REVOKE,
+            form
+        });
+    }
+    /**
+     * Update the authenticated user's role connection object for an application. This requires the `role_connections.write` scope.
+     * @param applicationID The ID of the application.
+     * @param data The metadata to update.
+     */
+    async updateRoleConnection(applicationID, data) {
+        return this._manager.request({
+            method: "PUT",
+            path: Routes.OAUTH_ROLE_CONNECTION(applicationID),
+            json: {
+                metadata: data.metadata,
+                platform_name: data.platformName,
+                platform_username: data.platformUsername
+            },
+            auth: this._token
+        }).then(d => ({
+            metadata: Object.entries(d.metadata).map(([key, value]) => ({
+                [key]: {
+                    description: value.description,
+                    descriptionLocalizations: value.description_localizations,
+                    key: value.key,
+                    name: value.name,
+                    nameLocalizations: value.name_localizations,
+                    type: value.type
+                }
+            })).reduce((a, b) => ({ ...a, ...b })),
+            platformName: d.platform_name,
+            platformUsername: d.platform_username
+        }));
+    }
+}
+exports.default = OAuthHelper;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/rest/RESTManager.d.ts

@@ -0,0 +1,42 @@
+/** @module RESTManager */
+import RequestHandler from "./RequestHandler";
+import type Client from "../Client";
+import Channels from "../routes/Channels";
+import Guilds from "../routes/Guilds";
+import Users from "../routes/Users";
+import OAuth from "../routes/OAuth";
+import Webhooks from "../routes/Webhooks";
+import type { RESTOptions } from "../types/client";
+import type { RequestOptions } from "../types/request-handler";
+import Applications from "../routes/Applications";
+import Interactions from "../routes/Interactions";
+import type { GetBotGatewayResponse, GetGatewayResponse } from "../types/gateway";
+import Miscellaneous from "../routes/Miscellaneous";
+/** A manager for all rest actions. */
+export default class RESTManager {
+    private _client;
+    applications: Applications;
+    channels: Channels;
+    guilds: Guilds;
+    handler: RequestHandler;
+    interactions: Interactions;
+    misc: Miscellaneous;
+    oauth: OAuth;
+    users: Users;
+    webhooks: Webhooks;
+    constructor(client: Client, options?: RESTOptions);
+    get client(): Client;
+    get options(): RESTOptions;
+    /** Alias for {@link RequestHandler#authRequest | RequestHandler#authRequest} */
+    authRequest<T = unknown>(options: Omit<RequestOptions, "auth">): Promise<T>;
+    /**
+     * Get the gateway information related to your bot client.
+     */
+    getBotGateway(): Promise<GetBotGatewayResponse>;
+    /**
+     * Get the gateway information.
+     */
+    getGateway(): Promise<GetGatewayResponse>;
+    /** Alias for {@link RequestHandler#request | RequestHandler#request} */
+    request<T = unknown>(options: RequestOptions): Promise<T>;
+}