src/api/Router.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* 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 { 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);
            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	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2022 OSN Inc.
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 { readdir } from "fs/promises";
21	import path from "path";
22	import DiscordClient from "../client/Client";
23	import Service from "../utils/structures/Service";
24	import Controller from "./Controller";
25	import Route from "./Route";
26	import Server from "./Server";
27
28	export interface RouterOptions {
29	routesDir: string;
30	}
31
32	export default class Router extends Service {
33	routesDir: string;
34	controllerObjects: Array <Controller> = [];
35	routes: Route[] = [];
36
37	constructor(client: DiscordClient, protected server: Server, { routesDir }: RouterOptions) {
38	super(client);
39	this.routesDir = routesDir;
40	}
41
42	async loadRoutes() {
43	const files = await readdir(this.routesDir);
44
45	for await (const file of files) {
46	if (!file.endsWith('.ts') && !file.endsWith('.js')) {
47	continue;
48	}
49
50	console.log(`Loading routes from "${file}"...`);
51
52	await import(path.join(this.routesDir, file));
53	}
54	}
55
56	static insert(method: string, path: string, callback: [typeof Controller, string]) {
57	let controller = DiscordClient.client.server.router.controllerObjects.find(c => c instanceof callback[0]);
58
59	if (!controller) {
60	controller = new callback[0](DiscordClient.client);
61	DiscordClient.client.server.router.controllerObjects.push(controller);
62	console.log("Pushed a controller");
63	}
64
65	const route = new Route(method, path, [controller, callback[1]]);
66	DiscordClient.client.server.router.routes.push(route);
67	return route;
68	}
69
70	static get(path: string, callback: [typeof Controller, string]) {
71	return Router.insert("GET", path, callback);
72	}
73
74	static post(path: string, callback: [typeof Controller, string]) {
75	return Router.insert("POST", path, callback);
76	}
77
78	static put(path: string, callback: [typeof Controller, string]) {
79	return Router.insert("PUT", path, callback);
80	}
81
82	static patch(path: string, callback: [typeof Controller, string]) {
83	return Router.insert("PATCH", path, callback);
84	}
85
86	static delete(path: string, callback: [typeof Controller, string]) {
87	return Router.insert("DELETE", path, callback);
88	}
89
90	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 } = {}) {
91	return {
92	get: get ? Router.get(path, [controller, 'index']) : undefined,
93	post: post ? Router.post(path, [controller, 'create']) : undefined,
94	put: put ? Router.put(path, [controller, 'update']) : undefined,
95	patch: patch ? Router.patch(path, [controller, 'update']) : undefined,
96	delete: del ? Router.delete(path, [controller, 'delete']) : undefined,
97	};
98	}
99	}