feat: use unstable_cache everywhere

app/(dashboard)/manage-repos/page.tsx

@@ -31,7 +31,7 @@ export default async function SelectRepoPage() {
         {repos.length > 0 ? (
           <>
             {repos.map((repo) => (
-              <RepoSelector key={repo.id} repo={repo} />
+              <RepoSelector key={repo.id} repo={repo} userId={user.id} />
             ))}
           </>
         ) : (

app/(dashboard)/manage-repos/repoSelector.tsx

@@ -6,12 +6,17 @@ import { TRepository } from "@/types/repository";
 import { useCallback, useEffect, useState } from "react";
 
 import { activateRepoAction, deactivateRepoAction, fetchRepoDetailsAction } from "./actions";
+import { cacheTags, revalidate } from "@/lib/cache";
+import { enrolledRepositoriesCache } from "@/lib/enrollment/cache";
+import { repositoryCache } from "@/lib/repository/cache";
 
 interface RepoSelectorProps {
   repo: TRepository;
+  // required for cache revalidation
+  userId: string
 }
 
-export const RepoSelector: React.FC<RepoSelectorProps> = ({ repo: initialRepo }) => {
+export const RepoSelector: React.FC<RepoSelectorProps> = ({ repo: initialRepo, userId }) => {
   const { toast } = useToast();
   const [repo, setRepo] = useState<TRepository>(initialRepo);
   const [isLoading, setIsLoading] = useState(false);
@@ -57,6 +62,8 @@ export const RepoSelector: React.FC<RepoSelectorProps> = ({ repo: initialRepo })
         });
       }
       await fetchRepoDetails();
+      enrolledRepositoriesCache.revalidate({ userId })
+      repositoryCache.revalidate({})
     } catch (error) {
       console.error("Error changing repository activation status", error);
       toast({

app/[githubLogin]/components/profile-page.tsx

@@ -12,8 +12,7 @@ import ProfileInfoBar from "./profile-info";
 
 export default async function ProfilePage({ githubLogin }: { githubLogin: string }) {
   // Get & enrich the player data
-  const enrichedUserData = await getEnrichedGithubUserData(githubLogin);
-
+  const enrichedUserData = await getEnrichedGithubUserData(githubLogin)
   let pointsAndRanks: Array<{
     id: string;
     repositoryName: string;
@@ -23,16 +22,17 @@ export default async function ProfilePage({ githubLogin }: { githubLogin: string
 
   if (enrichedUserData.enrolledRepositories && enrichedUserData.playerData?.id) {
     try {
+
       const result = await getPointsAndRankPerRepository(
         enrichedUserData.enrolledRepositories,
         enrichedUserData.playerData.id
-      );
+      )
 
       pointsAndRanks = result.map((item) => ({
         ...item,
         repositoryLogo: item.repositoryLogo || undefined,
       }));
-    } catch (error) {}
+    } catch (error) { }
   }
 
   let totalPoints = 0;
@@ -45,13 +45,13 @@ export default async function ProfilePage({ githubLogin }: { githubLogin: string
     chanceOfWinning = result.likelihoodOfWinning;
   }
 
-  const ossGgRepositories = await getAllRepositories();
+  const ossGgRepositories = await getAllRepositories()
 
   let pullRequests = [] as TPullRequest[];
 
   if (enrichedUserData.status.githubUserFound) {
     const ossGgRepositoriesIds = ossGgRepositories.map((repo) => `${repo.owner}/${repo.name}`);
-    pullRequests = await getPullRequestsByGithubLogin(ossGgRepositoriesIds, githubLogin);
+    pullRequests = await getPullRequestsByGithubLogin(ossGgRepositoriesIds, githubLogin)
   }
 
   return (

lib/cache/index.ts

@@ -0,0 +1,7 @@
+import { unstable_cache as cache } from "next/cache"
+
+
+// utility function to cache a function with tags and optional revalidation
+export async function withCache<T>(fn: () => Promise<T>, tags: string[], opts?: { revalidate?: number }): Promise<T> {
+  return cache(fn, tags, { tags, revalidate: opts?.revalidate })()
+}

lib/enrollment/cache.ts

@@ -0,0 +1,18 @@
+import { revalidateTag } from "next/cache";
+
+type RevalidateProps = {
+  userId?: string;
+}
+
+export const enrolledRepositoriesCache = {
+  tags: {
+    byUserId(userId: string) {
+      return [`enrolled-repositories-${userId}`];
+    },
+  },
+  revalidate({ userId }: RevalidateProps): void {
+    if (userId) {
+      revalidateTag(this.tags.byUserId(userId));
+    }
+  },
+};

lib/enrollment/service.ts

@@ -5,7 +5,8 @@ import { TRepository } from "@/types/repository";
 import { Prisma } from "@prisma/client";
 
 import { validateInputs } from "../utils/validate";
-
+import { revalidate, cacheTags, withCache } from "@/lib/cache"
+import { enrolledRepositoriesCache } from "./cache";
 /**
  * Enrolls a user in all repositories.
  * @param userId - The ID of the user to enroll.
@@ -32,6 +33,11 @@ export const enrollUserInAllRepositories = async (userId: string) => {
       data: enrollments,
       skipDuplicates: true,
     });
+
+
+    // we need a username
+    // await revalidate(cacheTags.enrichedProfile(userId))
+
   } catch (error) {
     throw error;
   }
@@ -62,7 +68,6 @@ export const createEnrollment = async (enrollmentData: TEnrollmentInput): Promis
     const enrollment = await db.enrollment.create({
       data: enrollmentData,
     });
-
     return enrollment;
   } catch (error) {
     if (error instanceof Prisma.PrismaClientKnownRequestError) {
@@ -89,6 +94,8 @@ export const deleteEnrollment = async (userId: string, repositoryId: string): Pr
         },
       },
     });
+    await revalidate(cacheTags.enrichedProfile(userId))
+
   } catch (error) {
     if (error instanceof Prisma.PrismaClientKnownRequestError) {
       throw new DatabaseError(error.message);
@@ -121,7 +128,7 @@ export const hasEnrollmentForRepository = async (userId: string, repositoryId: s
  * a repository the user is enrolled in. The array is empty if the user has no enrollments.
  */
 
-export const getEnrolledRepositories = async (userId: string): Promise<TRepository[]> => {
+export const getEnrolledRepositories = async (userId: string): Promise<TRepository[]> => withCache(async () => {
   const enrolledRepositories = await db.repository.findMany({
     where: {
       enrollments: {
@@ -149,4 +156,9 @@ export const getEnrolledRepositories = async (userId: string): Promise<TReposito
   });
 
   return enrolledRepositories;
-};
+},
+  enrolledRepositoriesCache.tags.byUserId(userId),
+  {
+    revalidate: 24 * 60 * 60,
+  }
+)

lib/github/service.ts

@@ -12,7 +12,7 @@ type PullRequestStatus = "open" | "merged" | "closed" | undefined;
 
 const octokit = new Octokit({ auth: GITHUB_APP_ACCESS_TOKEN });
 
-const fetchPullRequestsByGithubLogin = async (
+export const getPullRequestsByGithubLogin = async (
   playerRepositoryIds: string[],
   githubLogin: string,
   status?: PullRequestStatus
@@ -79,11 +79,6 @@ const fetchPullRequestsByGithubLogin = async (
   return pullRequests;
 };
 
-export const getPullRequestsByGithubLogin = unstable_cache(
-  fetchPullRequestsByGithubLogin,
-  ["fetchPullRequestsByGithubLogin"],
-  { revalidate: 60 }
-);
 
 const fetchAllOssGgIssuesOfRepos = async (
   repos: { id: number; fullName: string }[]

lib/github/utils.ts

@@ -7,7 +7,6 @@ import crypto from "node:crypto";
 import { GITHUB_APP_ID, GITHUB_APP_PRIVATE_KEY, OSS_GG_LABEL } from "../constants";
 import { assignUserPoints } from "../points/service";
 import { createUser, getUserByGithubId } from "../user/service";
-
 export const getOctokitInstance = (installationId: number) => {
   if (!installationId) {
     throw new Error("No installation id provided");

lib/githubUser/cache.ts

@@ -1,13 +1,13 @@
 import { revalidateTag } from "next/cache";
 
-interface RevalidateProps {
+type RevalidateProps = {
   githubLogin?: string;
 }
 
 export const githubUserCache = {
-  tag: {
+  tags: {
     byGithubLogin(githubLogin: string) {
-      return `github-users-${githubLogin}`;
+      return [`github-users-${githubLogin}`];
     },
   },
   revalidate({ githubLogin }: RevalidateProps): void {

lib/githubUser/service.ts

@@ -1,13 +1,13 @@
 import { GITHUB_APP_ACCESS_TOKEN } from "@/lib/constants";
-import { TGithubUserData, ZGithubUserData } from "@/types/githubUser";
+import { type TGithubUserData, ZGithubUserData } from "@/types/githubUser";
 // Adjust the import path as needed
 import { Octokit } from "@octokit/rest";
-import { unstable_cache } from "next/cache";
 
 import { githubUserCache } from "./cache";
+import { withCache } from "@/lib/cache";
 
 export const getGithubUserByLogin = (githubLogin: string): Promise<TGithubUserData | false> =>
-  unstable_cache(
+  withCache(
     async () => {
       try {
         const octokit = new Octokit({ auth: `token ${GITHUB_APP_ACCESS_TOKEN}` });
@@ -33,9 +33,8 @@ export const getGithubUserByLogin = (githubLogin: string): Promise<TGithubUserDa
         return false;
       }
     },
-    [`getGithubUserByLogin-${githubLogin}`],
+    githubUserCache.tags.byGithubLogin(githubLogin),
     {
-      tags: [githubUserCache.tag.byGithubLogin(githubLogin)],
-      revalidate: 60 * 60 * 24 * 7, // 1 week
+      revalidate: 7 * 24 * 60 * 60, // 7 days
     }
-  )();
+  )

lib/points/cache.ts

@@ -2,17 +2,49 @@ import { revalidateTag } from "next/cache";
 
 interface RevalidateProps {
   repositoryId?: string;
+  userId?: string;
+
 }
 
 export const pointsCache = {
-  tag: {
-    byRepositoryId(repositoryId: string) {
-      return `repositories-${repositoryId}-points`;
-    },
+  tags: {
+    byRepositoryId: (repositoryId: string, page?: number) => [
+      `points-repositories-${repositoryId}`,
+      `points-repositories-${repositoryId}-page-${page}`
+    ],
+    byPointsForPlayerInRepoByRepositoryId: (userId: string, repositoryId: string) => [
+      `points-user-${userId}`,
+      `points-user-${userId}-repository-${repositoryId}`
+    ],
+    getPointsAndRankPerRepository: (userId: string, repositoryId: string) => [
+      `points-user-${userId}`,
+      `points-user-${userId}-repository-${repositoryId}`
+    ],
+    rankByPlayerId: (userId: string) => [
+      `points-user-${userId}-rank`
+    ],
+
   },
-  revalidate({ repositoryId }: RevalidateProps): void {
+  revalidate({ repositoryId, userId }: RevalidateProps): void {
+    const tags = new Set<string>()
     if (repositoryId) {
-      revalidateTag(this.tag.byRepositoryId(repositoryId));
+      for (const tag of this.tags.byRepositoryId(repositoryId)) {
+        tags.add(tag);
+      }
+    }
+    if (userId) {
+      for (const tag of this.tags.rankByPlayerId(userId)) {
+        tags.add(tag);
+      }
     }
+    if (repositoryId && userId) {
+      for (const tag of this.tags.byPlayerAndRepositoryId(userId, repositoryId)) {
+        tags.add(tag);
+      }
+      for (const tag of this.tags.getPointsAndRankPerRepository(userId, repositoryId)) {
+        tags.add(tag);
+      }
+    }
+    tags.forEach((tag) => revalidateTag(tag))
   },
-};
+}