feat: local caching for dev

astro.config.mjs

@@ -7,6 +7,12 @@ export default defineConfig({
   adapter: cloudflare(),
   integrations: [react()],
   vite: {
+    build: {
+      sourcemap: false,
+    },
+    optimizeDeps: {
+      include: ["@tabler/icons-react"],
+    },
     resolve: {
       alias: {
         "@cdransf": "node_modules/@cdransf",

src/pages/posts/[...page].astro

@@ -49,7 +49,7 @@ const pagination = {
             </time>
           </div>
           <h3>
-            <a href={post.slug}>{post.title}</a>
+            <a href={post.url}>{post.title}</a>
           </h3>
           <p set:html={md(post.description)}></p>
         </article>

src/utils/data/activity.js

@@ -1,24 +1,24 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
+let cachedActivity = null;
+
 export async function fetchActivity() {
-  try {
+  if (import.meta.env.MODE === "development" && cachedActivity)
-    const { data, error } = await supabase
+    return cachedActivity;
-      .from('optimized_all_activity')
-      .select('feed');
 
-    if (error) {
+  const { data, error } = await supabase
-      console.error('Error fetching activity data:', error);
+    .from("optimized_all_activity")
-      return [];
+    .select("feed");
-    }
 
-    const [{ feed } = {}] = data || [];
+  if (error) return [];
-    return feed?.filter((item) => item.feed !== null) || [];
+  const [{ feed } = {}] = data || [];
-  } catch (error) {
+  const filteredFeed = feed?.filter((item) => item.feed !== null) || [];
-    console.error('Unexpected error fetching activity data:', error);
+
-    return [];
+  if (import.meta.env.MODE === "development") cachedActivity = filteredFeed;
-  }
+
-}
+  return filteredFeed;
+};

src/utils/data/albumReleases.js

@@ -5,39 +5,34 @@ const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
+let cachedAlbumReleases = null;
+
 export async function fetchAlbumReleases() {
-  try {
+  if (import.meta.env.MODE === 'development' && cachedAlbumReleases) return cachedAlbumReleases;
-    const today = DateTime.utc().startOf('day').toSeconds();
 
-    const { data, error } = await supabase
+  const today = DateTime.utc().startOf('day').toSeconds();
-      .from('optimized_album_releases')
-      .select('*');
 
-    if (error) {
+  const { data, error } = await supabase
-      console.error('Error fetching album releases:', error);
+    .from('optimized_album_releases')
-      return { all: [], upcoming: [] };
+    .select('*');
-    }
 
-    const all = data
+  if (error) return { all: [], upcoming: [] };
-      .map((album) => {
-        const releaseDate = DateTime.fromSeconds(album.release_timestamp)
-          .toUTC()
-          .startOf('day');
 
-        return {
+  const all = data
-          ...album,
+    .map((album) => {
-          description: album.artist.description,
+      const releaseDate = DateTime.fromSeconds(album.release_timestamp).toUTC().startOf('day');
-          date: releaseDate.toLocaleString(DateTime.DATE_FULL),
+      return {
-          timestamp: releaseDate.toSeconds(),
+        ...album,
-        };
+        description: album.artist.description,
-      })
+        date: releaseDate.toLocaleString(DateTime.DATE_FULL),
-      .sort((a, b) => a.timestamp - b.timestamp);
+        timestamp: releaseDate.toSeconds(),
+      };
+    })
+    .sort((a, b) => a.timestamp - b.timestamp);
 
-    const upcoming = all.filter((album) => album.release_timestamp > today);
+  const upcoming = all.filter((album) => album.release_timestamp > today);
 
-    return { all, upcoming };
+  if (import.meta.env.MODE === 'development') cachedAlbumReleases = { all, upcoming };
-  } catch (error) {
+
-    console.error('Unexpected error processing album releases:', error);
+  return { all, upcoming };
-    return { all: [], upcoming: [] };
+};
-  }
-}

src/utils/data/artists.js

@@ -1,38 +1,40 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
-import { parseCountryField } from '@utils/helpers.js';
+import { parseCountryField } from "@utils/helpers.js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
 
-export async function fetchArtists(){
+let cachedArtists = null;
+
+export async function fetchArtists() {
+  if (import.meta.env.MODE === "development" && cachedArtists)
+    return cachedArtists;
+
+  const PAGE_SIZE = 1000;
   let artists = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_artists')
+      .from("optimized_artists")
-      .select('*')
+      .select("*")
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
+    if (error) break;
-      console.error('Error fetching artists:', error);
-      break;
-    }
 
-    // Process and concatenate artists data
     artists = artists.concat(
       data.map((artist) => ({
         ...artist,
-        country: parseCountryField(artist['country']),
+        country: parseCountryField(artist["country"]),
       }))
     );
 
-    // Break if no more data
     if (data.length < PAGE_SIZE) break;
     rangeStart += PAGE_SIZE;
   }
 
+  if (import.meta.env.MODE === "development") cachedArtists = artists;
+
   return artists;
-};
+};

src/utils/data/blogroll.js

@@ -1,22 +1,28 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
+let cachedBlogroll = null;
+
 export async function fetchBlogroll() {
+  if (import.meta.env.MODE === "development" && cachedBlogroll)
+    return cachedBlogroll;
+
   const { data, error } = await supabase
-    .from('authors')
+    .from("authors")
-    .select('*')
+    .select("*")
-    .eq('blogroll', true)
+    .eq("blogroll", true)
-    .order('name', { ascending: true });
+    .order("name", { ascending: true });
 
-  if (error) {
+  if (error) return [];
-    console.error('Error fetching authors for the blogroll:', error);
-    return [];
-  }
 
-  return data.sort((a, b) =>
+  const sortedData = data.sort((a, b) =>
     a.name.toLowerCase().localeCompare(b.name.toLowerCase())
   );
-};
+
+  if (import.meta.env.MODE === "development") cachedBlogroll = sortedData;
+
+  return sortedData;
+};

src/utils/data/books.js

@@ -1,25 +1,26 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedBooks = null;
 
 export async function fetchBooks() {
+  if (import.meta.env.MODE === "development" && cachedBooks) return cachedBooks;
+
+  const PAGE_SIZE = 1000;
   let books = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_books')
+      .from("optimized_books")
-      .select('*')
+      .select("*")
-      .order('date_finished', { ascending: false })
+      .order("date_finished", { ascending: false })
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
+    if (error) break;
-      console.error('Error fetching books:', error);
-      break;
-    }
 
     books = books.concat(data);
     if (data.length < PAGE_SIZE) break;
@@ -39,12 +40,17 @@ export async function fetchBooks() {
   const sortedByYear = Object.values(years).filter((year) => year.value > 2017);
   const currentYear = new Date().getFullYear();
   const booksForCurrentYear =
-    sortedByYear.find((yearGroup) => yearGroup.value === currentYear)?.data || [];
+    sortedByYear.find((yearGroup) => yearGroup.value === currentYear)?.data ||
+    [];
 
-  return {
+  const result = {
     all: books,
     years: sortedByYear,
     currentYear: booksForCurrentYear,
     feed: books.filter((book) => book.feed),
   };
-};
+
+  if (import.meta.env.MODE === "development") cachedBooks = result;
+
+  return result;
+};

src/utils/data/concerts.js

@@ -1,32 +1,38 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedConcerts = null;
 
 export async function fetchConcertsData() {
+  if (import.meta.env.MODE === "development" && cachedConcerts)
+    return cachedConcerts;
+
+  const PAGE_SIZE = 1000;
   let concerts = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_concerts')
+      .from("optimized_concerts")
-      .select('*')
+      .select("*")
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
+    if (error) break;
-      console.error('Error fetching concerts:', error);
-      break;
-    }
 
     concerts = concerts.concat(data);
     if (data.length < PAGE_SIZE) break;
     rangeStart += PAGE_SIZE;
   }
 
-  return concerts.map((concert) => ({
+  const result = concerts.map((concert) => ({
     ...concert,
     artist: concert.artist || { name: concert.artist_name_string, url: null },
   }));
-};
+
+  if (import.meta.env.MODE === "development") cachedConcerts = result;
+
+  return result;
+};

src/utils/data/genres.js

@@ -1,18 +1,19 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
-export async function fetchGenres() {
+let cachedGenres = null;
-  const { data, error } = await supabase
-    .from('optimized_genres')
-    .select('*');
 
-  if (error) {
+export async function fetchGenres() {
-    console.error('Error fetching genres with artists:', error);
+  if (import.meta.env.MODE === "development" && cachedGenres)
-    return [];
+    return cachedGenres;
-  }
+
+  const { data, error } = await supabase.from("optimized_genres").select("*");
+
+  if (error) return [];
+  if (import.meta.env.MODE === "development") cachedGenres = data;
 
   return data;
-};
+};

src/utils/data/globals.js

@@ -1,19 +1,23 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
+let cachedGlobals = null;
+
 export async function fetchGlobals() {
+  const isDev = import.meta.env.MODE === "development";
+
+  if (isDev && cachedGlobals) return cachedGlobals;
+
   const { data, error } = await supabase
-    .from('optimized_globals')
+    .from("optimized_globals")
-    .select('*')
+    .select("*")
     .single();
 
-  if (error) {
+  if (error) return {};
-    console.error('Error fetching globals:', error);
+  if (isDev) cachedGlobals = data;
-    return {};
-  }
 
   return data;
-}
+};

src/utils/data/links.js

@@ -1,31 +1,33 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedLinks = null;
 
 export async function fetchLinks() {
+  if (import.meta.env.MODE === "development" && cachedLinks) return cachedLinks;
+
+  const PAGE_SIZE = 1000;
   let links = [];
   let page = 0;
   let fetchMore = true;
 
   while (fetchMore) {
     const { data, error } = await supabase
-      .from('optimized_links')
+      .from("optimized_links")
-      .select('*')
+      .select("*")
       .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
 
-    if (error) {
+    if (error) return links;
-      console.error('Error fetching links:', error);
-      return links;
-    }
-
     if (data.length < PAGE_SIZE) fetchMore = false;
 
     links = links.concat(data);
     page++;
   }
 
+  if (import.meta.env.MODE === "development") cachedLinks = links;
+
   return links;
-};
+};

src/utils/data/movies.js

@@ -1,25 +1,27 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
-import { DateTime } from 'luxon';
+import { DateTime } from "luxon";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedMovies = null;
 
 export async function fetchMovies() {
+  if (import.meta.env.MODE === "development" && cachedMovies)
+    return cachedMovies;
+
+  const PAGE_SIZE = 1000;
   let movies = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_movies')
+      .from("optimized_movies")
-      .select('*')
+      .select("*")
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
+    if (error) break;
-      console.error('Error fetching movies:', error);
-      break;
-    }
 
     movies = movies.concat(data);
     if (data.length < PAGE_SIZE) break;
@@ -27,16 +29,22 @@ export async function fetchMovies() {
   }
 
   const year = DateTime.now().year;
-  const favoriteMovies = movies.filter(movie => movie.favorite);
+  const favoriteMovies = movies.filter((movie) => movie.favorite);
   const recentlyWatchedMovies = movies.filter(
-    movie => movie.last_watched && year - DateTime.fromISO(movie.last_watched).year <= 3
+    (movie) =>
+      movie.last_watched &&
+      year - DateTime.fromISO(movie.last_watched).year <= 3
   );
 
-  return {
+  const result = {
     movies,
-    watchHistory: movies.filter(movie => movie.last_watched),
+    watchHistory: movies.filter((movie) => movie.last_watched),
     recentlyWatched: recentlyWatchedMovies,
     favorites: favoriteMovies.sort((a, b) => a.title.localeCompare(b.title)),
-    feed: movies.filter(movie => movie.feed),
+    feed: movies.filter((movie) => movie.feed),
   };
-};
+
+  if (import.meta.env.MODE === "development") cachedMovies = result;
+
+  return result;
+};

src/utils/data/music.js

@@ -1,11 +1,17 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedMusicData = null;
 
 export async function fetchMusicData() {
+  if (import.meta.env.MODE === "development" && cachedMusicData)
+    return cachedMusicData;
+
+  const PAGE_SIZE = 1000;
+
   const fetchDataFromView = async (viewName) => {
     let rows = [];
     let rangeStart = 0;
@@ -13,18 +19,12 @@ export async function fetchMusicData() {
     while (true) {
       const { data, error } = await supabase
         .from(viewName)
-        .select('*')
+        .select("*")
         .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-      if (error) {
+      if (error || data.length === 0) break;
-        console.error(`Error fetching data from view ${viewName}:`, error);
-        break;
-      }
-
-      if (data.length === 0) break;
 
       rows = [...rows, ...data];
-
       if (data.length < PAGE_SIZE) break;
       rangeStart += PAGE_SIZE;
     }
@@ -32,48 +32,51 @@ export async function fetchMusicData() {
     return rows;
   };
 
-  try {
+  const [
-    const [
+    recentTracks,
-      recentTracks,
+    weekTracks,
-      weekTracks,
+    weekArtists,
-      weekArtists,
+    weekAlbums,
-      weekAlbums,
+    weekGenres,
-      weekGenres,
+    monthTracks,
-      monthTracks,
+    monthArtists,
-      monthArtists,
+    monthAlbums,
-      monthAlbums,
+    monthGenres,
-      monthGenres,
+  ] = await Promise.all([
-    ] = await Promise.all([
+    fetchDataFromView("recent_tracks"),
-      fetchDataFromView('recent_tracks'),
+    fetchDataFromView("week_tracks"),
-      fetchDataFromView('week_tracks'),
+    fetchDataFromView("week_artists"),
-      fetchDataFromView('week_artists'),
+    fetchDataFromView("week_albums"),
-      fetchDataFromView('week_albums'),
+    fetchDataFromView("week_genres"),
-      fetchDataFromView('week_genres'),
+    fetchDataFromView("month_tracks"),
-      fetchDataFromView('month_tracks'),
+    fetchDataFromView("month_artists"),
-      fetchDataFromView('month_artists'),
+    fetchDataFromView("month_albums"),
-      fetchDataFromView('month_albums'),
+    fetchDataFromView("month_genres"),
-      fetchDataFromView('month_genres'),
+  ]);
-    ]);
 
-    return {
+  const result = {
-      recent: recentTracks,
+    recent: recentTracks,
-      week: {
+    week: {
-        tracks: weekTracks,
+      tracks: weekTracks,
-        artists: weekArtists,
+      artists: weekArtists,
-        albums: weekAlbums,
+      albums: weekAlbums,
-        genres: weekGenres,
+      genres: weekGenres,
-        totalTracks: weekTracks.reduce((acc, track) => acc + track.plays, 0).toLocaleString('en-US'),
+      totalTracks: weekTracks
-      },
+        .reduce((acc, track) => acc + track.plays, 0)
-      month: {
+        .toLocaleString("en-US"),
-        tracks: monthTracks,
+    },
-        artists: monthArtists,
+    month: {
-        albums: monthAlbums,
+      tracks: monthTracks,
-        genres: monthGenres,
+      artists: monthArtists,
-        totalTracks: monthTracks.reduce((acc, track) => acc + track.plays, 0).toLocaleString('en-US'),
+      albums: monthAlbums,
-      },
+      genres: monthGenres,
-    };
+      totalTracks: monthTracks
-  } catch (error) {
+        .reduce((acc, track) => acc + track.plays, 0)
-    console.error('Error fetching and processing music data:', error);
+        .toLocaleString("en-US"),
-    return {};
+    },
-  }
+  };
-};
+
+  if (import.meta.env.MODE === "development") cachedMusicData = result;
+
+  return result;
+};

src/utils/data/nav.js

@@ -1,39 +1,39 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = import.meta.env.SUPABASE_URL
+const SUPABASE_URL = import.meta.env.SUPABASE_URL;
-const SUPABASE_KEY = import.meta.env.SUPABASE_KEY
+const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+
+let cachedNavigation = null;
 
 export async function fetchNavigation() {
-  const { data, error } = await supabase
+  if (import.meta.env.MODE === "development" && cachedNavigation)
-    .from('optimized_navigation')
+    return cachedNavigation;
-    .select('*')
 
-  if (error) {
+  const { data, error } = await supabase
-    console.error('Error fetching navigation data:', error)
+    .from("optimized_navigation")
-    return {}
+    .select("*");
-  }
+  if (error) return {};
 
   const menu = data.reduce((acc, item) => {
     const menuItem = {
-      title: item['title'] || item['page_title'],
+      title: item["title"] || item["page_title"],
-      permalink: item['permalink'] || item ['page_permalink'],
+      permalink: item["permalink"] || item["page_permalink"],
-      icon: item['icon'],
+      icon: item["icon"],
-      sort: item['sort']
+      sort: item["sort"],
-    }
+    };
 
-    if (!acc[item['menu_location']]) {
+    if (!acc[item["menu_location"]]) acc[item["menu_location"]] = [menuItem];
-      acc[item['menu_location']] = [menuItem]
+    else acc[item["menu_location"]].push(menuItem);
-    } else {
-      acc[item['menu_location']].push(menuItem)
-    }
 
-    return acc
+    return acc;
-  }, {})
+  }, {});
 
-  Object.keys(menu).forEach(location => {
+  Object.keys(menu).forEach((location) => {
-    menu[location].sort((a, b) => a['sort'] - b['sort'])
+    menu[location].sort((a, b) => a["sort"] - b["sort"]);
-  })
+  });
 
-  return menu
+  if (import.meta.env.MODE === "development") cachedNavigation = menu;
-}
+
+  return menu;
+};

src/utils/data/nowPlaying.js

@@ -1,24 +1,31 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = import.meta.env.SUPABASE_URL
+const SUPABASE_URL = import.meta.env.SUPABASE_URL;
-const SUPABASE_KEY = import.meta.env.SUPABASE_KEY
+const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+
+let cachedNowPlaying = null;
 
 export async function fetchNowPlaying() {
+  if (import.meta.env.MODE === "development" && cachedNowPlaying)
+    return cachedNowPlaying;
+
   const { data, error } = await supabase
-    .from('optimized_latest_listen')
+    .from("optimized_latest_listen")
-    .select('*')
+    .select("*")
-    .single()
+    .single();
+  if (error) return {};
 
-  if (error) {
+  const genreEmoji = data.genre_emoji;
-    console.error('Error fetching the latest track:', error)
+  const emoji = data.artist_emoji || genreEmoji;
-    return {}
-  }
 
-  const genreEmoji = data.genre_emoji
+  const result = {
-  const emoji = data.artist_emoji || genreEmoji
+    content: `${emoji || "🎧"} ${
+      data.track_name
+    } by <a href="https://coryd.dev${data.url}">${data.artist_name}</a>`,
+  };
 
-  return {
+  if (import.meta.env.MODE === "development") cachedNowPlaying = result;
-    content: `${emoji || '🎧'} ${data.track_name} by <a href="https://coryd.dev${data.url}">${data.artist_name}</a>`,
+
-  }
+  return result;
-}
+};

src/utils/data/pages.js

@@ -1,16 +1,18 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
-export async function fetchPages() {
+let cachedPages = null;
-  const { data, error } = await supabase.from('optimized_pages').select('*');
 
-  if (error) {
+export async function fetchPages() {
-    console.error('Error fetching pages:', error);
+  if (import.meta.env.MODE === "development" && cachedPages) return cachedPages;
-    return [];
+
-  }
+  const { data, error } = await supabase.from("optimized_pages").select("*");
+  if (error) return [];
+
+  if (import.meta.env.MODE === "development") cachedPages = data;
 
   return data;
-}
+};

src/utils/data/posts.js

@@ -1,32 +1,35 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = import.meta.env['SUPABASE_URL']
+const SUPABASE_URL = import.meta.env["SUPABASE_URL"];
-const SUPABASE_KEY = import.meta.env['SUPABASE_KEY']
+const SUPABASE_KEY = import.meta.env["SUPABASE_KEY"];
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000
+
+let cachedPosts = null;
 
 export async function fetchAllPosts() {
-  let posts = []
+  if (import.meta.env.MODE === "development" && cachedPosts) return cachedPosts;
-  let page = 0
+
-  let fetchMore = true
+  const PAGE_SIZE = 1000;
+  let posts = [];
+  let page = 0;
+  let fetchMore = true;
 
   while (fetchMore) {
     const { data, error } = await supabase
-      .from('optimized_posts')
+      .from("optimized_posts")
-      .select('*')
+      .select("*")
-      .order('date', { ascending: false })
+      .order("date", { ascending: false })
-      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1)
+      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
 
-    if (error) {
+    if (error) return posts;
-      console.error('Error fetching posts:', error)
-      return posts
-    }
 
-    if (data.length < PAGE_SIZE) fetchMore = false
+    if (data.length < PAGE_SIZE) fetchMore = false;
 
-    posts = posts.concat(data)
+    posts = posts.concat(data);
-    page++
+    page++;
   }
 
-  return posts
+  if (import.meta.env.MODE === "development") cachedPosts = posts;
-}
+
+  return posts;
+};

src/utils/data/robots.js

@@ -1,29 +1,35 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 500;
+
+let cachedRobots = null;
 
 export async function fetchAllRobots() {
+  if (import.meta.env.MODE === "development" && cachedRobots)
+    return cachedRobots;
+
+  const PAGE_SIZE = 500;
   let robots = [];
   let from = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('robots')
+      .from("robots")
-      .select('user_agent')
+      .select("user_agent")
       .range(from, from + PAGE_SIZE - 1);
 
-    if (error) {
+    if (error) return [];
-      console.error('Error fetching robot data:', error);
-      return [];
-    }
 
     robots = robots.concat(data);
     if (data.length < PAGE_SIZE) break;
     from += PAGE_SIZE;
   }
 
-  return robots.map((robot) => robot['user_agent']).sort();
+  const result = robots.map((robot) => robot["user_agent"]).sort();
-};
+
+  if (import.meta.env.MODE === "development") cachedRobots = result;
+
+  return result;
+};

src/utils/data/search.js

@@ -1,19 +0,0 @@
-import { createClient } from '@supabase/supabase-js'
-
-const SUPABASE_URL = import.meta.env.SUPABASE_URL
-const SUPABASE_KEY = import.meta.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-
-export async function fetchSearchIndex() {
-  const { data, error } = await supabase
-    .from('optimized_search_index')
-    .select('search_index')
-
-  if (error) {
-    console.error('Error fetching search index data:', error)
-    return []
-  }
-
-  const [{ search_index } = {}] = data
-  return search_index || []
-}

src/utils/data/syndication.js

@@ -1,20 +1,24 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
-export default async function fetchSyndication() {
+let cachedSyndication = null;
-  const { data, error } = await supabase
-    .from('optimized_syndication')
-    .select('syndication');
 
-  if (error) {
+export default async function fetchSyndication() {
-    console.error('Error fetching syndication data:', error);
+  if (import.meta.env.MODE === "development" && cachedSyndication)
-    return [];
+    return cachedSyndication;
-  }
+
+  const { data, error } = await supabase
+    .from("optimized_syndication")
+    .select("syndication");
+  if (error) return [];
 
   const [{ syndication } = {}] = data;
+  const result = syndication?.filter((item) => item.syndication !== null) || [];
 
-  return syndication?.filter((item) => item.syndication !== null) || [];
+  if (import.meta.env.MODE === "development") cachedSyndication = result;
-}
+
+  return result;
+};

src/utils/data/tv.js

@@ -1,46 +1,53 @@
-import { createClient } from '@supabase/supabase-js';
+import { createClient } from "@supabase/supabase-js";
 
 const SUPABASE_URL = import.meta.env.SUPABASE_URL;
 const SUPABASE_KEY = import.meta.env.SUPABASE_KEY;
 const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
-const PAGE_SIZE = 1000;
+
+let cachedShows = null;
 
 export const fetchShows = async () => {
+  if (import.meta.env.MODE === "development" && cachedShows) return cachedShows;
+
+  const PAGE_SIZE = 1000;
   let shows = [];
   let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_shows')
+      .from("optimized_shows")
-      .select('*')
+      .select("*")
       .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
-    if (error) {
+    if (error) break;
-      console.error('Error fetching shows:', error);
-      break;
-    }
 
     shows = shows.concat(data);
     if (data.length < PAGE_SIZE) break;
     rangeStart += PAGE_SIZE;
   }
 
-  const watchedShows = shows.filter(show => show['last_watched_at'] !== null);
+  const watchedShows = shows.filter((show) => show["last_watched_at"] !== null);
-  const episodes = watchedShows.map(show => ({
+  const episodes = watchedShows.map((show) => ({
-    title: show['episode']['title'],
+    title: show["episode"]["title"],
-    year: show['year'],
+    year: show["year"],
-    formatted_episode: show['episode']['formatted_episode'],
+    formatted_episode: show["episode"]["formatted_episode"],
-    url: show['episode']['url'],
+    url: show["episode"]["url"],
-    image: show['episode']['image'],
+    image: show["episode"]["image"],
-    backdrop: show['episode']['backdrop'],
+    backdrop: show["episode"]["backdrop"],
-    last_watched_at: show['episode']['last_watched_at'],
+    last_watched_at: show["episode"]["last_watched_at"],
-    grid: show['grid'],
+    grid: show["grid"],
-    type: 'tv'
+    type: "tv",
   }));
 
-  return {
+  const result = {
     shows,
     recentlyWatched: episodes.slice(0, 225),
-    favorites: shows.filter(show => show.favorite).sort((a, b) => a.title.localeCompare(b.title)),
+    favorites: shows
+      .filter((show) => show.favorite)
+      .sort((a, b) => a.title.localeCompare(b.title)),
   };
-};
+
+  if (import.meta.env.MODE === "development") cachedShows = result;
+
+  return result;
+};