Merge pull request #783 from galnir/upgrade-to-v14

Upgrade to v14

Author: galnir

package-lock.json

@@ -30,18 +30,19 @@
   },
   "homepage": "https://github.com/galnir/Master-Bot#readme",
   "dependencies": {
-    "@prisma/client": "^4.8.1",
-    "@trpc/client": "^10.1.0",
-    "@trpc/next": "^10.1.0",
-    "@trpc/react-query": "^10.1.0",
-    "@trpc/server": "^10.1.0",
-    "concurrently": "^7.3.0",
+    "@prisma/client": "^4.12.0",
+    "@trpc/client": "^10.19.1",
+    "@trpc/next": "^10.19.1",
+    "@trpc/react-query": "^10.19.1",
+    "@trpc/server": "^10.19.1",
+    "axios": "^1.3.5",
+    "concurrently": "^8.0.1",
     "cpy-cli": "^4.2.0",
-    "superjson": "^1.9.1",
-    "zod": "^3.18.0"
+    "superjson": "^1.12.2",
+    "zod": "^3.21.4"
   },
   "devDependencies": {
-    "prisma": "^4.8.1",
-    "typescript": "^4.7.4"
+    "prisma": "^4.12.0",
+    "typescript": "^5.0.4"
   }
 }

package.json

@@ -2,7 +2,7 @@
 import * as trpc from '@trpc/server';
 import * as trpcNext from '@trpc/server/adapters/next';
 import { Session } from 'next-auth';
-import { unstable_getServerSession as getServerSession } from 'next-auth';
+import { getServerSession } from 'next-auth';
 import { authOptions as nextAuthOptions } from '../../dashboard/src/pages/api/auth/[...nextauth]';
 import { prisma } from './db/client';
 

packages/api/src/createContext.ts

@@ -26,7 +26,8 @@ export const channelRouter = t.router({
           }
         }
       );
-      const responseChannels: APIGuildChannel<any>[] = await response.json();
+      const responseChannels =
+        (await response.json()) as APIGuildChannel<any>[];
 
       const channels: APIGuildTextChannel<0>[] = responseChannels.filter(
         channel => channel.type === 0

packages/api/src/routers/channel.ts

@@ -82,7 +82,7 @@ export const commandRouter = t.router({
             }
           }
         );
-        const commands: CommandType[] = await response.json();
+        const commands = (await response.json()) as CommandType[];
 
         return { commands };
       } catch (e) {

packages/api/src/routers/command.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { APIGuild, APIRole } from 'discord-api-types/v10';
 import { TRPCError } from '@trpc/server';
 import { getFetch } from '@trpc/client';
+import axiosInstance from '../utils/axiosWithRefresh';
 
 const fetch = getFetch();
 
@@ -50,7 +51,7 @@ export const guildRouter = t.router({
           }
         );
 
-        const guild: APIGuild = await response.json();
+        const guild = (await response.json()) as APIGuild;
 
         return { guild };
       } catch {
@@ -229,25 +230,8 @@ export const guildRouter = t.router({
 
       return { guild };
     }),
-  getAllFromLocal: t.procedure
-    .input(
-      z.object({
-        ownerId: z.string()
-      })
-    )
-    .query(async ({ ctx, input }) => {
-      const { ownerId } = input;
-
-      const guilds = await ctx.prisma.guild.findMany({
-        where: {
-          ownerId: ownerId as string
-        }
-      });
-
-      return { guilds };
-    }),
   getAll: t.procedure.query(async ({ ctx }) => {
-    if (!ctx.session) {
+    if (!ctx.session || !ctx.session.user) {
       throw new TRPCError({
         message: 'Not Authenticated',
         code: 'UNAUTHORIZED'
@@ -258,10 +242,6 @@ export const guildRouter = t.router({
       where: {
         // @ts-ignore
         userId: ctx.session?.user?.id
-      },
-      select: {
-        access_token: true,
-        providerAccountId: true
       }
     });
 
@@ -272,26 +252,33 @@ export const guildRouter = t.router({
       });
     }
 
-    const dbGuilds = await ctx.prisma.guild.findMany({
-      where: {
-        ownerId: account.providerAccountId
-      }
-    });
-
-    // fetch guilds the user is owner in from discord api using the ownerId and token
     try {
-      const response = await fetch(`https://discord.com/api/users/@me/guilds`, {
-        headers: {
-          Authorization: `Bearer ${account.access_token}`
+      const dbGuilds = await ctx.prisma.guild.findMany({
+        where: {
+          ownerId: account.providerAccountId
         }
       });
 
-      const userGuilds: APIGuild[] = await response.json();
-      if (!userGuilds.length) {
-        return { guilds: dbGuilds };
-      }
-      const guildsUserOwns = userGuilds.filter(guild => guild.owner);
-      return { apiGuilds: guildsUserOwns, dbGuilds };
+      const response = await axiosInstance.get(
+        'https://discord.com/api/users/@me/guilds',
+        {
+          headers: {
+            Authorization: `Bearer ${account.access_token}`,
+            // @ts-ignore
+            'X-User-Id': ctx.session.user.id,
+            'X-Refresh-Token': account.refresh_token
+          }
+        }
+      );
+
+      const apiGuilds = response.data as APIGuild[];
+
+      const apiGuildsOwns = apiGuilds.filter(guild => guild.owner);
+
+      return {
+        apiGuilds: apiGuildsOwns,
+        dbGuilds
+      };
     } catch (e) {
       console.error(e);
       throw new TRPCError({
@@ -300,47 +287,6 @@ export const guildRouter = t.router({
       });
     }
   }),
-  getAllFromDiscordAPI: t.procedure.query(async ({ ctx }) => {
-    if (!ctx.session) {
-      throw new TRPCError({
-        message: 'Not Authenticated',
-        code: 'UNAUTHORIZED'
-      });
-    }
-
-    const account = await ctx.prisma.account.findFirst({
-      where: {
-        // @ts-ignore
-        userId: ctx.session?.user?.id
-      },
-      select: {
-        access_token: true,
-        providerAccountId: true,
-        user: {
-          select: {
-            discordId: true
-          }
-        }
-      }
-    });
-
-    if (!account || !account.access_token) {
-      throw new TRPCError({
-        code: 'NOT_FOUND',
-        message: 'Account not found'
-      });
-    }
-
-    const response = await fetch(`https://discord.com/api/users/@me/guilds`, {
-      headers: {
-        Authorization: `Bearer ${account.access_token}`
-      }
-    });
-
-    const userGuilds: APIGuild[] = await response.json();
-
-    return { guilds: userGuilds, discordId: account.user.discordId };
-  }),
   updateTwitchNotifications: t.procedure
     .input(
       z.object({
@@ -397,7 +343,7 @@ export const guildRouter = t.router({
         }
       );
 
-      const roles: APIRole[] = await response.json();
+      const roles = (await response.json()) as APIRole[];
 
       return { roles };
     })

packages/api/src/routers/guild.ts

@@ -33,7 +33,7 @@ export const hubRouter = t.router({
             })
           }
         );
-        parent = await response.json();
+        parent = (await response.json()) as any;
       } catch (e) {
         console.log(e);
         throw new TRPCError({
@@ -59,7 +59,7 @@ export const hubRouter = t.router({
             })
           }
         );
-        hubChannel = await response.json();
+        hubChannel = (await response.json()) as any;
       } catch {
         throw new TRPCError({
           message: 'Could not create channel',

packages/api/src/routers/hub.ts

@@ -0,0 +1,100 @@
+import axios from 'axios';
+import { prisma } from '../db/client';
+const axiosInstance = axios.create();
+
+// Refresh access token if expired and retry the request
+axiosInstance.interceptors.response.use(undefined, async error => {
+  // console.log('error is', error);
+  if (error.response && error.response.status === 401) {
+    const clientId = process.env.DISCORD_CLIENT_ID;
+    const clientSecret = process.env.DISCORD_CLIENT_SECRET;
+
+    if (!clientId || !clientSecret) {
+      return Promise.reject(error);
+    }
+
+    const originalRequest = error.config;
+    const refreshToken = originalRequest.headers['X-Refresh-Token'];
+    const userId = originalRequest.headers['X-User-Id'];
+
+    // Remove the custom headers
+    delete originalRequest.headers['X-Refresh-Token'];
+    delete originalRequest.headers['X-User-Id'];
+
+    // Check if we've already tried to refresh the token for this request
+    if (!originalRequest._retry) {
+      originalRequest._retry = true;
+
+      // Refresh the access token using your refreshAccessToken function
+      const newTokens = await refreshAccessToken(
+        clientId,
+        clientSecret,
+        refreshToken
+      );
+
+      if (newTokens) {
+        // Update the access token and refresh token in your database
+        await prisma.user.update({
+          where: {
+            id: userId
+          },
+          data: {}
+        });
+
+        // Update the access token in the original request's headers
+        originalRequest.headers[
+          'Authorization'
+        ] = `Bearer ${newTokens.accessToken}`;
+
+        // Retry the original request with the new access token
+        return axiosInstance(originalRequest);
+      }
+    }
+  }
+
+  // If the error isn't due to an expired token, pass it along
+  return Promise.reject(error);
+});
+
+async function refreshAccessToken(
+  clientId: string,
+  clientSecret: string,
+  refreshToken: string
+) {
+  try {
+    const response = await axios.post(
+      'https://discord.com/api/oauth2/token',
+      null,
+      {
+        params: {
+          client_id: clientId,
+          client_secret: clientSecret,
+          grant_type: 'refresh_token',
+          refresh_token: refreshToken
+        },
+        headers: {
+          'Content-Type': 'application/x-www-form-urlencoded'
+        }
+      }
+    );
+
+    const {
+      access_token,
+      refresh_token: newRefreshToken,
+      expires_in
+    } = response.data;
+
+    // Update the access and refresh tokens in your database
+
+    return {
+      accessToken: access_token,
+      refreshToken: newRefreshToken,
+      expiresIn: expires_in
+    };
+  } catch (error) {
+    console.error('Error refreshing access token:', error);
+    return null;
+  }
+}
+
+export default axiosInstance;