src/core/DynamicLoader.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 { Awaitable } from "discord.js";
import { Router } from "express";
import { lstat, readdir } from "node:fs/promises";
import path, { basename, dirname } from "node:path";
import Controller from "../api/Controller";
import { EventListenerInfo } from "../decorators/GatewayEventListener";
import { ClientEvents } from "../types/ClientEvents";
import { AnyFunction, Class, DefaultExport } from "../types/Utils";
import { log, logInfo } from "../utils/Logger";
import type Client from "./Client";
import Command from "./Command";
import EventListener from "./EventListener";
import Service from "./Service";

class DynamicLoader extends Service {
    protected readonly eventHandlers = new WeakMap<object, Record<keyof ClientEvents, AnyFunction[]>>();

    private async iterateDirectoryRecursively(root: string, rootArray?: string[]) {
        const filesAndDirectories = await readdir(root);
        const files: string[] = [];

        for (const file of filesAndDirectories) {
            const filepath = path.resolve(root, file);
            const stat = await lstat(filepath);

            if (stat.isDirectory()) {
                await this.iterateDirectoryRecursively(filepath, rootArray ?? files);
                continue;
            }

            (rootArray ?? files).push(filepath);
        }

        return files;
    }

    async loadControllers(router: Router) {
        const eventListenerFiles = await this.iterateDirectoryRecursively(path.resolve(__dirname, "../api/controllers"));

        for (const file of eventListenerFiles) {
            if ((!file.endsWith(".ts") && !file.endsWith(".js")) || file.endsWith(".d.ts")) {
                continue;
            }

            await this.loadController(file, router);
        }
    }

    async loadController(filepath: string, router: Router) {
        const { default: ControllerClass }: DefaultExport<Class<Controller, [Client]>> = await import(filepath);
        const controller = new ControllerClass(this.client);
        this.client.server.loadController(controller, ControllerClass, router);
        logInfo("Loaded Controller: ", ControllerClass.name);
    }

    async loadEvents() {
        const eventListenerFiles = await this.iterateDirectoryRecursively(path.resolve(__dirname, "../events"));

        for (const file of eventListenerFiles) {
            if ((!file.endsWith(".ts") && !file.endsWith(".js")) || file.endsWith(".d.ts")) {
                continue;
            }

            await this.loadEvent(file);
        }
    }

    async loadEvent(filepath: string) {
        const { default: EventListenerClass }: DefaultExport<Class<EventListener, [Client]>> = await import(filepath);
        const listener = new EventListenerClass(this.client);
        this.client.addEventListener(listener.name, listener.execute.bind(listener));
        logInfo("Loaded Event: ", listener.name);
    }

    async loadServiceFromDirectory(servicesDirectory = path.resolve(__dirname, "../services")) {
        const commandFiles = await this.iterateDirectoryRecursively(servicesDirectory);

        for (const file of commandFiles) {
            if ((!file.endsWith(".ts") && !file.endsWith(".js")) || file.endsWith(".d.ts")) {
                continue;
            }

            await this.client.serviceManager.loadService(file);
        }
    }

    flattenCommandGroups() {
        const groups = this.client.configManager.systemConfig.commands.groups;
        const groupNames = Object.keys(groups);

        if (groupNames.length === 0) {
            return null;
        }

        const flatten: Record<string, string> = {};

        for (const groupName of groupNames) {
            for (const commandName of groups[groupName]) {
                flatten[commandName] = groupName;
            }
        }

        return flatten;
    }

    async loadCommands(
        commandsDirectory = path.resolve(__dirname, "../commands"),
        loadMetadata: boolean = true,
        filter?: (path: string, name: string) => Awaitable<boolean>
    ) {
        const commandFiles = await this.iterateDirectoryRecursively(commandsDirectory);
        const groups = this.flattenCommandGroups();

        for (const file of commandFiles) {
            if ((!file.endsWith(".ts") && !file.endsWith(".js")) || file.endsWith(".d.ts")) {
                continue;
            }

            if (filter && !(await filter(file, path.basename(file)))) {
                continue;
            }

            await this.loadCommand(file, loadMetadata, groups);
        }
    }

    async loadCommand(filepath: string, loadMetadata = true, groups: Record<string, string> | null = null) {
        const { default: CommandClass }: DefaultExport<Class<Command, [Client]>> = await import(filepath);
        const command = new CommandClass(this.client);
        const previousCommand = this.client.commands.get(command.name);
        let aliasGroupSet = false;

        if (loadMetadata && previousCommand) {
            await this.unloadEventsFromMetadata(previousCommand);
        }

        this.client.commands.set(command.name, command);

        for (const alias of command.aliases) {
            this.client.commands.set(alias, command);

            if (groups?.[alias] && !aliasGroupSet) {
                command.group = groups?.[alias];
                aliasGroupSet = true;
            }
        }

        if (!aliasGroupSet || groups?.[command.name]) {
            command.group = groups?.[command.name] ?? basename(dirname(filepath));
        }

        if (loadMetadata) {
            await this.loadEventsFromMetadata(command);
        }

        logInfo("Loaded Command: ", command.name);
    }

    async loadEventsFromMetadata(object: object, accessConstructor = true) {
        const finalObject = accessConstructor ? object.constructor : object;
        const metadata =
            Symbol.metadata in finalObject
                ? (finalObject[Symbol.metadata] as { eventListeners?: EventListenerInfo[] })
                : {
                      eventListeners: Reflect.getMetadata("event_listeners", (finalObject as { prototype: object }).prototype)
                  };

        const handlerData = this.eventHandlers.get(object) ?? ({} as Record<keyof ClientEvents, AnyFunction[]>);

        for (const listenerInfo of metadata.eventListeners ?? []) {
            const callback = object[listenerInfo.methodName as unknown as keyof typeof object] as AnyFunction;
            const handler = callback.bind(object);
            handlerData[listenerInfo.event as keyof typeof handlerData] ??= [] as AnyFunction[];
            handlerData[listenerInfo.event as keyof typeof handlerData].push(handler);

            this.client.addEventListener(listenerInfo.event as keyof ClientEvents, handler);
        }

        this.eventHandlers.set(object, handlerData);

        if (metadata.eventListeners) {
            log(`Registered ${metadata.eventListeners?.length ?? 0} event listeners`);
        }
    }

    async unloadEventsFromMetadata(object: object) {
        const handlerData = this.eventHandlers.get(object) ?? ({} as Record<keyof ClientEvents, AnyFunction[]>);
        let count = 0;

        for (const event in handlerData) {
            for (const callback of handlerData[event as keyof typeof handlerData]) {
                this.client.removeEventListener(
                    event as keyof ClientEvents,
                    callback as (...args: ClientEvents[keyof ClientEvents]) => unknown
                );
            }

            count += handlerData[event as keyof typeof handlerData].length;
        }

        log(`Unloaded ${count} event listeners`);
    }
}

export default DynamicLoader;
1	rakinar2	577	/*
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 { Awaitable } from "discord.js";
21			import { Router } from "express";
22			import { lstat, readdir } from "node:fs/promises";
23			import path, { basename, dirname } from "node:path";
24			import Controller from "../api/Controller";
25			import { EventListenerInfo } from "../decorators/GatewayEventListener";
26			import { ClientEvents } from "../types/ClientEvents";
27			import { AnyFunction, Class, DefaultExport } from "../types/Utils";
28			import { log, logInfo } from "../utils/Logger";
29			import type Client from "./Client";
30			import Command from "./Command";
31			import EventListener from "./EventListener";
32			import Service from "./Service";
33
34			class DynamicLoader extends Service {
35			protected readonly eventHandlers = new WeakMap<object, Record<keyof ClientEvents, AnyFunction[]>>();
36
37			private async iterateDirectoryRecursively(root: string, rootArray?: string[]) {
38			const filesAndDirectories = await readdir(root);
39			const files: string[] = [];
40
41			for (const file of filesAndDirectories) {
42			const filepath = path.resolve(root, file);
43			const stat = await lstat(filepath);
44
45			if (stat.isDirectory()) {
46			await this.iterateDirectoryRecursively(filepath, rootArray ?? files);
47			continue;
48			}
49
50			(rootArray ?? files).push(filepath);
51			}
52
53			return files;
54			}
55
56			async loadControllers(router: Router) {
57			const eventListenerFiles = await this.iterateDirectoryRecursively(path.resolve(__dirname, "../api/controllers"));
58
59			for (const file of eventListenerFiles) {
60			if ((!file.endsWith(".ts") && !file.endsWith(".js")) \|\| file.endsWith(".d.ts")) {
61			continue;
62			}
63
64			await this.loadController(file, router);
65			}
66			}
67
68			async loadController(filepath: string, router: Router) {
69			const { default: ControllerClass }: DefaultExport<Class<Controller, [Client]>> = await import(filepath);
70			const controller = new ControllerClass(this.client);
71			this.client.server.loadController(controller, ControllerClass, router);
72			logInfo("Loaded Controller: ", ControllerClass.name);
73			}
74
75			async loadEvents() {
76			const eventListenerFiles = await this.iterateDirectoryRecursively(path.resolve(__dirname, "../events"));
77
78			for (const file of eventListenerFiles) {
79			if ((!file.endsWith(".ts") && !file.endsWith(".js")) \|\| file.endsWith(".d.ts")) {
80			continue;
81			}
82
83			await this.loadEvent(file);
84			}
85			}
86
87			async loadEvent(filepath: string) {
88			const { default: EventListenerClass }: DefaultExport<Class<EventListener, [Client]>> = await import(filepath);
89			const listener = new EventListenerClass(this.client);
90			this.client.addEventListener(listener.name, listener.execute.bind(listener));
91			logInfo("Loaded Event: ", listener.name);
92			}
93
94			async loadServiceFromDirectory(servicesDirectory = path.resolve(__dirname, "../services")) {
95			const commandFiles = await this.iterateDirectoryRecursively(servicesDirectory);
96
97			for (const file of commandFiles) {
98			if ((!file.endsWith(".ts") && !file.endsWith(".js")) \|\| file.endsWith(".d.ts")) {
99			continue;
100			}
101
102			await this.client.serviceManager.loadService(file);
103			}
104			}
105
106			flattenCommandGroups() {
107			const groups = this.client.configManager.systemConfig.commands.groups;
108			const groupNames = Object.keys(groups);
109
110			if (groupNames.length === 0) {
111			return null;
112			}
113
114			const flatten: Record<string, string> = {};
115
116			for (const groupName of groupNames) {
117			for (const commandName of groups[groupName]) {
118			flatten[commandName] = groupName;
119			}
120			}
121
122			return flatten;
123			}
124
125			async loadCommands(
126			commandsDirectory = path.resolve(__dirname, "../commands"),
127			loadMetadata: boolean = true,
128			filter?: (path: string, name: string) => Awaitable<boolean>
129			) {
130			const commandFiles = await this.iterateDirectoryRecursively(commandsDirectory);
131			const groups = this.flattenCommandGroups();
132
133			for (const file of commandFiles) {
134			if ((!file.endsWith(".ts") && !file.endsWith(".js")) \|\| file.endsWith(".d.ts")) {
135			continue;
136			}
137
138			if (filter && !(await filter(file, path.basename(file)))) {
139			continue;
140			}
141
142			await this.loadCommand(file, loadMetadata, groups);
143			}
144			}
145
146			async loadCommand(filepath: string, loadMetadata = true, groups: Record<string, string> \| null = null) {
147			const { default: CommandClass }: DefaultExport<Class<Command, [Client]>> = await import(filepath);
148			const command = new CommandClass(this.client);
149			const previousCommand = this.client.commands.get(command.name);
150			let aliasGroupSet = false;
151
152			if (loadMetadata && previousCommand) {
153			await this.unloadEventsFromMetadata(previousCommand);
154			}
155
156			this.client.commands.set(command.name, command);
157
158			for (const alias of command.aliases) {
159			this.client.commands.set(alias, command);
160
161			if (groups?.[alias] && !aliasGroupSet) {
162			command.group = groups?.[alias];
163			aliasGroupSet = true;
164			}
165			}
166
167			if (!aliasGroupSet \|\| groups?.[command.name]) {
168			command.group = groups?.[command.name] ?? basename(dirname(filepath));
169			}
170
171			if (loadMetadata) {
172			await this.loadEventsFromMetadata(command);
173			}
174
175			logInfo("Loaded Command: ", command.name);
176			}
177
178			async loadEventsFromMetadata(object: object, accessConstructor = true) {
179			const finalObject = accessConstructor ? object.constructor : object;
180			const metadata =
181			Symbol.metadata in finalObject
182			? (finalObject[Symbol.metadata] as { eventListeners?: EventListenerInfo[] })
183			: {
184			eventListeners: Reflect.getMetadata("event_listeners", (finalObject as { prototype: object }).prototype)
185			};
186
187			const handlerData = this.eventHandlers.get(object) ?? ({} as Record<keyof ClientEvents, AnyFunction[]>);
188
189			for (const listenerInfo of metadata.eventListeners ?? []) {
190			const callback = object[listenerInfo.methodName as unknown as keyof typeof object] as AnyFunction;
191			const handler = callback.bind(object);
192			handlerData[listenerInfo.event as keyof typeof handlerData] ??= [] as AnyFunction[];
193			handlerData[listenerInfo.event as keyof typeof handlerData].push(handler);
194
195			this.client.addEventListener(listenerInfo.event as keyof ClientEvents, handler);
196			}
197
198			this.eventHandlers.set(object, handlerData);
199
200			if (metadata.eventListeners) {
201			log(`Registered ${metadata.eventListeners?.length ?? 0} event listeners`);
202			}
203			}
204
205			async unloadEventsFromMetadata(object: object) {
206			const handlerData = this.eventHandlers.get(object) ?? ({} as Record<keyof ClientEvents, AnyFunction[]>);
207			let count = 0;
208
209			for (const event in handlerData) {
210			for (const callback of handlerData[event as keyof typeof handlerData]) {
211			this.client.removeEventListener(
212			event as keyof ClientEvents,
213			callback as (...args: ClientEvents[keyof ClientEvents]) => unknown
214			);
215			}
216
217			count += handlerData[event as keyof typeof handlerData].length;
218			}
219
220			log(`Unloaded ${count} event listeners`);
221			}
222			}
223
224			export default DynamicLoader;