fix(fetch): add cache: 'no-store' to avoid errors

src/app/api/[...id]/route.ts

@@ -6,80 +6,80 @@ import { NextRequest } from "next/server";
 export const dynamic = "force-dynamic";
 
 export async function GET(
-  req: NextRequest,
+    req: NextRequest,
-  options: { params: { id: string[] } },
+    options: { params: { id: string[] } },
 ) {
-  const userId = options.params.id.join("/");
+    const userId = options.params.id.join("/");
 
-  if (!userId)
+    if (!userId)
-    return Response.json(
+        return Response.json(
-      {
+            {
-        data: {
+                data: {
-          error: "No ID provided.",
+                    error: "No ID provided.",
-        },
+                },
-        success: false,
+                success: false,
-      },
+            },
-      {
+            {
-        status: 400,
+                status: 400,
-      },
+            },
-    );
+        );
 
-  if (!isSnowflake(userId))
+    if (!isSnowflake(userId))
-    return Response.json(
+        return Response.json(
-      {
+            {
-        data: {
+                data: {
-          error: "The ID you provide is not a valid snowflake.",
+                    error: "The ID you provide is not a valid snowflake.",
-        },
+                },
-        success: false,
+                success: false,
-      },
+            },
-      {
+            {
-        status: 400,
+                status: 400,
-      },
+            },
-    );
+        );
 
-  let getUser: any = {};
+    let getUser: any = {};
 
-  getUser.data = await fetch(
+    getUser.data = await fetch(`https://api.lanyard.rest/v1/users/${userId}`, {
-    `https://api.lanyard.rest/v1/users/${userId}`,
+        cache: "no-store",
-  ).then(async (res) => {
+    }).then(async (res) => {
-    const data = await res.json();
+        const data = await res.json();
 
-    if (!data.success) {
+        if (!data.success) {
-      getUser.error = data.error;
+            getUser.error = data.error;
+        }
+
+        return data;
+    });
+
+    if (getUser.error) {
+        return Response.json(
+            {
+                data: getUser.error,
+                success: false,
+            },
+            {
+                status: 400,
+            },
+        );
     }
 
-    return data;
+    const params: Parameters = Object.fromEntries(
-  });
+        req.nextUrl.searchParams.entries(),
-
-  if (getUser.error) {
-    return Response.json(
-      {
-        data: getUser.error,
-        success: false,
-      },
-      {
-        status: 400,
-      },
     );
-  }
 
-  const params: Parameters = Object.fromEntries(
+    try {
-    req.nextUrl.searchParams.entries(),
+        let user = await redis.hget("users", userId);
-  );
+        if (!user) await redis.hset("users", userId, "true");
+    } catch {
+        null;
+    }
 
-  try {
+    return new Response(await renderCard(getUser.data, params), {
-    let user = await redis.hget("users", userId);
+        headers: {
-    if (!user) await redis.hset("users", userId, "true");
+            "Content-Type": "image/svg+xml; charset=utf-8",
-  } catch {
+            "content-security-policy":
-    null;
+                "default-src 'none'; img-src * data:; style-src 'unsafe-inline'",
-  }
+        },
-
+        status: 200,
-  return new Response(await renderCard(getUser.data, params), {
+    });
-    headers: {
-      "Content-Type": "image/svg+xml; charset=utf-8",
-      "content-security-policy":
-        "default-src 'none'; img-src * data:; style-src 'unsafe-inline'",
-    },
-    status: 200,
-  });
 }

src/utils/actions.ts

@@ -9,9 +9,9 @@ export async function getUserCount() {
 }
 
 export async function isUserMonitored(userId: string) {
-    const user = await fetch(
+    const user = await fetch(`https://api.lanyard.rest/v1/users/${userId}`, {
-        `https://api.lanyard.rest/v1/users/${userId}`,
+        cache: "no-store",
-    ).then((res) => res.json());
+    }).then((res) => res.json());
 
     return user.success === true;
 }

src/utils/toBase64.ts

@@ -2,7 +2,9 @@ export const encodeBase64 = async (url: string): Promise<string> => {
     let response = "";
 
     try {
-        response = await fetch(url)
+        response = await fetch(url, {
+            cache: "no-store",
+        })
             .then((res) => res.blob())
             .then(async (blob) => {
                 const buffer = Buffer.from(await blob.arrayBuffer());