feat: forester dashboard + compression improvements

forester/dashboard/package.json

@@ -10,12 +10,14 @@
   },
   "dependencies": {
     "next": "^14.2.0",
+    "pg": "^8.18.0",
     "react": "^18.3.0",
     "react-dom": "^18.3.0",
     "swr": "^2.2.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
+    "@types/pg": "^8.16.0",
     "@types/react": "^18.3.0",
     "@types/react-dom": "^18.3.0",
     "autoprefixer": "^10.4.0",

forester/dashboard/src/app/api/[...path]/route.ts

@@ -0,0 +1,83 @@
+import { NextResponse } from "next/server";
+
+export const dynamic = "force-dynamic";
+
+const BACKEND_URL =
+  process.env.FORESTER_API_URL || "http://127.0.0.1:8080";
+
+const BACKEND_TIMEOUT_MS = Number(
+  process.env.FORESTER_API_TIMEOUT_MS ?? 8000
+);
+
+function isAbortError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "name" in error &&
+    (error as { name?: string }).name === "AbortError"
+  );
+}
+
+function joinBackendUrl(path: string): string {
+  const base = BACKEND_URL.replace(/\/+$/, "");
+  return `${base}/${path}`;
+}
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  const { path } = await params;
+  const backendPath = path.join("/");
+  const upstream = joinBackendUrl(backendPath);
+
+  const timeoutMs =
+    Number.isFinite(BACKEND_TIMEOUT_MS) && BACKEND_TIMEOUT_MS > 0
+      ? BACKEND_TIMEOUT_MS
+      : 8000;
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const response = await fetch(upstream, {
+      cache: "no-store",
+      signal: controller.signal,
+    });
+
+    const contentType = response.headers.get("content-type") ?? "";
+    const payload = contentType.includes("application/json")
+      ? await response.json()
+      : { message: await response.text() };
+
+    if (!response.ok) {
+      return NextResponse.json(
+        {
+          error: `Forester backend returned ${response.status}`,
+          upstream,
+          details: payload,
+        },
+        { status: response.status }
+      );
+    }
+
+    return NextResponse.json(payload, { status: response.status });
+  } catch (error) {
+    if (isAbortError(error)) {
+      return NextResponse.json(
+        {
+          error: `Backend request timed out after ${timeoutMs}ms`,
+          upstream,
+        },
+        { status: 504 }
+      );
+    }
+
+    return NextResponse.json(
+      { error: "Backend unavailable", upstream },
+      { status: 502 }
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+}

forester/dashboard/src/app/api/photon-stats/route.ts

@@ -0,0 +1,91 @@
+import { NextResponse } from "next/server";
+import { Pool } from "pg";
+
+export const dynamic = "force-dynamic";
+
+let pool: Pool | null = null;
+
+function getPool(): Pool | null {
+  const url = process.env.PHOTON_DATABASE_URL;
+  if (!url) return null;
+  if (!pool) {
+    pool = new Pool({ connectionString: url, max: 2, idleTimeoutMillis: 30_000 });
+  }
+  return pool;
+}
+
+export async function GET() {
+  const db = getPool();
+  if (!db) {
+    return NextResponse.json(
+      { error: "PHOTON_DATABASE_URL not configured" },
+      { status: 503 }
+    );
+  }
+
+  try {
+    const client = await db.connect();
+    try {
+      const [accounts, tokens, compressed] = await Promise.all([
+        client.query(`
+          SELECT
+            COUNT(*) AS total,
+            COUNT(*) FILTER (WHERE NOT spent) AS active
+          FROM accounts
+        `),
+        client.query(`
+          SELECT
+            COUNT(*) AS total,
+            COUNT(*) FILTER (WHERE NOT spent) AS active
+          FROM token_accounts
+        `),
+        client.query(`
+          SELECT
+            encode(a.owner, 'base64') AS owner_b64,
+            COUNT(*) AS total,
+            COUNT(*) FILTER (WHERE NOT a.spent) AS active
+          FROM accounts a
+          WHERE a.onchain_pubkey IS NOT NULL
+          GROUP BY a.owner
+          ORDER BY COUNT(*) DESC
+        `),
+      ]);
+
+      const totalAccounts = Number(accounts.rows[0].total);
+      const activeAccounts = Number(accounts.rows[0].active);
+      const totalTokens = Number(tokens.rows[0].total);
+      const activeTokens = Number(tokens.rows[0].active);
+
+      const compressedFromOnchain = compressed.rows.map((r: { owner_b64: string; total: string; active: string }) => ({
+        owner: Buffer.from(r.owner_b64, "base64").toString("hex"),
+        total: Number(r.total),
+        active: Number(r.active),
+      }));
+
+      const totalCompressedFromOnchain = compressedFromOnchain.reduce(
+        (sum: number, r: { total: number }) => sum + r.total,
+        0
+      );
+      const activeCompressedFromOnchain = compressedFromOnchain.reduce(
+        (sum: number, r: { active: number }) => sum + r.active,
+        0
+      );
+
+      return NextResponse.json({
+        accounts: { total: totalAccounts, active: activeAccounts },
+        token_accounts: { total: totalTokens, active: activeTokens },
+        compressed_from_onchain: {
+          total: totalCompressedFromOnchain,
+          active: activeCompressedFromOnchain,
+          by_owner: compressedFromOnchain,
+        },
+        timestamp: Math.floor(Date.now() / 1000),
+      });
+    } finally {
+      client.release();
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

forester/dashboard/src/app/layout.tsx

@@ -1,5 +1,4 @@
 import type { Metadata } from "next";
-import { Sidebar } from "@/components/Sidebar";
 import "./globals.css";
 
 export const metadata: Metadata = {
@@ -14,11 +13,8 @@ export default function RootLayout({
 }) {
   return (
     <html lang="en">
-      <body className="bg-white text-gray-900 antialiased">
-        <div className="flex min-h-screen">
-          <Sidebar />
-          <main className="flex-1 p-6 overflow-auto">{children}</main>
-        </div>
+      <body className="bg-gray-50 text-gray-900 antialiased">
+        <main className="max-w-6xl mx-auto px-6 py-8">{children}</main>
       </body>
     </html>
   );