diff --git a/.commitlintrc b/.commitlintrc
new file mode 100644
index 0000000..0df1d25
--- /dev/null
+++ b/.commitlintrc
@@ -0,0 +1,5 @@
+{
+ "extends": [
+ "@commitlint/config-conventional"
+ ]
+}
diff --git a/.github/workflows/commitlint.yml b/.github/workflows/commitlint.yml
new file mode 100644
index 0000000..c33af6f
--- /dev/null
+++ b/.github/workflows/commitlint.yml
@@ -0,0 +1,39 @@
+name: Commitlint
+
+on: [push, pull_request]
+
+jobs:
+ commitlint:
+ name: Run commitlint scanning
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix:
+ node-version: [23.x]
+
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ fetch-depth: 0
+
+ - name: Configure Corepack
+ run: corepack enable
+
+ - name: Use Node.js ${{ matrix.node-version }}
+ uses: actions/setup-node@v4
+ with:
+ node-version: ${{ matrix.node-version }}
+ cache: yarn
+
+ - name: Install commitlint
+ run: |
+ yarn add conventional-changelog-conventionalcommits
+ yarn add commitlint@latest
+
+ - name: Validate current commit (last commit) with commitlint
+ if: github.event_name == 'push'
+ run: npx commitlint --last --verbose
+
+ - name: Validate PR commits with commitlint
+ if: github.event_name == 'pull_request'
+ run: npx commitlint --from ${{ github.event.pull_request.base.sha }} --to ${{ github.event.pull_request.head.sha }} --verbose
diff --git a/.github/workflows/npm-build-and-compile.yml b/.github/workflows/npm-build-and-compile.yml
index d22aa36..51c4c1a 100644
--- a/.github/workflows/npm-build-and-compile.yml
+++ b/.github/workflows/npm-build-and-compile.yml
@@ -12,7 +12,7 @@ jobs:
strategy:
matrix:
- node-version: [21.x]
+ node-version: [23.x]
steps:
- uses: actions/checkout@v4
diff --git a/.husky/commit-msg b/.husky/commit-msg
new file mode 100644
index 0000000..34414dd
--- /dev/null
+++ b/.husky/commit-msg
@@ -0,0 +1 @@
+yarn dlx commitlint --edit \
diff --git a/.husky/pre-commit b/.husky/pre-commit
new file mode 100644
index 0000000..3723623
--- /dev/null
+++ b/.husky/pre-commit
@@ -0,0 +1 @@
+yarn lint-staged
diff --git a/.husky/pre-push b/.husky/pre-push
new file mode 100644
index 0000000..c69bd51
--- /dev/null
+++ b/.husky/pre-push
@@ -0,0 +1 @@
+yarn compile
diff --git a/.lintstagedrc.mjs b/.lintstagedrc.mjs
new file mode 100644
index 0000000..27118f0
--- /dev/null
+++ b/.lintstagedrc.mjs
@@ -0,0 +1,12 @@
+import path from 'path';
+import process from 'process';
+
+const buildEslintCommand = (filenames) =>
+ `eslint ${filenames.map((f) => path.relative(process.cwd(), f))}`;
+
+const prettierCommand = 'prettier --write';
+
+export default {
+ '*.{js,mjs,ts,mts}': [prettierCommand, buildEslintCommand],
+ '*.{json}': [prettierCommand],
+};
diff --git a/README.md b/README.md
index 2a8a40e..b556733 100644
--- a/README.md
+++ b/README.md
@@ -1,14 +1,27 @@
# Poixpixel's Discord Bot
> [!WARNING]
-> This Discord bot is not production ready and everything is subject to change
+> This Discord bot is not production ready.
+
+> [!TIP]
+> Want to see the bot in action? [Join our Discord server](https://discord.gg/KRTGjxx7gY).
## Development Commands
Install Dependencies: ``yarn install``
+Lint: ``yarn lint``
+
+Check Formatting: ``yarn format``
+
+Fix Formatting: ``yarn format:fix``
+
Compile: ``yarn compile``
Start: ``yarn target``
-Build & Start: ``yarn start``
+Build & Start (dev): ``yarn start:dev``
+
+Build & Start (prod): ``yarn start:prod``
+
+Restart (works only when the bot is started with ``yarn start:prod``): ``yarn restart``
diff --git a/assets/fonts/Manrope-Bold.ttf b/assets/fonts/Manrope-Bold.ttf
new file mode 100644
index 0000000..98c1c3d
Binary files /dev/null and b/assets/fonts/Manrope-Bold.ttf differ
diff --git a/assets/fonts/Manrope-Regular.ttf b/assets/fonts/Manrope-Regular.ttf
new file mode 100644
index 0000000..1a07233
Binary files /dev/null and b/assets/fonts/Manrope-Regular.ttf differ
diff --git a/config.example.json b/config.example.json
index 28fca15..32d9014 100644
--- a/config.example.json
+++ b/config.example.json
@@ -2,15 +2,61 @@
"token": "DISCORD_BOT_API_KEY",
"clientId": "DISCORD_BOT_ID",
"guildId": "DISCORD_SERVER_ID",
- "dbConnectionString": "POSTGRESQL_CONNECTION_STRING",
- "redisConnectionString": "REDIS_CONNECTION_STRING",
+ "database": {
+ "dbConnectionString": "POSTGRESQL_CONNECTION_STRING",
+ "maxRetryAttempts": "MAX_RETRY_ATTEMPTS",
+ "retryDelay": "RETRY_DELAY_IN_MS"
+ },
+ "redis": {
+ "redisConnectionString": "REDIS_CONNECTION_STRING",
+ "retryAttempts": "RETRY_ATTEMPTS",
+ "initialRetryDelay": "INITIAL_RETRY_DELAY_IN_MS"
+ },
"channels": {
"welcome": "WELCOME_CHANNEL_ID",
- "logs": "LOG_CHAANNEL_ID"
+ "logs": "LOG_CHANNEL_ID",
+ "counting": "COUNTING_CHANNEL_ID",
+ "factOfTheDay": "FACT_OF_THE_DAY_CHANNEL_ID",
+ "factApproval": "FACT_APPROVAL_CHANNEL_ID",
+ "advancements": "ADVANCEMENTS_CHANNEL_ID"
},
"roles": {
"joinRoles": [
"JOIN_ROLE_IDS"
- ]
+ ],
+ "levelRoles": [
+ {
+ "level": "LEVEL_NUMBER",
+ "roleId": "ROLE_ID"
+ },
+ {
+ "level": "LEVEL_NUMBER",
+ "roleId": "ROLE_ID"
+ },
+ {
+ "level": "LEVEL_NUMBER",
+ "roleId": "ROLE_ID"
+ }
+ ],
+ "staffRoles": [
+ {
+ "name": "ROLE_NAME",
+ "roleId": "ROLE_ID"
+ },
+ {
+ "name": "ROLE_NAME",
+ "roleId": "ROLE_ID"
+ },
+ {
+ "name": "ROLE_NAME",
+ "roleId": "ROLE_ID"
+ }
+ ],
+ "factPingRole": "FACT_OF_THE_DAY_ROLE_ID"
+ },
+ "leveling": {
+ "xpCooldown": "XP_COOLDOWN_IN_SECONDS",
+ "minXpAwarded": "MINIMUM_XP_AWARDED",
+ "maxXpAwarded": "MAXIMUM_XP_AWARDED"
}
}
diff --git a/drizzle.config.ts b/drizzle.config.ts
index 324e350..6fe8193 100644
--- a/drizzle.config.ts
+++ b/drizzle.config.ts
@@ -2,13 +2,13 @@ import fs from 'node:fs';
import { defineConfig } from 'drizzle-kit';
const config = JSON.parse(fs.readFileSync('./config.json', 'utf8'));
-const { dbConnectionString } = config;
+const { database } = config;
export default defineConfig({
out: './drizzle',
schema: './src/db/schema.ts',
dialect: 'postgresql',
dbCredentials: {
- url: dbConnectionString,
+ url: database.dbConnectionString,
},
});
diff --git a/package.json b/package.json
index 3e31f1f..1d04db1 100644
--- a/package.json
+++ b/package.json
@@ -9,10 +9,13 @@
"scripts": {
"compile": "npx tsc",
"target": "node ./target/discord-bot.js",
- "start": "yarn run compile && yarn run target",
+ "start:dev": "yarn run compile && yarn run target",
+ "start:prod": "yarn compile && pm2 start ./target/discord-bot.js --name poixpixel-discord-bot",
+ "restart": "pm2 restart poixpixel-discord-bot",
"lint": "npx eslint ./src && npx tsc --noEmit",
"format": "prettier --check --ignore-path .prettierignore .",
- "format:fix": "prettier --write --ignore-path .prettierignore ."
+ "format:fix": "prettier --write --ignore-path .prettierignore .",
+ "prepare": "husky"
},
"dependencies": {
"@napi-rs/canvas": "^0.1.68",
@@ -22,6 +25,8 @@
"pg": "^8.14.1"
},
"devDependencies": {
+ "@commitlint/cli": "^19.8.0",
+ "@commitlint/config-conventional": "^19.8.0",
"@eslint/eslintrc": "^3.3.1",
"@eslint/js": "^9.23.0",
"@microsoft/eslint-formatter-sarif": "^3.1.0",
@@ -33,10 +38,12 @@
"eslint": "^9.23.0",
"eslint-config-prettier": "^10.1.1",
"globals": "^16.0.0",
+ "husky": "^9.1.7",
+ "lint-staged": "^15.5.0",
"prettier": "3.5.3",
"ts-node": "^10.9.2",
"tsx": "^4.19.3",
"typescript": "^5.8.2"
},
- "packageManager": "yarn@4.6.0"
+ "packageManager": "yarn@4.7.0"
}
diff --git a/src/commands/fun/counting.ts b/src/commands/fun/counting.ts
new file mode 100644
index 0000000..fb8bbce
--- /dev/null
+++ b/src/commands/fun/counting.ts
@@ -0,0 +1,117 @@
+import {
+ SlashCommandBuilder,
+ EmbedBuilder,
+ PermissionsBitField,
+} from 'discord.js';
+
+import { SubcommandCommand } from '../../types/CommandTypes.js';
+import { getCountingData, setCount } from '../../util/countingManager.js';
+import { loadConfig } from '../../util/configLoader.js';
+
+const command: SubcommandCommand = {
+ data: new SlashCommandBuilder()
+ .setName('counting')
+ .setDescription('Commands related to the counting channel')
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('status')
+ .setDescription('Check the current counting status'),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('setcount')
+ .setDescription(
+ 'Set the current count to a specific number (Admin only)',
+ )
+ .addIntegerOption((option) =>
+ option
+ .setName('count')
+ .setDescription('The number to set as the current count')
+ .setRequired(true)
+ .setMinValue(0),
+ ),
+ ),
+
+ execute: async (interaction) => {
+ if (!interaction.isChatInputCommand()) return;
+
+ const subcommand = interaction.options.getSubcommand();
+
+ if (subcommand === 'status') {
+ const countingData = await getCountingData();
+ const countingChannelId = loadConfig().channels.counting;
+
+ const embed = new EmbedBuilder()
+ .setTitle('Counting Channel Status')
+ .setColor(0x0099ff)
+ .addFields(
+ {
+ name: 'Current Count',
+ value: countingData.currentCount.toString(),
+ inline: true,
+ },
+ {
+ name: 'Next Number',
+ value: (countingData.currentCount + 1).toString(),
+ inline: true,
+ },
+ {
+ name: 'Highest Count',
+ value: countingData.highestCount.toString(),
+ inline: true,
+ },
+ {
+ name: 'Total Correct Counts',
+ value: countingData.totalCorrect.toString(),
+ inline: true,
+ },
+ {
+ name: 'Counting Channel',
+ value: `<#${countingChannelId}>`,
+ inline: true,
+ },
+ )
+ .setFooter({ text: 'Remember: No user can count twice in a row!' })
+ .setTimestamp();
+
+ if (countingData.lastUserId) {
+ embed.addFields({
+ name: 'Last Counter',
+ value: `<@${countingData.lastUserId}>`,
+ inline: true,
+ });
+ }
+
+ await interaction.reply({ embeds: [embed] });
+ } else if (subcommand === 'setcount') {
+ if (
+ !interaction.memberPermissions?.has(
+ PermissionsBitField.Flags.Administrator,
+ )
+ ) {
+ await interaction.reply({
+ content: 'You need administrator permissions to use this command.',
+ flags: ['Ephemeral'],
+ });
+ return;
+ }
+
+ const count = interaction.options.getInteger('count');
+ if (count === null) {
+ await interaction.reply({
+ content: 'Invalid count specified.',
+ flags: ['Ephemeral'],
+ });
+ return;
+ }
+
+ await setCount(count);
+ await interaction.reply({
+ content: `Count has been set to **${count}**. The next number should be **${count + 1}**.`,
+ flags: ['Ephemeral'],
+ });
+ }
+ },
+};
+
+export default command;
diff --git a/src/commands/fun/fact.ts b/src/commands/fun/fact.ts
new file mode 100644
index 0000000..b0b4c93
--- /dev/null
+++ b/src/commands/fun/fact.ts
@@ -0,0 +1,245 @@
+import {
+ SlashCommandBuilder,
+ PermissionsBitField,
+ EmbedBuilder,
+ ActionRowBuilder,
+ ButtonBuilder,
+ ButtonStyle,
+} from 'discord.js';
+
+import {
+ addFact,
+ getPendingFacts,
+ approveFact,
+ deleteFact,
+ getLastInsertedFactId,
+} from '../../db/db.js';
+import { postFactOfTheDay } from '../../util/factManager.js';
+import { loadConfig } from '../../util/configLoader.js';
+import { SubcommandCommand } from '../../types/CommandTypes.js';
+
+const command: SubcommandCommand = {
+ data: new SlashCommandBuilder()
+ .setName('fact')
+ .setDescription('Manage facts of the day')
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('submit')
+ .setDescription('Submit a new fact for approval')
+ .addStringOption((option) =>
+ option
+ .setName('content')
+ .setDescription('The fact content')
+ .setRequired(true),
+ )
+ .addStringOption((option) =>
+ option
+ .setName('source')
+ .setDescription('Source of the fact (optional)')
+ .setRequired(false),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('approve')
+ .setDescription('Approve a pending fact (Mod only)')
+ .addIntegerOption((option) =>
+ option
+ .setName('id')
+ .setDescription('The ID of the fact to approve')
+ .setRequired(true),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('delete')
+ .setDescription('Delete a fact (Mod only)')
+ .addIntegerOption((option) =>
+ option
+ .setName('id')
+ .setDescription('The ID of the fact to delete')
+ .setRequired(true),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('pending')
+ .setDescription('List all pending facts (Mod only)'),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('post')
+ .setDescription('Post a fact of the day manually (Admin only)'),
+ ),
+
+ execute: async (interaction) => {
+ if (!interaction.isChatInputCommand()) return;
+
+ await interaction.deferReply({
+ flags: ['Ephemeral'],
+ });
+ await interaction.editReply('Processing...');
+
+ const config = loadConfig();
+ const subcommand = interaction.options.getSubcommand();
+
+ if (subcommand === 'submit') {
+ const content = interaction.options.getString('content', true);
+ const source = interaction.options.getString('source') || undefined;
+
+ const isAdmin = interaction.memberPermissions?.has(
+ PermissionsBitField.Flags.Administrator,
+ );
+
+ await addFact({
+ content,
+ source,
+ addedBy: interaction.user.id,
+ approved: isAdmin ? true : false,
+ });
+
+ if (!isAdmin) {
+ const approvalChannel = interaction.guild?.channels.cache.get(
+ config.channels.factApproval,
+ );
+
+ if (approvalChannel?.isTextBased()) {
+ const embed = new EmbedBuilder()
+ .setTitle('New Fact Submission')
+ .setDescription(content)
+ .setColor(0x0099ff)
+ .addFields(
+ {
+ name: 'Submitted By',
+ value: `<@${interaction.user.id}>`,
+ inline: true,
+ },
+ { name: 'Source', value: source || 'Not provided', inline: true },
+ )
+ .setTimestamp();
+
+ const factId = await getLastInsertedFactId();
+
+ const approveButton = new ButtonBuilder()
+ .setCustomId(`approve_fact_${factId}`)
+ .setLabel('Approve')
+ .setStyle(ButtonStyle.Success);
+
+ const rejectButton = new ButtonBuilder()
+ .setCustomId(`reject_fact_${factId}`)
+ .setLabel('Reject')
+ .setStyle(ButtonStyle.Danger);
+
+ const row = new ActionRowBuilder<ButtonBuilder>().addComponents(
+ approveButton,
+ rejectButton,
+ );
+
+ await approvalChannel.send({
+ embeds: [embed],
+ components: [row],
+ });
+ } else {
+ console.error('Approval channel not found or is not a text channel');
+ }
+ }
+
+ await interaction.editReply({
+ content: isAdmin
+ ? 'Your fact has been automatically approved and added to the database!'
+ : 'Your fact has been submitted for approval!',
+ });
+ } else if (subcommand === 'approve') {
+ if (
+ !interaction.memberPermissions?.has(
+ PermissionsBitField.Flags.ModerateMembers,
+ )
+ ) {
+ await interaction.editReply({
+ content: 'You do not have permission to approve facts.',
+ });
+ return;
+ }
+
+ const id = interaction.options.getInteger('id', true);
+ await approveFact(id);
+
+ await interaction.editReply({
+ content: `Fact #${id} has been approved!`,
+ });
+ } else if (subcommand === 'delete') {
+ if (
+ !interaction.memberPermissions?.has(
+ PermissionsBitField.Flags.ModerateMembers,
+ )
+ ) {
+ await interaction.editReply({
+ content: 'You do not have permission to delete facts.',
+ });
+ return;
+ }
+
+ const id = interaction.options.getInteger('id', true);
+ await deleteFact(id);
+
+ await interaction.editReply({
+ content: `Fact #${id} has been deleted!`,
+ });
+ } else if (subcommand === 'pending') {
+ if (
+ !interaction.memberPermissions?.has(
+ PermissionsBitField.Flags.ModerateMembers,
+ )
+ ) {
+ await interaction.editReply({
+ content: 'You do not have permission to view pending facts.',
+ });
+ return;
+ }
+
+ const pendingFacts = await getPendingFacts();
+
+ if (pendingFacts.length === 0) {
+ await interaction.editReply({
+ content: 'There are no pending facts.',
+ });
+ return;
+ }
+
+ const embed = new EmbedBuilder()
+ .setTitle('Pending Facts')
+ .setColor(0x0099ff)
+ .setDescription(
+ pendingFacts
+ .map((fact) => {
+ return `**ID #${fact.id}**\n${fact.content}\nSubmitted by: <@${fact.addedBy}>\nSource: ${fact.source || 'Not provided'}`;
+ })
+ .join('\n\n'),
+ )
+ .setTimestamp();
+
+ await interaction.editReply({
+ embeds: [embed],
+ });
+ } else if (subcommand === 'post') {
+ if (
+ !interaction.memberPermissions?.has(
+ PermissionsBitField.Flags.Administrator,
+ )
+ ) {
+ await interaction.editReply({
+ content: 'You do not have permission to manually post facts.',
+ });
+ return;
+ }
+
+ await postFactOfTheDay(interaction.client);
+
+ await interaction.editReply({
+ content: 'Fact of the day has been posted!',
+ });
+ }
+ },
+};
+
+export default command;
diff --git a/src/commands/fun/leaderboard.ts b/src/commands/fun/leaderboard.ts
new file mode 100644
index 0000000..0d37fef
--- /dev/null
+++ b/src/commands/fun/leaderboard.ts
@@ -0,0 +1,171 @@
+import {
+ SlashCommandBuilder,
+ EmbedBuilder,
+ ButtonBuilder,
+ ActionRowBuilder,
+ ButtonStyle,
+ StringSelectMenuBuilder,
+ APIEmbed,
+ JSONEncodable,
+} from 'discord.js';
+
+import { OptionsCommand } from '../../types/CommandTypes.js';
+import { getLevelLeaderboard } from '../../db/db.js';
+
+const command: OptionsCommand = {
+ data: new SlashCommandBuilder()
+ .setName('leaderboard')
+ .setDescription('Shows the server XP leaderboard')
+ .addIntegerOption((option) =>
+ option
+ .setName('limit')
+ .setDescription('Number of users per page (default: 10)')
+ .setRequired(false),
+ ),
+ execute: async (interaction) => {
+ if (!interaction.guild) return;
+
+ await interaction.deferReply();
+
+ try {
+ const usersPerPage =
+ (interaction.options.get('limit')?.value as number) || 10;
+
+ const allUsers = await getLevelLeaderboard(100);
+
+ if (allUsers.length === 0) {
+ const embed = new EmbedBuilder()
+ .setTitle('🏆 Server Leaderboard')
+ .setColor(0x5865f2)
+ .setDescription('No users found on the leaderboard yet.')
+ .setTimestamp();
+
+ await interaction.editReply({ embeds: [embed] });
+ }
+
+ const pages: (APIEmbed | JSONEncodable<APIEmbed>)[] = [];
+
+ for (let i = 0; i < allUsers.length; i += usersPerPage) {
+ const pageUsers = allUsers.slice(i, i + usersPerPage);
+ let leaderboardText = '';
+
+ for (let j = 0; j < pageUsers.length; j++) {
+ const user = pageUsers[j];
+ const position = i + j + 1;
+
+ try {
+ const member = await interaction.guild.members.fetch(
+ user.discordId,
+ );
+ leaderboardText += `**${position}.** ${member} - Level ${user.level} (${user.xp} XP)\n`;
+ } catch (error) {
+ leaderboardText += `**${position}.** <@${user.discordId}> - Level ${user.level} (${user.xp} XP)\n`;
+ }
+ }
+
+ const embed = new EmbedBuilder()
+ .setTitle('🏆 Server Leaderboard')
+ .setColor(0x5865f2)
+ .setDescription(leaderboardText)
+ .setTimestamp()
+ .setFooter({
+ text: `Page ${Math.floor(i / usersPerPage) + 1} of ${Math.ceil(allUsers.length / usersPerPage)}`,
+ });
+
+ pages.push(embed);
+ }
+
+ let currentPage = 0;
+
+ const getButtonActionRow = () =>
+ new ActionRowBuilder<ButtonBuilder>().addComponents(
+ new ButtonBuilder()
+ .setCustomId('previous')
+ .setLabel('Previous')
+ .setStyle(ButtonStyle.Primary)
+ .setDisabled(currentPage === 0),
+ new ButtonBuilder()
+ .setCustomId('next')
+ .setLabel('Next')
+ .setStyle(ButtonStyle.Primary)
+ .setDisabled(currentPage === pages.length - 1),
+ );
+
+ const getSelectMenuRow = () => {
+ const options = pages.map((_, index) => ({
+ label: `Page ${index + 1}`,
+ value: index.toString(),
+ default: index === currentPage,
+ }));
+
+ const select = new StringSelectMenuBuilder()
+ .setCustomId('select_page')
+ .setPlaceholder('Jump to a page')
+ .addOptions(options);
+
+ return new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
+ select,
+ );
+ };
+
+ const components =
+ pages.length > 1 ? [getButtonActionRow(), getSelectMenuRow()] : [];
+
+ const message = await interaction.editReply({
+ embeds: [pages[currentPage]],
+ components,
+ });
+
+ if (pages.length <= 1) return;
+
+ const collector = message.createMessageComponentCollector({
+ time: 60000,
+ });
+
+ collector.on('collect', async (i) => {
+ if (i.user.id !== interaction.user.id) {
+ await i.reply({
+ content: 'These controls are not for you!',
+ flags: ['Ephemeral'],
+ });
+ return;
+ }
+
+ if (i.isButton()) {
+ if (i.customId === 'previous' && currentPage > 0) {
+ currentPage--;
+ } else if (i.customId === 'next' && currentPage < pages.length - 1) {
+ currentPage++;
+ }
+ }
+
+ if (i.isStringSelectMenu()) {
+ const selected = parseInt(i.values[0]);
+ if (!isNaN(selected) && selected >= 0 && selected < pages.length) {
+ currentPage = selected;
+ }
+ }
+
+ await i.update({
+ embeds: [pages[currentPage]],
+ components: [getButtonActionRow(), getSelectMenuRow()],
+ });
+ });
+
+ collector.on('end', async () => {
+ if (message) {
+ try {
+ await interaction.editReply({ components: [] });
+ } catch (error) {
+ console.error('Error removing components:', error);
+ }
+ }
+ });
+ } catch (error) {
+ console.error('Error getting leaderboard:', error);
+ await interaction.editReply('Failed to get leaderboard information.');
+ }
+ },
+};
+
+export default command;
diff --git a/src/commands/fun/rank.ts b/src/commands/fun/rank.ts
new file mode 100644
index 0000000..0007d05
--- /dev/null
+++ b/src/commands/fun/rank.ts
@@ -0,0 +1,49 @@
+import { GuildMember, SlashCommandBuilder } from 'discord.js';
+
+import { OptionsCommand } from '../../types/CommandTypes.js';
+import {
+ generateRankCard,
+ getXpToNextLevel,
+} from '../../util/levelingSystem.js';
+import { getUserLevel } from '../../db/db.js';
+
+const command: OptionsCommand = {
+ data: new SlashCommandBuilder()
+ .setName('rank')
+ .setDescription('Shows your current rank and level')
+ .addUserOption((option) =>
+ option
+ .setName('user')
+ .setDescription('The user to check rank for (defaults to yourself)')
+ .setRequired(false),
+ ),
+ execute: async (interaction) => {
+ const member = await interaction.guild?.members.fetch(
+ (interaction.options.get('user')?.value as string) || interaction.user.id,
+ );
+
+ if (!member) {
+ await interaction.reply('User not found in this server.');
+ return;
+ }
+
+ await interaction.deferReply();
+
+ try {
+ const userData = await getUserLevel(member.id);
+ const rankCard = await generateRankCard(member, userData);
+
+ const xpToNextLevel = getXpToNextLevel(userData.level, userData.xp);
+
+ await interaction.editReply({
+ content: `${member}'s rank - Level ${userData.level} (${userData.xp} XP, ${xpToNextLevel} XP until next level)`,
+ files: [rankCard],
+ });
+ } catch (error) {
+ console.error('Error getting rank:', error);
+ await interaction.editReply('Failed to get rank information.');
+ }
+ },
+};
+
+export default command;
diff --git a/src/commands/util/members.ts b/src/commands/util/members.ts
index 083ee64..e1bc945 100644
--- a/src/commands/util/members.ts
+++ b/src/commands/util/members.ts
@@ -19,7 +19,7 @@ const command: Command = {
execute: async (interaction) => {
let members = await getAllMembers();
members = members.sort((a, b) =>
- a.discordUsername.localeCompare(b.discordUsername),
+ (a.discordUsername ?? '').localeCompare(b.discordUsername ?? ''),
);
const ITEMS_PER_PAGE = 15;
diff --git a/src/commands/util/recalculatelevels.ts b/src/commands/util/recalculatelevels.ts
new file mode 100644
index 0000000..0667d1a
--- /dev/null
+++ b/src/commands/util/recalculatelevels.ts
@@ -0,0 +1,36 @@
+import { PermissionsBitField, SlashCommandBuilder } from 'discord.js';
+
+import { Command } from '../../types/CommandTypes.js';
+import { recalculateUserLevels } from '../../util/levelingSystem.js';
+
+const command: Command = {
+ data: new SlashCommandBuilder()
+ .setName('recalculatelevels')
+ .setDescription('(Admin Only) Recalculate all user levels'),
+ execute: async (interaction) => {
+ if (
+ !interaction.memberPermissions?.has(
+ PermissionsBitField.Flags.Administrator,
+ )
+ ) {
+ await interaction.reply({
+ content: 'You do not have permission to use this command.',
+ flags: ['Ephemeral'],
+ });
+ return;
+ }
+
+ await interaction.deferReply();
+ await interaction.editReply('Recalculating levels...');
+
+ try {
+ await recalculateUserLevels();
+ await interaction.editReply('Levels recalculated successfully!');
+ } catch (error) {
+ console.error('Error recalculating levels:', error);
+ await interaction.editReply('Failed to recalculate levels.');
+ }
+ },
+};
+
+export default command;
diff --git a/src/commands/util/reconnect.ts b/src/commands/util/reconnect.ts
new file mode 100644
index 0000000..a4ed8f0
--- /dev/null
+++ b/src/commands/util/reconnect.ts
@@ -0,0 +1,203 @@
+import {
+ CommandInteraction,
+ PermissionsBitField,
+ SlashCommandBuilder,
+} from 'discord.js';
+
+import { SubcommandCommand } from '../../types/CommandTypes.js';
+import { loadConfig } from '../../util/configLoader.js';
+import {
+ initializeDatabaseConnection,
+ ensureDbInitialized,
+} from '../../db/db.js';
+import { isRedisConnected } from '../../db/redis.js';
+import {
+ NotificationType,
+ notifyManagers,
+} from '../../util/notificationHandler.js';
+
+const command: SubcommandCommand = {
+ data: new SlashCommandBuilder()
+ .setName('reconnect')
+ .setDescription('(Manager Only) Force reconnection to database or Redis')
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('database')
+ .setDescription('(Manager Only) Force reconnection to the database'),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('redis')
+ .setDescription('(Manager Only) Force reconnection to Redis cache'),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('status')
+ .setDescription(
+ '(Manager Only) Check connection status of database and Redis',
+ ),
+ ),
+
+ execute: async (interaction) => {
+ if (!interaction.isChatInputCommand()) return;
+
+ const config = loadConfig();
+ const managerRoleId = config.roles.staffRoles.find(
+ (role) => role.name === 'Manager',
+ )?.roleId;
+
+ const member = await interaction.guild?.members.fetch(interaction.user.id);
+ const hasManagerRole = member?.roles.cache.has(managerRoleId || '');
+
+ if (
+ !hasManagerRole &&
+ !interaction.memberPermissions?.has(
+ PermissionsBitField.Flags.Administrator,
+ )
+ ) {
+ await interaction.reply({
+ content:
+ 'You do not have permission to use this command. This command is restricted to users with the Manager role.',
+ flags: ['Ephemeral'],
+ });
+ return;
+ }
+
+ const subcommand = interaction.options.getSubcommand();
+
+ await interaction.deferReply({ flags: ['Ephemeral'] });
+
+ try {
+ if (subcommand === 'database') {
+ await handleDatabaseReconnect(interaction);
+ } else if (subcommand === 'redis') {
+ await handleRedisReconnect(interaction);
+ } else if (subcommand === 'status') {
+ await handleStatusCheck(interaction);
+ }
+ } catch (error) {
+ console.error(`Error in reconnect command (${subcommand}):`, error);
+ await interaction.editReply({
+ content: `An error occurred while processing the reconnect command: \`${error}\``,
+ });
+ }
+ },
+};
+
+/**
+ * Handle database reconnection
+ */
+async function handleDatabaseReconnect(interaction: CommandInteraction) {
+ await interaction.editReply('Attempting to reconnect to the database...');
+
+ try {
+ const success = await initializeDatabaseConnection();
+
+ if (success) {
+ await interaction.editReply(
+ '✅ **Database reconnection successful!** All database functions should now be operational.',
+ );
+
+ notifyManagers(
+ interaction.client,
+ NotificationType.DATABASE_CONNECTION_RESTORED,
+ `Database connection manually restored by ${interaction.user.tag}`,
+ );
+ } else {
+ await interaction.editReply(
+ '❌ **Database reconnection failed.** Check the logs for more details.',
+ );
+ }
+ } catch (error) {
+ console.error('Error reconnecting to database:', error);
+ await interaction.editReply(
+ `❌ **Database reconnection failed with error:** \`${error}\``,
+ );
+ }
+}
+
+/**
+ * Handle Redis reconnection
+ */
+async function handleRedisReconnect(interaction: CommandInteraction) {
+ await interaction.editReply('Attempting to reconnect to Redis...');
+
+ try {
+ const redisModule = await import('../../db/redis.js');
+
+ await redisModule.ensureRedisConnection();
+
+ const isConnected = redisModule.isRedisConnected();
+
+ if (isConnected) {
+ await interaction.editReply(
+ '✅ **Redis reconnection successful!** Cache functionality is now available.',
+ );
+
+ notifyManagers(
+ interaction.client,
+ NotificationType.REDIS_CONNECTION_RESTORED,
+ `Redis connection manually restored by ${interaction.user.tag}`,
+ );
+ } else {
+ await interaction.editReply(
+ '❌ **Redis reconnection failed.** The bot will continue to function without caching capabilities.',
+ );
+ }
+ } catch (error) {
+ console.error('Error reconnecting to Redis:', error);
+ await interaction.editReply(
+ `❌ **Redis reconnection failed with error:** \`${error}\``,
+ );
+ }
+}
+
+/**
+ * Handle status check for both services
+ */
+async function handleStatusCheck(interaction: any) {
+ await interaction.editReply('Checking connection status...');
+
+ try {
+ const dbStatus = await (async () => {
+ try {
+ await ensureDbInitialized();
+ return true;
+ } catch {
+ return false;
+ }
+ })();
+
+ const redisStatus = isRedisConnected();
+
+ const statusEmbed = {
+ title: '🔌 Service Connection Status',
+ fields: [
+ {
+ name: 'Database',
+ value: dbStatus ? '✅ Connected' : '❌ Disconnected',
+ inline: true,
+ },
+ {
+ name: 'Redis Cache',
+ value: redisStatus
+ ? '✅ Connected'
+ : '⚠️ Disconnected (caching disabled)',
+ inline: true,
+ },
+ ],
+ color:
+ dbStatus && redisStatus ? 0x00ff00 : dbStatus ? 0xffaa00 : 0xff0000,
+ timestamp: new Date().toISOString(),
+ };
+
+ await interaction.editReply({ content: '', embeds: [statusEmbed] });
+ } catch (error) {
+ console.error('Error checking connection status:', error);
+ await interaction.editReply(
+ `❌ **Error checking connection status:** \`${error}\``,
+ );
+ }
+}
+
+export default command;
diff --git a/src/commands/util/restart.ts b/src/commands/util/restart.ts
new file mode 100644
index 0000000..bf7afb4
--- /dev/null
+++ b/src/commands/util/restart.ts
@@ -0,0 +1,93 @@
+import { PermissionsBitField, SlashCommandBuilder } from 'discord.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+import { Command } from '../../types/CommandTypes.js';
+import { loadConfig } from '../../util/configLoader.js';
+import {
+ NotificationType,
+ notifyManagers,
+} from '../../util/notificationHandler.js';
+import { isRedisConnected } from '../../db/redis.js';
+import { ensureDatabaseConnection } from '../../db/db.js';
+
+const execAsync = promisify(exec);
+
+const command: Command = {
+ data: new SlashCommandBuilder()
+ .setName('restart')
+ .setDescription('(Manager Only) Restart the bot'),
+ execute: async (interaction) => {
+ const config = loadConfig();
+ const managerRoleId = config.roles.staffRoles.find(
+ (role) => role.name === 'Manager',
+ )?.roleId;
+
+ const member = await interaction.guild?.members.fetch(interaction.user.id);
+ const hasManagerRole = member?.roles.cache.has(managerRoleId || '');
+
+ if (
+ !hasManagerRole &&
+ !interaction.memberPermissions?.has(
+ PermissionsBitField.Flags.Administrator,
+ )
+ ) {
+ await interaction.reply({
+ content:
+ 'You do not have permission to restart the bot. This command is restricted to users with the Manager role.',
+ flags: ['Ephemeral'],
+ });
+ return;
+ }
+
+ await interaction.reply({
+ content: 'Restarting the bot... This may take a few moments.',
+ flags: ['Ephemeral'],
+ });
+
+ const dbConnected = await ensureDatabaseConnection();
+ const redisConnected = isRedisConnected();
+ let statusInfo = '';
+
+ if (!dbConnected) {
+ statusInfo += '⚠️ Database is currently disconnected\n';
+ }
+
+ if (!redisConnected) {
+ statusInfo += '⚠️ Redis caching is currently unavailable\n';
+ }
+
+ if (dbConnected && redisConnected) {
+ statusInfo = '✅ All services are operational\n';
+ }
+
+ await notifyManagers(
+ interaction.client,
+ NotificationType.BOT_RESTARTING,
+ `Restart initiated by ${interaction.user.tag}\n\nCurrent service status:\n${statusInfo}`,
+ );
+
+ setTimeout(async () => {
+ try {
+ console.log(
+ `Bot restart initiated by ${interaction.user.tag} (${interaction.user.id})`,
+ );
+
+ await execAsync('yarn restart');
+ } catch (error) {
+ console.error('Failed to restart the bot:', error);
+ try {
+ await interaction.followUp({
+ content:
+ 'Failed to restart the bot. Check the console for details.',
+ flags: ['Ephemeral'],
+ });
+ } catch {
+ // If this fails too, we can't do much
+ }
+ }
+ }, 1000);
+ },
+};
+
+export default command;
diff --git a/src/commands/util/xp.ts b/src/commands/util/xp.ts
new file mode 100644
index 0000000..cac94e8
--- /dev/null
+++ b/src/commands/util/xp.ts
@@ -0,0 +1,132 @@
+import { SlashCommandBuilder } from 'discord.js';
+
+import { SubcommandCommand } from '../../types/CommandTypes.js';
+import { addXpToUser, getUserLevel } from '../../db/db.js';
+import { loadConfig } from '../../util/configLoader.js';
+
+const command: SubcommandCommand = {
+ data: new SlashCommandBuilder()
+ .setName('xp')
+ .setDescription('(Manager only) Manage user XP')
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('add')
+ .setDescription('Add XP to a member')
+ .addUserOption((option) =>
+ option
+ .setName('user')
+ .setDescription('The user to add XP to')
+ .setRequired(true),
+ )
+ .addIntegerOption((option) =>
+ option
+ .setName('amount')
+ .setDescription('The amount of XP to add')
+ .setRequired(true),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('remove')
+ .setDescription('Remove XP from a member')
+ .addUserOption((option) =>
+ option
+ .setName('user')
+ .setDescription('The user to remove XP from')
+ .setRequired(true),
+ )
+ .addIntegerOption((option) =>
+ option
+ .setName('amount')
+ .setDescription('The amount of XP to remove')
+ .setRequired(true),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('set')
+ .setDescription('Set XP for a member')
+ .addUserOption((option) =>
+ option
+ .setName('user')
+ .setDescription('The user to set XP for')
+ .setRequired(true),
+ )
+ .addIntegerOption((option) =>
+ option
+ .setName('amount')
+ .setDescription('The amount of XP to set')
+ .setRequired(true),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('reset')
+ .setDescription('Reset XP for a member')
+ .addUserOption((option) =>
+ option
+ .setName('user')
+ .setDescription('The user to reset XP for')
+ .setRequired(true),
+ ),
+ ),
+ execute: async (interaction) => {
+ if (!interaction.isChatInputCommand()) return;
+
+ const commandUser = interaction.guild?.members.cache.get(
+ interaction.user.id,
+ );
+
+ const config = loadConfig();
+ const managerRoleId = config.roles.staffRoles.find(
+ (role) => role.name === 'Manager',
+ )?.roleId;
+
+ if (
+ !commandUser ||
+ !managerRoleId ||
+ commandUser.roles.highest.comparePositionTo(managerRoleId) < 0
+ ) {
+ await interaction.reply({
+ content: 'You do not have permission to use this command',
+ flags: ['Ephemeral'],
+ });
+ return;
+ }
+
+ await interaction.deferReply({
+ flags: ['Ephemeral'],
+ });
+ await interaction.editReply('Processing...');
+
+ const subcommand = interaction.options.getSubcommand();
+ const user = interaction.options.getUser('user', true);
+ const amount = interaction.options.getInteger('amount', false);
+
+ const userData = await getUserLevel(user.id);
+
+ if (subcommand === 'add') {
+ await addXpToUser(user.id, amount!);
+ await interaction.editReply({
+ content: `Added ${amount} XP to <@${user.id}>`,
+ });
+ } else if (subcommand === 'remove') {
+ await addXpToUser(user.id, -amount!);
+ await interaction.editReply({
+ content: `Removed ${amount} XP from <@${user.id}>`,
+ });
+ } else if (subcommand === 'set') {
+ await addXpToUser(user.id, amount! - userData.xp);
+ await interaction.editReply({
+ content: `Set ${amount} XP for <@${user.id}>`,
+ });
+ } else if (subcommand === 'reset') {
+ await addXpToUser(user.id, userData.xp * -1);
+ await interaction.editReply({
+ content: `Reset XP for <@${user.id}>`,
+ });
+ }
+ },
+};
+
+export default command;
diff --git a/src/db/db.ts b/src/db/db.ts
index ebc2db8..23e57f2 100644
--- a/src/db/db.ts
+++ b/src/db/db.ts
@@ -1,20 +1,34 @@
import pkg from 'pg';
import { drizzle } from 'drizzle-orm/node-postgres';
-import { eq } from 'drizzle-orm';
+import { Client, Collection, GuildMember } from 'discord.js';
+import { and, desc, eq, isNull, sql } from 'drizzle-orm';
import * as schema from './schema.js';
import { loadConfig } from '../util/configLoader.js';
import { del, exists, getJson, setJson } from './redis.js';
+import { calculateLevelFromXp } from '../util/levelingSystem.js';
+import {
+ logManagerNotification,
+ NotificationType,
+ notifyManagers,
+} from '../util/notificationHandler.js';
const { Pool } = pkg;
const config = loadConfig();
-const dbPool = new Pool({
- connectionString: config.dbConnectionString,
- ssl: true,
-});
-export const db = drizzle({ client: dbPool, schema });
+// Database connection state
+let isDbConnected = false;
+let connectionAttempts = 0;
+const MAX_DB_RETRY_ATTEMPTS = config.database.maxRetryAttempts;
+const INITIAL_DB_RETRY_DELAY = config.database.retryDelay;
+let hasNotifiedDbDisconnect = false;
+let discordClient: Client | null = null;
+let dbPool: pkg.Pool;
+export let db: ReturnType<typeof drizzle>;
+/**
+ * Custom error class for database errors
+ */
class DatabaseError extends Error {
constructor(
message: string,
@@ -25,121 +39,358 @@ class DatabaseError extends Error {
}
}
+/**
+ * Sets the Discord client for sending notifications
+ * @param client - The Discord client
+ */
+export function setDiscordClient(client: Client): void {
+ discordClient = client;
+}
+
+/**
+ * Initializes the database connection with retry logic
+ */
+export async function initializeDatabaseConnection(): Promise<boolean> {
+ try {
+ if (dbPool) {
+ try {
+ await dbPool.query('SELECT 1');
+ isDbConnected = true;
+ return true;
+ } catch (error) {
+ console.warn(
+ 'Existing database connection is not responsive, creating a new one',
+ );
+ try {
+ await dbPool.end();
+ } catch (endError) {
+ console.error('Error ending pool:', endError);
+ }
+ }
+ }
+
+ // Log the database connection string (without sensitive info)
+ console.log(
+ `Connecting to database... (connectionString length: ${config.database.dbConnectionString.length})`,
+ );
+
+ dbPool = new Pool({
+ connectionString: config.database.dbConnectionString,
+ ssl: true,
+ connectionTimeoutMillis: 10000,
+ });
+
+ await dbPool.query('SELECT 1');
+
+ db = drizzle({ client: dbPool, schema });
+
+ console.info('Successfully connected to database');
+ isDbConnected = true;
+ connectionAttempts = 0;
+
+ if (hasNotifiedDbDisconnect && discordClient) {
+ logManagerNotification(NotificationType.DATABASE_CONNECTION_RESTORED);
+ notifyManagers(
+ discordClient,
+ NotificationType.DATABASE_CONNECTION_RESTORED,
+ );
+ hasNotifiedDbDisconnect = false;
+ }
+
+ return true;
+ } catch (error) {
+ console.error('Failed to connect to database:', error);
+ isDbConnected = false;
+ connectionAttempts++;
+
+ if (connectionAttempts >= MAX_DB_RETRY_ATTEMPTS) {
+ if (!hasNotifiedDbDisconnect && discordClient) {
+ const message = `Failed to connect to database after ${connectionAttempts} attempts.`;
+ console.error(message);
+ logManagerNotification(
+ NotificationType.DATABASE_CONNECTION_LOST,
+ `Error: ${error}`,
+ );
+ notifyManagers(
+ discordClient,
+ NotificationType.DATABASE_CONNECTION_LOST,
+ `Connection attempts exhausted after ${connectionAttempts} tries. The bot cannot function without database access and will now terminate.`,
+ );
+ hasNotifiedDbDisconnect = true;
+ }
+
+ setTimeout(() => {
+ console.error('Database connection failed, shutting down bot');
+ process.exit(1);
+ }, 3000);
+
+ return false;
+ }
+
+ // Try to reconnect after delay with exponential backoff
+ const delay = Math.min(
+ INITIAL_DB_RETRY_DELAY * Math.pow(2, connectionAttempts - 1),
+ 30000,
+ );
+ console.log(
+ `Retrying database connection in ${delay}ms... (Attempt ${connectionAttempts}/${MAX_DB_RETRY_ATTEMPTS})`,
+ );
+
+ setTimeout(initializeDatabaseConnection, delay);
+
+ return false;
+ }
+}
+
+// Replace existing initialization with a properly awaited one
+let dbInitPromise = initializeDatabaseConnection().catch((error) => {
+ console.error('Failed to initialize database connection:', error);
+ process.exit(1);
+});
+
+/**
+ * Ensures the database is initialized and returns a promise
+ * @returns Promise for database initialization
+ */
+export async function ensureDbInitialized(): Promise<void> {
+ await dbInitPromise;
+
+ if (!isDbConnected) {
+ dbInitPromise = initializeDatabaseConnection();
+ await dbInitPromise;
+ }
+}
+
+/**
+ * Checks if the database connection is active and working
+ * @returns Promise resolving to true if connected, false otherwise
+ */
+export async function ensureDatabaseConnection(): Promise<boolean> {
+ await ensureDbInitialized();
+
+ if (!isDbConnected) {
+ return await initializeDatabaseConnection();
+ }
+
+ try {
+ await dbPool.query('SELECT 1');
+ return true;
+ } catch (error) {
+ console.error('Database connection test failed:', error);
+ isDbConnected = false;
+ return await initializeDatabaseConnection();
+ }
+}
+
+// ========================
+// Helper functions
+// ========================
+
+/**
+ * Generic error handler for database operations
+ * @param errorMessage - Error message to log
+ * @param error - Original error object
+ */
+export const handleDbError = (errorMessage: string, error: Error): never => {
+ console.error(`${errorMessage}: `, error);
+
+ if (
+ error.message.includes('connection') ||
+ error.message.includes('connect')
+ ) {
+ isDbConnected = false;
+ ensureDatabaseConnection().catch((err) => {
+ console.error('Failed to reconnect to database:', err);
+ });
+ }
+
+ throw new DatabaseError(errorMessage, error);
+};
+
+/**
+ * Checks and retrieves cached data or fetches from database
+ * @param cacheKey - Key to check in cache
+ * @param dbFetch - Function to fetch data from database
+ * @param ttl - Time to live for cache
+ * @returns Cached or fetched data
+ */
+async function withCache<T>(
+ cacheKey: string,
+ dbFetch: () => Promise<T>,
+ ttl?: number,
+): Promise<T> {
+ try {
+ const cachedData = await getJson<T>(cacheKey);
+ if (cachedData !== null) {
+ return cachedData;
+ }
+ } catch (error) {
+ console.warn(
+ `Cache retrieval failed for ${cacheKey}, falling back to database:`,
+ error,
+ );
+ }
+
+ const data = await dbFetch();
+
+ try {
+ await setJson(cacheKey, data, ttl);
+ } catch (error) {
+ console.warn(`Failed to cache data for ${cacheKey}:`, error);
+ }
+
+ return data;
+}
+
+/**
+ * Invalidates a cache key if it exists
+ * @param cacheKey - Key to invalidate
+ */
+async function invalidateCache(cacheKey: string): Promise<void> {
+ try {
+ if (await exists(cacheKey)) {
+ await del(cacheKey);
+ }
+ } catch (error) {
+ console.warn(`Error invalidating cache for key ${cacheKey}:`, error);
+ }
+}
+
+// ========================
+// Member Functions
+// ========================
+
+/**
+ * Get all non-bot members currently in the server
+ * @returns Array of member objects
+ */
export async function getAllMembers() {
try {
- if (await exists('nonBotMembers')) {
- const memberData =
- await getJson<(typeof schema.memberTable.$inferSelect)[]>(
- 'nonBotMembers',
- );
- if (memberData && memberData.length > 0) {
- return memberData;
- } else {
- await del('nonBotMembers');
- return await getAllMembers();
- }
- } else {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot get members');
+ }
+
+ const cacheKey = 'nonBotMembers';
+ return await withCache<schema.memberTableTypes[]>(cacheKey, async () => {
const nonBotMembers = await db
.select()
.from(schema.memberTable)
.where(eq(schema.memberTable.currentlyInServer, true));
- await setJson<(typeof schema.memberTable.$inferSelect)[]>(
- 'nonBotMembers',
- nonBotMembers,
- );
return nonBotMembers;
- }
- } catch (error) {
- console.error('Error getting all members: ', error);
- throw new DatabaseError('Failed to get all members: ', error as Error);
- }
-}
-
-export async function setMembers(nonBotMembers: any) {
- try {
- nonBotMembers.forEach(async (member: any) => {
- const memberInfo = await db
- .select()
- .from(schema.memberTable)
- .where(eq(schema.memberTable.discordId, member.user.id));
- if (memberInfo.length > 0) {
- await updateMember({
- discordId: member.user.id,
- discordUsername: member.user.username,
- currentlyInServer: true,
- });
- } else {
- const members: typeof schema.memberTable.$inferInsert = {
- discordId: member.user.id,
- discordUsername: member.user.username,
- };
- await db.insert(schema.memberTable).values(members);
- }
});
} catch (error) {
- console.error('Error setting members: ', error);
- throw new DatabaseError('Failed to set members: ', error as Error);
+ return handleDbError('Failed to get all members', error as Error);
}
}
-export async function getMember(discordId: string) {
+/**
+ * Set or update multiple members at once
+ * @param nonBotMembers - Array of member objects
+ */
+export async function setMembers(
+ nonBotMembers: Collection<string, GuildMember>,
+): Promise<void> {
try {
- if (await exists(`${discordId}-memberInfo`)) {
- const cachedMember = await getJson<
- typeof schema.memberTable.$inferSelect
- >(`${discordId}-memberInfo`);
- const cachedModerationHistory = await getJson<
- (typeof schema.moderationTable.$inferSelect)[]
- >(`${discordId}-moderationHistory`);
+ await ensureDbInitialized();
- if (
- cachedMember &&
- 'discordId' in cachedMember &&
- cachedModerationHistory &&
- cachedModerationHistory.length > 0
- ) {
- return {
- ...cachedMember,
- moderations: cachedModerationHistory,
- };
- } else {
- await del(`${discordId}-memberInfo`);
- await del(`${discordId}-moderationHistory`);
- return await getMember(discordId);
- }
- } else {
- const member = await db.query.memberTable.findFirst({
- where: eq(schema.memberTable.discordId, discordId),
- with: {
- moderations: true,
- },
- });
-
- await setJson<typeof schema.memberTable.$inferSelect>(
- `${discordId}-memberInfo`,
- member!,
- );
- await setJson<(typeof schema.moderationTable.$inferSelect)[]>(
- `${discordId}-moderationHistory`,
- member!.moderations,
- );
-
- return member;
+ if (!db) {
+ console.error('Database not initialized, cannot set members');
}
+
+ await Promise.all(
+ nonBotMembers.map(async (member) => {
+ const memberInfo = await db
+ .select()
+ .from(schema.memberTable)
+ .where(eq(schema.memberTable.discordId, member.user.id));
+
+ if (memberInfo.length > 0) {
+ await updateMember({
+ discordId: member.user.id,
+ discordUsername: member.user.username,
+ currentlyInServer: true,
+ });
+ } else {
+ const members: typeof schema.memberTable.$inferInsert = {
+ discordId: member.user.id,
+ discordUsername: member.user.username,
+ };
+ await db.insert(schema.memberTable).values(members);
+ }
+ }),
+ );
} catch (error) {
- console.error('Error getting member: ', error);
- throw new DatabaseError('Failed to get member: ', error as Error);
+ handleDbError('Failed to set members', error as Error);
}
}
+/**
+ * Get detailed information about a specific member including moderation history
+ * @param discordId - Discord ID of the user
+ * @returns Member object with moderation history
+ */
+export async function getMember(
+ discordId: string,
+): Promise<
+ | (schema.memberTableTypes & { moderations: schema.moderationTableTypes[] })
+ | undefined
+> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot get member');
+ }
+
+ const cacheKey = `${discordId}-memberInfo`;
+
+ const member = await withCache<schema.memberTableTypes>(
+ cacheKey,
+ async () => {
+ const memberData = await db
+ .select()
+ .from(schema.memberTable)
+ .where(eq(schema.memberTable.discordId, discordId))
+ .then((rows) => rows[0]);
+
+ return memberData as schema.memberTableTypes;
+ },
+ );
+
+ const moderations = await getMemberModerationHistory(discordId);
+
+ return {
+ ...member,
+ moderations,
+ };
+ } catch (error) {
+ return handleDbError('Failed to get member', error as Error);
+ }
+}
+
+/**
+ * Update a member's information in the database
+ * @param discordId - Discord ID of the user
+ * @param discordUsername - New username of the member
+ * @param currentlyInServer - Whether the member is currently in the server
+ * @param currentlyBanned - Whether the member is currently banned
+ */
export async function updateMember({
discordId,
discordUsername,
currentlyInServer,
currentlyBanned,
-}: schema.memberTableTypes) {
+}: schema.memberTableTypes): Promise<void> {
try {
- const result = await db
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot update member');
+ }
+
+ await db
.update(schema.memberTable)
.set({
discordUsername,
@@ -148,20 +399,252 @@ export async function updateMember({
})
.where(eq(schema.memberTable.discordId, discordId));
- if (await exists(`${discordId}-memberInfo`)) {
- await del(`${discordId}-memberInfo`);
- }
- if (await exists('nonBotMembers')) {
- await del('nonBotMembers');
- }
-
- return result;
+ await Promise.all([
+ invalidateCache(`${discordId}-memberInfo`),
+ invalidateCache('nonBotMembers'),
+ ]);
} catch (error) {
- console.error('Error updating member: ', error);
- throw new DatabaseError('Failed to update member: ', error as Error);
+ handleDbError('Failed to update member', error as Error);
}
}
+// ========================
+// Level & XP Functions
+// ========================
+
+/**
+ * Get user level information or create a new entry if not found
+ * @param discordId - Discord ID of the user
+ * @returns User level object
+ */
+export async function getUserLevel(
+ discordId: string,
+): Promise<schema.levelTableTypes> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot get user level');
+ }
+
+ const cacheKey = `level-${discordId}`;
+
+ return await withCache<schema.levelTableTypes>(cacheKey, async () => {
+ const level = await db
+ .select()
+ .from(schema.levelTable)
+ .where(eq(schema.levelTable.discordId, discordId))
+ .then((rows) => rows[0]);
+
+ if (level) {
+ return {
+ ...level,
+ lastMessageTimestamp: level.lastMessageTimestamp ?? undefined,
+ };
+ }
+
+ const newLevel: schema.levelTableTypes = {
+ discordId,
+ xp: 0,
+ level: 0,
+ lastMessageTimestamp: new Date(),
+ };
+
+ await db.insert(schema.levelTable).values(newLevel);
+ return newLevel;
+ });
+ } catch (error) {
+ return handleDbError('Error getting user level', error as Error);
+ }
+}
+
+/**
+ * Add XP to a user, updating their level if necessary
+ * @param discordId - Discord ID of the user
+ * @param amount - Amount of XP to add
+ */
+export async function addXpToUser(
+ discordId: string,
+ amount: number,
+): Promise<{
+ leveledUp: boolean;
+ newLevel: number;
+ oldLevel: number;
+}> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot add xp to user');
+ }
+
+ const cacheKey = `level-${discordId}`;
+ const userData = await getUserLevel(discordId);
+ const currentLevel = userData.level;
+
+ userData.xp += amount;
+ userData.lastMessageTimestamp = new Date();
+ userData.level = calculateLevelFromXp(userData.xp);
+
+ await invalidateLeaderboardCache();
+ await invalidateCache(cacheKey);
+ await withCache<schema.levelTableTypes>(
+ cacheKey,
+ async () => {
+ const result = await db
+ .update(schema.levelTable)
+ .set({
+ xp: userData.xp,
+ level: userData.level,
+ lastMessageTimestamp: userData.lastMessageTimestamp,
+ })
+ .where(eq(schema.levelTable.discordId, discordId))
+ .returning();
+
+ return result[0] as schema.levelTableTypes;
+ },
+ 300,
+ );
+
+ return {
+ leveledUp: userData.level > currentLevel,
+ newLevel: userData.level,
+ oldLevel: currentLevel,
+ };
+ } catch (error) {
+ return handleDbError('Error adding XP to user', error as Error);
+ }
+}
+
+/**
+ * Get a user's rank on the XP leaderboard
+ * @param discordId - Discord ID of the user
+ * @returns User's rank on the leaderboard
+ */
+export async function getUserRank(discordId: string): Promise<number> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot get user rank');
+ }
+
+ const leaderboardCache = await getLeaderboardData();
+
+ if (leaderboardCache) {
+ const userIndex = leaderboardCache.findIndex(
+ (member) => member.discordId === discordId,
+ );
+
+ if (userIndex !== -1) {
+ return userIndex + 1;
+ }
+ }
+
+ return 1;
+ } catch (error) {
+ return handleDbError('Failed to get user rank', error as Error);
+ }
+}
+
+/**
+ * Clear leaderboard cache
+ */
+export async function invalidateLeaderboardCache(): Promise<void> {
+ await invalidateCache('xp-leaderboard-cache');
+}
+
+/**
+ * Helper function to get or create leaderboard data
+ * @returns Array of leaderboard data
+ */
+async function getLeaderboardData(): Promise<
+ Array<{
+ discordId: string;
+ xp: number;
+ }>
+> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot get leaderboard data');
+ }
+
+ const cacheKey = 'xp-leaderboard-cache';
+ return withCache<Array<{ discordId: string; xp: number }>>(
+ cacheKey,
+ async () => {
+ return await db
+ .select({
+ discordId: schema.levelTable.discordId,
+ xp: schema.levelTable.xp,
+ })
+ .from(schema.levelTable)
+ .orderBy(desc(schema.levelTable.xp));
+ },
+ 300,
+ );
+ } catch (error) {
+ return handleDbError('Failed to get leaderboard data', error as Error);
+ }
+}
+
+/**
+ * Get the XP leaderboard
+ * @param limit - Number of entries to return
+ * @returns Array of leaderboard entries
+ */
+export async function getLevelLeaderboard(
+ limit = 10,
+): Promise<schema.levelTableTypes[]> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot get level leaderboard');
+ }
+
+ const leaderboardCache = await getLeaderboardData();
+
+ if (leaderboardCache) {
+ const limitedCache = leaderboardCache.slice(0, limit);
+
+ const fullLeaderboard = await Promise.all(
+ limitedCache.map(async (entry) => {
+ const userData = await getUserLevel(entry.discordId);
+ return userData;
+ }),
+ );
+
+ return fullLeaderboard;
+ }
+
+ return (await db
+ .select()
+ .from(schema.levelTable)
+ .orderBy(desc(schema.levelTable.xp))
+ .limit(limit)) as schema.levelTableTypes[];
+ } catch (error) {
+ return handleDbError('Failed to get leaderboard', error as Error);
+ }
+}
+
+// ========================
+// Moderation Functions
+// ========================
+
+/**
+ * Add a new moderation action to a member's history
+ * @param discordId - Discord ID of the user
+ * @param moderatorDiscordId - Discord ID of the moderator
+ * @param action - Type of action taken
+ * @param reason - Reason for the action
+ * @param duration - Duration of the action
+ * @param createdAt - Timestamp of when the action was taken
+ * @param expiresAt - Timestamp of when the action expires
+ * @param active - Wether the action is active or not
+ */
export async function updateMemberModerationHistory({
discordId,
moderatorDiscordId,
@@ -171,8 +654,16 @@ export async function updateMemberModerationHistory({
createdAt,
expiresAt,
active,
-}: schema.moderationTableTypes) {
+}: schema.moderationTableTypes): Promise<void> {
try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error(
+ 'Database not initialized, update member moderation history',
+ );
+ }
+
const moderationEntry = {
discordId,
moderatorDiscordId,
@@ -183,50 +674,240 @@ export async function updateMemberModerationHistory({
expiresAt,
active,
};
- const result = await db
- .insert(schema.moderationTable)
- .values(moderationEntry);
- if (await exists(`${discordId}-moderationHistory`)) {
- await del(`${discordId}-moderationHistory`);
- }
- if (await exists(`${discordId}-memberInfo`)) {
- await del(`${discordId}-memberInfo`);
- }
+ await db.insert(schema.moderationTable).values(moderationEntry);
- return result;
+ await Promise.all([
+ invalidateCache(`${discordId}-moderationHistory`),
+ invalidateCache(`${discordId}-memberInfo`),
+ ]);
} catch (error) {
- console.error('Error updating moderation history: ', error);
- throw new DatabaseError(
- 'Failed to update moderation history: ',
- error as Error,
- );
+ handleDbError('Failed to update moderation history', error as Error);
}
}
-export async function getMemberModerationHistory(discordId: string) {
+/**
+ * Get a member's moderation history
+ * @param discordId - Discord ID of the user
+ * @returns Array of moderation actions
+ */
+export async function getMemberModerationHistory(
+ discordId: string,
+): Promise<schema.moderationTableTypes[]> {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error(
+ 'Database not initialized, cannot get member moderation history',
+ );
+ }
+
+ const cacheKey = `${discordId}-moderationHistory`;
+
try {
- if (await exists(`${discordId}-moderationHistory`)) {
- return await getJson<(typeof schema.moderationTable.$inferSelect)[]>(
- `${discordId}-moderationHistory`,
- );
- } else {
- const moderationHistory = await db
- .select()
- .from(schema.moderationTable)
- .where(eq(schema.moderationTable.discordId, discordId));
-
- await setJson<(typeof schema.moderationTable.$inferSelect)[]>(
- `${discordId}-moderationHistory`,
- moderationHistory,
- );
- return moderationHistory;
- }
- } catch (error) {
- console.error('Error getting moderation history: ', error);
- throw new DatabaseError(
- 'Failed to get moderation history: ',
- error as Error,
+ return await withCache<schema.moderationTableTypes[]>(
+ cacheKey,
+ async () => {
+ const history = await db
+ .select()
+ .from(schema.moderationTable)
+ .where(eq(schema.moderationTable.discordId, discordId));
+ return history as schema.moderationTableTypes[];
+ },
);
+ } catch (error) {
+ return handleDbError('Failed to get moderation history', error as Error);
+ }
+}
+
+// ========================
+// Fact Functions
+// ========================
+
+/**
+ * Add a new fact to the database
+ * @param content - Content of the fact
+ * @param source - Source of the fact
+ * @param addedBy - Discord ID of the user who added the fact
+ * @param approved - Whether the fact is approved or not
+ */
+export async function addFact({
+ content,
+ source,
+ addedBy,
+ approved = false,
+}: schema.factTableTypes): Promise<void> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot add fact');
+ }
+
+ await db.insert(schema.factTable).values({
+ content,
+ source,
+ addedBy,
+ approved,
+ });
+
+ await invalidateCache('unused-facts');
+ } catch (error) {
+ handleDbError('Failed to add fact', error as Error);
+ }
+}
+
+/**
+ * Get the ID of the most recently added fact
+ * @returns ID of the last inserted fact
+ */
+export async function getLastInsertedFactId(): Promise<number> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot get last inserted fact');
+ }
+
+ const result = await db
+ .select({ id: sql<number>`MAX(${schema.factTable.id})` })
+ .from(schema.factTable);
+
+ return result[0]?.id ?? 0;
+ } catch (error) {
+ return handleDbError('Failed to get last inserted fact ID', error as Error);
+ }
+}
+
+/**
+ * Get a random fact that hasn't been used yet
+ * @returns Random fact object
+ */
+export async function getRandomUnusedFact(): Promise<schema.factTableTypes> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot get random unused fact');
+ }
+
+ const cacheKey = 'unused-facts';
+ const facts = await withCache<schema.factTableTypes[]>(
+ cacheKey,
+ async () => {
+ return (await db
+ .select()
+ .from(schema.factTable)
+ .where(
+ and(
+ eq(schema.factTable.approved, true),
+ isNull(schema.factTable.usedOn),
+ ),
+ )) as schema.factTableTypes[];
+ },
+ );
+
+ if (facts.length === 0) {
+ await db
+ .update(schema.factTable)
+ .set({ usedOn: null })
+ .where(eq(schema.factTable.approved, true));
+
+ await invalidateCache(cacheKey);
+ return await getRandomUnusedFact();
+ }
+
+ return facts[
+ Math.floor(Math.random() * facts.length)
+ ] as schema.factTableTypes;
+ } catch (error) {
+ return handleDbError('Failed to get random fact', error as Error);
+ }
+}
+
+/**
+ * Mark a fact as used
+ * @param id - ID of the fact to mark as used
+ */
+export async function markFactAsUsed(id: number): Promise<void> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot mark fact as used');
+ }
+
+ await db
+ .update(schema.factTable)
+ .set({ usedOn: new Date() })
+ .where(eq(schema.factTable.id, id));
+
+ await invalidateCache('unused-facts');
+ } catch (error) {
+ handleDbError('Failed to mark fact as used', error as Error);
+ }
+}
+
+/**
+ * Get all pending facts that need approval
+ * @returns Array of pending fact objects
+ */
+export async function getPendingFacts(): Promise<schema.factTableTypes[]> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot get pending facts');
+ }
+
+ return (await db
+ .select()
+ .from(schema.factTable)
+ .where(eq(schema.factTable.approved, false))) as schema.factTableTypes[];
+ } catch (error) {
+ return handleDbError('Failed to get pending facts', error as Error);
+ }
+}
+
+/**
+ * Approve a fact
+ * @param id - ID of the fact to approve
+ */
+export async function approveFact(id: number): Promise<void> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot approve fact');
+ }
+
+ await db
+ .update(schema.factTable)
+ .set({ approved: true })
+ .where(eq(schema.factTable.id, id));
+
+ await invalidateCache('unused-facts');
+ } catch (error) {
+ handleDbError('Failed to approve fact', error as Error);
+ }
+}
+
+/**
+ * Delete a fact
+ * @param id - ID of the fact to delete
+ */
+export async function deleteFact(id: number): Promise<void> {
+ try {
+ await ensureDbInitialized();
+
+ if (!db) {
+ console.error('Database not initialized, cannot delete fact');
+ }
+
+ await db.delete(schema.factTable).where(eq(schema.factTable.id, id));
+
+ await invalidateCache('unused-facts');
+ } catch (error) {
+ return handleDbError('Failed to delete fact', error as Error);
}
}
diff --git a/src/db/redis.ts b/src/db/redis.ts
index 8938d17..6b58f6b 100644
--- a/src/db/redis.ts
+++ b/src/db/redis.ts
@@ -1,9 +1,31 @@
import Redis from 'ioredis';
+import { Client } from 'discord.js';
+
import { loadConfig } from '../util/configLoader.js';
+import {
+ logManagerNotification,
+ NotificationType,
+ notifyManagers,
+} from '../util/notificationHandler.js';
const config = loadConfig();
-const redis = new Redis(config.redisConnectionString);
+// Redis connection state
+let isRedisAvailable = false;
+let redis: Redis;
+let connectionAttempts = 0;
+const MAX_RETRY_ATTEMPTS = config.redis.retryAttempts;
+const INITIAL_RETRY_DELAY = config.redis.initialRetryDelay;
+let hasNotifiedDisconnect = false;
+let discordClient: Client | null = null;
+
+// ========================
+// Redis Utility Classes and Helper Functions
+// ========================
+
+/**
+ * Custom error class for Redis errors
+ */
class RedisError extends Error {
constructor(
message: string,
@@ -14,77 +36,271 @@ class RedisError extends Error {
}
}
-redis.on('error', (error) => {
- console.error('Redis connection error:', error);
- throw new RedisError('Failed to connect to Redis instance: ', error);
-});
+/**
+ * Redis error handler
+ * @param errorMessage - The error message to log
+ * @param error - The error object
+ */
+const handleRedisError = (errorMessage: string, error: Error): null => {
+ console.error(`${errorMessage}:`, error);
+ throw new RedisError(errorMessage, error);
+};
-redis.on('connect', () => {
- console.log('Successfully connected to Redis');
-});
+/**
+ * Sets the Discord client for sending notifications
+ * @param client - The Discord client
+ */
+export function setDiscordClient(client: Client): void {
+ discordClient = client;
+}
+/**
+ * Initializes the Redis connection with retry logic
+ */
+async function initializeRedisConnection() {
+ try {
+ if (redis && redis.status !== 'end' && redis.status !== 'close') {
+ return;
+ }
+
+ redis = new Redis(config.redis.redisConnectionString, {
+ retryStrategy(times) {
+ connectionAttempts = times;
+ if (times >= MAX_RETRY_ATTEMPTS) {
+ const message = `Failed to connect to Redis after ${times} attempts. Caching will be disabled.`;
+ console.warn(message);
+
+ if (!hasNotifiedDisconnect && discordClient) {
+ logManagerNotification(NotificationType.REDIS_CONNECTION_LOST);
+ notifyManagers(
+ discordClient,
+ NotificationType.REDIS_CONNECTION_LOST,
+ `Connection attempts exhausted after ${times} tries. Caching is now disabled.`,
+ );
+ hasNotifiedDisconnect = true;
+ }
+
+ return null;
+ }
+
+ const delay = Math.min(INITIAL_RETRY_DELAY * Math.pow(2, times), 30000);
+ console.log(
+ `Retrying Redis connection in ${delay}ms... (Attempt ${times + 1}/${MAX_RETRY_ATTEMPTS})`,
+ );
+ return delay;
+ },
+ maxRetriesPerRequest: 3,
+ enableOfflineQueue: true,
+ });
+
+ // ========================
+ // Redis Events
+ // ========================
+ redis.on('error', (error: Error) => {
+ console.error('Redis Connection Error:', error);
+ isRedisAvailable = false;
+ });
+
+ redis.on('connect', () => {
+ console.info('Successfully connected to Redis');
+ isRedisAvailable = true;
+ connectionAttempts = 0;
+
+ if (hasNotifiedDisconnect && discordClient) {
+ logManagerNotification(NotificationType.REDIS_CONNECTION_RESTORED);
+ notifyManagers(
+ discordClient,
+ NotificationType.REDIS_CONNECTION_RESTORED,
+ );
+ hasNotifiedDisconnect = false;
+ }
+ });
+
+ redis.on('close', () => {
+ console.warn('Redis connection closed');
+ isRedisAvailable = false;
+
+ // Try to reconnect after some time if we've not exceeded max attempts
+ if (connectionAttempts < MAX_RETRY_ATTEMPTS) {
+ const delay = Math.min(
+ INITIAL_RETRY_DELAY * Math.pow(2, connectionAttempts),
+ 30000,
+ );
+ setTimeout(initializeRedisConnection, delay);
+ } else if (!hasNotifiedDisconnect && discordClient) {
+ logManagerNotification(NotificationType.REDIS_CONNECTION_LOST);
+ notifyManagers(
+ discordClient,
+ NotificationType.REDIS_CONNECTION_LOST,
+ 'Connection closed and max retry attempts reached.',
+ );
+ hasNotifiedDisconnect = true;
+ }
+ });
+
+ redis.on('reconnecting', () => {
+ console.info('Attempting to reconnect to Redis...');
+ });
+ } catch (error) {
+ console.error('Failed to initialize Redis:', error);
+ isRedisAvailable = false;
+
+ if (!hasNotifiedDisconnect && discordClient) {
+ logManagerNotification(
+ NotificationType.REDIS_CONNECTION_LOST,
+ `Error: ${error}`,
+ );
+ notifyManagers(
+ discordClient,
+ NotificationType.REDIS_CONNECTION_LOST,
+ `Initialization error: ${error}`,
+ );
+ hasNotifiedDisconnect = true;
+ }
+ }
+}
+
+// Initialize Redis connection
+initializeRedisConnection();
+
+/**
+ * Check if Redis is currently available, and attempt to reconnect if not
+ * @returns - True if Redis is connected and available
+ */
+export async function ensureRedisConnection(): Promise<boolean> {
+ if (!isRedisAvailable) {
+ await initializeRedisConnection();
+ }
+ return isRedisAvailable;
+}
+
+// ========================
+// Redis Functions
+// ========================
+
+/**
+ * Function to set a key in Redis
+ * @param key - The key to set
+ * @param value - The value to set
+ * @param ttl - The time to live for the key
+ * @returns - 'OK' if successful
+ */
export async function set(
key: string,
value: string,
ttl?: number,
-): Promise<'OK'> {
- try {
- await redis.set(key, value);
- if (ttl) await redis.expire(key, ttl);
- } catch (error) {
- console.error('Redis set error: ', error);
- throw new RedisError(`Failed to set key: ${key}, `, error as Error);
+): Promise<'OK' | null> {
+ if (!(await ensureRedisConnection())) {
+ console.warn('Redis unavailable, skipping set operation');
+ return null;
+ }
+
+ try {
+ await redis.set(`bot:${key}`, value);
+ if (ttl) await redis.expire(`bot:${key}`, ttl);
+ return 'OK';
+ } catch (error) {
+ return handleRedisError(`Failed to set key: ${key}`, error as Error);
}
- return Promise.resolve('OK');
}
+/**
+ * Function to set a key in Redis with a JSON value
+ * @param key - The key to set
+ * @param value - The value to set
+ * @param ttl - The time to live for the key
+ * @returns - 'OK' if successful
+ */
export async function setJson<T>(
key: string,
value: T,
ttl?: number,
-): Promise<'OK'> {
+): Promise<'OK' | null> {
return await set(key, JSON.stringify(value), ttl);
}
-export async function incr(key: string): Promise<number> {
+/**
+ * Increments a key in Redis
+ * @param key - The key to increment
+ * @returns - The new value of the key, or null if Redis is unavailable
+ */
+export async function incr(key: string): Promise<number | null> {
+ if (!(await ensureRedisConnection())) {
+ console.warn('Redis unavailable, skipping increment operation');
+ return null;
+ }
+
try {
- return await redis.incr(key);
+ return await redis.incr(`bot:${key}`);
} catch (error) {
- console.error('Redis increment error: ', error);
- throw new RedisError(`Failed to increment key: ${key}, `, error as Error);
+ return handleRedisError(`Failed to increment key: ${key}`, error as Error);
}
}
-export async function exists(key: string): Promise<boolean> {
+/**
+ * Checks if a key exists in Redis
+ * @param key - The key to check
+ * @returns - True if the key exists, false otherwise, or null if Redis is unavailable
+ */
+export async function exists(key: string): Promise<boolean | null> {
+ if (!(await ensureRedisConnection())) {
+ console.warn('Redis unavailable, skipping exists operation');
+ return null;
+ }
+
try {
- return (await redis.exists(key)) === 1;
+ return (await redis.exists(`bot:${key}`)) === 1;
} catch (error) {
- console.error('Redis exists error: ', error);
- throw new RedisError(
- `Failed to check if key exists: ${key}, `,
+ return handleRedisError(
+ `Failed to check if key exists: ${key}`,
error as Error,
);
}
}
+/**
+ * Gets the value of a key in Redis
+ * @param key - The key to get
+ * @returns - The value of the key, or null if the key does not exist or Redis is unavailable
+ */
export async function get(key: string): Promise<string | null> {
+ if (!(await ensureRedisConnection())) {
+ console.warn('Redis unavailable, skipping get operation');
+ return null;
+ }
+
try {
- return await redis.get(key);
+ return await redis.get(`bot:${key}`);
} catch (error) {
- console.error('Redis get error: ', error);
- throw new RedisError(`Failed to get key: ${key}, `, error as Error);
+ return handleRedisError(`Failed to get key: ${key}`, error as Error);
}
}
-export async function mget(...keys: string[]): Promise<(string | null)[]> {
+/**
+ * Gets the values of multiple keys in Redis
+ * @param keys - The keys to get
+ * @returns - The values of the keys, or null if Redis is unavailable
+ */
+export async function mget(
+ ...keys: string[]
+): Promise<(string | null)[] | null> {
+ if (!(await ensureRedisConnection())) {
+ console.warn('Redis unavailable, skipping mget operation');
+ return null;
+ }
+
try {
- return await redis.mget(keys);
+ return await redis.mget(...keys.map((key) => `bot:${key}`));
} catch (error) {
- console.error('Redis mget error: ', error);
- throw new RedisError(`Failed to get keys: ${keys}, `, error as Error);
+ return handleRedisError('Failed to get keys', error as Error);
}
}
+/**
+ * Gets the value of a key in Redis and parses it as a JSON object
+ * @param key - The key to get
+ * @returns - The parsed JSON value of the key, or null if the key does not exist or Redis is unavailable
+ */
export async function getJson<T>(key: string): Promise<T | null> {
const value = await get(key);
if (!value) return null;
@@ -95,11 +311,28 @@ export async function getJson<T>(key: string): Promise<T | null> {
}
}
-export async function del(key: string): Promise<number> {
+/**
+ * Deletes a key in Redis
+ * @param key - The key to delete
+ * @returns - The number of keys that were deleted, or null if Redis is unavailable
+ */
+export async function del(key: string): Promise<number | null> {
+ if (!(await ensureRedisConnection())) {
+ console.warn('Redis unavailable, skipping delete operation');
+ return null;
+ }
+
try {
- return await redis.del(key);
+ return await redis.del(`bot:${key}`);
} catch (error) {
- console.error('Redis del error: ', error);
- throw new RedisError(`Failed to delete key: ${key}, `, error as Error);
+ return handleRedisError(`Failed to delete key: ${key}`, error as Error);
}
}
+
+/**
+ * Check if Redis is currently available
+ * @returns - True if Redis is connected and available
+ */
+export function isRedisConnected(): boolean {
+ return isRedisAvailable;
+}
diff --git a/src/db/schema.ts b/src/db/schema.ts
index cbf6782..61bdc94 100644
--- a/src/db/schema.ts
+++ b/src/db/schema.ts
@@ -25,6 +25,24 @@ export const memberTable = pgTable('members', {
currentlyMuted: boolean('currently_muted').notNull().default(false),
});
+export interface levelTableTypes {
+ id?: number;
+ discordId: string;
+ xp: number;
+ level: number;
+ lastMessageTimestamp?: Date;
+}
+
+export const levelTable = pgTable('levels', {
+ id: integer().primaryKey().generatedAlwaysAsIdentity(),
+ discordId: varchar('discord_id')
+ .notNull()
+ .references(() => memberTable.discordId, { onDelete: 'cascade' }),
+ xp: integer('xp').notNull().default(0),
+ level: integer('level').notNull().default(0),
+ lastMessageTimestamp: timestamp('last_message_timestamp'),
+});
+
export interface moderationTableTypes {
id?: number;
discordId: string;
@@ -51,8 +69,20 @@ export const moderationTable = pgTable('moderations', {
active: boolean('active').notNull().default(true),
});
-export const memberRelations = relations(memberTable, ({ many }) => ({
+export const memberRelations = relations(memberTable, ({ many, one }) => ({
moderations: many(moderationTable),
+ levels: one(levelTable, {
+ fields: [memberTable.discordId],
+ references: [levelTable.discordId],
+ }),
+ facts: many(factTable),
+}));
+
+export const levelRelations = relations(levelTable, ({ one }) => ({
+ member: one(memberTable, {
+ fields: [levelTable.discordId],
+ references: [memberTable.discordId],
+ }),
}));
export const moderationRelations = relations(moderationTable, ({ one }) => ({
@@ -61,3 +91,23 @@ export const moderationRelations = relations(moderationTable, ({ one }) => ({
references: [memberTable.discordId],
}),
}));
+
+export type factTableTypes = {
+ id?: number;
+ content: string;
+ source?: string;
+ addedBy: string;
+ addedAt?: Date;
+ approved?: boolean;
+ usedOn?: Date;
+};
+
+export const factTable = pgTable('facts', {
+ id: integer().primaryKey().generatedAlwaysAsIdentity(),
+ content: varchar('content').notNull(),
+ source: varchar('source'),
+ addedBy: varchar('added_by').notNull(),
+ addedAt: timestamp('added_at').defaultNow().notNull(),
+ approved: boolean('approved').default(false).notNull(),
+ usedOn: timestamp('used_on'),
+});
diff --git a/src/events/interactionCreate.ts b/src/events/interactionCreate.ts
index 328b10f..f25d2a3 100644
--- a/src/events/interactionCreate.ts
+++ b/src/events/interactionCreate.ts
@@ -2,39 +2,99 @@ import { Events, Interaction } from 'discord.js';
import { ExtendedClient } from '../structures/ExtendedClient.js';
import { Event } from '../types/EventTypes.js';
+import { approveFact, deleteFact } from '../db/db.js';
export default {
name: Events.InteractionCreate,
execute: async (interaction: Interaction) => {
- if (!interaction.isCommand()) return;
+ if (interaction.isCommand()) {
+ const client = interaction.client as ExtendedClient;
+ const command = client.commands.get(interaction.commandName);
- const client = interaction.client as ExtendedClient;
- const command = client.commands.get(interaction.commandName);
+ if (!command) {
+ console.error(
+ `No command matching ${interaction.commandName} was found.`,
+ );
+ return;
+ }
- if (!command) {
- console.error(
- `No command matching ${interaction.commandName} was found.`,
- );
- return;
- }
+ try {
+ await command.execute(interaction);
+ } catch (error: any) {
+ console.error(`Error executing ${interaction.commandName}`);
+ console.error(error);
- try {
- await command.execute(interaction);
- } catch (error) {
- console.error(`Error executing ${interaction.commandName}`);
- console.error(error);
+ const isUnknownInteractionError =
+ error.code === 10062 ||
+ (error.message && error.message.includes('Unknown interaction'));
- if (interaction.replied || interaction.deferred) {
- await interaction.followUp({
- content: 'There was an error while executing this command!',
- flags: ['Ephemeral'],
+ if (!isUnknownInteractionError) {
+ try {
+ if (interaction.replied || interaction.deferred) {
+ await interaction
+ .followUp({
+ content: 'There was an error while executing this command!',
+ flags: ['Ephemeral'],
+ })
+ .catch((e) =>
+ console.error('Failed to send error followup:', e),
+ );
+ } else {
+ await interaction
+ .reply({
+ content: 'There was an error while executing this command!',
+ flags: ['Ephemeral'],
+ })
+ .catch((e) => console.error('Failed to send error reply:', e));
+ }
+ } catch (replyError) {
+ console.error('Failed to respond with error message:', replyError);
+ }
+ } else {
+ console.warn(
+ 'Interaction expired before response could be sent (code 10062)',
+ );
+ }
+ }
+ } else if (interaction.isButton()) {
+ const { customId } = interaction;
+
+ if (customId.startsWith('approve_fact_')) {
+ if (!interaction.memberPermissions?.has('ModerateMembers')) {
+ await interaction.reply({
+ content: 'You do not have permission to approve facts.',
+ flags: ['Ephemeral'],
+ });
+ return;
+ }
+
+ const factId = parseInt(customId.replace('approve_fact_', ''), 10);
+ await approveFact(factId);
+
+ await interaction.update({
+ content: `✅ Fact #${factId} has been approved by <@${interaction.user.id}>`,
+ components: [],
});
- } else {
- await interaction.reply({
- content: 'There was an error while executing this command!',
- flags: ['Ephemeral'],
+ } else if (customId.startsWith('reject_fact_')) {
+ if (!interaction.memberPermissions?.has('ModerateMembers')) {
+ await interaction.reply({
+ content: 'You do not have permission to reject facts.',
+ flags: ['Ephemeral'],
+ });
+ return;
+ }
+
+ const factId = parseInt(customId.replace('reject_fact_', ''), 10);
+ await deleteFact(factId);
+
+ await interaction.update({
+ content: `❌ Fact #${factId} has been rejected by <@${interaction.user.id}>`,
+ components: [],
});
}
+ } else {
+ console.warn('Unhandled interaction type:', interaction);
+ return;
}
},
} as Event<typeof Events.InteractionCreate>;
diff --git a/src/events/memberEvents.ts b/src/events/memberEvents.ts
index a6ddc80..671f99a 100644
--- a/src/events/memberEvents.ts
+++ b/src/events/memberEvents.ts
@@ -1,4 +1,10 @@
-import { Events, Guild, GuildMember, PartialGuildMember } from 'discord.js';
+import {
+ Collection,
+ Events,
+ Guild,
+ GuildMember,
+ PartialGuildMember,
+} from 'discord.js';
import { updateMember, setMembers } from '../db/db.js';
import { generateMemberBanner } from '../util/helpers.js';
@@ -19,12 +25,9 @@ export const memberJoin: Event<typeof Events.GuildMemberAdd> = {
}
try {
- await setMembers([
- {
- discordId: member.user.id,
- discordUsername: member.user.username,
- },
- ]);
+ const memberCollection = new Collection<string, GuildMember>();
+ memberCollection.set(member.user.id, member);
+ await setMembers(memberCollection);
if (!member.user.bot) {
const attachment = await generateMemberBanner({
diff --git a/src/events/messageEvents.ts b/src/events/messageEvents.ts
index 8bd0f33..07d0595 100644
--- a/src/events/messageEvents.ts
+++ b/src/events/messageEvents.ts
@@ -1,7 +1,17 @@
import { AuditLogEvent, Events, Message, PartialMessage } from 'discord.js';
import { Event } from '../types/EventTypes.js';
+import { loadConfig } from '../util/configLoader.js';
+import {
+ addCountingReactions,
+ processCountingMessage,
+ resetCounting,
+} from '../util/countingManager.js';
import logAction from '../util/logging/logAction.js';
+import {
+ checkAndAssignLevelRoles,
+ processMessage,
+} from '../util/levelingSystem.js';
export const messageDelete: Event<typeof Events.MessageDelete> = {
name: Events.MessageDelete,
@@ -62,4 +72,87 @@ export const messageUpdate: Event<typeof Events.MessageUpdate> = {
},
};
-export default [messageDelete, messageUpdate];
+export const messageCreate: Event<typeof Events.MessageCreate> = {
+ name: Events.MessageCreate,
+ execute: async (message: Message) => {
+ try {
+ if (message.author.bot || !message.guild) return;
+
+ const levelResult = await processMessage(message);
+ const advancementsChannelId = loadConfig().channels.advancements;
+ const advancementsChannel = message.guild?.channels.cache.get(
+ advancementsChannelId,
+ );
+
+ if (!advancementsChannel?.isTextBased()) {
+ console.error(
+ 'Advancements channel not found or is not a text channel',
+ );
+ return;
+ }
+
+ if (levelResult?.leveledUp) {
+ await advancementsChannel.send(
+ `🎉 Congratulations <@${message.author.id}>! You've leveled up to **Level ${levelResult.newLevel}**!`,
+ );
+
+ const assignedRole = await checkAndAssignLevelRoles(
+ message.guild,
+ message.author.id,
+ levelResult.newLevel,
+ );
+
+ if (assignedRole) {
+ await advancementsChannel.send(
+ `<@${message.author.id}> You've earned the <@&${assignedRole}> role!`,
+ );
+ }
+ }
+
+ const countingChannelId = loadConfig().channels.counting;
+ const countingChannel =
+ message.guild?.channels.cache.get(countingChannelId);
+
+ if (!countingChannel || message.channel.id !== countingChannelId) return;
+ if (!countingChannel.isTextBased()) {
+ console.error('Counting channel not found or is not a text channel');
+ return;
+ }
+
+ const result = await processCountingMessage(message);
+
+ if (result.isValid) {
+ await addCountingReactions(message, result.milestoneType || 'normal');
+ } else {
+ let errorMessage: string;
+
+ switch (result.reason) {
+ case 'not_a_number':
+ errorMessage = `${message.author}, that's not a valid number! The count has been reset. The next number should be **1**.`;
+ break;
+ case 'too_high':
+ errorMessage = `${message.author}, too high! The count was **${(result?.expectedCount ?? 0) - 1}** and the next number should have been **${result.expectedCount}**. The count has been reset.`;
+ break;
+ case 'too_low':
+ errorMessage = `${message.author}, too low! The count was **${(result?.expectedCount ?? 0) - 1}** and the next number should have been **${result.expectedCount}**. The count has been reset.`;
+ break;
+ case 'same_user':
+ errorMessage = `${message.author}, you can't count twice in a row! The count has been reset. The next number should be **1**.`;
+ break;
+ default:
+ errorMessage = `${message.author}, something went wrong with the count. The count has been reset. The next number should be **1**.`;
+ }
+
+ await resetCounting();
+
+ await countingChannel.send(errorMessage);
+
+ await message.react('❌');
+ }
+ } catch (error) {
+ console.error('Error handling message create: ', error);
+ }
+ },
+};
+
+export default [messageCreate, messageDelete, messageUpdate];
diff --git a/src/events/ready.ts b/src/events/ready.ts
index 2430295..24c0ff7 100644
--- a/src/events/ready.ts
+++ b/src/events/ready.ts
@@ -1,8 +1,15 @@
import { Client, Events } from 'discord.js';
-import { setMembers } from '../db/db.js';
+import { ensureDbInitialized, setMembers } from '../db/db.js';
import { loadConfig } from '../util/configLoader.js';
import { Event } from '../types/EventTypes.js';
+import { scheduleFactOfTheDay } from '../util/factManager.js';
+
+import {
+ ensureRedisConnection,
+ setDiscordClient as setRedisDiscordClient,
+} from '../db/redis.js';
+import { setDiscordClient as setDbDiscordClient } from '../db/db.js';
export default {
name: Events.ClientReady,
@@ -10,6 +17,12 @@ export default {
execute: async (client: Client) => {
const config = loadConfig();
try {
+ setRedisDiscordClient(client);
+ setDbDiscordClient(client);
+
+ await ensureDbInitialized();
+ await ensureRedisConnection();
+
const guild = client.guilds.cache.find(
(guilds) => guilds.id === config.guildId,
);
@@ -21,8 +34,10 @@ export default {
const members = await guild.members.fetch();
const nonBotMembers = members.filter((m) => !m.user.bot);
await setMembers(nonBotMembers);
+
+ await scheduleFactOfTheDay(client);
} catch (error) {
- console.error('Failed to initialize members in database:', error);
+ console.error('Failed to initialize the bot:', error);
}
console.log(`Ready! Logged in as ${client.user?.tag}`);
diff --git a/src/structures/ExtendedClient.ts b/src/structures/ExtendedClient.ts
index 4dfba26..bf0d153 100644
--- a/src/structures/ExtendedClient.ts
+++ b/src/structures/ExtendedClient.ts
@@ -4,6 +4,9 @@ import { Config } from '../types/ConfigTypes.js';
import { deployCommands } from '../util/deployCommand.js';
import { registerEvents } from '../util/eventLoader.js';
+/**
+ * Extended client class that extends the default Client class
+ */
export class ExtendedClient extends Client {
public commands: Collection<string, Command>;
private config: Config;
diff --git a/src/types/CommandTypes.ts b/src/types/CommandTypes.ts
index 30d175c..002cd17 100644
--- a/src/types/CommandTypes.ts
+++ b/src/types/CommandTypes.ts
@@ -2,14 +2,29 @@ import {
CommandInteraction,
SlashCommandBuilder,
SlashCommandOptionsOnlyBuilder,
+ SlashCommandSubcommandsOnlyBuilder,
} from 'discord.js';
+/**
+ * Command interface for normal commands
+ */
export interface Command {
data: Omit<SlashCommandBuilder, 'addSubcommand' | 'addSubcommandGroup'>;
execute: (interaction: CommandInteraction) => Promise<void>;
}
+/**
+ * Command interface for options commands
+ */
export interface OptionsCommand {
data: SlashCommandOptionsOnlyBuilder;
execute: (interaction: CommandInteraction) => Promise<void>;
}
+
+/**
+ * Command interface for subcommand commands
+ */
+export interface SubcommandCommand {
+ data: SlashCommandSubcommandsOnlyBuilder;
+ execute: (interaction: CommandInteraction) => Promise<void>;
+}
diff --git a/src/types/ConfigTypes.ts b/src/types/ConfigTypes.ts
index e92ae94..b38b126 100644
--- a/src/types/ConfigTypes.ts
+++ b/src/types/ConfigTypes.ts
@@ -1,14 +1,43 @@
+/**
+ * Config interface for the bot
+ */
export interface Config {
token: string;
clientId: string;
guildId: string;
- dbConnectionString: string;
- redisConnectionString: string;
+ database: {
+ dbConnectionString: string;
+ maxRetryAttempts: number;
+ retryDelay: number;
+ };
+ redis: {
+ redisConnectionString: string;
+ retryAttempts: number;
+ initialRetryDelay: number;
+ };
channels: {
welcome: string;
logs: string;
+ counting: string;
+ factOfTheDay: string;
+ factApproval: string;
+ advancements: string;
};
roles: {
joinRoles: string[];
+ levelRoles: {
+ level: number;
+ roleId: string;
+ }[];
+ staffRoles: {
+ name: string;
+ roleId: string;
+ }[];
+ factPingRole: string;
+ };
+ leveling: {
+ xpCooldown: number;
+ minXpAwarded: number;
+ maxXpAwarded: number;
};
}
diff --git a/src/types/EventTypes.ts b/src/types/EventTypes.ts
index f07556d..df6cf7c 100644
--- a/src/types/EventTypes.ts
+++ b/src/types/EventTypes.ts
@@ -1,5 +1,8 @@
import { ClientEvents } from 'discord.js';
+/**
+ * Event interface for events
+ */
export interface Event<K extends keyof ClientEvents> {
name: K;
once?: boolean;
diff --git a/src/util/configLoader.ts b/src/util/configLoader.ts
index 497e5a0..4a847dc 100644
--- a/src/util/configLoader.ts
+++ b/src/util/configLoader.ts
@@ -2,6 +2,10 @@ import { Config } from '../types/ConfigTypes.js';
import fs from 'node:fs';
import path from 'node:path';
+/**
+ * Loads the config file from the root directory
+ * @returns - The loaded config object
+ */
export function loadConfig(): Config {
try {
const configPath = path.join(process.cwd(), './config.json');
diff --git a/src/util/countingManager.ts b/src/util/countingManager.ts
new file mode 100644
index 0000000..a3beb67
--- /dev/null
+++ b/src/util/countingManager.ts
@@ -0,0 +1,191 @@
+import { Message } from 'discord.js';
+
+import { getJson, setJson } from '../db/redis.js';
+
+interface CountingData {
+ currentCount: number;
+ lastUserId: string | null;
+ highestCount: number;
+ totalCorrect: number;
+}
+
+const MILESTONE_REACTIONS = {
+ normal: '✅',
+ multiples25: '✨',
+ multiples50: '⭐',
+ multiples100: '🎉',
+};
+
+/**
+ * Initializes the counting data if it doesn't exist
+ * @returns - The initialized counting data
+ */
+export async function initializeCountingData(): Promise<CountingData> {
+ const exists = await getJson<CountingData>('counting');
+ if (exists) return exists;
+
+ const initialData: CountingData = {
+ currentCount: 0,
+ lastUserId: null,
+ highestCount: 0,
+ totalCorrect: 0,
+ };
+
+ await setJson<CountingData>('counting', initialData);
+ return initialData;
+}
+
+/**
+ * Gets the current counting data
+ * @returns - The current counting data
+ */
+export async function getCountingData(): Promise<CountingData> {
+ const data = await getJson<CountingData>('counting');
+ if (!data) {
+ return initializeCountingData();
+ }
+ return data;
+}
+
+/**
+ * Updates the counting data with new data
+ * @param data - The data to update the counting data with
+ */
+export async function updateCountingData(
+ data: Partial<CountingData>,
+): Promise<void> {
+ const currentData = await getCountingData();
+ const updatedData = { ...currentData, ...data };
+ await setJson<CountingData>('counting', updatedData);
+}
+
+/**
+ * Resets the counting data to the initial state
+ * @returns - The current count
+ */
+export async function resetCounting(): Promise<void> {
+ await updateCountingData({
+ currentCount: 0,
+ lastUserId: null,
+ });
+ return;
+}
+
+/**
+ * Processes a counting message to determine if it is valid
+ * @param message - The message to process
+ * @returns - An object with information about the message
+ */
+export async function processCountingMessage(message: Message): Promise<{
+ isValid: boolean;
+ expectedCount?: number;
+ isMilestone?: boolean;
+ milestoneType?: keyof typeof MILESTONE_REACTIONS;
+ reason?: string;
+}> {
+ try {
+ const countingData = await getCountingData();
+
+ const content = message.content.trim();
+ const count = Number(content);
+
+ if (isNaN(count) || !Number.isInteger(count)) {
+ return {
+ isValid: false,
+ expectedCount: countingData.currentCount + 1,
+ reason: 'not_a_number',
+ };
+ }
+
+ const expectedCount = countingData.currentCount + 1;
+ if (count !== expectedCount) {
+ return {
+ isValid: false,
+ expectedCount,
+ reason: count > expectedCount ? 'too_high' : 'too_low',
+ };
+ }
+
+ if (countingData.lastUserId === message.author.id) {
+ return { isValid: false, expectedCount, reason: 'same_user' };
+ }
+
+ const newCount = countingData.currentCount + 1;
+ const newHighestCount = Math.max(newCount, countingData.highestCount);
+
+ await updateCountingData({
+ currentCount: newCount,
+ lastUserId: message.author.id,
+ highestCount: newHighestCount,
+ totalCorrect: countingData.totalCorrect + 1,
+ });
+
+ let isMilestone = false;
+ let milestoneType: keyof typeof MILESTONE_REACTIONS = 'normal';
+
+ if (newCount % 100 === 0) {
+ isMilestone = true;
+ milestoneType = 'multiples100';
+ } else if (newCount % 50 === 0) {
+ isMilestone = true;
+ milestoneType = 'multiples50';
+ } else if (newCount % 25 === 0) {
+ isMilestone = true;
+ milestoneType = 'multiples25';
+ }
+
+ return {
+ isValid: true,
+ expectedCount: newCount + 1,
+ isMilestone,
+ milestoneType,
+ };
+ } catch (error) {
+ console.error('Error processing counting message:', error);
+ return { isValid: false, reason: 'error' };
+ }
+}
+
+/**
+ * Adds counting reactions to a message based on the milestone type
+ * @param message - The message to add counting reactions to
+ * @param milestoneType - The type of milestone to add reactions for
+ */
+export async function addCountingReactions(
+ message: Message,
+ milestoneType: keyof typeof MILESTONE_REACTIONS,
+): Promise<void> {
+ try {
+ await message.react(MILESTONE_REACTIONS[milestoneType]);
+
+ if (milestoneType === 'multiples100') {
+ await message.react('💯');
+ }
+ } catch (error) {
+ console.error('Error adding counting reactions:', error);
+ }
+}
+
+/**
+ * Gets the current counting status
+ * @returns - A string with the current counting status
+ */
+export async function getCountingStatus(): Promise<string> {
+ const data = await getCountingData();
+ return `Current count: ${data.currentCount}\nHighest count ever: ${data.highestCount}\nTotal correct counts: ${data.totalCorrect}`;
+}
+
+/**
+ * Sets the current count to a specific number
+ * @param count - The number to set as the current count
+ */
+export async function setCount(count: number): Promise<void> {
+ if (!Number.isInteger(count) || count < 0) {
+ throw new Error('Count must be a non-negative integer.');
+ }
+
+ await updateCountingData({
+ currentCount: count,
+ lastUserId: null,
+ });
+}
diff --git a/src/util/deployCommand.ts b/src/util/deployCommand.ts
index 9ce4580..891734b 100644
--- a/src/util/deployCommand.ts
+++ b/src/util/deployCommand.ts
@@ -1,6 +1,6 @@
-import { REST, Routes } from 'discord.js';
import fs from 'fs';
import path from 'path';
+import { REST, Routes } from 'discord.js';
import { loadConfig } from './configLoader.js';
const config = loadConfig();
@@ -11,6 +11,11 @@ const commandsPath = path.join(__dirname, 'target', 'commands');
const rest = new REST({ version: '10' }).setToken(token);
+/**
+ * Gets all files in the command directory and its subdirectories
+ * @param directory - The directory to get files from
+ * @returns - An array of file paths
+ */
const getFilesRecursively = (directory: string): string[] => {
const files: string[] = [];
const filesInDirectory = fs.readdirSync(directory);
@@ -30,15 +35,21 @@ const getFilesRecursively = (directory: string): string[] => {
const commandFiles = getFilesRecursively(commandsPath);
+/**
+ * Registers all commands in the command directory with the Discord API
+ * @returns - An array of valid command objects
+ */
export const deployCommands = async () => {
try {
console.log(
`Started refreshing ${commandFiles.length} application (/) commands...`,
);
- const existingCommands = (await rest.get(
- Routes.applicationGuildCommands(clientId, guildId),
- )) as any[];
+ console.log('Undeploying all existing commands...');
+ await rest.put(Routes.applicationGuildCommands(clientId, guildId), {
+ body: [],
+ });
+ console.log('Successfully undeployed all commands');
const commands = commandFiles.map(async (file) => {
const commandModule = await import(`file://${file}`);
@@ -64,18 +75,6 @@ export const deployCommands = async () => {
const apiCommands = validCommands.map((command) => command.data.toJSON());
- const commandsToRemove = existingCommands.filter(
- (existingCmd) =>
- !apiCommands.some((newCmd) => newCmd.name === existingCmd.name),
- );
-
- for (const cmdToRemove of commandsToRemove) {
- await rest.delete(
- Routes.applicationGuildCommand(clientId, guildId, cmdToRemove.id),
- );
- console.log(`Removed command: ${cmdToRemove.name}`);
- }
-
const data: any = await rest.put(
Routes.applicationGuildCommands(clientId, guildId),
{ body: apiCommands },
diff --git a/src/util/eventLoader.ts b/src/util/eventLoader.ts
index 855f296..d212380 100644
--- a/src/util/eventLoader.ts
+++ b/src/util/eventLoader.ts
@@ -7,6 +7,10 @@ import { dirname } from 'path';
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
+/**
+ * Registers all event handlers in the events directory
+ * @param client - The Discord client
+ */
export async function registerEvents(client: Client): Promise<void> {
try {
const eventsPath = join(__dirname, '..', 'events');
diff --git a/src/util/factManager.ts b/src/util/factManager.ts
new file mode 100644
index 0000000..d146f67
--- /dev/null
+++ b/src/util/factManager.ts
@@ -0,0 +1,89 @@
+import { EmbedBuilder, Client } from 'discord.js';
+
+import { getRandomUnusedFact, markFactAsUsed } from '../db/db.js';
+import { loadConfig } from './configLoader.js';
+
+let isFactScheduled = false;
+
+/**
+ * Schedule the fact of the day to be posted daily
+ * @param client - The Discord client
+ */
+export async function scheduleFactOfTheDay(client: Client): Promise<void> {
+ if (isFactScheduled) {
+ console.log(
+ 'Fact of the day already scheduled, skipping duplicate schedule',
+ );
+ return;
+ }
+
+ try {
+ isFactScheduled = true;
+ const now = new Date();
+ const tomorrow = new Date();
+ tomorrow.setDate(now.getDate() + 1);
+ tomorrow.setHours(0, 0, 0, 0);
+
+ const timeUntilMidnight = tomorrow.getTime() - now.getTime();
+
+ setTimeout(() => {
+ postFactOfTheDay(client);
+ isFactScheduled = false;
+ scheduleFactOfTheDay(client);
+ }, timeUntilMidnight);
+
+ console.log(
+ `Next fact of the day scheduled in ${Math.floor(timeUntilMidnight / 1000 / 60)} minutes`,
+ );
+ } catch (error) {
+ console.error('Error scheduling fact of the day:', error);
+ isFactScheduled = false;
+ setTimeout(() => scheduleFactOfTheDay(client), 60 * 60 * 1000);
+ }
+}
+
+/**
+ * Post the fact of the day to the configured channel
+ * @param client - The Discord client
+ */
+export async function postFactOfTheDay(client: Client): Promise<void> {
+ try {
+ const config = loadConfig();
+ const guild = client.guilds.cache.get(config.guildId);
+
+ if (!guild) {
+ console.error('Guild not found');
+ return;
+ }
+
+ const factChannel = guild.channels.cache.get(config.channels.factOfTheDay);
+ if (!factChannel?.isTextBased()) {
+ console.error('Fact channel not found or is not a text channel');
+ return;
+ }
+
+ const fact = await getRandomUnusedFact();
+ if (!fact) {
+ console.error('No facts available');
+ return;
+ }
+
+ const embed = new EmbedBuilder()
+ .setTitle('🌟 Fact of the Day 🌟')
+ .setDescription(fact.content)
+ .setColor(0xffaa00)
+ .setTimestamp();
+
+ if (fact.source) {
+ embed.setFooter({ text: `Source: ${fact.source}` });
+ }
+
+ await factChannel.send({
+ content: `<@&${config.roles.factPingRole}>`,
+ embeds: [embed],
+ });
+ await markFactAsUsed(fact.id!);
+ } catch (error) {
+ console.error('Error posting fact of the day:', error);
+ }
+}
diff --git a/src/util/helpers.ts b/src/util/helpers.ts
index dcc6fca..edfe5aa 100644
--- a/src/util/helpers.ts
+++ b/src/util/helpers.ts
@@ -5,11 +5,16 @@ import { AttachmentBuilder, Client, GuildMember, Guild } from 'discord.js';
import { and, eq } from 'drizzle-orm';
import { moderationTable } from '../db/schema.js';
-import { db, updateMember } from '../db/db.js';
+import { db, handleDbError, updateMember } from '../db/db.js';
import logAction from './logging/logAction.js';
const __dirname = path.resolve();
+/**
+ * Turns a duration string into milliseconds
+ * @param duration - The duration to parse
+ * @returns - The parsed duration in milliseconds
+ */
export function parseDuration(duration: string): number {
const regex = /^(\d+)(s|m|h|d)$/;
const match = duration.match(regex);
@@ -30,17 +35,27 @@ export function parseDuration(duration: string): number {
}
}
+/**
+ * Member banner types
+ */
interface generateMemberBannerTypes {
member: GuildMember;
width: number;
height: number;
}
+/**
+ * Generates a welcome banner for a member
+ * @param member - The member to generate a banner for
+ * @param width - The width of the banner
+ * @param height - The height of the banner
+ * @returns - The generated banner
+ */
export async function generateMemberBanner({
member,
width,
height,
-}: generateMemberBannerTypes) {
+}: generateMemberBannerTypes): Promise<AttachmentBuilder> {
const welcomeBackground = path.join(__dirname, 'assets', 'welcome-bg.png');
const canvas = Canvas.createCanvas(width, height);
const context = canvas.getContext('2d');
@@ -92,12 +107,19 @@ export async function generateMemberBanner({
return attachment;
}
+/**
+ * Schedules an unban for a user
+ * @param client - The client to use
+ * @param guildId - The guild ID to unban the user from
+ * @param userId - The user ID to unban
+ * @param expiresAt - The date to unban the user at
+ */
export async function scheduleUnban(
client: Client,
guildId: string,
userId: string,
expiresAt: Date,
-) {
+): Promise<void> {
const timeUntilUnban = expiresAt.getTime() - Date.now();
if (timeUntilUnban > 0) {
setTimeout(async () => {
@@ -106,12 +128,19 @@ export async function scheduleUnban(
}
}
+/**
+ * Executes an unban for a user
+ * @param client - The client to use
+ * @param guildId - The guild ID to unban the user from
+ * @param userId - The user ID to unban
+ * @param reason - The reason for the unban
+ */
export async function executeUnban(
client: Client,
guildId: string,
userId: string,
reason?: string,
-) {
+): Promise<void> {
try {
const guild = await client.guilds.fetch(guildId);
await guild.members.unban(userId, reason ?? 'Temporary ban expired');
@@ -140,26 +169,96 @@ export async function executeUnban(
reason: reason ?? 'Temporary ban expired',
});
} catch (error) {
- console.error(`Failed to unban user ${userId}:`, error);
+ handleDbError(`Failed to unban user ${userId}`, error as Error);
}
}
-export async function loadActiveBans(client: Client, guild: Guild) {
- const activeBans = await db
- .select()
- .from(moderationTable)
- .where(
- and(eq(moderationTable.action, 'ban'), eq(moderationTable.active, true)),
- );
+/**
+ * Loads all active bans and schedules unban events
+ * @param client - The client to use
+ * @param guild - The guild to load bans for
+ */
+export async function loadActiveBans(
+ client: Client,
+ guild: Guild,
+): Promise<void> {
+ try {
+ const activeBans = await db
+ .select()
+ .from(moderationTable)
+ .where(
+ and(
+ eq(moderationTable.action, 'ban'),
+ eq(moderationTable.active, true),
+ ),
+ );
- for (const ban of activeBans) {
- if (!ban.expiresAt) continue;
+ for (const ban of activeBans) {
+ if (!ban.expiresAt) continue;
- const timeUntilUnban = ban.expiresAt.getTime() - Date.now();
- if (timeUntilUnban <= 0) {
- await executeUnban(client, guild.id, ban.discordId);
- } else {
- await scheduleUnban(client, guild.id, ban.discordId, ban.expiresAt);
+ const timeUntilUnban = ban.expiresAt.getTime() - Date.now();
+ if (timeUntilUnban <= 0) {
+ await executeUnban(client, guild.id, ban.discordId);
+ } else {
+ await scheduleUnban(client, guild.id, ban.discordId, ban.expiresAt);
+ }
}
+ } catch (error) {
+ handleDbError('Failed to load active bans', error as Error);
+ }
+}
+
+/**
+ * Types for the roundRect function
+ */
+interface roundRectTypes {
+ ctx: Canvas.SKRSContext2D;
+ x: number;
+ y: number;
+ width: number;
+ height: number;
+ fill: boolean;
+ radius?: number;
+}
+
+/**
+ * Creates a rounded rectangle
+ * @param ctx - The canvas context to use
+ * @param x - The x position of the rectangle
+ * @param y - The y position of the rectangle
+ * @param width - The width of the rectangle
+ * @param height - The height of the rectangle
+ * @param radius - The radius of the corners
+ * @param fill - Whether to fill the rectangle
+ */
+export function roundRect({
+ ctx,
+ x,
+ y,
+ width,
+ height,
+ radius,
+ fill,
+}: roundRectTypes): void {
+ if (typeof radius === 'undefined') {
+ radius = 5;
+ }
+
+ ctx.beginPath();
+ ctx.moveTo(x + radius, y);
+ ctx.lineTo(x + width - radius, y);
+ ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
+ ctx.lineTo(x + width, y + height - radius);
+ ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+ ctx.lineTo(x + radius, y + height);
+ ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
+ ctx.lineTo(x, y + radius);
+ ctx.quadraticCurveTo(x, y, x + radius, y);
+ ctx.closePath();
+
+ if (fill) {
+ ctx.fill();
+ } else {
+ ctx.stroke();
}
}
diff --git a/src/util/levelingSystem.ts b/src/util/levelingSystem.ts
new file mode 100644
index 0000000..ba42ea6
--- /dev/null
+++ b/src/util/levelingSystem.ts
@@ -0,0 +1,281 @@
+import path from 'path';
+import Canvas, { GlobalFonts } from '@napi-rs/canvas';
+import { GuildMember, Message, AttachmentBuilder, Guild } from 'discord.js';
+
+import {
+ addXpToUser,
+ db,
+ getUserLevel,
+ getUserRank,
+ handleDbError,
+} from '../db/db.js';
+import * as schema from '../db/schema.js';
+import { loadConfig } from './configLoader.js';
+import { roundRect } from './helpers.js';
+
+const config = loadConfig();
+
+const XP_COOLDOWN = config.leveling.xpCooldown * 1000;
+const MIN_XP = config.leveling.minXpAwarded;
+const MAX_XP = config.leveling.maxXpAwarded;
+
+const __dirname = path.resolve();
+
+/**
+ * Calculates the amount of XP required to reach the given level
+ * @param level - The level to calculate the XP for
+ * @returns - The amount of XP required to reach the given level
+ */
+export const calculateXpForLevel = (level: number): number => {
+ if (level === 0) return 0;
+ return (5 / 6) * level * (2 * level * level + 27 * level + 91);
+};
+
+/**
+ * Calculates the level that corresponds to the given amount of XP
+ * @param xp - The amount of XP to calculate the level for
+ * @returns - The level that corresponds to the given amount of XP
+ */
+export const calculateLevelFromXp = (xp: number): number => {
+ if (xp < calculateXpForLevel(1)) return 0;
+
+ let level = 0;
+ while (calculateXpForLevel(level + 1) <= xp) {
+ level++;
+ }
+
+ return level;
+};
+
+/**
+ * Gets the amount of XP required to reach the next level
+ * @param level - The level to calculate the XP for
+ * @param currentXp - The current amount of XP
+ * @returns - The amount of XP required to reach the next level
+ */
+export const getXpToNextLevel = (level: number, currentXp: number): number => {
+ if (level === 0) return calculateXpForLevel(1) - currentXp;
+
+ const nextLevelXp = calculateXpForLevel(level + 1);
+ return nextLevelXp - currentXp;
+};
+
+/**
+ * Recalculates the levels for all users in the database
+ */
+export async function recalculateUserLevels() {
+ try {
+ const users = await db.select().from(schema.levelTable);
+
+ for (const user of users) {
+ await addXpToUser(user.discordId, 0);
+ }
+ } catch (error) {
+ handleDbError('Failed to recalculate user levels', error as Error);
+ }
+}
+
+/**
+ * Processes a message for XP
+ * @param message - The message to process for XP
+ * @returns - The result of processing the message
+ */
+export async function processMessage(message: Message) {
+ if (message.author.bot || !message.guild) return;
+
+ try {
+ const userId = message.author.id;
+ const userData = await getUserLevel(userId);
+
+ if (userData.lastMessageTimestamp) {
+ const lastMessageTime = new Date(userData.lastMessageTimestamp).getTime();
+ const currentTime = Date.now();
+
+ if (currentTime - lastMessageTime < XP_COOLDOWN) {
+ return null;
+ }
+ }
+
+ const xpToAdd = Math.floor(Math.random() * (MAX_XP - MIN_XP + 1)) + MIN_XP;
+ const result = await addXpToUser(userId, xpToAdd);
+
+ return result;
+ } catch (error) {
+ console.error('Error processing message for XP:', error);
+ return null;
+ }
+}
+
+/**
+ * Generates a rank card for the given member
+ * @param member - The member to generate a rank card for
+ * @param userData - The user's level data
+ * @returns - The rank card as an attachment
+ */
+export async function generateRankCard(
+ member: GuildMember,
+ userData: schema.levelTableTypes,
+) {
+ GlobalFonts.registerFromPath(
+ path.join(__dirname, 'assets', 'fonts', 'Manrope-Bold.ttf'),
+ 'Manrope Bold',
+ );
+ GlobalFonts.registerFromPath(
+ path.join(__dirname, 'assets', 'fonts', 'Manrope-Regular.ttf'),
+ 'Manrope',
+ );
+
+ const userRank = await getUserRank(userData.discordId);
+
+ const canvas = Canvas.createCanvas(934, 282);
+ const context = canvas.getContext('2d');
+
+ context.fillStyle = '#23272A';
+ context.fillRect(0, 0, canvas.width, canvas.height);
+
+ context.fillStyle = '#2C2F33';
+ roundRect({
+ ctx: context,
+ x: 22,
+ y: 22,
+ width: 890,
+ height: 238,
+ radius: 20,
+ fill: true,
+ });
+
+ try {
+ const avatar = await Canvas.loadImage(
+ member.user.displayAvatarURL({ extension: 'png', size: 256 }),
+ );
+ context.save();
+ context.beginPath();
+ context.arc(120, 141, 80, 0, Math.PI * 2);
+ context.closePath();
+ context.clip();
+ context.drawImage(avatar, 40, 61, 160, 160);
+ context.restore();
+ } catch (error) {
+ console.error('Error loading avatar image:', error);
+ context.fillStyle = '#5865F2';
+ context.beginPath();
+ context.arc(120, 141, 80, 0, Math.PI * 2);
+ context.fill();
+ }
+
+ context.font = '38px "Manrope Bold"';
+ context.fillStyle = '#FFFFFF';
+ context.fillText(member.user.username, 242, 142);
+
+ context.font = '24px "Manrope Bold"';
+ context.fillStyle = '#FFFFFF';
+ context.textAlign = 'end';
+ context.fillText(`LEVEL ${userData.level}`, 890, 82);
+
+ context.font = '24px "Manrope Bold"';
+ context.fillStyle = '#FFFFFF';
+ context.fillText(`RANK #${userRank}`, 890, 122);
+
+ const barWidth = 615;
+ const barHeight = 38;
+ const barX = 242;
+ const barY = 182;
+
+ const currentLevel = userData.level;
+ const currentLevelXp = calculateXpForLevel(currentLevel);
+ const nextLevelXp = calculateXpForLevel(currentLevel + 1);
+
+ const xpNeededForNextLevel = nextLevelXp - currentLevelXp;
+
+ let xpIntoCurrentLevel;
+ if (currentLevel === 0) {
+ xpIntoCurrentLevel = userData.xp;
+ } else {
+ xpIntoCurrentLevel = userData.xp - currentLevelXp;
+ }
+
+ const progress = Math.max(
+ 0,
+ Math.min(xpIntoCurrentLevel / xpNeededForNextLevel, 1),
+ );
+
+ context.fillStyle = '#484b4E';
+ roundRect({
+ ctx: context,
+ x: barX,
+ y: barY,
+ width: barWidth,
+ height: barHeight,
+ radius: barHeight / 2,
+ fill: true,
+ });
+
+ if (progress > 0) {
+ context.fillStyle = '#5865F2';
+ roundRect({
+ ctx: context,
+ x: barX,
+ y: barY,
+ width: barWidth * progress,
+ height: barHeight,
+ radius: barHeight / 2,
+ fill: true,
+ });
+ }
+
+ context.textAlign = 'center';
+ context.font = '20px "Manrope"';
+ context.fillStyle = '#A0A0A0';
+ context.fillText(
+ `${xpIntoCurrentLevel.toLocaleString()} / ${xpNeededForNextLevel.toLocaleString()} XP`,
+ barX + barWidth / 2,
+ barY + barHeight / 2 + 7,
+ );
+
+ return new AttachmentBuilder(canvas.toBuffer('image/png'), {
+ name: 'rank-card.png',
+ });
+}
+
+/**
+ * Assigns level roles to a user based on their new level
+ * @param guild - The guild to assign roles in
+ * @param userId - The userId of the user to assign roles to
+ * @param newLevel - The new level of the user
+ * @returns - The highest role that was assigned
+ */
+export async function checkAndAssignLevelRoles(
+ guild: Guild,
+ userId: string,
+ newLevel: number,
+) {
+ try {
+ if (!config.roles.levelRoles || config.roles.levelRoles.length === 0) {
+ return;
+ }
+
+ const member = await guild.members.fetch(userId);
+ if (!member) return;
+
+ const rolesToAdd = config.roles.levelRoles
+ .filter((role) => role.level <= newLevel)
+ .map((role) => role.roleId);
+
+ if (rolesToAdd.length === 0) return;
+
+ const existingLevelRoles = config.roles.levelRoles.map((r) => r.roleId);
+ const rolesToRemove = member.roles.cache.filter((role) =>
+ existingLevelRoles.includes(role.id),
+ );
+ if (rolesToRemove.size > 0) {
+ await member.roles.remove(rolesToRemove);
+ }
+
+ const highestRole = rolesToAdd[rolesToAdd.length - 1];
+ await member.roles.add(highestRole);
+
+ return highestRole;
+ } catch (error) {
+ console.error('Error assigning level roles:', error);
+ }
+}
diff --git a/src/util/logging/constants.ts b/src/util/logging/constants.ts
index 85ed0bf..d9c3b60 100644
--- a/src/util/logging/constants.ts
+++ b/src/util/logging/constants.ts
@@ -1,6 +1,9 @@
import { ChannelType } from 'discord.js';
import { LogActionType } from './types';
+/**
+ * Colors for different actions
+ */
export const ACTION_COLORS: Record<string, number> = {
// Danger actions - Red
ban: 0xff0000,
@@ -31,6 +34,9 @@ export const ACTION_COLORS: Record<string, number> = {
default: 0x0099ff,
};
+/**
+ * Emojis for different actions
+ */
export const ACTION_EMOJIS: Record<LogActionType, string> = {
roleCreate: '⭐',
roleDelete: '🗑️',
@@ -54,6 +60,9 @@ export const ACTION_EMOJIS: Record<LogActionType, string> = {
roleRemove: '➖',
};
+/**
+ * Types of channels
+ */
export const CHANNEL_TYPES: Record<number, string> = {
[ChannelType.GuildText]: 'Text Channel',
[ChannelType.GuildVoice]: 'Voice Channel',
diff --git a/src/util/logging/logAction.ts b/src/util/logging/logAction.ts
index 7becbe5..a78ea48 100644
--- a/src/util/logging/logAction.ts
+++ b/src/util/logging/logAction.ts
@@ -1,10 +1,10 @@
import {
- TextChannel,
ButtonStyle,
ButtonBuilder,
ActionRowBuilder,
GuildChannel,
} from 'discord.js';
+
import {
LogActionPayload,
ModerationLogAction,
@@ -22,10 +22,18 @@ import {
getPermissionDifference,
getPermissionNames,
} from './utils.js';
+import { loadConfig } from '../configLoader.js';
-export default async function logAction(payload: LogActionPayload) {
- const logChannel = payload.guild.channels.cache.get('1007787977432383611');
- if (!logChannel || !(logChannel instanceof TextChannel)) {
+/**
+ * Logs an action to the log channel
+ * @param payload - The payload to log
+ */
+export default async function logAction(
+ payload: LogActionPayload,
+): Promise<void> {
+ const config = loadConfig();
+ const logChannel = payload.guild.channels.cache.get(config.channels.logs);
+ if (!logChannel?.isTextBased()) {
console.error('Log channel not found or is not a Text Channel.');
return;
}
diff --git a/src/util/logging/types.ts b/src/util/logging/types.ts
index 36eed72..8319a3a 100644
--- a/src/util/logging/types.ts
+++ b/src/util/logging/types.ts
@@ -7,6 +7,9 @@ import {
PermissionsBitField,
} from 'discord.js';
+/**
+ * Moderation log action types
+ */
export type ModerationActionType =
| 'ban'
| 'kick'
@@ -14,23 +17,38 @@ export type ModerationActionType =
| 'unban'
| 'unmute'
| 'warn';
+/**
+ * Message log action types
+ */
export type MessageActionType = 'messageDelete' | 'messageEdit';
+/**
+ * Member log action types
+ */
export type MemberActionType =
| 'memberJoin'
| 'memberLeave'
| 'memberUsernameUpdate'
| 'memberNicknameUpdate';
+/**
+ * Role log action types
+ */
export type RoleActionType =
| 'roleAdd'
| 'roleRemove'
| 'roleCreate'
| 'roleDelete'
| 'roleUpdate';
+/**
+ * Channel log action types
+ */
export type ChannelActionType =
| 'channelCreate'
| 'channelDelete'
| 'channelUpdate';
+/**
+ * All log action types
+ */
export type LogActionType =
| ModerationActionType
| MessageActionType
@@ -38,6 +56,9 @@ export type LogActionType =
| RoleActionType
| ChannelActionType;
+/**
+ * Properties of a role
+ */
export type RoleProperties = {
name: string;
color: string;
@@ -45,6 +66,9 @@ export type RoleProperties = {
mentionable: boolean;
};
+/**
+ * Base log action properties
+ */
export interface BaseLogAction {
guild: Guild;
action: LogActionType;
@@ -53,6 +77,9 @@ export interface BaseLogAction {
duration?: string;
}
+/**
+ * Log action properties for moderation actions
+ */
export interface ModerationLogAction extends BaseLogAction {
action: ModerationActionType;
target: GuildMember;
@@ -61,6 +88,9 @@ export interface ModerationLogAction extends BaseLogAction {
duration?: string;
}
+/**
+ * Log action properties for message actions
+ */
export interface MessageLogAction extends BaseLogAction {
action: MessageActionType;
message: Message<true>;
@@ -68,11 +98,17 @@ export interface MessageLogAction extends BaseLogAction {
newContent?: string;
}
+/**
+ * Log action properties for member actions
+ */
export interface MemberLogAction extends BaseLogAction {
action: 'memberJoin' | 'memberLeave';
member: GuildMember;
}
+/**
+ * Log action properties for member username or nickname updates
+ */
export interface MemberUpdateAction extends BaseLogAction {
action: 'memberUsernameUpdate' | 'memberNicknameUpdate';
member: GuildMember;
@@ -80,6 +116,9 @@ export interface MemberUpdateAction extends BaseLogAction {
newValue: string;
}
+/**
+ * Log action properties for role actions
+ */
export interface RoleLogAction extends BaseLogAction {
action: 'roleAdd' | 'roleRemove';
member: GuildMember;
@@ -87,6 +126,9 @@ export interface RoleLogAction extends BaseLogAction {
moderator?: GuildMember;
}
+/**
+ * Log action properties for role updates
+ */
export interface RoleUpdateAction extends BaseLogAction {
action: 'roleUpdate';
role: Role;
@@ -97,12 +139,18 @@ export interface RoleUpdateAction extends BaseLogAction {
moderator?: GuildMember;
}
+/**
+ * Log action properties for role creation or deletion
+ */
export interface RoleCreateDeleteAction extends BaseLogAction {
action: 'roleCreate' | 'roleDelete';
role: Role;
moderator?: GuildMember;
}
+/**
+ * Log action properties for channel actions
+ */
export interface ChannelLogAction extends BaseLogAction {
action: ChannelActionType;
channel: GuildChannel;
@@ -123,6 +171,9 @@ export interface ChannelLogAction extends BaseLogAction {
moderator?: GuildMember;
}
+/**
+ * Payload for a log action
+ */
export type LogActionPayload =
| ModerationLogAction
| MessageLogAction
diff --git a/src/util/logging/utils.ts b/src/util/logging/utils.ts
index d47d0ce..c6c2977 100644
--- a/src/util/logging/utils.ts
+++ b/src/util/logging/utils.ts
@@ -5,9 +5,15 @@ import {
EmbedField,
PermissionsBitField,
} from 'discord.js';
+
import { LogActionPayload, LogActionType, RoleProperties } from './types.js';
import { ACTION_EMOJIS } from './constants.js';
+/**
+ * Formats a permission name to be more readable
+ * @param perm - The permission to format
+ * @returns - The formatted permission name
+ */
export const formatPermissionName = (perm: string): string => {
return perm
.split('_')
@@ -15,6 +21,12 @@ export const formatPermissionName = (perm: string): string => {
.join(' ');
};
+/**
+ * Creates a field for a user
+ * @param user - The user to create a field for
+ * @param label - The label for the field
+ * @returns - The created field
+ */
export const createUserField = (
user: User | GuildMember,
label = 'User',
@@ -24,6 +36,12 @@ export const createUserField = (
inline: true,
});
+/**
+ * Creates a field for a moderator
+ * @param moderator - The moderator to create a field for
+ * @param label - The label for the field
+ * @returns - The created field
+ */
export const createModeratorField = (
moderator?: GuildMember,
label = 'Moderator',
@@ -36,12 +54,23 @@ export const createModeratorField = (
}
: null;
+/**
+ * Creates a field for a channel
+ * @param channel - The channel to create a field for
+ * @returns - The created field
+ */
export const createChannelField = (channel: GuildChannel): EmbedField => ({
name: 'Channel',
value: `<#${channel.id}>`,
inline: true,
});
+/**
+ * Creates a field for changed permissions
+ * @param oldPerms - The old permissions
+ * @param newPerms - The new permissions
+ * @returns - The created fields
+ */
export const createPermissionChangeFields = (
oldPerms: Readonly<PermissionsBitField>,
newPerms: Readonly<PermissionsBitField>,
@@ -84,6 +113,11 @@ export const createPermissionChangeFields = (
return fields;
};
+/**
+ * Gets the names of the permissions in a bitfield
+ * @param permissions - The permissions to get the names of
+ * @returns - The names of the permissions
+ */
export const getPermissionNames = (
permissions: Readonly<PermissionsBitField>,
): string[] => {
@@ -98,6 +132,12 @@ export const getPermissionNames = (
return names;
};
+/**
+ * Compares two bitfields and returns the names of the permissions that are in the first bitfield but not the second
+ * @param a - The first bitfield
+ * @param b - The second bitfield
+ * @returns - The names of the permissions that are in the first bitfield but not the second
+ */
export const getPermissionDifference = (
a: Readonly<PermissionsBitField>,
b: Readonly<PermissionsBitField>,
@@ -114,6 +154,12 @@ export const getPermissionDifference = (
return names;
};
+/**
+ * Creates a field for a role
+ * @param oldRole - The old role
+ * @param newRole - The new role
+ * @returns - The fields for the role changes
+ */
export const createRoleChangeFields = (
oldRole: Partial<RoleProperties>,
newRole: Partial<RoleProperties>,
@@ -153,6 +199,11 @@ export const createRoleChangeFields = (
return fields;
};
+/**
+ * Gets the ID of the item that was logged
+ * @param payload - The payload to get the log item ID from
+ * @returns - The ID of the log item
+ */
export const getLogItemId = (payload: LogActionPayload): string => {
switch (payload.action) {
case 'roleCreate':
@@ -188,6 +239,11 @@ export const getLogItemId = (payload: LogActionPayload): string => {
}
};
+/**
+ * Gets the emoji for an action
+ * @param action - The action to get an emoji for
+ * @returns - The emoji for the action
+ */
export const getEmojiForAction = (action: LogActionType): string => {
return ACTION_EMOJIS[action] || '📝';
};
diff --git a/src/util/notificationHandler.ts b/src/util/notificationHandler.ts
new file mode 100644
index 0000000..a2f8a58
--- /dev/null
+++ b/src/util/notificationHandler.ts
@@ -0,0 +1,151 @@
+import { Client, Guild, GuildMember } from 'discord.js';
+import { loadConfig } from './configLoader.js';
+
+/**
+ * Types of notifications that can be sent
+ */
+export enum NotificationType {
+ // Redis notifications
+ REDIS_CONNECTION_LOST = 'REDIS_CONNECTION_LOST',
+ REDIS_CONNECTION_RESTORED = 'REDIS_CONNECTION_RESTORED',
+
+ // Database notifications
+ DATABASE_CONNECTION_LOST = 'DATABASE_CONNECTION_LOST',
+ DATABASE_CONNECTION_RESTORED = 'DATABASE_CONNECTION_RESTORED',
+
+ // Bot notifications
+ BOT_RESTARTING = 'BOT_RESTARTING',
+ BOT_ERROR = 'BOT_ERROR',
+}
+
+/**
+ * Maps notification types to their messages
+ */
+const NOTIFICATION_MESSAGES = {
+ [NotificationType.REDIS_CONNECTION_LOST]:
+ '⚠️ **Redis Connection Lost**\n\nThe bot has lost connection to Redis after multiple retry attempts. Caching functionality is disabled until the connection is restored.',
+ [NotificationType.REDIS_CONNECTION_RESTORED]:
+ '✅ **Redis Connection Restored**\n\nThe bot has successfully reconnected to Redis. All caching functionality has been restored.',
+
+ [NotificationType.DATABASE_CONNECTION_LOST]:
+ '🚨 **Database Connection Lost**\n\nThe bot has lost connection to the database after multiple retry attempts. The bot cannot function properly without database access and will shut down.',
+ [NotificationType.DATABASE_CONNECTION_RESTORED]:
+ '✅ **Database Connection Restored**\n\nThe bot has successfully reconnected to the database.',
+
+ [NotificationType.BOT_RESTARTING]:
+ '🔄 **Bot Restarting**\n\nThe bot is being restarted. Services will be temporarily unavailable.',
+ [NotificationType.BOT_ERROR]:
+ '🚨 **Critical Bot Error**\n\nThe bot has encountered a critical error and may not function correctly.',
+};
+
+/**
+ * Creates a Discord-friendly timestamp string
+ * @returns Formatted Discord timestamp string
+ */
+function createDiscordTimestamp(): string {
+ const timestamp = Math.floor(Date.now() / 1000);
+ return `<t:${timestamp}:F> (<t:${timestamp}:R>)`;
+}
+
+/**
+ * Gets all managers with the Manager role
+ * @param guild - The guild to search in
+ * @returns Array of members with the Manager role
+ */
+async function getManagers(guild: Guild): Promise<GuildMember[]> {
+ const config = loadConfig();
+ const managerRoleId = config.roles?.staffRoles?.find(
+ (role) => role.name === 'Manager',
+ )?.roleId;
+
+ if (!managerRoleId) {
+ console.warn('Manager role not found in config');
+ return [];
+ }
+
+ try {
+ await guild.members.fetch();
+
+ return Array.from(
+ guild.members.cache
+ .filter(
+ (member) => member.roles.cache.has(managerRoleId) && !member.user.bot,
+ )
+ .values(),
+ );
+ } catch (error) {
+ console.error('Error fetching managers:', error);
+ return [];
+ }
+}
+
+/**
+ * Sends a notification to users with the Manager role
+ * @param client - Discord client instance
+ * @param type - Type of notification to send
+ * @param customMessage - Optional custom message to append
+ */
+export async function notifyManagers(
+ client: Client,
+ type: NotificationType,
+ customMessage?: string,
+): Promise<void> {
+ try {
+ const config = loadConfig();
+ const guild = client.guilds.cache.get(config.guildId);
+
+ if (!guild) {
+ console.error(`Guild with ID ${config.guildId} not found`);
+ return;
+ }
+
+ const managers = await getManagers(guild);
+
+ if (managers.length === 0) {
+ console.warn('No managers found to notify');
+ return;
+ }
+
+ const baseMessage = NOTIFICATION_MESSAGES[type];
+ const timestamp = createDiscordTimestamp();
+ const fullMessage = customMessage
+ ? `${baseMessage}\n\n${customMessage}`
+ : baseMessage;
+
+ let successCount = 0;
+ for (const manager of managers) {
+ try {
+ await manager.send({
+ content: `${fullMessage}\n\nTimestamp: ${timestamp}`,
+ });
+ successCount++;
+ } catch (error) {
+ console.error(
+ `Failed to send DM to manager ${manager.user.tag}:`,
+ error,
+ );
+ }
+ }
+
+ console.log(
+ `Sent ${type} notification to ${successCount}/${managers.length} managers`,
+ );
+ } catch (error) {
+ console.error('Error sending manager notifications:', error);
+ }
+}
+
+/**
+ * Log a manager-level notification to the console
+ * @param type - Type of notification
+ * @param details - Additional details
+ */
+export function logManagerNotification(
+ type: NotificationType,
+ details?: string,
+): void {
+ const baseMessage = NOTIFICATION_MESSAGES[type].split('\n')[0];
+ console.warn(
+ `MANAGER NOTIFICATION: ${baseMessage}${details ? ` | ${details}` : ''}`,
+ );
+}
diff --git a/yarn.lock b/yarn.lock
index 7e88ffc..366d61e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -5,6 +5,215 @@ __metadata:
version: 8
cacheKey: 10c0
+"@babel/code-frame@npm:^7.0.0":
+ version: 7.26.2
+ resolution: "@babel/code-frame@npm:7.26.2"
+ dependencies:
+ "@babel/helper-validator-identifier": "npm:^7.25.9"
+ js-tokens: "npm:^4.0.0"
+ picocolors: "npm:^1.0.0"
+ checksum: 10c0/7d79621a6849183c415486af99b1a20b84737e8c11cd55b6544f688c51ce1fd710e6d869c3dd21232023da272a79b91efb3e83b5bc2dc65c1187c5fcd1b72ea8
+ languageName: node
+ linkType: hard
+
+"@babel/helper-validator-identifier@npm:^7.25.9":
+ version: 7.25.9
+ resolution: "@babel/helper-validator-identifier@npm:7.25.9"
+ checksum: 10c0/4fc6f830177b7b7e887ad3277ddb3b91d81e6c4a24151540d9d1023e8dc6b1c0505f0f0628ae653601eb4388a8db45c1c14b2c07a9173837aef7e4116456259d
+ languageName: node
+ linkType: hard
+
+"@commitlint/cli@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/cli@npm:19.8.0"
+ dependencies:
+ "@commitlint/format": "npm:^19.8.0"
+ "@commitlint/lint": "npm:^19.8.0"
+ "@commitlint/load": "npm:^19.8.0"
+ "@commitlint/read": "npm:^19.8.0"
+ "@commitlint/types": "npm:^19.8.0"
+ tinyexec: "npm:^0.3.0"
+ yargs: "npm:^17.0.0"
+ bin:
+ commitlint: ./cli.js
+ checksum: 10c0/6931c62c18b848b2c7266ec0b2d3a690a9ec9f83151a67a89ef20a49c84d5e6ee8dbaee4aaec14b2bd1229fdd91c7a0b41b7fd68c52fff8632a0037d52bd6eb2
+ languageName: node
+ linkType: hard
+
+"@commitlint/config-conventional@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/config-conventional@npm:19.8.0"
+ dependencies:
+ "@commitlint/types": "npm:^19.8.0"
+ conventional-changelog-conventionalcommits: "npm:^7.0.2"
+ checksum: 10c0/c0e2ad4ee8b793ad08ce8f0fd242d8111c71c81eba53b652431b7852e02d3eef0a383e234b7574429f5d1876b712a915921f6ff61fdaccdf708cbbaf3fa1f2f0
+ languageName: node
+ linkType: hard
+
+"@commitlint/config-validator@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/config-validator@npm:19.8.0"
+ dependencies:
+ "@commitlint/types": "npm:^19.8.0"
+ ajv: "npm:^8.11.0"
+ checksum: 10c0/968b3041dbf1683f9da443c2998a53ced52e86b98a48862f39f303af69638c72b7409840c16b3ded27eaa1636bdbf6b2464f8a2628c40d8f14a66a5474359ed5
+ languageName: node
+ linkType: hard
+
+"@commitlint/ensure@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/ensure@npm:19.8.0"
+ dependencies:
+ "@commitlint/types": "npm:^19.8.0"
+ lodash.camelcase: "npm:^4.3.0"
+ lodash.kebabcase: "npm:^4.1.1"
+ lodash.snakecase: "npm:^4.1.1"
+ lodash.startcase: "npm:^4.4.0"
+ lodash.upperfirst: "npm:^4.3.1"
+ checksum: 10c0/5160dcf41c595496894cf1d075b4ee15c14b3689967d8693d4121689475d36853eceeb09fc4e07b6f002e7b8869e75418b0c1cd95d4ee32d062811301337875c
+ languageName: node
+ linkType: hard
+
+"@commitlint/execute-rule@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/execute-rule@npm:19.8.0"
+ checksum: 10c0/fee5848e41680935510c6eebe2afcfe3511e2ccc39686c555f2e2db0205345479c7dbd84e7a8a2b22c7700ce75e6442b24685fbc3a419b0ea91f83a0850c6489
+ languageName: node
+ linkType: hard
+
+"@commitlint/format@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/format@npm:19.8.0"
+ dependencies:
+ "@commitlint/types": "npm:^19.8.0"
+ chalk: "npm:^5.3.0"
+ checksum: 10c0/25de71d5b19c126e7e9f471dcf8015bc362ee94fec7ca0da866181832548cb4a04c18f732c8d7cc64641e896a33d0e199bd445edd9e0ef164b0e7bd7259b86b1
+ languageName: node
+ linkType: hard
+
+"@commitlint/is-ignored@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/is-ignored@npm:19.8.0"
+ dependencies:
+ "@commitlint/types": "npm:^19.8.0"
+ semver: "npm:^7.6.0"
+ checksum: 10c0/6f882266cca84fdc2a435cc01388b070c60cdda56dff6cb1bd98a443982d8bb90b186972450c733ee1190122882f53e715a7204d9fc9787b5303ca545985958c
+ languageName: node
+ linkType: hard
+
+"@commitlint/lint@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/lint@npm:19.8.0"
+ dependencies:
+ "@commitlint/is-ignored": "npm:^19.8.0"
+ "@commitlint/parse": "npm:^19.8.0"
+ "@commitlint/rules": "npm:^19.8.0"
+ "@commitlint/types": "npm:^19.8.0"
+ checksum: 10c0/5ce1074e5ad1ed12158fb722d4d643be71c3ae35113c6b13faa71dd85a07eeafec50ef2fee3f3e6fccdbd8bf8684613aa097e287b54a7cbcae1f9f28e2b95e8d
+ languageName: node
+ linkType: hard
+
+"@commitlint/load@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/load@npm:19.8.0"
+ dependencies:
+ "@commitlint/config-validator": "npm:^19.8.0"
+ "@commitlint/execute-rule": "npm:^19.8.0"
+ "@commitlint/resolve-extends": "npm:^19.8.0"
+ "@commitlint/types": "npm:^19.8.0"
+ chalk: "npm:^5.3.0"
+ cosmiconfig: "npm:^9.0.0"
+ cosmiconfig-typescript-loader: "npm:^6.1.0"
+ lodash.isplainobject: "npm:^4.0.6"
+ lodash.merge: "npm:^4.6.2"
+ lodash.uniq: "npm:^4.5.0"
+ checksum: 10c0/6826a015ce40ae6043ff45bf29c7d515822ea416ab2a2a6eec6a69e5ba81b71419cadd609070aa3695d59f5442c34e3c264889df343eb66595c130185db58bad
+ languageName: node
+ linkType: hard
+
+"@commitlint/message@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/message@npm:19.8.0"
+ checksum: 10c0/a7390fade33e381a17d53ec16081bd6915d61cf4eb326739ee4b4c1f3a4016f84e953dd273126fcf23deaf5ca2ed49d75c0e667bc159dcfb26cb37ce840d97a9
+ languageName: node
+ linkType: hard
+
+"@commitlint/parse@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/parse@npm:19.8.0"
+ dependencies:
+ "@commitlint/types": "npm:^19.8.0"
+ conventional-changelog-angular: "npm:^7.0.0"
+ conventional-commits-parser: "npm:^5.0.0"
+ checksum: 10c0/ece54b76d2bf6eb620d972810a8db276a104cbd29db6a3c7eb661fc6eaf8212fda04a42920eac56831f65af77bc4a8e15260c2c0881f351289d93e4cf5371cde
+ languageName: node
+ linkType: hard
+
+"@commitlint/read@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/read@npm:19.8.0"
+ dependencies:
+ "@commitlint/top-level": "npm:^19.8.0"
+ "@commitlint/types": "npm:^19.8.0"
+ git-raw-commits: "npm:^4.0.0"
+ minimist: "npm:^1.2.8"
+ tinyexec: "npm:^0.3.0"
+ checksum: 10c0/94b9156f67b95d0ca7dd9653e399b7129d0b84c4940dc79a5264148688ca01c70780ef235b67d344059e575938c9e0988af9fa7233a793dcd74f49f9278e0e68
+ languageName: node
+ linkType: hard
+
+"@commitlint/resolve-extends@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/resolve-extends@npm:19.8.0"
+ dependencies:
+ "@commitlint/config-validator": "npm:^19.8.0"
+ "@commitlint/types": "npm:^19.8.0"
+ global-directory: "npm:^4.0.1"
+ import-meta-resolve: "npm:^4.0.0"
+ lodash.mergewith: "npm:^4.6.2"
+ resolve-from: "npm:^5.0.0"
+ checksum: 10c0/7b05d0c9bc2171e1475baeef13d30d6d985e1dd9cb4652355484a8d4841797dffd3e80edd5c61182cbfab1a28f4180ccbdef87bfa8f4586e057e05e238f5b19b
+ languageName: node
+ linkType: hard
+
+"@commitlint/rules@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/rules@npm:19.8.0"
+ dependencies:
+ "@commitlint/ensure": "npm:^19.8.0"
+ "@commitlint/message": "npm:^19.8.0"
+ "@commitlint/to-lines": "npm:^19.8.0"
+ "@commitlint/types": "npm:^19.8.0"
+ checksum: 10c0/3d6e932dfbd4c6384d3b3ded66a9f886667988cae4b1ae091350198ae8ca5c703142f13ccd8b632a0d260fd48072f5bc67836c15e6d637033b97dac2c81c95dd
+ languageName: node
+ linkType: hard
+
+"@commitlint/to-lines@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/to-lines@npm:19.8.0"
+ checksum: 10c0/1a0f34805615f244f34471138cfd5c8a45531ec3d1a0254370835db817dd06ec14181a8b281cd508632cf217d6cf5148473984bf4736d74b275fe69b8cd40863
+ languageName: node
+ linkType: hard
+
+"@commitlint/top-level@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/top-level@npm:19.8.0"
+ dependencies:
+ find-up: "npm:^7.0.0"
+ checksum: 10c0/04d39835bfb8d9f86b693d8d13bfe7e6566d48ac57e382e5139277bb0e5fa286645fe220c323fcb8e6569eea48ab26253c0eb4f6a142855a3a7b7565891ead7c
+ languageName: node
+ linkType: hard
+
+"@commitlint/types@npm:^19.8.0":
+ version: 19.8.0
+ resolution: "@commitlint/types@npm:19.8.0"
+ dependencies:
+ "@types/conventional-commits-parser": "npm:^5.0.0"
+ chalk: "npm:^5.3.0"
+ checksum: 10c0/634a5db20110675da8ddf226f200c33f262c6e99d06853fd4a2f6d543e6cc7dfe48b045f7ae76bcce2e39595099bfebe6a5dd6da37ff2968733c1263b8d46644
+ languageName: node
+ linkType: hard
+
"@cspotcode/source-map-support@npm:^0.8.0":
version: 0.8.1
resolution: "@cspotcode/source-map-support@npm:0.8.1"
@@ -1068,6 +1277,15 @@ __metadata:
languageName: node
linkType: hard
+"@types/conventional-commits-parser@npm:^5.0.0":
+ version: 5.0.1
+ resolution: "@types/conventional-commits-parser@npm:5.0.1"
+ dependencies:
+ "@types/node": "npm:*"
+ checksum: 10c0/4b7b561f195f779d07f973801a9f15d77cd58ceb67e817459688b11cc735288d30de050f445c91f4cd2c007fa86824e59a6e3cde602d150b828c4474f6e67be5
+ languageName: node
+ linkType: hard
+
"@types/estree@npm:^1.0.6":
version: 1.0.6
resolution: "@types/estree@npm:1.0.6"
@@ -1246,6 +1464,18 @@ __metadata:
languageName: node
linkType: hard
+"JSONStream@npm:^1.3.5":
+ version: 1.3.5
+ resolution: "JSONStream@npm:1.3.5"
+ dependencies:
+ jsonparse: "npm:^1.2.0"
+ through: "npm:>=2.2.7 <3"
+ bin:
+ JSONStream: ./bin.js
+ checksum: 10c0/0f54694da32224d57b715385d4a6b668d2117379d1f3223dc758459246cca58fdc4c628b83e8a8883334e454a0a30aa198ede77c788b55537c1844f686a751f2
+ languageName: node
+ linkType: hard
+
"abbrev@npm:^2.0.0":
version: 2.0.0
resolution: "abbrev@npm:2.0.0"
@@ -1320,6 +1550,27 @@ __metadata:
languageName: node
linkType: hard
+"ajv@npm:^8.11.0":
+ version: 8.17.1
+ resolution: "ajv@npm:8.17.1"
+ dependencies:
+ fast-deep-equal: "npm:^3.1.3"
+ fast-uri: "npm:^3.0.1"
+ json-schema-traverse: "npm:^1.0.0"
+ require-from-string: "npm:^2.0.2"
+ checksum: 10c0/ec3ba10a573c6b60f94639ffc53526275917a2df6810e4ab5a6b959d87459f9ef3f00d5e7865b82677cb7d21590355b34da14d1d0b9c32d75f95a187e76fff35
+ languageName: node
+ linkType: hard
+
+"ansi-escapes@npm:^7.0.0":
+ version: 7.0.0
+ resolution: "ansi-escapes@npm:7.0.0"
+ dependencies:
+ environment: "npm:^1.0.0"
+ checksum: 10c0/86e51e36fabef18c9c004af0a280573e828900641cea35134a124d2715e0c5a473494ab4ce396614505da77638ae290ff72dd8002d9747d2ee53f5d6bbe336be
+ languageName: node
+ linkType: hard
+
"ansi-regex@npm:^5.0.1":
version: 5.0.1
resolution: "ansi-regex@npm:5.0.1"
@@ -1343,7 +1594,7 @@ __metadata:
languageName: node
linkType: hard
-"ansi-styles@npm:^6.1.0":
+"ansi-styles@npm:^6.0.0, ansi-styles@npm:^6.1.0, ansi-styles@npm:^6.2.1":
version: 6.2.1
resolution: "ansi-styles@npm:6.2.1"
checksum: 10c0/5d1ec38c123984bcedd996eac680d548f31828bd679a66db2bdf11844634dde55fec3efa9c6bb1d89056a5e79c1ac540c4c784d592ea1d25028a92227d2f2d5c
@@ -1364,6 +1615,13 @@ __metadata:
languageName: node
linkType: hard
+"array-ify@npm:^1.0.0":
+ version: 1.0.0
+ resolution: "array-ify@npm:1.0.0"
+ checksum: 10c0/75c9c072faac47bd61779c0c595e912fe660d338504ac70d10e39e1b8a4a0c9c87658703d619b9d1b70d324177ae29dc8d07dda0d0a15d005597bc4c5a59c70c
+ languageName: node
+ linkType: hard
+
"balanced-match@npm:^1.0.0":
version: 1.0.2
resolution: "balanced-match@npm:1.0.2"
@@ -1443,6 +1701,13 @@ __metadata:
languageName: node
linkType: hard
+"chalk@npm:^5.3.0, chalk@npm:^5.4.1":
+ version: 5.4.1
+ resolution: "chalk@npm:5.4.1"
+ checksum: 10c0/b23e88132c702f4855ca6d25cb5538b1114343e41472d5263ee8a37cccfccd9c4216d111e1097c6a27830407a1dc81fecdf2a56f2c63033d4dbbd88c10b0dcef
+ languageName: node
+ linkType: hard
+
"chownr@npm:^2.0.0":
version: 2.0.0
resolution: "chownr@npm:2.0.0"
@@ -1457,6 +1722,36 @@ __metadata:
languageName: node
linkType: hard
+"cli-cursor@npm:^5.0.0":
+ version: 5.0.0
+ resolution: "cli-cursor@npm:5.0.0"
+ dependencies:
+ restore-cursor: "npm:^5.0.0"
+ checksum: 10c0/7ec62f69b79f6734ab209a3e4dbdc8af7422d44d360a7cb1efa8a0887bbe466a6e625650c466fe4359aee44dbe2dc0b6994b583d40a05d0808a5cb193641d220
+ languageName: node
+ linkType: hard
+
+"cli-truncate@npm:^4.0.0":
+ version: 4.0.0
+ resolution: "cli-truncate@npm:4.0.0"
+ dependencies:
+ slice-ansi: "npm:^5.0.0"
+ string-width: "npm:^7.0.0"
+ checksum: 10c0/d7f0b73e3d9b88cb496e6c086df7410b541b56a43d18ade6a573c9c18bd001b1c3fba1ad578f741a4218fdc794d042385f8ac02c25e1c295a2d8b9f3cb86eb4c
+ languageName: node
+ linkType: hard
+
+"cliui@npm:^8.0.1":
+ version: 8.0.1
+ resolution: "cliui@npm:8.0.1"
+ dependencies:
+ string-width: "npm:^4.2.0"
+ strip-ansi: "npm:^6.0.1"
+ wrap-ansi: "npm:^7.0.0"
+ checksum: 10c0/4bda0f09c340cbb6dfdc1ed508b3ca080f12992c18d68c6be4d9cf51756033d5266e61ec57529e610dacbf4da1c634423b0c1b11037709cc6b09045cbd815df5
+ languageName: node
+ linkType: hard
+
"cluster-key-slot@npm:^1.1.0":
version: 1.1.2
resolution: "cluster-key-slot@npm:1.1.2"
@@ -1480,6 +1775,30 @@ __metadata:
languageName: node
linkType: hard
+"colorette@npm:^2.0.20":
+ version: 2.0.20
+ resolution: "colorette@npm:2.0.20"
+ checksum: 10c0/e94116ff33b0ff56f3b83b9ace895e5bf87c2a7a47b3401b8c3f3226e050d5ef76cf4072fb3325f9dc24d1698f9b730baf4e05eeaf861d74a1883073f4c98a40
+ languageName: node
+ linkType: hard
+
+"commander@npm:^13.1.0":
+ version: 13.1.0
+ resolution: "commander@npm:13.1.0"
+ checksum: 10c0/7b8c5544bba704fbe84b7cab2e043df8586d5c114a4c5b607f83ae5060708940ed0b5bd5838cf8ce27539cde265c1cbd59ce3c8c6b017ed3eec8943e3a415164
+ languageName: node
+ linkType: hard
+
+"compare-func@npm:^2.0.0":
+ version: 2.0.0
+ resolution: "compare-func@npm:2.0.0"
+ dependencies:
+ array-ify: "npm:^1.0.0"
+ dot-prop: "npm:^5.1.0"
+ checksum: 10c0/78bd4dd4ed311a79bd264c9e13c36ed564cde657f1390e699e0f04b8eee1fc06ffb8698ce2dfb5fbe7342d509579c82d4e248f08915b708f77f7b72234086cc3
+ languageName: node
+ linkType: hard
+
"concat-map@npm:0.0.1":
version: 0.0.1
resolution: "concat-map@npm:0.0.1"
@@ -1487,6 +1806,68 @@ __metadata:
languageName: node
linkType: hard
+"conventional-changelog-angular@npm:^7.0.0":
+ version: 7.0.0
+ resolution: "conventional-changelog-angular@npm:7.0.0"
+ dependencies:
+ compare-func: "npm:^2.0.0"
+ checksum: 10c0/90e73e25e224059b02951b6703b5f8742dc2a82c1fea62163978e6735fd3ab04350897a8fc6f443ec6b672d6b66e28a0820e833e544a0101f38879e5e6289b7e
+ languageName: node
+ linkType: hard
+
+"conventional-changelog-conventionalcommits@npm:^7.0.2":
+ version: 7.0.2
+ resolution: "conventional-changelog-conventionalcommits@npm:7.0.2"
+ dependencies:
+ compare-func: "npm:^2.0.0"
+ checksum: 10c0/3cb1eab35e37fc973cfb3aed0e159f54414e49b222988da1c2aa86cc8a87fe7531491bbb7657fe5fc4dc0e25f5b50e2065ba8ac71cc4c08eed9189102a2b81bd
+ languageName: node
+ linkType: hard
+
+"conventional-commits-parser@npm:^5.0.0":
+ version: 5.0.0
+ resolution: "conventional-commits-parser@npm:5.0.0"
+ dependencies:
+ JSONStream: "npm:^1.3.5"
+ is-text-path: "npm:^2.0.0"
+ meow: "npm:^12.0.1"
+ split2: "npm:^4.0.0"
+ bin:
+ conventional-commits-parser: cli.mjs
+ checksum: 10c0/c9e542f4884119a96a6bf3311ff62cdee55762d8547f4c745ae3ebdc50afe4ba7691e165e34827d5cf63283cbd93ab69917afd7922423075b123d5d9a7a82ed2
+ languageName: node
+ linkType: hard
+
+"cosmiconfig-typescript-loader@npm:^6.1.0":
+ version: 6.1.0
+ resolution: "cosmiconfig-typescript-loader@npm:6.1.0"
+ dependencies:
+ jiti: "npm:^2.4.1"
+ peerDependencies:
+ "@types/node": "*"
+ cosmiconfig: ">=9"
+ typescript: ">=5"
+ checksum: 10c0/5e3baf85a9da7dcdd7ef53a54d1293400eed76baf0abb3a41bf9fcc789f1a2653319443471f9a1dc32951f1de4467a6696ccd0f88640e7827f1af6ff94ceaf1a
+ languageName: node
+ linkType: hard
+
+"cosmiconfig@npm:^9.0.0":
+ version: 9.0.0
+ resolution: "cosmiconfig@npm:9.0.0"
+ dependencies:
+ env-paths: "npm:^2.2.1"
+ import-fresh: "npm:^3.3.0"
+ js-yaml: "npm:^4.1.0"
+ parse-json: "npm:^5.2.0"
+ peerDependencies:
+ typescript: ">=4.9.5"
+ peerDependenciesMeta:
+ typescript:
+ optional: true
+ checksum: 10c0/1c1703be4f02a250b1d6ca3267e408ce16abfe8364193891afc94c2d5c060b69611fdc8d97af74b7e6d5d1aac0ab2fb94d6b079573146bc2d756c2484ce5f0ee
+ languageName: node
+ linkType: hard
+
"create-require@npm:^1.1.0":
version: 1.1.1
resolution: "create-require@npm:1.1.1"
@@ -1494,7 +1875,7 @@ __metadata:
languageName: node
linkType: hard
-"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.6":
+"cross-spawn@npm:^7.0.0, cross-spawn@npm:^7.0.2, cross-spawn@npm:^7.0.3, cross-spawn@npm:^7.0.6":
version: 7.0.6
resolution: "cross-spawn@npm:7.0.6"
dependencies:
@@ -1505,6 +1886,13 @@ __metadata:
languageName: node
linkType: hard
+"dargs@npm:^8.0.0":
+ version: 8.1.0
+ resolution: "dargs@npm:8.1.0"
+ checksum: 10c0/08cbd1ee4ac1a16fb7700e761af2e3e22d1bdc04ac4f851926f552dde8f9e57714c0d04013c2cca1cda0cba8fb637e0f93ad15d5285547a939dd1989ee06a82d
+ languageName: node
+ linkType: hard
+
"debug@npm:4, debug@npm:^4.3.4":
version: 4.3.7
resolution: "debug@npm:4.3.7"
@@ -1529,6 +1917,18 @@ __metadata:
languageName: node
linkType: hard
+"debug@npm:^4.4.0":
+ version: 4.4.0
+ resolution: "debug@npm:4.4.0"
+ dependencies:
+ ms: "npm:^2.1.3"
+ peerDependenciesMeta:
+ supports-color:
+ optional: true
+ checksum: 10c0/db94f1a182bf886f57b4755f85b3a74c39b5114b9377b7ab375dc2cfa3454f09490cc6c30f829df3fc8042bc8b8995f6567ce5cd96f3bc3688bd24027197d9de
+ languageName: node
+ linkType: hard
+
"deep-is@npm:^0.1.3":
version: 0.1.4
resolution: "deep-is@npm:0.1.4"
@@ -1593,6 +1993,15 @@ __metadata:
languageName: node
linkType: hard
+"dot-prop@npm:^5.1.0":
+ version: 5.3.0
+ resolution: "dot-prop@npm:5.3.0"
+ dependencies:
+ is-obj: "npm:^2.0.0"
+ checksum: 10c0/93f0d343ef87fe8869320e62f2459f7e70f49c6098d948cc47e060f4a3f827d0ad61e83cb82f2bd90cd5b9571b8d334289978a43c0f98fea4f0e99ee8faa0599
+ languageName: node
+ linkType: hard
+
"drizzle-kit@npm:^0.30.6":
version: 0.30.6
resolution: "drizzle-kit@npm:0.30.6"
@@ -1707,6 +2116,13 @@ __metadata:
languageName: node
linkType: hard
+"emoji-regex@npm:^10.3.0":
+ version: 10.4.0
+ resolution: "emoji-regex@npm:10.4.0"
+ checksum: 10c0/a3fcedfc58bfcce21a05a5f36a529d81e88d602100145fcca3dc6f795e3c8acc4fc18fe773fbf9b6d6e9371205edb3afa2668ec3473fa2aa7fd47d2a9d46482d
+ languageName: node
+ linkType: hard
+
"emoji-regex@npm:^8.0.0":
version: 8.0.0
resolution: "emoji-regex@npm:8.0.0"
@@ -1730,7 +2146,7 @@ __metadata:
languageName: node
linkType: hard
-"env-paths@npm:^2.2.0":
+"env-paths@npm:^2.2.0, env-paths@npm:^2.2.1":
version: 2.2.1
resolution: "env-paths@npm:2.2.1"
checksum: 10c0/285325677bf00e30845e330eec32894f5105529db97496ee3f598478e50f008c5352a41a30e5e72ec9de8a542b5a570b85699cd63bd2bc646dbcb9f311d83bc4
@@ -1744,6 +2160,13 @@ __metadata:
languageName: node
linkType: hard
+"environment@npm:^1.0.0":
+ version: 1.1.0
+ resolution: "environment@npm:1.1.0"
+ checksum: 10c0/fb26434b0b581ab397039e51ff3c92b34924a98b2039dcb47e41b7bca577b9dbf134a8eadb364415c74464b682e2d3afe1a4c0eb9873dc44ea814c5d3103331d
+ languageName: node
+ linkType: hard
+
"err-code@npm:^2.0.2":
version: 2.0.3
resolution: "err-code@npm:2.0.3"
@@ -1751,6 +2174,15 @@ __metadata:
languageName: node
linkType: hard
+"error-ex@npm:^1.3.1":
+ version: 1.3.2
+ resolution: "error-ex@npm:1.3.2"
+ dependencies:
+ is-arrayish: "npm:^0.2.1"
+ checksum: 10c0/ba827f89369b4c93382cfca5a264d059dfefdaa56ecc5e338ffa58a6471f5ed93b71a20add1d52290a4873d92381174382658c885ac1a2305f7baca363ce9cce
+ languageName: node
+ linkType: hard
+
"esbuild-register@npm:^3.5.0":
version: 3.6.0
resolution: "esbuild-register@npm:3.6.0"
@@ -2005,6 +2437,13 @@ __metadata:
languageName: node
linkType: hard
+"escalade@npm:^3.1.1":
+ version: 3.2.0
+ resolution: "escalade@npm:3.2.0"
+ checksum: 10c0/ced4dd3a78e15897ed3be74e635110bbf3b08877b0a41be50dcb325ee0e0b5f65fc2d50e9845194d7c4633f327e2e1c6cce00a71b617c5673df0374201d67f65
+ languageName: node
+ linkType: hard
+
"escape-string-regexp@npm:^4.0.0":
version: 4.0.0
resolution: "escape-string-regexp@npm:4.0.0"
@@ -2227,6 +2666,30 @@ __metadata:
languageName: node
linkType: hard
+"eventemitter3@npm:^5.0.1":
+ version: 5.0.1
+ resolution: "eventemitter3@npm:5.0.1"
+ checksum: 10c0/4ba5c00c506e6c786b4d6262cfbce90ddc14c10d4667e5c83ae993c9de88aa856033994dd2b35b83e8dc1170e224e66a319fa80adc4c32adcd2379bbc75da814
+ languageName: node
+ linkType: hard
+
+"execa@npm:^8.0.1":
+ version: 8.0.1
+ resolution: "execa@npm:8.0.1"
+ dependencies:
+ cross-spawn: "npm:^7.0.3"
+ get-stream: "npm:^8.0.1"
+ human-signals: "npm:^5.0.0"
+ is-stream: "npm:^3.0.0"
+ merge-stream: "npm:^2.0.0"
+ npm-run-path: "npm:^5.1.0"
+ onetime: "npm:^6.0.0"
+ signal-exit: "npm:^4.1.0"
+ strip-final-newline: "npm:^3.0.0"
+ checksum: 10c0/2c52d8775f5bf103ce8eec9c7ab3059909ba350a5164744e9947ed14a53f51687c040a250bda833f906d1283aa8803975b84e6c8f7a7c42f99dc8ef80250d1af
+ languageName: node
+ linkType: hard
+
"exponential-backoff@npm:^3.1.1":
version: 3.1.1
resolution: "exponential-backoff@npm:3.1.1"
@@ -2268,6 +2731,13 @@ __metadata:
languageName: node
linkType: hard
+"fast-uri@npm:^3.0.1":
+ version: 3.0.6
+ resolution: "fast-uri@npm:3.0.6"
+ checksum: 10c0/74a513c2af0584448aee71ce56005185f81239eab7a2343110e5bad50c39ad4fb19c5a6f99783ead1cac7ccaf3461a6034fda89fffa2b30b6d99b9f21c2f9d29
+ languageName: node
+ linkType: hard
+
"fastq@npm:^1.6.0":
version: 1.17.1
resolution: "fastq@npm:1.17.1"
@@ -2314,6 +2784,17 @@ __metadata:
languageName: node
linkType: hard
+"find-up@npm:^7.0.0":
+ version: 7.0.0
+ resolution: "find-up@npm:7.0.0"
+ dependencies:
+ locate-path: "npm:^7.2.0"
+ path-exists: "npm:^5.0.0"
+ unicorn-magic: "npm:^0.1.0"
+ checksum: 10c0/e6ee3e6154560bc0ab3bc3b7d1348b31513f9bdf49a5dd2e952495427d559fa48cdf33953e85a309a323898b43fa1bfbc8b80c880dfc16068384783034030008
+ languageName: node
+ linkType: hard
+
"flat-cache@npm:^3.0.4":
version: 3.2.0
resolution: "flat-cache@npm:3.2.0"
@@ -2412,6 +2893,27 @@ __metadata:
languageName: node
linkType: hard
+"get-caller-file@npm:^2.0.5":
+ version: 2.0.5
+ resolution: "get-caller-file@npm:2.0.5"
+ checksum: 10c0/c6c7b60271931fa752aeb92f2b47e355eac1af3a2673f47c9589e8f8a41adc74d45551c1bc57b5e66a80609f10ffb72b6f575e4370d61cc3f7f3aaff01757cde
+ languageName: node
+ linkType: hard
+
+"get-east-asian-width@npm:^1.0.0":
+ version: 1.3.0
+ resolution: "get-east-asian-width@npm:1.3.0"
+ checksum: 10c0/1a049ba697e0f9a4d5514c4623781c5246982bdb61082da6b5ae6c33d838e52ce6726407df285cdbb27ec1908b333cf2820989bd3e986e37bb20979437fdf34b
+ languageName: node
+ linkType: hard
+
+"get-stream@npm:^8.0.1":
+ version: 8.0.1
+ resolution: "get-stream@npm:8.0.1"
+ checksum: 10c0/5c2181e98202b9dae0bb4a849979291043e5892eb40312b47f0c22b9414fc9b28a3b6063d2375705eb24abc41ecf97894d9a51f64ff021511b504477b27b4290
+ languageName: node
+ linkType: hard
+
"get-tsconfig@npm:^4.7.0, get-tsconfig@npm:^4.7.5":
version: 4.8.1
resolution: "get-tsconfig@npm:4.8.1"
@@ -2421,6 +2923,19 @@ __metadata:
languageName: node
linkType: hard
+"git-raw-commits@npm:^4.0.0":
+ version: 4.0.0
+ resolution: "git-raw-commits@npm:4.0.0"
+ dependencies:
+ dargs: "npm:^8.0.0"
+ meow: "npm:^12.0.1"
+ split2: "npm:^4.0.0"
+ bin:
+ git-raw-commits: cli.mjs
+ checksum: 10c0/ab51335d9e55692fce8e42788013dba7a7e7bf9f5bf0622c8cd7ddc9206489e66bb939563fca4edb3aa87477e2118f052702aad1933b13c6fa738af7f29884f0
+ languageName: node
+ linkType: hard
+
"glob-parent@npm:^5.1.2":
version: 5.1.2
resolution: "glob-parent@npm:5.1.2"
@@ -2469,6 +2984,15 @@ __metadata:
languageName: node
linkType: hard
+"global-directory@npm:^4.0.1":
+ version: 4.0.1
+ resolution: "global-directory@npm:4.0.1"
+ dependencies:
+ ini: "npm:4.1.1"
+ checksum: 10c0/f9cbeef41db4876f94dd0bac1c1b4282a7de9c16350ecaaf83e7b2dd777b32704cc25beeb1170b5a63c42a2c9abfade74d46357fe0133e933218bc89e613d4b2
+ languageName: node
+ linkType: hard
+
"globals@npm:^13.19.0":
version: 13.24.0
resolution: "globals@npm:13.24.0"
@@ -2540,6 +3064,22 @@ __metadata:
languageName: node
linkType: hard
+"human-signals@npm:^5.0.0":
+ version: 5.0.0
+ resolution: "human-signals@npm:5.0.0"
+ checksum: 10c0/5a9359073fe17a8b58e5a085e9a39a950366d9f00217c4ff5878bd312e09d80f460536ea6a3f260b5943a01fe55c158d1cea3fc7bee3d0520aeef04f6d915c82
+ languageName: node
+ linkType: hard
+
+"husky@npm:^9.1.7":
+ version: 9.1.7
+ resolution: "husky@npm:9.1.7"
+ bin:
+ husky: bin.js
+ checksum: 10c0/35bb110a71086c48906aa7cd3ed4913fb913823715359d65e32e0b964cb1e255593b0ae8014a5005c66a68e6fa66c38dcfa8056dbbdfb8b0187c0ffe7ee3a58f
+ languageName: node
+ linkType: hard
+
"iconv-lite@npm:^0.6.2":
version: 0.6.3
resolution: "iconv-lite@npm:0.6.3"
@@ -2566,6 +3106,23 @@ __metadata:
languageName: node
linkType: hard
+"import-fresh@npm:^3.3.0":
+ version: 3.3.1
+ resolution: "import-fresh@npm:3.3.1"
+ dependencies:
+ parent-module: "npm:^1.0.0"
+ resolve-from: "npm:^4.0.0"
+ checksum: 10c0/bf8cc494872fef783249709385ae883b447e3eb09db0ebd15dcead7d9afe7224dad7bd7591c6b73b0b19b3c0f9640eb8ee884f01cfaf2887ab995b0b36a0cbec
+ languageName: node
+ linkType: hard
+
+"import-meta-resolve@npm:^4.0.0":
+ version: 4.1.0
+ resolution: "import-meta-resolve@npm:4.1.0"
+ checksum: 10c0/42f3284b0460635ddf105c4ad99c6716099c3ce76702602290ad5cbbcd295700cbc04e4bdf47bacf9e3f1a4cec2e1ff887dabc20458bef398f9de22ddff45ef5
+ languageName: node
+ linkType: hard
+
"imurmurhash@npm:^0.1.4":
version: 0.1.4
resolution: "imurmurhash@npm:0.1.4"
@@ -2597,6 +3154,13 @@ __metadata:
languageName: node
linkType: hard
+"ini@npm:4.1.1":
+ version: 4.1.1
+ resolution: "ini@npm:4.1.1"
+ checksum: 10c0/7fddc8dfd3e63567d4fdd5d999d1bf8a8487f1479d0b34a1d01f28d391a9228d261e19abc38e1a6a1ceb3400c727204fce05725d5eb598dfcf2077a1e3afe211
+ languageName: node
+ linkType: hard
+
"ioredis@npm:^5.6.0":
version: 5.6.0
resolution: "ioredis@npm:5.6.0"
@@ -2624,6 +3188,13 @@ __metadata:
languageName: node
linkType: hard
+"is-arrayish@npm:^0.2.1":
+ version: 0.2.1
+ resolution: "is-arrayish@npm:0.2.1"
+ checksum: 10c0/e7fb686a739068bb70f860b39b67afc62acc62e36bb61c5f965768abce1873b379c563e61dd2adad96ebb7edf6651111b385e490cf508378959b0ed4cac4e729
+ languageName: node
+ linkType: hard
+
"is-extglob@npm:^2.1.1":
version: 2.1.1
resolution: "is-extglob@npm:2.1.1"
@@ -2638,6 +3209,22 @@ __metadata:
languageName: node
linkType: hard
+"is-fullwidth-code-point@npm:^4.0.0":
+ version: 4.0.0
+ resolution: "is-fullwidth-code-point@npm:4.0.0"
+ checksum: 10c0/df2a717e813567db0f659c306d61f2f804d480752526886954a2a3e2246c7745fd07a52b5fecf2b68caf0a6c79dcdace6166fdf29cc76ed9975cc334f0a018b8
+ languageName: node
+ linkType: hard
+
+"is-fullwidth-code-point@npm:^5.0.0":
+ version: 5.0.0
+ resolution: "is-fullwidth-code-point@npm:5.0.0"
+ dependencies:
+ get-east-asian-width: "npm:^1.0.0"
+ checksum: 10c0/cd591b27d43d76b05fa65ed03eddce57a16e1eca0b7797ff7255de97019bcaf0219acfc0c4f7af13319e13541f2a53c0ace476f442b13267b9a6a7568f2b65c8
+ languageName: node
+ linkType: hard
+
"is-glob@npm:^4.0.0, is-glob@npm:^4.0.1, is-glob@npm:^4.0.3":
version: 4.0.3
resolution: "is-glob@npm:4.0.3"
@@ -2661,6 +3248,13 @@ __metadata:
languageName: node
linkType: hard
+"is-obj@npm:^2.0.0":
+ version: 2.0.0
+ resolution: "is-obj@npm:2.0.0"
+ checksum: 10c0/85044ed7ba8bd169e2c2af3a178cacb92a97aa75de9569d02efef7f443a824b5e153eba72b9ae3aca6f8ce81955271aa2dc7da67a8b720575d3e38104208cb4e
+ languageName: node
+ linkType: hard
+
"is-path-inside@npm:^3.0.3":
version: 3.0.3
resolution: "is-path-inside@npm:3.0.3"
@@ -2668,6 +3262,22 @@ __metadata:
languageName: node
linkType: hard
+"is-stream@npm:^3.0.0":
+ version: 3.0.0
+ resolution: "is-stream@npm:3.0.0"
+ checksum: 10c0/eb2f7127af02ee9aa2a0237b730e47ac2de0d4e76a4a905a50a11557f2339df5765eaea4ceb8029f1efa978586abe776908720bfcb1900c20c6ec5145f6f29d8
+ languageName: node
+ linkType: hard
+
+"is-text-path@npm:^2.0.0":
+ version: 2.0.0
+ resolution: "is-text-path@npm:2.0.0"
+ dependencies:
+ text-extensions: "npm:^2.0.0"
+ checksum: 10c0/e3c470e1262a3a54aa0fca1c0300b2659a7aed155714be6b643f88822c03bcfa6659b491f7a05c5acd3c1a3d6d42bab47e1bdd35bcc3a25973c4f26b2928bc1a
+ languageName: node
+ linkType: hard
+
"isexe@npm:^2.0.0":
version: 2.0.0
resolution: "isexe@npm:2.0.0"
@@ -2695,6 +3305,22 @@ __metadata:
languageName: node
linkType: hard
+"jiti@npm:^2.4.1":
+ version: 2.4.2
+ resolution: "jiti@npm:2.4.2"
+ bin:
+ jiti: lib/jiti-cli.mjs
+ checksum: 10c0/4ceac133a08c8faff7eac84aabb917e85e8257f5ad659e843004ce76e981c457c390a220881748ac67ba1b940b9b729b30fb85cbaf6e7989f04b6002c94da331
+ languageName: node
+ linkType: hard
+
+"js-tokens@npm:^4.0.0":
+ version: 4.0.0
+ resolution: "js-tokens@npm:4.0.0"
+ checksum: 10c0/e248708d377aa058eacf2037b07ded847790e6de892bbad3dac0abba2e759cb9f121b00099a65195616badcb6eca8d14d975cb3e89eb1cfda644756402c8aeed
+ languageName: node
+ linkType: hard
+
"js-yaml@npm:^4.1.0":
version: 4.1.0
resolution: "js-yaml@npm:4.1.0"
@@ -2727,6 +3353,13 @@ __metadata:
languageName: node
linkType: hard
+"json-parse-even-better-errors@npm:^2.3.0":
+ version: 2.3.1
+ resolution: "json-parse-even-better-errors@npm:2.3.1"
+ checksum: 10c0/140932564c8f0b88455432e0f33c4cb4086b8868e37524e07e723f4eaedb9425bdc2bafd71bd1d9765bd15fd1e2d126972bc83990f55c467168c228c24d665f3
+ languageName: node
+ linkType: hard
+
"json-schema-traverse@npm:^0.4.1":
version: 0.4.1
resolution: "json-schema-traverse@npm:0.4.1"
@@ -2734,6 +3367,13 @@ __metadata:
languageName: node
linkType: hard
+"json-schema-traverse@npm:^1.0.0":
+ version: 1.0.0
+ resolution: "json-schema-traverse@npm:1.0.0"
+ checksum: 10c0/71e30015d7f3d6dc1c316d6298047c8ef98a06d31ad064919976583eb61e1018a60a0067338f0f79cabc00d84af3fcc489bd48ce8a46ea165d9541ba17fb30c6
+ languageName: node
+ linkType: hard
+
"json-stable-stringify-without-jsonify@npm:^1.0.1":
version: 1.0.1
resolution: "json-stable-stringify-without-jsonify@npm:1.0.1"
@@ -2741,6 +3381,13 @@ __metadata:
languageName: node
linkType: hard
+"jsonparse@npm:^1.2.0":
+ version: 1.3.1
+ resolution: "jsonparse@npm:1.3.1"
+ checksum: 10c0/89bc68080cd0a0e276d4b5ab1b79cacd68f562467008d176dc23e16e97d4efec9e21741d92ba5087a8433526a45a7e6a9d5ef25408696c402ca1cfbc01a90bf0
+ languageName: node
+ linkType: hard
+
"keyv@npm:^4.5.3, keyv@npm:^4.5.4":
version: 4.5.4
resolution: "keyv@npm:4.5.4"
@@ -2760,6 +3407,54 @@ __metadata:
languageName: node
linkType: hard
+"lilconfig@npm:^3.1.3":
+ version: 3.1.3
+ resolution: "lilconfig@npm:3.1.3"
+ checksum: 10c0/f5604e7240c5c275743561442fbc5abf2a84ad94da0f5adc71d25e31fa8483048de3dcedcb7a44112a942fed305fd75841cdf6c9681c7f640c63f1049e9a5dcc
+ languageName: node
+ linkType: hard
+
+"lines-and-columns@npm:^1.1.6":
+ version: 1.2.4
+ resolution: "lines-and-columns@npm:1.2.4"
+ checksum: 10c0/3da6ee62d4cd9f03f5dc90b4df2540fb85b352081bee77fe4bbcd12c9000ead7f35e0a38b8d09a9bb99b13223446dd8689ff3c4959807620726d788701a83d2d
+ languageName: node
+ linkType: hard
+
+"lint-staged@npm:^15.5.0":
+ version: 15.5.0
+ resolution: "lint-staged@npm:15.5.0"
+ dependencies:
+ chalk: "npm:^5.4.1"
+ commander: "npm:^13.1.0"
+ debug: "npm:^4.4.0"
+ execa: "npm:^8.0.1"
+ lilconfig: "npm:^3.1.3"
+ listr2: "npm:^8.2.5"
+ micromatch: "npm:^4.0.8"
+ pidtree: "npm:^0.6.0"
+ string-argv: "npm:^0.3.2"
+ yaml: "npm:^2.7.0"
+ bin:
+ lint-staged: bin/lint-staged.js
+ checksum: 10c0/393b24d85d705a36e6556dc9d9b710594163be60f7789a2ca71bbf8f31debc10f7fde9cd0e868466ac2b7c154661983602decd7abbb6c685b21007bc70dbbdd6
+ languageName: node
+ linkType: hard
+
+"listr2@npm:^8.2.5":
+ version: 8.2.5
+ resolution: "listr2@npm:8.2.5"
+ dependencies:
+ cli-truncate: "npm:^4.0.0"
+ colorette: "npm:^2.0.20"
+ eventemitter3: "npm:^5.0.1"
+ log-update: "npm:^6.1.0"
+ rfdc: "npm:^1.4.1"
+ wrap-ansi: "npm:^9.0.0"
+ checksum: 10c0/f5a9599514b00c27d7eb32d1117c83c61394b2a985ec20e542c798bf91cf42b19340215701522736f5b7b42f557e544afeadec47866e35e5d4f268f552729671
+ languageName: node
+ linkType: hard
+
"locate-path@npm:^6.0.0":
version: 6.0.0
resolution: "locate-path@npm:6.0.0"
@@ -2769,6 +3464,22 @@ __metadata:
languageName: node
linkType: hard
+"locate-path@npm:^7.2.0":
+ version: 7.2.0
+ resolution: "locate-path@npm:7.2.0"
+ dependencies:
+ p-locate: "npm:^6.0.0"
+ checksum: 10c0/139e8a7fe11cfbd7f20db03923cacfa5db9e14fa14887ea121345597472b4a63c1a42a8a5187defeeff6acf98fd568da7382aa39682d38f0af27433953a97751
+ languageName: node
+ linkType: hard
+
+"lodash.camelcase@npm:^4.3.0":
+ version: 4.3.0
+ resolution: "lodash.camelcase@npm:4.3.0"
+ checksum: 10c0/fcba15d21a458076dd309fce6b1b4bf611d84a0ec252cb92447c948c533ac250b95d2e00955801ebc367e5af5ed288b996d75d37d2035260a937008e14eaf432
+ languageName: node
+ linkType: hard
+
"lodash.defaults@npm:^4.2.0":
version: 4.2.0
resolution: "lodash.defaults@npm:4.2.0"
@@ -2783,6 +3494,20 @@ __metadata:
languageName: node
linkType: hard
+"lodash.isplainobject@npm:^4.0.6":
+ version: 4.0.6
+ resolution: "lodash.isplainobject@npm:4.0.6"
+ checksum: 10c0/afd70b5c450d1e09f32a737bed06ff85b873ecd3d3d3400458725283e3f2e0bb6bf48e67dbe7a309eb371a822b16a26cca4a63c8c52db3fc7dc9d5f9dd324cbb
+ languageName: node
+ linkType: hard
+
+"lodash.kebabcase@npm:^4.1.1":
+ version: 4.1.1
+ resolution: "lodash.kebabcase@npm:4.1.1"
+ checksum: 10c0/da5d8f41dbb5bc723d4bf9203d5096ca8da804d6aec3d2b56457156ba6c8d999ff448d347ebd97490da853cb36696ea4da09a431499f1ee8deb17b094ecf4e33
+ languageName: node
+ linkType: hard
+
"lodash.merge@npm:^4.6.2":
version: 4.6.2
resolution: "lodash.merge@npm:4.6.2"
@@ -2790,13 +3515,41 @@ __metadata:
languageName: node
linkType: hard
-"lodash.snakecase@npm:4.1.1":
+"lodash.mergewith@npm:^4.6.2":
+ version: 4.6.2
+ resolution: "lodash.mergewith@npm:4.6.2"
+ checksum: 10c0/4adbed65ff96fd65b0b3861f6899f98304f90fd71e7f1eb36c1270e05d500ee7f5ec44c02ef979b5ddbf75c0a0b9b99c35f0ad58f4011934c4d4e99e5200b3b5
+ languageName: node
+ linkType: hard
+
+"lodash.snakecase@npm:4.1.1, lodash.snakecase@npm:^4.1.1":
version: 4.1.1
resolution: "lodash.snakecase@npm:4.1.1"
checksum: 10c0/f0b3f2497eb20eea1a1cfc22d645ecaeb78ac14593eb0a40057977606d2f35f7aaff0913a06553c783b535aafc55b718f523f9eb78f8d5293f492af41002eaf9
languageName: node
linkType: hard
+"lodash.startcase@npm:^4.4.0":
+ version: 4.4.0
+ resolution: "lodash.startcase@npm:4.4.0"
+ checksum: 10c0/bd82aa87a45de8080e1c5ee61128c7aee77bf7f1d86f4ff94f4a6d7438fc9e15e5f03374b947be577a93804c8ad6241f0251beaf1452bf716064eeb657b3a9f0
+ languageName: node
+ linkType: hard
+
+"lodash.uniq@npm:^4.5.0":
+ version: 4.5.0
+ resolution: "lodash.uniq@npm:4.5.0"
+ checksum: 10c0/262d400bb0952f112162a320cc4a75dea4f66078b9e7e3075ffbc9c6aa30b3e9df3cf20e7da7d566105e1ccf7804e4fbd7d804eee0b53de05d83f16ffbf41c5e
+ languageName: node
+ linkType: hard
+
+"lodash.upperfirst@npm:^4.3.1":
+ version: 4.3.1
+ resolution: "lodash.upperfirst@npm:4.3.1"
+ checksum: 10c0/435625da4b3ee74e7a1367a780d9107ab0b13ef4359fc074b2a1a40458eb8d91b655af62f6795b7138d493303a98c0285340160341561d6896e4947e077fa975
+ languageName: node
+ linkType: hard
+
"lodash@npm:^4.17.14, lodash@npm:^4.17.21":
version: 4.17.21
resolution: "lodash@npm:4.17.21"
@@ -2804,6 +3557,19 @@ __metadata:
languageName: node
linkType: hard
+"log-update@npm:^6.1.0":
+ version: 6.1.0
+ resolution: "log-update@npm:6.1.0"
+ dependencies:
+ ansi-escapes: "npm:^7.0.0"
+ cli-cursor: "npm:^5.0.0"
+ slice-ansi: "npm:^7.1.0"
+ strip-ansi: "npm:^7.1.0"
+ wrap-ansi: "npm:^9.0.0"
+ checksum: 10c0/4b350c0a83d7753fea34dcac6cd797d1dc9603291565de009baa4aa91c0447eab0d3815a05c8ec9ac04fdfffb43c82adcdb03ec1fceafd8518e1a8c1cff4ff89
+ languageName: node
+ linkType: hard
+
"lru-cache@npm:^10.0.1, lru-cache@npm:^10.2.0":
version: 10.4.3
resolution: "lru-cache@npm:10.4.3"
@@ -2845,6 +3611,20 @@ __metadata:
languageName: node
linkType: hard
+"meow@npm:^12.0.1":
+ version: 12.1.1
+ resolution: "meow@npm:12.1.1"
+ checksum: 10c0/a125ca99a32e2306e2f4cbe651a0d27f6eb67918d43a075f6e80b35e9bf372ebf0fc3a9fbc201cbbc9516444b6265fb3c9f80c5b7ebd32f548aa93eb7c28e088
+ languageName: node
+ linkType: hard
+
+"merge-stream@npm:^2.0.0":
+ version: 2.0.0
+ resolution: "merge-stream@npm:2.0.0"
+ checksum: 10c0/867fdbb30a6d58b011449b8885601ec1690c3e41c759ecd5a9d609094f7aed0096c37823ff4a7190ef0b8f22cc86beb7049196ff68c016e3b3c671d0dac91ce5
+ languageName: node
+ linkType: hard
+
"merge2@npm:^1.3.0":
version: 1.4.1
resolution: "merge2@npm:1.4.1"
@@ -2852,7 +3632,7 @@ __metadata:
languageName: node
linkType: hard
-"micromatch@npm:^4.0.4":
+"micromatch@npm:^4.0.4, micromatch@npm:^4.0.8":
version: 4.0.8
resolution: "micromatch@npm:4.0.8"
dependencies:
@@ -2862,6 +3642,20 @@ __metadata:
languageName: node
linkType: hard
+"mimic-fn@npm:^4.0.0":
+ version: 4.0.0
+ resolution: "mimic-fn@npm:4.0.0"
+ checksum: 10c0/de9cc32be9996fd941e512248338e43407f63f6d497abe8441fa33447d922e927de54d4cc3c1a3c6d652857acd770389d5a3823f311a744132760ce2be15ccbf
+ languageName: node
+ linkType: hard
+
+"mimic-function@npm:^5.0.0":
+ version: 5.0.1
+ resolution: "mimic-function@npm:5.0.1"
+ checksum: 10c0/f3d9464dd1816ecf6bdf2aec6ba32c0728022039d992f178237d8e289b48764fee4131319e72eedd4f7f094e22ded0af836c3187a7edc4595d28dd74368fd81d
+ languageName: node
+ linkType: hard
+
"minimatch@npm:^3.0.5, minimatch@npm:^3.1.1, minimatch@npm:^3.1.2":
version: 3.1.2
resolution: "minimatch@npm:3.1.2"
@@ -2880,6 +3674,13 @@ __metadata:
languageName: node
linkType: hard
+"minimist@npm:^1.2.8":
+ version: 1.2.8
+ resolution: "minimist@npm:1.2.8"
+ checksum: 10c0/19d3fcdca050087b84c2029841a093691a91259a47def2f18222f41e7645a0b7c44ef4b40e88a1e58a40c84d2ef0ee6047c55594d298146d0eb3f6b737c20ce6
+ languageName: node
+ linkType: hard
+
"minipass-collect@npm:^2.0.1":
version: 2.0.1
resolution: "minipass-collect@npm:2.0.1"
@@ -3032,6 +3833,15 @@ __metadata:
languageName: node
linkType: hard
+"npm-run-path@npm:^5.1.0":
+ version: 5.3.0
+ resolution: "npm-run-path@npm:5.3.0"
+ dependencies:
+ path-key: "npm:^4.0.0"
+ checksum: 10c0/124df74820c40c2eb9a8612a254ea1d557ddfab1581c3e751f825e3e366d9f00b0d76a3c94ecd8398e7f3eee193018622677e95816e8491f0797b21e30b2deba
+ languageName: node
+ linkType: hard
+
"obuf@npm:~1.1.2":
version: 1.1.2
resolution: "obuf@npm:1.1.2"
@@ -3048,6 +3858,24 @@ __metadata:
languageName: node
linkType: hard
+"onetime@npm:^6.0.0":
+ version: 6.0.0
+ resolution: "onetime@npm:6.0.0"
+ dependencies:
+ mimic-fn: "npm:^4.0.0"
+ checksum: 10c0/4eef7c6abfef697dd4479345a4100c382d73c149d2d56170a54a07418c50816937ad09500e1ed1e79d235989d073a9bade8557122aee24f0576ecde0f392bb6c
+ languageName: node
+ linkType: hard
+
+"onetime@npm:^7.0.0":
+ version: 7.0.0
+ resolution: "onetime@npm:7.0.0"
+ dependencies:
+ mimic-function: "npm:^5.0.0"
+ checksum: 10c0/5cb9179d74b63f52a196a2e7037ba2b9a893245a5532d3f44360012005c9cadb60851d56716ebff18a6f47129dab7168022445df47c2aff3b276d92585ed1221
+ languageName: node
+ linkType: hard
+
"optionator@npm:^0.9.3":
version: 0.9.4
resolution: "optionator@npm:0.9.4"
@@ -3071,6 +3899,15 @@ __metadata:
languageName: node
linkType: hard
+"p-limit@npm:^4.0.0":
+ version: 4.0.0
+ resolution: "p-limit@npm:4.0.0"
+ dependencies:
+ yocto-queue: "npm:^1.0.0"
+ checksum: 10c0/a56af34a77f8df2ff61ddfb29431044557fcbcb7642d5a3233143ebba805fc7306ac1d448de724352861cb99de934bc9ab74f0d16fe6a5460bdbdf938de875ad
+ languageName: node
+ linkType: hard
+
"p-locate@npm:^5.0.0":
version: 5.0.0
resolution: "p-locate@npm:5.0.0"
@@ -3080,6 +3917,15 @@ __metadata:
languageName: node
linkType: hard
+"p-locate@npm:^6.0.0":
+ version: 6.0.0
+ resolution: "p-locate@npm:6.0.0"
+ dependencies:
+ p-limit: "npm:^4.0.0"
+ checksum: 10c0/d72fa2f41adce59c198270aa4d3c832536c87a1806e0f69dffb7c1a7ca998fb053915ca833d90f166a8c082d3859eabfed95f01698a3214c20df6bb8de046312
+ languageName: node
+ linkType: hard
+
"p-map@npm:^4.0.0":
version: 4.0.0
resolution: "p-map@npm:4.0.0"
@@ -3105,6 +3951,18 @@ __metadata:
languageName: node
linkType: hard
+"parse-json@npm:^5.2.0":
+ version: 5.2.0
+ resolution: "parse-json@npm:5.2.0"
+ dependencies:
+ "@babel/code-frame": "npm:^7.0.0"
+ error-ex: "npm:^1.3.1"
+ json-parse-even-better-errors: "npm:^2.3.0"
+ lines-and-columns: "npm:^1.1.6"
+ checksum: 10c0/77947f2253005be7a12d858aedbafa09c9ae39eb4863adf330f7b416ca4f4a08132e453e08de2db46459256fb66afaac5ee758b44fe6541b7cdaf9d252e59585
+ languageName: node
+ linkType: hard
+
"path-exists@npm:^4.0.0":
version: 4.0.0
resolution: "path-exists@npm:4.0.0"
@@ -3112,6 +3970,13 @@ __metadata:
languageName: node
linkType: hard
+"path-exists@npm:^5.0.0":
+ version: 5.0.0
+ resolution: "path-exists@npm:5.0.0"
+ checksum: 10c0/b170f3060b31604cde93eefdb7392b89d832dfbc1bed717c9718cbe0f230c1669b7e75f87e19901da2250b84d092989a0f9e44d2ef41deb09aa3ad28e691a40a
+ languageName: node
+ linkType: hard
+
"path-is-absolute@npm:^1.0.0":
version: 1.0.1
resolution: "path-is-absolute@npm:1.0.1"
@@ -3126,6 +3991,13 @@ __metadata:
languageName: node
linkType: hard
+"path-key@npm:^4.0.0":
+ version: 4.0.0
+ resolution: "path-key@npm:4.0.0"
+ checksum: 10c0/794efeef32863a65ac312f3c0b0a99f921f3e827ff63afa5cb09a377e202c262b671f7b3832a4e64731003fa94af0263713962d317b9887bd1e0c48a342efba3
+ languageName: node
+ linkType: hard
+
"path-scurry@npm:^1.11.1":
version: 1.11.1
resolution: "path-scurry@npm:1.11.1"
@@ -3246,6 +4118,13 @@ __metadata:
languageName: node
linkType: hard
+"picocolors@npm:^1.0.0":
+ version: 1.1.1
+ resolution: "picocolors@npm:1.1.1"
+ checksum: 10c0/e2e3e8170ab9d7c7421969adaa7e1b31434f789afb9b3f115f6b96d91945041ac3ceb02e9ec6fe6510ff036bcc0bf91e69a1772edc0b707e12b19c0f2d6bcf58
+ languageName: node
+ linkType: hard
+
"picomatch@npm:^2.3.1":
version: 2.3.1
resolution: "picomatch@npm:2.3.1"
@@ -3253,10 +4132,21 @@ __metadata:
languageName: node
linkType: hard
+"pidtree@npm:^0.6.0":
+ version: 0.6.0
+ resolution: "pidtree@npm:0.6.0"
+ bin:
+ pidtree: bin/pidtree.js
+ checksum: 10c0/0829ec4e9209e230f74ebf4265f5ccc9ebfb488334b525cb13f86ff801dca44b362c41252cd43ae4d7653a10a5c6ab3be39d2c79064d6895e0d78dc50a5ed6e9
+ languageName: node
+ linkType: hard
+
"poixpixel-discord-bot@workspace:.":
version: 0.0.0-use.local
resolution: "poixpixel-discord-bot@workspace:."
dependencies:
+ "@commitlint/cli": "npm:^19.8.0"
+ "@commitlint/config-conventional": "npm:^19.8.0"
"@eslint/eslintrc": "npm:^3.3.1"
"@eslint/js": "npm:^9.23.0"
"@microsoft/eslint-formatter-sarif": "npm:^3.1.0"
@@ -3271,7 +4161,9 @@ __metadata:
eslint: "npm:^9.23.0"
eslint-config-prettier: "npm:^10.1.1"
globals: "npm:^16.0.0"
+ husky: "npm:^9.1.7"
ioredis: "npm:^5.6.0"
+ lint-staged: "npm:^15.5.0"
pg: "npm:^8.14.1"
prettier: "npm:3.5.3"
ts-node: "npm:^10.9.2"
@@ -3410,6 +4302,20 @@ __metadata:
languageName: node
linkType: hard
+"require-directory@npm:^2.1.1":
+ version: 2.1.1
+ resolution: "require-directory@npm:2.1.1"
+ checksum: 10c0/83aa76a7bc1531f68d92c75a2ca2f54f1b01463cb566cf3fbc787d0de8be30c9dbc211d1d46be3497dac5785fe296f2dd11d531945ac29730643357978966e99
+ languageName: node
+ linkType: hard
+
+"require-from-string@npm:^2.0.2":
+ version: 2.0.2
+ resolution: "require-from-string@npm:2.0.2"
+ checksum: 10c0/aaa267e0c5b022fc5fd4eef49d8285086b15f2a1c54b28240fdf03599cbd9c26049fee3eab894f2e1f6ca65e513b030a7c264201e3f005601e80c49fb2937ce2
+ languageName: node
+ linkType: hard
+
"resolve-from@npm:^4.0.0":
version: 4.0.0
resolution: "resolve-from@npm:4.0.0"
@@ -3417,6 +4323,13 @@ __metadata:
languageName: node
linkType: hard
+"resolve-from@npm:^5.0.0":
+ version: 5.0.0
+ resolution: "resolve-from@npm:5.0.0"
+ checksum: 10c0/b21cb7f1fb746de8107b9febab60095187781137fd803e6a59a76d421444b1531b641bba5857f5dc011974d8a5c635d61cec49e6bd3b7fc20e01f0fafc4efbf2
+ languageName: node
+ linkType: hard
+
"resolve-pkg-maps@npm:^1.0.0":
version: 1.0.0
resolution: "resolve-pkg-maps@npm:1.0.0"
@@ -3424,6 +4337,16 @@ __metadata:
languageName: node
linkType: hard
+"restore-cursor@npm:^5.0.0":
+ version: 5.1.0
+ resolution: "restore-cursor@npm:5.1.0"
+ dependencies:
+ onetime: "npm:^7.0.0"
+ signal-exit: "npm:^4.1.0"
+ checksum: 10c0/c2ba89131eea791d1b25205bdfdc86699767e2b88dee2a590b1a6caa51737deac8bad0260a5ded2f7c074b7db2f3a626bcf1fcf3cdf35974cbeea5e2e6764f60
+ languageName: node
+ linkType: hard
+
"retry@npm:^0.12.0":
version: 0.12.0
resolution: "retry@npm:0.12.0"
@@ -3438,6 +4361,13 @@ __metadata:
languageName: node
linkType: hard
+"rfdc@npm:^1.4.1":
+ version: 1.4.1
+ resolution: "rfdc@npm:1.4.1"
+ checksum: 10c0/4614e4292356cafade0b6031527eea9bc90f2372a22c012313be1dcc69a3b90c7338158b414539be863fa95bfcb2ddcd0587be696841af4e6679d85e62c060c7
+ languageName: node
+ linkType: hard
+
"rimraf@npm:^3.0.2":
version: 3.0.2
resolution: "rimraf@npm:3.0.2"
@@ -3506,13 +4436,33 @@ __metadata:
languageName: node
linkType: hard
-"signal-exit@npm:^4.0.1":
+"signal-exit@npm:^4.0.1, signal-exit@npm:^4.1.0":
version: 4.1.0
resolution: "signal-exit@npm:4.1.0"
checksum: 10c0/41602dce540e46d599edba9d9860193398d135f7ff72cab629db5171516cfae628d21e7bfccde1bbfdf11c48726bc2a6d1a8fb8701125852fbfda7cf19c6aa83
languageName: node
linkType: hard
+"slice-ansi@npm:^5.0.0":
+ version: 5.0.0
+ resolution: "slice-ansi@npm:5.0.0"
+ dependencies:
+ ansi-styles: "npm:^6.0.0"
+ is-fullwidth-code-point: "npm:^4.0.0"
+ checksum: 10c0/2d4d40b2a9d5cf4e8caae3f698fe24ae31a4d778701724f578e984dcb485ec8c49f0c04dab59c401821e80fcdfe89cace9c66693b0244e40ec485d72e543914f
+ languageName: node
+ linkType: hard
+
+"slice-ansi@npm:^7.1.0":
+ version: 7.1.0
+ resolution: "slice-ansi@npm:7.1.0"
+ dependencies:
+ ansi-styles: "npm:^6.2.1"
+ is-fullwidth-code-point: "npm:^5.0.0"
+ checksum: 10c0/631c971d4abf56cf880f034d43fcc44ff883624867bf11ecbd538c47343911d734a4656d7bc02362b40b89d765652a7f935595441e519b59e2ad3f4d5d6fe7ca
+ languageName: node
+ linkType: hard
+
"smart-buffer@npm:^4.2.0":
version: 4.2.0
resolution: "smart-buffer@npm:4.2.0"
@@ -3558,7 +4508,7 @@ __metadata:
languageName: node
linkType: hard
-"split2@npm:^4.1.0":
+"split2@npm:^4.0.0, split2@npm:^4.1.0":
version: 4.2.0
resolution: "split2@npm:4.2.0"
checksum: 10c0/b292beb8ce9215f8c642bb68be6249c5a4c7f332fc8ecadae7be5cbdf1ea95addc95f0459ef2e7ad9d45fd1064698a097e4eb211c83e772b49bc0ee423e91534
@@ -3588,7 +4538,14 @@ __metadata:
languageName: node
linkType: hard
-"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.1.0":
+"string-argv@npm:^0.3.2":
+ version: 0.3.2
+ resolution: "string-argv@npm:0.3.2"
+ checksum: 10c0/75c02a83759ad1722e040b86823909d9a2fc75d15dd71ec4b537c3560746e33b5f5a07f7332d1e3f88319909f82190843aa2f0a0d8c8d591ec08e93d5b8dec82
+ languageName: node
+ linkType: hard
+
+"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.1.0, string-width@npm:^4.2.0, string-width@npm:^4.2.3":
version: 4.2.3
resolution: "string-width@npm:4.2.3"
dependencies:
@@ -3610,6 +4567,17 @@ __metadata:
languageName: node
linkType: hard
+"string-width@npm:^7.0.0":
+ version: 7.2.0
+ resolution: "string-width@npm:7.2.0"
+ dependencies:
+ emoji-regex: "npm:^10.3.0"
+ get-east-asian-width: "npm:^1.0.0"
+ strip-ansi: "npm:^7.1.0"
+ checksum: 10c0/eb0430dd43f3199c7a46dcbf7a0b34539c76fe3aa62763d0b0655acdcbdf360b3f66f3d58ca25ba0205f42ea3491fa00f09426d3b7d3040e506878fc7664c9b9
+ languageName: node
+ linkType: hard
+
"strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1":
version: 6.0.1
resolution: "strip-ansi@npm:6.0.1"
@@ -3619,7 +4587,7 @@ __metadata:
languageName: node
linkType: hard
-"strip-ansi@npm:^7.0.1":
+"strip-ansi@npm:^7.0.1, strip-ansi@npm:^7.1.0":
version: 7.1.0
resolution: "strip-ansi@npm:7.1.0"
dependencies:
@@ -3628,6 +4596,13 @@ __metadata:
languageName: node
linkType: hard
+"strip-final-newline@npm:^3.0.0":
+ version: 3.0.0
+ resolution: "strip-final-newline@npm:3.0.0"
+ checksum: 10c0/a771a17901427bac6293fd416db7577e2bc1c34a19d38351e9d5478c3c415f523f391003b42ed475f27e33a78233035df183525395f731d3bfb8cdcbd4da08ce
+ languageName: node
+ linkType: hard
+
"strip-json-comments@npm:^3.1.1":
version: 3.1.1
resolution: "strip-json-comments@npm:3.1.1"
@@ -3658,6 +4633,13 @@ __metadata:
languageName: node
linkType: hard
+"text-extensions@npm:^2.0.0":
+ version: 2.4.0
+ resolution: "text-extensions@npm:2.4.0"
+ checksum: 10c0/6790e7ee72ad4d54f2e96c50a13e158bb57ce840dddc770e80960ed1550115c57bdc2cee45d5354d7b4f269636f5ca06aab4d6e0281556c841389aa837b23fcb
+ languageName: node
+ linkType: hard
+
"text-table@npm:^0.2.0":
version: 0.2.0
resolution: "text-table@npm:0.2.0"
@@ -3665,6 +4647,20 @@ __metadata:
languageName: node
linkType: hard
+"through@npm:>=2.2.7 <3":
+ version: 2.3.8
+ resolution: "through@npm:2.3.8"
+ checksum: 10c0/4b09f3774099de0d4df26d95c5821a62faee32c7e96fb1f4ebd54a2d7c11c57fe88b0a0d49cf375de5fee5ae6bf4eb56dbbf29d07366864e2ee805349970d3cc
+ languageName: node
+ linkType: hard
+
+"tinyexec@npm:^0.3.0":
+ version: 0.3.2
+ resolution: "tinyexec@npm:0.3.2"
+ checksum: 10c0/3efbf791a911be0bf0821eab37a3445c2ba07acc1522b1fa84ae1e55f10425076f1290f680286345ed919549ad67527d07281f1c19d584df3b74326909eb1f90
+ languageName: node
+ linkType: hard
+
"to-regex-range@npm:^5.0.1":
version: 5.0.1
resolution: "to-regex-range@npm:5.0.1"
@@ -3808,6 +4804,13 @@ __metadata:
languageName: node
linkType: hard
+"unicorn-magic@npm:^0.1.0":
+ version: 0.1.0
+ resolution: "unicorn-magic@npm:0.1.0"
+ checksum: 10c0/e4ed0de05b0a05e735c7d8a2930881e5efcfc3ec897204d5d33e7e6247f4c31eac92e383a15d9a6bccb7319b4271ee4bea946e211bf14951fec6ff2cbbb66a92
+ languageName: node
+ linkType: hard
+
"unique-filename@npm:^3.0.0":
version: 3.0.0
resolution: "unique-filename@npm:3.0.0"
@@ -3878,7 +4881,7 @@ __metadata:
languageName: node
linkType: hard
-"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0":
+"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0, wrap-ansi@npm:^7.0.0":
version: 7.0.0
resolution: "wrap-ansi@npm:7.0.0"
dependencies:
@@ -3900,6 +4903,17 @@ __metadata:
languageName: node
linkType: hard
+"wrap-ansi@npm:^9.0.0":
+ version: 9.0.0
+ resolution: "wrap-ansi@npm:9.0.0"
+ dependencies:
+ ansi-styles: "npm:^6.2.1"
+ string-width: "npm:^7.0.0"
+ strip-ansi: "npm:^7.1.0"
+ checksum: 10c0/a139b818da9573677548dd463bd626a5a5286271211eb6e4e82f34a4f643191d74e6d4a9bb0a3c26ec90e6f904f679e0569674ac099ea12378a8b98e20706066
+ languageName: node
+ linkType: hard
+
"wrappy@npm:1":
version: 1.0.2
resolution: "wrappy@npm:1.0.2"
@@ -3929,6 +4943,13 @@ __metadata:
languageName: node
linkType: hard
+"y18n@npm:^5.0.5":
+ version: 5.0.8
+ resolution: "y18n@npm:5.0.8"
+ checksum: 10c0/4df2842c36e468590c3691c894bc9cdbac41f520566e76e24f59401ba7d8b4811eb1e34524d57e54bc6d864bcb66baab7ffd9ca42bf1eda596618f9162b91249
+ languageName: node
+ linkType: hard
+
"yallist@npm:^4.0.0":
version: 4.0.0
resolution: "yallist@npm:4.0.0"
@@ -3936,6 +4957,37 @@ __metadata:
languageName: node
linkType: hard
+"yaml@npm:^2.7.0":
+ version: 2.7.0
+ resolution: "yaml@npm:2.7.0"
+ bin:
+ yaml: bin.mjs
+ checksum: 10c0/886a7d2abbd70704b79f1d2d05fe9fb0aa63aefb86e1cb9991837dced65193d300f5554747a872b4b10ae9a12bc5d5327e4d04205f70336e863e35e89d8f4ea9
+ languageName: node
+ linkType: hard
+
+"yargs-parser@npm:^21.1.1":
+ version: 21.1.1
+ resolution: "yargs-parser@npm:21.1.1"
+ checksum: 10c0/f84b5e48169479d2f402239c59f084cfd1c3acc197a05c59b98bab067452e6b3ea46d4dd8ba2985ba7b3d32a343d77df0debd6b343e5dae3da2aab2cdf5886b2
+ languageName: node
+ linkType: hard
+
+"yargs@npm:^17.0.0":
+ version: 17.7.2
+ resolution: "yargs@npm:17.7.2"
+ dependencies:
+ cliui: "npm:^8.0.1"
+ escalade: "npm:^3.1.1"
+ get-caller-file: "npm:^2.0.5"
+ require-directory: "npm:^2.1.1"
+ string-width: "npm:^4.2.3"
+ y18n: "npm:^5.0.5"
+ yargs-parser: "npm:^21.1.1"
+ checksum: 10c0/ccd7e723e61ad5965fffbb791366db689572b80cca80e0f96aad968dfff4156cd7cd1ad18607afe1046d8241e6fb2d6c08bf7fa7bfb5eaec818735d8feac8f05
+ languageName: node
+ linkType: hard
+
"yn@npm:3.1.1":
version: 3.1.1
resolution: "yn@npm:3.1.1"
@@ -3949,3 +5001,10 @@ __metadata:
checksum: 10c0/dceb44c28578b31641e13695d200d34ec4ab3966a5729814d5445b194933c096b7ced71494ce53a0e8820685d1d010df8b2422e5bf2cdea7e469d97ffbea306f
languageName: node
linkType: hard
+
+"yocto-queue@npm:^1.0.0":
+ version: 1.2.0
+ resolution: "yocto-queue@npm:1.2.0"
+ checksum: 10c0/9fb3adeba76b69cc7c916831c092bb69ac1aa685c692ae6eb819a9599cbe0c4ecfd5269c145691a15b86d0a25b27d854d6116bbc0851a3373c0a86edb96f1602
+ languageName: node
+ linkType: hard