Merge pull request #75 from r4topunk/perf/feed-single-query

perf(feed): unified feedEvents query (5 queries → 1)

Author: r4topunk

src/app/api/members/route.ts

@@ -1,12 +1,11 @@
-import { NextResponse } from "next/server";
 import { unstable_cache } from "next/cache";
+import { NextResponse } from "next/server";
 import { fetchFarcasterProfilesByAddress } from "@/services/farcaster";
 import {
   fetchActiveVotesForVoters,
   fetchAllMembers,
   fetchNonCanceledProposalsCount,
-  fetchVotesCountForVoters,
-  fetchVoteSupportForVoters,
+  fetchVoterActivity,
   type MemberListItem,
 } from "@/services/members";
 
@@ -19,24 +18,22 @@ const getCachedMembers = unstable_cache(
   async (): Promise<MemberListItem[]> => {
     const members = await fetchAllMembers();
     const owners = members.map((m) => m.owner);
-    const [
-      votesCountResult,
-      activeVotesResult,
-      nonCanceledResult,
-      voteSupportResult,
-      farcasterResult,
-    ] = await Promise.allSettled([
-      fetchVotesCountForVoters(owners),
-      fetchActiveVotesForVoters(owners),
-      fetchNonCanceledProposalsCount(),
-      fetchVoteSupportForVoters(owners),
-      fetchFarcasterProfilesByAddress(owners),
-    ]);
+    const [voterActivityResult, activeVotesResult, nonCanceledResult, farcasterResult] =
+      await Promise.allSettled([
+        fetchVoterActivity(owners),
+        fetchActiveVotesForVoters(owners),
+        fetchNonCanceledProposalsCount(),
+        fetchFarcasterProfilesByAddress(owners),
+      ]);
 
-    const votesCountMap = votesCountResult.status === "fulfilled" ? votesCountResult.value : {};
+    const voterActivity =
+      voterActivityResult.status === "fulfilled"
+        ? voterActivityResult.value
+        : { counts: {}, support: {} };
+    const votesCountMap = voterActivity.counts;
+    const voteSupportMap = voterActivity.support;
     const activeVotesMap = activeVotesResult.status === "fulfilled" ? activeVotesResult.value : {};
     const nonCanceledCount = nonCanceledResult.status === "fulfilled" ? nonCanceledResult.value : 0;
-    const voteSupportMap = voteSupportResult.status === "fulfilled" ? voteSupportResult.value : {};
     const farcasterProfiles = farcasterResult.status === "fulfilled" ? farcasterResult.value : {};
 
     return members.map((m) => {

src/app/api/proposals/per-month/route.ts

@@ -1,6 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
-import { SubgraphSDK } from "@buildeross/sdk";
-import { CHAIN, DAO_ADDRESSES } from "@/lib/config";
+import { DAO_ADDRESSES } from "@/lib/config";
+import { subgraphQuery } from "@/lib/subgraph";
 
 export const dynamic = "force-dynamic";
 export const revalidate = 300; // 5 minutes
@@ -9,6 +9,22 @@ export const revalidate = 300; // 5 minutes
 let cache: { proposals: number[]; timestamp: number } | null = null;
 const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 
+// Minimal query: only `timeCreated` — previous SDK call pulled full
+// proposal payload (description, calldatas, votes) per entry just to
+// bucket by month.
+const PROPOSAL_TIMESTAMPS_QUERY = `
+  query ProposalTimestamps($dao: String!, $first: Int!) {
+    proposals(
+      where: { dao: $dao }
+      first: $first
+      orderBy: timeCreated
+      orderDirection: desc
+    ) {
+      timeCreated
+    }
+  }
+`;
+
 export async function GET(request: NextRequest) {
   try {
     const months = parseInt(request.nextUrl.searchParams.get("months") || "12", 10);
@@ -22,14 +38,14 @@ export async function GET(request: NextRequest) {
       });
     }
 
-    // Fetch from subgraph (no RPC calls)
-    const result = await SubgraphSDK.connect(CHAIN.id).proposals({
-      where: { dao: DAO_ADDRESSES.token.toLowerCase() },
+    const { proposals: rows } = await subgraphQuery<{
+      proposals: Array<{ timeCreated: string }>;
+    }>(PROPOSAL_TIMESTAMPS_QUERY, {
+      dao: DAO_ADDRESSES.token.toLowerCase(),
       first: 500,
-      skip: 0,
     });
 
-    const proposals = (result.proposals || []).map((p) => Number(p.timeCreated ?? 0));
+    const proposals = (rows || []).map((p) => Number(p.timeCreated ?? 0));
 
     // Update cache
     cache = { proposals, timestamp: now };
@@ -67,4 +83,3 @@ function groupByMonth(timestamps: number[], months: number) {
 
   return result;
 }
-

src/services/dao.ts

@@ -7,54 +7,57 @@ export type DaoStats = {
   ownerCount: number;
 };
 
-type DaoQuery = {
+export type DaoOverview = DaoStats & {
+  totalAuctionSalesWei: bigint;
+};
+
+type DaoOverviewQuery = {
   dao: {
     id: string;
     totalSupply: number;
     ownerCount: number;
+    totalAuctionSales: string | null;
   } | null;
 };
 
-const DAO_GQL = /* GraphQL */ `
-  query Dao($id: ID!) {
+// Single query covering every `dao(id)` read currently scattered across
+// fetchDaoStats + fetchTotalAuctionSalesWei. React `cache()` dedupes
+// within a request so callers still see per-request memoization.
+const DAO_OVERVIEW_GQL = /* GraphQL */ `
+  query DaoOverview($id: ID!) {
     dao(id: $id) {
       id
       totalSupply
       ownerCount
+      totalAuctionSales
     }
   }
 `;
 
-export const fetchDaoStats = cache(async (): Promise<DaoStats> => {
+function safeBigInt(value: string | null | undefined): bigint {
+  try {
+    return BigInt(value ?? "0");
+  } catch {
+    return BigInt(0);
+  }
+}
+
+export const fetchDaoOverview = cache(async (): Promise<DaoOverview> => {
   const id = DAO_ADDRESSES.token.toLowerCase();
-  const data = await subgraphQuery<DaoQuery>(DAO_GQL, { id });
+  const data = await subgraphQuery<DaoOverviewQuery>(DAO_OVERVIEW_GQL, { id });
   return {
     totalSupply: Number(data.dao?.totalSupply ?? 0),
     ownerCount: Number(data.dao?.ownerCount ?? 0),
+    totalAuctionSalesWei: safeBigInt(data.dao?.totalAuctionSales),
   };
 });
 
-type DaoSalesQuery = {
-  dao: {
-    totalAuctionSales: string;
-  } | null;
-};
-
-const DAO_TOTAL_AUCTION_SALES_GQL = /* GraphQL */ `
-  query TotalAuctionSales($id: ID!) {
-    dao(id: $id) {
-      totalAuctionSales
-    }
-  }
-`;
+export const fetchDaoStats = cache(async (): Promise<DaoStats> => {
+  const { totalSupply, ownerCount } = await fetchDaoOverview();
+  return { totalSupply, ownerCount };
+});
 
 export const fetchTotalAuctionSalesWei = cache(async (): Promise<bigint> => {
-  const id = DAO_ADDRESSES.token.toLowerCase();
-  const data = await subgraphQuery<DaoSalesQuery>(DAO_TOTAL_AUCTION_SALES_GQL, { id });
-  const wei = data.dao?.totalAuctionSales ?? "0";
-  try {
-    return BigInt(wei);
-  } catch {
-    return BigInt(0);
-  }
+  const { totalAuctionSalesWei } = await fetchDaoOverview();
+  return totalAuctionSalesWei;
 });