src/api/Router.ts

import { readdir } from "fs/promises";
import path from "path";
import DiscordClient from "../client/Client";
import Service from "../utils/structures/Service";
import Controller from "./Controller";
import Route from "./Route";
import Server from "./Server";

export interface RouterOptions {
    routesDir: string;
}

export default class Router extends Service {
    routesDir: string;
    controllerObjects: Array <Controller> = [];
    routes: Route[] = [];

    constructor(client: DiscordClient, protected server: Server, { routesDir }: RouterOptions) {
        super(client);
        this.routesDir = routesDir;
    }

    async loadRoutes() {
        const files = await readdir(this.routesDir);

        for await (const file of files) {
            if (!file.endsWith('.ts') && !file.endsWith('.js')) {
                continue;
            }

            console.log(`Loading routes from "${file}"...`);

            await import(path.join(this.routesDir, file));
        }
    }

    static insert(method: string, path: string, callback: [typeof Controller, string]) {
        let controller = DiscordClient.client.server.router.controllerObjects.find(c => c instanceof callback[0]);

        if (!controller) {
            controller = new callback[0]();
            DiscordClient.client.server.router.controllerObjects.push(controller);
            console.log("Pushed a controller");
        }

        const route = new Route(method, path, [controller, callback[1]]);
        DiscordClient.client.server.router.routes.push(route);
        return route;
    }
    
    static get(path: string, callback: [typeof Controller, string]) {
        return Router.insert("GET", path, callback);
    }
    
    static post(path: string, callback: [typeof Controller, string]) {
        return Router.insert("POST", path, callback);
    }
    
    static put(path: string, callback: [typeof Controller, string]) {
        return Router.insert("PUT", path, callback);
    }
    
    static patch(path: string, callback: [typeof Controller, string]) {
        return Router.insert("PATCH", path, callback);
    }
    
    static delete(path: string, callback: [typeof Controller, string]) {
        return Router.insert("DELETE", path, callback);
    }

    static resource(path: string, controller: typeof Controller, { get = true, post = true, put = true, patch = true, del = true }: { get?: boolean, post?: boolean, put?: boolean, patch?: boolean, del?: boolean } = {}) {
        return {
            get: get ? Router.get(path, [controller, 'index']) : undefined,
            post: post ? Router.post(path, [controller, 'create']) : undefined,
            put: put ? Router.put(path, [controller, 'update']) : undefined,
            patch: patch ? Router.patch(path, [controller, 'update']) : undefined,
            delete: del ? Router.delete(path, [controller, 'delete']) : undefined,
        };
    }
}
1	rakin	323	import { readdir } from "fs/promises";
2			import path from "path";
3			import DiscordClient from "../client/Client";
4			import Service from "../utils/structures/Service";
5			import Controller from "./Controller";
6			import Route from "./Route";
7			import Server from "./Server";
8
9			export interface RouterOptions {
10			routesDir: string;
11			}
12
13			export default class Router extends Service {
14			routesDir: string;
15			controllerObjects: Array <Controller> = [];
16			routes: Route[] = [];
17
18			constructor(client: DiscordClient, protected server: Server, { routesDir }: RouterOptions) {
19			super(client);
20			this.routesDir = routesDir;
21			}
22
23			async loadRoutes() {
24			const files = await readdir(this.routesDir);
25
26			for await (const file of files) {
27			if (!file.endsWith('.ts') && !file.endsWith('.js')) {
28			continue;
29			}
30
31			console.log(`Loading routes from "${file}"...`);
32
33			await import(path.join(this.routesDir, file));
34			}
35			}
36
37			static insert(method: string, path: string, callback: [typeof Controller, string]) {
38			let controller = DiscordClient.client.server.router.controllerObjects.find(c => c instanceof callback[0]);
39
40			if (!controller) {
41			controller = new callback[0]();
42			DiscordClient.client.server.router.controllerObjects.push(controller);
43			console.log("Pushed a controller");
44			}
45
46			const route = new Route(method, path, [controller, callback[1]]);
47			DiscordClient.client.server.router.routes.push(route);
48			return route;
49			}
50
51			static get(path: string, callback: [typeof Controller, string]) {
52			return Router.insert("GET", path, callback);
53			}
54
55			static post(path: string, callback: [typeof Controller, string]) {
56			return Router.insert("POST", path, callback);
57			}
58
59			static put(path: string, callback: [typeof Controller, string]) {
60			return Router.insert("PUT", path, callback);
61			}
62
63			static patch(path: string, callback: [typeof Controller, string]) {
64			return Router.insert("PATCH", path, callback);
65			}
66
67			static delete(path: string, callback: [typeof Controller, string]) {
68			return Router.insert("DELETE", path, callback);
69			}
70	rakin	326
71			static resource(path: string, controller: typeof Controller, { get = true, post = true, put = true, patch = true, del = true }: { get?: boolean, post?: boolean, put?: boolean, patch?: boolean, del?: boolean } = {}) {
72			return {
73			get: get ? Router.get(path, [controller, 'index']) : undefined,
74			post: post ? Router.post(path, [controller, 'create']) : undefined,
75			put: put ? Router.put(path, [controller, 'update']) : undefined,
76			patch: patch ? Router.patch(path, [controller, 'update']) : undefined,
77			delete: del ? Router.delete(path, [controller, 'delete']) : undefined,
78			};
79			}
80	rakin	323	}