Package Exports

malzahir
malzahir/dist/index.js

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (malzahir) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

🚀 Rashi Discord

A powerful, feature-rich Discord bot framework built with TypeScript. It provides a complete toolkit for modern bot development, making it easy to build, scale, and maintain production-ready bots.

✨ Key Features

🔧 TypeScript First – Full type safety, IntelliSense, and modern development practices
🗃️ VerseDB Integration – Lightweight database system with support for JSON, YAML, and MongoDB
📁 Automatic Loading – Seamless auto-registration of events and commands
🔒 Built-in Encryption – AES-secured storage for sensitive data
👀 Hot Reloading – File watcher for rapid development
🛡️ Crash Protection – Automatic error handling and reporting
🎨 Advanced Logging – Color-coded logs with timestamps and categories
📦 Flexible Package Manager Support – Works with both Yarn and NPM
📊 Bot Analytics – Integrated statistics and activity tracking
🧩 Middleware System – Guard commands with ownerOnly, cooldown, requirePermissions, nsfwOnly, devOnly, etc.
🎵 Music Support – Lavalink/YouTube/Spotify integrations
⏰ Task Scheduler – Interval, CRON, and delayed jobs built-in

🛠️ Installation

npm install rashi-discord
# or
yarn add rashi-discord

🚀 Quick Start

Advanced Configuration

// src/index.ts - Main bot entry point
import { Client, GatewayIntentBits } from "discord.js";
import { starter } from "rashi-discord";
import dotenv from "dotenv";
import path from "path";

dotenv.config();

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
    GatewayIntentBits.GuildMembers,
    GatewayIntentBits.GuildVoiceStates,
  ],
});

const botConfig = {
  bot: {
    token: process.env.DISCORD_TOKEN!,
    ownerId: process.env.BOT_OWNER_ID!,
    clientId: process.env.CLIENT_ID!,
    devGuildId: process.env.DEV_GUILD_ID,
  },

  prefix: { path: path.join(__dirname, "commands", "general"), prefix: "!" },
  slash: { path: path.join(__dirname, "commands", "slash") },
  nonprefix: { path: path.join(__dirname, "commands", "nonprefix") },
  events: { path: path.join(__dirname, "events") },

  // ⬅️ dopisane
  poruEvents: { path: path.join(__dirname, "poru-events") },

  terminal: true,

  Status: {
    status: "online" as const,
    activities: [
      "Obsługuję {users} użytkowników 👥",
      "Na {servers} serwerach 🌍",
      "Mam {commands} komend ⚡",
      "Użyto mnie {used} razy 📊",
      "Kocham was ❤️",
    ],
    time: 30000,
  },

  music: {
    enabled: true,
    nodes: [
      {
        name: "RY4N",
        host: "vip.visionhost.cloud",
        port: 7023,
        password: "youshallnotpass",
        secure: false,
      },
    ],
    defaultVolume: 80,
    defaultPlatform: "ytsearch",
    autoLeave: true,
    reconnectTries: 5,
    reconnectInterval: 5000,
    requestTimeout: 10000,
    resume: true,
    resumeKey: "rashi-music",
    resumeTimeout: 60_000,
    autoPlay: true,
    queueLimit: 200,
    trackMaxLength: 0,
  },

  database: {
    type: (process.env.DB_TYPE as "mongodb" | "json" | "yaml") || "mongodb",
    connectionString: process.env.MONGO_URL,
    path: "./database",
    encryption: false,
    encryptionKey: process.env.DB_KEY || undefined,
  },
};

starter(client, botConfig).then(() => {
  console.log("✅ Bot started!");
});

📁 Project Structure

your-bot/
├── commands/
│   ├── general/
│   │   ├── ping.ts
│   │   └── info.ts
│   └── slash/
│       ├── help.ts
│       └── stats.ts
├── events/
│   ├── ready.ts
│   └── messageCreate.ts
├── index.ts
└── package.json

🎯 Command Examples

Prefix Command

// commands/general/ping.ts
// src/commands/general/ping.ts - Example prefix command
import { Message } from 'discord.js';
import { Command } from 'rashi-discord';

const pingCommand: Command = {
  name: 'ping',
  description: 'Check bot latency and response time',
  aliases: ['p', 'latency'],
  cooldown: 5, // 5 seconds cooldown
  
  async execute(message: Message, args: string[]) {
    const start = Date.now();
    
    const reply = await message.reply('🏓 Calculating ping...');
    
    const latency = Date.now() - start;
    const apiLatency = Math.round(message.client.ws.ping);
    
    const embed = {
      title: '🏓 Pong!',
      fields: [
        {
          name: '📊 Bot Latency',
          value: `\`${latency}ms\``,
          inline: true
        },
        {
          name: '🌐 API Latency', 
          value: `\`${apiLatency}ms\``,
          inline: true
        },
        {
          name: '⏱️ Status',
          value: latency < 100 ? '🟢 Excellent' : latency < 200 ? '🟡 Good' : '🔴 Slow',
          inline: true
        }
      ],
      color: latency < 100 ? 0x00FF00 : latency < 200 ? 0xFFFF00 : 0xFF0000,
      timestamp: new Date().toISOString(),
      footer: {
        text: `Requested by ${message.author.username}`,
        icon_url: message.author.displayAvatarURL()
      }
    };

    await reply.edit({ content: '', embeds: [embed] });
  }
};

export default pingCommand;

Slash Command

// commands/slash/info.ts
// commands/slash/slash.ts - FIXED
import { SlashCommand } from 'rashi-discord';
import { SlashCommandBuilder, CommandInteraction } from 'discord.js';

const slashCommand: SlashCommand = {
  data: new SlashCommandBuilder()
    .setName('info')
    .setDescription('Display bot information'),
  
  async execute(interaction: CommandInteraction): Promise<void> {
    const embed = {
      title: 'Bot Information',
      description: 'Bot created with Rashi Discord',
      color: 0x5865F2,
      fields: [
        {
          name: 'Statistics',
          value: `Servers: ${interaction.client.guilds.cache.size}\nUsers: ${interaction.client.users.cache.size}`
        }
      ],
      timestamp: new Date().toISOString()
    };

    await interaction.reply({ embeds: [embed] });
  }
};

export default slashCommand;

🎊 Event Example

// events/ready.ts
import { Event } from 'rashi-discord';
import { Client } from 'discord.js';

const readyEvent: Event = {
  name: 'ready',
  once: true,
  execute: async (client: Client) => {
    console.log(`✅ Bot ${client.user?.tag} jest gotowy!`);
    
    // Set bot status
    client.user?.setActivity('🎮 Rashi Discord', { type: 'PLAYING' });
  }
};

export default readyEvent;

⏰ Task Scheduler

You can schedule jobs directly from commands or events with simple syntax:

client.scheduler.once("reminder-123", "5m", () => {
  console.log("⏰ Reminder after 5 minutes!");
});

client.scheduler.every("stats-log", "10m", () => {
  client.logger.info(
    `📊 Guilds=${client.guilds.cache.size}, Users=${client.users.cache.size}`
  );
});

client.scheduler.cron("daily-announcement", "0 12 * * *", () => {
  const channel = client.channels.cache.get("1234567890");
  if (channel?.isTextBased()) {
    channel.send("☀️ Daily announcement: Have a great day!");
  }
});

🧩 Middleware

Middlewares run before executing a command and can block or modify execution. They are reusable plugins (like Express middlewares).

Permissions Middleware

import { requirePermissions } from "rashi-discord";

const echo: SlashCommand = {
  data: new SlashCommandBuilder()
    .setName("echo")
    .setDescription("Echo your input")
    .addStringOption(opt =>
      opt.setName("text").setDescription("Text to echo").setRequired(true)
    ),

  middlewares: [requirePermissions(["ManageMessages"])],

  async execute(interaction) {
    const text = interaction.options.getString("text", true);
    await interaction.reply(`🔊 ${text}`);
  },
};

Built-in middlewares

ownerOnly() – restrict to bot owner

devOnly() – restrict to developers

cooldown(ms) – add cooldown to commands

requirePermissions([...]) – check user permissions

nsfwOnly() – restrict to NSFW channels

argsRequired(min) – enforce args

requireRole("Admin") / requireRoles(["Mod", "Helper"])

🗃️ Database Usage

MongoDB

// MongoDB automatically connected if configured
const user = await bot.database?.findOne('users', { id: '123456789' });
await bot.database?.insertOne('users', { 
  id: '123456789', 
  username: 'JohnDoe',
  coins: 100
});

JSON/YAML (VerseDB)

// Works the same way as MongoDB
const guild = await bot.database?.findOne('guilds', { id: message.guild.id });
await bot.database?.updateOne('guilds', 
  { id: message.guild.id }, 
  { prefix: '?' }
);

📊 Bot Statistics

Access real-time bot statistics:

console.log(bot.stats);
// Output:
// {
//   commandsUsed: 42,
//   slashCommandsUsed: 18,
//   eventsTriggered: 156,
//   uptime: 3600
// }

🎨 Advanced Logging

import { Logger } from 'rashi-discord';

const logger = new Logger({
  level: 'debug',
  colorized: true,
  saveToFile: true,
  filePath: './logs/custom.log'
});

logger.info('✅ Bot started successfully');
logger.warn('⚠️ High memory usage detected');
logger.error('❌ Database connection failed');

🔧 Configuration Options

Option	Type	Default	Description
`token`	`string`	required	Discord bot token
`prefix`	`string`	`'!'`	Command prefix
`database`	`DatabaseConfig`	`undefined`	Database configuration
`logging`	`LoggingConfig`	`{ level: 'info' }`	Logging settings
`antiCrash`	`boolean`	`true`	Enable anti-crash system
`hotReload`	`boolean`	`false`	Enable hot reloading
`scheduler`	`TaskScheduler`	`built-in`	Run tasks with intervals/CRON

Database Configuration

interface DatabaseConfig {
  type: 'mongodb' | 'json' | 'yaml';
  connectionString?: string; // For MongoDB
  path?: string; // For JSON/YAML files
  encryption?: boolean;
  encryptionKey?: string;
}

🔥 Hot Reloading

Enable hot reloading for development:

const bot = new BotStarter({
  token: 'YOUR_BOT_TOKEN',
  hotReload: true // Automatically reloads commands and events on file changes
});

🛡️ Anti-Crash System

Built-in protection against crashes:

Handles unhandled promise rejections
Catches uncaught exceptions
Logs Discord.js errors
Keeps your bot running 24/7

📦 Publishing to NPM

Build your library:

npm run build

Publish to NPM:

npm publish

🤝 Contributing

Fork the repository
Create your feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🎯 Examples

Check out the examples folder for complete bot implementations using Rashi Discord.

🆘 Support

Made with ❤️ by [Rashi aka Malzahir]