seyfert 4.4.1 → 5.0.0

package/lib/client/client.d.ts

@@ -1,15 +1,16 @@
 import type { CommandContext, Message } from '..';
 import { type Awaitable, type DeepPartial, type PickPartial, type When } from '../common';
 import { EventHandler } from '../events';
-import type { GatewayDispatchPayload, GatewayPresenceUpdateData } from '../types';
+import { type GatewayDispatchPayload, type GatewayPresenceUpdateData } from '../types';
 import { ShardManager, type ShardManagerOptions } from '../websocket';
 import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
 import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
 import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
 import { BaseClient } from './base';
 import { Collectors } from './collectors';
+import { type AnySeyfertPlugin, type ExtendOf, type RegisteredPluginExtension, type RegisteredPlugins } from './plugins';
 import { type ClientUserStructure, type MessageStructure } from './transformers';
-export declare class Client<Ready extends boolean = boolean> extends BaseClient {
+declare class ClientBase<Ready extends boolean = boolean> extends BaseClient {
     gateway: ShardManager;
     me: When<Ready, ClientUserStructure>;
     options: Omit<ClientOptions, 'commands'> & {
@@ -34,9 +35,25 @@ export declare class Client<Ready extends boolean = boolean> extends BaseClient
         intents?: number;
     }): Promise<void>;
     start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection'>, execute?: boolean): Promise<void>;
-    protected onPacket(shardId: number, packet: GatewayDispatchPayload): Promise<void>;
+    protected onPacket(shardId: number, packet: GatewayDispatchPayload): Promise<GatewayDispatchPayload | null>;
+    private handleGatewaySendPayload;
 }
-export interface ClientOptions extends BaseClientOptions {
+type ClientPluginsOf<TPluginsOrReady extends readonly AnySeyfertPlugin[] | boolean> = TPluginsOrReady extends readonly AnySeyfertPlugin[] ? TPluginsOrReady : RegisteredPlugins;
+type ClientReadyOf<TPluginsOrReady extends readonly AnySeyfertPlugin[] | boolean, Ready extends boolean> = TPluginsOrReady extends boolean ? TPluginsOrReady : Ready;
+type ClientAmbientExtensionOf<TPluginsOrReady extends readonly AnySeyfertPlugin[] | boolean> = TPluginsOrReady extends readonly AnySeyfertPlugin[] ? {} : RegisteredPluginExtension;
+type ClientOptionsOf<TPluginsOrReady extends readonly AnySeyfertPlugin[] | boolean> = TPluginsOrReady extends readonly AnySeyfertPlugin[] ? ClientOptions<TPluginsOrReady> : ClientOptions<RegisteredPlugins>;
+type Materialize<T> = {
+    [K in keyof T]: T[K];
+};
+export type Client<TPluginsOrReady extends readonly AnySeyfertPlugin[] | boolean = RegisteredPlugins, Ready extends boolean = boolean> = ClientBase<ClientReadyOf<TPluginsOrReady, Ready>> & ClientAmbientExtensionOf<TPluginsOrReady> & Materialize<ExtendOf<ClientPluginsOf<TPluginsOrReady>>>;
+type ClientBaseStatics = Omit<typeof ClientBase, 'prototype'>;
+export type ClientConstructor = ClientBaseStatics & {
+    new <TPluginsOrReady extends readonly AnySeyfertPlugin[] | boolean = RegisteredPlugins, Ready extends boolean = boolean>(options?: ClientOptionsOf<TPluginsOrReady>): Client<TPluginsOrReady, Ready>;
+    prototype: Client;
+};
+export declare const Client: ClientConstructor;
+export interface ClientOptions<TPlugins extends readonly AnySeyfertPlugin[] = RegisteredPlugins> extends BaseClientOptions {
+    plugins?: TPlugins;
     presence?: (shardId: number) => GatewayPresenceUpdateData;
     shards?: {
         start: number;
@@ -53,7 +70,15 @@ export interface ClientOptions extends BaseClientOptions {
         reply?: (ctx: CommandContext) => Awaitable<boolean>;
     };
     handlePayload?: ShardManagerOptions['handlePayload'];
+    handleSendPayload?: ShardManagerOptions['handleSendPayload'];
+    /**
+     * @deprecated Use shard disconnect events instead. Injected ShardManager callbacks can double-fire.
+     */
     onShardDisconnect?: ShardManagerOptions['onShardDisconnect'];
+    /**
+     * @deprecated Use shard reconnect events instead. Injected ShardManager callbacks can double-fire.
+     */
     onShardReconnect?: ShardManagerOptions['onShardReconnect'];
     resharding?: PickPartial<NonNullable<ShardManagerOptions['resharding']>, 'getInfo'>;
 }
+export {};

package/lib/client/client.js

@@ -3,14 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
 const common_1 = require("../common");
 const events_1 = require("../events");
+const types_1 = require("../types");
 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 collectors_1 = require("./collectors");
+const plugins_1 = require("./plugins");
 const transformers_1 = require("./transformers");
 let parentPort;
-class Client extends base_1.BaseClient {
+class ClientBase extends base_1.BaseClient {
     gateway;
     me;
     memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
@@ -45,6 +47,8 @@ class Client extends base_1.BaseClient {
                 await oldOnShardReconnect?.(data);
                 await this.onShardReconnect(data);
             };
+            const oldHandleSendPayload = gateway.options.handleSendPayload;
+            gateway.options.handleSendPayload = (shardId, payload) => this.handleGatewaySendPayload(shardId, payload, oldHandleSendPayload);
             this.gateway = gateway;
         }
     }
@@ -61,10 +65,12 @@ class Client extends base_1.BaseClient {
     }
     async loadEvents(dir) {
         dir ??= await this.getRC().then(x => x.locations.events);
+        await (0, plugins_1.runPluginHooks)(this, 'events:beforeLoad', this, dir);
         if (dir) {
             await this.events.load(dir);
             this.logger.info('EventHandler loaded');
         }
+        await (0, plugins_1.runPluginHooks)(this, 'events:afterLoad', this, dir);
     }
     async execute(options = {}) {
         await super.execute(options);
@@ -79,7 +85,9 @@ class Client extends base_1.BaseClient {
                         this.gateway.options.handlePayload(data.shardId, data.payload);
                         break;
                     case 'SEND_TO_SHARD':
-                        this.gateway.send(data.shardId, data.payload);
+                        void this.gateway.send(data.shardId, data.payload).catch(error => {
+                            this.logger.fatal('Watcher failed to send payload to shard', error);
+                        });
                         break;
                 }
             });
@@ -93,10 +101,12 @@ class Client extends base_1.BaseClient {
         await this.loadEvents(options.eventsDir);
         const { token: tokenRC, intents: intentsRC, debug: debugRC } = await this.getRC();
         const token = options?.token ?? tokenRC;
-        const intents = options?.connection?.intents ?? intentsRC;
-        this.cache.intents = intents;
+        const connectionIntents = options?.connection?.intents;
+        const intents = this.resolvePluginGatewayIntents(connectionIntents ?? intentsRC);
         if (!this.gateway) {
-            (0, common_1.assertString)(token, 'token is not a string');
+            if (typeof token !== 'string' || token.length === 0) {
+                throw new common_1.SeyfertError('INVALID_TOKEN', { metadata: { detail: 'token is not a string' } });
+            }
             this.gateway = new websocket_1.ShardManager({
                 token,
                 info: await this.proxy.gateway.bot.get(),
@@ -105,6 +115,7 @@ class Client extends base_1.BaseClient {
                     await this.options?.handlePayload?.(shardId, packet);
                     return this.onPacket(shardId, packet);
                 },
+                handleSendPayload: (shardId, payload) => this.handleGatewaySendPayload(shardId, payload, this.options?.handleSendPayload),
                 onShardDisconnect: this.onShardDisconnect.bind(this),
                 onShardReconnect: this.onShardReconnect.bind(this),
                 presence: this.options?.presence,
@@ -125,13 +136,17 @@ class Client extends base_1.BaseClient {
             });
         }
         if (execute) {
-            await this.execute(options.connection);
+            await this.execute({ ...(options.connection ?? {}), intents });
         }
         else {
             await super.execute(options);
         }
     }
     async onPacket(shardId, packet) {
+        const pluginPacket = await (0, plugins_1.applyPluginGatewayDispatchInterceptors)(this, shardId, packet);
+        if (pluginPacket === null)
+            return null;
+        packet = pluginPacket;
         Promise.allSettled([
             this.events.runEvent('RAW', this, packet, shardId, false),
             this.collectors.run('RAW', packet, this),
@@ -140,7 +155,7 @@ class Client extends base_1.BaseClient {
             case 'GUILD_MEMBER_UPDATE':
                 {
                     if (!this.memberUpdateHandler.check(packet.d)) {
-                        return;
+                        return packet;
                     }
                     await this.events.execute(packet, this, shardId);
                 }
@@ -148,7 +163,7 @@ class Client extends base_1.BaseClient {
             case 'PRESENCE_UPDATE':
                 {
                     if (!this.presenceUpdateHandler.check(packet.d)) {
-                        return;
+                        return packet;
                     }
                     await this.events.execute(packet, this, shardId);
                 }
@@ -156,19 +171,19 @@ class Client extends base_1.BaseClient {
             //rest of the events
             default: {
                 switch (packet.t) {
-                    case 'INTERACTION_CREATE':
+                    case types_1.GatewayDispatchEvents.InteractionCreate:
                         {
                             await this.events.execute(packet, this, shardId);
                             await this.handleCommand.interaction(packet.d, shardId);
                         }
                         break;
-                    case 'MESSAGE_CREATE':
+                    case types_1.GatewayDispatchEvents.MessageCreate:
                         {
                             await this.events.execute(packet, this, shardId);
                             await this.handleCommand.message(packet.d, shardId);
                         }
                         break;
-                    case 'READY': {
+                    case types_1.GatewayDispatchEvents.Ready: {
                         this.botId = packet.d.user.id;
                         this.applicationId = packet.d.application.id;
                         this.me = transformers_1.Transformers.ClientUser(this, packet.d.user, packet.d.application);
@@ -176,7 +191,7 @@ class Client extends base_1.BaseClient {
                         await this.events.execute(packet, this, shardId);
                         break;
                     }
-                    case 'GUILDS_READY':
+                    case types_1.GatewayDispatchEvents.GuildsReady:
                         {
                             await this.events.execute(packet, this, shardId);
                             if ([...this.gateway.values()].every(shard => shard.isReady)) {
@@ -191,6 +206,16 @@ class Client extends base_1.BaseClient {
                 break;
             }
         }
+        return packet;
+    }
+    async handleGatewaySendPayload(shardId, payload, handleSendPayload) {
+        const pluginPayload = await (0, plugins_1.applyPluginGatewaySendPayloadWrappers)(this, shardId, payload);
+        if (pluginPayload === null)
+            return null;
+        const result = await handleSendPayload?.(shardId, pluginPayload);
+        if (result === null)
+            return null;
+        return result ?? pluginPayload;
     }
 }
-exports.Client = Client;
+exports.Client = ClientBase;

package/lib/client/collectors.d.ts

@@ -1,8 +1,9 @@
-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>;
-export type CollectorRunPameters<T extends AllClientEvents> = Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>;
+import { type Awaitable, type CamelCase } from '../common';
+import type { CallbackEventHandler, ClientNameEvents, CustomEventsKeys, GatewayEvents } from '../events';
+export type AllClientEvents = CustomEventsKeys | ClientNameEvents;
+type ClientDispatchEvent = AllClientEvents | GatewayEvents;
+export type ParseClientEventName<T extends ClientDispatchEvent> = T extends GatewayEvents ? CamelCase<T> : T;
+export type CollectorRunParameters<T extends AllClientEvents> = Awaited<Parameters<CallbackEventHandler[ParseClientEventName<T>]>[0]>;
 type RunData<T extends AllClientEvents> = {
     options: {
         event: T;
@@ -10,9 +11,9 @@ type RunData<T extends AllClientEvents> = {
         timeout?: number;
         onStop?: (reason: string) => unknown;
         onStopError?: (reason: string, error: unknown) => unknown;
-        filter: (arg: CollectorRunPameters<T>) => Awaitable<boolean>;
-        run: (arg: CollectorRunPameters<T>, stop: (reason?: string) => void) => unknown;
-        onRunError?: (arg: CollectorRunPameters<T>, error: unknown, stop: (reason?: string) => void) => unknown;
+        filter: (arg: CollectorRunParameters<T>) => Awaitable<boolean>;
+        run: (arg: CollectorRunParameters<T>, stop: (reason?: string) => void) => unknown;
+        onRunError?: (arg: CollectorRunParameters<T>, error: unknown, stop: (reason?: string) => void) => unknown;
     };
     idle?: NodeJS.Timeout;
     timeout?: NodeJS.Timeout;

package/lib/client/collectors.js

@@ -1,71 +1,38 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Collectors = void 0;
 const node_crypto_1 = require("node:crypto");
-const RawEvents = __importStar(require("../events/hooks"));
+const common_1 = require("../common");
+const utils_1 = require("../events/utils");
+function normalizeCollectorEventName(name) {
+    return (name === name.toUpperCase() ? common_1.ReplaceRegex.camel(name.toLowerCase()) : name);
+}
 class Collectors {
     values = new Map();
     generateRandomUUID(name) {
-        const collectors = this.values.get(name);
-        if (!collectors)
+        if (!this.values.has(name))
             return '*';
-        let nonce = (0, node_crypto_1.randomUUID)();
-        while (collectors.find(x => x.nonce === nonce)) {
-            nonce = (0, node_crypto_1.randomUUID)();
-        }
-        return nonce;
+        return (0, node_crypto_1.randomUUID)();
     }
     create(options) {
-        const nonce = this.generateRandomUUID(options.event);
-        if (!this.values.has(options.event)) {
-            this.values.set(options.event, []);
+        const event = options.event;
+        const nonce = this.generateRandomUUID(event);
+        if (!this.values.has(event)) {
+            this.values.set(event, []);
         }
-        this.values.get(options.event).push({
+        this.values.get(event).push({
             options: {
                 ...options,
-                name: options.event,
+                event,
             },
             idle: options.idle && options.idle > 0
                 ? setTimeout(() => {
-                    return this.delete(options.event, nonce, 'idle');
+                    return this.delete(event, nonce, 'idle');
                 }, options.idle)
                 : undefined,
             timeout: options.timeout && options.timeout > 0
                 ? setTimeout(() => {
-                    return this.delete(options.event, nonce, 'timeout');
+                    return this.delete(event, nonce, 'timeout');
                 }, options.timeout)
                 : undefined,
             nonce,
@@ -95,11 +62,12 @@ class Collectors {
     }
     /**@internal */
     async run(name, raw, client) {
-        const collectors = this.values.get(name);
+        const event = normalizeCollectorEventName(name);
+        const collectors = this.values.get(event);
         if (!collectors)
             return;
-        const data = (await RawEvents[name]?.(client, raw)) ?? raw;
-        for (const i of collectors) {
+        const data = (await (0, utils_1.resolveRawEventData)(name, client, raw)) ?? raw;
+        for (const i of [...collectors]) {
             if (await i.options.filter(data)) {
                 i.idle?.refresh();
                 const stop = (reason = 'unknown') => {
@@ -111,7 +79,6 @@ class Collectors {
                 catch (e) {
                     await i.options.onRunError?.(data, e, stop);
                 }
-                break;
             }
         }
     }

package/lib/client/httpclient.d.ts

@@ -1,7 +1,10 @@
 import type { DeepPartial } from '../common';
 import type { BaseClientOptions, StartOptions } from './base';
 import { BaseClient } from './base';
+import type { RegisteredPluginExtension } from './plugins';
 export declare class HttpClient extends BaseClient {
     constructor(options?: BaseClientOptions);
     start(options?: DeepPartial<Omit<StartOptions, 'connection' | 'eventsDir'>>): Promise<void>;
 }
+export interface HttpClient extends RegisteredPluginExtension {
+}

package/lib/client/index.d.ts

@@ -1,5 +1,7 @@
-export type { RuntimeConfig, RuntimeConfigHTTP } from './base';
+export type { BotConfig, ClientMiddlewares, ContextScope, ContextScopeContext, HttpConfig, RuntimeConfig, RuntimeConfigHTTP, } from './base';
 export * from './client';
+export { type AllClientEvents, type CollectorRunParameters, Collectors, type ParseClientEventName } from './collectors';
 export * from './httpclient';
+export * from './plugins';
 export * from './transformers';
 export * from './workerclient';

package/lib/client/index.js

@@ -14,7 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collectors = void 0;
 __exportStar(require("./client"), exports);
+var collectors_1 = require("./collectors");
+Object.defineProperty(exports, "Collectors", { enumerable: true, get: function () { return collectors_1.Collectors; } });
 __exportStar(require("./httpclient"), exports);
+__exportStar(require("./plugins"), exports);
 __exportStar(require("./transformers"), exports);
 __exportStar(require("./workerclient"), exports);

package/lib/client/intents.d.ts

@@ -0,0 +1,3 @@
+import type { IntentStrings } from '../common/types/util';
+export type GatewayIntentInput = number | IntentStrings | number[];
+export declare function resolveGatewayIntents(intents?: GatewayIntentInput): number;

package/lib/client/intents.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGatewayIntents = resolveGatewayIntents;
+const types_1 = require("../types");
+function resolveGatewayIntents(intents) {
+    if (typeof intents === 'number')
+        return intents;
+    return (intents?.reduce((current, intent) => current | (typeof intent === 'number' ? intent : types_1.GatewayIntentBits[intent]), 0) ?? 0);
+}

package/lib/client/plugins/api.d.ts

@@ -0,0 +1,4 @@
+import { type PluginEventContributionScope, type PluginRuntimeRecord, type PluginRuntimeRegistry } from './registry';
+import type { SeyfertPluginApi, SeyfertPluginTeardownApi } from './types';
+export declare function createPluginApi(record: PluginRuntimeRecord, registry: PluginRuntimeRegistry, scope: 'teardown'): SeyfertPluginTeardownApi;
+export declare function createPluginApi(record: PluginRuntimeRecord, registry: PluginRuntimeRegistry, scope?: Exclude<PluginEventContributionScope, 'teardown'>): SeyfertPluginApi;