rhythia-api 216.0.0 → 225.0.0

package/utils/activityStatus.ts

@@ -0,0 +1,36 @@
+import { supabase } from "./supabase";
+
+export const INACTIVITY_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
+
+export type ActivityStatus = "active" | "inactive";
+
+export function getScoreActivityCutoffIso(now = Date.now()) {
+  return new Date(now - INACTIVITY_WINDOW_MS).toISOString();
+}
+
+export async function getActivityStatusForUserId(userId: number) {
+  const cutoffIso = getScoreActivityCutoffIso();
+  const { data } = await supabase
+    .from("scores")
+    .select("id")
+    .eq("userId", userId)
+    .gte("created_at", cutoffIso)
+    .limit(1);
+
+  return data?.length ? ("active" as const) : ("inactive" as const);
+}
+
+export async function getActiveProfileIdSet(profileIds: number[]) {
+  if (!profileIds.length) return new Set<number>();
+
+  const cutoffIso = getScoreActivityCutoffIso();
+  const { data } = await supabase
+    .from("profiles")
+    .select("id,scores!inner(id)")
+    .in("id", profileIds)
+    .gte("scores.created_at", cutoffIso)
+    .limit(1, { foreignTable: "scores" });
+
+  return new Set((data || []).map((row) => row.id));
+}
+

package/utils/cache.ts

@@ -0,0 +1,60 @@
+import { supabase } from "./supabase";
+
+const CACHE_TABLE = "cache";
+
+type CacheKey = string | number;
+
+const normalizeKey = (key: CacheKey) => String(key);
+
+export async function getCacheValue<T = unknown>(
+  key: CacheKey
+): Promise<T | null> {
+  const { data, error } = await supabase
+    .from(CACHE_TABLE)
+    .select("value")
+    .eq("key", normalizeKey(key))
+    .maybeSingle();
+
+  if (error) {
+    console.error("getCacheValue error", error);
+    return null;
+  }
+
+  return (data?.value as T) ?? null;
+}
+
+export async function setCacheValue<T = unknown>(
+  key: CacheKey,
+  value: T
+): Promise<void> {
+  const { error } = await supabase
+    .from(CACHE_TABLE)
+    .upsert({ key: normalizeKey(key), value } as any);
+
+  if (error) {
+    console.error("setCacheValue error", error);
+  }
+}
+
+export async function invalidateCache(key: CacheKey): Promise<void> {
+  const { error } = await supabase
+    .from(CACHE_TABLE)
+    .delete()
+    .eq("key", normalizeKey(key));
+
+  if (error) {
+    console.error("invalidateCache error", error);
+  }
+}
+
+export async function invalidateCachePrefix(prefix: CacheKey): Promise<void> {
+  const normalizedPrefix = normalizeKey(prefix);
+  const { error } = await supabase
+    .from(CACHE_TABLE)
+    .delete()
+    .like("key", `${normalizedPrefix}%`);
+
+  if (error) {
+    console.error("invalidateCachePrefix error", error);
+  }
+}

package/utils/leaderboardCache.ts

@@ -0,0 +1,8 @@
+import { setCacheValue } from "./cache";
+
+export const LEADERBOARD_CACHE_INVALIDATE_KEY = "leaderboard:invalidateAt";
+
+export async function invalidateLeaderboardCache() {
+  await setCacheValue(LEADERBOARD_CACHE_INVALIDATE_KEY, Date.now());
+}
+

package/utils/requestUtils.ts

@@ -5,7 +5,7 @@ import { supabase } from "./supabase";
 
 interface Props<
   K = (...args: any[]) => Promise<NextResponse<any>>,
-  T = ZodObject<any>
+  T = ZodObject<any>,
 > {
   request: Request;
   schema: { input: T; output: T };
@@ -49,6 +49,7 @@ export async function protectedApi({
     }
     return await activity(data, request);
   } catch (error) {
+    console.log(`Couldn't parse`, error.toString());
     return NextResponse.json({ error: error.toString() }, { status: 400 });
   }
 }