Project Structure

const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.GuildMessageReactions,
        GatewayIntentBits.GuildMembers
    ],
    partials: [Partials.Message, Partials.Channel, Partials.Reaction]
});

client.once('clientReady', async () => {
    // Load all state
    loadRaidChannels();
    loadGuildSettings();
    
    // Initialize systems
    await registerCommands();
    await reinitializeRaids(client);
    startReminderScheduler();
});

// In-memory caches for fast access
const activeRaids = new Map();
const raidChannels = new Map();
const guildSettings = new Map();

// Database-backed setters
function setActiveRaid(messageId, raidData) {
    activeRaids.set(messageId, raidData);
    // Immediately persist to database
    statements.insertRaid.run(serializeRaid(messageId, raidData));
}

const CHECK_INTERVAL_MS = 60 * 1000;

async function runReminderCheck() {
    for (const [messageId, raidData] of activeRaids.entries()) {
        const secondsUntil = raidData.timestamp - now;
        
        if (secondsUntil <= settings.creatorReminderSeconds) {
            await sendCreatorReminder(client, raidData);
        }
        
        if (isRaidFull(raidData) && secondsUntil <= settings.autoCloseSeconds) {
            await autoCloseRaid(client, raidData);
        }
    }
}

module.exports = [
    require('./availability'),
    require('./create'),
    require('./raid'),
    // ... all commands
];

async function registerCommands(clientId, token, commands) {
    const rest = new REST({ version: '10' }).setToken(token);
    const commandData = commands.map(cmd => cmd.data.toJSON());
    
    await rest.put(
        Routes.applicationCommands(clientId),
        { body: commandData }
    );
}

const locks = new Map(); // messageId -> Mutex

async function handleReactionAdd(reaction, user) {
    // Acquire lock for this specific raid
    const lock = getLock(reaction.message.id);
    const release = await lock.acquire();
    
    try {
        // Rate limit check
        if (!reactionLimiter.isAllowed(user.id)) {
            await reaction.users.remove(user.id);
            return;
        }
        
        // Process signup atomically
        const raidData = activeRaids.get(reaction.message.id);
        if (raidData.closed) {
            await reaction.users.remove(user.id);
            return;
        }
        
        // Add to role or waitlist
        const roleIndex = raidData.signups.findIndex(
            r => r.emoji === reaction.emoji.name
        );
        // ... signup logic
    } finally {
        release();
    }
}

async function reinitializeRaids(client) {
    for (const [messageId, raidData] of activeRaids.entries()) {
        try {
            // Fetch raid message from Discord
            const channel = await client.channels.fetch(raidData.channelId);
            const message = await channel.messages.fetch(messageId);
            
            // Re-add reactions if missing
            for (const role of raidData.signups) {
                if (!message.reactions.cache.has(role.emoji)) {
                    await message.react(role.emoji);
                }
            }
            
            logger.info('Raid reinitialized', { raidId: raidData.raidId });
        } catch (error) {
            logger.warn('Failed to reinitialize raid', { messageId, error });
        }
    }
}

const db = new Database(DB_PATH);

// Enable WAL mode for concurrent performance
db.pragma('journal_mode = WAL');
db.pragma('foreign_keys = ON');

function initializeSchema() {
    const schema = fs.readFileSync(SCHEMA_PATH, 'utf8');
    db.exec(schema);
    runMigrations();
}

function prepare(sql) {
    return db.prepare(sql);
}

function transaction(fn) {
    return db.transaction(fn);
}

CREATE TABLE IF NOT EXISTS raids (
  message_id TEXT PRIMARY KEY,
  raid_id TEXT,
  guild_id TEXT,
  type TEXT DEFAULT 'raid',
  timestamp INTEGER,
  creator_id TEXT,
  closed_at INTEGER,
  version INTEGER DEFAULT 1,
  FOREIGN KEY (guild_id) REFERENCES guilds(id)
);

{
  "clientId": "YOUR_CLIENT_ID",
  "token": "YOUR_BOT_TOKEN",
  "allowedGuildIds": ["GUILD_ID_1"],
  "ownerId": "YOUR_USER_ID"
}

{
  "scripts": {
    "test": "node --test --test-force-exit"
  },
  "dependencies": {
    "discord.js": "^14.24.2",
    "better-sqlite3": "^12.5.0",
    "chrono-node": "^2.9.0",
    "async-mutex": "^0.5.0",
    "dotenv": "^17.2.3"
  }
}