seyfert 0.1.0 → 1.0.0

package/lib/api/handlers/Shared.js

@@ -1,125 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleErrors = exports.makeNetworkRequest = exports.incrementInvalidCount = void 0;
-const DiscordAPIError_js_1 = require("../errors/DiscordAPIError.js");
-const HTTPError_js_1 = require("../errors/HTTPError.js");
-const constants_js_1 = require("../utils/constants.js");
-const utils_js_1 = require("../utils/utils.js");
-/**
- * Invalid request limiting is done on a per-IP basis, not a per-token basis.
- * The best we can do is track invalid counts process-wide (on the theory that
- * users could have multiple bots run from one process) rather than per-bot.
- * Therefore, store these at file scope here rather than in the client's
- * RESTManager object.
- */
-let invalidCount = 0;
-let invalidCountResetTime = null;
-/**
- * Increment the invalid request count and emit warning if necessary
- *
- * @internal
- */
-function incrementInvalidCount(manager) {
-    if (!invalidCountResetTime || invalidCountResetTime < Date.now()) {
-        invalidCountResetTime = Date.now() + 1_000 * 60 * 10;
-        invalidCount = 0;
-    }
-    invalidCount++;
-    const emitInvalid = manager.options.invalidRequestWarningInterval > 0 &&
-        invalidCount % manager.options.invalidRequestWarningInterval === 0;
-    if (emitInvalid) {
-        // Let library users know periodically about invalid requests
-        manager.debugger?.info({
-            count: invalidCount,
-            remainingTime: invalidCountResetTime - Date.now(),
-        });
-    }
-}
-exports.incrementInvalidCount = incrementInvalidCount;
-/**
- * Performs the actual network request for a request handler
- *
- * @param manager - The manager that holds options and emits informational events
- * @param routeId - The generalized api route with literal ids for major parameters
- * @param url - The fully resolved url to make the request to
- * @param options - The fetch options needed to make the request
- * @param requestData - Extra data from the user's request needed for errors and additional processing
- * @param retries - The number of retries this request has already attempted (recursion occurs on the handler)
- * @returns The respond from the network or `null` when the request should be retried
- * @internal
- */
-async function makeNetworkRequest(manager, routeId, url, options, requestData, retries) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), manager.options.timeout);
-    if (requestData.signal) {
-        // If the user signal was aborted, abort the controller, else abort the local signal.
-        // The reason why we don't re-use the user's signal, is because users may use the same signal for multiple
-        // requests, and we do not want to cause unexpected side-effects.
-        if (requestData.signal.aborted)
-            controller.abort();
-        else
-            requestData.signal.addEventListener('abort', () => controller.abort());
-    }
-    let res;
-    try {
-        res = await manager.options.makeRequest(url, { ...options, signal: controller.signal });
-    }
-    catch (error) {
-        if (!(error instanceof Error))
-            throw error;
-        // Retry the specified number of times if needed
-        if ((0, utils_js_1.shouldRetry)(error) && retries !== manager.options.retries) {
-            // Retry is handled by the handler upon receiving null
-            return null;
-        }
-        throw error;
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-    manager.debugger?.info(constants_js_1.RESTEvents.Response, {
-        method: options.method ?? 'get',
-        path: routeId.original,
-        route: routeId.bucketRoute,
-        options,
-        data: requestData,
-        retries,
-    }, res instanceof Response ? res.clone() : { ...res });
-    return res;
-}
-exports.makeNetworkRequest = makeNetworkRequest;
-/**
- * Handles 5xx and 4xx errors (not 429's) conventionally. 429's should be handled before calling this function
- *
- * @param manager - The manager that holds options and emits informational events
- * @param res - The response received from {@link makeNetworkRequest}
- * @param method - The method used to make the request
- * @param url - The fully resolved url to make the request to
- * @param requestData - Extra data from the user's request needed for errors and additional processing
- * @param retries - The number of retries this request has already attempted (recursion occurs on the handler)
- * @returns The response if the status code is not handled or null to request a retry
- */
-async function handleErrors(manager, res, method, url, requestData, retries) {
-    const status = res.status;
-    if (status >= 500 && status < 600) {
-        // Retry the specified number of times for possible server side issues
-        if (retries !== manager.options.retries) {
-            return null;
-        }
-        // We are out of retries, throw an error
-        throw new HTTPError_js_1.HTTPError(status, res.statusText, method, url, requestData);
-    }
-    // Handle possible malformed requests
-    if (status >= 400 && status < 500) {
-        // If we receive this status code, it means the token we had is no longer valid.
-        if (status === 401 && requestData.auth) {
-            manager.setToken(null);
-        }
-        // The request will not succeed for some reason, parse the error returned from the api
-        const data = (await (0, utils_js_1.parseResponse)(res));
-        // throw the API error
-        throw new DiscordAPIError_js_1.DiscordAPIError(data, 'code' in data ? data.code : data.error, status, method, url, requestData);
-    }
-    return res;
-}
-exports.handleErrors = handleErrors;

package/lib/api/interfaces/Handler.d.ts

@@ -1,21 +0,0 @@
-import type { RequestInit } from 'undici-types';
-import type { HandlerRequestData, ResponseLike, RouteData } from '../utils/types.js';
-export interface IHandler {
-    /**
-     * The unique id of the handler
-     */
-    readonly id: string;
-    /**
-     * If the bucket is currently inactive (no pending requests)
-     */
-    get inactive(): boolean;
-    /**
-     * Queues a request to be sent
-     *
-     * @param routeId - The generalized api route with literal ids for major parameters
-     * @param url - The url to do the request on
-     * @param options - All the information needed to make a request
-     * @param requestData - Extra data from the user's request needed for errors and additional processing
-     */
-    queueRequest(routeId: RouteData, url: string, options: RequestInit, requestData: HandlerRequestData): Promise<ResponseLike>;
-}

package/lib/api/interfaces/Handler.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/websocket/discord/handlemessage.js

@@ -1 +0,0 @@
-"use strict";

package/lib/websocket/discord/memberUpdate.d.ts

@@ -1,16 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { APIUser, GatewayGuildMemberUpdateDispatchData } from 'discord-api-types/v10';
-export declare class MemberUpdateHandler {
-    guildMemberUpdate: Map<string, {
-        timeout: NodeJS.Timeout;
-        member: GatewayGuildMemberUpdateDispatchData;
-    }>;
-    check(member: GatewayGuildMemberUpdateDispatchData): boolean;
-    setMember(member: GatewayGuildMemberUpdateDispatchData): void;
-    membersEquals(old: GatewayGuildMemberUpdateDispatchData, member: GatewayGuildMemberUpdateDispatchData): boolean;
-    usersEqual(old: APIUser, user: APIUser): boolean;
-}

package/lib/websocket/discord/memberUpdate.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemberUpdateHandler = void 0;
-class MemberUpdateHandler {
-    guildMemberUpdate = new Map();
-    check(member) {
-        if (!this.guildMemberUpdate.has(member.user.id)) {
-            this.setMember(member);
-            return true;
-        }
-        const data = this.guildMemberUpdate.get(member.user.id);
-        if (this.usersEqual(data.member.user, member.user)) {
-            return this.membersEquals(data.member, member);
-        }
-        clearTimeout(data.timeout);
-        this.setMember(member);
-        return true;
-    }
-    setMember(member) {
-        this.guildMemberUpdate.set(member.user.id, {
-            member,
-            timeout: setTimeout(() => {
-                this.guildMemberUpdate.delete(member.user.id);
-            }, 1.5e3),
-        });
-    }
-    membersEquals(old, member) {
-        return (old.joined_at === member.joined_at &&
-            old.nick === member.nick &&
-            old.avatar === member.avatar &&
-            old.pending === member.pending &&
-            old.communication_disabled_until === member.communication_disabled_until &&
-            old.flags === member.flags &&
-            (old.roles === member.roles ||
-                (old.roles.length === member.roles.length && old.roles.every((role, i) => role === member.roles[i]))));
-    }
-    usersEqual(old, user) {
-        return (old.username === user.username &&
-            old.discriminator === user.discriminator &&
-            old.global_name === user.global_name &&
-            old.avatar === user.avatar &&
-            old.public_flags === user.public_flags &&
-            old.banner === user.banner &&
-            old.accent_color === user.accent_color);
-    }
-}
-exports.MemberUpdateHandler = MemberUpdateHandler;