seyfert 0.1.0 → 1.0.1

package/lib/client/client.js

@@ -2,14 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
 const node_worker_threads_1 = require("node:worker_threads");
+const common_1 = require("../common");
 const events_1 = require("../events");
 const structures_1 = require("../structures");
 const websocket_1 = require("../websocket");
 const memberUpdate_1 = require("../websocket/discord/events/memberUpdate");
 const presenceUpdate_1 = require("../websocket/discord/events/presenceUpdate");
 const base_1 = require("./base");
-const oninteraction_1 = require("./oninteraction");
+const oninteractioncreate_1 = require("./oninteractioncreate");
+const onmessagecreate_1 = require("./onmessagecreate");
 class Client extends base_1.BaseClient {
+    __handleGuilds = new Set();
     gateway;
     events = new events_1.EventHandler(this.logger);
     me;
@@ -67,13 +70,14 @@ class Client extends base_1.BaseClient {
                 token,
                 info: await this.proxy.gateway.bot.get(),
                 intents,
-                handlePayload: (shardId, packet) => {
+                handlePayload: async (shardId, packet) => {
+                    await this.options?.handlePayload?.(shardId, packet);
                     return this.onPacket(shardId, packet);
                 },
                 presence: this.options?.presence,
                 debug: debugRC,
-                shardStart: this.options?.shardStart,
-                shardEnd: this.options?.shardEnd,
+                shardStart: this.options?.shards?.start,
+                shardEnd: this.options?.shards?.end,
             });
         }
         this.cache.intents = this.gateway.options.intents;
@@ -85,6 +89,7 @@ class Client extends base_1.BaseClient {
         }
     }
     async onPacket(shardId, packet) {
+        await this.events.runEvent('RAW', this, packet, shardId);
         switch (packet.t) {
             //// Cases where we must obtain the old data before updating
             case 'GUILD_MEMBER_UPDATE':
@@ -101,47 +106,40 @@ class Client extends base_1.BaseClient {
                 await this.events.execute(packet.t, packet, this, shardId);
                 await this.cache.onPacket(packet);
                 break;
-            case 'GUILD_DELETE':
-            case 'CHANNEL_UPDATE': {
-                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);
                 switch (packet.t) {
+                    case 'INTERACTION_CREATE':
+                        await (0, oninteractioncreate_1.onInteractionCreate)(this, packet.d, shardId);
+                        break;
+                    case 'MESSAGE_CREATE':
+                        await (0, onmessagecreate_1.onMessageCreate)(this, packet.d, shardId);
+                        break;
                     case 'READY':
                         for (const g of packet.d.guilds) {
-                            this.__handleGuilds.add(g.id);
+                            this.__handleGuilds?.add(g.id);
                         }
                         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) {
-                            if ([...this.gateway.values()].every(shard => shard.data.session_id) &&
-                                this.events.values.BOT_READY &&
-                                (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
-                                this.events.values.BOT_READY.fired = true;
-                                await this.events.values.BOT_READY.run(this.me, this, -1);
+                        if (!this.__handleGuilds?.size ||
+                            !((this.gateway.options.intents & common_1.GatewayIntentBits.Guilds) === common_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 'INTERACTION_CREATE': {
-                        await (0, oninteraction_1.onInteraction)(shardId, packet.d, this);
-                        break;
-                    }
                     case 'GUILD_CREATE': {
-                        if (this.__handleGuilds.has(packet.d.id)) {
+                        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) &&
-                                this.events.values.BOT_READY &&
-                                (this.events.values.BOT_READY.fired ? !this.events.values.BOT_READY.data.once : true)) {
-                                this.events.values.BOT_READY.fired = true;
-                                await this.events.values.BOT_READY.run(this.me, this, -1);
+                            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;

package/lib/client/httpclient.d.ts

@@ -1,14 +1,13 @@
 /// <reference types="node" />
 import type { HttpRequest, HttpResponse } from 'uWebSockets.js';
 import type { APIInteraction, DeepPartial } from '../common';
-import type { StartOptions } from './base';
+import type { BaseClientOptions, StartOptions } from './base';
 import { BaseClient } from './base';
-declare let UWS: typeof import('uWebSockets.js');
 export declare class HttpClient extends BaseClient {
-    app: ReturnType<typeof UWS.App>;
+    app: ReturnType<typeof import('uWebSockets.js').App>;
     publicKey: string;
     publicKeyHex: Buffer;
-    constructor();
+    constructor(options?: BaseClientOptions);
     protected static readJson<T extends Record<string, any>>(res: HttpResponse): Promise<T>;
     protected execute(options?: {
         publicKey?: string;
@@ -18,4 +17,3 @@ export declare class HttpClient extends BaseClient {
     protected verifySignature(res: HttpResponse, req: HttpRequest): Promise<APIInteraction | undefined>;
     onPacket(res: HttpResponse, req: HttpRequest): Promise<void>;
 }
-export {};

package/lib/client/httpclient.js

@@ -1,13 +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.HttpClient = void 0;
-const form_data_1 = __importDefault(require("form-data"));
+const magic_bytes_js_1 = require("magic-bytes.js");
+const api_1 = require("../api");
+const utils_1 = require("../api/utils/utils");
 const common_1 = require("../common");
 const base_1 = require("./base");
-const oninteraction_1 = require("./oninteraction");
+const oninteractioncreate_1 = require("./oninteractioncreate");
 let UWS;
 let nacl;
 try {
@@ -26,8 +25,8 @@ class HttpClient extends base_1.BaseClient {
     app;
     publicKey;
     publicKeyHex;
-    constructor() {
-        super();
+    constructor(options) {
+        super(options);
         if (!UWS) {
             throw new Error('No uws installed.');
         }
@@ -88,9 +87,9 @@ class HttpClient extends base_1.BaseClient {
     }
     // https://discord.com/developers/docs/interactions/receiving-and-responding#security-and-authorization
     async verifySignature(res, req) {
-        const body = await HttpClient.readJson(res);
         const timestamp = req.getHeader('x-signature-timestamp');
         const ed25519 = req.getHeader('x-signature-ed25519');
+        const body = await HttpClient.readJson(res);
         if (nacl.sign.detached.verify(Buffer.from(timestamp + JSON.stringify(body)), Buffer.from(ed25519, 'hex'), this.publicKeyHex)) {
             return body;
         }
@@ -112,19 +111,33 @@ class HttpClient extends base_1.BaseClient {
                         .end(JSON.stringify({ type: common_1.InteractionResponseType.Pong }));
                     break;
                 default:
-                    await (0, oninteraction_1.onInteraction)(-1, rawBody, this, async ({ body, files }) => {
+                    await (0, oninteractioncreate_1.onInteractionCreate)(this, rawBody, -1, async ({ body, files }) => {
                         let response;
-                        let headers = {};
-                        if (files?.length) {
-                            response = new form_data_1.default();
-                            for (const key in files) {
-                                const file = files[key];
-                                response.append(key, file.data, file);
+                        const headers = {};
+                        if (files) {
+                            response = new FormData();
+                            for (const [index, file] of files.entries()) {
+                                const fileKey = file.key ?? `files[${index}]`;
+                                if ((0, utils_1.isBufferLike)(file.data)) {
+                                    let contentType = file.contentType;
+                                    if (!contentType) {
+                                        const [parsedType] = (0, magic_bytes_js_1.filetypeinfo)(file.data);
+                                        if (parsedType) {
+                                            contentType =
+                                                api_1.OverwrittenMimeTypes[parsedType.mime] ??
+                                                    parsedType.mime ??
+                                                    'application/octet-stream';
+                                        }
+                                    }
+                                    response.append(fileKey, new Blob([file.data], { type: contentType }), file.name);
+                                }
+                                else {
+                                    response.append(fileKey, new Blob([`${file.data}`], { type: file.contentType }), file.name);
+                                }
                             }
                             if (body) {
                                 response.append('payload_json', JSON.stringify(body));
                             }
-                            headers = Object.assign(headers, response.getHeaders());
                         }
                         else {
                             response = body ?? {};

package/lib/client/{oninteraction.d.ts → oninteractioncreate.d.ts}

@@ -1,4 +1,4 @@
 import { type APIInteraction } from 'discord-api-types/v10';
 import type { __InternalReplyFunction } from '../structures';
 import type { BaseClient } from './base';
-export declare function onInteraction(shardId: number, body: APIInteraction, self: BaseClient, __reply?: __InternalReplyFunction): Promise<any>;
+export declare function onInteractionCreate(self: BaseClient, body: APIInteraction, shardId: number, __reply?: __InternalReplyFunction): Promise<any>;

package/lib/client/{oninteraction.js → oninteractioncreate.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.onInteraction = void 0;
+exports.onInteractionCreate = void 0;
 const v10_1 = require("discord-api-types/v10");
 const commands_1 = require("../commands");
 const structures_1 = require("../structures");
-async function onInteraction(shardId, body, self, __reply) {
+async function onInteractionCreate(self, body, shardId, __reply) {
     self.debugger?.debug(`[${v10_1.InteractionType[body.type] ?? body.type}] Interaction received.`);
     switch (body.type) {
         case v10_1.InteractionType.ApplicationCommandAutocomplete:
@@ -26,13 +26,14 @@ async function onInteraction(shardId, body, self, __reply) {
                         await command.autocomplete(interaction);
                     }
                     catch (error) {
-                        self.logger.error(`${optionsResolver.fullCommandName} ${command.name} just threw an error, ${error ? (typeof error === 'object' && 'message' in error ? error.message : error) : 'Unknown'}`);
-                        await command.onAutocompleteError?.(interaction, error);
+                        if (!command.onAutocompleteError)
+                            return self.logger.error(`${optionsResolver.fullCommandName} ${command.name} just threw an error, ${error ? (typeof error === 'object' && 'message' in error ? error.message : error) : 'Unknown'}`);
+                        await command.onAutocompleteError(interaction, error);
                     }
                 }
                 catch (error) {
                     try {
-                        await optionsResolver.getCommand()?.onInternalError(self, error);
+                        await optionsResolver.getCommand()?.onInternalError?.(self, error);
                     }
                     catch {
                         // supress error
@@ -60,26 +61,31 @@ async function onInteraction(shardId, body, self, __reply) {
                             const extendContext = self.options?.context?.(interaction) ?? {};
                             Object.assign(context, extendContext);
                             try {
+                                if (command.botPermissions && interaction.appPermissions) {
+                                    const permissions = interaction.appPermissions.missings(...interaction.appPermissions.values(command.botPermissions));
+                                    if (permissions.length) {
+                                        return command.onPermissionsFail?.(context, interaction.appPermissions.keys(permissions));
+                                    }
+                                }
                                 const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
-                                if (resultRunGlobalMiddlewares === 'pass') {
+                                if (resultRunGlobalMiddlewares.pass) {
                                     return;
                                 }
-                                if (resultRunGlobalMiddlewares) {
-                                    return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares);
+                                if ('error' in resultRunGlobalMiddlewares) {
+                                    return command.onMiddlewaresError(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
                                 }
                                 const resultRunMiddlewares = await command.__runMiddlewares(context);
-                                if (resultRunMiddlewares === 'pass') {
+                                if (resultRunMiddlewares.pass) {
                                     return;
                                 }
-                                if (resultRunGlobalMiddlewares) {
-                                    return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares);
+                                if ('error' in resultRunMiddlewares) {
+                                    return command.onMiddlewaresError(context, resultRunMiddlewares.error ?? 'Unknown error');
                                 }
                                 try {
                                     await command.run(context);
                                     await command.onAfterRun?.(context, undefined);
                                 }
                                 catch (error) {
-                                    self.logger.error(`${command.name} just threw an error, ${error ? (typeof error === 'object' && 'message' in error ? error.message : error) : 'Unknown'}`);
                                     await command.onRunError?.(context, error);
                                     await command.onAfterRun?.(context, error);
                                 }
@@ -112,37 +118,42 @@ async function onInteraction(shardId, body, self, __reply) {
                             const extendContext = self.options?.context?.(interaction) ?? {};
                             Object.assign(context, extendContext);
                             try {
+                                if (command.botPermissions && interaction.appPermissions) {
+                                    const permissions = interaction.appPermissions.missings(...interaction.appPermissions.values(command.botPermissions));
+                                    if (permissions.length) {
+                                        return command.onPermissionsFail?.(context, interaction.appPermissions.keys(permissions));
+                                    }
+                                }
                                 const [erroredOptions, result] = await command.__runOptions(context, optionsResolver);
                                 if (erroredOptions) {
                                     return command.onOptionsError?.(context, result);
                                 }
                                 const resultRunGlobalMiddlewares = await command.__runGlobalMiddlewares(context);
-                                if (resultRunGlobalMiddlewares === 'pass') {
+                                if (resultRunGlobalMiddlewares.pass) {
                                     return;
                                 }
-                                if (resultRunGlobalMiddlewares) {
-                                    return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares);
+                                if ('error' in resultRunGlobalMiddlewares) {
+                                    return command.onMiddlewaresError?.(context, resultRunGlobalMiddlewares.error ?? 'Unknown error');
                                 }
                                 const resultRunMiddlewares = await command.__runMiddlewares(context);
-                                if (resultRunMiddlewares === 'pass') {
+                                if (resultRunMiddlewares.pass) {
                                     return;
                                 }
-                                if (resultRunMiddlewares) {
-                                    return command.onMiddlewaresError?.(context, resultRunMiddlewares);
+                                if ('error' in resultRunMiddlewares) {
+                                    return command.onMiddlewaresError?.(context, resultRunMiddlewares.error ?? 'Unknown error');
                                 }
                                 try {
                                     await command.run(context);
                                     await command.onAfterRun?.(context, undefined);
                                 }
                                 catch (error) {
-                                    self.logger.error(`${optionsResolver.fullCommandName} just threw an error, ${error ? (typeof error === 'object' && 'message' in error ? error.message : error) : 'Unknown'}`);
                                     await command.onRunError?.(context, error);
                                     await command.onAfterRun?.(context, error);
                                 }
                             }
                             catch (error) {
                                 try {
-                                    await command.onInternalError(self, error);
+                                    await command.onInternalError?.(self, error);
                                 }
                                 catch {
                                     // supress error
@@ -167,8 +178,8 @@ async function onInteraction(shardId, body, self, __reply) {
         case v10_1.InteractionType.MessageComponent:
             {
                 const interaction = structures_1.BaseInteraction.from(self, body, __reply);
-                if (self.components.hasComponent(body.message.interaction.id, interaction.customId)) {
-                    await self.components.onComponent(body.message.interaction.id, interaction);
+                if (self.components.hasComponent(body.message.id, interaction.customId)) {
+                    await self.components.onComponent(body.message.id, interaction);
                 }
                 else {
                     await self.components.executeComponent(interaction);
@@ -177,4 +188,4 @@ async function onInteraction(shardId, body, self, __reply) {
             break;
     }
 }
-exports.onInteraction = onInteraction;
+exports.onInteractionCreate = onInteractionCreate;

package/lib/client/onmessagecreate.d.ts

@@ -0,0 +1,3 @@
+import { type GatewayMessageCreateDispatchData } from 'discord-api-types/v10';
+import { type Client, type WorkerClient } from '..';
+export declare function onMessageCreate(self: Client | WorkerClient, rawMessage: GatewayMessageCreateDispatchData, shardId: number): Promise<any>;