chore: normalize formatting

src/data/activity.js

@@ -1,20 +1,20 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
 export default async function fetchActivity() {
   const { data, error } = await supabase
-    .from('optimized_all_activity')
-    .select('feed')
+    .from("optimized_all_activity")
+    .select("feed");
 
   if (error) {
-    console.error('Error fetching activity data:', error)
-    return []
+    console.error("Error fetching activity data:", error);
+    return [];
   }
 
-  const [{ feed } = {}] = data
+  const [{ feed } = {}] = data;
 
-  return feed?.filter(item => item['feed'] !== null) || []
-}
+  return feed?.filter((item) => item["feed"] !== null) || [];
+}

src/data/albumReleases.js

@@ -1,43 +1,47 @@
-import { createClient } from '@supabase/supabase-js'
-import { DateTime } from 'luxon'
+import { createClient } from "@supabase/supabase-js";
+import { DateTime } from "luxon";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
 const fetchAlbumReleases = async () => {
-  const today = DateTime.utc().startOf('day').toSeconds()
+  const today = DateTime.utc().startOf("day").toSeconds();
 
   const { data, error } = await supabase
-    .from('optimized_album_releases')
-    .select('*')
+    .from("optimized_album_releases")
+    .select("*");
 
   if (error) {
-    console.error('Error fetching data:', error)
-    return []
+    console.error("Error fetching data:", error);
+    return [];
   }
 
-  const all = data.map(album => {
-    const releaseDate = DateTime.fromSeconds(album['release_timestamp']).toUTC().startOf('day')
+  const all = data
+    .map((album) => {
+      const releaseDate = DateTime.fromSeconds(album["release_timestamp"])
+        .toUTC()
+        .startOf("day");
 
-    return {
-      ...album,
-      description: album['artist']['description'],
-      date: releaseDate.toLocaleString(DateTime.DATE_FULL),
-      timestamp: releaseDate.toSeconds()
-    }
-  }).sort((a, b) => a['timestamp'] - b['timestamp'])
+      return {
+        ...album,
+        description: album["artist"]["description"],
+        date: releaseDate.toLocaleString(DateTime.DATE_FULL),
+        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 }
-}
+  return { all, upcoming };
+};
 
 export default async function () {
   try {
-    return await fetchAlbumReleases()
+    return await fetchAlbumReleases();
   } catch (error) {
-    console.error('Error fetching and processing album releases:', error)
-    return []
+    console.error("Error fetching and processing album releases:", error);
+    return [];
   }
-}
+}

src/data/artists.js

@@ -1,47 +1,47 @@
-import { createClient } from '@supabase/supabase-js'
-import { parseCountryField } from '../../config/utilities/index.js'
+import { createClient } from "@supabase/supabase-js";
+import { parseCountryField } from "../../config/utilities/index.js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 1000
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 1000;
 
 const fetchAllArtists = async () => {
-  let artists = []
-  let rangeStart = 0
+  let artists = [];
+  let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_artists')
-      .select('*')
-      .range(rangeStart, rangeStart + PAGE_SIZE - 1)
+      .from("optimized_artists")
+      .select("*")
+      .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
     if (error) {
-      console.error('Error fetching artists:', error)
-      break
+      console.error("Error fetching artists:", error);
+      break;
     }
 
-    artists = artists.concat(data)
-    if (data.length < PAGE_SIZE) break
-    rangeStart += PAGE_SIZE
+    artists = artists.concat(data);
+    if (data.length < PAGE_SIZE) break;
+    rangeStart += PAGE_SIZE;
   }
 
-  return artists
-}
+  return artists;
+};
 
 const processArtists = (artists) => {
-  return artists.map(artist => ({
+  return artists.map((artist) => ({
     ...artist,
-    country: parseCountryField(artist['country']),
-  }))
-}
+    country: parseCountryField(artist["country"]),
+  }));
+};
 
 export default async function () {
   try {
-    const artists = await fetchAllArtists()
-    return processArtists(artists)
+    const artists = await fetchAllArtists();
+    return processArtists(artists);
   } catch (error) {
-    console.error('Error fetching and processing artists data:', error)
-    return []
+    console.error("Error fetching and processing artists data:", error);
+    return [];
   }
-}
+}

src/data/blogroll.js

@@ -1,29 +1,31 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
 const fetchBlogroll = async () => {
   const { data, error } = await supabase
-    .from('authors')
-    .select('*')
-    .eq('blogroll', true)
-    .order('name', { ascending: true })
+    .from("authors")
+    .select("*")
+    .eq("blogroll", true)
+    .order("name", { ascending: true });
 
   if (error) {
-    console.error('Error fetching authors for the blogroll:', error)
-    return []
+    console.error("Error fetching authors for the blogroll:", error);
+    return [];
   }
 
-  return data.sort((a, b) => a['name'].toLowerCase().localeCompare(b['name'].toLowerCase()))
-}
+  return data.sort((a, b) =>
+    a["name"].toLowerCase().localeCompare(b["name"].toLowerCase())
+  );
+};
 
 export default async function () {
   try {
-    return await fetchBlogroll()
+    return await fetchBlogroll();
   } catch (error) {
-    console.error('Error fetching and processing the blogroll:', error)
-    return []
+    console.error("Error fetching and processing the blogroll:", error);
+    return [];
   }
-}
+}

src/data/books.js

@@ -1,60 +1,60 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 1000
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 1000;
 
 const fetchAllBooks = async () => {
-  let books = []
-  let rangeStart = 0
+  let books = [];
+  let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_books')
-      .select('*')
-      .order('date_finished', { ascending: false })
-      .range(rangeStart, rangeStart + PAGE_SIZE - 1)
+      .from("optimized_books")
+      .select("*")
+      .order("date_finished", { ascending: false })
+      .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
     if (error) {
-      console.error('Error fetching books:', error)
-      break
+      console.error("Error fetching books:", error);
+      break;
     }
 
-    books = books.concat(data)
-    if (data.length < PAGE_SIZE) break
-    rangeStart += PAGE_SIZE
+    books = books.concat(data);
+    if (data.length < PAGE_SIZE) break;
+    rangeStart += PAGE_SIZE;
   }
 
-  return books
-}
+  return books;
+};
 
 const sortBooksByYear = (books) => {
-  const years = {}
-  books.forEach(book => {
-    const year = book['year']
+  const years = {};
+  books.forEach((book) => {
+    const year = book["year"];
     if (!years[year]) {
-      years[year] = { value: year, data: [book] }
+      years[year] = { value: year, data: [book] };
     } else {
-      years[year]['data'].push(book)
+      years[year]["data"].push(book);
     }
-  })
-  return Object.values(years).filter(year => year['value'] > 2017)
-}
+  });
+  return Object.values(years).filter((year) => year["value"] > 2017);
+};
 
-const currentYear = new Date().getFullYear()
+const currentYear = new Date().getFullYear();
 
 export default async function () {
-  const books = await fetchAllBooks()
-  const sortedByYear = sortBooksByYear(books)
-  const booksForCurrentYear = sortedByYear.find(
-    yearGroup => yearGroup.value === currentYear
-  )?.data || []
+  const books = await fetchAllBooks();
+  const sortedByYear = sortBooksByYear(books);
+  const booksForCurrentYear =
+    sortedByYear.find((yearGroup) => yearGroup.value === currentYear)?.data ||
+    [];
 
   return {
     all: books,
     years: sortedByYear,
     currentYear: booksForCurrentYear,
-    feed: books.filter(book => book['feed'])
-  }
-}
+    feed: books.filter((book) => book["feed"]),
+  };
+}

src/data/concerts.js

@@ -1,46 +1,46 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 1000
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 1000;
 
 const fetchAllConcerts = async () => {
-  let concerts = []
-  let rangeStart = 0
+  let concerts = [];
+  let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_concerts')
-      .select('*')
-      .range(rangeStart, rangeStart + PAGE_SIZE - 1)
+      .from("optimized_concerts")
+      .select("*")
+      .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
     if (error) {
-      console.error('Error fetching concerts:', error)
-      break
+      console.error("Error fetching concerts:", error);
+      break;
     }
 
-    concerts = concerts.concat(data)
-    if (data.length < PAGE_SIZE) break
-    rangeStart += PAGE_SIZE
+    concerts = concerts.concat(data);
+    if (data.length < PAGE_SIZE) break;
+    rangeStart += PAGE_SIZE;
   }
 
-  return concerts
-}
+  return concerts;
+};
 
 const processConcerts = (concerts) => {
-  return concerts.map(concert => ({
+  return concerts.map((concert) => ({
     ...concert,
     artist: concert.artist || { name: concert.artist_name_string, url: null },
-  }))
-}
+  }));
+};
 
 export default async function () {
   try {
-    const concerts = await fetchAllConcerts()
-    return processConcerts(concerts)
+    const concerts = await fetchAllConcerts();
+    return processConcerts(concerts);
   } catch (error) {
-    console.error('Error fetching and processing concerts data:', error)
-    return []
+    console.error("Error fetching and processing concerts data:", error);
+    return [];
   }
-}
+}

src/data/genres.js

@@ -1,27 +1,25 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
 const fetchGenres = async () => {
-  const { data, error } = await supabase
-    .from('optimized_genres')
-    .select('*')
+  const { data, error } = await supabase.from("optimized_genres").select("*");
 
   if (error) {
-    console.error('Error fetching genres with artists:', error)
-    return []
+    console.error("Error fetching genres with artists:", error);
+    return [];
   }
 
-  return data
-}
+  return data;
+};
 
 export default async function () {
   try {
-    return await fetchGenres()
+    return await fetchGenres();
   } catch (error) {
-    console.error('Error fetching and processing genres:', error)
-    return []
+    console.error("Error fetching and processing genres:", error);
+    return [];
   }
-}
+}

src/data/globals.js

@@ -1,28 +1,28 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
 const fetchGlobals = async () => {
   const { data, error } = await supabase
-    .from('optimized_globals')
-    .select('*')
-    .single()
+    .from("optimized_globals")
+    .select("*")
+    .single();
 
   if (error) {
-    console.error('Error fetching globals:', error)
-    return {}
+    console.error("Error fetching globals:", error);
+    return {};
   }
 
-  return data
-}
+  return data;
+};
 
 export default async function () {
   try {
-    return await fetchGlobals()
+    return await fetchGlobals();
   } catch (error) {
-    console.error('Error fetching and processing globals:', error)
-    return {}
+    console.error("Error fetching and processing globals:", error);
+    return {};
   }
-}
+}

src/data/links.js

@@ -1,40 +1,40 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 1000
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 1000;
 
 const fetchAllLinks = async () => {
-  let links = []
-  let page = 0
-  let fetchMore = true
+  let links = [];
+  let page = 0;
+  let fetchMore = true;
 
   while (fetchMore) {
     const { data, error } = await supabase
-      .from('optimized_links')
-      .select('*')
-      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1)
+      .from("optimized_links")
+      .select("*")
+      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
 
     if (error) {
-      console.error('Error fetching links:', error)
-      return links
+      console.error("Error fetching links:", error);
+      return links;
     }
 
-    if (data.length < PAGE_SIZE) fetchMore = false
+    if (data.length < PAGE_SIZE) fetchMore = false;
 
-    links = links.concat(data)
-    page++
+    links = links.concat(data);
+    page++;
   }
 
-  return links
-}
+  return links;
+};
 
 export default async function () {
   try {
-    return await fetchAllLinks()
+    return await fetchAllLinks();
   } catch (error) {
-    console.error('Error fetching and processing links:', error)
-    return []
+    console.error("Error fetching and processing links:", error);
+    return [];
   }
-}
+}

src/data/movies.js

@@ -1,62 +1,67 @@
-import { createClient } from '@supabase/supabase-js'
-import { DateTime } from 'luxon'
+import { createClient } from "@supabase/supabase-js";
+import { DateTime } from "luxon";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 1000
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 1000;
 
 const fetchAllMovies = async () => {
-  let movies = []
-  let rangeStart = 0
+  let movies = [];
+  let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_movies')
-      .select('*')
-      .range(rangeStart, rangeStart + PAGE_SIZE - 1)
+      .from("optimized_movies")
+      .select("*")
+      .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
     if (error) {
-      console.error('Error fetching movies:', error)
-      break
+      console.error("Error fetching movies:", error);
+      break;
     }
 
-    movies = movies.concat(data)
+    movies = movies.concat(data);
 
-    if (data.length < PAGE_SIZE) break
-    rangeStart += PAGE_SIZE
+    if (data.length < PAGE_SIZE) break;
+    rangeStart += PAGE_SIZE;
   }
 
-  return movies
-}
+  return movies;
+};
 
 export default async function () {
-  const year = DateTime.now().year
+  const year = DateTime.now().year;
 
   try {
-    const movies = await fetchAllMovies()
-    const favoriteMovies = movies.filter(movie => movie['favorite'])
+    const movies = await fetchAllMovies();
+    const favoriteMovies = movies.filter((movie) => movie["favorite"]);
     const now = DateTime.now();
-    const recentlyWatchedMovies = movies.filter(movie => {
-        const lastWatched = movie['last_watched']
-        return (lastWatched && now.diff(DateTime.fromISO(lastWatched), 'months').months <= 6)
-    })
+    const recentlyWatchedMovies = movies.filter((movie) => {
+      const lastWatched = movie["last_watched"];
+      return (
+        lastWatched &&
+        now.diff(DateTime.fromISO(lastWatched), "months").months <= 6
+      );
+    });
 
     return {
       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']),
-    }
+      favorites: favoriteMovies.sort((a, b) =>
+        a["title"].localeCompare(b["title"])
+      ),
+      feed: movies.filter((movie) => movie["feed"]),
+    };
   } catch (error) {
-    console.error('Error fetching and processing movies data:', error)
+    console.error("Error fetching and processing movies data:", error);
     return {
       movies: [],
       watchHistory: [],
       recentlyWatched: [],
       favorites: [],
-      feed: []
-    }
+      feed: [],
+    };
   }
-}
+}

src/data/music.js

@@ -1,35 +1,35 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 1000
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 1000;
 
 const fetchDataFromView = async (viewName) => {
-  let rows = []
-  let rangeStart = 0
+  let rows = [];
+  let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
       .from(viewName)
-      .select('*')
-      .range(rangeStart, rangeStart + PAGE_SIZE - 1)
+      .select("*")
+      .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
     if (error) {
-      console.error(`Error fetching data from view ${viewName}:`, error)
-      break
+      console.error(`Error fetching data from view ${viewName}:`, error);
+      break;
     }
 
-    if (data.length === 0) break
+    if (data.length === 0) break;
 
-    rows = [...rows, ...data]
+    rows = [...rows, ...data];
 
-    if (data.length < PAGE_SIZE) break
-    rangeStart += PAGE_SIZE
+    if (data.length < PAGE_SIZE) break;
+    rangeStart += PAGE_SIZE;
   }
 
-  return rows
-}
+  return rows;
+};
 
 export default async function fetchMusicData() {
   try {
@@ -44,16 +44,16 @@ export default async function fetchMusicData() {
       monthAlbums,
       monthGenres,
     ] = await Promise.all([
-      fetchDataFromView('recent_tracks'),
-      fetchDataFromView('week_tracks'),
-      fetchDataFromView('week_artists'),
-      fetchDataFromView('week_albums'),
-      fetchDataFromView('week_genres'),
-      fetchDataFromView('month_tracks'),
-      fetchDataFromView('month_artists'),
-      fetchDataFromView('month_albums'),
-      fetchDataFromView('month_genres'),
-    ])
+      fetchDataFromView("recent_tracks"),
+      fetchDataFromView("week_tracks"),
+      fetchDataFromView("week_artists"),
+      fetchDataFromView("week_albums"),
+      fetchDataFromView("week_genres"),
+      fetchDataFromView("month_tracks"),
+      fetchDataFromView("month_artists"),
+      fetchDataFromView("month_albums"),
+      fetchDataFromView("month_genres"),
+    ]);
 
     return {
       recent: recentTracks,
@@ -64,7 +64,7 @@ export default async function fetchMusicData() {
         genres: weekGenres,
         totalTracks: weekTracks
           .reduce((acc, track) => acc + track.plays, 0)
-          .toLocaleString('en-US'),
+          .toLocaleString("en-US"),
       },
       month: {
         tracks: monthTracks,
@@ -73,11 +73,11 @@ export default async function fetchMusicData() {
         genres: monthGenres,
         totalTracks: monthTracks
           .reduce((acc, track) => acc + track.plays, 0)
-          .toLocaleString('en-US'),
+          .toLocaleString("en-US"),
       },
-    }
+    };
   } catch (error) {
-    console.error('Error fetching and processing music data:', error)
-    return {}
+    console.error("Error fetching and processing music data:", error);
+    return {};
   }
-}
+}

src/data/nav.js

@@ -1,48 +1,48 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
 const fetchAllNavigation = async () => {
   const { data, error } = await supabase
-    .from('optimized_navigation')
-    .select('*')
+    .from("optimized_navigation")
+    .select("*");
 
   if (error) {
-    console.error('Error fetching navigation data:', error)
-    return {}
+    console.error("Error fetching navigation data:", error);
+    return {};
   }
 
   const menu = data.reduce((acc, item) => {
     const menuItem = {
-      title: item['title'] || item['page_title'],
-      permalink: item['permalink'] || item ['page_permalink'],
-      icon: item['icon'],
-      sort: item['sort']
-    }
+      title: item["title"] || item["page_title"],
+      permalink: item["permalink"] || item["page_permalink"],
+      icon: item["icon"],
+      sort: item["sort"],
+    };
 
-    if (!acc[item['menu_location']]) {
-      acc[item['menu_location']] = [menuItem]
+    if (!acc[item["menu_location"]]) {
+      acc[item["menu_location"]] = [menuItem];
     } else {
-      acc[item['menu_location']].push(menuItem)
+      acc[item["menu_location"]].push(menuItem);
     }
 
-    return acc
-  }, {})
+    return acc;
+  }, {});
 
-  Object.keys(menu).forEach(location => {
-    menu[location].sort((a, b) => a['sort'] - b['sort'])
-  })
+  Object.keys(menu).forEach((location) => {
+    menu[location].sort((a, b) => a["sort"] - b["sort"]);
+  });
 
-  return menu
-}
+  return menu;
+};
 
 export default async function () {
   try {
-    return await fetchAllNavigation()
+    return await fetchAllNavigation();
   } catch (error) {
-    console.error('Error fetching and processing navigation data:', error)
-    return {}
+    console.error("Error fetching and processing navigation data:", error);
+    return {};
   }
-}
+}

src/data/nowPlaying.js

@@ -1,33 +1,35 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
 
 const fetchNowPlaying = async () => {
   const { data, error } = await supabase
-    .from('optimized_latest_listen')
-    .select('*')
-    .single()
+    .from("optimized_latest_listen")
+    .select("*")
+    .single();
 
   if (error) {
-    console.error('Error fetching the latest track:', error)
-    return {}
+    console.error("Error fetching the latest track:", error);
+    return {};
   }
 
-  const genreEmoji = data.genre_emoji
-  const emoji = data.artist_emoji || genreEmoji
+  const genreEmoji = data.genre_emoji;
+  const emoji = data.artist_emoji || genreEmoji;
 
   return {
-    content: `${emoji || '🎧'} ${data.track_name} by <a href="https://coryd.dev${data.url}">${data.artist_name}</a>`,
-  }
-}
+    content: `${emoji || "🎧"} ${
+      data.track_name
+    } by <a href="https://coryd.dev${data.url}">${data.artist_name}</a>`,
+  };
+};
 
 export default async function () {
   try {
-    return await fetchNowPlaying()
+    return await fetchNowPlaying();
   } catch (error) {
-    console.error('Error fetching and processing now-playing data:', error)
-    return {}
+    console.error("Error fetching and processing now-playing data:", error);
+    return {};
   }
-}
+}

src/data/pages.js

@@ -1,40 +1,40 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env['SUPABASE_URL']
-const SUPABASE_KEY = process.env['SUPABASE_KEY']
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 250
+const SUPABASE_URL = process.env["SUPABASE_URL"];
+const SUPABASE_KEY = process.env["SUPABASE_KEY"];
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 250;
 
 const fetchAllPages = async () => {
-  let pages = []
-  let page = 0
-  let fetchMore = true
+  let pages = [];
+  let page = 0;
+  let fetchMore = true;
 
   while (fetchMore) {
     const { data, error } = await supabase
-      .from('optimized_pages')
-      .select('*')
-      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1)
+      .from("optimized_pages")
+      .select("*")
+      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
 
     if (error) {
-      console.error('Error fetching pages:', error)
-      return pages
+      console.error("Error fetching pages:", error);
+      return pages;
     }
 
-    if (data.length < PAGE_SIZE) fetchMore = false
+    if (data.length < PAGE_SIZE) fetchMore = false;
 
-    pages = pages.concat(data)
-    page++
+    pages = pages.concat(data);
+    page++;
   }
 
-  return pages
-}
+  return pages;
+};
 
 export default async function () {
   try {
-    return await fetchAllPages()
+    return await fetchAllPages();
   } catch (error) {
-    console.error('Error fetching and processing pages:', error)
-    return []
+    console.error("Error fetching and processing pages:", error);
+    return [];
   }
-}
+}

src/data/posts.js

@@ -1,41 +1,41 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env['SUPABASE_URL']
-const SUPABASE_KEY = process.env['SUPABASE_KEY']
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 1000
+const SUPABASE_URL = process.env["SUPABASE_URL"];
+const SUPABASE_KEY = process.env["SUPABASE_KEY"];
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 1000;
 
 const fetchAllPosts = async () => {
-  let posts = []
-  let page = 0
-  let fetchMore = true
+  let posts = [];
+  let page = 0;
+  let fetchMore = true;
 
   while (fetchMore) {
     const { data, error } = await supabase
-      .from('optimized_posts')
-      .select('*')
-      .order('date', { ascending: false })
-      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1)
+      .from("optimized_posts")
+      .select("*")
+      .order("date", { ascending: false })
+      .range(page * PAGE_SIZE, (page + 1) * PAGE_SIZE - 1);
 
     if (error) {
-      console.error('Error fetching posts:', 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)
-    page++
+    posts = posts.concat(data);
+    page++;
   }
 
-  return posts
-}
+  return posts;
+};
 
 export default async function () {
   try {
-    return await fetchAllPosts()
+    return await fetchAllPosts();
   } catch (error) {
-    console.error('Error fetching and processing posts:', error)
-    return []
+    console.error("Error fetching and processing posts:", error);
+    return [];
   }
-}
+}

src/data/robots.js

@@ -1,38 +1,40 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 500
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 500;
 
 const fetchAllRobots = async () => {
-  let robots = []
-  let from = 0
+  let robots = [];
+  let from = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('robots')
-      .select('user_agent')
-      .range(from, from + PAGE_SIZE - 1)
+      .from("robots")
+      .select("user_agent")
+      .range(from, from + PAGE_SIZE - 1);
 
     if (error) {
-      console.error('Error fetching robot data:', error)
-      return []
+      console.error("Error fetching robot data:", error);
+      return [];
     }
 
-    robots = robots.concat(data)
-    if (data.length < PAGE_SIZE) break
-    from += PAGE_SIZE
+    robots = robots.concat(data);
+    if (data.length < PAGE_SIZE) break;
+    from += PAGE_SIZE;
   }
 
-  return robots.map(robot => robot['user_agent']).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))
-}
+  return robots
+    .map((robot) => robot["user_agent"])
+    .sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+};
 
 export default async function () {
   try {
-    return await fetchAllRobots()
+    return await fetchAllRobots();
   } catch (error) {
-    console.error('Error fetching and processing robot data:', error)
-    return []
+    console.error("Error fetching and processing robot data:", error);
+    return [];
   }
-}
+}

src/data/syndication.js

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

src/data/tv.js

@@ -1,61 +1,65 @@
-import { createClient } from '@supabase/supabase-js'
+import { createClient } from "@supabase/supabase-js";
 
-const SUPABASE_URL = process.env.SUPABASE_URL
-const SUPABASE_KEY = process.env.SUPABASE_KEY
-const supabase = createClient(SUPABASE_URL, SUPABASE_KEY)
-const PAGE_SIZE = 1000
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+const PAGE_SIZE = 1000;
 
 const fetchAllShows = async () => {
-  let shows = []
-  let rangeStart = 0
+  let shows = [];
+  let rangeStart = 0;
 
   while (true) {
     const { data, error } = await supabase
-      .from('optimized_shows')
-      .select('*')
-      .range(rangeStart, rangeStart + PAGE_SIZE - 1)
+      .from("optimized_shows")
+      .select("*")
+      .range(rangeStart, rangeStart + PAGE_SIZE - 1);
 
     if (error) {
-      console.error('Error fetching shows:', error)
-      break
+      console.error("Error fetching shows:", error);
+      break;
     }
 
-    shows = shows.concat(data)
-    if (data.length < PAGE_SIZE) break
-    rangeStart += PAGE_SIZE
+    shows = shows.concat(data);
+    if (data.length < PAGE_SIZE) break;
+    rangeStart += PAGE_SIZE;
   }
 
-  return shows
-}
+  return shows;
+};
 
 export default async function () {
   try {
-    const shows = await fetchAllShows()
-    const watchedShows = shows.filter(show => show['last_watched_at'] !== null)
-    const episodes = watchedShows.map(show => ({
-      title: show['episode']['title'],
-      year: show['year'],
-      formatted_episode: show['episode']['formatted_episode'],
-      url: show['episode']['url'],
-      image: show['episode']['image'],
-      backdrop: show['episode']['backdrop'],
-      last_watched_at: show['episode']['last_watched_at'],
-      grid: show['grid'],
-      type: 'tv'
-    }))
+    const shows = await fetchAllShows();
+    const watchedShows = shows.filter(
+      (show) => show["last_watched_at"] !== null
+    );
+    const episodes = watchedShows.map((show) => ({
+      title: show["episode"]["title"],
+      year: show["year"],
+      formatted_episode: show["episode"]["formatted_episode"],
+      url: show["episode"]["url"],
+      image: show["episode"]["image"],
+      backdrop: show["episode"]["backdrop"],
+      last_watched_at: show["episode"]["last_watched_at"],
+      grid: show["grid"],
+      type: "tv",
+    }));
 
     return {
       shows,
       recentlyWatched: episodes.slice(0, 125),
-      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)),
+    };
   } catch (error) {
-    console.error('Error fetching and processing shows data:', error)
+    console.error("Error fetching and processing shows data:", error);
 
     return {
       shows: [],
       recentlyWatched: [],
       favorites: [],
-    }
+    };
   }
-}
+}