src/core/DynamicLoader.ts

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 { 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, Function[]>>();

    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);
        }
    }

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

        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);
        }
    }

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

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

        command.group = basename(dirname(filepath));
        this.client.commands.set(command.name, command);

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

        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 any).prototype)
                  };

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

        for (const listenerInfo of metadata.eventListeners ?? []) {
            const callback = object[listenerInfo.methodName as unknown as keyof typeof object] as Function;
            const handler = callback.bind(object);
            handlerData[listenerInfo.event as keyof typeof handlerData] ??= [] as Function[];
            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, Function[]>);
        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]) => any
                );
            }

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

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

export default DynamicLoader;
1	import { Awaitable } from "discord.js";
2	import { Router } from "express";
3	import { lstat, readdir } from "node:fs/promises";
4	import path, { basename, dirname } from "node:path";
5	import Controller from "../api/Controller";
6	import { EventListenerInfo } from "../decorators/GatewayEventListener";
7	import { ClientEvents } from "../types/ClientEvents";
8	import { Class, DefaultExport } from "../types/Utils";
9	import { log, logInfo } from "../utils/logger";
10	import type Client from "./Client";
11	import Command from "./Command";
12	import EventListener from "./EventListener";
13	import Service from "./Service";
14
15	class DynamicLoader extends Service {
16	protected readonly eventHandlers = new WeakMap<object, Record<keyof ClientEvents, Function[]>>();
17
18	private async iterateDirectoryRecursively(root: string, rootArray?: string[]) {
19	const filesAndDirectories = await readdir(root);
20	const files: string[] = [];
21
22	for (const file of filesAndDirectories) {
23	const filepath = path.resolve(root, file);
24	const stat = await lstat(filepath);
25
26	if (stat.isDirectory()) {
27	await this.iterateDirectoryRecursively(filepath, rootArray ?? files);
28	continue;
29	}
30
31	(rootArray ?? files).push(filepath);
32	}
33
34	return files;
35	}
36
37	async loadControllers(router: Router) {
38	const eventListenerFiles = await this.iterateDirectoryRecursively(path.resolve(__dirname, "../api/controllers"));
39
40	for (const file of eventListenerFiles) {
41	if ((!file.endsWith(".ts") && !file.endsWith(".js")) \|\| file.endsWith(".d.ts")) {
42	continue;
43	}
44
45	await this.loadController(file, router);
46	}
47	}
48
49	async loadController(filepath: string, router: Router) {
50	const { default: ControllerClass }: DefaultExport<Class<Controller, [Client]>> = await import(filepath);
51	const controller = new ControllerClass(this.client);
52	this.client.server.loadController(controller, ControllerClass, router);
53	logInfo("Loaded Controller: ", ControllerClass.name);
54	}
55
56	async loadEvents() {
57	const eventListenerFiles = await this.iterateDirectoryRecursively(path.resolve(__dirname, "../events"));
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.loadEvent(file);
65	}
66	}
67
68	async loadEvent(filepath: string) {
69	const { default: EventListenerClass }: DefaultExport<Class<EventListener, [Client]>> = await import(filepath);
70	const listener = new EventListenerClass(this.client);
71	this.client.addEventListener(listener.name, listener.execute.bind(listener));
72	logInfo("Loaded Event: ", listener.name);
73	}
74
75	async loadServiceFromDirectory(servicesDirectory = path.resolve(__dirname, "../services")) {
76	const commandFiles = await this.iterateDirectoryRecursively(servicesDirectory);
77
78	for (const file of commandFiles) {
79	if ((!file.endsWith(".ts") && !file.endsWith(".js")) \|\| file.endsWith(".d.ts")) {
80	continue;
81	}
82
83	await this.client.serviceManager.loadService(file);
84	}
85	}
86
87	async loadCommands(
88	commandsDirectory = path.resolve(__dirname, "../commands"),
89	loadMetadata: boolean = true,
90	filter?: (path: string, name: string) => Awaitable<boolean>
91	) {
92	const commandFiles = await this.iterateDirectoryRecursively(commandsDirectory);
93
94	for (const file of commandFiles) {
95	if ((!file.endsWith(".ts") && !file.endsWith(".js")) \|\| file.endsWith(".d.ts")) {
96	continue;
97	}
98
99	if (filter && !(await filter(file, path.basename(file)))) {
100	continue;
101	}
102
103	await this.loadCommand(file, loadMetadata);
104	}
105	}
106
107	async loadCommand(filepath: string, loadMetadata = true) {
108	const { default: CommandClass }: DefaultExport<Class<Command, [Client]>> = await import(filepath);
109	const command = new CommandClass(this.client);
110	const previousCommand = this.client.commands.get(command.name);
111
112	if (loadMetadata && previousCommand) {
113	await this.unloadEventsFromMetadata(previousCommand);
114	}
115
116	command.group = basename(dirname(filepath));
117	this.client.commands.set(command.name, command);
118
119	for (const alias of command.aliases) {
120	this.client.commands.set(alias, command);
121	}
122
123	if (loadMetadata) {
124	await this.loadEventsFromMetadata(command);
125	}
126
127	logInfo("Loaded Command: ", command.name);
128	}
129
130	async loadEventsFromMetadata(object: object, accessConstructor = true) {
131	const finalObject = accessConstructor ? object.constructor : object;
132	const metadata =
133	Symbol.metadata in finalObject
134	? (finalObject[Symbol.metadata] as { eventListeners?: EventListenerInfo[] })
135	: {
136	eventListeners: Reflect.getMetadata("event_listeners", (finalObject as any).prototype)
137	};
138
139	const handlerData = this.eventHandlers.get(object) ?? ({} as Record<keyof ClientEvents, Function[]>);
140
141	for (const listenerInfo of metadata.eventListeners ?? []) {
142	const callback = object[listenerInfo.methodName as unknown as keyof typeof object] as Function;
143	const handler = callback.bind(object);
144	handlerData[listenerInfo.event as keyof typeof handlerData] ??= [] as Function[];
145	handlerData[listenerInfo.event as keyof typeof handlerData].push(handler);
146
147	this.client.addEventListener(listenerInfo.event as keyof ClientEvents, handler);
148	}
149
150	this.eventHandlers.set(object, handlerData);
151
152	if (metadata.eventListeners) {
153	log(`Registered ${metadata.eventListeners?.length ?? 0} event listeners`);
154	}
155	}
156
157	async unloadEventsFromMetadata(object: object) {
158	const handlerData = this.eventHandlers.get(object) ?? ({} as Record<keyof ClientEvents, Function[]>);
159	let count = 0;
160
161	for (const event in handlerData) {
162	for (const callback of handlerData[event as keyof typeof handlerData]) {
163	this.client.removeEventListener(
164	event as keyof ClientEvents,
165	callback as (...args: ClientEvents[keyof ClientEvents]) => any
166	);
167	}
168
169	count += handlerData[event as keyof typeof handlerData].length;
170	}
171
172	log(`Unloaded ${count} event listeners`);
173	}
174	}
175
176	export default DynamicLoader;