refactor: addressed PR comments

Author: alexcambose

apps/insights/package.json

@@ -28,7 +28,7 @@
     "@pythnetwork/known-publishers": "workspace:*",
     "@react-hookz/web": "catalog:",
     "@solana/web3.js": "catalog:",
-    "async-cache-dedupe": "^3.0.0",
+    "async-cache-dedupe": "catalog:",
     "bs58": "catalog:",
     "clsx": "catalog:",
     "cryptocurrency-icons": "catalog:",

apps/insights/src/app/api/pyth/get-feeds-for-publisher/[publisher]/route.ts

@@ -1,30 +1,39 @@
-import { NextResponse } from "next/server";
+import { NextRequest, NextResponse } from "next/server";
 import { stringify } from "superjson";
 
-import { getFeedsCached } from '../../../../../server/pyth/get-feeds';
-import { Cluster } from "../../../../../services/pyth";
+import { Cluster, parseCluster } from "../../../../../services/pyth";
+import { getFeeds } from "../../../../../services/pyth/get-feeds";
 
-export const GET = async (request: Request, { params }: { params: Promise<{ publisher: string }> }) => {
+export const GET = async (
+  request: NextRequest,
+  { params }: { params: Promise<{ publisher: string }> },
+) => {
   const { publisher } = await params;
-  const { searchParams } = new URL(request.url);
-  const cluster = Number.parseInt(searchParams.get("cluster") ?? Cluster.Pythnet.toString()) as Cluster;
+  const clusterName = request.nextUrl.searchParams.get("cluster");
 
-  // check if cluster is valid
-  if (cluster && !Object.values(Cluster).includes(cluster)) {
-    return NextResponse.json({ error: "Invalid cluster" }, { status: 400 });
+  const cluster =
+    clusterName === null ? Cluster.Pythnet : parseCluster(clusterName);
+
+  if (cluster === undefined) {
+    return NextResponse.json({ error: "Invalid Cluster" }, { status: 400 });
   }
 
   if (!publisher) {
-    return NextResponse.json({ error: "Publisher is required" }, { status: 400 });
-  } 
+    return NextResponse.json(
+      { error: "Publisher is required" },
+      { status: 400 },
+    );
+  }
+
+  const feeds = await getFeeds(cluster);
 
-  const feeds = await getFeedsCached(cluster);
+  const filteredFeeds = feeds.filter((feed) =>
+    feed.price.priceComponents.some((c) => c.publisher === publisher),
+  );
 
-  const filteredFeeds = feeds.filter((feed) => feed.price.priceComponents.some((c) => c.publisher === publisher));
-  
   return new Response(stringify(filteredFeeds), {
     headers: {
-      'Content-Type': 'application/json',
+      "Content-Type": "application/json",
     },
   });
-};
+};

apps/insights/src/app/api/pyth/get-feeds/[symbol]/route.ts

@@ -1,25 +1,30 @@
 import { NextResponse } from "next/server";
-import { stringify } from 'superjson';
+import { stringify } from "superjson";
 
-import { getFeedsCached } from "../../../../../server/pyth/get-feeds";
 import { Cluster } from "../../../../../services/pyth";
+import { getFeeds } from "../../../../../services/pyth/get-feeds";
 
-export const GET = async (request: Request, { params }: { params: Promise<{ symbol: string }> }) => {
+export const GET = async (
+  request: Request,
+  { params }: { params: Promise<{ symbol: string }> },
+) => {
   const { symbol } = await params;
   const { searchParams } = new URL(request.url);
-  const cluster = Number.parseInt(searchParams.get("cluster") ?? Cluster.Pythnet.toString()) as Cluster;
+  const cluster = Number.parseInt(
+    searchParams.get("cluster") ?? Cluster.Pythnet.toString(),
+  ) as Cluster;
 
   // check if cluster is valid
   if (cluster && !Object.values(Cluster).includes(cluster)) {
     return NextResponse.json({ error: "Invalid cluster" }, { status: 400 });
   }
-  
-  const feeds = await getFeedsCached(cluster);
+
+  const feeds = await getFeeds(cluster);
   const feed = feeds.find((feed) => feed.symbol === symbol);
-  
+
   return new Response(stringify(feed), {
     headers: {
-      'Content-Type': 'application/json',
-    }
+      "Content-Type": "application/json",
+    },
   });
-};
+};

apps/insights/src/app/api/pyth/get-feeds/route.ts

@@ -1,33 +1,35 @@
 import { NextResponse } from "next/server";
-import { stringify } from 'superjson';
-import type { z } from 'zod';
+import { stringify } from "superjson";
 
-import { getFeedsCached } from "../../../../server/pyth/get-feeds";
-import { Cluster, priceFeedsSchema } from "../../../../services/pyth";
+import { Cluster } from "../../../../services/pyth";
+import { getFeeds } from "../../../../services/pyth/get-feeds";
 
 export const GET = async (request: Request) => {
   // get cluster from query params
   const { searchParams } = new URL(request.url);
-  const excludePriceComponents = searchParams.get("excludePriceComponents") === "true";
-  const cluster = Number.parseInt(searchParams.get("cluster") ?? Cluster.Pythnet.toString()) as Cluster;
+  const excludePriceComponents =
+    searchParams.get("excludePriceComponents") === "true";
+  const cluster = Number.parseInt(
+    searchParams.get("cluster") ?? Cluster.Pythnet.toString(),
+  ) as Cluster;
 
   // check if cluster is valid
   if (cluster && !Object.values(Cluster).includes(cluster)) {
     return NextResponse.json({ error: "Invalid cluster" }, { status: 400 });
   }
 
-  let feeds = await getFeedsCached(cluster) as Omit<z.infer<typeof priceFeedsSchema>[number], 'price'>[];
-  
-  if(excludePriceComponents) {
-    feeds = feeds.map((feed) => ({
-      ...feed,
-      price: undefined,
-    }));
-  }
-  
-  return new Response(stringify(feeds), {
+  const feeds = await getFeeds(cluster);
+  const filteredFeeds = excludePriceComponents
+    ? feeds.map((feed) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { price, ...rest } = feed;
+        return rest;
+      })
+    : feeds;
+
+  return new Response(stringify(filteredFeeds), {
     headers: {
-      'Content-Type': 'application/json',
+      "Content-Type": "application/json",
     },
   });
-};
+};

apps/insights/src/app/api/pyth/get-publishers/[symbol]/route.ts

@@ -1,13 +1,18 @@
 import { NextResponse } from "next/server";
 
-import { getPublishersForClusterCached } from "../../../../../server/pyth/get-publishers-for-cluster";
 import { Cluster } from "../../../../../services/pyth";
+import { getPublishersForCluster } from "../../../../../services/pyth/get-publishers-for-cluster";
 
-export const GET = async (request: Request, { params }: { params: Promise<{ symbol: string }> }) => {
+export const GET = async (
+  request: Request,
+  { params }: { params: Promise<{ symbol: string }> },
+) => {
   const { symbol } = await params;
   // get cluster from query params
   const { searchParams } = new URL(request.url);
-  const cluster = Number.parseInt(searchParams.get("cluster") ?? Cluster.Pythnet.toString()) as Cluster;
+  const cluster = Number.parseInt(
+    searchParams.get("cluster") ?? Cluster.Pythnet.toString(),
+  ) as Cluster;
 
   // check if cluster is valid
   if (cluster && !Object.values(Cluster).includes(cluster)) {
@@ -18,7 +23,7 @@ export const GET = async (request: Request, { params }: { params: Promise<{ symb
     return NextResponse.json({ error: "Symbol is required" }, { status: 400 });
   }
 
-  const map = await getPublishersForClusterCached(cluster);
+  const map = await getPublishersForCluster(cluster);
 
   return NextResponse.json(map[symbol] ?? []);
-};
+};

apps/insights/src/app/component-score-history/route.ts

@@ -16,13 +16,13 @@ export const GET = async (req: NextRequest) => {
   );
   if (parsed.success) {
     const { cluster, publisherKey, symbol, from, to } = parsed.data;
-    const data = await getFeedScoreHistory(
+    const data = await getFeedScoreHistory({
       cluster,
       publisherKey,
       symbol,
       from,
       to,
-    );
+    });
     return Response.json(data);
   } else {
     return new Response(fromError(parsed.error).toString(), {

apps/insights/src/app/historical-prices/route.ts

@@ -6,7 +6,10 @@ export async function GET(req: NextRequest) {
   const symbol = req.nextUrl.searchParams.get("symbol");
   const until = req.nextUrl.searchParams.get("until");
   if (symbol && until) {
-    const res = await getHistoricalPrices(decodeURIComponent(symbol), until);
+    const res = await getHistoricalPrices({
+      symbol: decodeURIComponent(symbol),
+      until,
+    });
     return Response.json(res);
   } else {
     return new Response("Must provide `symbol` and `until`", { status: 400 });

apps/insights/src/app/price-feeds/[slug]/layout.ts

@@ -2,8 +2,8 @@ import type { Metadata } from "next";
 import { notFound } from "next/navigation";
 import type { ReactNode } from "react";
 
-import { getFeedsCached } from "../../../server/pyth/get-feeds";
 import { Cluster } from "../../../services/pyth";
+import { getFeeds } from "../../../services/pyth/get-feeds";
 
 export { PriceFeedLayout as default } from "../../../components/PriceFeed/layout";
 
@@ -20,7 +20,7 @@ export const generateMetadata = async ({
 }: Props): Promise<Metadata> => {
   const [{ slug }, feeds] = await Promise.all([
     params,
-    getFeedsCached(Cluster.Pythnet),
+    getFeeds(Cluster.Pythnet),
   ]);
   const symbol = decodeURIComponent(slug);
   const feed = feeds.find((item) => item.symbol === symbol);

apps/insights/src/components/Overview/index.tsx

@@ -9,8 +9,8 @@ import PriceFeedsLight from "./price-feeds-light.svg";
 import PublishersDark from "./publishers-dark.svg";
 import PublishersLight from "./publishers-light.svg";
 import { TabList } from "./tab-list";
-import { getFeedsCached } from "../../server/pyth/get-feeds";
 import { Cluster } from "../../services/pyth";
+import { getFeeds } from "../../services/pyth/get-feeds";
 import {
   totalVolumeTraded,
   activeChains,
@@ -24,7 +24,7 @@ import { FormattedDate } from "../FormattedDate";
 import { FormattedNumber } from "../FormattedNumber";
 
 export const Overview = async () => {
-  const priceFeeds = await getFeedsCached(Cluster.Pythnet);
+  const priceFeeds = await getFeeds(Cluster.Pythnet);
   const today = new Date();
 
   const feedCounts = [

apps/insights/src/components/PriceFeed/get-feed.tsx

@@ -1,27 +1,17 @@
 import { notFound } from "next/navigation";
-import { parse } from "superjson";
-import { z } from "zod";
 
-import { PUBLIC_URL, VERCEL_AUTOMATION_BYPASS_SECRET } from '../../config/server';
-import { getFeedForSymbolCached } from '../../server/pyth';
-import { Cluster, priceFeedsSchema } from "../../services/pyth";
-import { DEFAULT_CACHE_TTL } from '../../utils/cache';
+import { getFeedForSymbolRequest, getFeedsRequest } from "../../server/pyth";
+import { Cluster } from "../../services/pyth";
 
 export const getFeed = async (params: Promise<{ slug: string }>) => {
-  const data = await fetch(`${PUBLIC_URL}/api/pyth/get-feeds?cluster=${Cluster.Pythnet.toString()}&excludePriceComponents=true`, {
-    next: {
-      revalidate: DEFAULT_CACHE_TTL,
-    },
-    headers: {
-      'x-vercel-protection-bypass': VERCEL_AUTOMATION_BYPASS_SECRET,
-    },
-  });
-  const dataJson = await data.text();
-  const feeds: z.infer<typeof priceFeedsSchema> = parse(dataJson);
+  const feeds = await getFeedsRequest(Cluster.Pythnet);
 
   const { slug } = await params;
   const symbol = decodeURIComponent(slug);
-  const feed = await getFeedForSymbolCached({symbol, cluster: Cluster.Pythnet});
+  const feed = await getFeedForSymbolRequest({
+    symbol,
+    cluster: Cluster.Pythnet,
+  });
 
   return {
     feeds,