@mathisalarcon/discord-bot-dashboard-api 1.0.0

package/src/index.ts

@@ -0,0 +1,143 @@
+import { Client } from "discord.js";
+import "dotenv/config";
+import express, { Router } from "express";
+import path from "path";
+import fs from "fs";
+
+var PORT: number = process.env.PORT ? parseInt(process.env.PORT) : 3000;
+
+type Options = {
+	client: Client;
+	secret: string;
+}
+export default async function ({ client, secret }: Options): Promise<void> {
+	const app = express().use(express.json());
+	app.set("secret", secret);
+	const apiRouter = Router();
+	app.use("/api", apiRouter);
+	await loadBaseMiddleware(apiRouter, client);
+	await loadRoutes(apiRouter, client);
+	await startServer(app);
+	app.bot = client;
+}
+
+async function startServer(app: express.Express): Promise<void> {
+    return new Promise<void>((resolve) => {
+            app.listen(PORT, () => {
+				console.log(`Server is running on port ${PORT}`);
+				resolve();
+			}).on("error", (err: any) => {
+				console.log(
+					`Failed to start server on port ${PORT}, retrying on port ${++PORT}.\nFor production, set the PORT environment variable to a fixed port.`
+				);
+				startServer(app).then(() => resolve());
+			});
+	});
+}
+async function loadRoutes(
+	app: Router,
+	client: Client,
+	dir = path.join(__dirname, "routes")
+): Promise<void> {
+    const files = fs.readdirSync(dir).reverse();
+	for (const file of files) {
+		const dirname = path.join(dir, file);
+		if (fs.statSync(dirname).isDirectory()) {
+			// Make router base on the route;
+			const router = Router({ mergeParams: true });
+			// Check if it is a param or normal route
+			// Make the [...] regex
+			const route =
+				file.startsWith("[") && file.endsWith("]")
+					? `:${file.slice(1, -1)}`
+                    : file;
+            
+            console.log(`Loading route: /${route}`);
+			// check if subfolder has route or middlewares (js or ts files)
+			const subFiles = fs.readdirSync(dirname);
+			if (
+				subFiles
+					.map((f) => f.replace(/\.ts|\.js/, ""))
+					.includes("middleware")
+			) {
+				const middlewareModule: MiddlewareModule = await import(
+					path.join(
+						dirname,
+						subFiles.find(
+							(f) => f.replace(/\.ts|\.js/, "") === "middleware"
+						) as string
+					)
+				);
+
+				/* require(path.join(
+					dirname,
+					subFiles.find((f) =>
+						f.replace(/\.ts|\.js/, "").includes("middleware")
+					) as string
+				)); */
+				router.use((req, res, next) =>
+					middlewareModule.default(req, res, next, client)
+				);
+			}
+			if (
+				subFiles
+					.map((f) => f.replace(/\.ts|\.js/, ""))
+					.includes("route")
+			) {
+				const routerModule: RouteModule = await import(
+					path.join(
+						dirname,
+						subFiles.find(
+							(f) => f.replace(/\.ts|\.js/, "") === "route"
+						) as string
+					)
+				);
+				router.all(`/`, (req, res) => {
+					const method = req.method.toUpperCase();
+					switch (method) {
+						case "GET":
+							return routerModule.GET(req, res, client);
+						case "POST":
+							if (routerModule.POST)
+								return routerModule.POST(req, res, client);
+							break;
+						case "PUT":
+							if (routerModule.PUT) return routerModule.PUT(req, res, client);
+							break;
+						case "DELETE":
+							if (routerModule.DELETE)
+								return routerModule.DELETE(req, res, client);
+							break;
+					}
+					res.status(405).send({ error: "Method Not Allowed" });
+				});
+			}
+			// Recursive load routes
+			app.use(`/${route}`, router);
+			await loadRoutes(router, client, dirname);
+		}
+	}
+}
+async function loadBaseMiddleware(app: Router, client: Client): Promise<void> {
+	const middlewareModule: MiddlewareModule = await import(
+		path.join(__dirname, "routes", `middleware`)
+	);
+	app.use((req, res, next) =>
+		middlewareModule.default(req, res, next, client)
+	);
+}
+
+type RouteModule = {
+	GET(req: express.Request, res: express.Response, client: Client): unknown;
+	POST?(req: express.Request, res: express.Response, client: Client): unknown;
+	PUT?(req: express.Request, res: express.Response, client: Client): unknown;
+	DELETE?(req: express.Request, res: express.Response, client: Client): unknown;
+};
+type MiddlewareModule = {
+	default(
+		req: express.Request,
+		res: express.Response,
+		next: express.NextFunction,
+		client: Client
+	): unknown;
+};

package/src/routes/guilds/[guildId]/members/[memberId]/permissions/route.ts

@@ -0,0 +1,26 @@
+import express from "express";
+import { Client } from "discord.js";
+import { Params } from "../route";
+
+export async function GET(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const { guildId, memberId } = req.params as Params;
+
+	try {
+		const guild = await client.guilds.fetch(guildId).catch(() => null);
+		if (!guild) return res.status(404).json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+		const member = await guild.members
+			.fetch({
+				user: memberId,
+			})
+			.catch(() => null);
+		if (!member) return res.status(404).json({ error: "Member not found", code: "MEMBER_NOT_FOUND" });
+
+		return res.status(200).json(member.permissions.toArray());
+	} catch (error) {
+		return res.status(500).json({ error: "Internal Server Error", code: "INTERNAL_SERVER_ERROR" });
+	}
+}

package/src/routes/guilds/[guildId]/members/[memberId]/roles/[roleId]/route.ts

@@ -0,0 +1,163 @@
+import express from "express";
+import { Client } from "discord.js";
+import { Params as SubParams } from "../../route";
+
+export type Params = SubParams & {
+	roleId: string;
+};
+
+export async function GET(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const { guildId, memberId, roleId } = req.params as Params;
+
+	try {
+		const guild = await client.guilds.fetch(guildId).catch(() => null);
+		if (!guild)
+			return res
+				.status(404)
+				.json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+
+		const member = await guild.members
+			.fetch({
+				user: memberId,
+			})
+			.catch(() => null);
+		if (!member)
+			return res
+				.status(404)
+				.json({ error: "Member not found", code: "MEMBER_NOT_FOUND" });
+
+		const role = await guild.roles.fetch(roleId).catch(() => null);
+		if (!role)
+			return res
+				.status(404)
+				.json({ error: "Role not found", code: "ROLE_NOT_FOUND" });
+
+		return res.status(200).json(role.toJSON());
+	} catch (error) {
+		return res.status(500).json({
+			error: "Internal Server Error",
+			code: "INTERNAL_SERVER_ERROR",
+		});
+	}
+}
+export async function POST(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const { guildId, memberId, roleId } = req.params as Params;
+
+	try {
+		const guild = await client.guilds.fetch(guildId).catch(() => null);
+		if (!guild) return res.status(404).json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+
+		const member = await guild.members
+			.fetch({
+				user: memberId,
+			})
+			.catch(() => null);
+		if (!member) return res.status(404).json({ error: "Member not found", code: "MEMBER_NOT_FOUND" });
+
+		const role = await guild.roles.fetch(roleId).catch(() => null);
+		if (!role) return res.status(404).json({ error: "Role not found", code: "ROLE_NOT_FOUND" });
+
+		// Check if bot has permission to manage roles
+		if (!guild.members.me)
+			return res.status(500).json({
+				error: "Bot member not found in guild",
+				code: "BOT_MEMBER_NOT_FOUND",
+			});
+		if (!guild.members.me.permissions.has("ManageRoles"))
+			return res.status(403).json({
+				error: "Bot lacks Manage Roles permission",
+				code: "BOT_MISSING_PERMISSIONS",
+			});
+		// Check if the bot's highest role is higher than the role to be assigned
+		if (guild.members.me.roles.highest.position <= role.position)
+			return res.status(403).json({
+				error: "Bot's highest role is not higher than the role to be assigned",
+				code: "BOT_ROLE_HIERARCHY",
+			});
+		
+		if(member.roles.cache.has(role.id)) return res.status(400).json({ error: "Member already has the role", code: "ALREADY_EXISTS" });
+
+		await member.roles.add(role);
+
+		return res.status(200).json({ message: "Role assigned successfully" });
+	} catch (error) {
+		return res.status(500).json({
+			error: "Internal Server Error",
+			code: "INTERNAL_SERVER_ERROR",
+		});
+	}
+}
+export async function DELETE(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const { guildId, memberId, roleId } = req.params as Params;
+
+	try {
+		const guild = await client.guilds.fetch(guildId).catch(() => null);
+		if (!guild)
+			return res
+				.status(404)
+				.json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+
+		const member = await guild.members
+			.fetch({
+				user: memberId,
+			})
+			.catch(() => null);
+		if (!member)
+			return res
+				.status(404)
+				.json({ error: "Member not found", code: "MEMBER_NOT_FOUND" });
+
+		const role = await guild.roles.fetch(roleId).catch(() => null);
+		if (!role)
+			return res
+				.status(404)
+				.json({ error: "Role not found", code: "ROLE_NOT_FOUND" });
+
+		// Check if bot has permission to manage roles
+		if (!guild.members.me)
+			return res.status(500).json({
+				error: "Bot member not found in guild",
+				code: "BOT_MEMBER_NOT_FOUND",
+			});
+		if (!guild.members.me.permissions.has("ManageRoles"))
+			return res.status(403).json({
+				error: "Bot lacks Manage Roles permission",
+				code: "BOT_MISSING_PERMISSIONS",
+			});
+		// Check if the bot's highest role is higher than the role to be assigned
+		if (guild.members.me.roles.highest.position <= role.position)
+			return res.status(403).json({
+				error: "Bot's highest role is not higher than the role to be assigned",
+				code: "BOT_ROLE_HIERARCHY",
+			});
+
+		if (!member.roles.cache.has(role.id))
+			return res
+				.status(400)
+				.json({
+					error: "Member does not have the role",
+					code: "ALREADY_EXISTS",
+				});
+
+		await member.roles.remove(role);
+
+		return res.status(200).json({ message: "Role removed successfully" });
+	} catch (error) {
+		return res.status(500).json({
+			error: "Internal Server Error",
+			code: "INTERNAL_SERVER_ERROR",
+		});
+	}
+}

package/src/routes/guilds/[guildId]/members/[memberId]/roles/route.ts

@@ -0,0 +1,29 @@
+import express from "express";
+import { Client } from "discord.js";
+import { Params } from "../route";
+
+export async function GET(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const { guildId, memberId } = req.params as Params;
+
+	try {
+		const guild = await client.guilds.fetch(guildId).catch(() => null);
+		if (!guild) return res.status(404).json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+
+		const member = await guild.members
+			.fetch({
+				user: memberId,
+			})
+			.catch(() => null);
+		if (!member) return res.status(404).json({ error: "Member not found", code: "MEMBER_NOT_FOUND" });
+
+		return res
+			.status(200)
+			.json(member.roles.cache.map((role) => role.toJSON()));
+	} catch (error) {
+		return res.status(500).json({ error: "Internal Server Error", code: "INTERNAL_SERVER_ERROR" });
+	}
+}

package/src/routes/guilds/[guildId]/members/[memberId]/route.ts

@@ -0,0 +1,29 @@
+import express from "express";
+import { Client } from "discord.js";
+import { Params as SubParams } from "../../route";
+
+export type Params = SubParams & {
+	memberId: string;
+};
+
+export async function GET(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const { guildId, memberId } = req.params as Params;
+
+	try {
+		const guild = await client.guilds.fetch(guildId).catch(() => null);
+		if (!guild) return res.status(404).json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+		const member = await guild.members
+			.fetch({
+				user: memberId,
+			})
+			.catch(() => null);
+		if (!member) return res.status(404).json({ error: "Member not found", code: "MEMBER_NOT_FOUND" });
+		return res.status(200).json(member.toJSON());
+	} catch (error) {
+		return res.status(500).json({ error: "Internal Server Error", code: "INTERNAL_SERVER_ERROR" });
+	}
+}

package/src/routes/guilds/[guildId]/members/route.ts

@@ -0,0 +1,32 @@
+import express from "express";
+import { Client } from "discord.js";
+import { Params } from "../route";
+
+export async function GET(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const { guildId } = req.params as Params;
+	const limit = req.query.limit ? Number(req.query.limit) : 50;
+	const after = req.query.after ? req.query.after : null;
+
+	try {
+		const guild = await client.guilds.fetch(guildId).catch(() => null);
+		if (!guild) return res.status(404).json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+
+		const members = await guild.members.fetch();
+		let membersArray = Array.from(members.values());
+
+		let startIndex = after
+			? membersArray.findIndex((m) => m.id === after) + 1
+			: 0;
+		let paginatedMembers = membersArray.slice(
+			startIndex,
+			startIndex + limit
+		);
+		return res.status(200).json(paginatedMembers);
+	} catch (error) {
+		return res.status(500).json({ error: "Internal Server Error", code: "INTERNAL_SERVER_ERROR" });
+	}
+}

package/src/routes/guilds/[guildId]/roles/[roleId]/members/route.ts

@@ -0,0 +1,25 @@
+import express from "express";
+import { Client } from "discord.js";
+import { Params } from "../route";
+
+export async function GET(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const { guildId, roleId } = req.params as Params;
+
+	try {
+		const guild = await client.guilds.fetch(guildId).catch(() => null);
+		if (!guild) return res.status(404).json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+
+		const role = await guild.roles.fetch(roleId).catch(() => null);
+		if (!role) return res.status(404).json({ error: "Role not found", code: "ROLE_NOT_FOUND" });
+
+		return res
+			.status(200)
+			.json(role.members.map((member) => member.toJSON()));
+	} catch (error) {
+		return res.status(500).json({ error: "Internal Server Error", code: "INTERNAL_SERVER_ERROR" });
+	}
+}

package/src/routes/guilds/[guildId]/roles/[roleId]/route.ts

@@ -0,0 +1,27 @@
+import express from "express";
+import { Client } from "discord.js";
+import { Params as SubParams } from "../../route";
+
+export type Params = SubParams & {
+    roleId: string;
+};
+
+export async function GET(
+    req: express.Request,
+    res: express.Response,
+    client: Client
+) {
+    const { guildId, roleId } = req.params as Params;
+    
+    try {
+        const guild = await client.guilds.fetch(guildId).catch(() => null);
+        if (!guild) return res.status(404).json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+
+        const role = await guild.roles.fetch(roleId).catch(() => null);
+        if (!role) return res.status(404).json({ error: "Role not found", code: "ROLE_NOT_FOUND" });
+
+        return res.status(200).json(role.toJSON());
+    } catch (error) {
+        return res.status(500).json({ error: "Internal Server Error", code: "INTERNAL_SERVER_ERROR" });
+    }
+}

package/src/routes/guilds/[guildId]/roles/route.ts

@@ -0,0 +1,22 @@
+import express from "express";
+import { Client } from "discord.js";
+import { Params } from "../route";
+
+export async function GET(
+    req: express.Request,
+    res: express.Response,
+    client: Client
+) {
+    const { guildId } = req.params as Params;
+    
+    try {
+        const guild = await client.guilds.fetch(guildId).catch(() => null);
+        if (!guild) return res.status(404).json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+
+        const roles = await guild.roles.fetch();
+        const rolesJSON = Array.from(roles.values()).map(role => role.toJSON());
+        return res.status(200).json(rolesJSON);
+    } catch (error) {
+        return res.status(500).json({ error: "Internal Server Error", code: "INTERNAL_SERVER_ERROR" });
+    }
+}

package/src/routes/guilds/[guildId]/route.ts

@@ -0,0 +1,23 @@
+import express from "express";
+import { Client } from "discord.js";
+
+export type Params = {
+	guildId: string;
+};
+
+export async function GET(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const { guildId } = req.params as Params;
+
+	try {
+		const guild = await client.guilds.fetch(guildId).catch(() => null);
+		if (!guild) return res.status(404).json({ error: "Guild not found", code: "GUILD_NOT_FOUND" });
+
+		return res.status(200).json(guild.toJSON());
+	} catch (error) {
+		return res.status(500).json({ error: "Internal Server Error", code: "INTERNAL_SERVER_ERROR" });
+	}
+}

package/src/routes/guilds/route.ts

@@ -0,0 +1,28 @@
+import express from "express";
+import { Client } from "discord.js";
+
+export async function GET(
+	req: express.Request,
+	res: express.Response,
+	client: Client
+) {
+	const limit = req.query.limit ? Number(req.query.limit) : 50;
+	const after = req.query.after ? req.query.after : null;
+
+	try {
+		const guilds = Array.from(
+			await client.guilds.fetch().then((g) => g.values())
+		);
+
+		const startIndex = after
+			? guilds.findIndex((g) => g.id === after) + 1
+			: 0;
+		const paginatedGuilds = guilds.slice(startIndex, startIndex + limit);
+
+		const guildsJSON = paginatedGuilds.map((guild) => guild.toJSON());
+
+		return res.status(200).json(guildsJSON);
+	} catch (error) {
+		return res.status(500).json({ error: "Internal Server Error", code: "INTERNAL_SERVER_ERROR" });
+	}
+}

package/src/routes/middleware.ts

@@ -0,0 +1,14 @@
+import { Client } from "discord.js";
+
+export default async function (req: any, res: any, next: any, client: Client) {
+	// Check if bot token is provided
+	if (!req.headers["authorization"])
+		return res
+			.status(401)
+			.send({ error: "Unauthorized", code: "UNAUTHORIZED" });
+
+	if (req.headers["authorization"] !== req.app.get("secret"))
+		return res.status(403).send({ error: "Forbidden", code: "FORBIDDEN" });
+
+	next();
+}

package/src/types/express.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "discord.js";
+
+declare global {
+	namespace Express {
+		interface Application {
+			bot: Client;
+		}
+	}
+}
+
+export {};

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compileOnSave": true,
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es5",
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "esModuleInterop": true,
+        "declaration": true,
+        "strict": true,
+        "skipLibCheck": true
+    },
+    "include": ["src", "src/.test.ts"],
+    "exclude": ["node_modules"]
+}