seyfert 1.4.0 → 1.5.0

package/lib/client/client.js

@@ -11,16 +11,25 @@ const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
 const base_1 = require("./base");
 const oninteractioncreate_1 = require("./oninteractioncreate");
 const onmessagecreate_1 = require("./onmessagecreate");
+const collectors_1 = require("./collectors");
 let parentPort;
 class Client extends base_1.BaseClient {
     __handleGuilds = new Set();
     gateway;
-    events = new events_1.EventHandler(this.logger);
     me;
     memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
     presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
+    collectors = new collectors_1.Collectors();
+    events = new events_1.EventHandler(this);
     constructor(options) {
         super(options);
+        this.options = (0, common_1.MergeOptions)({
+            commands: {
+                argsParser: options?.commands?.argsParser ?? onmessagecreate_1.defaultArgsParser,
+                optionsParser: options?.commands?.optionsParser ??
+                    onmessagecreate_1.defaultOptionsParser,
+            },
+        }, this.options);
     }
     setServices({ gateway, ...rest }) {
         super.setServices(rest);
@@ -38,7 +47,7 @@ class Client extends base_1.BaseClient {
                 this.events = undefined;
             }
             else if (typeof rest.handlers.events === 'function') {
-                this.events = new events_1.EventHandler(this.logger);
+                this.events = new events_1.EventHandler(this);
                 this.events.setHandlers({
                     callback: rest.handlers.events,
                 });
@@ -49,7 +58,7 @@ class Client extends base_1.BaseClient {
         }
     }
     async loadEvents(dir) {
-        dir ??= await this.getRC().then(x => x.events);
+        dir ??= await this.getRC().then((x) => x.events);
         if (dir && this.events) {
             await this.events.load(dir);
             this.logger.info('EventHandler loaded');
@@ -61,10 +70,7 @@ class Client extends base_1.BaseClient {
         if (worker_threads?.parentPort) {
             parentPort = worker_threads.parentPort;
         }
-        if (!worker_threads?.workerData?.__USING_WATCHER__) {
-            await this.gateway.spawnShards();
-        }
-        else {
+        if (worker_threads?.workerData?.__USING_WATCHER__) {
             parentPort?.on('message', (data) => {
                 switch (data.type) {
                     case 'PAYLOAD':
@@ -76,11 +82,14 @@ class Client extends base_1.BaseClient {
                 }
             });
         }
+        else {
+            await this.gateway.spawnShards();
+        }
     }
     async start(options = {}, execute = true) {
         await super.start(options);
         await this.loadEvents(options.eventsDir);
-        const { token: tokenRC, intents: intentsRC, debug: debugRC } = await this.getRC();
+        const { token: tokenRC, intents: intentsRC, debug: debugRC, } = await this.getRC();
         const token = options?.token ?? tokenRC;
         const intents = options?.connection?.intents ?? intentsRC;
         if (!this.gateway) {
@@ -98,7 +107,10 @@ class Client extends base_1.BaseClient {
                 shardStart: this.options?.shards?.start,
                 shardEnd: this.options?.shards?.end ?? this.options?.shards?.total,
                 totalShards: this.options?.shards?.total ?? this.options?.shards?.end,
-                properties: { ...this.options?.gateway?.properties, ...websocket_1.properties },
+                properties: {
+                    ...websocket_1.properties,
+                    ...this.options?.gateway?.properties,
+                },
                 compress: this.options?.gateway?.compress,
             });
         }
@@ -119,35 +131,30 @@ class Client extends base_1.BaseClient {
                     return;
                 }
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
                 break;
             case 'PRESENCE_UPDATE':
                 if (!this.presenceUpdateHandler.check(packet.d)) {
                     return;
                 }
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
                 break;
-            case 'MESSAGE_UPDATE':
-            case 'MESSAGE_DELETE_BULK':
-            case 'MESSAGE_DELETE':
-            case 'GUILD_DELETE':
-            case 'CHANNEL_UPDATE':
-            case 'GUILD_EMOJIS_UPDATE':
-            case 'GUILD_UPDATE':
-            case 'GUILD_ROLE_UPDATE':
-            case 'GUILD_ROLE_DELETE':
-            case 'THREAD_UPDATE':
-            case 'USER_UPDATE':
-            case 'VOICE_STATE_UPDATE':
-            case 'STAGE_INSTANCE_UPDATE':
-            case 'GUILD_STICKERS_UPDATE':
+            case 'GUILD_CREATE': {
+                if (this.__handleGuilds?.has(packet.d.id)) {
+                    this.__handleGuilds.delete(packet.d.id);
+                    if (!this.__handleGuilds.size &&
+                        [...this.gateway.values()].every((shard) => shard.data.session_id)) {
+                        await this.events?.runEvent('BOT_READY', this, this.me, -1);
+                    }
+                    if (!this.__handleGuilds.size)
+                        delete this.__handleGuilds;
+                    return this.cache.onPacket(packet);
+                }
                 await this.events?.execute(packet.t, packet, this, shardId);
-                await this.cache.onPacket(packet);
                 break;
+            }
             //rest of the events
             default: {
-                await this.cache.onPacket(packet);
+                await this.events?.execute(packet.t, packet, this, shardId);
                 switch (packet.t) {
                     case 'INTERACTION_CREATE':
                         await (0, oninteractioncreate_1.onInteractionCreate)(this, packet.d, shardId);
@@ -162,29 +169,18 @@ class Client extends base_1.BaseClient {
                         this.botId = packet.d.user.id;
                         this.applicationId = packet.d.application.id;
                         this.me = new structures_1.ClientUser(this, packet.d.user, packet.d.application);
-                        if (!this.__handleGuilds?.size ||
-                            !((this.gateway.options.intents & v10_1.GatewayIntentBits.Guilds) === v10_1.GatewayIntentBits.Guilds)) {
-                            if ([...this.gateway.values()].every(shard => shard.data.session_id)) {
+                        if (!(this.__handleGuilds?.size &&
+                            (this.gateway.options.intents &
+                                v10_1.GatewayIntentBits.Guilds) ===
+                                v10_1.GatewayIntentBits.Guilds)) {
+                            if ([...this.gateway.values()].every((shard) => shard.data.session_id)) {
                                 await this.events?.runEvent('BOT_READY', this, this.me, -1);
                             }
                             delete this.__handleGuilds;
                         }
                         this.debugger?.debug(`#${shardId}[${packet.d.user.username}](${this.botId}) is online...`);
                         break;
-                    case 'GUILD_CREATE': {
-                        if (this.__handleGuilds?.has(packet.d.id)) {
-                            this.__handleGuilds.delete(packet.d.id);
-                            if (!this.__handleGuilds.size && [...this.gateway.values()].every(shard => shard.data.session_id)) {
-                                await this.events?.runEvent('BOT_READY', this, this.me, -1);
-                            }
-                            if (!this.__handleGuilds.size)
-                                delete this.__handleGuilds;
-                            return;
-                        }
-                        break;
-                    }
                 }
-                await this.events?.execute(packet.t, packet, this, shardId);
                 break;
             }
         }

package/lib/client/collectors.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import type { Awaitable, CamelCase } from '../common';
+import type { CallbackEventHandler, CustomEventsKeys, GatewayEvents } from '../events';
+export type AllClientEvents = CustomEventsKeys | GatewayEvents;
+export type ParseClientEventName<T extends AllClientEvents> = T extends CustomEventsKeys ? T : CamelCase<T>;
+type RunData<T extends AllClientEvents> = {
+    options: {
+        event: T;
+        idle?: number;
+        timeout?: number;
+        onStop?: (reason: string) => unknown;
+        onStopError?: (reason: string, error: unknown) => unknown;
+        filter: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>) => Awaitable<boolean>;
+        run: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, stop: (reason?: string) => void) => unknown;
+        onRunError?: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, error: unknown, stop: (reason?: string) => void) => unknown;
+    };
+    idle?: NodeJS.Timeout;
+    timeout?: NodeJS.Timeout;
+    nonce: string;
+};
+export declare class Collectors {
+    readonly values: Map<AllClientEvents, RunData<any>[]>;
+    private generateRandomUUID;
+    create<T extends AllClientEvents>(options: RunData<T>['options']): {
+        event: T;
+        idle?: number | undefined;
+        timeout?: number | undefined;
+        onStop?: ((reason: string) => unknown) | undefined;
+        onStopError?: ((reason: string, error: unknown) => unknown) | undefined;
+        filter: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>) => Awaitable<boolean>;
+        run: (arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, stop: (reason?: string | undefined) => void) => unknown;
+        onRunError?: ((arg: Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>, error: unknown, stop: (reason?: string | undefined) => void) => unknown) | undefined;
+    };
+    private delete;
+}
+export {};

package/lib/client/collectors.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collectors = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_console_1 = require("node:console");
+class Collectors {
+    values = new Map();
+    generateRandomUUID(name) {
+        const collectors = this.values.get(name);
+        if (!collectors)
+            return '*';
+        let nonce = (0, node_crypto_1.randomUUID)();
+        while (collectors.find(x => x.nonce === nonce)) {
+            nonce = (0, node_crypto_1.randomUUID)();
+        }
+        return nonce;
+    }
+    create(options) {
+        const nonce = this.generateRandomUUID(options.event);
+        if (!this.values.has(options.event)) {
+            this.values.set(options.event, []);
+        }
+        this.values.get(options.event).push({
+            options: {
+                ...options,
+                name: options.event,
+            },
+            idle: options.idle && options.idle > 0
+                ? setTimeout(() => {
+                    return this.delete(options.event, nonce, 'idle');
+                }, options.idle)
+                : undefined,
+            timeout: options.timeout && options.timeout > 0
+                ? setTimeout(() => {
+                    return this.delete(options.event, nonce, 'timeout');
+                }, options.timeout)
+                : undefined,
+            nonce,
+        });
+        return options;
+    }
+    async delete(name, nonce, reason = 'unknown') {
+        const collectors = this.values.get(name);
+        if (!collectors?.length) {
+            if (collectors)
+                this.values.delete(name);
+            return;
+        }
+        const index = collectors.findIndex(x => x.nonce === nonce);
+        if (index === -1)
+            return;
+        const collector = collectors[index];
+        clearTimeout(collector.idle);
+        clearTimeout(collector.timeout);
+        collectors.splice(index, 1);
+        try {
+            await collector.options.onStop?.(reason);
+        }
+        catch (e) {
+            await collector.options.onStopError?.(reason, node_console_1.error);
+        }
+    }
+    /**@internal */
+    async run(name, data) {
+        const collectors = this.values.get(name);
+        if (!collectors)
+            return;
+        for (const i of collectors) {
+            if (await i.options.filter(data)) {
+                i.idle?.refresh();
+                const stop = (reason = 'unknown') => {
+                    return this.delete(i.options.event, i.nonce, reason);
+                };
+                try {
+                    await i.options.run(data, stop);
+                }
+                catch (e) {
+                    await i.options.onRunError?.(data, e, stop);
+                }
+                break;
+            }
+        }
+    }
+}
+exports.Collectors = Collectors;

package/lib/client/httpclient.js

@@ -176,12 +176,7 @@ class HttpClient extends base_1.BaseClient {
     }
     async onPacket(res, req) {
         const rawBody = await this.verifySignature(res, req);
-        if (!rawBody) {
-            this.debugger?.debug('Invalid request/No info, returning 418 status.');
-            // I'm a teapot
-            res.writeStatus('418').end();
-        }
-        else {
+        if (rawBody) {
             switch (rawBody.type) {
                 case v10_1.InteractionType.Ping:
                     this.debugger?.debug('Ping interaction received, responding.');
@@ -232,6 +227,11 @@ class HttpClient extends base_1.BaseClient {
                     break;
             }
         }
+        else {
+            this.debugger?.debug('Invalid request/No info, returning 418 status.');
+            // I'm a teapot
+            res.writeStatus('418').end();
+        }
     }
 }
 exports.HttpClient = HttpClient;

package/lib/client/onmessagecreate.d.ts

@@ -1,3 +1,13 @@
-import { type GatewayMessageCreateDispatchData } from 'discord-api-types/v10';
-import { type Client, type WorkerClient } from '..';
+import { type APIApplicationCommandInteractionDataOption, type GatewayMessageCreateDispatchData } from 'discord-api-types/v10';
+import { Command, type MessageCommandOptionErrors, SubCommand, type UsingClient, type Client, type ContextOptionsResolved, type WorkerClient } from '..';
+import type { MakeRequired } from '../common';
 export declare function onMessageCreate(self: Client | WorkerClient, rawMessage: GatewayMessageCreateDispatchData, shardId: number): Promise<any>;
+export declare function defaultOptionsParser(self: UsingClient, command: Command | SubCommand, message: GatewayMessageCreateDispatchData, args: Partial<Record<string, string>>, resolved: MakeRequired<ContextOptionsResolved>): Promise<{
+    errors: {
+        name: string;
+        error: string;
+        fullError: MessageCommandOptionErrors;
+    }[];
+    options: APIApplicationCommandInteractionDataOption[];
+}>;
+export declare function defaultArgsParser(content: string): Record<string, string>;

package/lib/client/onmessagecreate.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onMessageCreate = void 0;
+exports.defaultArgsParser = exports.defaultOptionsParser = exports.onMessageCreate = void 0;
 const v10_1 = require("discord-api-types/v10");
 const __1 = require("..");
 const structures_1 = require("../structures");
@@ -45,7 +45,7 @@ async function onMessageCreate(self, rawMessage, shardId) {
     const message = new structures_1.Message(self, rawMessage);
     const prefixes = (await self.options.commands.prefix(message)).sort((a, b) => b.length - a.length);
     const prefix = prefixes.find(x => message.content.startsWith(x));
-    if (!prefix || !message.content.startsWith(prefix))
+    if (!(prefix !== undefined && message.content.startsWith(prefix)))
         return;
     const content = message.content.slice(prefix.length).trimStart();
     const { fullCommandName, command, parent } = getCommandFromContent(content
@@ -56,7 +56,9 @@ async function onMessageCreate(self, rawMessage, shardId) {
         return;
     if (!command.run)
         return self.logger.warn(`${fullCommandName} command does not have 'run' callback`);
-    if (!command.contexts?.includes(__1.InteractionContextTypes.BOT_DM) && !message.guildId)
+    if (!command.contexts.includes(v10_1.InteractionContextType.BotDM) && !message.guildId)
+        return;
+    if (!command.contexts.includes(v10_1.InteractionContextType.Guild) && message.guildId)
         return;
     if (command.guildId && !command.guildId?.includes(message.guildId))
         return;
@@ -71,14 +73,26 @@ async function onMessageCreate(self, rawMessage, shardId) {
     for (const i of fullCommandName.split(' ')) {
         newContent = newContent.slice(newContent.indexOf(i) + i.length);
     }
-    const args = (self.options?.commands?.argsParser ?? defaultArgsParser)(newContent.slice(1), command, message);
-    const { options, errors } = await parseOptions(self, command, rawMessage, args, resolved);
+    const args = self.options.commands.argsParser(newContent.slice(1), command, message);
+    const { options, errors } = await self.options.commands.optionsParser(self, command, rawMessage, args, resolved);
     const optionsResolver = new __1.OptionResolver(self, options, parent, message.guildId, resolved);
     const context = new __1.CommandContext(self, message, optionsResolver, shardId, command);
     //@ts-expect-error
     const extendContext = self.options?.context?.(message) ?? {};
     Object.assign(context, extendContext);
     try {
+        if (errors.length) {
+            return command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
+                return [
+                    x.name,
+                    {
+                        failed: true,
+                        value: x.error,
+                        parseError: x.fullError,
+                    },
+                ];
+            })));
+        }
         if (command.defaultMemberPermissions && message.guildId) {
             const memberPermissions = await self.members.permissions(message.guildId, message.author.id);
             const permissions = memberPermissions.missings(...memberPermissions.values([command.defaultMemberPermissions]));
@@ -98,17 +112,6 @@ async function onMessageCreate(self, rawMessage, shardId) {
                 return command.onBotPermissionsFail?.(context, appPermissions.keys(permissions));
             }
         }
-        if (errors.length) {
-            return command.onOptionsError?.(context, Object.fromEntries(errors.map(x => {
-                return [
-                    x.name,
-                    {
-                        failed: true,
-                        value: x.error,
-                    },
-                ];
-            })));
-        }
         const [erroredOptions, result] = await command.__runOptions(context, optionsResolver);
         if (erroredOptions) {
             return command.onOptionsError?.(context, result);
@@ -146,7 +149,7 @@ async function onMessageCreate(self, rawMessage, shardId) {
     }
 }
 exports.onMessageCreate = onMessageCreate;
-async function parseOptions(self, command, message, args, resolved) {
+async function defaultOptionsParser(self, command, message, args, resolved) {
     const options = [];
     const errors = [];
     for (const i of (command.options ?? [])) {
@@ -179,6 +182,7 @@ async function parseOptions(self, command, message, args, resolved) {
                                             error: `The entered channel type is not one of ${i
                                                 .channel_types.map(t => v10_1.ChannelType[t])
                                                 .join(', ')}`,
+                                            fullError: ['CHANNEL_TYPES', i.channel_types],
                                         });
                                         break;
                                     }
@@ -274,6 +278,7 @@ async function parseOptions(self, command, message, args, resolved) {
                                 errors.push({
                                     name: i.name,
                                     error: `The entered string has less than ${option.min_length} characters. The minimum required is ${option.min_length} characters.`,
+                                    fullError: ['STRING_MIN_LENGTH', option.min_length],
                                 });
                                 break;
                             }
@@ -284,6 +289,7 @@ async function parseOptions(self, command, message, args, resolved) {
                                 errors.push({
                                     name: i.name,
                                     error: `The entered string has more than ${option.max_length} characters. The maximum required is ${option.max_length} characters.`,
+                                    fullError: ['STRING_MAX_LENGTH', option.max_length],
                                 });
                                 break;
                             }
@@ -297,6 +303,7 @@ async function parseOptions(self, command, message, args, resolved) {
                                     error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
                                         .map(x => x.name)
                                         .join(', ')}.`,
+                                    fullError: ['STRING_INVALID_CHOICE', option.choices],
                                 });
                                 break;
                             }
@@ -319,6 +326,7 @@ async function parseOptions(self, command, message, args, resolved) {
                                 errors.push({
                                     name: i.name,
                                     error: 'The entered choice is an invalid number.',
+                                    fullError: ['NUMBER_NAN', args[i.name]],
                                 });
                                 break;
                             }
@@ -328,6 +336,7 @@ async function parseOptions(self, command, message, args, resolved) {
                                     errors.push({
                                         name: i.name,
                                         error: `The entered number is less than ${option.min_value}. The minimum allowed is ${option.min_value}`,
+                                        fullError: ['NUMBER_MIN_VALUE', option.min_value],
                                     });
                                     break;
                                 }
@@ -338,6 +347,7 @@ async function parseOptions(self, command, message, args, resolved) {
                                     errors.push({
                                         name: i.name,
                                         error: `The entered number is greater than ${option.max_value}. The maximum allowed is ${option.max_value}`,
+                                        fullError: ['NUMBER_MAX_VALUE', option.max_value],
                                     });
                                     break;
                                 }
@@ -352,6 +362,7 @@ async function parseOptions(self, command, message, args, resolved) {
                                 error: `The entered choice is invalid. Please choose one of the following options: ${option.choices
                                     .map(x => x.name)
                                     .join(', ')}.`,
+                                fullError: ['NUMBER_INVALID_CHOICE', option.choices],
                             });
                             break;
                         }
@@ -373,17 +384,20 @@ async function parseOptions(self, command, message, args, resolved) {
                     errors.push({
                         error: 'Option is required but returned undefined',
                         name: i.name,
+                        fullError: ['OPTION_REQUIRED'],
                     });
         }
         catch (e) {
             errors.push({
                 error: e && typeof e === 'object' && 'message' in e ? e.message : `${e}`,
                 name: i.name,
+                fullError: ['UNKNOWN', e],
             });
         }
     }
     return { errors, options };
 }
+exports.defaultOptionsParser = defaultOptionsParser;
 function defaultArgsParser(content) {
     const args = {};
     for (const i of content.match(/-(.*?)(?=\s-|$)/gs) ?? []) {
@@ -391,5 +405,6 @@ function defaultArgsParser(content) {
     }
     return args;
 }
+exports.defaultArgsParser = defaultArgsParser;
 //-(.*?)(?=\s-|$)/gs
 //-(?<text>[^-]*)/gm

package/lib/client/workerclient.d.ts

@@ -14,10 +14,12 @@ import type { WorkerShardInfo } from '../websocket/discord/worker';
 import type { ManagerMessages } from '../websocket/discord/workermanager';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
-import type { Client } from './client';
+import type { Client, ClientOptions } from './client';
+import { Collectors } from './collectors';
 export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
     private __handleGuilds?;
     logger: Logger;
+    collectors: Collectors;
     events?: EventHandler | undefined;
     me: When<Ready, ClientUser>;
     promises: Map<string, {
@@ -48,5 +50,6 @@ interface WorkerClientOptions extends BaseClientOptions {
     disabledCache: Cache['disabledCache'];
     commands?: NonNullable<Client['options']>['commands'];
     handlePayload?: ShardManagerOptions['handlePayload'];
+    gateway?: ClientOptions['gateway'];
 }
 export {};