djs-builder 0.1.0

package/lib/discord/functions/devLogs.ts

@@ -0,0 +1,116 @@
+import { WebhookClient, EmbedBuilder } from 'discord.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export async function devLogger(devLogger: any): Promise<void> {
+  const webhook = new WebhookClient({ url: devLogger.webhookURL });
+
+  const watchedExtensions = ['.js', '.json', '.txt', '.md', '.ts', '.tsx', '.jsx', '.html', '.css', '.py', '.verse'];
+
+  const MAX_FIELD_VALUE_LENGTH = 1024;
+
+  const watchDirectory = (directory: string) => {
+    fs.readdir(directory, (err, files) => {
+      if (err) {
+        console.error('Error reading directory:', err);
+        return;
+      }
+
+      for (const file of files) {
+        const filePath = path.join(directory, file);
+        fs.stat(filePath, (err, stats) => {
+          if (err) {
+            console.error('Error getting file stats:', err);
+            return;
+          }
+
+          if (stats.isDirectory()) {
+            watchDirectory(filePath);
+          } else {
+            if (watchedExtensions.some(ext => file.endsWith(ext))) {
+              watchFile(filePath);
+            }
+          }
+        });
+      }
+    });
+  };
+
+  const watchFile = (filePath: string) => {
+    fs.watchFile(filePath, { interval: 500 }, (curr, prev) => {
+      if (curr.mtime !== prev.mtime) {
+        readFile(filePath);
+      }
+    });
+  };
+
+  const readFile = (filePath: string) => {
+    fs.readFile(filePath, 'utf-8', (err, data) => {
+      if (err) {
+        console.error('Error reading file:', err);
+        return;
+      }
+
+      const embed = createEmbed(filePath, data);
+      sendWebhook(embed);
+    });
+  };
+
+  const createEmbed = (filePath: string, data: string) => {
+    let changes = '```' + getFileType(filePath) + '\n' + data + '\n```';
+
+    let changesChunks: string[] = [];
+    while (changes.length > MAX_FIELD_VALUE_LENGTH) {
+      changesChunks.push(changes.substring(0, MAX_FIELD_VALUE_LENGTH));
+      changes = changes.substring(MAX_FIELD_VALUE_LENGTH);
+    }
+    changesChunks.push(changes);
+
+    const embed = new EmbedBuilder()
+      .setColor('#3498db')
+      .setTitle('File Changed')
+      .setDescription(`> - File: \`${filePath}\``)
+      .setTimestamp();
+
+    for (let i = 0; i < changesChunks.length; i++) {
+      embed.addFields({ name: 'Changes:', value: changesChunks[i]});
+    }
+
+    return embed;
+  };
+
+  const sendWebhook = (embed: EmbedBuilder) => {
+    webhook.send({ content: devLogger.mention || '' ,embeds: [embed] })
+      .then()
+      .catch((error) => console.error('Error Dev Logger Message', error));
+  };
+
+  const getFileType = (filePath: string): string => {
+    const extension = path.extname(filePath);
+    switch (extension) {
+      case '.js':
+      case '.ts':
+      case '.jsx':
+      case '.tsx':
+        return 'javascript';
+      case '.json':
+        return 'json';
+      case '.txt':
+      case '.md':
+        return 'plaintext';
+      case '.html':
+        return 'html';
+      case '.css':
+        return 'css';
+      case '.py':
+        return 'python';
+      case '.verse':
+        return 'verse';
+      default:
+        return 'unknown';
+    }
+  };
+
+  watchDirectory(devLogger.pathToWatch);
+}
+

package/lib/discord/functions/mongoDb.ts

@@ -0,0 +1,38 @@
+import { MongoClient, Db } from 'mongodb';
+
+let db: Db | null = null;
+let isInitialized = false;
+let connectionPromise: Promise<MongoClient> | null = null;
+
+async function initialize(uri: string, dbName: string): Promise<void> {
+    if (isInitialized || connectionPromise) {
+        return;
+    }
+
+    try {
+        const client = new MongoClient(uri);
+        connectionPromise = client.connect();
+        const connectedClient = await connectionPromise;
+        db = connectedClient.db(dbName || 'djsBuilder');
+        isInitialized = true;
+    } catch (error) {
+        console.error('Error initializing MongoDB:', error);
+    } finally {
+        connectionPromise = null;
+    }
+}
+
+export async function mongoConnect(uri: string, dbName: string): Promise<void> {
+    await initialize(uri, dbName);
+}
+
+export async function getDb(): Promise<Db> {
+    if (!isInitialized) {
+        throw new Error('MongoDB connection not initialized');
+    }
+    if (!db) {
+        throw new Error('MongoDB connection not established');
+    }
+    
+    return db;
+}

package/lib/discord/functions/similarity.ts

@@ -0,0 +1,44 @@
+import { Collection } from 'discord.js'
+import { Command } from '../types/starter';
+export function getSimilarCommands(commandName: string, commands: Collection<string, Command>): string[] {
+    const similarityThreshold = 0.6; 
+    const similarCommands: { name: string; similarity: number }[] = [];
+
+    commands.forEach((_, cmdName) => {
+        const similarity = calculateSimilarity(commandName, cmdName);
+        if (similarity >= similarityThreshold) {
+            similarCommands.push({ name: cmdName, similarity });
+        }
+    });
+
+    similarCommands.sort((a, b) => b.similarity - a.similarity);
+
+    return similarCommands.map(cmd => cmd.name);
+}
+
+function calculateSimilarity(str1: string, str2: string): number {
+    const len1 = str1.length;
+    const len2 = str2.length;
+    const matrix = [];
+
+    // Initialize the matrix
+    for (let i = 0; i <= len1; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= len2; j++) {
+        matrix[0][j] = j;
+    }
+
+    for (let i = 1; i <= len1; i++) {
+        for (let j = 1; j <= len2; j++) {
+            const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(
+                matrix[i - 1][j] + 1,
+                matrix[i][j - 1] + 1,
+                matrix[i - 1][j - 1] + cost 
+            );
+        }
+    }
+
+    return 1 - matrix[len1][len2] / Math.max(len1, len2);
+}

package/lib/discord/functions/terminal.ts

@@ -0,0 +1,95 @@
+import { blue, cyan, green, magenta, red } from 'colorette';
+import { BotOptions } from '../types/starter';
+import Table from 'cli-table';
+import fs from 'fs';
+import path from 'path';
+
+interface Client {
+    user: { username: string };
+    prefixSize?: number;
+    slashSize?: number;
+    eventSize?: number;
+}
+
+export async function terminalLogs(client: any, bot: BotOptions): Promise<void> {
+    const { user, prefixSize = 0, slashSize = 0, eventSize = 0 } = client;
+
+    const totalCommands = slashSize + prefixSize;
+    const totalGuilds = client.guilds.cache.size;
+    const totalMembers = client.guilds.cache.reduce((acc: any, guild: any) => acc + guild.memberCount, 0);
+
+    function getProjectSize(dir: string): number {
+        let size = 0;
+        const files = fs.readdirSync(dir, { withFileTypes: true });
+
+        files.forEach(file => {
+            const filePath = path.join(dir, file.name);
+            if (file.isDirectory() && file.name !== 'node_modules') {
+                size += getProjectSize(filePath);
+            } else if (file.isFile()) {
+                size += fs.statSync(filePath).size;
+            }
+        });
+
+        return size;
+    }
+
+    function findProjectRoot(): string {
+        let currentDir = __dirname;
+        while (!fs.existsSync(path.join(currentDir, 'package.json'))) {
+            currentDir = path.dirname(currentDir);
+        }
+        return currentDir;
+    }
+
+    const projectPath = findProjectRoot();
+    const projectSize = getProjectSize(projectPath);
+
+    const botStatesTable = new Table({
+        head: [blue('# Bot States')],
+        colWidths: [30, 20]
+    });
+    botStatesTable.push(
+        [magenta('Bot Name'), user.username],
+        [green('Prefix Count'), prefixSize],
+        [red('Slash Command Count'), slashSize],
+        [cyan('Total Commands'), totalCommands],
+        [magenta('Event Count'), eventSize]
+    );
+
+    const botInfoTable = new Table({
+        head: [blue('# Bot Info')],
+        colWidths: [30, 25]
+    });
+    if (client.presence?.Status) {
+        botInfoTable.push([magenta('Status'), client.presence.Status]);
+    }
+    if (bot.Status?.activities && bot.Status.activities.length > 0) {
+        botInfoTable.push([green('Activity'), bot.Status.activities[0]]);
+    }
+    if (bot.BotInfo?.botInvite) {
+        botInfoTable.push([magenta('Bot Invite'), bot.BotInfo.botInvite]);
+    }
+    botInfoTable.push(
+        [red('Guilds Count'), totalGuilds],
+        [cyan('Members Count'), totalMembers]
+    );
+    if (bot.Database?.verse) {
+        botInfoTable.push([magenta('Bot Database'), 'VerseDb']);
+    } else if (bot.Database?.mongo) {
+        botInfoTable.push([magenta('Bot Database'), 'MongoDb']);
+    }
+    botInfoTable.push([magenta('Bot Size'), `${(projectSize / (1024 * 1024)).toFixed(2)} MB`]);
+    if (client.user?.displayAvatarURL()) {
+        botInfoTable.push([magenta('AvatarURL'), client.user.displayAvatarURL()]);
+    }
+    if (bot.BotInfo?.ownerId) {
+        botInfoTable.push([magenta('Owner'), bot.BotInfo.ownerId]);
+    }
+    if (client.readyTimestamp) {
+        const loggedInAt = new Date(client.readyTimestamp).toLocaleString();
+        botInfoTable.push([magenta('Logged In At'), loggedInAt]);
+    }
+    console.log(botStatesTable.toString());
+    console.log(botInfoTable.toString());
+}

package/lib/discord/functions/utils.ts

@@ -0,0 +1,4 @@
+import { getSimilarCommands } from './similarity';
+import { mongoConnect, getDb } from './mongoDb';
+import { verseConnect } from './versedb'
+export { getSimilarCommands, mongoConnect, getDb, verseConnect }

package/lib/discord/functions/versedb.ts

@@ -0,0 +1,17 @@
+import versedb from "verse.db";
+import { LocalDb } from "../types/starter";
+
+export async function verseConnect(options: LocalDb) {
+    const connection = {
+        adapter: options.apaterType,
+        dataPath: options.path,
+        encryption: { secret: options.encryption || 'djs-builder' },
+        devLogs: {
+            enable: options.dev.enable,
+            path: options.dev.logsPath || ''
+        }
+    };
+
+    const db = new versedb.connect(connection)
+    return db;
+}

package/lib/discord/types/starter.ts

@@ -0,0 +1,108 @@
+import { Client } from 'discord.js'
+
+export interface BotOptions {
+    token?: string;
+    logs?: {
+        devLogs?: {
+            enable: boolean
+            pathToWatch: any;
+            webhookURL: string;
+            mention?: string;
+        };
+        terminal?: boolean
+    };
+    name?: string;
+    avatar?: string;
+    banner?: string;
+    BotInfo?: {
+        perms?: string[];
+        serverId?: string
+        botInvite?: string
+        serverInvite?: string
+        ownerId?: string
+        partners?: string[];
+    };
+    Status?: {
+        state: 'online' | 'dnd' | 'idle' | 'invisible' | 'Streaming' | any;
+        activities?: string[] | undefined;
+        type?: number;
+        delay?: number;
+    };
+    Database?: {
+        mongo?: MongoDbOptions;
+        verse?: LocalDb;
+    }
+}
+
+export interface SlashOptions {
+    path: string;
+    baseDir: any;
+    global?: boolean;
+    serverId?: string;
+    logsId?: string;
+}
+
+export interface PrefixOptions {
+    path: string;
+    baseDir: any;
+    prefix: string;
+    global?: boolean;
+    serverIds?: string[];
+    logsId?: string;
+}
+
+export interface MongoDbOptions{
+      mongoURI: string;
+      dbName?: string;
+}
+
+export interface LocalDb{
+    apaterType: 'json' | 'sql' | 'yaml';
+    path: string;
+    dev: {
+        enable: boolean;
+        logsPath?: string
+    };
+    encryption?: string 
+}
+
+export interface AntiCrash{
+    enable: boolean;
+    webhookURL: string;
+    mention?: string;
+}
+
+export interface EventsOptions {
+    path: string;
+    baseDir: any;
+    logsId?: string;
+    recursive?: boolean;
+    eventBlacklist?: string[];
+}
+
+
+export interface Command {
+    name: string;
+    description?: string;
+    execute?: (...args: any[]) => void;
+    run?: (...args: any[]) => void;
+    aliases?: string[];
+    cooldown?: number;
+    usage?: string;
+    prefix?: boolean;
+    category?: string;
+    owner?: boolean;
+}
+
+export interface StarterOptions {
+    bot: BotOptions;
+    slash?: SlashOptions;
+    prefix?: PrefixOptions;
+    events?: EventsOptions;
+    anticrash?: AntiCrash; 
+}
+
+export interface StarterInterface {
+    start(djs: Client, options: StarterOptions): Promise<any>;
+}
+

package/lib/discord/types/utils.ts

@@ -0,0 +1,2 @@
+import { StarterOptions, StarterInterface, EventsOptions, Command, PrefixOptions, SlashOptions } from './starter'
+export { StarterOptions, StarterInterface, EventsOptions, Command, PrefixOptions, SlashOptions   }

package/lib/discord/utils.ts

@@ -0,0 +1,4 @@
+import { Starter } from "./events-handler/starter";
+import { Components } from './builder/utils';
+
+export { Starter, Components }

package/lib/index.ts

@@ -0,0 +1,35 @@
+import axios from "axios";
+import path from "path";
+import fs from "fs";
+
+const RED: string = "\x1b[31m";
+const CYAN: string = "\x1b[36m";
+const RESET: string = "\x1b[0m";
+
+const packageJsonPath: string = path.resolve(process.cwd(), "package.json");
+const packageJson: any = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+const getLibraryVersion = function(library: string): string {
+    const dependencies: any = packageJson.dependencies || {};
+    const devDependencies: any = packageJson.devDependencies || {};
+    const version: string = (dependencies[library] || devDependencies[library] || "").replace(/^(\^|~)/, "") || "Not installed";
+    return version;
+};
+
+axios
+    .get("https://registry.npmjs.com/-/v1/search?text=djs-builder")
+    .then(function(response: any) {
+        const version: string = response.data.objects[0]?.package?.version;
+        if (version && getLibraryVersion("djs-builder") !== version) {
+            console.error(CYAN +
+                "Error: Please update djs-builder to the latest version (" + version + ")." +
+                RESET);
+        }
+    })
+    .catch(function(error: any) {});
+
+
+import { Starter, Components } from "./discord/utils";
+
+export { Starter, Components };
+export default { Starter, Components };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "djs-builder",
+  "version": "0.1.0",
+  "description": "Discord.js bot builder. Supports Ts and Js.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "dev": "ts-node lib/index.ts",
+    "start": "node dist/index.js"
+  },
+  "author": "zenith-79",
+  "license": "MIT",
+  "keywords": [
+    "discord",
+    "discord bots",
+    "discord.js",
+    "bots",
+    "bot builder",
+    "handler",
+    "slash",
+    "prefix",
+    "slash commands",
+    "prefix commands",
+    "commands",
+    "events",
+    "logger",
+    "database",
+    "verse",
+    "mongodb"
+  ],
+  "dependencies": {
+    "cli-table": "^0.3.11",
+    "colorette": "^2.0.20",
+    "discord.js": "^14.14.1",
+    "mongodb": "^6.5.0",
+    "verse.db": "^1.1.6"
+  },
+  "devDependencies": {
+    "@types/cli-table": "^0.3.4",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  }
+}