seyfert 1.5.0 → 2.1.0

package/lib/websocket/discord/workermanager.js

@@ -13,16 +13,13 @@ const common_1 = require("../../common");
 const constants_1 = require("../constants");
 const structures_1 = require("../structures");
 const timeout_1 = require("../structures/timeout");
-const memberUpdate_1 = require("./events/memberUpdate");
-const presenceUpdate_1 = require("./events/presenceUpdate");
 class WorkerManager extends Map {
     options;
     debugger;
     connectQueue;
+    workerQueue = [];
     cacheAdapter;
     promises = new Map();
-    memberUpdateHandler = new memberUpdate_1.MemberUpdateHandler();
-    presenceUpdateHandler = new presenceUpdate_1.PresenceUpdateHandler();
     rest;
     constructor(options) {
         super();
@@ -103,38 +100,33 @@ class WorkerManager extends Map {
             case 'threads':
                 worker.postMessage(body);
                 break;
+            case 'custom':
+                this.options.adapter.postMessage(id, body);
+                break;
         }
     }
     async prepareWorkers(shards) {
+        const worker_threads = (0, common_1.lazyLoadPackage)('node:worker_threads');
+        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,
+            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);
             }
-            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) {
@@ -163,11 +155,16 @@ class WorkerManager extends Map {
                 worker.on('message', data => this.handleWorkerMessage(data));
                 return worker;
             }
+            case 'custom':
+                this.options.adapter.spawn(workerData, env);
+                return {
+                    ready: false,
+                };
         }
     }
     spawn(workerId, shardId) {
         this.connectQueue.push(() => {
-            const worker = this.get(workerId);
+            const worker = this.has(workerId);
             if (!worker) {
                 this.debugger?.fatal("Trying spawn with worker doesn't exist");
                 return;
@@ -181,12 +178,28 @@ class WorkerManager extends Map {
     }
     async handleWorkerMessage(message) {
         switch (message.type) {
+            case 'WORKER_START':
+                {
+                    this.postMessage(message.workerId, {
+                        type: 'SPAWN_SHARDS',
+                        compress: this.options.compress ?? false,
+                        info: {
+                            ...this.options.info,
+                            shards: this.totalShards,
+                        },
+                        properties: {
+                            ...constants_1.properties,
+                            ...this.options.properties,
+                        },
+                    });
+                }
+                break;
             case 'CONNECT_QUEUE':
                 this.spawn(message.workerId, message.shardId);
                 break;
             case 'CACHE_REQUEST':
                 {
-                    const worker = this.get(message.workerId);
+                    const worker = this.has(message.workerId);
                     if (!worker) {
                         throw new Error('Invalid request from unavailable worker');
                     }
@@ -200,21 +213,7 @@ class WorkerManager extends Map {
                 }
                 break;
             case 'RECEIVE_PAYLOAD':
-                {
-                    switch (message.payload.t) {
-                        case 'GUILD_MEMBER_UPDATE':
-                            if (!this.memberUpdateHandler.check(message.payload.d)) {
-                                return;
-                            }
-                            break;
-                        case 'PRESENCE_UPDATE':
-                            if (!this.presenceUpdateHandler.check(message.payload.d)) {
-                                return;
-                            }
-                            break;
-                    }
-                    this.options.handlePayload(message.shardId, message.workerId, message.payload);
-                }
+                await this.options.handlePayload(message.shardId, message.workerId, message.payload);
                 break;
             case 'RESULT_PAYLOAD':
                 {
@@ -264,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);
@@ -322,7 +333,7 @@ class WorkerManager extends Map {
     }
     async send(data, shardId) {
         const workerId = this.calculateWorkerId(shardId);
-        const worker = this.get(workerId);
+        const worker = this.has(workerId);
         if (!worker) {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
@@ -337,7 +348,7 @@ class WorkerManager extends Map {
     }
     async getShardInfo(shardId) {
         const workerId = this.calculateWorkerId(shardId);
-        const worker = this.get(workerId);
+        const worker = this.has(workerId);
         if (!worker) {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
@@ -346,7 +357,7 @@ class WorkerManager extends Map {
         return this.generateSendPromise(nonce, 'Get shard info timeout');
     }
     async getWorkerInfo(workerId) {
-        const worker = this.get(workerId);
+        const worker = this.has(workerId);
         if (!worker) {
             throw new Error(`Worker #${workerId} doesnt exist`);
         }
@@ -381,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/lib/websocket/structures/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { type Logger } from '../../common';
 /**
  * options of the dynamic bucket

package/lib/websocket/structures/index.js

@@ -62,7 +62,7 @@ class DynamicBucket {
     acquire(force = false) {
         return new Promise(res => {
             this.queue[force ? 'unshift' : 'push'](res);
-            void this.processQueue();
+            this.processQueue();
         });
     }
     static chunk(array, chunks) {

package/lib/websocket/structures/timeout.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 export declare class ConnectTimeout {
     intervalTime: number;
     readonly promises: ((x: boolean) => any)[];

package/package.json

@@ -1,74 +1,70 @@
-{
-	"name": "seyfert",
-	"version": "1.5.0",
-	"description": "The most advanced framework for discord bots",
-	"main": "./lib/index.js",
-	"module": "./lib/index.js",
-	"types": "./lib/index.d.ts",
-	"files": [
-		"lib/**"
-	],
-	"scripts": {
-		"build": "tsc --outDir ./lib",
-		"prepublishOnly": "npm run build",
-		"prepare": "npm run build && husky install",
-		"lint": "biome lint --apply ./src",
-		"format": "biome format --write ./src",
-		"check-h": "biome check --apply ./src",
-		"check": "biome check --apply --no-errors-on-unmatched ./src"
-	},
-	"author": "MARCROCK22",
-	"license": "Apache-2.0",
-	"dependencies": {
-		"chokidar": "^3.6.0",
-		"discord-api-types": "^0.37.86",
-		"magic-bytes.js": "^1.10.0",
-		"ts-mixer": "^6.0.4",
-		"ws": "^8.17.0"
-	},
-	"lint-staged": {
-		"*.ts": [
-			"biome check --apply",
-			"biome format --write"
-		]
-	},
-	"devDependencies": {
-		"@biomejs/biome": "1.7.3",
-		"@commitlint/cli": "^19.3.0",
-		"@commitlint/config-conventional": "^19.2.2",
-		"@types/node": "^20.12.12",
-		"@types/ws": "^8.5.10",
-		"husky": "^9.0.11",
-		"lint-staged": "^15.2.5",
-		"typescript": "^5.4.5"
-	},
-	"optionalDependencies": {
-		"ioredis": "^5.4.1",
-		"tweetnacl": "^1.0.3",
-		"uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.42.0"
-	},
-	"homepage": "https://seyfert.dev",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/tiramisulabs/seyfert.git"
-	},
-	"bugs": {
-		"url": "https://github.com/tiramisulabs/seyfert"
-	},
-	"keywords": [
-		"api",
-		"discord",
-		"bots",
-		"typescript",
-		"botdev"
-	],
-	"publishConfig": {
-		"access": "public"
-	},
-	"contributors": [
-		{
-			"name": "socram03",
-			"url": "https://github.com/socram03"
-		}
-	]
-}
+{
+	"name": "seyfert",
+	"version": "2.1.0",
+	"description": "The most advanced framework for discord bots",
+	"main": "./lib/index.js",
+	"module": "./lib/index.js",
+	"types": "./lib/index.d.ts",
+	"files": [
+		"lib/**"
+	],
+	"scripts": {
+		"build": "tsc --outDir ./lib",
+		"prepublishOnly": "npm run build",
+		"prepare": "npm run build && husky",
+		"lint": "biome lint --write ./src",
+		"format": "biome format --write ./src",
+		"check-h": "biome check --write ./src",
+		"check": "biome check --write --no-errors-on-unmatched ./src"
+	},
+	"author": "MARCROCK22",
+	"license": "MIT",
+	"devDependencies": {
+		"@biomejs/biome": "1.8.3",
+		"@commitlint/cli": "^19.4.0",
+		"@commitlint/config-conventional": "^19.2.2",
+		"@types/node": "^22.5.0",
+		"husky": "^9.1.5",
+		"lint-staged": "^15.2.9",
+		"typescript": "^5.5.4"
+	},
+	"homepage": "https://seyfert.dev",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/tiramisulabs/seyfert.git"
+	},
+	"bugs": {
+		"url": "https://github.com/tiramisulabs/seyfert"
+	},
+	"keywords": [
+		"api",
+		"discord",
+		"bots",
+		"typescript",
+		"botdev"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"maintainers": [
+		{
+			"name": "socram03",
+			"url": "https://github.com/socram03"
+		}
+	],
+	"contributors": [
+		{
+			"name": "Free 公園",
+			"url": "https://github.com/FreeAoi"
+		},
+		{
+			"name": "David",
+			"url": "https://github.com/Drylozu"
+		}
+	],
+	"lint-staged": {
+		"*.ts": [
+			"biome check --write"
+		]
+	}
+}

package/lib/cache/adapters/redis.d.ts

@@ -1,37 +0,0 @@
-import type { RedisOptions } from 'ioredis';
-import type { Adapter } from './types';
-interface RedisAdapterOptions {
-    namespace?: string;
-}
-export declare class RedisAdapter implements Adapter {
-    isAsync: boolean;
-    client: import('ioredis').Redis;
-    namespace: string;
-    constructor(data: ({
-        client: import('ioredis').Redis;
-    } | {
-        redisOptions: RedisOptions;
-    }) & RedisAdapterOptions);
-    private __scanSets;
-    scan(query: string, returnKeys?: false): Promise<any[]>;
-    scan(query: string, returnKeys: true): Promise<string[]>;
-    get(keys: string[]): Promise<any[]>;
-    get(keys: string): Promise<any>;
-    set(id: [string, any][]): Promise<void>;
-    set(id: string, data: any): Promise<void>;
-    patch(updateOnly: boolean, id: [string, any][]): Promise<void>;
-    patch(updateOnly: boolean, id: string, data: any): Promise<void>;
-    values(to: string): Promise<any[]>;
-    keys(to: string): Promise<string[]>;
-    count(to: string): Promise<number>;
-    remove(keys: string | string[]): Promise<void>;
-    flush(): Promise<void>;
-    contains(to: string, keys: string): Promise<boolean>;
-    getToRelationship(to: string): Promise<string[]>;
-    bulkAddToRelationShip(data: Record<string, string[]>): Promise<void>;
-    addToRelationship(to: string, keys: string | string[]): Promise<void>;
-    removeToRelationship(to: string, keys: string | string[]): Promise<void>;
-    removeRelationship(to: string | string[]): Promise<void>;
-    protected buildKey(key: string): string;
-}
-export {};

package/lib/cache/adapters/redis.js

@@ -1,218 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisAdapter = void 0;
-let Redis;
-try {
-    Redis = require('ioredis').Redis;
-}
-catch {
-    // potocuit > seyfert
-}
-class RedisAdapter {
-    isAsync = true;
-    client;
-    namespace;
-    constructor(data) {
-        if (!Redis) {
-            throw new Error('No ioredis installed');
-        }
-        this.client = 'client' in data ? data.client : new Redis(data.redisOptions);
-        this.namespace = data.namespace ?? 'seyfert';
-    }
-    __scanSets(query, returnKeys = false) {
-        const match = this.buildKey(query);
-        return new Promise((r, j) => {
-            const stream = this.client.scanStream({
-                match,
-                type: 'set',
-            });
-            const keys = [];
-            stream
-                .on('data', resultKeys => keys.push(...resultKeys))
-                .on('end', () => (returnKeys ? r(keys.map(x => this.buildKey(x))) : r(this.get(keys))))
-                .on('error', err => j(err));
-        });
-    }
-    scan(query, returnKeys = false) {
-        const match = this.buildKey(query);
-        return new Promise((r, j) => {
-            const stream = this.client.scanStream({
-                match,
-                // omit relationships
-                type: 'hash',
-            });
-            const keys = [];
-            stream
-                .on('data', resultKeys => keys.push(...resultKeys))
-                .on('end', () => (returnKeys ? r(keys.map(x => this.buildKey(x))) : r(this.get(keys))))
-                .on('error', err => j(err));
-        });
-    }
-    async get(keys) {
-        if (!Array.isArray(keys)) {
-            const value = await this.client.hgetall(this.buildKey(keys));
-            if (value) {
-                return toNormal(value);
-            }
-            return;
-        }
-        const pipeline = this.client.pipeline();
-        for (const key of keys) {
-            pipeline.hgetall(this.buildKey(key));
-        }
-        return (await pipeline.exec())?.filter(x => !!x[1]).map(x => toNormal(x[1])) ?? [];
-    }
-    async set(id, data) {
-        if (!Array.isArray(id)) {
-            await this.client.hset(this.buildKey(id), toDb(data));
-            return;
-        }
-        const pipeline = this.client.pipeline();
-        for (const [k, v] of id) {
-            pipeline.hset(this.buildKey(k), toDb(v));
-        }
-        await pipeline.exec();
-    }
-    async patch(updateOnly, id, data) {
-        if (!Array.isArray(id)) {
-            if (updateOnly) {
-                await this.client.eval(`if redis.call('exists',KEYS[1]) == 1 then redis.call('hset', KEYS[1], ${Array.from({ length: Object.keys(data).length * 2 }, (_, i) => `ARGV[${i + 1}]`)}) end`, 1, this.buildKey(id), ...Object.entries(toDb(data)).flat());
-            }
-            else {
-                await this.client.hset(this.buildKey(id), toDb(data));
-            }
-            return;
-        }
-        const pipeline = this.client.pipeline();
-        for (const [k, v] of id) {
-            if (updateOnly) {
-                pipeline.eval(`if redis.call('exists',KEYS[1]) == 1 then redis.call('hset', KEYS[1], ${Array.from({ length: Object.keys(v).length * 2 }, (_, i) => `ARGV[${i + 1}]`)}) end`, 1, this.buildKey(k), ...Object.entries(toDb(v)).flat());
-            }
-            else {
-                pipeline.hset(this.buildKey(k), toDb(v));
-            }
-        }
-        await pipeline.exec();
-    }
-    async values(to) {
-        const array = [];
-        const data = await this.keys(to);
-        if (data.length) {
-            const items = await this.get(data);
-            for (const item of items) {
-                if (item) {
-                    array.push(item);
-                }
-            }
-        }
-        return array;
-    }
-    async keys(to) {
-        const data = await this.getToRelationship(to);
-        return data.map(id => this.buildKey(`${to}.${id}`));
-    }
-    async count(to) {
-        return this.client.scard(`${this.buildKey(to)}:set`);
-    }
-    async remove(keys) {
-        if (!Array.isArray(keys)) {
-            await this.client.del(this.buildKey(keys));
-            return;
-        }
-        await this.client.del(...keys.map(x => this.buildKey(x)));
-    }
-    async flush() {
-        const keys = await Promise.all([
-            this.scan(this.buildKey('*'), true),
-            this.__scanSets(this.buildKey('*'), true),
-        ]).then(x => x.flat());
-        if (!keys.length)
-            return;
-        await this.remove(keys);
-    }
-    async contains(to, keys) {
-        return (await this.client.sismember(`${this.buildKey(to)}:set`, keys)) === 1;
-    }
-    async getToRelationship(to) {
-        return this.client.smembers(`${this.buildKey(to)}:set`);
-    }
-    async bulkAddToRelationShip(data) {
-        const pipeline = this.client.pipeline();
-        for (const [key, value] of Object.entries(data)) {
-            pipeline.sadd(`${this.buildKey(key)}:set`, ...value);
-        }
-        await pipeline.exec();
-    }
-    async addToRelationship(to, keys) {
-        await this.client.sadd(`${this.buildKey(to)}:set`, ...(Array.isArray(keys) ? keys : [keys]));
-    }
-    async removeToRelationship(to, keys) {
-        await this.client.srem(`${this.buildKey(to)}:set`, ...(Array.isArray(keys) ? keys : [keys]));
-    }
-    async removeRelationship(to) {
-        await this.client.del(...(Array.isArray(to) ? to.map(x => `${this.buildKey(x)}:set`) : [`${this.buildKey(to)}:set`]));
-    }
-    buildKey(key) {
-        return key.startsWith(this.namespace) ? key : `${this.namespace}:${key}`;
-    }
-}
-exports.RedisAdapter = RedisAdapter;
-const isObject = (o) => {
-    return !!o && typeof o === 'object' && !Array.isArray(o);
-};
-function toNormal(target) {
-    if (typeof target.ARRAY_OF === 'string')
-        return JSON.parse(target.ARRAY_OF).map(toNormal);
-    if (!Object.keys(target).length)
-        return undefined;
-    const result = {};
-    for (const [key, value] of Object.entries(target)) {
-        if (key.startsWith('O_')) {
-            result[key.slice(2)] = JSON.parse(value);
-        }
-        else if (key.startsWith('N_')) {
-            result[key.slice(2)] = Number(value);
-        }
-        else if (key.startsWith('B_')) {
-            result[key.slice(2)] = value === 'true';
-        }
-        else {
-            result[key] = value;
-        }
-    }
-    return result;
-}
-function toDb(target) {
-    if (Array.isArray(target))
-        return { ARRAY_OF: JSON.stringify(target.map(toDb)) };
-    const result = {};
-    for (const [key, value] of Object.entries(target)) {
-        switch (typeof value) {
-            case 'boolean':
-                result[`B_${key}`] = value;
-                break;
-            case 'number':
-                result[`N_${key}`] = `${value}`;
-                break;
-            case 'object':
-                if (Array.isArray(value)) {
-                    result[`O_${key}`] = JSON.stringify(value);
-                    break;
-                }
-                if (isObject(value)) {
-                    result[`O_${key}`] = JSON.stringify(value);
-                    break;
-                }
-                if (!Number.isNaN(value)) {
-                    result[`O_${key}`] = 'null';
-                    break;
-                }
-                result[`O_${key}`] = JSON.stringify(value);
-                break;
-            default:
-                result[key] = value;
-                break;
-        }
-    }
-    return result;
-}

package/lib/client/oninteractioncreate.d.ts

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