Discord birthday bot: greet every member on their day (Python and JavaScript)

discord.py
python-dotenv
tzdata

DISCORD_TOKEN=paste-your-token-here

import json
import os
from datetime import date, datetime
from pathlib import Path
from zoneinfo import ZoneInfo

import discord
from discord import app_commands
from discord.ext import tasks
from dotenv import load_dotenv

load_dotenv()  # reads the token from the .env file

# Birthdays are saved next to the bot: a restart doesn't lose them.
DATA = Path("birthdays.json")
ZONE = ZoneInfo("Europe/London")  # change it if your group lives in another time zone
HOUR = 9  # greetings go out from this hour on
MONTHS = ["January", "February", "March", "April", "May", "June", "July",
          "August", "September", "October", "November", "December"]
NO_PINGS = discord.AllowedMentions.none()


def load() -> dict:
    return json.loads(DATA.read_text("utf-8")) if DATA.exists() else {}


def save(data: dict) -> None:
    DATA.write_text(json.dumps(data, indent=2), "utf-8")


def server(data: dict, guild_id: int) -> dict:
    return data.setdefault(str(guild_id), {"channel": None, "last": None, "birthdays": {}})


def next_birthday(day: int, month: int, today: date) -> date:
    """The next birthday from today on (today included)."""
    for year in (today.year, today.year + 1):
        try:
            when = date(year, month, day)
        except ValueError:
            when = date(year, 2, 28)  # born on 29 February and this isn't a leap year
        if when >= today:
            return when


def join(names: list[str]) -> str:
    return names[0] if len(names) == 1 else ", ".join(names[:-1]) + " and " + names[-1]


class Bot(discord.Client):
    def __init__(self):
        # No privileged intents: each person is looked up by their ID when it's their day.
        super().__init__(intents=discord.Intents.default())
        self.tree = app_commands.CommandTree(self)

    async def setup_hook(self):
        await self.tree.sync()  # publishes the commands
        greet.start()


bot = Bot()


@tasks.loop(minutes=30)  # checks every half hour: if the bot was off at 9, it greets when it comes back
async def greet():
    now = datetime.now(ZONE)
    if now.hour < HOUR:
        return
    today = now.date()
    for guild_id, data in load().items():
        if data["last"] == today.isoformat() or data["channel"] is None:
            continue  # already greeted today, or no channel
        guild = bot.get_guild(int(guild_id))
        channel = bot.get_channel(data["channel"])
        if guild is None or channel is None:
            continue
        people = []
        for user_id, (day, month) in data["birthdays"].items():
            if next_birthday(day, month, today) != today:
                continue
            try:
                await guild.fetch_member(int(user_id))  # still on the server?
            except discord.HTTPException:
                continue  # they've left (or Discord isn't answering): they're not named
            people.append(f"<@{user_id}>")
        if people:
            try:
                await channel.send(f"🎂 Happy birthday, {join(people)}! 🎉",
                                   allowed_mentions=discord.AllowedMentions(users=True, roles=False, everyone=False))
            except discord.HTTPException as error:
                print(f"Couldn't greet in {guild_id}: {error!r}")
                continue  # tried again on the next round
        fresh = load()  # read again in case someone used a command meanwhile
        server(fresh, int(guild_id))["last"] = today.isoformat()
        save(fresh)


@greet.before_loop
async def before_greet():
    await bot.wait_until_ready()


@bot.tree.command(name="birthday", description="Save your birthday (without the year)")
@app_commands.guild_only()
@app_commands.describe(day="Day of the month", month="Month, from 1 to 12")
async def birthday(interaction: discord.Interaction, day: app_commands.Range[int, 1, 31], month: app_commands.Range[int, 1, 12]):
    try:
        date(2000, month, day)  # 2000 was a leap year: 29 February is valid
    except ValueError:
        await interaction.response.send_message("That date doesn't exist.", ephemeral=True)
        return
    data = load()
    s = server(data, interaction.guild_id)
    s["birthdays"][str(interaction.user.id)] = [day, month]
    save(data)
    missing = "" if s["channel"] else " There's no greetings channel yet: someone who manages the server has to use /birthday-channel."
    await interaction.response.send_message(f"Saved: {MONTHS[month - 1]} {day}.{missing}", ephemeral=True)


@bot.tree.command(name="forget-birthday", description="Remove your birthday from this server")
@app_commands.guild_only()
async def forget_birthday(interaction: discord.Interaction):
    data = load()
    removed = server(data, interaction.guild_id)["birthdays"].pop(str(interaction.user.id), None)
    save(data)
    text = "Removed: I won't greet you any more." if removed else "You didn't have a birthday saved."
    await interaction.response.send_message(text, ephemeral=True)


@bot.tree.command(name="birthdays", description="The server's upcoming birthdays")
@app_commands.guild_only()
async def birthdays(interaction: discord.Interaction):
    today = datetime.now(ZONE).date()
    saved = server(load(), interaction.guild_id)["birthdays"]
    if not saved:
        await interaction.response.send_message("Nobody has saved their birthday yet. Use /birthday.", ephemeral=True)
        return
    order = sorted(saved.items(), key=lambda p: next_birthday(p[1][0], p[1][1], today))[:10]
    lines = [f"{MONTHS[month - 1]} {day}: <@{user_id}>" for user_id, (day, month) in order]
    # The names show, but nobody gets pinged.
    await interaction.response.send_message("🎂 Upcoming birthdays:\n" + "\n".join(lines), allowed_mentions=NO_PINGS)


@bot.tree.command(name="birthday-channel", description="Choose the channel where greetings go")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)  # by default, only people who manage the server
async def birthday_channel(interaction: discord.Interaction, channel: discord.TextChannel):
    if not channel.permissions_for(interaction.guild.me).send_messages:
        await interaction.response.send_message(f"I can't write in {channel.mention}: give me “View Channel” and “Send Messages” there.", ephemeral=True)
        return
    data = load()
    server(data, interaction.guild_id)["channel"] = channel.id
    save(data)
    await interaction.response.send_message(f"Done: I'll greet in {channel.mention} from {HOUR}:00.", ephemeral=True)


@bot.event
async def on_ready():
    print(f"Logged in as {bot.user}")


bot.run(os.environ["DISCORD_TOKEN"])

{
  "name": "birthday-bot",
  "version": "1.0.0",
  "main": "index.js",
  "dependencies": {
    "discord.js": "^14.16.0",
    "dotenv": "^16.4.0"
  }
}

DISCORD_TOKEN=paste-your-token-here

require("dotenv").config(); // reads the token from the .env file
const fs = require("node:fs");
const path = require("node:path");
const { ChannelType, Client, Events, GatewayIntentBits, InteractionContextType, MessageFlags, PermissionFlagsBits, SlashCommandBuilder } = require("discord.js");

// Birthdays are saved next to the bot: a restart doesn't lose them.
const DATA = path.join(__dirname, "birthdays.json");
const ZONE = "Europe/London"; // change it if your group lives in another time zone
const HOUR = 9; // greetings go out from this hour on
const HALF_HOUR = 30 * 60 * 1000; // checks every half hour: if the bot was off at 9, it greets when it comes back
const MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];

const load = () => (fs.existsSync(DATA) ? JSON.parse(fs.readFileSync(DATA, "utf8")) : {});
const save = (data) => fs.writeFileSync(DATA, JSON.stringify(data, null, 2));
const server = (data, guildId) => (data[guildId] ??= { channel: null, last: null, birthdays: {} });
const two = (n) => String(n).padStart(2, "0");
const join = (names) => (names.length === 1 ? names[0] : `${names.slice(0, -1).join(", ")} and ${names.at(-1)}`);

// The date ("YYYY-MM-DD") and the hour right now in the chosen time zone.
function now() {
  const parts = new Intl.DateTimeFormat("en-CA", { timeZone: ZONE, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", hourCycle: "h23" }).formatToParts(new Date());
  const p = Object.fromEntries(parts.map((x) => [x.type, x.value]));
  return { today: `${p.year}-${p.month}-${p.day}`, hour: Number(p.hour) };
}

// The next birthday from today on (today included), as "YYYY-MM-DD".
function nextBirthday(day, month, today) {
  const year = Number(today.slice(0, 4));
  for (const y of [year, year + 1]) {
    const leap = new Date(Date.UTC(y, 1, 29)).getUTCDate() === 29;
    const d = day === 29 && month === 2 && !leap ? 28 : day; // born on 29 February and this isn't a leap year
    const when = `${y}-${two(month)}-${two(d)}`;
    if (when >= today) return when;
  }
}

// No privileged intents: each person is looked up by their ID when it's their day.
const client = new Client({ intents: [GatewayIntentBits.Guilds] });

async function greet() {
  const { today, hour } = now();
  if (hour < HOUR) return;
  for (const [guildId, data] of Object.entries(load())) {
    if (data.last === today || !data.channel) continue; // already greeted today, or no channel
    const guild = client.guilds.cache.get(guildId);
    const channel = client.channels.cache.get(data.channel);
    if (!guild || !channel) continue;
    const people = [];
    for (const [userId, [day, month]] of Object.entries(data.birthdays)) {
      if (nextBirthday(day, month, today) !== today) continue;
      const member = await guild.members.fetch(userId).catch(() => null); // still on the server?
      if (member) people.push(`<@${userId}>`);
    }
    if (people.length) {
      try {
        await channel.send({ content: `🎂 Happy birthday, ${join(people)}! 🎉`, allowedMentions: { parse: ["users"] } });
      } catch (error) {
        console.error(`Couldn't greet in ${guildId}:`, error);
        continue; // tried again on the next round
      }
    }
    const fresh = load(); // read again in case someone used a command meanwhile
    server(fresh, guildId).last = today;
    save(fresh);
  }
}

const commands = [
  new SlashCommandBuilder().setName("birthday").setDescription("Save your birthday (without the year)").setContexts(InteractionContextType.Guild)
    .addIntegerOption((o) => o.setName("day").setDescription("Day of the month").setRequired(true).setMinValue(1).setMaxValue(31))
    .addIntegerOption((o) => o.setName("month").setDescription("Month, from 1 to 12").setRequired(true).setMinValue(1).setMaxValue(12)),
  new SlashCommandBuilder().setName("forget-birthday").setDescription("Remove your birthday from this server").setContexts(InteractionContextType.Guild),
  new SlashCommandBuilder().setName("birthdays").setDescription("The server's upcoming birthdays").setContexts(InteractionContextType.Guild),
  new SlashCommandBuilder().setName("birthday-channel").setDescription("Choose the channel where greetings go").setContexts(InteractionContextType.Guild)
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild) // by default, only people who manage the server
    .addChannelOption((o) => o.setName("channel").setDescription("Text channel").setRequired(true).addChannelTypes(ChannelType.GuildText)),
];

client.on(Events.InteractionCreate, async (i) => {
  if (!i.isChatInputCommand()) return;
  const hidden = { flags: MessageFlags.Ephemeral };
  const data = load();
  const s = server(data, i.guildId);

  if (i.commandName === "birthday") {
    const day = i.options.getInteger("day");
    const month = i.options.getInteger("month");
    if (new Date(Date.UTC(2000, month - 1, day)).getUTCDate() !== day) { // 2000 was a leap year: 29 February is valid
      await i.reply({ content: "That date doesn't exist.", ...hidden });
      return;
    }
    s.birthdays[i.user.id] = [day, month];
    save(data);
    const missing = s.channel ? "" : " There's no greetings channel yet: someone who manages the server has to use /birthday-channel.";
    await i.reply({ content: `Saved: ${MONTHS[month - 1]} ${day}.${missing}`, ...hidden });
  } else if (i.commandName === "forget-birthday") {
    const had = i.user.id in s.birthdays;
    delete s.birthdays[i.user.id];
    save(data);
    await i.reply({ content: had ? "Removed: I won't greet you any more." : "You didn't have a birthday saved.", ...hidden });
  } else if (i.commandName === "birthdays") {
    const { today } = now();
    const order = Object.entries(s.birthdays).sort((a, b) => nextBirthday(...a[1], today).localeCompare(nextBirthday(...b[1], today))).slice(0, 10);
    if (!order.length) {
      await i.reply({ content: "Nobody has saved their birthday yet. Use /birthday.", ...hidden });
      return;
    }
    const lines = order.map(([userId, [day, month]]) => `${MONTHS[month - 1]} ${day}: <@${userId}>`);
    // The names show, but nobody gets pinged.
    await i.reply({ content: `🎂 Upcoming birthdays:\n${lines.join("\n")}`, allowedMentions: { parse: [] } });
  } else if (i.commandName === "birthday-channel") {
    const channel = i.options.getChannel("channel");
    if (!channel.permissionsFor(i.guild.members.me).has(PermissionFlagsBits.SendMessages)) {
      await i.reply({ content: `I can't write in ${channel}: give me “View Channel” and “Send Messages” there.`, ...hidden });
      return;
    }
    s.channel = channel.id;
    save(data);
    await i.reply({ content: `Done: I'll greet in ${channel} from ${HOUR}:00.`, ...hidden });
  }
});

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set(commands.map((x) => x.toJSON())); // publishes the commands
  console.log(`Logged in as ${c.user.tag}`);
  setInterval(() => greet().catch(console.error), HALF_HOUR);
  greet().catch(console.error);
});

client.login(process.env.DISCORD_TOKEN);