snowtransfer 0.3.0

package/dist/RequestHandler.js

@@ -0,0 +1,238 @@
+"use strict";
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable no-async-promise-executor */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const events_1 = require("events");
+const crypto_1 = __importDefault(require("crypto"));
+const centra_1 = __importDefault(require("centra"));
+const Endpoints_1 = __importDefault(require("./Endpoints"));
+const form_data_1 = __importDefault(require("form-data"));
+const { version } = require("../package.json");
+const Constants_1 = __importDefault(require("./Constants"));
+class DiscordAPIError extends Error {
+    constructor(path, error, method, status) {
+        super();
+        const flattened = DiscordAPIError.flattenErrors(error.errors || error).join("\n");
+        this.name = "DiscordAPIError";
+        this.message = error.message && flattened ? `${error.message}\n${flattened}` : error.message || flattened;
+        this.method = method;
+        this.path = path;
+        this.code = error.code;
+        this.httpStatus = status;
+    }
+    static flattenErrors(obj, key = "") {
+        let messages = [];
+        for (const [k, v] of Object.entries(obj)) {
+            if (k === "message")
+                continue;
+            const newKey = key ? (isNaN(Number(k)) ? `${key}.${k}` : `${key}[${k}]`) : k;
+            if (v._errors) {
+                messages.push(`${newKey}: ${v._errors.map(e => e.message).join(" ")}`);
+            }
+            else if (v.code || v.message) {
+                messages.push(`${v.code ? `${v.code}: ` : ""}${v.message}`.trim());
+            }
+            else if (typeof v === "string") {
+                messages.push(v);
+            }
+            else {
+                messages = messages.concat(this.flattenErrors(v, newKey));
+            }
+        }
+        return messages;
+    }
+}
+/**
+ * Request Handler class
+ */
+class RequestHandler extends events_1.EventEmitter {
+    /**
+     * Create a new request handler
+     * @param ratelimiter ratelimiter to use for ratelimiting requests
+     * @param options options
+     */
+    constructor(ratelimiter, options) {
+        super();
+        this.ratelimiter = ratelimiter;
+        this.options = {
+            baseHost: Endpoints_1.default.BASE_HOST,
+            baseURL: Endpoints_1.default.BASE_URL,
+            headers: {
+                Authorization: options.token,
+                "User-Agent": `DiscordBot (https://github.com/DasWolke/SnowTransfer, ${version})`
+            }
+        };
+        Object.assign(this.options, options);
+        this.apiURL = this.options.baseHost + Endpoints_1.default.BASE_URL;
+        this.latency = 500;
+    }
+    /**
+     * Request a route from the discord api
+     * @param endpoint endpoint to request
+     * @param method http method to use
+     * @param dataType type of the data being sent
+     * @param data data to send, if any
+     * @param amount amount of requests previously executed
+     * @returns Result of the request
+     */
+    request(endpoint, method, dataType = "json", data = {}, amount = 0) {
+        if (typeof data === "number")
+            data = String(data);
+        const stack = new Error().stack;
+        return new Promise(async (res, rej) => {
+            this.ratelimiter.queue(async (bkt) => {
+                const reqID = crypto_1.default.randomBytes(20).toString("hex");
+                const latency = Date.now();
+                try {
+                    this.emit("request", reqID, { endpoint, method, dataType, data });
+                    let request;
+                    if (dataType == "json") {
+                        request = await this._request(endpoint, method, data, (method === "get" || endpoint.includes("/bans") || endpoint.includes("/prune")), amount);
+                    }
+                    else if (dataType == "multipart") {
+                        request = await this._multiPartRequest(endpoint, method, data, amount);
+                    }
+                    else {
+                        const e = new Error("Forbidden dataType. Use json or multipart");
+                        e.stack = stack;
+                        throw e;
+                    }
+                    // 429 and 502 are recoverable and will be re-tried automatically with 3 attempts max.
+                    if (request.statusCode && !Constants_1.default.OK_STATUS_CODES.includes(request.statusCode) && ![429, 502].includes(request.statusCode)) {
+                        const e = new DiscordAPIError(endpoint, request.headers["content-type"] === "application/json" ? await request.json() : request.body, method, request.statusCode);
+                        e.stack = stack;
+                        throw e;
+                    }
+                    if (request.headers["date"]) {
+                        this.latency = Date.now() - latency;
+                        const offsetDate = this._getOffsetDateFromHeader(request.headers["date"]);
+                        const match = endpoint.match(/\/reactions\//);
+                        this._applyRatelimitHeaders(bkt, request.headers, offsetDate, !!match);
+                    }
+                    if (request.statusCode && [429, 502].includes(request.statusCode)) {
+                        if (request.statusCode === 429)
+                            this.emit("rateLimit", { timeout: bkt.reset, limit: bkt.limit, method: method, path: endpoint, route: this.ratelimiter.routify(endpoint, method) });
+                        return this.request(endpoint, method, dataType, data, amount++);
+                    }
+                    this.emit("done", reqID, request);
+                    if (request.body) {
+                        let b;
+                        try {
+                            b = JSON.parse(request.body.toString());
+                        }
+                        catch {
+                            res(undefined);
+                        }
+                        return res(b);
+                    }
+                    else {
+                        return res(undefined);
+                    }
+                }
+                catch (error) {
+                    if (error && error.stack)
+                        error.stack = stack;
+                    this.emit("requestError", reqID, error);
+                    return rej(error);
+                }
+            }, endpoint, method);
+        });
+    }
+    /**
+     * Calculate the time difference between the local server and discord
+     * @param dateHeader Date header value returned by discord
+     * @returns Offset in milliseconds
+     */
+    _getOffsetDateFromHeader(dateHeader) {
+        const discordDate = Date.parse(dateHeader);
+        const offset = Date.now() - discordDate;
+        return Date.now() + offset;
+    }
+    /**
+     * Apply the received ratelimit headers to the ratelimit bucket
+     * @param bkt Ratelimit bucket to apply the headers to
+     * @param headers Http headers received from discord
+     * @param offsetDate Unix timestamp of the current date + offset to discord time
+     * @param reactions Whether to use reaction ratelimits (1/250ms)
+     */
+    _applyRatelimitHeaders(bkt, headers, offsetDate, reactions = false) {
+        if (headers["x-ratelimit-global"]) {
+            bkt.ratelimiter.global = true;
+            bkt.ratelimiter.globalResetAt = Date.now() + (parseFloat(headers["retry_after"]) * 1000);
+        }
+        if (headers["x-ratelimit-reset"]) {
+            const reset = (headers["x-ratelimit-reset"] * 1000) - offsetDate;
+            if (reactions) {
+                bkt.reset = Math.max(reset, 250);
+            }
+            else {
+                bkt.reset = reset;
+            }
+        }
+        if (headers["x-ratelimit-remaining"]) {
+            bkt.remaining = parseInt(headers["x-ratelimit-remaining"]);
+            if (bkt.remaining === 0)
+                bkt.resetAt = Date.now() + bkt.reset;
+        }
+        else {
+            bkt.remaining = 1;
+        }
+        if (headers["x-ratelimit-limit"]) {
+            bkt.limit = parseInt(headers["x-ratelimit-limit"]);
+        }
+    }
+    /**
+     * Execute a normal json request
+     * @param endpoint Endpoint to use
+     * @param data Data to send
+     * @param useParams Whether to send the data in the body or use query params
+     * @param amount amount of requests previously executed
+     * @returns Result of the request
+     */
+    async _request(endpoint, method, data, useParams = false, amount = 0) {
+        if (amount >= 3)
+            throw new Error("Max amount of rety attempts reached");
+        const headers = {};
+        if (typeof data != "string" && data.reason) {
+            headers["X-Audit-Log-Reason"] = encodeURIComponent(data.reason);
+            delete data.reason;
+        }
+        const req = (0, centra_1.default)(this.apiURL, method).path(endpoint).header(this.options.headers);
+        if (useParams) {
+            return req.query(data).send();
+        }
+        else {
+            if (data && typeof data === "object")
+                req.body(data, "json");
+            else if (data)
+                req.body(data);
+            return req.send();
+        }
+    }
+    /**
+     * Execute a multipart/form-data request
+     * @param endpoint Endpoint to use
+     * @param method Http Method to use
+     * @param data data to send
+     * @returns Result of the request
+     */
+    async _multiPartRequest(endpoint, method, data, amount = 0) {
+        if (amount >= 3)
+            throw new Error("Max amount of rety attempts reached");
+        const form = new form_data_1.default();
+        if (data.files && Array.isArray(data.files) && data.files.every(f => !!f.name && !!f.file)) {
+            for (const file of data.files) {
+                form.append(file.name, file.file, file.name);
+                delete file.file;
+            }
+        }
+        form.append("payload_json", JSON.stringify(data));
+        // duplicate headers in options as to not risk mutating the state.
+        const newHeaders = Object.assign({}, this.options.headers, form.getHeaders());
+        return (0, centra_1.default)(this.apiURL, method).path(endpoint).header(newHeaders).body(form.getBuffer()).timeout(15000).send();
+    }
+}
+RequestHandler.DiscordAPIErrror = DiscordAPIError;
+module.exports = RequestHandler;

package/dist/SnowTransfer.d.ts

@@ -0,0 +1,51 @@
+import Ratelimiter from "./Ratelimiter";
+import RequestHandler from "./RequestHandler";
+import ChannelMethods from "./methods/Channels";
+import UserMethods from "./methods/Users";
+import GuildAssetsMethods from "./methods/GuildAssets";
+import WebhookMethods from "./methods/Webhooks";
+import GuildMethods from "./methods/Guilds";
+import GuildTemplateMethods from "./methods/GuildTemplate";
+import InteractionMethods from "./methods/Interactions";
+import InviteMethods from "./methods/Invites";
+import VoiceMethods from "./methods/Voices";
+import BotMethods from "./methods/Bots";
+import AuditLogMethods from "./methods/AuditLog";
+import StageInstanceMethods from "./methods/StageInstance";
+declare class SnowTransfer {
+    options: {
+        baseHost: string;
+        disableEveryone: boolean;
+        sentryOptions: {
+            extra: {
+                snowtransferVersion: string;
+            };
+        };
+        useRedis: boolean;
+    };
+    token: string;
+    channel: ChannelMethods;
+    requestHandler: RequestHandler;
+    user: UserMethods;
+    guildAssets: GuildAssetsMethods;
+    webhook: WebhookMethods;
+    guild: GuildMethods;
+    guildTemplate: GuildTemplateMethods;
+    interaction: InteractionMethods;
+    invite: InviteMethods;
+    voice: VoiceMethods;
+    bot: BotMethods;
+    auditLog: AuditLogMethods;
+    stageInstance: StageInstanceMethods;
+    ratelimiter: Ratelimiter;
+    /**
+     * Create a new Rest Client
+     * @param token Discord Bot token to use
+     * @param options options
+     */
+    constructor(token: string, options?: {
+        baseHost?: string;
+        disableEveryone?: boolean;
+    });
+}
+export = SnowTransfer;

package/dist/SnowTransfer.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const Ratelimiter_1 = __importDefault(require("./Ratelimiter"));
+const RequestHandler_1 = __importDefault(require("./RequestHandler"));
+const Channels_1 = __importDefault(require("./methods/Channels"));
+const Users_1 = __importDefault(require("./methods/Users"));
+const GuildAssets_1 = __importDefault(require("./methods/GuildAssets"));
+const Webhooks_1 = __importDefault(require("./methods/Webhooks"));
+const Guilds_1 = __importDefault(require("./methods/Guilds"));
+const GuildTemplate_1 = __importDefault(require("./methods/GuildTemplate"));
+const Interactions_1 = __importDefault(require("./methods/Interactions"));
+const Invites_1 = __importDefault(require("./methods/Invites"));
+const Voices_1 = __importDefault(require("./methods/Voices"));
+const Bots_1 = __importDefault(require("./methods/Bots"));
+const AuditLog_1 = __importDefault(require("./methods/AuditLog"));
+const StageInstance_1 = __importDefault(require("./methods/StageInstance"));
+const Endpoints_1 = __importDefault(require("./Endpoints"));
+const { version } = require("../package.json");
+class SnowTransfer {
+    /**
+     * Create a new Rest Client
+     * @param token Discord Bot token to use
+     * @param options options
+     */
+    constructor(token, options) {
+        if (!token || token === "") {
+            throw new Error("Missing token");
+        }
+        if (!token.startsWith("Bot")) {
+            token = `Bot ${token}`;
+        }
+        this.options = { baseHost: Endpoints_1.default.BASE_HOST, disableEveryone: false, sentryOptions: { extra: { snowtransferVersion: version } }, useRedis: false };
+        this.token = token;
+        Object.assign(this.options, options);
+        this.ratelimiter = new Ratelimiter_1.default();
+        this.requestHandler = new RequestHandler_1.default(this.ratelimiter, {
+            token: this.token,
+            baseHost: this.options.baseHost || Endpoints_1.default.BASE_HOST
+        });
+        this.channel = new Channels_1.default(this.requestHandler, this.options.disableEveryone);
+        this.user = new Users_1.default(this.requestHandler);
+        this.guildAssets = new GuildAssets_1.default(this.requestHandler);
+        this.webhook = new Webhooks_1.default(this.requestHandler, this.options.disableEveryone);
+        this.guild = new Guilds_1.default(this.requestHandler);
+        this.guildTemplate = new GuildTemplate_1.default(this.requestHandler);
+        this.interaction = new Interactions_1.default(this.requestHandler, this.webhook);
+        this.invite = new Invites_1.default(this.requestHandler);
+        this.voice = new Voices_1.default(this.requestHandler);
+        this.bot = new Bots_1.default(this.requestHandler);
+        this.auditLog = new AuditLog_1.default(this.requestHandler);
+        this.stageInstance = new StageInstance_1.default(this.requestHandler);
+    }
+}
+module.exports = SnowTransfer;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import Constants from "./Constants";
+import Endpoints from "./Endpoints";
+import SnowTransfer from "./SnowTransfer";
+export { Constants, Endpoints, SnowTransfer };

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnowTransfer = exports.Endpoints = exports.Constants = void 0;
+const Constants_1 = __importDefault(require("./Constants"));
+exports.Constants = Constants_1.default;
+const Endpoints_1 = __importDefault(require("./Endpoints"));
+exports.Endpoints = Endpoints_1.default;
+const SnowTransfer_1 = __importDefault(require("./SnowTransfer"));
+exports.SnowTransfer = SnowTransfer_1.default;

package/dist/methods/AuditLog.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Methods for interacting with Guild Audit Logs
+ */
+declare class AuditLogMethods {
+    requestHandler: import("../RequestHandler");
+    /**
+     * Create a new Audit Log Method Handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.auditLog.method`, where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     */
+    constructor(requestHandler: import("../RequestHandler"));
+    /**
+     * Get the audit logs of the specified guild id
+     * @param guildId id of a guild
+     * @param data optional audit log filter values
+     * @returns An object with [audit log data](https://discord.com/developers/docs/resources/audit-log#audit-log-object)
+     *
+     * | Permissions needed | Condition |
+     * |--------------------|-----------|
+     * | VIEW_AUDIT_LOG     | always    |
+     */
+    getAuditLog(guildId: string, data?: GetAuditLogOptions): Promise<import("discord-typings").AuditLogObject>;
+}
+interface GetAuditLogOptions {
+    /**
+     * Filter the audit log with the id of a user
+     */
+    user_id?: string;
+    /**
+     * [Type](https://discord.com/developers/docs/resources/audit-log#audit-log-entry-object-audit-log-events) of the audit log event
+     */
+    action_type?: import("discord-typings").AuditLogEventType;
+    /**
+     * Filter the audit log before a certain entry id
+     */
+    before?: string;
+    /**
+     * How many entries are returned (min 1, max 100)
+     */
+    limit: number;
+}
+export = AuditLogMethods;

package/dist/methods/AuditLog.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const Endpoints_1 = __importDefault(require("../Endpoints"));
+/**
+ * Methods for interacting with Guild Audit Logs
+ */
+class AuditLogMethods {
+    /**
+     * Create a new Audit Log Method Handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.auditLog.method`, where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     */
+    constructor(requestHandler) {
+        this.requestHandler = requestHandler;
+    }
+    /**
+     * Get the audit logs of the specified guild id
+     * @param guildId id of a guild
+     * @param data optional audit log filter values
+     * @returns An object with [audit log data](https://discord.com/developers/docs/resources/audit-log#audit-log-object)
+     *
+     * | Permissions needed | Condition |
+     * |--------------------|-----------|
+     * | VIEW_AUDIT_LOG     | always    |
+     */
+    async getAuditLog(guildId, data) {
+        return this.requestHandler.request(Endpoints_1.default.GUILD_AUDIT_LOGS(guildId), "get", "json", data);
+    }
+}
+module.exports = AuditLogMethods;

package/dist/methods/Bots.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Methods for interacting with bot specific endpoints
+ */
+declare class BotMethods {
+    requestHandler: import("../RequestHandler");
+    /**
+     * Create a new Bot Method Handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.bot.method`, where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     */
+    constructor(requestHandler: import("../RequestHandler"));
+    /**
+     * Get the gateway url to connect to
+     * @returns [Gateway data](https://discord.com/developers/docs/topics/gateway#get-gateway-example-response)
+     *
+     * @example
+     * let client = new SnowTransfer('TOKEN');
+     * let result = await client.bot.getGateway();
+     * // result should be something like {"url": "wss://gateway.discord.gg"}
+     */
+    getGateway(): Promise<GatewayData>;
+    /**
+     * Get the gateway url to connect to and a recommended amount of shards to use
+     * @returns [Gateway data](https://discord.com/developers/docs/topics/gateway#get-gateway-example-response)
+     *
+     * @example
+     * let client = new SnowTransfer('TOKEN');
+     * let result = await client.bot.getGateway();
+     * // result should be something like {"url": "wss://gateway.discord.gg", "shards": 1}
+     */
+    getGatewayBot(): Promise<GatewayData>;
+}
+interface GatewayData {
+    url: string;
+    shards?: number;
+}
+export = BotMethods;

package/dist/methods/Bots.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const Endpoints_1 = __importDefault(require("../Endpoints"));
+/**
+ * Methods for interacting with bot specific endpoints
+ */
+class BotMethods {
+    /**
+     * Create a new Bot Method Handler
+     *
+     * Usually SnowTransfer creates a method handler for you, this is here for completion
+     *
+     * You can access the methods listed via `client.bot.method`, where `client` is an initialized SnowTransfer instance
+     * @param requestHandler request handler that calls the rest api
+     */
+    constructor(requestHandler) {
+        this.requestHandler = requestHandler;
+    }
+    /**
+     * Get the gateway url to connect to
+     * @returns [Gateway data](https://discord.com/developers/docs/topics/gateway#get-gateway-example-response)
+     *
+     * @example
+     * let client = new SnowTransfer('TOKEN');
+     * let result = await client.bot.getGateway();
+     * // result should be something like {"url": "wss://gateway.discord.gg"}
+     */
+    getGateway() {
+        return this.requestHandler.request(Endpoints_1.default.GATEWAY, "get", "json");
+    }
+    /**
+     * Get the gateway url to connect to and a recommended amount of shards to use
+     * @returns [Gateway data](https://discord.com/developers/docs/topics/gateway#get-gateway-example-response)
+     *
+     * @example
+     * let client = new SnowTransfer('TOKEN');
+     * let result = await client.bot.getGateway();
+     * // result should be something like {"url": "wss://gateway.discord.gg", "shards": 1}
+     */
+    getGatewayBot() {
+        return this.requestHandler.request(Endpoints_1.default.GATEWAY_BOT, "get", "json");
+    }
+}
+module.exports = BotMethods;