seyfert 2.0.0 → 2.1.0

package/lib/websocket/discord/sharder.js

@@ -31,6 +31,64 @@ class ShardManager extends Map {
             if (worker_threads.parentPort)
                 parentPort = worker_threads.parentPort;
         }
+        if (this.options.resharding.interval <= 0)
+            return;
+        setInterval(async () => {
+            this.debugger?.debug('Checking if reshard is needed');
+            const info = await this.options.resharding.getInfo();
+            if (info.shards <= this.totalShards)
+                return this.debugger?.debug('Resharding not needed');
+            //https://github.com/discordeno/discordeno/blob/6a5f446c0651b9fad9f1550ff1857fe7a026426b/packages/gateway/src/manager.ts#L106C8-L106C94
+            const percentage = (info.shards / ((this.totalShards * 2500) / 1000)) * 100;
+            if (percentage < this.options.resharding.percentage)
+                return this.debugger?.debug(`Percentage is not enough to reshard ${percentage}/${this.options.resharding.percentage}`);
+            this.debugger?.info('Starting resharding process');
+            this.connectQueue.concurrency = info.session_start_limit.max_concurrency;
+            this.options.totalShards = info.shards;
+            this.options.info.session_start_limit.max_concurrency = info.session_start_limit.max_concurrency;
+            let shardsConnected = 0;
+            let handlePayload = async (sharder, _, packet) => {
+                if ((packet.t === 'GUILD_CREATE' || packet.t === 'GUILD_DELETE') &&
+                    this.options.resharding.onGuild(packet.d.id)) {
+                    return;
+                }
+                if (packet.t !== 'READY')
+                    return;
+                this.options.resharding.reloadGuilds(packet.d.guilds.map(x => x.id));
+                if (++shardsConnected < info.shards)
+                    return; //waiting for last shard to connect
+                // dont listen more events when all shards are ready
+                handlePayload = async () => { };
+                await this.disconnectAll();
+                this.clear();
+                for (const [id, shard] of sharder) {
+                    shard.options.handlePayload = (shardId, packet) => {
+                        return this.options.handlePayload(shardId, packet);
+                    };
+                    this.set(id, shard);
+                }
+                sharder.clear();
+            };
+            const resharder = new ShardManager({
+                ...this.options,
+                resharding: {
+                    // getInfo mock, we don't need it
+                    getInfo: () => ({}),
+                    interval: 0,
+                    percentage: 0,
+                    reloadGuilds() { },
+                    onGuild() {
+                        return true;
+                    },
+                },
+                handlePayload: (shardId, packet) => {
+                    return handlePayload(resharder, shardId, packet);
+                },
+            });
+            // share ratelimit
+            resharder.connectQueue = this.connectQueue;
+            await resharder.spawnShards();
+        }, this.options.resharding.interval);
     }
     get totalShards() {
         return this.options.totalShards ?? this.options.info.shards;
@@ -53,7 +111,7 @@ class ShardManager extends Map {
         return acc / this.size;
     }
     calculateShardId(guildId) {
-        return Number((BigInt(guildId) >> 22n) % BigInt(this.options.info.shards ?? 1));
+        return (0, common_1.calculateShardId)(guildId, this.totalShards);
     }
     spawn(shardId) {
         this.debugger?.info(`Spawn shard ${shardId}`);

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

@@ -29,6 +29,26 @@ export interface ShardManagerOptions extends ShardDetails {
      */
     presence?: (shardId: number, workerId: number) => GatewayPresenceUpdateData;
     compress?: boolean;
+    resharding?: {
+        /**
+         * @returns the gateway connection info
+         */
+        getInfo(): Promise<APIGatewayBotInfo>;
+        interval: number;
+        percentage: number;
+        /**
+         *
+         * @param ids
+         * @returns
+         */
+        reloadGuilds: (ids: string[]) => unknown;
+        /**
+         *
+         * @param id
+         * @returns true if deleted
+         */
+        onGuild: (id: string) => boolean;
+    };
 }
 export interface CustomManagerAdapter {
     postMessage(workerId: number, body: unknown): Awaitable<unknown>;
@@ -39,7 +59,7 @@ export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handleP
     adapter?: CustomManagerAdapter;
     workers?: number;
     /**
-     * @default 32
+     * @default 16
      */
     shardsPerWorker?: number;
     workerProxy?: boolean;

package/lib/websocket/discord/socket/custom.d.ts

@@ -19,7 +19,7 @@ export declare class SeyfertWebSocket {
     private connect;
     handleReadable(): void;
     handleEvent(body: Buffer, opcode: number): void;
-    handleClose(): void;
+    handleClose(): Promise<void>;
     send(data: string): void;
     private _write;
     onping(_data: string): void;

package/lib/websocket/discord/socket/custom.js

@@ -18,38 +18,51 @@ class SeyfertWebSocket {
         this.path = `${urlParts.pathname}${urlParts.search || ''}`;
         this.connect();
     }
-    connect() {
-        const key = (0, node_crypto_1.randomBytes)(16).toString('base64');
-        const req = (0, node_https_1.request)({
-            //discord gateway hostname
-            hostname: this.hostname,
-            path: this.path,
-            headers: {
-                Connection: 'Upgrade',
-                Upgrade: 'websocket',
-                'Sec-WebSocket-Key': key,
-                'Sec-WebSocket-Version': '13',
-            },
-        });
-        req.on('upgrade', (res, socket) => {
-            const hash = (0, node_crypto_1.createHash)('sha1').update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest('base64');
-            const accept = res.headers['sec-websocket-accept'];
-            if (accept !== hash) {
-                socket.end(() => {
-                    this.onerror(new Error('Invalid sec-websocket-accept header'));
-                });
-                return;
-            }
-            this.socket = socket;
-            socket.on('readable', this.handleReadable.bind(this));
-            socket.on('close', this.handleClose.bind(this));
-            socket.on('error', err => this.onerror(err));
-            this.onopen();
-        });
-        req.on('close', () => {
-            req.removeAllListeners();
+    connect(retries = 0) {
+        return new Promise((resolve, rej) => {
+            const key = (0, node_crypto_1.randomBytes)(16).toString('base64');
+            const req = (0, node_https_1.request)({
+                //discord gateway hostname
+                hostname: this.hostname,
+                path: this.path,
+                headers: {
+                    Connection: 'Upgrade',
+                    Upgrade: 'websocket',
+                    'Sec-WebSocket-Key': key,
+                    'Sec-WebSocket-Version': '13',
+                },
+            });
+            req.on('upgrade', (res, socket) => {
+                const hash = (0, node_crypto_1.createHash)('sha1').update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest('base64');
+                const accept = res.headers['sec-websocket-accept'];
+                if (accept !== hash) {
+                    socket.end(() => {
+                        rej(new Error('Invalid sec-websocket-accept header'));
+                    });
+                    return;
+                }
+                this.socket = socket;
+                socket.on('readable', this.handleReadable.bind(this));
+                socket.on('close', this.handleClose.bind(this));
+                socket.on('error', err => this.onerror(err));
+                resolve();
+                this.onopen();
+            });
+            req.on('close', () => {
+                req.removeAllListeners();
+            });
+            req.on('error', e => {
+                if (retries < 5) {
+                    setTimeout(() => {
+                        resolve(this.connect(retries + 1));
+                    }, 500);
+                }
+                else {
+                    rej(e);
+                }
+            });
+            req.end();
         });
-        req.end();
     }
     handleReadable() {
         // Keep reading until no data, this is useful when two payloads merges.
@@ -66,9 +79,11 @@ class SeyfertWebSocket {
                 // Equivalent to readUint32BE
                 length = this.readBytes(2, slice - 2);
             }
+            const payloadLength = slice + length;
             // Read the frame, ignore data next to it, leave it to next `while` cycle
-            const frame = this.socket.read(slice + length);
-            if (!frame)
+            const frame = this.socket.read(payloadLength);
+            // unfinished object when socket closes while reading the data
+            if (!frame || frame.length !== payloadLength)
                 return;
             // Get fin (0 | 1)
             const fin = frame[0] >> 7;
@@ -131,7 +146,7 @@ class SeyfertWebSocket {
                 break;
         }
     }
-    handleClose() {
+    async handleClose() {
         this.socket?.removeAllListeners();
         this.socket?.destroy();
         this.socket = undefined;
@@ -146,6 +161,8 @@ class SeyfertWebSocket {
         this._write(Buffer.from(data), 1);
     }
     _write(buffer, opcode) {
+        if (!this.socket?.writable)
+            return;
         const length = buffer.length;
         let frame;
         // Kinda same logic as above, but client-side

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

@@ -35,6 +35,7 @@ export type WorkerSendInfo = CreateWorkerMessage<'WORKER_INFO', WorkerInfo & {
     nonce: string;
 }>;
 export type WorkerReady = CreateWorkerMessage<'WORKER_READY'>;
+export type WorkerShardsConnected = CreateWorkerMessage<'WORKER_SHARDS_CONNECTED'>;
 export type WorkerStart = CreateWorkerMessage<'WORKER_START'>;
 export type WorkerSendApiRequest = CreateWorkerMessage<'WORKER_API_REQUEST', {
     method: HttpMethods;
@@ -51,5 +52,5 @@ export type WorkerSendEval = CreateWorkerMessage<'EVAL', {
     nonce: string;
     toWorkerId: number;
 }>;
-export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerSendApiRequest | WorkerSendEvalResponse | WorkerSendEval | WorkerStart;
+export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerShardsConnected | WorkerSendApiRequest | WorkerSendEvalResponse | WorkerSendEval | WorkerStart;
 export {};

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

@@ -14,6 +14,7 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | import('
     options: MakePartial<Required<WorkerManagerOptions>, 'adapter'>;
     debugger?: Logger;
     connectQueue: ConnectQueue;
+    workerQueue: (() => void)[];
     cacheAdapter: Adapter;
     promises: Map<string, {
         resolve: (value: any) => void;
@@ -50,7 +51,7 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | import('
     send(data: GatewaySendPayload, shardId: number): Promise<true>;
     getShardInfo(shardId: number): Promise<WorkerShardInfo>;
     getWorkerInfo(workerId: number): Promise<WorkerInfo>;
-    start(): Promise<void>;
+    start(): Promise<void | undefined>;
 }
 type CreateManagerMessage<T extends string, D extends object = {}> = {
     type: T;

package/lib/websocket/discord/workermanager.js

@@ -17,6 +17,7 @@ class WorkerManager extends Map {
     options;
     debugger;
     connectQueue;
+    workerQueue = [];
     cacheAdapter;
     promises = new Map();
     rest;
@@ -109,20 +110,22 @@ class WorkerManager extends Map {
         if (!worker_threads)
             throw new Error('Cannot prepare workers without worker_threads.');
         for (let i = 0; i < shards.length; i++) {
-            let worker = this.get(i);
-            if (!worker) {
-                worker = this.createWorker({
-                    path: this.options.path,
-                    debug: this.options.debug,
-                    token: this.options.token,
-                    shards: shards[i],
-                    intents: this.options.intents,
-                    workerId: i,
-                    workerProxy: this.options.workerProxy,
-                    totalShards: this.totalShards,
-                    mode: this.options.mode,
+            const workerExists = this.has(i);
+            if (!workerExists) {
+                this.workerQueue.push(() => {
+                    const worker = this.createWorker({
+                        path: this.options.path,
+                        debug: this.options.debug,
+                        token: this.options.token,
+                        shards: shards[i],
+                        intents: this.options.intents,
+                        workerId: i,
+                        workerProxy: this.options.workerProxy,
+                        totalShards: this.totalShards,
+                        mode: this.options.mode,
+                    });
+                    this.set(i, worker);
                 });
-                this.set(i, worker);
             }
         }
     }
@@ -260,6 +263,18 @@ class WorkerManager extends Map {
                     }
                 }
                 break;
+            case 'WORKER_SHARDS_CONNECTED':
+                {
+                    const nextWorker = this.workerQueue.shift();
+                    if (nextWorker) {
+                        this.debugger?.info('Spawning next worker');
+                        nextWorker();
+                    }
+                    else {
+                        this.debugger?.info('No more workers to spawn left');
+                    }
+                }
+                break;
             case 'WORKER_API_REQUEST':
                 {
                     const response = await this.rest.request(message.method, message.url, message.requestOptions);
@@ -377,6 +392,8 @@ class WorkerManager extends Map {
         }
         const spaces = this.prepareSpaces();
         await this.prepareWorkers(spaces);
+        // Start workers queue
+        return this.workerQueue.shift()?.();
     }
 }
 exports.WorkerManager = WorkerManager;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "seyfert",
-	"version": "2.0.0",
+	"version": "2.1.0",
 	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",
@@ -18,7 +18,7 @@
 		"check": "biome check --write --no-errors-on-unmatched ./src"
 	},
 	"author": "MARCROCK22",
-	"license": "Apache-2.0",
+	"license": "MIT",
 	"devDependencies": {
 		"@biomejs/biome": "1.8.3",
 		"@commitlint/cli": "^19.4.0",
@@ -61,5 +61,10 @@
 			"name": "David",
 			"url": "https://github.com/Drylozu"
 		}
-	]
+	],
+	"lint-staged": {
+		"*.ts": [
+			"biome check --write"
+		]
+	}
 }