Home<\/a> <\/p>\n <\/div>\n \n
0-minute read<\/p>\n
Read full article<\/a> · Push to Kindle<\/a> · txtify.it<\/a><\/p>\n <\/div>\n`,
+ pageWithoutSummaryContentUrl: 'https//this-is-a-fake-url.com',
+ pageSummary: {
+ title: 'You Might Not Need an Effect β React',
+ keyFeatures: [
+ 'Effects in React are used to synchronize components with external systems, but they are not always necessary.',
+ 'Effects should not be used to transform data for rendering or handle user events.',
+ 'Unnecessary Effects can be removed to make the code simpler, faster, and less error-prone.',
+ 'In cases where Effects are needed, it is important to handle race conditions and clean up after the Effect.',
+ ],
+ readingTime: '26-minute read',
+ },
+ pageSummaryDiscordView: `**You Might Not Need an Effect β React** \n- Effects in React are used to synchronize components with external systems, but they are not always necessary.\n- Effects should not be used to transform data for rendering or handle user events.\n- Unnecessary Effects can be removed to make the code simpler, faster, and less error-prone.\n- In cases where Effects are needed, it is important to handle race conditions and clean up after the Effect.\nβ 26-minute read`,
+ };
+};
+type SummarizeCoolPagesFixture = ReturnType;
+describe('Feature: summarize cool pages', () => {
+ let fixture: SummarizeCoolPagesFixture;
+ beforeEach(() => {
+ // config is mocked to avoid to call the third party API and to avoid to handle env-var
+ vi.mock('../config', async () => ({
+ config: (await import('./mocks/config.mock')).default,
+ }));
+ // useless atm but will be useful when we will have to reset the fixture
+ fixture = createSummarizeCoolPagesFixture();
+ });
+ afterEach(() => {
+ vi.resetAllMocks();
+ });
+ describe('Rule: parseHtmlSummarized() should parse an html content', () => {
+ it('parseHtmlSummarized() should return a PageSummary with an html with a summary content', async () => {
+ const html = fixture.htmlWithSummaryContent;
+ const result = await parseHtmlSummarized({
+ html,
+ url: fixture.pageWithSummaryContentUrl,
+ });
+ expect(result).toEqual(fixture.pageSummary);
+ });
+ it('parseHtmlSummarized() should throw a NoContentFoundSummaryError when the html content is not found', async () => {
+ const html = fixture.htmlContentNotFound;
+ try {
+ await parseHtmlSummarized({
+ html,
+ url: fixture.pageWithoutSummaryContentUrl,
+ });
+ } catch (error) {
+ expect(error).toBeInstanceOf(NoContentFoundSummaryError);
+ if (error instanceof NoContentFoundSummaryError) {
+ expect(error.message).toEqual(
+ `Content Not Found for ${fixture.pageWithoutSummaryContentUrl}`,
+ );
+ }
+ }
+ });
+ });
+ it('getPageSummaryDiscordView() should return a string with the page summary', () => {
+ expect(getPageSummaryDiscordView(fixture.pageSummary)).toEqual(fixture.pageSummaryDiscordView);
+ });
+
+ describe('Rule: isPageSummarizeSuccessData() should check if the data is a PageSummarizerDataSuccess', () => {
+ it('isPageSummarizeSuccessData() should return true when the data is a PageSummarizerDataSuccess', () => {
+ // I'm using as because eslint can't autofix and sort the import itself
+ const data = {
+ success: true,
+ html: fixture.htmlWithSummaryContent,
+ } as {
+ success: true;
+ html: string;
+ };
+ const result = isPageSummarizeSuccessData(data);
+ expect(result).toBe(true);
+ });
+ it('isPageSummarizeSuccessData() should return false when the data is not a PageSummarizerDataSuccess', () => {
+ const data = {
+ success: false,
+ html: undefined,
+ } as {
+ success: false;
+ html: undefined;
+ };
+ const result = isPageSummarizeSuccessData(data);
+ expect(result).toBe(false);
+ });
+ });
+});
diff --git a/src/__tests__/works.spec.ts b/src/__tests__/works.spec.ts
new file mode 100644
index 0000000..19af9a4
--- /dev/null
+++ b/src/__tests__/works.spec.ts
@@ -0,0 +1,7 @@
+import { describe, expect, it } from 'vitest';
+
+describe('setup vitest', () => {
+ it('works', () => {
+ expect(true).toBe(true);
+ });
+});
diff --git a/src/config.ts b/src/config.ts
new file mode 100644
index 0000000..69ef576
--- /dev/null
+++ b/src/config.ts
@@ -0,0 +1,14 @@
+import env from 'env-var';
+
+export const config = {
+ discord: {
+ token: env.get('DISCORD_TOKEN').required().asString(),
+ coolLinksChannelId: env.get('COOL_LINKS_CHANNEL_ID').required().asString(),
+ },
+ redis: {
+ url: env.get('REDIS_URL').required().asString(),
+ },
+ thirdParties: {
+ pageSummarizerBaseUrl: env.get('PAGE_SUMMARIZER_BASE_URL').required().asString(),
+ },
+};
diff --git a/src/core/cache.ts b/src/core/cache.ts
new file mode 100644
index 0000000..37915a8
--- /dev/null
+++ b/src/core/cache.ts
@@ -0,0 +1,67 @@
+import '@keyv/redis';
+
+import Keyv from 'keyv';
+
+import { config } from '../config';
+import type { Frequency } from '../modules/recurringMessage/recurringMessage.helpers';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+interface CacheGet> {
+ (key: Key): Promise;
+ (key: Key, defaultValue: Entries[Key]): Promise;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+interface Cache> {
+ get: CacheGet;
+ set: (key: Key, value: Entries[Key]) => Promise;
+ delete: (key: Key) => Promise;
+ has: (key: Key) => Promise;
+ clear: () => Promise;
+}
+
+interface CacheEntries {
+ lobbyIds: string[];
+ onDemandChannels: string[];
+ quoiFeurChannels: string[];
+ recurringMessages: { id: string; channelId: string; frequency: Frequency; message: string }[];
+}
+
+class CacheImpl implements Cache {
+ private readonly backend = new Keyv(config.redis.url);
+
+ public get(key: Key): Promise;
+ public get(
+ key: Key,
+ defaultValue: CacheEntries[Key],
+ ): Promise;
+ public async get(
+ key: Key,
+ defaultValue?: CacheEntries[Key],
+ ): Promise {
+ const value = (await this.backend.get(key)) as CacheEntries[Key] | undefined;
+
+ return value === undefined ? defaultValue : value;
+ }
+
+ public async set(
+ key: Key,
+ value: CacheEntries[Key],
+ ): Promise {
+ await this.backend.set(key, value);
+ }
+
+ public async delete(key: Key): Promise {
+ await this.backend.delete(key);
+ }
+
+ public async has(key: Key): Promise {
+ return this.backend.has(key);
+ }
+
+ public async clear(): Promise {
+ await this.backend.clear();
+ }
+}
+
+export const cache = new CacheImpl();
diff --git a/src/core/checkUniqueSlashCommandNames.ts b/src/core/checkUniqueSlashCommandNames.ts
new file mode 100644
index 0000000..776927c
--- /dev/null
+++ b/src/core/checkUniqueSlashCommandNames.ts
@@ -0,0 +1,9 @@
+import type { BotCommand } from '../types/bot';
+
+export const checkUniqueSlashCommandNames = (botCommands: BotCommand[]) => {
+ const slashCommandNames = botCommands.map((command) => command.schema.name);
+ const uniqueSlashCommandNames = new Set(slashCommandNames);
+ if (uniqueSlashCommandNames.size !== slashCommandNames.length) {
+ throw new Error('Found duplicate slash command names');
+ }
+};
diff --git a/src/core/deleteExistingCommands.ts b/src/core/deleteExistingCommands.ts
new file mode 100644
index 0000000..b9d955e
--- /dev/null
+++ b/src/core/deleteExistingCommands.ts
@@ -0,0 +1,17 @@
+import { REST, Routes } from 'discord.js';
+
+export const deleteExistingCommands = async (
+ rest: REST,
+ clientId: string,
+ guildId: string,
+): Promise => {
+ const guildCommands = (await rest.get(Routes.applicationGuildCommands(clientId, guildId))) as {
+ id: string;
+ }[];
+
+ await guildCommands.reduce>(async (promise, guildCommand) => {
+ await promise;
+
+ await rest.delete(Routes.applicationGuildCommand(clientId, guildId, guildCommand.id));
+ }, Promise.resolve());
+};
diff --git a/src/core/getIntentsFromModules.ts b/src/core/getIntentsFromModules.ts
new file mode 100644
index 0000000..1499726
--- /dev/null
+++ b/src/core/getIntentsFromModules.ts
@@ -0,0 +1,6 @@
+import type { BotModule } from '../types/bot';
+
+export const getIntentsFromModules = (modules: Record) => {
+ const intents = Object.values(modules).flatMap((module) => module.intents ?? []);
+ return [...new Set(intents)] as const;
+};
diff --git a/src/core/loadModules.ts b/src/core/loadModules.ts
new file mode 100644
index 0000000..233f41c
--- /dev/null
+++ b/src/core/loadModules.ts
@@ -0,0 +1,29 @@
+import { type Client } from 'discord.js';
+
+import type { BotModule } from '../types/bot';
+import { checkUniqueSlashCommandNames } from './checkUniqueSlashCommandNames';
+import { pushCommands, routeCommands } from './loaderCommands';
+import { routeHandlers } from './routeHandlers';
+
+export const loadModules = async (
+ client: Client,
+ modulesToLoad: Record,
+): Promise => {
+ const botCommands = Object.values(modulesToLoad).flatMap((module) => module.slashCommands ?? []);
+ checkUniqueSlashCommandNames(botCommands);
+ routeCommands(client, botCommands);
+
+ const clientId = client.application?.id;
+ if (!clientId) throw new Error('Client id is not defined');
+
+ const { guilds } = client;
+
+ for (const guild of guilds.cache.values()) {
+ await pushCommands(
+ botCommands.map((command) => command.schema),
+ clientId,
+ guild.id,
+ );
+ }
+ routeHandlers(client, modulesToLoad);
+};
diff --git a/src/core/loaderCommands.ts b/src/core/loaderCommands.ts
new file mode 100644
index 0000000..3cbb7d7
--- /dev/null
+++ b/src/core/loaderCommands.ts
@@ -0,0 +1,60 @@
+import {
+ Client,
+ REST,
+ type RESTPostAPIChatInputApplicationCommandsJSONBody,
+ Routes,
+} from 'discord.js';
+
+import { config } from '../config';
+import type { BotCommand } from '../types/bot';
+import { deleteExistingCommands } from './deleteExistingCommands';
+
+const { discord } = config;
+
+export const pushCommands = async (
+ commands: RESTPostAPIChatInputApplicationCommandsJSONBody[],
+ clientId: string,
+ guildId: string,
+) => {
+ const rest = new REST({ version: '10' }).setToken(discord.token);
+ await deleteExistingCommands(rest, clientId, guildId);
+ await rest.put(Routes.applicationGuildCommands(clientId, guildId), {
+ body: commands,
+ });
+};
+
+export const routeCommands = (client: Client, botCommands: BotCommand[]) =>
+ client.on('interactionCreate', async (interaction) => {
+ if (!interaction.inGuild() || !interaction.isChatInputCommand()) {
+ return;
+ }
+
+ const command = botCommands.find((command) => command.schema.name === interaction.commandName);
+
+ if (!command) {
+ await interaction.reply({
+ content: `Command not found ${interaction.commandName}`,
+ ephemeral: true,
+ });
+ return;
+ }
+
+ if (typeof command.handler === 'function') {
+ await command.handler(interaction);
+ return;
+ }
+
+ const subCommand = command.handler[interaction.options.getSubcommand()];
+
+ if (!subCommand) {
+ await interaction.reply({
+ content: `Subcommand not found ${
+ interaction.commandName
+ } ${interaction.options.getSubcommand()}`,
+ ephemeral: true,
+ });
+ return;
+ }
+
+ await subCommand(interaction);
+ });
diff --git a/src/core/routeHandlers.ts b/src/core/routeHandlers.ts
new file mode 100644
index 0000000..dc762b3
--- /dev/null
+++ b/src/core/routeHandlers.ts
@@ -0,0 +1,21 @@
+import type { Client, ClientEvents } from 'discord.js';
+
+import type { BotModule, EventHandler } from '../types/bot';
+
+export const routeHandlers = (client: Client, modulesToLoad: Record) => {
+ const eventNames = Object.values(modulesToLoad).flatMap(
+ (module) => Object.keys(module.eventHandlers ?? {}) as (keyof ClientEvents)[],
+ );
+ const uniqueEventNames = [...new Set(eventNames)];
+
+ uniqueEventNames.forEach((eventName) => {
+ const eventHandlersToCall = Object.values(modulesToLoad)
+ .map((module) => module.eventHandlers?.[eventName])
+ .filter((e): e is EventHandler => Boolean(e));
+
+ client.on(eventName, async (...args) => {
+ const handlersPromises = eventHandlersToCall.map(async (handler) => handler(...args));
+ await Promise.allSettled(handlersPromises);
+ });
+ });
+};
diff --git a/src/helpers/normalizeName.helper.ts b/src/helpers/normalizeName.helper.ts
new file mode 100644
index 0000000..bebd0d1
--- /dev/null
+++ b/src/helpers/normalizeName.helper.ts
@@ -0,0 +1,12 @@
+import { paramCase } from 'param-case';
+
+export const normalizeName = (name: string): string =>
+ paramCase(
+ name
+ // Normalize Unicode characters
+ .normalize('NFD')
+ // Remove diacritics
+ .replace(/[\u0300-\u036F]/g, '')
+ // Remove non-ASCII characters
+ .replace(/[^\u0000-\u007F]/g, ''),
+ );
diff --git a/src/helpers/regex.helper.ts b/src/helpers/regex.helper.ts
new file mode 100644
index 0000000..2044aa0
--- /dev/null
+++ b/src/helpers/regex.helper.ts
@@ -0,0 +1,14 @@
+const socialNetworksUrlRegex = new RegExp(
+ '^(https?://)?(www.)?(facebook.com|fb.me|twitter.com|vxtwitter.com|instagram.com|linkedin.com|youtube.com|youtu.be|pinterest.com|snapchat.com|tiktok.com)/[a-zA-Z0-9.-/?=&#_]+$',
+);
+const punctuationRegex = /[.,!?]/g;
+const markdownRegex = /(\*\*|__|\*|_|`|~)(.*?)\1/g;
+const emojiRegex = /|\p{Extended_Pictographic}/gu;
+
+export const isASocialNetworkUrl = (url: string): boolean => {
+ return socialNetworksUrlRegex.test(url);
+};
+
+export const removePunctuation = (text: string) => text.replaceAll(punctuationRegex, '');
+export const removeEmoji = (text: string) => text.replaceAll(emojiRegex, '');
+export const removeMarkdown = (text: string) => text.replaceAll(markdownRegex, '$2');
diff --git a/src/helpers/resolveCatch.helper.ts b/src/helpers/resolveCatch.helper.ts
new file mode 100644
index 0000000..c8e5b76
--- /dev/null
+++ b/src/helpers/resolveCatch.helper.ts
@@ -0,0 +1,19 @@
+/**
+ * @param { Promise } promise
+ * @param { Object= } errorExt - Additional Information you can pass to the err object
+ * @return { Promise }
+ */
+export const resolveCatch = (
+ promise: Promise,
+ errorExt?: object,
+): Promise<[U, undefined] | [null, T]> => {
+ return promise
+ .then<[null, T]>((data: T) => [null, data])
+ .catch<[U, undefined]>((err: U) => {
+ if (errorExt) {
+ const parsedError = Object.assign({}, err, errorExt);
+ return [parsedError, undefined];
+ }
+ return [err, undefined];
+ });
+};
diff --git a/src/helpers/roles.ts b/src/helpers/roles.ts
new file mode 100644
index 0000000..7002449
--- /dev/null
+++ b/src/helpers/roles.ts
@@ -0,0 +1,8 @@
+import { type APIInteractionGuildMember, GuildMember } from 'discord.js';
+
+export const isAdmin = (member: GuildMember | APIInteractionGuildMember | null): boolean =>
+ member instanceof GuildMember && member.roles.cache.some((role) => role.name === 'Admin');
+
+export const isModo = (member: GuildMember | APIInteractionGuildMember | null): boolean =>
+ member instanceof GuildMember &&
+ member.roles.cache.some((role) => role.name === 'Admin' || role.name === 'Modo');
diff --git a/src/main.ts b/src/main.ts
new file mode 100644
index 0000000..c86eafa
--- /dev/null
+++ b/src/main.ts
@@ -0,0 +1,28 @@
+import { Client } from 'discord.js';
+
+import { config } from './config';
+import { getIntentsFromModules } from './core/getIntentsFromModules';
+import { loadModules } from './core/loadModules';
+import { modules } from './modules/modules';
+
+const { discord } = config;
+
+const client = new Client({
+ intents: ['Guilds', ...getIntentsFromModules(modules)],
+});
+
+await client.login(discord.token);
+await new Promise((resolve) => {
+ client.on('ready', () => {
+ Object.values(modules).map((module) => module.eventHandlers?.ready?.(client));
+ resolve();
+ });
+});
+
+if (!client.isReady()) {
+ throw new Error('Client should be ready at this stage');
+}
+
+await loadModules(client, modules);
+
+console.log('Bot started.');
diff --git a/src/modules/coolLinksManagement/coolLinksManagement.module.ts b/src/modules/coolLinksManagement/coolLinksManagement.module.ts
new file mode 100644
index 0000000..e13f37f
--- /dev/null
+++ b/src/modules/coolLinksManagement/coolLinksManagement.module.ts
@@ -0,0 +1,81 @@
+import { MessageType, ThreadAutoArchiveDuration } from 'discord.js';
+import ogs from 'open-graph-scraper';
+
+import { config } from '../../config';
+import { isASocialNetworkUrl } from '../../helpers/regex.helper';
+import type { BotModule } from '../../types/bot';
+import { getPageSummary } from './summarizeCoolPages';
+import { getVideoSummary } from './summarizeCoolVideos';
+
+const getThreadNameFromOpenGraph = async (url: string): Promise => {
+ try {
+ const { result } = await ogs({ url });
+ if (!result.success) throw new Error('No OG data found');
+
+ const ogSiteName = result.ogSiteName;
+ const ogTitle = result.ogTitle;
+ if (ogSiteName && ogTitle) {
+ return `${ogSiteName} - ${ogTitle}`;
+ }
+ if (ogSiteName) {
+ return ogSiteName;
+ }
+ if (ogTitle) {
+ return ogTitle;
+ }
+ } catch (error) {
+ console.error(error);
+ }
+
+ return null;
+};
+
+const youtubeUrlRegex = new RegExp('^(https?)?(://)?(www.)?(m.)?((youtube.com)|(youtu.be))');
+
+export const coolLinksManagement: BotModule = {
+ eventHandlers: {
+ messageCreate: async (message) => {
+ if (
+ message.author.bot ||
+ message.type !== MessageType.Default ||
+ message.channelId !== config.discord.coolLinksChannelId
+ ) {
+ return;
+ }
+ const urlRegex = /(((https?:\/\/)|(www\.))[^\s]+)/g;
+ const detectedURLs = message.content.match(urlRegex);
+
+ if (detectedURLs === null) {
+ await message.delete();
+ return;
+ }
+
+ await message.react('β
');
+ await message.react('β');
+
+ const url = detectedURLs[0];
+ const threadName = await getThreadNameFromOpenGraph(url);
+ const thread = await message.startThread({
+ name: threadName ?? message.content,
+ autoArchiveDuration: ThreadAutoArchiveDuration.ThreeDays,
+ });
+ if (thread.joinable) await thread.join();
+
+ if (youtubeUrlRegex.test(url)) {
+ const summary = await getVideoSummary(url);
+ if (!summary) return;
+
+ await thread.send(summary);
+ }
+ if (!youtubeUrlRegex.test(url) && !isASocialNetworkUrl(url)) {
+ try {
+ const pageSummaryDiscordView = await getPageSummary(url);
+ await thread.send(pageSummaryDiscordView);
+ } catch (error) {
+ console.error(error);
+ }
+ }
+ },
+ },
+ intents: ['GuildMessages', 'MessageContent', 'GuildMessageReactions'],
+};
diff --git a/src/modules/coolLinksManagement/summarizeCoolPages.ts b/src/modules/coolLinksManagement/summarizeCoolPages.ts
new file mode 100644
index 0000000..f10399d
--- /dev/null
+++ b/src/modules/coolLinksManagement/summarizeCoolPages.ts
@@ -0,0 +1,109 @@
+import { load } from 'cheerio';
+
+import { config } from '../../config';
+import { resolveCatch } from '../../helpers/resolveCatch.helper';
+// langfrom can't be changed to another language, this result in a translation of the summary that throw an HTTP error because we are in "FREE PLAN"
+const parseBaseUrl = `${config.thirdParties.pageSummarizerBaseUrl}/convert.php?type=expand&lang=en&langfrom=user&url=`;
+
+type PageSummary = {
+ title: string;
+ keyFeatures: string[];
+ readingTime: string;
+};
+
+export type PageSummarizerDataSuccess = {
+ success: true;
+ html: string;
+};
+
+export type PageSummarizerDataFailure = {
+ success: false;
+ html?: undefined;
+};
+
+export type PageSummarizerData = PageSummarizerDataSuccess | PageSummarizerDataFailure;
+
+export const isPageSummarizeSuccessData = (
+ data: PageSummarizerData,
+): data is PageSummarizerDataSuccess => {
+ return data?.success && typeof data?.html === 'string';
+};
+
+export class NoContentFoundSummaryError extends Error {
+ constructor(readonly pageUrl: string) {
+ super();
+ this.message = `Content Not Found for ${pageUrl}`;
+ this.name = 'NotContentFoundError';
+ }
+}
+export class PageSummarizerInvalidDataError extends Error {
+ constructor(
+ readonly pageUrl: string,
+ readonly data?: PageSummarizerDataFailure,
+ ) {
+ super();
+ this.message = `Invalid data for ${pageUrl}, check the third party API, received: ${JSON.stringify(
+ data,
+ )}`;
+ this.name = 'PageSummarizerInvalidDataError';
+ }
+}
+export const parseHtmlSummarized = ({
+ html,
+ url,
+}: {
+ html: string;
+ url: string;
+}): Promise => {
+ const $ = load(html);
+
+ const title = $('.box.narrow h2').text();
+ if (title === 'No content found') {
+ throw new NoContentFoundSummaryError(url);
+ }
+ const keyFeatures = $('.box.narrow ul li')
+ .toArray()
+ .map((li) => $(li).text());
+ const readingTime = $('.time-to-read').text();
+ return Promise.resolve({
+ title,
+ keyFeatures,
+ readingTime,
+ });
+};
+
+export const getPageSummaryDiscordView = (pageSummary: PageSummary) => {
+ const { title, keyFeatures, readingTime } = pageSummary;
+ return `**${title}** \n${keyFeatures
+ .map((keyFeature) => `- ${keyFeature}`)
+ .join('\n')}\nβ ${readingTime}`;
+};
+
+export const getPageSummary = async (pageUrl: string) => {
+ const [responseError, response] = await resolveCatch(
+ fetch(`${parseBaseUrl}${pageUrl}`, { method: 'GET' }),
+ );
+ if (responseError) {
+ throw responseError;
+ }
+ const [dataError, data] = await resolveCatch(response.json() as Promise);
+ if (dataError) {
+ throw dataError;
+ }
+ // idk what's the type of data if success is false, I don't tried to make it crash
+ if (isPageSummarizeSuccessData(data)) {
+ const { html } = data;
+
+ const [pageSummaryError, pageSummary] = await resolveCatch(
+ parseHtmlSummarized({
+ html,
+ url: pageUrl,
+ }),
+ );
+ if (pageSummaryError) {
+ throw pageSummaryError;
+ }
+ return getPageSummaryDiscordView(pageSummary);
+ }
+ throw new PageSummarizerInvalidDataError(pageUrl, data);
+};
diff --git a/src/modules/coolLinksManagement/summarizeCoolVideos.ts b/src/modules/coolLinksManagement/summarizeCoolVideos.ts
new file mode 100644
index 0000000..3225319
--- /dev/null
+++ b/src/modules/coolLinksManagement/summarizeCoolVideos.ts
@@ -0,0 +1,41 @@
+const baseUrl = 'https://www.summarize.tech/api/summary';
+
+// Example usage:
+// const videoUrl = 'https://www.youtube.com/watch?v=ruUlK6zRwS8';
+// const summary = await getVideoSummary(videoUrl);
+// console.log({ summary });
+
+type SummaryResponse = {
+ rollups: Record;
+ title: string;
+};
+
+type SummaryChunk = {
+ children: Record;
+ summary: string;
+};
+
+const makeId = (length: number) => {
+ let result = '';
+ const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_';
+ const charactersLength = characters.length;
+
+ for (let i = 0; i < length; i++)
+ result += characters.charAt(Math.floor(Math.random() * charactersLength));
+
+ return result;
+};
+
+export const getVideoSummary = async (videoUrl: string) => {
+ return await fetch(baseUrl, {
+ method: 'POST',
+ body: JSON.stringify({ url: videoUrl, deviceId: makeId(21) }),
+ headers: { 'content-type': 'application/json' },
+ })
+ .then((res) => res.json())
+ .then((res) =>
+ (Object.values((res as SummaryResponse).rollups) ?? [])
+ .map((chunk) => chunk.summary)
+ .join(' '),
+ );
+};
diff --git a/src/modules/fart/fart.module.ts b/src/modules/fart/fart.module.ts
new file mode 100644
index 0000000..ff024a3
--- /dev/null
+++ b/src/modules/fart/fart.module.ts
@@ -0,0 +1,17 @@
+import { SlashCommandBuilder } from 'discord.js';
+
+import type { BotModule } from '../../types/bot';
+
+export const fart: BotModule = {
+ slashCommands: [
+ {
+ schema: new SlashCommandBuilder()
+ .setName('fart')
+ .setDescription('Replies with https://prout.dev')
+ .toJSON(),
+ handler: async (interaction) => {
+ await interaction.reply('https://prout.dev');
+ },
+ },
+ ],
+};
diff --git a/src/modules/modules.ts b/src/modules/modules.ts
new file mode 100644
index 0000000..d6c90d7
--- /dev/null
+++ b/src/modules/modules.ts
@@ -0,0 +1,15 @@
+import { coolLinksManagement } from './coolLinksManagement/coolLinksManagement.module';
+import { fart } from './fart/fart.module';
+import { patternReplace } from './patternReplace/patternReplace.module';
+import { quoiFeur } from './quoiFeur/quoiFeur.module';
+import { recurringMessage } from './recurringMessage/recurringMessage.module';
+import { voiceOnDemand } from './voiceOnDemand/voiceOnDemand.module';
+
+export const modules = {
+ fart,
+ voiceOnDemand,
+ coolLinksManagement,
+ patternReplace,
+ quoiFeur,
+ recurringMessage,
+};
diff --git a/src/modules/patternReplace/patternReplace.module.ts b/src/modules/patternReplace/patternReplace.module.ts
new file mode 100644
index 0000000..238550b
--- /dev/null
+++ b/src/modules/patternReplace/patternReplace.module.ts
@@ -0,0 +1,42 @@
+import { MessageType } from 'discord.js';
+
+import { config } from '../../config';
+import type { BotModule } from '../../types/bot';
+
+const urlMappings = [
+ {
+ pattern: /https?:\/\/(mobile\.)?twitter\.com\/(\S+)\/status\/(\d+)/g,
+ replacement: 'https://vxtwitter.com/$2/status/$3',
+ },
+];
+
+export const patternReplace: BotModule = {
+ eventHandlers: {
+ messageCreate: async (message) => {
+ if (
+ message.author.bot ||
+ message.type !== MessageType.Default ||
+ message.channelId === config.discord.coolLinksChannelId
+ ) {
+ return;
+ }
+
+ let modifiedContent = message.content;
+
+ for (const { pattern, replacement } of urlMappings) {
+ if (pattern.test(modifiedContent)) {
+ modifiedContent = modifiedContent.replace(pattern, replacement);
+ }
+ }
+
+ const hasModification = message.content !== modifiedContent;
+ if (!hasModification) return;
+
+ const newMessage = [`<@${message.author.id}>`, modifiedContent].join('\n');
+
+ await message.channel.send(newMessage);
+ await message.delete();
+ },
+ },
+ intents: ['GuildMessages', 'MessageContent'],
+};
diff --git a/src/modules/quoiFeur/quoiFeur.helpers.ts b/src/modules/quoiFeur/quoiFeur.helpers.ts
new file mode 100644
index 0000000..7a66433
--- /dev/null
+++ b/src/modules/quoiFeur/quoiFeur.helpers.ts
@@ -0,0 +1,105 @@
+import {
+ ChannelType,
+ type ChatInputCommandInteraction,
+ DMChannel,
+ type Message,
+ type NonThreadGuildBasedChannel,
+} from 'discord.js';
+
+import { cache } from '../../core/cache';
+import { removeEmoji, removeMarkdown, removePunctuation } from '../../helpers/regex.helper';
+
+const ONE_MINUTE = 1 * 60 * 1000;
+
+const quoiDetectorRegex = /\bquoi\s*$/i;
+const endWithQuoi = (text: string) =>
+ quoiDetectorRegex.test(removeEmoji(removePunctuation(removeMarkdown(text))));
+
+const reactWith = async (message: Message, reactions: string[]) => {
+ for (const reaction of reactions) {
+ await message.react(reaction);
+ }
+};
+
+const reactWithCoubeh = async (message: Message) =>
+ reactWith(message, ['π¨', 'π΄', 'πΊ', 'π§', 'πͺ', 'π', 'π']);
+
+const reactWithFeur = async (message: Message) => reactWith(message, ['π«', 'πͺ', 'πΊ', 'π·']);
+
+export const reactOnEndWithQuoi = async (message: Message) => {
+ if (!endWithQuoi(message.content)) return;
+
+ const channelIds = await cache.get('quoiFeurChannels', []);
+
+ const messageParentId =
+ message.channel.type === ChannelType.PublicThread ? message.channel.parentId : null;
+
+ const isMessageInQuoiFeurChannel =
+ channelIds.includes(message.channelId) ||
+ (messageParentId && channelIds.includes(messageParentId));
+
+ if (!isMessageInQuoiFeurChannel) return;
+
+ const probability = 1 / 6;
+
+ if (Math.random() <= probability) {
+ await reactWithCoubeh(message);
+ await message.member?.timeout(
+ ONE_MINUTE * 5,
+ `${message.member.displayName} have the cramptΓ©s`,
+ );
+ return;
+ }
+
+ await reactWithFeur(message);
+};
+
+export const addQuoiFeurToChannel = async (interaction: ChatInputCommandInteraction) => {
+ const { channel } = interaction;
+ if (!channel || !channel.isTextBased() || channel.type !== ChannelType.GuildText) return;
+
+ const channels = await cache.get('quoiFeurChannels', []);
+ if (channels.includes(channel.id)) {
+ await interaction.reply({
+ content: 'Quoi-feur is already enabled in this channel',
+ ephemeral: true,
+ });
+ return;
+ }
+
+ await cache.set('quoiFeurChannels', [...channels, channel.id]);
+ await interaction.reply({ content: 'Quoi-feur enabled in this channel', ephemeral: true });
+};
+
+export const removeQuoiFeurFromChannel = async (interaction: ChatInputCommandInteraction) => {
+ const { channel } = interaction;
+ if (!channel || !channel.isTextBased() || channel.type !== ChannelType.GuildText) return;
+
+ const channels = await cache.get('quoiFeurChannels', []);
+ if (!channels.includes(channel.id)) {
+ await interaction.reply({
+ content: 'Quoi-feur is not enabled in this channel',
+ ephemeral: true,
+ });
+ return;
+ }
+
+ await cache.set(
+ 'quoiFeurChannels',
+ channels.filter((channelId) => channelId !== channel.id),
+ );
+ await interaction.reply({ content: 'Quoi-feur disabled in this channel', ephemeral: true });
+};
+
+export const cleanCacheOnChannelDelete = async (
+ channel: DMChannel | NonThreadGuildBasedChannel,
+) => {
+ const { id } = channel;
+ const channels = await cache.get('quoiFeurChannels', []);
+ if (!channels.includes(id)) return;
+
+ await cache.set(
+ 'quoiFeurChannels',
+ channels.filter((channelId) => channelId !== id),
+ );
+};
diff --git a/src/modules/quoiFeur/quoiFeur.module.ts b/src/modules/quoiFeur/quoiFeur.module.ts
new file mode 100644
index 0000000..bdae8f4
--- /dev/null
+++ b/src/modules/quoiFeur/quoiFeur.module.ts
@@ -0,0 +1,35 @@
+import { SlashCommandBuilder } from 'discord.js';
+
+import type { BotModule } from '../../types/bot';
+import {
+ addQuoiFeurToChannel,
+ cleanCacheOnChannelDelete,
+ reactOnEndWithQuoi,
+ removeQuoiFeurFromChannel,
+} from './quoiFeur.helpers';
+
+export const quoiFeur: BotModule = {
+ slashCommands: [
+ {
+ schema: new SlashCommandBuilder()
+ .setName('quoi-feur')
+ .setDescription('Manage quoi-feur game in the channel')
+ .addSubcommand((subcommand) =>
+ subcommand.setName('enable').setDescription('Enable the quoi-feur game in the channel'),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand.setName('disable').setDescription('Disable the quoi-feur game in the channel'),
+ )
+ .toJSON(),
+ handler: {
+ enable: addQuoiFeurToChannel,
+ disable: removeQuoiFeurFromChannel,
+ },
+ },
+ ],
+ eventHandlers: {
+ messageCreate: reactOnEndWithQuoi,
+ channelDelete: cleanCacheOnChannelDelete,
+ },
+ intents: ['Guilds', 'GuildMessages', 'MessageContent', 'GuildMessageReactions'],
+};
diff --git a/src/modules/recurringMessage/recurringMessage.helpers.ts b/src/modules/recurringMessage/recurringMessage.helpers.ts
new file mode 100644
index 0000000..89ff4a6
--- /dev/null
+++ b/src/modules/recurringMessage/recurringMessage.helpers.ts
@@ -0,0 +1,202 @@
+import { CronJob } from 'cron';
+import { randomUUID } from 'crypto';
+import type {
+ ChatInputCommandInteraction,
+ Client,
+ DMChannel,
+ NonThreadGuildBasedChannel,
+} from 'discord.js';
+
+import { cache } from '../../core/cache';
+import { isModo } from '../../helpers/roles';
+
+const MAX_MESSAGE_LENGTH = 2000;
+
+const cronTime = {
+ daily: '0 0 9 * * *',
+ weekly: '0 0 9 * * 1',
+ monthly: '0 0 9 1 * *',
+};
+
+const frequencyDisplay = {
+ daily: 'every day at 9am',
+ weekly: 'every monday at 9am',
+ monthly: 'the 1st of every month at 9am',
+};
+
+const inMemoryJobList: { id: string; job: CronJob }[] = [];
+
+export type Frequency = keyof typeof cronTime;
+
+export const isFrequency = (frequency: string): frequency is Frequency => {
+ return Object.keys(cronTime).includes(frequency);
+};
+
+export const hasPermission = (interaction: ChatInputCommandInteraction) => {
+ if (!isModo(interaction.member)) {
+ void interaction.reply({ content: 'You are not allowed to use this command', ephemeral: true });
+ return false;
+ }
+ return true;
+};
+
+export const createRecurringMessage = (
+ client: Client,
+ channelId: string,
+ frequency: Frequency,
+ message: string,
+): CronJob => {
+ return new CronJob(
+ cronTime[frequency],
+ () => {
+ const channel = client.channels.cache.get(channelId);
+ if (!channel || !channel.isTextBased()) {
+ console.error(`Channel ${channelId} not found`);
+ return;
+ }
+ void channel.send(message);
+ },
+ null,
+ true,
+ 'Europe/Paris',
+ );
+};
+
+export const addRecurringMessage = async (interaction: ChatInputCommandInteraction) => {
+ const jobId = randomUUID();
+ const channelId = interaction.channelId;
+ const frequency = interaction.options.getString('frequency', true);
+ if (!isFrequency(frequency)) {
+ await interaction.reply({ content: `${frequency} is not a valid frequency`, ephemeral: true });
+ return;
+ }
+ const message = interaction.options.getString('message', true);
+
+ if (message.length > MAX_MESSAGE_LENGTH) {
+ await interaction.reply({
+ content: `Message is too long (max ${MAX_MESSAGE_LENGTH} characters)`,
+ ephemeral: true,
+ });
+ return;
+ }
+
+ const job = createRecurringMessage(interaction.client, channelId, frequency, message);
+ job.start();
+
+ inMemoryJobList.push({ id: jobId, job });
+
+ const recurringMessages = await cache.get('recurringMessages', []);
+ await cache.set('recurringMessages', [
+ ...recurringMessages,
+ { id: jobId, channelId, frequency, message },
+ ]);
+
+ await interaction.reply({
+ content: `Recurring message added ${frequencyDisplay[frequency]}`,
+ ephemeral: true,
+ });
+};
+
+export const removeRecurringMessage = async (interaction: ChatInputCommandInteraction) => {
+ const jobId = interaction.options.getString('id', true);
+
+ const recurringMessages = await cache.get('recurringMessages', []);
+ await cache.set(
+ 'recurringMessages',
+ recurringMessages.filter(({ id }) => id !== jobId),
+ );
+
+ const job = inMemoryJobList.find(({ id }) => id === jobId)?.job;
+ if (!job) {
+ await interaction.reply({ content: 'Recurring message not found', ephemeral: true });
+ return;
+ }
+
+ job.stop();
+
+ await interaction.reply({ content: 'Recurring message removed', ephemeral: true });
+};
+
+export const listRecurringMessages = async (interaction: ChatInputCommandInteraction) => {
+ const recurringMessages = await cache.get('recurringMessages', []);
+
+ if (recurringMessages.length === 0) {
+ await interaction.reply({ content: 'No recurring message found', ephemeral: true });
+ return;
+ }
+
+ const messagesInCurrentGuild = recurringMessages.filter(
+ ({ channelId }) => interaction.guild?.channels.cache.has(channelId),
+ );
+
+ const messagesByChannelName = messagesInCurrentGuild.reduce<
+ Record>
+ >((acc, { id, frequency, message, channelId }) => {
+ const channel = interaction.guild?.channels.cache.get(channelId);
+ if (channel === undefined) throw new Error('Channel not found');
+
+ const { name } = channel;
+ const currentMessages = acc[name];
+
+ if (currentMessages === undefined) {
+ return { ...acc, [name]: [{ id, frequency, message }] };
+ }
+
+ currentMessages.push({ id, frequency, message });
+
+ return acc;
+ }, {});
+
+ const embeds = Object.entries(messagesByChannelName).map(([channelName, messages]) => {
+ const fields = messages.map(({ id, frequency, message }) => ({
+ name: `β° - ${frequencyDisplay[frequency as Frequency]} (id: ${id})`,
+ value: message.substring(0, 1000) + (message.length > 1000 ? '...' : ''),
+ }));
+
+ return {
+ title: `# ${channelName}`,
+ color: 0x0099ff,
+ fields,
+ };
+ });
+
+ await interaction.reply({ embeds, ephemeral: true });
+};
+
+export const relaunchRecurringMessages = async (client: Client) => {
+ const recurringMessages = await cache.get('recurringMessages', []);
+
+ const channelsToClear = new Set();
+ for (const { id, channelId, frequency, message } of recurringMessages) {
+ if (!client.channels.cache.get(channelId)) {
+ channelsToClear.add(channelId);
+ continue;
+ }
+ const job = createRecurringMessage(client, channelId, frequency, message);
+ job.start();
+ inMemoryJobList.push({ id, job });
+ }
+
+ await cache.set(
+ 'recurringMessages',
+ recurringMessages.filter(({ channelId }) => !channelsToClear.has(channelId)),
+ );
+};
+
+export const removeAllFromChannel = async (channel: DMChannel | NonThreadGuildBasedChannel) => {
+ const { id } = channel;
+
+ const recurringMessages = await cache.get('recurringMessages', []);
+ const jobsToRemove = recurringMessages.filter(({ channelId }) => id === channelId);
+
+ await cache.set(
+ 'recurringMessages',
+ recurringMessages.filter(({ channelId }) => id !== channelId),
+ );
+
+ for (const { id } of jobsToRemove) {
+ const job = inMemoryJobList.find(({ id: jobId }) => id === jobId)?.job;
+ if (!job) continue;
+ job.stop();
+ }
+};
diff --git a/src/modules/recurringMessage/recurringMessage.module.ts b/src/modules/recurringMessage/recurringMessage.module.ts
new file mode 100644
index 0000000..bc24c7c
--- /dev/null
+++ b/src/modules/recurringMessage/recurringMessage.module.ts
@@ -0,0 +1,77 @@
+import { SlashCommandBuilder } from 'discord.js';
+
+import type { BotModule } from '../../types/bot';
+import {
+ addRecurringMessage,
+ hasPermission,
+ listRecurringMessages,
+ relaunchRecurringMessages,
+ removeAllFromChannel,
+ removeRecurringMessage,
+} from './recurringMessage.helpers';
+
+export const recurringMessage: BotModule = {
+ slashCommands: [
+ {
+ schema: new SlashCommandBuilder()
+ .setName('recurrent')
+ .setDescription('Manage recurring messages')
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('add')
+ .setDescription('Add a recurring message')
+ .addStringOption((option) =>
+ option
+ .setName('frequency')
+ .setDescription('How often to send the message')
+ .addChoices(
+ { name: 'daily', value: 'daily' },
+ { name: 'weekly', value: 'weekly' },
+ { name: 'monthly', value: 'monthly' },
+ )
+ .setRequired(true),
+ )
+ .addStringOption((option) =>
+ option.setName('message').setDescription('The message to send').setRequired(true),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand
+ .setName('remove')
+ .setDescription('Remove a recurring message')
+ .addStringOption((option) =>
+ option
+ .setName('id')
+ .setDescription('The id of the recurring message to remove')
+ .setRequired(true),
+ ),
+ )
+ .addSubcommand((subcommand) =>
+ subcommand.setName('list').setDescription('List recurring messages'),
+ )
+ .toJSON(),
+ handler: {
+ add: async (interaction) => {
+ if (!hasPermission(interaction)) return;
+
+ await addRecurringMessage(interaction);
+ },
+ remove: async (interaction) => {
+ if (!hasPermission(interaction)) return;
+
+ await removeRecurringMessage(interaction);
+ },
+ list: async (interaction) => {
+ if (!hasPermission(interaction)) return;
+
+ await listRecurringMessages(interaction);
+ },
+ },
+ },
+ ],
+ eventHandlers: {
+ ready: relaunchRecurringMessages,
+ channelDelete: removeAllFromChannel,
+ },
+ intents: ['Guilds'],
+};
diff --git a/src/modules/voiceOnDemand/voiceOnDemand.helpers.ts b/src/modules/voiceOnDemand/voiceOnDemand.helpers.ts
new file mode 100644
index 0000000..d3225b2
--- /dev/null
+++ b/src/modules/voiceOnDemand/voiceOnDemand.helpers.ts
@@ -0,0 +1,64 @@
+import type {
+ CategoryChannel,
+ GuildChannelCreateOptions,
+ GuildMember,
+ VoiceState,
+} from 'discord.js';
+import { ChannelType, OverwriteType } from 'discord.js';
+import type { SetNonNullable } from 'type-fest';
+
+import { cache } from '../../core/cache';
+import { normalizeName } from '../../helpers/normalizeName.helper';
+
+type CheckedVoiceState = SetNonNullable;
+
+export const isJoinState = (newState: VoiceState): newState is CheckedVoiceState =>
+ newState.channel !== null && newState.channelId !== null && newState.member !== null;
+
+export const isLeaveState = (oldState: VoiceState): oldState is CheckedVoiceState =>
+ oldState.channel !== null && oldState.channelId !== null && oldState.member !== null;
+
+export const handleJoinLobby = async (state: CheckedVoiceState): Promise => {
+ const channel = await createUserVoiceChannel(state.channel.parent, state.member);
+ await state.member.voice.setChannel(channel);
+};
+
+export const handleLeaveOnDemand = async (state: CheckedVoiceState): Promise => {
+ const channels = await cache.get('onDemandChannels', []);
+
+ const { channel } = state;
+ const { id, members, guild } = channel;
+
+ if (channels.includes(id) && members.size === 0) {
+ await channel.delete();
+ guild.channels.cache.delete(id);
+
+ const filtered = channels.filter((channelId) => channelId !== id);
+ await cache.set('onDemandChannels', filtered);
+ }
+};
+
+export const createUserVoiceChannel = async (
+ parent: CategoryChannel | null,
+ member: GuildMember,
+): Promise => {
+ const { displayName, id, guild } = member;
+
+ const name = `voice-${normalizeName(displayName)}`;
+
+ const options: GuildChannelCreateOptions = {
+ name,
+ type: ChannelType.GuildVoice,
+ permissionOverwrites: [
+ { type: OverwriteType.Member, id, allow: ['DeafenMembers', 'MuteMembers', 'MoveMembers'] },
+ ],
+ };
+
+ const channel = await guild.channels.create(parent === null ? options : { ...options, parent });
+
+ const channels = await cache.get('onDemandChannels', []);
+
+ await cache.set('onDemandChannels', [...channels, channel.id]);
+
+ return channel.id;
+};
diff --git a/src/modules/voiceOnDemand/voiceOnDemand.module.ts b/src/modules/voiceOnDemand/voiceOnDemand.module.ts
new file mode 100644
index 0000000..6257958
--- /dev/null
+++ b/src/modules/voiceOnDemand/voiceOnDemand.module.ts
@@ -0,0 +1,113 @@
+import { ChannelType, Guild, SlashCommandBuilder } from 'discord.js';
+
+import { cache } from '../../core/cache';
+import type { BotModule } from '../../types/bot';
+import {
+ handleJoinLobby,
+ handleLeaveOnDemand,
+ isJoinState,
+ isLeaveState,
+} from './voiceOnDemand.helpers';
+
+export const voiceOnDemand: BotModule = {
+ slashCommands: [
+ {
+ schema: new SlashCommandBuilder()
+ .setName('voice-on-demand')
+ .setDescription('Actions related to the voice lobby')
+ .addSubcommand((subcommand) =>
+ subcommand.setName('create').setDescription('Creates the voice lobby'),
+ )
+ .toJSON(),
+ handler: {
+ create: async (interaction): Promise => {
+ const { guild } = interaction;
+
+ if (!(guild instanceof Guild)) {
+ await interaction.reply({
+ content: 'This command is only available in guilds',
+ ephemeral: true,
+ });
+
+ return;
+ }
+ const lobbyIds = await cache.get('lobbyIds', []);
+ const lobbyId = lobbyIds.find((lobbyId) => guild.channels.cache.has(lobbyId));
+
+ if (lobbyId !== undefined) {
+ await interaction.reply({
+ content: 'Voice on demand voice lobby already exists.',
+ ephemeral: true,
+ });
+ return;
+ }
+
+ const { id } = await guild.channels.create({
+ name: 'Lobby',
+ type: ChannelType.GuildVoice,
+ });
+
+ //NOTES: this is a potential race condition.
+ await cache.set('lobbyIds', [...lobbyIds, id]);
+
+ await interaction.reply({
+ content: 'Created voice on demand voice channel.',
+ ephemeral: true,
+ });
+ },
+ },
+ },
+ ],
+ eventHandlers: {
+ voiceStateUpdate: async (oldState, newState) => {
+ const lobbyIds = await cache.get('lobbyIds', []);
+ const onDemandChannels = await cache.get('onDemandChannels', []);
+
+ const isLobbyChannel = lobbyIds.includes(newState.channelId ?? '');
+ const isOnDemandChannel = onDemandChannels.includes(oldState.channelId ?? '');
+
+ if (!isOnDemandChannel && !isLobbyChannel) {
+ return;
+ }
+
+ if (isOnDemandChannel && isLeaveState(oldState)) {
+ await handleLeaveOnDemand(oldState);
+ }
+
+ if (isLobbyChannel && isJoinState(newState)) {
+ await handleJoinLobby(newState);
+ }
+ },
+ channelDelete: async (channel) => {
+ if (channel.type !== ChannelType.GuildVoice) {
+ return;
+ }
+
+ const lobbyIds = await cache.get('lobbyIds', []);
+ const onDemandChannels = await cache.get('onDemandChannels', []);
+
+ const isLobbyChannel = lobbyIds.includes(channel.id);
+ const isOnDemandChannel = onDemandChannels.includes(channel.id);
+
+ if (!isOnDemandChannel && !isLobbyChannel) {
+ return;
+ }
+
+ await cache.set(
+ 'lobbyIds',
+ lobbyIds.filter((lobbyId) => lobbyId !== channel.id),
+ );
+
+ await Promise.all(
+ onDemandChannels.map(async (id) => {
+ const updatedChannel = await channel.guild.channels.fetch(id).catch(() => null);
+ if (updatedChannel !== null) {
+ await channel.guild.channels.delete(id);
+ channel.guild.channels.cache.delete(id);
+ }
+ }),
+ );
+ },
+ },
+ intents: ['GuildVoiceStates', 'GuildMembers'],
+};
diff --git a/src/types/bot.ts b/src/types/bot.ts
new file mode 100644
index 0000000..efde7ad
--- /dev/null
+++ b/src/types/bot.ts
@@ -0,0 +1,27 @@
+import type {
+ ChatInputCommandInteraction,
+ ClientEvents,
+ ClientOptions,
+ RESTPostAPIChatInputApplicationCommandsJSONBody,
+} from 'discord.js';
+
+type slashCommandHandler = (
+ interaction: ChatInputCommandInteraction<'cached' | 'raw'>,
+) => Promise;
+
+export type EventHandler = (
+ ...args: ClientEvents[T]
+) => Promise;
+
+export type BotCommand = {
+ schema: RESTPostAPIChatInputApplicationCommandsJSONBody;
+ handler: slashCommandHandler | Record;
+};
+
+export type BotModule = {
+ slashCommands?: Array;
+ eventHandlers?: {
+ [key in keyof ClientEvents]?: EventHandler;
+ };
+ intents?: ClientOptions['intents'];
+};
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..ab354fa
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,25 @@
+{
+ "compilerOptions": {
+ "esModuleInterop": true,
+ "exactOptionalPropertyTypes": true,
+ "forceConsistentCasingInFileNames": true,
+ "module": "ESNext",
+ "moduleResolution": "bundler",
+ "noErrorTruncation": true,
+ "noFallthroughCasesInSwitch": true,
+ "noImplicitOverride": true,
+ "noImplicitReturns": true,
+ "noPropertyAccessFromIndexSignature": true,
+ "noUncheckedIndexedAccess": true,
+ "noUnusedLocals": true,
+ "noUnusedParameters": true,
+ "resolveJsonModule": true,
+ "skipDefaultLibCheck": true,
+ "skipLibCheck": true,
+ "strict": true,
+ "target": "ESNext",
+ "types": ["node"],
+ "useUnknownInCatchVariables": true,
+ "verbatimModuleSyntax": true
+ }
+}
diff --git a/tsup.config.ts b/tsup.config.ts
new file mode 100644
index 0000000..d6ad64d
--- /dev/null
+++ b/tsup.config.ts
@@ -0,0 +1,10 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+ clean: true,
+ format: ['esm'],
+ keepNames: true,
+ minify: true,
+ sourcemap: true,
+ target: 'esnext',
+});
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..de87991
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,5 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+ test: {},
+});