seyfert 1.0.1 → 1.1.1

package/lib/structures/channels.js

@@ -10,7 +10,6 @@ exports.DirectoryChannel = exports.NewsChannel = exports.CategoryChannel = expor
 const v10_1 = require("discord-api-types/v10");
 const ts_mixer_1 = require("ts-mixer");
 const builders_1 = require("../builders");
-const Webhook_1 = require("./Webhook");
 const DiscordBase_1 = require("./extra/DiscordBase");
 const functions_1 = require("./extra/functions");
 class BaseChannel extends DiscordBase_1.DiscordBase {
@@ -103,13 +102,13 @@ class BaseGuildChannel extends BaseChannel {
         values: () => (this.guildId ? this.client.cache.overwrites?.values(this.guildId) ?? [] : []),
     };
     memberPermissions(member, checkAdmin = true) {
-        return this.client.channels.overwrites.memberPermissions(this.id, member, checkAdmin);
+        return this.client.channels.memberPermissions(this.id, member, checkAdmin);
     }
     rolePermissions(role, checkAdmin = true) {
-        return this.client.channels.overwrites.rolePermissions(this.id, role, checkAdmin);
+        return this.client.channels.rolePermissions(this.id, role, checkAdmin);
     }
     overwritesFor(member) {
-        return this.client.channels.overwrites.overwritesFor(this.id, member);
+        return this.client.channels.overwritesFor(this.id, member);
     }
     guild(force = false) {
         return this.client.guilds.fetch(this.guildId, force);
@@ -147,17 +146,17 @@ class MessagesMethods extends DiscordBase_1.DiscordBase {
     }
     static reactions(ctx) {
         return {
-            add: (messageId, emoji) => ctx.client.messages.reactions.add(messageId, ctx.channelId, emoji),
-            delete: (messageId, emoji, userId = '@me') => ctx.client.messages.reactions.delete(messageId, ctx.channelId, emoji, userId),
-            fetch: (messageId, emoji, query) => ctx.client.messages.reactions.fetch(messageId, ctx.channelId, emoji, query),
-            purge: (messageId, emoji) => ctx.client.messages.reactions.purge(messageId, ctx.channelId, emoji),
+            add: (messageId, emoji) => ctx.client.reactions.add(messageId, ctx.channelId, emoji),
+            delete: (messageId, emoji, userId = '@me') => ctx.client.reactions.delete(messageId, ctx.channelId, emoji, userId),
+            fetch: (messageId, emoji, query) => ctx.client.reactions.fetch(messageId, ctx.channelId, emoji, query),
+            purge: (messageId, emoji) => ctx.client.reactions.purge(messageId, ctx.channelId, emoji),
         };
     }
     static pins(ctx) {
         return {
-            fetch: () => ctx.client.channels.pins.fetch(ctx.channelId),
-            set: (messageId, reason) => ctx.client.channels.pins.set(messageId, ctx.channelId, reason),
-            delete: (messageId, reason) => ctx.client.channels.pins.delete(messageId, ctx.channelId, reason),
+            fetch: () => ctx.client.channels.pins(ctx.channelId),
+            set: (messageId, reason) => ctx.client.channels.setPin(messageId, ctx.channelId, reason),
+            delete: (messageId, reason) => ctx.client.channels.deletePin(messageId, ctx.channelId, reason),
         };
     }
     static transformMessageBody(body) {
@@ -254,10 +253,7 @@ class WebhookGuildMethods extends DiscordBase_1.DiscordBase {
     webhooks = WebhookGuildMethods.guild({ client: this.client, guildId: this.id });
     static guild(ctx) {
         return {
-            list: async () => {
-                const webhooks = await ctx.client.proxy.guilds(ctx.guildId).webhooks.get();
-                return webhooks.map(webhook => new Webhook_1.Webhook(ctx.client, webhook));
-            },
+            list: () => ctx.client.webhooks.listFromChannel(ctx.guildId),
         };
     }
 }
@@ -266,16 +262,8 @@ class WebhookChannelMethods extends DiscordBase_1.DiscordBase {
     webhooks = WebhookChannelMethods.channel({ client: this.client, channelId: this.id });
     static channel(ctx) {
         return {
-            list: async () => {
-                const webhooks = await ctx.client.proxy.channels(ctx.channelId).webhooks.get();
-                return webhooks.map(webhook => new Webhook_1.Webhook(ctx.client, webhook));
-            },
-            create: async (body) => {
-                const webhook = await ctx.client.proxy.channels(ctx.channelId).webhooks.post({
-                    body,
-                });
-                return new Webhook_1.Webhook(ctx.client, webhook);
-            },
+            list: () => ctx.client.webhooks.listFromChannel(ctx.channelId),
+            create: async (body) => ctx.client.webhooks.create(ctx.channelId, body),
         };
     }
 }

package/lib/structures/extra/Base.d.ts

@@ -1,7 +1,6 @@
-import type { BaseClient } from '../../client/base';
 import type { UsingClient } from '../../commands';
 /** */
 export declare abstract class Base {
-    constructor(client: BaseClient);
+    constructor(client: UsingClient);
     readonly client: UsingClient;
 }

package/lib/structures/extra/DiscordBase.d.ts

@@ -1,10 +1,10 @@
-import type { BaseClient } from '../../client/base';
+import type { UsingClient } from '../../commands';
 import { Base } from './Base';
 export declare class DiscordBase<Data extends Record<string, any> = {
     id: string;
 }> extends Base {
     id: string;
-    constructor(client: BaseClient, 
+    constructor(client: UsingClient, 
     /** Unique ID of the object */
     data: Data);
     /**

package/lib/websocket/constants/index.js

@@ -16,6 +16,7 @@ const ShardManagerDefaults = {
     intents: 0,
     properties,
     version: 10,
+    shardStart: 0,
     handlePayload: (shardId, packet) => {
         console.info(`Packet ${packet.t} on shard ${shardId}`);
     },

package/lib/websocket/discord/shard.js

@@ -42,7 +42,9 @@ class Shard {
         });
     }
     get latency() {
-        return this.heart.lastAck && this.heart.lastBeat ? this.heart.lastAck - this.heart.lastBeat : Infinity;
+        return this.heart.lastAck && this.heart.lastBeat
+            ? this.heart.lastAck - this.heart.lastBeat
+            : Number.POSITIVE_INFINITY;
     }
     get isOpen() {
         return this.websocket?.readyState === ws_1.WebSocket.OPEN;
@@ -94,7 +96,7 @@ class Shard {
             d: {
                 token: `Bot ${this.options.token}`,
                 compress: this.options.compress,
-                properties: constants_1.properties,
+                properties: this.options.properties ?? constants_1.properties,
                 shard: [this.id, this.options.info.shards],
                 intents: this.options.intents,
                 presence: this.options.presence,

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

@@ -7,6 +7,9 @@ export declare class ShardManager extends Map<number, Shard> {
     options: ShardManagerOptions;
     debugger?: Logger;
     constructor(options: ShardManagerOptions);
+    get totalShards(): number;
+    get shardStart(): number;
+    get shardEnd(): number;
     get remaining(): number;
     get concurrency(): number;
     get latency(): number;

package/lib/websocket/discord/sharder.js

@@ -23,6 +23,15 @@ class ShardManager extends Map {
             });
         }
     }
+    get totalShards() {
+        return this.options.totalShards ?? this.options.info.shards;
+    }
+    get shardStart() {
+        return this.options.shardStart ?? 0;
+    }
+    get shardEnd() {
+        return this.options.shardEnd ?? this.totalShards;
+    }
     get remaining() {
         return this.options.info.session_start_limit.remaining;
     }
@@ -43,7 +52,7 @@ class ShardManager extends Map {
         shard ??= new shard_js_1.Shard(shardId, {
             token: this.options.token,
             intents: this.options.intents,
-            info: { ...this.options.info, shards: (this.options.shardEnd ?? this.options.totalShards) },
+            info: { ...this.options.info, shards: this.totalShards },
             handlePayload: this.options.handlePayload,
             properties: this.options.properties,
             debugger: this.debugger,
@@ -72,12 +81,10 @@ class ShardManager extends Map {
      */
     spawnBuckets() {
         this.debugger?.info('#0 Preparing buckets');
-        const chunks = structures_1.SequentialBucket.chunk(new Array(this.options.shardStart !== undefined && this.options.shardEnd !== undefined
-            ? this.options.shardEnd - this.options.shardStart
-            : this.options.totalShards), this.concurrency);
+        const chunks = structures_1.SequentialBucket.chunk(new Array(this.shardEnd - this.shardStart), this.concurrency);
         chunks.forEach((arr, index) => {
             for (let i = 0; i < arr.length; i++) {
-                const id = i + (index > 0 ? index * this.concurrency : 0) + (this.options.shardStart ?? 0);
+                const id = i + (index > 0 ? index * this.concurrency : 0) + this.shardStart;
                 chunks[index][i] = this.spawn(id);
             }
         });

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

@@ -30,6 +30,7 @@ export interface ShardManagerOptions extends ShardDetails {
     compress?: boolean;
 }
 export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handlePayload'> {
+    mode: 'threads' | 'clusters';
     workers?: number;
     /**
      * @default 32

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 WorkerStart = CreateWorkerMessage<'WORKER_START'>;
 export type WorkerSendApiRequest = CreateWorkerMessage<'WORKER_API_REQUEST', {
     method: HttpMethods;
     url: `/${string}`;
@@ -55,5 +56,5 @@ export type WorkerSendEval = CreateWorkerMessage<'EVAL', {
     nonce: string;
     toWorkerId: number;
 }>;
-export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerSendApiRequest | WorkerExecuteEval | WorkerSendEvalResponse | WorkerSendEval;
+export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerSendApiRequest | WorkerExecuteEval | WorkerSendEvalResponse | WorkerSendEval | WorkerStart;
 export {};

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

@@ -4,7 +4,9 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { Worker } from 'node:worker_threads';
+/// <reference types="node" />
+import { type Worker as ClusterWorker } from 'node:cluster';
+import { Worker as ThreadWorker } from 'node:worker_threads';
 import { ApiHandler } from '../..';
 import { type Adapter } from '../../cache';
 import { Logger, type GatewayPresenceUpdateData, type GatewaySendPayload, type MakePartial } from '../../common';
@@ -13,7 +15,7 @@ import { MemberUpdateHandler } from './events/memberUpdate';
 import { PresenceUpdateHandler } from './events/presenceUpdate';
 import type { ShardOptions, WorkerData, WorkerManagerOptions } from './shared';
 import type { WorkerInfo, WorkerMessage, WorkerShardInfo } from './worker';
-export declare class WorkerManager extends Map<number, Worker & {
+export declare class WorkerManager extends Map<number, (ClusterWorker | ThreadWorker) & {
     ready?: boolean;
 }> {
     options: Required<WorkerManagerOptions>;
@@ -34,6 +36,8 @@ export declare class WorkerManager extends Map<number, Worker & {
     get concurrency(): number;
     get totalWorkers(): number;
     get totalShards(): number;
+    get shardStart(): number;
+    get shardEnd(): number;
     get shardsPerWorker(): number;
     get workers(): number;
     syncLatency({ shardId, workerId }: {
@@ -43,8 +47,9 @@ export declare class WorkerManager extends Map<number, Worker & {
     calculateShardId(guildId: string): number;
     calculateWorkerId(shardId: number): number;
     prepareSpaces(): number[][];
+    postMessage(id: number, body: any): void;
     prepareWorkers(shards: number[][]): Promise<void>;
-    createWorker(workerData: WorkerData): Worker;
+    createWorker(workerData: WorkerData): ClusterWorker | ThreadWorker;
     spawn(workerId: number, shardId: number): void;
     handleWorkerMessage(message: WorkerMessage): Promise<void>;
     private generateNonce;

package/lib/websocket/discord/workermanager.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkerManager = void 0;
+const node_cluster_1 = __importDefault(require("node:cluster"));
 const node_crypto_1 = require("node:crypto");
 const node_worker_threads_1 = require("node:worker_threads");
 const __1 = require("../..");
@@ -23,7 +27,7 @@ class WorkerManager extends Map {
     rest;
     constructor(options) {
         super();
-        this.options = (0, common_1.MergeOptions)(constants_1.WorkerManagerDefaults, options);
+        this.options = options;
         this.cacheAdapter = new cache_1.MemoryAdapter();
     }
     setCache(adapter) {
@@ -42,7 +46,13 @@ class WorkerManager extends Map {
         return this.options.workers;
     }
     get totalShards() {
-        return this.options.totalShards;
+        return this.options.totalShards ?? this.options.info.shards;
+    }
+    get shardStart() {
+        return this.options.shardStart ?? 0;
+    }
+    get shardEnd() {
+        return this.options.shardEnd ?? this.totalShards;
     }
     get shardsPerWorker() {
         return this.options.shardsPerWorker;
@@ -62,10 +72,10 @@ class WorkerManager extends Map {
         return data.shards.reduce((acc, prv) => acc + prv.latency, 0) / data.shards.length;
     }
     calculateShardId(guildId) {
-        return Number((BigInt(guildId) >> 22n) % BigInt(this.options.info.shards ?? 1));
+        return Number((BigInt(guildId) >> 22n) % BigInt(this.totalShards));
     }
     calculateWorkerId(shardId) {
-        const workerId = Math.floor(shardId / this.shardsPerWorker);
+        const workerId = Math.floor((shardId - this.shardStart) / this.shardsPerWorker);
         if (workerId >= this.workers) {
             throw new Error('Invalid shardId');
         }
@@ -73,18 +83,29 @@ class WorkerManager extends Map {
     }
     prepareSpaces() {
         this.debugger?.info('Preparing buckets');
-        const chunks = structures_1.SequentialBucket.chunk(new Array(this.options.shardStart !== undefined && this.options.shardEnd !== undefined
-            ? this.options.shardEnd - this.options.shardStart
-            : this.options.totalShards), this.options.shardsPerWorker);
+        const chunks = structures_1.SequentialBucket.chunk(new Array(this.shardEnd - this.shardStart), this.options.shardsPerWorker);
         chunks.forEach((shards, index) => {
             for (let i = 0; i < shards.length; i++) {
-                const id = i + (index > 0 ? index * this.options.shardsPerWorker : 0) + (this.options.shardStart ?? 0);
+                const id = i + (index > 0 ? index * this.options.shardsPerWorker : 0) + this.shardStart;
                 chunks[index][i] = id;
             }
         });
         this.debugger?.info(`${chunks.length} buckets created`);
         return chunks;
     }
+    postMessage(id, body) {
+        const worker = this.get(id);
+        if (!worker)
+            return this.debugger?.error(`Worker ${id} doesnt exists.`);
+        switch (this.options.mode) {
+            case 'clusters':
+                worker.send(body);
+                break;
+            case 'threads':
+                worker.postMessage(body);
+                break;
+        }
+    }
     async prepareWorkers(shards) {
         for (let i = 0; i < shards.length; i++) {
             let worker = this.get(i);
@@ -100,18 +121,47 @@ class WorkerManager extends Map {
                 });
                 this.set(i, worker);
             }
-            worker.postMessage({
-                type: 'SPAWN_SHARDS',
-                compress: this.options.compress ?? false,
-                info: this.options.info,
-                properties: this.options.properties,
-            });
+            const listener = (message) => {
+                if (message.type !== 'WORKER_START')
+                    return;
+                worker.removeListener('message', listener);
+                this.postMessage(i, {
+                    type: 'SPAWN_SHARDS',
+                    compress: this.options.compress ?? false,
+                    info: {
+                        ...this.options.info,
+                        shards: this.totalShards,
+                    },
+                    properties: this.options.properties,
+                });
+            };
+            worker.on('message', listener);
         }
     }
     createWorker(workerData) {
-        const worker = new node_worker_threads_1.Worker(workerData.path, { workerData });
-        worker.on('message', data => this.handleWorkerMessage(data));
-        return worker;
+        const env = {
+            SEYFERT_SPAWNING: 'true',
+        };
+        for (const i in workerData) {
+            env[`SEYFERT_WORKER_${i.toUpperCase()}`] = workerData[i];
+        }
+        switch (this.options.mode) {
+            case 'threads': {
+                const worker = new node_worker_threads_1.Worker(workerData.path, {
+                    env,
+                });
+                worker.on('message', data => this.handleWorkerMessage(data));
+                return worker;
+            }
+            case 'clusters': {
+                node_cluster_1.default.setupPrimary({
+                    exec: workerData.path,
+                });
+                const worker = node_cluster_1.default.fork(env);
+                worker.on('message', data => this.handleWorkerMessage(data));
+                return worker;
+            }
+        }
     }
     spawn(workerId, shardId) {
         this.connectQueue.push(() => {
@@ -120,7 +170,7 @@ class WorkerManager extends Map {
                 this.debugger?.fatal("Trying spawn with worker doesn't exist");
                 return;
             }
-            worker.postMessage({
+            this.postMessage(workerId, {
                 type: 'ALLOW_CONNECT',
                 shardId,
                 presence: this.options.presence?.(shardId, workerId),
@@ -140,7 +190,7 @@ class WorkerManager extends Map {
                     }
                     // @ts-expect-error
                     const result = await this.cacheAdapter[message.method](...message.args);
-                    worker.postMessage({
+                    this.postMessage(message.workerId, {
                         type: 'CACHE_RESULT',
                         nonce: message.nonce,
                         result,
@@ -203,7 +253,7 @@ class WorkerManager extends Map {
                 {
                     this.get(message.workerId).ready = true;
                     if ([...this.values()].every(w => w.ready)) {
-                        this.get(this.keys().next().value)?.postMessage({
+                        this.postMessage(this.keys().next().value, {
                             type: 'BOT_READY',
                         });
                         this.forEach(w => {
@@ -215,7 +265,7 @@ class WorkerManager extends Map {
             case 'WORKER_API_REQUEST':
                 {
                     const response = await this.rest.request(message.method, message.url, message.requestOptions);
-                    this.get(message.workerId).postMessage({
+                    this.postMessage(message.workerId, {
                         nonce: message.nonce,
                         response,
                         type: 'API_RESPONSE',
@@ -237,13 +287,13 @@ class WorkerManager extends Map {
             case 'EVAL':
                 {
                     const nonce = this.generateNonce();
-                    this.get(message.toWorkerId).postMessage({
+                    this.postMessage(message.toWorkerId, {
                         nonce,
                         func: message.func,
                         type: 'EXECUTE_EVAL',
                         toWorkerId: message.toWorkerId,
                     });
-                    this.generateSendPromise(nonce, 'Eval timeout').then(val => this.get(message.workerId).postMessage({
+                    this.generateSendPromise(nonce, 'Eval timeout').then(val => this.postMessage(message.workerId, {
                         nonce: message.nonce,
                         response: val,
                         type: 'EVAL_RESPONSE',
@@ -281,7 +331,7 @@ class WorkerManager extends Map {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
         const nonce = this.generateNonce();
-        worker.postMessage({
+        this.postMessage(workerId, {
             type: 'SEND_PAYLOAD',
             shardId,
             nonce,
@@ -296,7 +346,7 @@ class WorkerManager extends Map {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
         const nonce = this.generateNonce(false);
-        worker.postMessage({ shardId, nonce, type: 'SHARD_INFO' });
+        this.postMessage(workerId, { shardId, nonce, type: 'SHARD_INFO' });
         return this.generateSendPromise(nonce, 'Get shard info timeout');
     }
     async getWorkerInfo(workerId) {
@@ -305,7 +355,7 @@ class WorkerManager extends Map {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
         const nonce = this.generateNonce();
-        worker.postMessage({ nonce, type: 'WORKER_INFO' });
+        this.postMessage(workerId, { nonce, type: 'WORKER_INFO' });
         return this.generateSendPromise(nonce, 'Get worker info timeout');
     }
     async start() {
@@ -320,12 +370,10 @@ class WorkerManager extends Map {
             debug: this.options.debug,
         });
         this.options.info ??= await new __1.Router(this.rest).createProxy().gateway.bot.get();
-        this.options.totalShards ??= this.options.info.shards;
+        this.options.shardEnd ??= this.options.totalShards ?? this.options.info.shards;
+        this.options.totalShards ??= this.options.shardEnd;
         this.options = (0, common_1.MergeOptions)(constants_1.WorkerManagerDefaults, this.options);
         this.options.workers ??= Math.ceil(this.options.totalShards / this.options.shardsPerWorker);
-        this.options.info.shards = this.options.totalShards;
-        this.options.shardEnd ??= this.options.totalShards;
-        this.options.shardStart ??= 0;
         this.connectQueue = new timeout_1.ConnectQueue(5.5e3, this.concurrency);
         if (this.options.debug) {
             this.debugger = new common_1.Logger({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "seyfert",
-	"version": "1.0.1",
+	"version": "1.1.1",
 	"description": "The most advanced framework for discord bots",
 	"main": "./lib/index.js",
 	"module": "./lib/index.js",
@@ -18,10 +18,10 @@
 		"check": "biome check --apply --changed --no-errors-on-unmatched ./src"
 	},
 	"author": "MARCROCK22",
-	"license": "ISC",
+	"license": "Apache-2.0",
 	"dependencies": {
 		"chokidar": "^3.6.0",
-		"discord-api-types": "^0.37.73",
+		"discord-api-types": "^0.37.76",
 		"magic-bytes.js": "^1.10.0",
 		"ts-mixer": "^6.0.4",
 		"ws": "^8.16.0"
@@ -34,11 +34,13 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "1.6.0",
-		"@types/node": "^20.11.25",
+		"@commitlint/cli": "^19.2.1",
+		"@commitlint/config-conventional": "^19.1.0",
+		"@types/node": "^20.11.30",
 		"@types/ws": "^8.5.10",
 		"husky": "^9.0.11",
 		"lint-staged": "^15.2.2",
-		"typescript": "^5.4.2"
+		"typescript": "^5.4.3"
 	},
 	"optionalDependencies": {
 		"ioredis": "^5.3.2",
@@ -69,4 +71,4 @@
 			"url": "https://github.com/socram03"
 		}
 	]
-}
+}