seyfert 0.1.0 → 1.0.0

package/lib/api/REST.js

@@ -1,424 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.REST = void 0;
-const magic_bytes_js_1 = require("magic-bytes.js");
-const collection_1 = require("../collection");
-const common_1 = require("../common");
-const logger_1 = require("../common/it/logger");
-const functions_1 = require("../structures/extra/functions");
-const CDN_1 = require("./CDN");
-const BurstHandler_1 = require("./handlers/BurstHandler");
-const SequentialHandler_1 = require("./handlers/SequentialHandler");
-const constants_1 = require("./utils/constants");
-const types_1 = require("./utils/types");
-const utils_1 = require("./utils/utils");
-/**
- * Represents the class that manages handlers for endpoints
- */
-class REST {
-    /**
-     * The {@link https://undici.nodejs.org/#/docs/api/Agent | Agent} for all requests
-     * performed by this manager.
-     */
-    agent = null;
-    /**
-     * The number of requests remaining in the global bucket
-     */
-    globalRemaining;
-    /**
-     * The promise used to wait out the global rate limit
-     */
-    globalDelay = null;
-    /**
-     * The timestamp at which the global bucket resets
-     */
-    globalReset = -1;
-    /**
-     * API bucket hashes that are cached from provided routes
-     */
-    hashes = new collection_1.Collection();
-    /**
-     * Request handlers created from the bucket hash and the major parameters
-     */
-    handlers = new collection_1.Collection();
-    cdn;
-    #token = null;
-    hashTimer;
-    handlerTimer;
-    options;
-    debugger;
-    constructor(options) {
-        this.options = (0, common_1.MergeOptions)(constants_1.DefaultRestOptions, options);
-        this.options.offset = Math.max(0, this.options.offset);
-        this.globalRemaining = Math.max(1, this.options.globalRequestsPerSecond);
-        this.agent = options.agent ?? null;
-        this.#token = options.token;
-        this.cdn = new CDN_1.CDN();
-        if (options.debug) {
-            this.debugger = new logger_1.Logger({
-                name: '[REST]',
-            });
-        }
-        // Start sweepers
-        this.setupSweepers();
-    }
-    setupSweepers() {
-        // eslint-disable-next-line unicorn/consistent-function-scoping
-        const validateMaxInterval = (interval) => {
-            if (interval > 14_400_000) {
-                throw new Error('Cannot set an interval greater than 4 hours');
-            }
-        };
-        if (this.options.hashSweepInterval !== 0 && this.options.hashSweepInterval !== Number.POSITIVE_INFINITY) {
-            validateMaxInterval(this.options.hashSweepInterval);
-            this.hashTimer = setInterval(() => {
-                const sweptHashes = new collection_1.Collection();
-                const currentDate = Date.now();
-                // Begin sweeping hash based on lifetimes
-                this.hashes.sweep((val, key) => {
-                    // `-1` indicates a global hash
-                    if (val.lastAccess === -1)
-                        return false;
-                    // Check if lifetime has been exceeded
-                    const shouldSweep = Math.floor(currentDate - val.lastAccess) > this.options.hashLifetime;
-                    // Add hash to collection of swept hashes
-                    if (shouldSweep) {
-                        // Add to swept hashes
-                        sweptHashes.set(key, val);
-                        // Emit debug information
-                        this.debugger?.info(`Hash ${val.value} for ${key} swept due to lifetime being exceeded`);
-                    }
-                    return shouldSweep;
-                });
-                // Fire event
-                this.debugger?.info(sweptHashes);
-            }, this.options.hashSweepInterval);
-            this.hashTimer.unref?.();
-        }
-        if (this.options.handlerSweepInterval !== 0 && this.options.handlerSweepInterval !== Number.POSITIVE_INFINITY) {
-            validateMaxInterval(this.options.handlerSweepInterval);
-            this.handlerTimer = setInterval(() => {
-                const sweptHandlers = new collection_1.Collection();
-                // Begin sweeping handlers based on activity
-                this.handlers.sweep((val, key) => {
-                    // Collect inactive handlers
-                    if (val.inactive) {
-                        sweptHandlers.set(key, val);
-                        this.debugger?.info(`Handler ${val.id} for ${key} swept due to being inactive`);
-                    }
-                    return val.inactive;
-                });
-                // Fire event
-                this.debugger?.info(sweptHandlers);
-            }, this.options.handlerSweepInterval);
-            this.handlerTimer.unref?.();
-        }
-    }
-    /**
-     * Runs a get request from the api
-     *
-     * @param route - The full route to query
-     * @param options - Optional request options
-     */
-    async get(route, options) {
-        const data = await this.request({
-            ...options,
-            method: types_1.RequestMethod.Get,
-            fullRoute: route,
-            query: options?.query ? new URLSearchParams(options.query) : undefined,
-        });
-        return data;
-    }
-    /**
-     * Runs a delete request from the api
-     *
-     * @param route - The full route to query
-     * @param options - Optional request options
-     */
-    async delete(route, options) {
-        const data = await this.request({
-            ...options,
-            fullRoute: route,
-            method: types_1.RequestMethod.Delete,
-            query: options?.query ? new URLSearchParams(options.query) : undefined,
-        });
-        return data;
-    }
-    /**
-     * Runs a post request from the api
-     *
-     * @param route - The full route to query
-     * @param options - Optional request options
-     */
-    async post(route, body) {
-        const data = await this.request({
-            fullRoute: route,
-            method: types_1.RequestMethod.Post,
-            ...body,
-            body: body?.body,
-            query: body?.query ? new URLSearchParams(body.query) : undefined,
-            files: body?.files,
-        });
-        return data;
-    }
-    /**
-     * Runs a put request from the api
-     *
-     * @param route - The full route to query
-     * @param options - Optional request options
-     */
-    async put(route, body) {
-        const data = await this.request({
-            ...body,
-            body: body?.body,
-            query: body?.query ? new URLSearchParams(body.query) : undefined,
-            files: body?.files,
-            fullRoute: route,
-            method: types_1.RequestMethod.Put,
-        });
-        return data;
-    }
-    /**
-     * Runs a patch request from the api
-     *
-     * @param route - The full route to query
-     * @param options - Optional request options
-     */
-    async patch(route, body) {
-        const data = await this.request({
-            ...body,
-            body: body?.body,
-            query: body?.query ? new URLSearchParams(body.query) : undefined,
-            files: body?.files,
-            fullRoute: route,
-            method: types_1.RequestMethod.Patch,
-        });
-        return data;
-    }
-    /**
-     * Runs a request from the api
-     *
-     * @param options - Request options
-     */
-    async request(options) {
-        const response = await this.queueRequest(options);
-        return (0, utils_1.parseResponse)(response);
-    }
-    /**
-     * Sets the default agent to use for requests performed by this manager
-     *
-     * @param agent - The agent to use
-     */
-    setAgent(agent) {
-        this.agent = agent;
-        return this;
-    }
-    /**
-     * Sets the authorization token that should be used for requests
-     *
-     * @param token - The authorization token to use
-     */
-    setToken(token) {
-        this.#token = token;
-        return this;
-    }
-    /**
-     * Queues a request to be sent
-     *
-     * @param request - All the information needed to make a request
-     * @returns The response from the api request
-     */
-    async queueRequest(request) {
-        // Generalize the endpoint to its route data
-        const routeId = REST.generateRouteData(request.fullRoute, request.method);
-        // Get the bucket hash for the generic route, or point to a global route otherwise
-        const hash = this.hashes.get(`${request.method}:${routeId.bucketRoute}`) ?? {
-            value: `Global(${request.method}:${routeId.bucketRoute})`,
-            lastAccess: -1,
-        };
-        // Get the request handler for the obtained hash, with its major parameter
-        const handler = this.handlers.get(`${hash.value}:${routeId.majorParameter}`) ??
-            this.createHandler(hash.value, routeId.majorParameter);
-        // Resolve the request into usable fetch options
-        const { url, fetchOptions } = await this.resolveRequest(request);
-        // Queue the request
-        return handler.queueRequest(routeId, url, fetchOptions, {
-            body: request.body,
-            files: request.files,
-            auth: request.auth !== false,
-            signal: request.signal,
-        });
-    }
-    /**
-     * Creates a new rate limit handler from a hash, based on the hash and the major parameter
-     *
-     * @param hash - The hash for the route
-     * @param majorParameter - The major parameter for this handler
-     * @internal
-     */
-    createHandler(hash, majorParameter) {
-        // Create the async request queue to handle requests
-        const queue = majorParameter === constants_1.BurstHandlerMajorIdKey
-            ? new BurstHandler_1.BurstHandler(this, hash, majorParameter)
-            : new SequentialHandler_1.SequentialHandler(this, hash, majorParameter);
-        // Save the queue based on its id
-        this.handlers.set(queue.id, queue);
-        return queue;
-    }
-    /**
-     * Formats the request data to a usable format for fetch
-     *
-     * @param request - The request data
-     */
-    async resolveRequest(request) {
-        let query = '';
-        // If a query option is passed, use it
-        if (request.query) {
-            const resolvedQuery = request.query.toString();
-            if (resolvedQuery !== '') {
-                query = `?${resolvedQuery}`;
-            }
-        }
-        // Create the required headers
-        const headers = {
-            ...this.options.headers,
-            'User-Agent': `${constants_1.DefaultUserAgent} ${this.options.userAgentAppendix}`.trim(),
-        };
-        // If this request requires authorization (allowing non-"authorized" requests for webhooks)
-        if (request.auth !== false) {
-            // If we haven't received a token, throw an error
-            if (!this.#token) {
-                throw new Error('Expected token to be set for this request, but none was present');
-            }
-            headers.Authorization = `${request.authPrefix ?? this.options.authPrefix} ${this.#token}`;
-        }
-        // If a reason was set, set its appropriate header
-        if (request.reason?.length) {
-            headers['X-Audit-Log-Reason'] = encodeURIComponent(request.reason);
-        }
-        // Format the full request URL (api base, optional version, endpoint, optional querystring)
-        const url = `${this.options.api}${request.versioned === false ? '' : `/v${this.options.version}`}${request.fullRoute}${query}`;
-        let finalBody;
-        let additionalHeaders = {};
-        if (request.files?.length) {
-            const formData = new FormData();
-            // Attach all files to the request
-            for (const [index, file] of request.files.entries()) {
-                const fileKey = file.key ?? `files[${index}]`;
-                // https://developer.mozilla.org/en-US/docs/Web/API/FormData/append#parameters
-                // FormData.append only accepts a string or Blob.
-                // https://developer.mozilla.org/en-US/docs/Web/API/Blob/Blob#parameters
-                // The Blob constructor accepts TypedArray/ArrayBuffer, strings, and Blobs.
-                if ((0, utils_1.isBufferLike)(file.data)) {
-                    // Try to infer the content type from the buffer if one isn't passed
-                    let contentType = file.contentType;
-                    if (!contentType) {
-                        const [parsedType] = (0, magic_bytes_js_1.filetypeinfo)(file.data);
-                        if (parsedType) {
-                            contentType =
-                                constants_1.OverwrittenMimeTypes[parsedType.mime] ??
-                                    parsedType.mime ??
-                                    'application/octet-stream';
-                        }
-                    }
-                    formData.append(fileKey, new Blob([file.data], { type: contentType }), file.name);
-                }
-                else {
-                    formData.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
-                }
-            }
-            // If a JSON body was added as well, attach it to the form data, using payload_json unless otherwise specified
-            if (request.body != null) {
-                if (request.appendToFormData) {
-                    for (const [key, value] of Object.entries(request.body)) {
-                        // @ts-expect-error
-                        formData.append(key, value);
-                    }
-                }
-                else {
-                    formData.append('payload_json', JSON.stringify(request.body));
-                }
-            }
-            // Set the final body to the form data
-            // @ts-expect-error
-            finalBody = formData;
-            // eslint-disable-next-line no-eq-null, eqeqeq
-        }
-        else if (request.body != null) {
-            if (request.passThroughBody) {
-                finalBody = request.body;
-            }
-            else {
-                // Stringify the JSON data
-                finalBody = JSON.stringify(request.body);
-                // Set the additional headers to specify the content-type
-                additionalHeaders = { 'Content-Type': 'application/json' };
-            }
-        }
-        const method = request.method.toUpperCase();
-        // The non null assertions in the following block are due to exactOptionalPropertyTypes, they have been tested to work with undefined
-        const fetchOptions = {
-            // Set body to null on get / head requests. This does not follow fetch spec (likely because it causes subtle bugs) but is aligned with what request was doing
-            body: ['GET', 'HEAD'].includes(method) ? null : finalBody,
-            headers: { ...request.headers, ...additionalHeaders, ...headers },
-            method,
-            // Prioritize setting an agent per request, use the agent for this instance otherwise.
-            dispatcher: request.dispatcher ?? this.agent ?? undefined,
-        };
-        return { url, fetchOptions };
-    }
-    /**
-     * Stops the hash sweeping interval
-     */
-    clearHashSweeper() {
-        clearInterval(this.hashTimer);
-    }
-    /**
-     * Stops the request handler sweeping interval
-     */
-    clearHandlerSweeper() {
-        clearInterval(this.handlerTimer);
-    }
-    /**
-     * Generates route data for an endpoint:method
-     *
-     * @param endpoint - The raw endpoint to generalize
-     * @param method - The HTTP method this endpoint is called without
-     * @internal
-     */
-    static generateRouteData(endpoint, method) {
-        if (endpoint.startsWith('/interactions/') && endpoint.endsWith('/callback')) {
-            return {
-                majorParameter: constants_1.BurstHandlerMajorIdKey,
-                bucketRoute: '/interactions/:id/:token/callback',
-                original: endpoint,
-            };
-        }
-        const majorIdMatch = /(?:^\/webhooks\/(\d{17,19}\/[^/?]+))|(?:^\/(?:channels|guilds|webhooks)\/(\d{17,19}))/.exec(endpoint);
-        // Get the major id or id + token for this route - global otherwise
-        const majorId = majorIdMatch?.[2] ?? majorIdMatch?.[1] ?? 'global';
-        const baseRoute = endpoint
-            // Strip out all ids
-            .replaceAll(/\d{17,19}/g, ':id')
-            // Strip out reaction as they fall under the same bucket
-            .replace(/\/reactions\/(.*)/, '/reactions/:reaction')
-            // Strip out webhook tokens
-            .replace(/\/webhooks\/:id\/[^/?]+/, '/webhooks/:id/:token');
-        let exceptions = '';
-        // Hard-Code Old Message Deletion Exception (2 week+ old messages are a different bucket)
-        // https://github.com/discord/discord-api-docs/issues/1295
-        if (method === types_1.RequestMethod.Delete && baseRoute === '/channels/:id/messages/:id') {
-            const id = /\d{17,19}$/.exec(endpoint)[0];
-            const timestamp = Number((0, functions_1.snowflakeToTimestamp)(id));
-            if (Date.now() - timestamp > 1_000 * 60 * 60 * 24 * 14) {
-                exceptions += '/Delete Old Message';
-            }
-        }
-        return {
-            majorParameter: majorId,
-            bucketRoute: baseRoute + exceptions,
-            original: endpoint,
-        };
-    }
-}
-exports.REST = REST;

package/lib/api/errors/DiscordAPIError.d.ts

@@ -1,51 +0,0 @@
-import type { InternalRequest, RawFile } from '../utils/types.js';
-interface DiscordErrorFieldInformation {
-    code: string;
-    message: string;
-}
-interface DiscordErrorGroupWrapper {
-    _errors: DiscordError[];
-}
-type DiscordError = DiscordErrorFieldInformation | DiscordErrorGroupWrapper | string | {
-    [k: string]: DiscordError;
-};
-export interface DiscordErrorData {
-    code: number;
-    errors?: DiscordError;
-    message: string;
-}
-export interface OAuthErrorData {
-    error: string;
-    error_description?: string;
-}
-export interface RequestBody {
-    files: RawFile[] | undefined;
-    json: unknown | undefined;
-}
-/**
- * Represents an API error returned by Discord
- */
-export declare class DiscordAPIError extends Error {
-    rawError: DiscordErrorData | OAuthErrorData;
-    code: number | string;
-    status: number;
-    method: string;
-    url: string;
-    requestBody: RequestBody;
-    /**
-     * @param rawError - The error reported by Discord
-     * @param code - The error code reported by Discord
-     * @param status - The status code of the response
-     * @param method - The method of the request that erred
-     * @param url - The url of the request that erred
-     * @param bodyData - The unparsed data for the request that errored
-     */
-    constructor(rawError: DiscordErrorData | OAuthErrorData, code: number | string, status: number, method: string, url: string, bodyData: Pick<InternalRequest, 'body' | 'files'>);
-    /**
-     * The name of the error
-     */
-    get name(): string;
-    private static getMessage;
-    private static flattenDiscordError;
-}
-export {};

package/lib/api/errors/DiscordAPIError.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscordAPIError = void 0;
-function isErrorGroupWrapper(error) {
-    return Reflect.has(error, '_errors');
-}
-function isErrorResponse(error) {
-    return typeof Reflect.get(error, 'message') === 'string';
-}
-/**
- * Represents an API error returned by Discord
- */
-class DiscordAPIError extends Error {
-    rawError;
-    code;
-    status;
-    method;
-    url;
-    requestBody;
-    /**
-     * @param rawError - The error reported by Discord
-     * @param code - The error code reported by Discord
-     * @param status - The status code of the response
-     * @param method - The method of the request that erred
-     * @param url - The url of the request that erred
-     * @param bodyData - The unparsed data for the request that errored
-     */
-    constructor(rawError, code, status, method, url, bodyData) {
-        super(DiscordAPIError.getMessage(rawError));
-        this.rawError = rawError;
-        this.code = code;
-        this.status = status;
-        this.method = method;
-        this.url = url;
-        this.requestBody = { files: bodyData.files, json: bodyData.body };
-    }
-    /**
-     * The name of the error
-     */
-    get name() {
-        return `${DiscordAPIError.name}[${this.code}]`;
-    }
-    static getMessage(error) {
-        let flattened = '';
-        if ('code' in error) {
-            if (error.errors) {
-                flattened = [...this.flattenDiscordError(error.errors)].join('\n');
-            }
-            return error.message && flattened
-                ? `${error.message}\n${flattened}`
-                : error.message || flattened || 'Unknown Error';
-        }
-        return error.error_description ?? 'No Description';
-    }
-    static *flattenDiscordError(obj, key = '') {
-        if (isErrorResponse(obj)) {
-            return yield `${key.length ? `${key}[${obj.code}]` : `${obj.code}`}: ${obj.message}`.trim();
-        }
-        for (const [otherKey, val] of Object.entries(obj)) {
-            const nextKey = otherKey.startsWith('_')
-                ? key
-                : key
-                    ? Number.isNaN(Number(otherKey))
-                        ? `${key}.${otherKey}`
-                        : `${key}[${otherKey}]`
-                    : otherKey;
-            if (typeof val === 'string') {
-                yield val;
-            }
-            else if (isErrorGroupWrapper(val)) {
-                for (const error of val._errors) {
-                    yield* this.flattenDiscordError(error, nextKey);
-                }
-            }
-            else {
-                yield* this.flattenDiscordError(val, nextKey);
-            }
-        }
-    }
-}
-exports.DiscordAPIError = DiscordAPIError;

package/lib/api/errors/HTTPError.d.ts

@@ -1,20 +0,0 @@
-import type { InternalRequest } from '../utils/types.js';
-import type { RequestBody } from './DiscordAPIError.js';
-/**
- * Represents a HTTP error
- */
-export declare class HTTPError extends Error {
-    status: number;
-    method: string;
-    url: string;
-    requestBody: RequestBody;
-    name: string;
-    /**
-     * @param status - The status code of the response
-     * @param statusText - The status text of the response
-     * @param method - The method of the request that erred
-     * @param url - The url of the request that erred
-     * @param bodyData - The unparsed data for the request that errored
-     */
-    constructor(status: number, statusText: string, method: string, url: string, bodyData: Pick<InternalRequest, 'body' | 'files'>);
-}

package/lib/api/errors/HTTPError.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTPError = void 0;
-/**
- * Represents a HTTP error
- */
-class HTTPError extends Error {
-    status;
-    method;
-    url;
-    requestBody;
-    name = HTTPError.name;
-    /**
-     * @param status - The status code of the response
-     * @param statusText - The status text of the response
-     * @param method - The method of the request that erred
-     * @param url - The url of the request that erred
-     * @param bodyData - The unparsed data for the request that errored
-     */
-    constructor(status, statusText, method, url, bodyData) {
-        super(statusText);
-        this.status = status;
-        this.method = method;
-        this.url = url;
-        this.requestBody = { files: bodyData.files, json: bodyData.body };
-    }
-}
-exports.HTTPError = HTTPError;

package/lib/api/errors/RateLimitError.d.ts

@@ -1,19 +0,0 @@
-import type { RateLimitData } from '../utils/types.js';
-export declare class RateLimitError extends Error implements RateLimitData {
-    timeToReset: number;
-    limit: number;
-    method: string;
-    hash: string;
-    url: string;
-    route: string;
-    majorParameter: string;
-    global: boolean;
-    retryAfter: number;
-    sublimitTimeout: number;
-    scope: RateLimitData['scope'];
-    constructor({ timeToReset, limit, method, hash, url, route, majorParameter, global, retryAfter, sublimitTimeout, scope, }: RateLimitData);
-    /**
-     * The name of the error
-     */
-    get name(): string;
-}

package/lib/api/errors/RateLimitError.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RateLimitError = void 0;
-class RateLimitError extends Error {
-    timeToReset;
-    limit;
-    method;
-    hash;
-    url;
-    route;
-    majorParameter;
-    global;
-    retryAfter;
-    sublimitTimeout;
-    scope;
-    constructor({ timeToReset, limit, method, hash, url, route, majorParameter, global, retryAfter, sublimitTimeout, scope, }) {
-        super();
-        this.timeToReset = timeToReset;
-        this.limit = limit;
-        this.method = method;
-        this.hash = hash;
-        this.url = url;
-        this.route = route;
-        this.majorParameter = majorParameter;
-        this.global = global;
-        this.retryAfter = retryAfter;
-        this.sublimitTimeout = sublimitTimeout;
-        this.scope = scope;
-    }
-    /**
-     * The name of the error
-     */
-    get name() {
-        return `${RateLimitError.name}[${this.route}]`;
-    }
-}
-exports.RateLimitError = RateLimitError;