error handling and admin settings

Author: Moonded

bun.lockb

@@ -17,6 +17,7 @@
     "@elysiajs/jwt": "^1.2.0",
     "@elysiajs/swagger": "^1.2.2",
     "@prisma/client": "^6.6.0",
+    "discord.js": "^14.19.3",
     "elysia": "latest",
     "elysia-rate-limit": "^4.3.0",
     "octokit": "^4.1.3",

package.json

@@ -0,0 +1,200 @@
+import { Elysia, t } from "elysia";
+import { prisma } from "../utils/prisma";
+import { bearer } from "@elysiajs/bearer";
+import { ValidateAuth } from "src/middleware/auth";
+import { NexusQuery, GithubQuery, errorLog, client as DClient } from "../utils";
+import type { GuildMember, GuildMemberRoleManager } from "discord.js";
+import { Prisma } from "@prisma/client";
+
+export const admin = new Elysia({ prefix: "/admin" }).use(bearer()).guard(
+  {
+    beforeHandle({ set, bearer, error, path }) {
+      return ValidateAuth(set, bearer, error, path, "admin");
+    },
+  },
+  (app) =>
+    app
+      .get("/update/users", async ({ error }) => {
+        try {
+          const allUsers = await prisma.user.findMany();
+
+          if (!allUsers) return error;
+
+          allUsers.map(async (user) => {
+            try {
+              if (JSON.parse(user.Roles as string) == 0) {
+                const DiscordUser = (await DClient.guilds.cache
+                  .find((guild) => {
+                    return guild.id === process.env.GUILD_ID;
+                  })
+                  ?.members.fetch(user.DiscordiD)) as GuildMember;
+
+                const Roles = DiscordUser
+                  ? (DiscordUser.roles as GuildMemberRoleManager).cache.map(
+                      (role) => {
+                        return {
+                          id: role.id,
+                          name: role.name,
+                          position: role.position,
+                          rawPosition: role.rawPosition,
+                          icon: role.icon,
+                          iconUrl: role.iconURL(),
+                        };
+                      }
+                    )
+                  : [];
+
+                //   console.log(Roles);
+
+                const update = await prisma.user.update({
+                  where: {
+                    DiscordiD: user.DiscordiD,
+                  },
+                  data: {
+                    Roles: Roles,
+                  },
+                });
+
+                console.log(update);
+              }
+            } catch (e) {
+              errorLog(e);
+            }
+
+            if (
+              user.Username === null ||
+              user.Avatar === null ||
+              user.Roles === null
+            ) {
+              const DiscordUser = (await DClient.users.fetch(
+                user.DiscordiD
+              )) as any;
+
+              const Roles = DiscordUser.member
+                ? (
+                    DiscordUser.member.roles as GuildMemberRoleManager
+                  ).cache.map((role) => {
+                    return {
+                      id: role.id,
+                      name: role.name,
+                      position: role.position,
+                      rawPosition: role.rawPosition,
+                      icon: role.icon,
+                      iconUrl: role.iconURL(),
+                    };
+                  })
+                : [];
+
+              await prisma.user.update({
+                where: {
+                  DiscordiD: user.DiscordiD,
+                },
+                data: {
+                  Username: DiscordUser.username,
+                  GlobalName: DiscordUser.globalname,
+                  Avatar: DiscordUser.avatar,
+                  Roles: JSON.stringify(Roles),
+                },
+              });
+            }
+
+            if (user.GithubUsername && user.Github !== null) {
+              const Github: any =
+                (await GithubQuery(user.GithubUsername)) ?? undefined;
+
+              await prisma.user.update({
+                where: {
+                  DiscordiD: user.DiscordiD,
+                },
+                data: {
+                  Github: Github,
+                },
+              });
+            }
+
+            if (user.NexusModsUsername && user.NexusMods !== null) {
+              const NexusMods: Record<string, any> | undefined =
+                await NexusQuery(user.NexusModsUsername);
+
+              await prisma.user.update({
+                where: {
+                  DiscordiD: user.DiscordiD,
+                },
+                data: {
+                  NexusMods: NexusMods,
+                },
+              });
+            }
+          });
+
+          return await prisma.user.findMany({
+            orderBy: {
+              GlobalId: "desc",
+            },
+          });
+        } catch (e) {
+          errorLog(e);
+          return error;
+        }
+      })
+      .post(
+        "/import/users",
+        async ({ body, error }) => {
+          try {
+            const NexusMods: Record<string, any> | undefined = await NexusQuery(
+              body.NexusModsUsername
+            );
+
+            const Github: any =
+              (await GithubQuery(body.GithubUsername)) ?? undefined;
+
+            return await prisma.user.upsert({
+              where: {
+                DiscordiD: body.DiscordiD,
+              },
+              update: {
+                Username: body.Username,
+                GlobalName: body.GlobalName,
+                Theme: body.Theme,
+                Style: body.Style,
+                Description: body.Description,
+                GithubUsername: body.GithubUsername,
+                NexusModsUsername: body.NexusModsUsername,
+                NexusMods: NexusMods,
+                Github: Github,
+                Roles: body.Roles ?? [],
+              },
+              create: {
+                Username: body.Username,
+                GlobalName: body.GlobalName,
+                Theme: body.Theme,
+                Style: body.Style,
+                Description: body.Description,
+                DiscordiD: body.DiscordiD,
+                GithubUsername: body.GithubUsername,
+                NexusModsUsername: body.NexusModsUsername,
+                NexusMods: NexusMods,
+                Github: Github,
+                Roles: body.Roles ?? [],
+              },
+            });
+          } catch (e) {
+            errorLog(e);
+            return error;
+          }
+        },
+        {
+          body: t.Object({
+            Username: t.Union([t.String(), t.Null()]),
+            GlobalName: t.Union([t.String(), t.Null()]),
+            DiscordiD: t.String(),
+            Theme: t.String(),
+            Style: t.String(),
+            Description: t.Union([t.String(), t.Null()]),
+            GithubUsername: t.Union([t.String(), t.Null()]),
+            NexusModsUsername: t.Union([t.String(), t.Null()]),
+            Roles: t.Union([t.Array(t.String()), t.Null()]),
+          }),
+        }
+      )
+);

src/api/admin.ts

@@ -50,6 +50,10 @@ export const auth = new Elysia({ prefix: "/auth" }).use(
             },
             update: {
               JWT: JWT,
+              Endpoints:
+                DiscordUser.id === process.env.ADMIN_ID!
+                  ? AdminPermission
+                  : defaultPermission,
             },
             create: {
               DiscordId: DiscordUser.id,

src/api/auth.ts

@@ -1,4 +1,5 @@
 export * from "./bot";
 export * from "./web";
 export * from "./auth";
-export * from "./moderation"
+export * from "./moderation"
+export * from "./admin";

src/api/index.ts

@@ -6,7 +6,6 @@ export const web = new Elysia({ prefix: "/web" })
   .get("/", async ({ error }) => {
     try {
       return await prisma.user.findMany({
-        take: 10,
         orderBy: {
           GlobalId: "desc",
         },

src/api/web.ts

@@ -1,6 +1,6 @@
 import swagger from "@elysiajs/swagger";
 import { Elysia } from "elysia";
-import { bot, web, auth, moderation } from "api";
+import { bot, web, auth, moderation, admin } from "api";
 import { ping, root, profile } from "pages";
 import {
   prisma,
@@ -28,6 +28,7 @@ try {
     .use(cors(CORSConfig))
     .use(rateLimit(rateLimitConfig))
     // .use(profile)
+    .use(admin)
     .use(ping)
     .use(bot)
     .use(web)

src/index.ts

@@ -3,4 +3,5 @@ export * from "./nexusmods"
 export * from "./prisma";
 export * from "./github";
 export * from './config'
-export * from './perms'
+export * from './perms'
+export * from './tempBot'

src/utils/index.ts

@@ -40,4 +40,12 @@ export const AdminPermission = {
       userId: ["GET"],
     },
   },
+  admin: {
+    update: {
+      users: ["GET"],
+    },
+    import: {
+      users: ["POST"],
+    }
+  }
 };

src/utils/perms.ts

@@ -0,0 +1,15 @@
+import { Client, Events, GatewayIntentBits } from "discord.js";
+
+const client = new Client({
+  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMembers, GatewayIntentBits.GuildModeration],
+});
+
+client.once(Events.ClientReady, () => {
+  console.log("Client is ready!");
+});
+
+client.login(process.env.DISCORD_BOT_TOKEN!).catch((err) => {
+  console.error("Failed to login to Discord:", err);
+});
+
+export { client };