src/core/Client.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import { PrismaClient } from "@prisma/client";
import {
    ClientOptions,
    Collection,
    ClientEvents as DiscordClientEvents,
    Client as DiscordJSClient,
    GuildEmoji
} from "discord.js";
import path from "node:path";
import Server from "../api/Server";
import type AIAutoModService from "../automod/AIAutoModService";
import type Antijoin from "../automod/Antijoin";
import type Antiraid from "../automod/Antiraid";
import type Antispam from "../automod/Antispam";
import type FileFilterService from "../automod/FileFilterService";
import type MessageFilter from "../automod/MessageFilter";
import type MessageRuleService from "../automod/MessageRuleService";
import type ProfileFilter from "../automod/ProfileFilter";
import type VerificationService from "../automod/VerificationService";
import type AFKService from "../services/AFKService";
import type AutoRoleService from "../services/AutoRoleService";
import type BallotManager from "../services/BallotManager";
import type BumpReminderService from "../services/BumpReminderService";
import type ChannelLockManager from "../services/ChannelLockManager";
import type CommandManager from "../services/CommandManager";
import type CommandPermissionOverwriteManager from "../services/CommandPermissionOverwriteManager";
import type ConfigManager from "../services/ConfigManager";
import type CooldownService from "../services/CooldownService";
import type ExtensionService from "../services/ExtensionService";
import type ImageRecognitionService from "../services/ImageRecognitionService";
import type InfractionManager from "../services/InfractionManager";
import type InviteTrackerService from "../services/InviteTrackerService";
import type KeypressHandlerService from "../services/KeypressHandlerService";
import type LogServer from "../services/LogServer";
import type LoggerService from "../services/LoggerService";
import type MetadataService from "../services/MetadataService";
import type PermissionManager from "../services/PermissionManager";
import type QueueManager from "../services/QueueManager";
import type QuickMuteService from "../services/QuickMuteService";
import type ReactionRoleService from "../services/ReactionRoleService";
import type ReportService from "../services/ReportService";
import type SnippetManager from "../services/SnippetManager";
import type StartupManager from "../services/StartupManager";
import type StatsService from "../services/StatsService";
import type TranslationService from "../services/TranslationService";
import type TriggerService from "../services/TriggerService";
import type WelcomerService from "../services/WelcomerService";
import { ClientEvents } from "../types/ClientEvents";
import { developmentMode } from "../utils/utils";
import type Command from "./Command";
import DynamicLoader from "./DynamicLoader";
import ServiceManager from "./ServiceManager";

class Client<R extends boolean = boolean> extends DiscordJSClient<R> {
    public static instance: Client;
    private readonly eventListeners = new Map<string, Function[]>();
    public readonly commands = new Collection<string, Command>();
    public readonly emojiMap = new Map<string, GuildEmoji>();

    public readonly prisma = new PrismaClient({
        errorFormat: "pretty",
        log: developmentMode() ? ["error", "info", "query", "warn"] : ["error", "info", "warn"]
    });

    public readonly server = new Server(this);
    public readonly dynamicLoader = new DynamicLoader(this);
    public readonly serviceManager = new ServiceManager(this);

    public readonly aliases = {
        automod: path.resolve(__dirname, "../automod"),
        services: path.resolve(__dirname, "../services")
    };

    public readonly services = [
        "@services/StartupManager",
        "@services/ConfigManager",
        "@services/CommandManager",
        "@services/InfractionManager",
        "@services/LoggerService",
        "@services/QueueManager",
        "@services/WelcomerService",
        "@services/SnippetManager",
        "@services/ChannelLockManager",
        "@services/PermissionManager",
        "@services/MetadataService",
        "@services/QuickMuteService",
        "@services/TranslationService",
        "@services/AutoRoleService",
        "@services/ReactionRoleService",
        "@services/AFKService",
        "@services/InviteTrackerService",
        "@services/BallotManager",
        "@services/TriggerService",
        "@services/ExtensionService",
        "@services/BumpReminderService",
        "@services/LogServer",
        "@services/CooldownService",
        "@services/KeypressHandlerService",
        "@services/CommandPermissionOverwriteManager",
        "@services/ReportService",
        "@services/StatsService",
        "@services/ImageRecognitionService",

        "@automod/MessageFilter",
        "@automod/Antispam",
        "@automod/Antiraid",
        "@automod/Antijoin",
        "@automod/ProfileFilter",
        "@automod/FileFilterService",
        "@automod/MessageRuleService",
        "@automod/AIAutoModService",
        "@automod/VerificationService"
    ];

    startupManager!: StartupManager;
    configManager!: ConfigManager;
    commandManager!: CommandManager;
    infractionManager!: InfractionManager;
    logger!: LoggerService;
    messageFilter!: MessageFilter;
    antispam!: Antispam;
    queueManager!: QueueManager;
    snippetManager!: SnippetManager;
    welcomerService!: WelcomerService;
    antiraid!: Antiraid;
    channelLockManager!: ChannelLockManager;
    antijoin!: Antijoin;
    profileFilter!: ProfileFilter;
    permissionManager!: PermissionManager;
    metadata!: MetadataService;
    quickMute!: QuickMuteService;
    translator!: TranslationService;
    autoRoleService!: AutoRoleService;
    reactionRoleService!: ReactionRoleService;
    afkService!: AFKService;
    inviteTracker!: InviteTrackerService;
    ballotManager!: BallotManager;
    fileFilter!: FileFilterService;
    messageRuleService!: MessageRuleService;
    triggerService!: TriggerService;
    aiAutoMod!: AIAutoModService;
    extensionService!: ExtensionService;
    bumpReminder!: BumpReminderService;
    logServer!: LogServer;
    cooldown!: CooldownService;
    keypressHandler!: KeypressHandlerService;
    verification!: VerificationService;
    reportService!: ReportService;
    commandPermissionOverwriteManager!: CommandPermissionOverwriteManager;
    statsService!: StatsService;
    imageRecognitionService!: ImageRecognitionService;

    constructor(options: ClientOptions) {
        super(options);
        Client.instance = this;
    }

    async boot({ commands = true, events = true }: { commands?: boolean; events?: boolean } = {}) {
        await this.serviceManager.loadServices();

        if (events) {
            await this.dynamicLoader.loadEvents();
        }

        if (commands) {
            await this.dynamicLoader.loadCommands();
        }
    }

    async getHomeGuild() {
        return this.guilds.cache.get(process.env.HOME_GUILD_ID) ?? (await this.guilds.fetch(process.env.HOME_GUILD_ID));
    }

    addEventListener<K extends keyof ClientEvents>(name: K, listener: (...args: ClientEvents[K]) => unknown) {
        const handlers = this.eventListeners.get(name) ?? [];

        if (!this.eventListeners.has(name)) {
            this.eventListeners.set(name, handlers);
        }

        handlers.push(listener);
        this.on(name as keyof DiscordClientEvents, listener as (...args: DiscordClientEvents[keyof DiscordClientEvents]) => void);
    }

    removeEventListener<K extends keyof ClientEvents>(name: K, listener?: (...args: ClientEvents[K]) => unknown) {
        if (!listener) {
            this.eventListeners.delete(name);
            this.removeAllListeners(name as keyof DiscordClientEvents);
            return;
        }

        const handlers = this.eventListeners.get(name) ?? [];
        const index = handlers.findIndex(handler => handler === listener);

        if (index === -1) {
            return;
        }

        const handler = handlers.splice(index, 1)[0];
        this.off(name as keyof DiscordClientEvents, handler as (...args: DiscordClientEvents[keyof DiscordClientEvents]) => void);
    }

    emitWaitLocal<K extends keyof ClientEvents>(name: K, ...args: ClientEvents[K]) {
        return new Promise<void>(async (resolve, reject) => {
            for (const listener of this.eventListeners.get(name) ?? []) {
                await listener(...args);
            }

            resolve();
        });
    }

    emitWait<K extends keyof ClientEvents>(name: K, ...args: ClientEvents[K]) {
        for (const listener of this.eventListeners.get(name) ?? []) {
            listener(...args);
        }
    }
}

export default Client;
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
5	*
6	* SudoBot is free software; you can redistribute it and/or modify it
7	* under the terms of the GNU Affero General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* SudoBot is distributed in the hope that it will be useful, but
12	* WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public License
17	* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18	*/
19
20	import { PrismaClient } from "@prisma/client";
21	import {
22	ClientOptions,
23	Collection,
24	ClientEvents as DiscordClientEvents,
25	Client as DiscordJSClient,
26	GuildEmoji
27	} from "discord.js";
28	import path from "node:path";
29	import Server from "../api/Server";
30	import type AIAutoModService from "../automod/AIAutoModService";
31	import type Antijoin from "../automod/Antijoin";
32	import type Antiraid from "../automod/Antiraid";
33	import type Antispam from "../automod/Antispam";
34	import type FileFilterService from "../automod/FileFilterService";
35	import type MessageFilter from "../automod/MessageFilter";
36	import type MessageRuleService from "../automod/MessageRuleService";
37	import type ProfileFilter from "../automod/ProfileFilter";
38	import type VerificationService from "../automod/VerificationService";
39	import type AFKService from "../services/AFKService";
40	import type AutoRoleService from "../services/AutoRoleService";
41	import type BallotManager from "../services/BallotManager";
42	import type BumpReminderService from "../services/BumpReminderService";
43	import type ChannelLockManager from "../services/ChannelLockManager";
44	import type CommandManager from "../services/CommandManager";
45	import type CommandPermissionOverwriteManager from "../services/CommandPermissionOverwriteManager";
46	import type ConfigManager from "../services/ConfigManager";
47	import type CooldownService from "../services/CooldownService";
48	import type ExtensionService from "../services/ExtensionService";
49	import type ImageRecognitionService from "../services/ImageRecognitionService";
50	import type InfractionManager from "../services/InfractionManager";
51	import type InviteTrackerService from "../services/InviteTrackerService";
52	import type KeypressHandlerService from "../services/KeypressHandlerService";
53	import type LogServer from "../services/LogServer";
54	import type LoggerService from "../services/LoggerService";
55	import type MetadataService from "../services/MetadataService";
56	import type PermissionManager from "../services/PermissionManager";
57	import type QueueManager from "../services/QueueManager";
58	import type QuickMuteService from "../services/QuickMuteService";
59	import type ReactionRoleService from "../services/ReactionRoleService";
60	import type ReportService from "../services/ReportService";
61	import type SnippetManager from "../services/SnippetManager";
62	import type StartupManager from "../services/StartupManager";
63	import type StatsService from "../services/StatsService";
64	import type TranslationService from "../services/TranslationService";
65	import type TriggerService from "../services/TriggerService";
66	import type WelcomerService from "../services/WelcomerService";
67	import { ClientEvents } from "../types/ClientEvents";
68	import { developmentMode } from "../utils/utils";
69	import type Command from "./Command";
70	import DynamicLoader from "./DynamicLoader";
71	import ServiceManager from "./ServiceManager";
72
73	class Client<R extends boolean = boolean> extends DiscordJSClient<R> {
74	public static instance: Client;
75	private readonly eventListeners = new Map<string, Function[]>();
76	public readonly commands = new Collection<string, Command>();
77	public readonly emojiMap = new Map<string, GuildEmoji>();
78
79	public readonly prisma = new PrismaClient({
80	errorFormat: "pretty",
81	log: developmentMode() ? ["error", "info", "query", "warn"] : ["error", "info", "warn"]
82	});
83
84	public readonly server = new Server(this);
85	public readonly dynamicLoader = new DynamicLoader(this);
86	public readonly serviceManager = new ServiceManager(this);
87
88	public readonly aliases = {
89	automod: path.resolve(__dirname, "../automod"),
90	services: path.resolve(__dirname, "../services")
91	};
92
93	public readonly services = [
94	"@services/StartupManager",
95	"@services/ConfigManager",
96	"@services/CommandManager",
97	"@services/InfractionManager",
98	"@services/LoggerService",
99	"@services/QueueManager",
100	"@services/WelcomerService",
101	"@services/SnippetManager",
102	"@services/ChannelLockManager",
103	"@services/PermissionManager",
104	"@services/MetadataService",
105	"@services/QuickMuteService",
106	"@services/TranslationService",
107	"@services/AutoRoleService",
108	"@services/ReactionRoleService",
109	"@services/AFKService",
110	"@services/InviteTrackerService",
111	"@services/BallotManager",
112	"@services/TriggerService",
113	"@services/ExtensionService",
114	"@services/BumpReminderService",
115	"@services/LogServer",
116	"@services/CooldownService",
117	"@services/KeypressHandlerService",
118	"@services/CommandPermissionOverwriteManager",
119	"@services/ReportService",
120	"@services/StatsService",
121	"@services/ImageRecognitionService",
122
123	"@automod/MessageFilter",
124	"@automod/Antispam",
125	"@automod/Antiraid",
126	"@automod/Antijoin",
127	"@automod/ProfileFilter",
128	"@automod/FileFilterService",
129	"@automod/MessageRuleService",
130	"@automod/AIAutoModService",
131	"@automod/VerificationService"
132	];
133
134	startupManager!: StartupManager;
135	configManager!: ConfigManager;
136	commandManager!: CommandManager;
137	infractionManager!: InfractionManager;
138	logger!: LoggerService;
139	messageFilter!: MessageFilter;
140	antispam!: Antispam;
141	queueManager!: QueueManager;
142	snippetManager!: SnippetManager;
143	welcomerService!: WelcomerService;
144	antiraid!: Antiraid;
145	channelLockManager!: ChannelLockManager;
146	antijoin!: Antijoin;
147	profileFilter!: ProfileFilter;
148	permissionManager!: PermissionManager;
149	metadata!: MetadataService;
150	quickMute!: QuickMuteService;
151	translator!: TranslationService;
152	autoRoleService!: AutoRoleService;
153	reactionRoleService!: ReactionRoleService;
154	afkService!: AFKService;
155	inviteTracker!: InviteTrackerService;
156	ballotManager!: BallotManager;
157	fileFilter!: FileFilterService;
158	messageRuleService!: MessageRuleService;
159	triggerService!: TriggerService;
160	aiAutoMod!: AIAutoModService;
161	extensionService!: ExtensionService;
162	bumpReminder!: BumpReminderService;
163	logServer!: LogServer;
164	cooldown!: CooldownService;
165	keypressHandler!: KeypressHandlerService;
166	verification!: VerificationService;
167	reportService!: ReportService;
168	commandPermissionOverwriteManager!: CommandPermissionOverwriteManager;
169	statsService!: StatsService;
170	imageRecognitionService!: ImageRecognitionService;
171
172	constructor(options: ClientOptions) {
173	super(options);
174	Client.instance = this;
175	}
176
177	async boot({ commands = true, events = true }: { commands?: boolean; events?: boolean } = {}) {
178	await this.serviceManager.loadServices();
179
180	if (events) {
181	await this.dynamicLoader.loadEvents();
182	}
183
184	if (commands) {
185	await this.dynamicLoader.loadCommands();
186	}
187	}
188
189	async getHomeGuild() {
190	return this.guilds.cache.get(process.env.HOME_GUILD_ID) ?? (await this.guilds.fetch(process.env.HOME_GUILD_ID));
191	}
192
193	addEventListener<K extends keyof ClientEvents>(name: K, listener: (...args: ClientEvents[K]) => unknown) {
194	const handlers = this.eventListeners.get(name) ?? [];
195
196	if (!this.eventListeners.has(name)) {
197	this.eventListeners.set(name, handlers);
198	}
199
200	handlers.push(listener);
201	this.on(name as keyof DiscordClientEvents, listener as (...args: DiscordClientEvents[keyof DiscordClientEvents]) => void);
202	}
203
204	removeEventListener<K extends keyof ClientEvents>(name: K, listener?: (...args: ClientEvents[K]) => unknown) {
205	if (!listener) {
206	this.eventListeners.delete(name);
207	this.removeAllListeners(name as keyof DiscordClientEvents);
208	return;
209	}
210
211	const handlers = this.eventListeners.get(name) ?? [];
212	const index = handlers.findIndex(handler => handler === listener);
213
214	if (index === -1) {
215	return;
216	}
217
218	const handler = handlers.splice(index, 1)[0];
219	this.off(name as keyof DiscordClientEvents, handler as (...args: DiscordClientEvents[keyof DiscordClientEvents]) => void);
220	}
221
222	emitWaitLocal<K extends keyof ClientEvents>(name: K, ...args: ClientEvents[K]) {
223	return new Promise<void>(async (resolve, reject) => {
224	for (const listener of this.eventListeners.get(name) ?? []) {
225	await listener(...args);
226	}
227
228	resolve();
229	});
230	}
231
232	emitWait<K extends keyof ClientEvents>(name: K, ...args: ClientEvents[K]) {
233	for (const listener of this.eventListeners.get(name) ?? []) {
234	listener(...args);
235	}
236	}
237	}
238
239	export default Client;