chore(*.sql): use sql-formatter for sql formatting

.husky/pre-commit

@@ -1 +1,2 @@
 npx lint-staged
+npm run format:sql

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "coryd.dev",
-  "version": "10.2.4",
+  "version": "10.3.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "coryd.dev",
-      "version": "10.2.4",
+      "version": "10.3.4",
       "license": "MIT",
       "dependencies": {
         "minisearch": "^7.1.2",
@@ -34,6 +34,7 @@
         "postcss-import-ext-glob": "^2.1.1",
         "prettier": "3.5.3",
         "rimraf": "^6.0.1",
+        "sql-formatter": "15.6.4",
         "terser": "^5.42.0",
         "truncate-html": "^1.2.2"
       },
@@ -1422,6 +1423,13 @@
         "node": ">=4"
       }
     },
+    "node_modules/discontinuous-range": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/discontinuous-range/-/discontinuous-range-1.0.0.tgz",
+      "integrity": "sha512-c68LpLbO+7kP/b1Hr1qs8/BJ09F5khZGTxqxZuhzxpmwJKOgRFHJWIb9/KmqnqHhLdO55aOxFH/EGBvUQbL/RQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/dom-serializer": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
@@ -2858,6 +2866,36 @@
         "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
+    "node_modules/nearley": {
+      "version": "2.20.1",
+      "resolved": "https://registry.npmjs.org/nearley/-/nearley-2.20.1.tgz",
+      "integrity": "sha512-+Mc8UaAebFzgV+KpI5n7DasuuQCHA89dmwm7JXw3TV43ukfNQ9DnBH3Mdb2g/I4Fdxc26pwimBWvjIw0UAILSQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "commander": "^2.19.0",
+        "moo": "^0.5.0",
+        "railroad-diagrams": "^1.0.0",
+        "randexp": "0.4.6"
+      },
+      "bin": {
+        "nearley-railroad": "bin/nearley-railroad.js",
+        "nearley-test": "bin/nearley-test.js",
+        "nearley-unparse": "bin/nearley-unparse.js",
+        "nearleyc": "bin/nearleyc.js"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://nearley.js.org/#give-to-nearley"
+      }
+    },
+    "node_modules/nearley/node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/no-case": {
       "version": "3.0.4",
       "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz",
@@ -3930,6 +3968,27 @@
       ],
       "license": "MIT"
     },
+    "node_modules/railroad-diagrams": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/railroad-diagrams/-/railroad-diagrams-1.0.0.tgz",
+      "integrity": "sha512-cz93DjNeLY0idrCNOH6PviZGRN9GJhsdm9hpn1YCS879fj4W+x5IFJhhkRZcwVgMmFF7R82UA/7Oh+R8lLZg6A==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
+    "node_modules/randexp": {
+      "version": "0.4.6",
+      "resolved": "https://registry.npmjs.org/randexp/-/randexp-0.4.6.tgz",
+      "integrity": "sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "discontinuous-range": "1.0.0",
+        "ret": "~0.1.10"
+      },
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
     "node_modules/range-parser": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
@@ -4034,6 +4093,16 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/ret": {
+      "version": "0.1.15",
+      "resolved": "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz",
+      "integrity": "sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12"
+      }
+    },
     "node_modules/reusify": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
@@ -4321,6 +4390,20 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
+    "node_modules/sql-formatter": {
+      "version": "15.6.4",
+      "resolved": "https://registry.npmjs.org/sql-formatter/-/sql-formatter-15.6.4.tgz",
+      "integrity": "sha512-osSvFAtUu/SqT4ywdPTraCHR/VzMjeG+cXFEGwJJtm2SoA/uewU6Sm2HYyqo6W7VTGSWUWx7WT8KkE3HJq51cA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1",
+        "nearley": "^2.20.1"
+      },
+      "bin": {
+        "sql-formatter": "bin/sql-formatter-cli.cjs"
+      }
+    },
     "node_modules/ssri": {
       "version": "11.0.0",
       "resolved": "https://registry.npmjs.org/ssri/-/ssri-11.0.0.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "coryd.dev",
-  "version": "10.2.4",
+  "version": "10.3.4",
   "description": "The source for my personal site. Built using 11ty (and other tools).",
   "type": "module",
   "engines": {
@@ -13,7 +13,8 @@
     "php": "export $(grep -v '^#' .env | xargs) && php -d error_reporting=E_ALL^E_DEPRECATED -S localhost:8080 -t dist",
     "build": "eleventy",
     "clean": "rimraf dist .cache",
-    "format": "npx prettier --write '**/*.{js,ts,json,css,md}' && composer format:php",
+    "format": "npx prettier --write '**/*.{js,ts,json,css,md}' && composer format:php && npm run format:sql",
+    "format:sql": "find queries -name '*.sql' -print0 | xargs -0 -n 1 sql-formatter --language postgresql --fix",
     "update": "composer update && npm upgrade && npm --prefix cli upgrade && ncu && ncu --cwd cli",
     "setup": "sh ./scripts/setup.sh",
     "setup:deploy": "sh ./scripts/setup.sh  --deploy",
@@ -60,6 +61,7 @@
     "postcss-import-ext-glob": "^2.1.1",
     "prettier": "3.5.3",
     "rimraf": "^6.0.1",
+    "sql-formatter": "15.6.4",
     "terser": "^5.42.0",
     "truncate-html": "^1.2.2"
   }

queries/functions/get_feed_data.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION get_feed_data(feed_key TEXT)
+CREATE OR REPLACE FUNCTION get_feed_data (feed_key TEXT) RETURNS JSON AS $$
-RETURNS JSON AS $$
 DECLARE
   result JSON;
   sql_query TEXT;

queries/functions/get_tagged_content.sql

@@ -1,9 +1,8 @@
-CREATE OR REPLACE FUNCTION get_tagged_content(
+CREATE OR REPLACE FUNCTION get_tagged_content (
   tag_query TEXT,
   page_size INTEGER DEFAULT 20,
   page_offset INTEGER DEFAULT 0
-)
+) RETURNS TABLE (
-RETURNS TABLE (
   tag TEXT,
   title TEXT,
   url TEXT,

queries/functions/get_top_tags.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION get_top_tag_groups()
+CREATE OR REPLACE FUNCTION get_top_tag_groups () RETURNS JSON AS $$
-RETURNS JSON AS $$
 BEGIN
   RETURN json_build_object(
     'tags', (

queries/functions/parse_country_field.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION normalize_country_field(countryField TEXT)
+CREATE OR REPLACE FUNCTION normalize_country_field (countryField TEXT) RETURNS TEXT AS $$
-RETURNS TEXT AS $$
 DECLARE
   delimiters TEXT[] := ARRAY[',', '/', '&', 'and'];
   countries TEXT[];

queries/functions/search.sql

@@ -1,21 +1,24 @@
-DROP FUNCTION IF EXISTS search_optimized_index(text, integer, integer, text[]);
+DROP FUNCTION IF EXISTS search_optimized_index (text, integer, integer, text[]);
 
-CREATE FUNCTION search_optimized_index(search_query text, page_size integer, page_offset integer, sections text[])
+CREATE FUNCTION search_optimized_index (
-  RETURNS TABLE(
+  search_query text,
-    result_id integer,
+  page_size integer,
-    url text,
+  page_offset integer,
-    title text,
+  sections text[]
-    description text,
+) RETURNS TABLE (
-    tags text[],
+  result_id integer,
-    genre_name text,
+  url text,
-    genre_url text,
+  title text,
-    section text,
+  description text,
-    type text,
+  tags text[],
-    total_plays text,
+  genre_name text,
-    rank real,
+  genre_url text,
-    total_count bigint
+  section text,
-  )
+  type text,
-  AS $$
+  total_plays text,
+  rank real,
+  total_count bigint
+) AS $$
 BEGIN
   RETURN QUERY
   SELECT
@@ -42,5 +45,4 @@ BEGIN
     rank DESC
   LIMIT page_size OFFSET page_offset;
 END;
-$$
+$$ LANGUAGE plpgsql;
-LANGUAGE plpgsql;

queries/functions/slugify.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION slugify(input TEXT)
+CREATE OR REPLACE FUNCTION slugify (input TEXT) RETURNS TEXT AS $$
-RETURNS TEXT AS $$
 BEGIN
   RETURN lower(regexp_replace(unaccent(regexp_replace(input, '[^\w\s-]', '', 'g')), '\s+', '-', 'g'));
 END;

queries/functions/update_album_key.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION update_album_key(old_album_key TEXT, new_album_key TEXT)
+CREATE OR REPLACE FUNCTION update_album_key (old_album_key TEXT, new_album_key TEXT) RETURNS void AS $$
-RETURNS void AS $$
 BEGIN
   UPDATE listens
   SET album_key = new_album_key

queries/functions/update_artist_key.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION update_artist_name(old_artist_name TEXT, new_artist_name TEXT)
+CREATE OR REPLACE FUNCTION update_artist_name (old_artist_name TEXT, new_artist_name TEXT) RETURNS void AS $$
-RETURNS void AS $$
 BEGIN
   UPDATE listens
   SET artist_name = new_artist_name

queries/functions/update_days_read.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION update_days_read()
+CREATE OR REPLACE FUNCTION update_days_read () RETURNS TRIGGER AS $$
-RETURNS TRIGGER AS $$
 DECLARE
   pacific_today DATE;
   last_read DATE;

queries/functions/update_listen_totals.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION update_listen_totals()
+CREATE OR REPLACE FUNCTION update_listen_totals () RETURNS void AS $$
-RETURNS void AS $$
 BEGIN
   WITH artist_plays AS (
     SELECT artist_name, COUNT(*)::integer AS total_plays

queries/functions/update_scheduled_episode_status.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION update_scheduled_episode_status()
+CREATE OR REPLACE FUNCTION update_scheduled_episode_status () RETURNS TRIGGER AS $$
-RETURNS TRIGGER AS $$
 BEGIN
   UPDATE scheduled_episodes
   SET status = 'aired'

queries/functions/update_scheduled_on_watch.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION update_scheduled_on_watch()
+CREATE OR REPLACE FUNCTION update_scheduled_on_watch () RETURNS TRIGGER AS $$
-RETURNS TRIGGER AS $$
 BEGIN
   UPDATE scheduled_episodes
   SET status = 'watched'

queries/jobs/update_scheduled_episodes.sql

@@ -1,6 +1,8 @@
-SELECT cron.schedule(
+SELECT
-  '0 0 * * *',
+  cron.schedule (
-  $$ UPDATE scheduled_episodes
+    '0 0 * * *',
+    $$ UPDATE scheduled_episodes
      SET status = 'aired'
      WHERE air_date < CURRENT_DATE
-     AND status = 'upcoming' $$);
+     AND status = 'upcoming' $$
+  );

queries/selects/top_albums.sql

@@ -5,7 +5,15 @@ SELECT
 FROM
   optimized_listens l
 WHERE
-  EXTRACT(YEAR FROM TO_TIMESTAMP(l.listened_at)) = EXTRACT(YEAR FROM CURRENT_DATE)
+  EXTRACT(
+    YEAR
+    FROM
+      TO_TIMESTAMP(l.listened_at)
+  ) = EXTRACT(
+    YEAR
+    FROM
+      CURRENT_DATE
+  )
   AND l.artist_name IS NOT NULL
   AND l.album_name IS NOT NULL
 GROUP BY
@@ -13,4 +21,5 @@ GROUP BY
   l.album_name
 ORDER BY
   COUNT(l.id) DESC
-LIMIT 10;
+LIMIT
+  10;

queries/selects/top_artists.sql

@@ -4,10 +4,19 @@ SELECT
 FROM
   optimized_listens l
 WHERE
-  EXTRACT(YEAR FROM TO_TIMESTAMP(l.listened_at)) = EXTRACT(YEAR FROM CURRENT_DATE)
+  EXTRACT(
+    YEAR
+    FROM
+      TO_TIMESTAMP(l.listened_at)
+  ) = EXTRACT(
+    YEAR
+    FROM
+      CURRENT_DATE
+  )
   AND l.artist_name IS NOT NULL
 GROUP BY
   l.artist_name
 ORDER BY
   COUNT(l.id) DESC
-LIMIT 10;
+LIMIT
+  10;

queries/triggers/decrement_total_plays.sql

@@ -1,17 +1,30 @@
 BEGIN
-  UPDATE artists
+UPDATE artists
-  SET total_plays = total_plays - 1
+SET
-  WHERE name_string = OLD.artist_name;
+  total_plays = total_plays - 1
-  UPDATE albums
+WHERE
-  SET total_plays = total_plays - 1
+  name_string = OLD.artist_name;
-  WHERE name = OLD.album_name
+
-    AND artist_name = OLD.artist_name;
+UPDATE albums
-  UPDATE genres
+SET
-  SET total_plays = total_plays - 1
+  total_plays = total_plays - 1
-  WHERE id = (
+WHERE
-    SELECT genres
+  name = OLD.album_name
-    FROM artists
+  AND artist_name = OLD.artist_name;
-    WHERE name_string = OLD.artist_name
+
+UPDATE genres
+SET
+  total_plays = total_plays - 1
+WHERE
+  id = (
+    SELECT
+      genres
+    FROM
+      artists
+    WHERE
+      name_string = OLD.artist_name
   );
-  RETURN OLD;
+
+RETURN OLD;
+
 END;

queries/triggers/mark_scheduled_as_watched.sql

@@ -1,4 +1,3 @@
 CREATE TRIGGER mark_scheduled_as_watched
-AFTER INSERT ON episodes
+AFTER INSERT ON episodes FOR EACH ROW
-FOR EACH ROW
+EXECUTE FUNCTION update_scheduled_on_watch ();
-EXECUTE FUNCTION update_scheduled_on_watch();

queries/triggers/update_days_read.sql

@@ -1,5 +1,10 @@
 CREATE TRIGGER trigger_update_days_read
-AFTER UPDATE OF progress ON books
+AFTER
-FOR EACH ROW
+UPDATE OF progress ON books FOR EACH ROW WHEN (
-WHEN (OLD.progress IS DISTINCT FROM NEW.progress AND (NEW.read_status = 'started' OR NEW.read_status = 'finished'))
+  OLD.progress IS DISTINCT FROM NEW.progress
-EXECUTE FUNCTION update_days_read();
+  AND (
+    NEW.read_status = 'started'
+    OR NEW.read_status = 'finished'
+  )
+)
+EXECUTE FUNCTION update_days_read ();

queries/triggers/update_scheduled_status.sql

@@ -1,5 +1,4 @@
-CREATE OR REPLACE FUNCTION update_scheduled_episode_status()
+CREATE OR REPLACE FUNCTION update_scheduled_episode_status () RETURNS TRIGGER AS $$
-RETURNS TRIGGER AS $$
 BEGIN
   IF NEW.air_date < CURRENT_DATE AND NEW.status = 'upcoming' THEN
     NEW.status := 'aired';

queries/triggers/update_total_plays.sql

@@ -1,17 +1,30 @@
 BEGIN
-  UPDATE artists
+UPDATE artists
-  SET total_plays = total_plays + 1
+SET
-  WHERE name_string = NEW.artist_name;
+  total_plays = total_plays + 1
-  UPDATE albums
+WHERE
-  SET total_plays = total_plays + 1
+  name_string = NEW.artist_name;
-  WHERE key = NEW.album_key
+
-    AND artist_name = NEW.artist_name;
+UPDATE albums
-  UPDATE genres
+SET
-  SET total_plays = total_plays + 1
+  total_plays = total_plays + 1
-  WHERE id = (
+WHERE
-    SELECT genres
+  key = NEW.album_key
-    FROM artists
+  AND artist_name = NEW.artist_name;
-    WHERE name_string = NEW.artist_name
+
+UPDATE genres
+SET
+  total_plays = total_plays + 1
+WHERE
+  id = (
+    SELECT
+      genres
+    FROM
+      artists
+    WHERE
+      name_string = NEW.artist_name
   );
-  RETURN NEW;
+
+RETURN NEW;
+
 END;

queries/views/content/blogroll.sql

@@ -6,6 +6,9 @@ SELECT
   json_feed,
   newsletter,
   mastodon
-FROM authors
+FROM
-WHERE blogroll = true
+  authors
-ORDER BY LOWER(unaccent(name)) ASC;
+WHERE
+  blogroll = true
+ORDER BY
+  LOWER(unaccent (name)) ASC;

queries/views/content/links.sql

@@ -7,24 +7,45 @@ SELECT
   l.link,
   a.mastodon,
   a.name,
-  json_build_object('name', a.name, 'url', a.url, 'mastodon', a.mastodon) AS author,
+  json_build_object(
+    'name',
+    a.name,
+    'url',
+    a.url,
+    'mastodon',
+    a.mastodon
+  ) AS author,
   'link' AS type,
   (
-    SELECT array_agg(t.name)
+    SELECT
-    FROM links_tags lt
+      array_agg(t.name)
-    LEFT JOIN tags t ON lt.tags_id = t.id
+    FROM
-    WHERE lt.links_id = l.id
+      links_tags lt
+      LEFT JOIN tags t ON lt.tags_id = t.id
+    WHERE
+      lt.links_id = l.id
   ) AS tags,
   json_build_object(
-    'title', CONCAT(l.title, ' via ', a.name),
+    'title',
-    'url', l.link,
+    CONCAT(l.title, ' via ', a.name),
-    'description', l.description,
+    'url',
-    'date', l.date
+    l.link,
+    'description',
+    l.description,
+    'date',
+    l.date
   ) AS feed
 FROM
   links l
   JOIN authors a ON l.author = a.id
 GROUP BY
-  l.id, l.title, l.date, l.description, l.link, a.mastodon, a.name, a.url
+  l.id,
+  l.title,
+  l.date,
+  l.description,
+  l.link,
+  a.mastodon,
+  a.name,
+  a.url
 ORDER BY
   l.date DESC;

queries/views/content/posts.sql

@@ -8,183 +8,367 @@ SELECT
   p.featured,
   p.slug AS url,
   CASE
-    WHEN df.filename_disk IS NOT NULL AND df.filename_disk != '' AND df.filename_disk != '/' THEN
+    WHEN df.filename_disk IS NOT NULL
-      CONCAT(globals.cdn_url, '/', df.filename_disk)
+    AND df.filename_disk != ''
+    AND df.filename_disk != '/' THEN CONCAT(globals.cdn_url, '/', df.filename_disk)
     ELSE NULL
   END AS image,
   p.image_alt,
-  CASE WHEN EXTRACT(YEAR FROM AGE(CURRENT_DATE, p.date)) > 3 THEN TRUE ELSE FALSE END AS old_post,
+  CASE
+    WHEN EXTRACT(
+      YEAR
+      FROM
+        AGE (CURRENT_DATE, p.date)
+    ) > 3 THEN TRUE
+    ELSE FALSE
+  END AS old_post,
   (
-    SELECT json_agg(CASE
+    SELECT
-      WHEN pb.collection = 'youtube_player' THEN json_build_object('type', pb.collection, 'url', yp.url)
+      json_agg(
-      WHEN pb.collection = 'forgejo_banner' THEN json_build_object('type', pb.collection, 'url', fb.url)
+        CASE
-      WHEN pb.collection = 'github_banner' THEN json_build_object('type', pb.collection, 'url', gb.url)
+          WHEN pb.collection = 'youtube_player' THEN json_build_object('type', pb.collection, 'url', yp.url)
-      WHEN pb.collection = 'npm_banner' THEN json_build_object('type', pb.collection, 'url', nb.url, 'command', nb.command)
+          WHEN pb.collection = 'forgejo_banner' THEN json_build_object('type', pb.collection, 'url', fb.url)
-      WHEN pb.collection = 'rss_banner' THEN json_build_object('type', pb.collection, 'url', rb.url, 'text', rb.text)
+          WHEN pb.collection = 'github_banner' THEN json_build_object('type', pb.collection, 'url', gb.url)
-      WHEN pb.collection = 'calendar_banner' THEN json_build_object('type', pb.collection, 'url', cb.url, 'text', cb.text)
+          WHEN pb.collection = 'npm_banner' THEN json_build_object(
-      WHEN pb.collection = 'hero' THEN json_build_object('type', pb.collection, 'image', CONCAT('/', df_hero.filename_disk), 'alt_text', h.alt_text)
+            'type',
-      WHEN pb.collection = 'markdown' THEN json_build_object('type', pb.collection, 'text', md.text)
+            pb.collection,
-      ELSE json_build_object('type', pb.collection)
+            'url',
-    END)
+            nb.url,
-    FROM posts_blocks pb
+            'command',
-    LEFT JOIN youtube_player yp ON pb.collection = 'youtube_player' AND yp.id = pb.item::integer
+            nb.command
-    LEFT JOIN forgejo_banner fb ON pb.collection = 'forgejo_banner' AND fb.id = pb.item::integer
+          )
-    LEFT JOIN github_banner gb ON pb.collection = 'github_banner' AND gb.id = pb.item::integer
+          WHEN pb.collection = 'rss_banner' THEN json_build_object(
-    LEFT JOIN npm_banner nb ON pb.collection = 'npm_banner' AND nb.id = pb.item::integer
+            'type',
-    LEFT JOIN rss_banner rb ON pb.collection = 'rss_banner' AND rb.id = pb.item::integer
+            pb.collection,
-    LEFT JOIN calendar_banner cb ON pb.collection = 'calendar_banner' AND cb.id = pb.item::integer
+            'url',
-    LEFT JOIN hero h ON pb.collection = 'hero' AND h.id = pb.item::integer
+            rb.url,
-    LEFT JOIN directus_files df_hero ON h.image = df_hero.id
+            'text',
-    LEFT JOIN markdown md ON pb.collection = 'markdown' AND md.id = pb.item::integer
+            rb.text
-    WHERE pb.posts_id = p.id
+          )
+          WHEN pb.collection = 'calendar_banner' THEN json_build_object(
+            'type',
+            pb.collection,
+            'url',
+            cb.url,
+            'text',
+            cb.text
+          )
+          WHEN pb.collection = 'hero' THEN json_build_object(
+            'type',
+            pb.collection,
+            'image',
+            CONCAT('/', df_hero.filename_disk),
+            'alt_text',
+            h.alt_text
+          )
+          WHEN pb.collection = 'markdown' THEN json_build_object('type', pb.collection, 'text', md.text)
+          ELSE json_build_object('type', pb.collection)
+        END
+      )
+    FROM
+      posts_blocks pb
+      LEFT JOIN youtube_player yp ON pb.collection = 'youtube_player'
+      AND yp.id = pb.item::integer
+      LEFT JOIN forgejo_banner fb ON pb.collection = 'forgejo_banner'
+      AND fb.id = pb.item::integer
+      LEFT JOIN github_banner gb ON pb.collection = 'github_banner'
+      AND gb.id = pb.item::integer
+      LEFT JOIN npm_banner nb ON pb.collection = 'npm_banner'
+      AND nb.id = pb.item::integer
+      LEFT JOIN rss_banner rb ON pb.collection = 'rss_banner'
+      AND rb.id = pb.item::integer
+      LEFT JOIN calendar_banner cb ON pb.collection = 'calendar_banner'
+      AND cb.id = pb.item::integer
+      LEFT JOIN hero h ON pb.collection = 'hero'
+      AND h.id = pb.item::integer
+      LEFT JOIN directus_files df_hero ON h.image = df_hero.id
+      LEFT JOIN markdown md ON pb.collection = 'markdown'
+      AND md.id = pb.item::integer
+    WHERE
+      pb.posts_id = p.id
   ) AS blocks,
   (
-    SELECT array_agg(t.name)
+    SELECT
-    FROM posts_tags pt
+      array_agg(t.name)
-    LEFT JOIN tags t ON pt.tags_id = t.id
+    FROM
-    WHERE pt.posts_id = p.id
+      posts_tags pt
+      LEFT JOIN tags t ON pt.tags_id = t.id
+    WHERE
+      pt.posts_id = p.id
   ) AS tags,
   (
-    SELECT json_agg(json_build_object('name', g.name, 'url', g.slug) ORDER BY g.name ASC)
+    SELECT
-    FROM posts_genres gp
+      json_agg(
-    LEFT JOIN genres g ON gp.genres_id = g.id
+        json_build_object('name', g.name, 'url', g.slug)
-    WHERE gp.posts_id = p.id
+        ORDER BY
+          g.name ASC
+      )
+    FROM
+      posts_genres gp
+      LEFT JOIN genres g ON gp.genres_id = g.id
+    WHERE
+      gp.posts_id = p.id
   ) AS genres,
   (
-    SELECT json_agg(json_build_object(
+    SELECT
-      'name', a.name_string,
+      json_agg(
-      'url', a.slug,
+        json_build_object(
-      'country', a.country,
+          'name',
-      'total_plays', a.total_plays,
+          a.name_string,
-      'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          'url',
-      'grid', json_build_object(
+          a.slug,
-        'title', a.name_string,
+          'country',
-        'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          a.country,
-        'alt', CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays of ', a.name_string),
+          'total_plays',
-        'subtext', CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays'),
+          a.total_plays,
-        'url', a.slug
+          'image',
-      ),
+          CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
-      'type', 'music'
+          'grid',
-    ) ORDER BY a.total_plays DESC)
+          json_build_object(
-    FROM posts_artists pa
+            'title',
-    LEFT JOIN artists a ON pa.artists_id = a.id
+            a.name_string,
-    LEFT JOIN directus_files df_artist ON a.art = df_artist.id
+            'image',
-    WHERE pa.posts_id = p.id
+            CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
-      AND a.total_plays IS NOT NULL AND a.total_plays > 0
+            'alt',
+            CONCAT(
+              to_char(a.total_plays, 'FM999,999,999,999'),
+              ' plays of ',
+              a.name_string
+            ),
+            'subtext',
+            CONCAT(
+              to_char(a.total_plays, 'FM999,999,999,999'),
+              ' plays'
+            ),
+            'url',
+            a.slug
+          ),
+          'type',
+          'music'
+        )
+        ORDER BY
+          a.total_plays DESC
+      )
+    FROM
+      posts_artists pa
+      LEFT JOIN artists a ON pa.artists_id = a.id
+      LEFT JOIN directus_files df_artist ON a.art = df_artist.id
+    WHERE
+      pa.posts_id = p.id
+      AND a.total_plays IS NOT NULL
+      AND a.total_plays > 0
   ) AS artists,
   (
-    SELECT json_agg(json_build_object(
+    SELECT
-      'title', b.title,
+      json_agg(
-      'author', b.author,
+        json_build_object(
-      'url', b.slug,
+          'title',
-      'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          b.title,
-      'grid', json_build_object(
+          'author',
-        'title', NULL,
+          b.author,
-        'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          'url',
-        'alt', CONCAT('Cover for ', b.title, ' by ', b.author),
+          b.slug,
-        'subtext', CASE WHEN b.star_rating IS NOT NULL THEN b.star_rating ELSE NULL END,
+          'image',
-        'url', b.slug
+          CONCAT(globals.cdn_url, '/', df_book.filename_disk),
-      ),
+          'grid',
-      'type', 'books'
+          json_build_object(
-    ) ORDER BY b.title ASC)
+            'title',
-    FROM posts_books pbk
+            NULL,
-    LEFT JOIN books b ON pbk.books_id = b.id
+            'image',
-    LEFT JOIN directus_files df_book ON b.art = df_book.id
+            CONCAT(globals.cdn_url, '/', df_book.filename_disk),
-    WHERE pbk.posts_id = p.id
+            'alt',
+            CONCAT('Cover for ', b.title, ' by ', b.author),
+            'subtext',
+            CASE
+              WHEN b.star_rating IS NOT NULL THEN b.star_rating
+              ELSE NULL
+            END,
+            'url',
+            b.slug
+          ),
+          'type',
+          'books'
+        )
+        ORDER BY
+          b.title ASC
+      )
+    FROM
+      posts_books pbk
+      LEFT JOIN books b ON pbk.books_id = b.id
+      LEFT JOIN directus_files df_book ON b.art = df_book.id
+    WHERE
+      pbk.posts_id = p.id
       AND LOWER(b.read_status) = 'finished'
   ) AS books,
   (
-    SELECT json_agg(json_build_object(
+    SELECT
-      'title', m.title,
+      json_agg(
-      'year', m.year,
+        json_build_object(
-      'url', m.slug,
+          'title',
-      'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          m.title,
-      'grid', json_build_object(
+          'year',
-        'title', NULL,
+          m.year,
-        'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          'url',
-        'alt', CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+          m.slug,
-        'subtext', CASE WHEN m.star_rating IS NOT NULL THEN m.star_rating::text ELSE m.year::text END,
+          'image',
-        'url', m.slug
+          CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
-      ),
+          'grid',
-      'type', 'movies'
+          json_build_object(
-    ) ORDER BY m.year ASC)
+            'title',
-    FROM posts_movies pm
+            NULL,
-    LEFT JOIN movies m ON pm.movies_id = m.id
+            'image',
-    LEFT JOIN directus_files df_movie ON m.art = df_movie.id
+            CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
-    WHERE pm.posts_id = p.id AND m.last_watched IS NOT NULL
+            'alt',
+            CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+            'subtext',
+            CASE
+              WHEN m.star_rating IS NOT NULL THEN m.star_rating::text
+              ELSE m.year::text
+            END,
+            'url',
+            m.slug
+          ),
+          'type',
+          'movies'
+        )
+        ORDER BY
+          m.year ASC
+      )
+    FROM
+      posts_movies pm
+      LEFT JOIN movies m ON pm.movies_id = m.id
+      LEFT JOIN directus_files df_movie ON m.art = df_movie.id
+    WHERE
+      pm.posts_id = p.id
+      AND m.last_watched IS NOT NULL
   ) AS movies,
   (
-    SELECT json_agg(json_build_object(
+    SELECT
-      'title', s.title,
+      json_agg(
-      'year', s.year,
+        json_build_object(
-      'url', s.slug,
+          'title',
-      'image', CONCAT(globals.cdn_url, '/', df_show.filename_disk),
+          s.title,
-      'grid', json_build_object(
+          'year',
-        'title', NULL,
+          s.year,
-        'image', CONCAT(globals.cdn_url, '/', df_show.filename_disk),
+          'url',
-        'alt', CONCAT('Artwork for ', s.title),
+          s.slug,
-        'subtext', CASE
+          'image',
-          WHEN (
+          CONCAT(globals.cdn_url, '/', df_show.filename_disk),
-            SELECT MAX(e1.last_watched_at)
+          'grid',
-            FROM episodes e1
+          json_build_object(
-            WHERE e1.show = s.id
+            'title',
-          ) >= NOW() - INTERVAL '90 days' THEN
+            NULL,
-            (
+            'image',
-              SELECT CONCAT('S', e2.season_number, 'E', e2.episode_number)
+            CONCAT(globals.cdn_url, '/', df_show.filename_disk),
-              FROM episodes e2
+            'alt',
-              WHERE e2.show = s.id
+            CONCAT('Artwork for ', s.title),
-              ORDER BY e2.last_watched_at DESC, e2.season_number DESC, e2.episode_number DESC
+            'subtext',
-              LIMIT 1
+            CASE
-            )
+              WHEN (
-          ELSE s.year::text
+                SELECT
-        END,
+                  MAX(e1.last_watched_at)
-        'url', s.slug
+                FROM
-      ),
+                  episodes e1
-      'type', 'tv'
+                WHERE
-    ) ORDER BY s.year ASC)
+                  e1.show = s.id
-    FROM posts_shows ps
+              ) >= NOW() - INTERVAL '90 days' THEN (
-    LEFT JOIN shows s ON ps.shows_id = s.id
+                SELECT
-    LEFT JOIN directus_files df_show ON s.art = df_show.id
+                  CONCAT('S', e2.season_number, 'E', e2.episode_number)
-    WHERE ps.posts_id = p.id
+                FROM
+                  episodes e2
+                WHERE
+                  e2.show = s.id
+                ORDER BY
+                  e2.last_watched_at DESC,
+                  e2.season_number DESC,
+                  e2.episode_number DESC
+                LIMIT
+                  1
+              )
+              ELSE s.year::text
+            END,
+            'url',
+            s.slug
+          ),
+          'type',
+          'tv'
+        )
+        ORDER BY
+          s.year ASC
+      )
+    FROM
+      posts_shows ps
+      LEFT JOIN shows s ON ps.shows_id = s.id
+      LEFT JOIN directus_files df_show ON s.art = df_show.id
+    WHERE
+      ps.posts_id = p.id
       AND EXISTS (
-        SELECT 1
+        SELECT
-        FROM episodes e
+          1
-        WHERE e.show = s.id
+        FROM
+          episodes e
+        WHERE
+          e.show = s.id
           AND e.last_watched_at IS NOT NULL
       )
   ) AS shows,
   json_build_object(
-    'title', p.title,
+    'title',
-    'url', p.slug,
+    p.title,
-    'description', p.description,
+    'url',
-    'content', p.content,
+    p.slug,
-    'date', p.date,
+    'description',
-    'image', CASE
+    p.description,
-      WHEN df.filename_disk IS NOT NULL AND df.filename_disk != '' AND df.filename_disk != '/' THEN CONCAT(globals.cdn_url, '/', df.filename_disk)
+    'content',
+    p.content,
+    'date',
+    p.date,
+    'image',
+    CASE
+      WHEN df.filename_disk IS NOT NULL
+      AND df.filename_disk != ''
+      AND df.filename_disk != '/' THEN CONCAT(globals.cdn_url, '/', df.filename_disk)
       ELSE NULL
     END
   ) AS feed,
   json_build_object(
-    'title', p.title,
+    'title',
-    'description', LEFT(
+    p.title,
+    'description',
+    LEFT(
       regexp_replace(
         regexp_replace(
           regexp_replace(p.description, E'[*_`~#>-]', '', 'g'),
-          E'\\[(.*?)\\]\\((.*?)\\)', E'\\1', 'g'
+          E'\\[(.*?)\\]\\((.*?)\\)',
+          E'\\1',
+          'g'
         ),
-        E'!\\[(.*?)\\]\\((.*?)\\)', '', 'g'
+        E'!\\[(.*?)\\]\\((.*?)\\)',
+        '',
+        'g'
       ),
       250
     ),
-    'open_graph_image', CASE
+    'open_graph_image',
-      WHEN df.filename_disk IS NOT NULL AND df.filename_disk != '' AND df.filename_disk != '/' THEN
+    CASE
-        CONCAT('/', df.filename_disk)
+      WHEN df.filename_disk IS NOT NULL
-      ELSE globals.metadata->>'open_graph_image'
+      AND df.filename_disk != ''
+      AND df.filename_disk != '/' THEN CONCAT('/', df.filename_disk)
+      ELSE globals.metadata ->> 'open_graph_image'
     END,
-    'url', CONCAT(globals.url, p.slug),
+    'url',
-    'type', 'article'
+    CONCAT(globals.url, p.slug),
+    'type',
+    'article'
   ) AS metadata
-FROM posts p
+FROM
-LEFT JOIN directus_files df ON p.image = df.id
+  posts p
-CROSS JOIN optimized_globals globals
+  LEFT JOIN directus_files df ON p.image = df.id
-GROUP BY p.id, df.filename_disk, globals.cdn_url, globals.site_name, globals.url, globals.metadata->>'open_graph_image';
+  CROSS JOIN optimized_globals globals
+GROUP BY
+  p.id,
+  df.filename_disk,
+  globals.cdn_url,
+  globals.site_name,
+  globals.url,
+  globals.metadata ->> 'open_graph_image';

queries/views/feeds/all_activity.sql

@@ -1,65 +1,117 @@
 CREATE OR REPLACE VIEW optimized_all_activity AS
-WITH feed_data AS (
+WITH
-  SELECT json_build_object(
+  feed_data AS (
-    'title', p.title,
+    SELECT
-    'url', p.url,
-    'description', p.content,
-    'date', p.date,
-    'type', 'article',
-    'label', 'Post',
-    'content', p.content
-  ) AS feed
-  FROM optimized_posts p
-  UNION ALL
-  SELECT json_build_object(
-    'title', CONCAT(l.title, ' via ', l.author->>'name'),
-    'url', l.link,
-    'description', l.description,
-    'date', l.date,
-    'type', 'link',
-    'label', 'Link',
-    'author', l.author
-  ) AS feed
-  FROM optimized_links l
-  UNION ALL
-  SELECT CASE
-    WHEN LOWER(b.status) = 'finished' THEN
       json_build_object(
-        'title', CONCAT(b.title, ' by ', b.author,
+        'title',
-          CASE WHEN b.rating IS NOT NULL THEN CONCAT(' (', b.rating, ')') ELSE '' END
+        p.title,
-        ),
+        'url',
-        'url', b.url,
+        p.url,
-        'description', COALESCE(b.review, b.description),
+        'description',
-        'date', b.date_finished,
+        p.content,
-        'type', 'books',
+        'date',
-        'label', 'Book',
+        p.date,
-        'image', b.image,
+        'type',
-        'rating', b.rating
+        'article',
-      )
+        'label',
-    ELSE NULL
+        'Post',
-  END AS feed
+        'content',
-  FROM optimized_books b
+        p.content
-  UNION ALL
+      ) AS feed
-  SELECT CASE
+    FROM
-    WHEN m.last_watched IS NOT NULL THEN
+      optimized_posts p
+    UNION ALL
+    SELECT
       json_build_object(
-        'title', CONCAT(m.title,
+        'title',
-          CASE WHEN m.rating IS NOT NULL THEN CONCAT(' (', m.rating, ')') ELSE '' END
+        CONCAT(l.title, ' via ', l.author ->> 'name'),
-        ),
+        'url',
-        'url', m.url,
+        l.link,
-        'description', COALESCE(m.review, m.description),
+        'description',
-        'date', m.last_watched,
+        l.description,
-        'type', 'movies',
+        'date',
-        'label', 'Movie',
+        l.date,
-        'image', m.image,
+        'type',
-        'rating', m.rating
+        'link',
-      )
+        'label',
-    ELSE NULL
+        'Link',
-  END AS feed
+        'author',
-  FROM optimized_movies m
+        l.author
-)
+      ) AS feed
-SELECT feed
+    FROM
-FROM feed_data
+      optimized_links l
-WHERE feed IS NOT NULL
+    UNION ALL
-ORDER BY (feed->>'date')::timestamp DESC
+    SELECT
-LIMIT 20;
+      CASE
+        WHEN LOWER(b.status) = 'finished' THEN json_build_object(
+          'title',
+          CONCAT(
+            b.title,
+            ' by ',
+            b.author,
+            CASE
+              WHEN b.rating IS NOT NULL THEN CONCAT(' (', b.rating, ')')
+              ELSE ''
+            END
+          ),
+          'url',
+          b.url,
+          'description',
+          COALESCE(b.review, b.description),
+          'date',
+          b.date_finished,
+          'type',
+          'books',
+          'label',
+          'Book',
+          'image',
+          b.image,
+          'rating',
+          b.rating
+        )
+        ELSE NULL
+      END AS feed
+    FROM
+      optimized_books b
+    UNION ALL
+    SELECT
+      CASE
+        WHEN m.last_watched IS NOT NULL THEN json_build_object(
+          'title',
+          CONCAT(
+            m.title,
+            CASE
+              WHEN m.rating IS NOT NULL THEN CONCAT(' (', m.rating, ')')
+              ELSE ''
+            END
+          ),
+          'url',
+          m.url,
+          'description',
+          COALESCE(m.review, m.description),
+          'date',
+          m.last_watched,
+          'type',
+          'movies',
+          'label',
+          'Movie',
+          'image',
+          m.image,
+          'rating',
+          m.rating
+        )
+        ELSE NULL
+      END AS feed
+    FROM
+      optimized_movies m
+  )
+SELECT
+  feed
+FROM
+  feed_data
+WHERE
+  feed IS NOT NULL
+ORDER BY
+  (feed ->> 'date')::timestamp DESC
+LIMIT
+  20;

queries/views/feeds/headers.sql

@@ -1,12 +1,12 @@
 CREATE OR REPLACE VIEW optimized_headers AS
 SELECT
   p.path AS resource_path,
-  json_agg(json_build_object('header_name', hr.name, 'header_value', hr.value)) AS headers
+  json_agg(
+    json_build_object('header_name', hr.name, 'header_value', hr.value)
+  ) AS headers
 FROM
   paths p
-JOIN
+  JOIN paths_header_rules phr ON p.id = phr.paths_id
-  paths_header_rules phr ON p.id = phr.paths_id
+  JOIN header_rules hr ON phr.header_rules_id = hr.id
-JOIN
-  header_rules hr ON phr.header_rules_id = hr.id
 GROUP BY
   p.path;

queries/views/feeds/oembed.sql

@@ -1,70 +1,151 @@
-CREATE OR REPLACE VIEW optimized_oembed AS 
+CREATE OR REPLACE VIEW optimized_oembed AS
-WITH oembed_data AS (
+WITH
-  SELECT 
+  oembed_data AS (
-    'post' AS type, 
+    SELECT
-    p.url::TEXT AS url, 
+      'post' AS type,
-    p.title AS title, 
+      p.url::TEXT AS url,
-    p.description AS description, 
+      p.title AS title,
-    COALESCE(NULLIF(p.metadata->>'open_graph_image', ''), (SELECT metadata->>'open_graph_image' FROM optimized_globals LIMIT 1)) AS image_url,
+      p.description AS description,
-    p.date AS content_date
+      COALESCE(
-  FROM optimized_posts p
+        NULLIF(p.metadata ->> 'open_graph_image', ''),
-  UNION ALL
+        (
-  SELECT
+          SELECT
-    'page' AS type,
+            metadata ->> 'open_graph_image'
-    pa.permalink::TEXT AS url,
+          FROM
-    pa.title AS title,
+            optimized_globals
-    pa.description AS description,
+          LIMIT
-    COALESCE(NULLIF(pa.metadata->>'open_graph_image', ''), (SELECT metadata->>'open_graph_image' FROM optimized_globals LIMIT 1)) AS image_url,
+            1
-    NULL::timestamptz AS content_date
+        )
-  FROM optimized_pages pa
+      ) AS image_url,
-  UNION ALL
+      p.date AS content_date
-  SELECT
+    FROM
-    'book' AS type,
+      optimized_posts p
-    b.url::TEXT AS url,
+    UNION ALL
-    b.title AS title,
+    SELECT
-    b.description AS description,
+      'page' AS type,
-    COALESCE(NULLIF(b.metadata->>'open_graph_image', ''), (SELECT metadata->>'open_graph_image' FROM optimized_globals LIMIT 1)) AS image_url,
+      pa.permalink::TEXT AS url,
-    b.date_finished AS content_date
+      pa.title AS title,
-  FROM optimized_books b
+      pa.description AS description,
-  UNION ALL
+      COALESCE(
-  SELECT
+        NULLIF(pa.metadata ->> 'open_graph_image', ''),
-    'artist' AS type,
+        (
-    ar.url::TEXT AS url,
+          SELECT
-    ar.name AS title,
+            metadata ->> 'open_graph_image'
-    ar.description AS description,
+          FROM
-    COALESCE(NULLIF(ar.metadata->>'open_graph_image', ''), (SELECT metadata->>'open_graph_image' FROM optimized_globals LIMIT 1)) AS image_url,
+            optimized_globals
-    CURRENT_TIMESTAMP AS content_date
+          LIMIT
-  FROM optimized_artists ar
+            1
-  UNION ALL
+        )
-  SELECT
+      ) AS image_url,
-    'genre' AS type,
+      NULL::timestamptz AS content_date
-    g.url::TEXT AS url,
+    FROM
-    g.name AS title,
+      optimized_pages pa
-    g.description AS description,
+    UNION ALL
-    COALESCE(NULLIF(g.metadata->>'open_graph_image', ''), (SELECT metadata->>'open_graph_image' FROM optimized_globals LIMIT 1)) AS image_url,
+    SELECT
-    CURRENT_TIMESTAMP AS content_date
+      'book' AS type,
-  FROM optimized_genres g
+      b.url::TEXT AS url,
-  UNION ALL
+      b.title AS title,
-  SELECT
+      b.description AS description,
-    'show' AS type,
+      COALESCE(
-    s.url::TEXT AS url,
+        NULLIF(b.metadata ->> 'open_graph_image', ''),
-    s.title AS title,
+        (
-    s.description AS description,
+          SELECT
-    COALESCE(NULLIF(s.metadata->>'open_graph_image', ''), (SELECT metadata->>'open_graph_image' FROM optimized_globals LIMIT 1)) AS image_url,
+            metadata ->> 'open_graph_image'
-    s.last_watched_at AS content_date
+          FROM
-  FROM optimized_shows s
+            optimized_globals
-  UNION ALL
+          LIMIT
-  SELECT
+            1
-    'movie' AS type,
+        )
-    m.url::TEXT AS url,
+      ) AS image_url,
-    m.title AS title,
+      b.date_finished AS content_date
-    m.description AS description,
+    FROM
-    COALESCE(NULLIF(m.metadata->>'open_graph_image', ''), (SELECT metadata->>'open_graph_image' FROM optimized_globals LIMIT 1)) AS image_url,
+      optimized_books b
-    m.last_watched AS content_date
+    UNION ALL
-  FROM optimized_movies m
+    SELECT
-)
+      'artist' AS type,
-SELECT 
+      ar.url::TEXT AS url,
-  ROW_NUMBER() OVER (ORDER BY url) AS id, 
+      ar.name AS title,
-  * 
+      ar.description AS description,
-FROM 
+      COALESCE(
+        NULLIF(ar.metadata ->> 'open_graph_image', ''),
+        (
+          SELECT
+            metadata ->> 'open_graph_image'
+          FROM
+            optimized_globals
+          LIMIT
+            1
+        )
+      ) AS image_url,
+      CURRENT_TIMESTAMP AS content_date
+    FROM
+      optimized_artists ar
+    UNION ALL
+    SELECT
+      'genre' AS type,
+      g.url::TEXT AS url,
+      g.name AS title,
+      g.description AS description,
+      COALESCE(
+        NULLIF(g.metadata ->> 'open_graph_image', ''),
+        (
+          SELECT
+            metadata ->> 'open_graph_image'
+          FROM
+            optimized_globals
+          LIMIT
+            1
+        )
+      ) AS image_url,
+      CURRENT_TIMESTAMP AS content_date
+    FROM
+      optimized_genres g
+    UNION ALL
+    SELECT
+      'show' AS type,
+      s.url::TEXT AS url,
+      s.title AS title,
+      s.description AS description,
+      COALESCE(
+        NULLIF(s.metadata ->> 'open_graph_image', ''),
+        (
+          SELECT
+            metadata ->> 'open_graph_image'
+          FROM
+            optimized_globals
+          LIMIT
+            1
+        )
+      ) AS image_url,
+      s.last_watched_at AS content_date
+    FROM
+      optimized_shows s
+    UNION ALL
+    SELECT
+      'movie' AS type,
+      m.url::TEXT AS url,
+      m.title AS title,
+      m.description AS description,
+      COALESCE(
+        NULLIF(m.metadata ->> 'open_graph_image', ''),
+        (
+          SELECT
+            metadata ->> 'open_graph_image'
+          FROM
+            optimized_globals
+          LIMIT
+            1
+        )
+      ) AS image_url,
+      m.last_watched AS content_date
+    FROM
+      optimized_movies m
+  )
+SELECT
+  ROW_NUMBER() OVER (
+    ORDER BY
+      url
+  ) AS id,
+  *
+FROM
   oembed_data;

queries/views/feeds/recent_activity.sql

@@ -1,124 +1,147 @@
 CREATE OR REPLACE VIEW optimized_recent_activity AS
-WITH activity_data AS (
+WITH
-  SELECT
+  activity_data AS (
-    NULL::bigint AS id,
+    SELECT
-    p.date AS content_date,
+      NULL::bigint AS id,
-    p.title,
+      p.date AS content_date,
-    p.content AS description,
+      p.title,
-    p.url AS url,
+      p.content AS description,
-    p.featured AS featured,
+      p.url AS url,
-    p.tags::TEXT[],
+      p.featured AS featured,
-    NULL AS author,
+      p.tags::TEXT[],
-    NULL AS image,
+      NULL AS author,
-    NULL AS rating,
+      NULL AS image,
-    NULL AS artist_url,
+      NULL AS rating,
-    NULL AS venue_lat,
+      NULL AS artist_url,
-    NULL AS venue_lon,
+      NULL AS venue_lat,
-    NULL AS venue_name,
+      NULL AS venue_lon,
-    NULL AS notes,
+      NULL AS venue_name,
-    'article' AS type,
+      NULL AS notes,
-    'Post' AS label
+      'article' AS type,
-  FROM optimized_posts p
+      'Post' AS label
-
+    FROM
-  UNION ALL
+      optimized_posts p
-
+    UNION ALL
-  SELECT
+    SELECT
-    NULL::bigint AS id,
+      NULL::bigint AS id,
-    l.date AS content_date,
+      l.date AS content_date,
-    l.title,
+      l.title,
-    l.description,
+      l.description,
-    l.link AS url,
+      l.link AS url,
-    NULL AS featured,
+      NULL AS featured,
-    l.tags::TEXT[],
+      l.tags::TEXT[],
-    l.author,
+      l.author,
-    NULL AS image,
+      NULL AS image,
-    NULL AS rating,
+      NULL AS rating,
-    NULL AS artist_url,
+      NULL AS artist_url,
-    NULL AS venue_lat,
+      NULL AS venue_lat,
-    NULL AS venue_lon,
+      NULL AS venue_lon,
-    NULL AS venue_name,
+      NULL AS venue_name,
-    NULL AS notes,
+      NULL AS notes,
-    'link' AS type,
+      'link' AS type,
-    'Link' AS label
+      'Link' AS label
-  FROM optimized_links l
+    FROM
-
+      optimized_links l
-  UNION ALL
+    UNION ALL
-
+    SELECT
-  SELECT
+      NULL::bigint AS id,
-    NULL::bigint AS id,
+      b.date_finished AS content_date,
-    b.date_finished AS content_date,
+      CONCAT(
-    CONCAT(b.title,
+        b.title,
-      CASE WHEN b.rating IS NOT NULL THEN CONCAT(' (', b.rating, ')') ELSE '' END
+        CASE
-    ) AS title,
+          WHEN b.rating IS NOT NULL THEN CONCAT(' (', b.rating, ')')
-    b.description,
+          ELSE ''
-    b.url AS url,
+        END
-    NULL AS featured,
+      ) AS title,
-    b.tags::TEXT[],
+      b.description,
-    NULL AS author,
+      b.url AS url,
-    b.image,
+      NULL AS featured,
-    b.rating,
+      b.tags::TEXT[],
-    NULL AS artist_url,
+      NULL AS author,
-    NULL AS venue_lat,
+      b.image,
-    NULL AS venue_lon,
+      b.rating,
-    NULL AS venue_name,
+      NULL AS artist_url,
-    NULL AS notes,
+      NULL AS venue_lat,
-    'books' AS type,
+      NULL AS venue_lon,
-    'Book' AS label
+      NULL AS venue_name,
-  FROM optimized_books b
+      NULL AS notes,
-  WHERE LOWER(b.status) = 'finished'
+      'books' AS type,
-
+      'Book' AS label
-  UNION ALL
+    FROM
-
+      optimized_books b
-  SELECT
+    WHERE
-    NULL::bigint AS id,
+      LOWER(b.status) = 'finished'
-    m.last_watched AS content_date,
+    UNION ALL
-    CONCAT(m.title,
+    SELECT
-      CASE WHEN m.rating IS NOT NULL THEN CONCAT(' (', m.rating, ')') ELSE '' END
+      NULL::bigint AS id,
-    ) AS title,
+      m.last_watched AS content_date,
-    m.description,
+      CONCAT(
-    m.url AS url,
+        m.title,
-    NULL AS featured,
+        CASE
-    m.tags::TEXT[],
+          WHEN m.rating IS NOT NULL THEN CONCAT(' (', m.rating, ')')
-    NULL AS author,
+          ELSE ''
-    m.image,
+        END
-    m.rating,
+      ) AS title,
-    NULL AS artist_url,
+      m.description,
-    NULL AS venue_lat,
+      m.url AS url,
-    NULL AS venue_lon,
+      NULL AS featured,
-    NULL AS venue_name,
+      m.tags::TEXT[],
-    NULL AS notes,
+      NULL AS author,
-    'movies' AS type,
+      m.image,
-    'Movie' AS label
+      m.rating,
-  FROM optimized_movies m
+      NULL AS artist_url,
-  WHERE m.last_watched IS NOT NULL
+      NULL AS venue_lat,
-
+      NULL AS venue_lon,
-  UNION ALL
+      NULL AS venue_name,
-
+      NULL AS notes,
-  SELECT
+      'movies' AS type,
-    c.id,
+      'Movie' AS label
-    c.date AS content_date,
+    FROM
-    CONCAT(c.artist->>'name', ' at ', c.venue->>'name_short') AS title,
+      optimized_movies m
-    c.concert_notes AS description,
+    WHERE
-    NULL AS url,
+      m.last_watched IS NOT NULL
-    NULL AS featured,
+    UNION ALL
-    NULL AS tags,
+    SELECT
-    NULL AS author,
+      c.id,
-    NULL AS image,
+      c.date AS content_date,
-    NULL AS rating,
+      CONCAT(
-    c.artist->>'url' AS artist_url,
+        c.artist ->> 'name',
-    c.venue->>'latitude' AS venue_lat,
+        ' at ',
-    c.venue->>'longitude' AS venue_lon,
+        c.venue ->> 'name_short'
-    c.venue->>'name_short' AS venue_name,
+      ) AS title,
-    c.concert_notes AS notes,
+      c.concert_notes AS description,
-    'concerts' AS type,
+      NULL AS url,
-    'Concert' AS label
+      NULL AS featured,
-  FROM optimized_concerts c
+      NULL AS tags,
-)
+      NULL AS author,
-SELECT json_agg(recent_activity_data ORDER BY recent_activity_data.content_date DESC) AS feed
+      NULL AS image,
-FROM (
+      NULL AS rating,
-  SELECT *
+      c.artist ->> 'url' AS artist_url,
-  FROM activity_data
+      c.venue ->> 'latitude' AS venue_lat,
-  WHERE content_date IS NOT NULL
+      c.venue ->> 'longitude' AS venue_lon,
-  ORDER BY content_date DESC
+      c.venue ->> 'name_short' AS venue_name,
-  LIMIT 20
+      c.concert_notes AS notes,
-) AS recent_activity_data;
+      'concerts' AS type,
+      'Concert' AS label
+    FROM
+      optimized_concerts c
+  )
+SELECT
+  json_agg(
+    recent_activity_data
+    ORDER BY
+      recent_activity_data.content_date DESC
+  ) AS feed
+FROM
+  (
+    SELECT
+      *
+    FROM
+      activity_data
+    WHERE
+      content_date IS NOT NULL
+    ORDER BY
+      content_date DESC
+    LIMIT
+      20
+  ) AS recent_activity_data;

queries/views/feeds/robots.sql

@@ -1,12 +1,14 @@
 CREATE OR REPLACE VIEW optimized_robots AS
 SELECT
   r.path,
-  array_agg(ua.user_agent ORDER BY ua.user_agent) AS user_agents
+  array_agg(
+    ua.user_agent
+    ORDER BY
+      ua.user_agent
+  ) AS user_agents
 FROM
   robots AS r
-JOIN
+  JOIN robots_user_agents AS rua ON r.id = rua.robots_id
-  robots_user_agents AS rua ON r.id = rua.robots_id
+  JOIN user_agents AS ua ON rua.user_agents_id = ua.id
-JOIN
-  user_agents AS ua ON rua.user_agents_id = ua.id
 GROUP BY
   r.path;

queries/views/feeds/search.sql

@@ -1,118 +1,125 @@
 CREATE OR REPLACE VIEW optimized_search_index AS
-WITH search_data AS (
+WITH
-  SELECT
+  search_data AS (
-    p.title,
+    SELECT
-    p.url::TEXT AS url,
+      p.title,
-    p.description AS description,
+      p.url::TEXT AS url,
-    p.tags,
+      p.description AS description,
-    NULL AS genre_name,
+      p.tags,
-    NULL AS genre_url,
+      NULL AS genre_name,
-    NULL::TEXT AS total_plays,
+      NULL AS genre_url,
-    p.date AS content_date,
+      NULL::TEXT AS total_plays,
-    'article' AS type,
+      p.date AS content_date,
-    'post' AS section
+      'article' AS type,
-  FROM
+      'post' AS section
-    optimized_posts p
+    FROM
-  UNION ALL
+      optimized_posts p
-  SELECT
+    UNION ALL
-    CONCAT(l.title, ' via ', l.name) AS title,
+    SELECT
-    l.link::TEXT AS url,
+      CONCAT(l.title, ' via ', l.name) AS title,
-    l.description AS description,
+      l.link::TEXT AS url,
-    l.tags,
+      l.description AS description,
-    NULL AS genre_name,
+      l.tags,
-    NULL AS genre_url,
+      NULL AS genre_name,
-    NULL::TEXT AS total_plays,
+      NULL AS genre_url,
-    l.date AS content_date,
+      NULL::TEXT AS total_plays,
-    'link' AS type,
+      l.date AS content_date,
-    'link' AS section
+      'link' AS type,
-  FROM
+      'link' AS section
-    optimized_links l
+    FROM
-  UNION ALL
+      optimized_links l
-  SELECT
+    UNION ALL
-    CASE WHEN b.rating IS NOT NULL THEN
+    SELECT
-      CONCAT(b.title, ' (', b.rating, ')')
+      CASE
-    ELSE
+        WHEN b.rating IS NOT NULL THEN CONCAT(b.title, ' (', b.rating, ')')
-      b.title
+        ELSE b.title
-    END AS title,
+      END AS title,
-    b.url::TEXT AS url,
+      b.url::TEXT AS url,
-    b.description AS description,
+      b.description AS description,
-    b.tags,
+      b.tags,
-    NULL AS genre_name,
+      NULL AS genre_name,
-    NULL AS genre_url,
+      NULL AS genre_url,
-    NULL::TEXT AS total_plays,
+      NULL::TEXT AS total_plays,
-    b.date_finished AS content_date,
+      b.date_finished AS content_date,
-    'books' AS type,
+      'books' AS type,
-    'book' AS section
+      'book' AS section
-  FROM
+    FROM
-    optimized_books b
+      optimized_books b
-  WHERE
+    WHERE
-    LOWER(b.status) = 'finished'
+      LOWER(b.status) = 'finished'
-  UNION ALL
+    UNION ALL
-  SELECT
+    SELECT
-    ar.name AS title,
+      ar.name AS title,
-    ar.url::TEXT AS url,
+      ar.url::TEXT AS url,
-    ar.description AS description,
+      ar.description AS description,
-    ARRAY[ar.genre_name] AS tags,
+      ARRAY[ar.genre_name] AS tags,
-    CONCAT(COALESCE(ar.emoji, ar.genre_emoji, '🎧'), ' ', ar.genre_name) AS genre_name,
+      CONCAT(
-    ar.genre_slug AS genre_url,
+        COALESCE(ar.emoji, ar.genre_emoji, '🎧'),
-    TO_CHAR(ar.total_plays::NUMERIC, 'FM999,999,999,999') AS total_plays,
+        ' ',
-    NULL AS content_date,
+        ar.genre_name
-    'music' AS type,
+      ) AS genre_name,
-    'artist' AS section
+      ar.genre_slug AS genre_url,
-  FROM
+      TO_CHAR(ar.total_plays::NUMERIC, 'FM999,999,999,999') AS total_plays,
-    optimized_artists ar
+      NULL AS content_date,
-  UNION ALL
+      'music' AS type,
-  SELECT
+      'artist' AS section
-    g.name AS title,
+    FROM
-    g.url::TEXT AS url,
+      optimized_artists ar
-    g.description AS description,
+    UNION ALL
-    NULL AS tags,
+    SELECT
-    g.name AS genre_name,
+      g.name AS title,
-    g.url AS genre_url,
+      g.url::TEXT AS url,
-    g.total_plays AS total_plays,
+      g.description AS description,
-    NULL AS content_date,
+      NULL AS tags,
-    'music' AS type,
+      g.name AS genre_name,
-    'genre' AS section
+      g.url AS genre_url,
-  FROM
+      g.total_plays AS total_plays,
-    optimized_genres g
+      NULL AS content_date,
-  UNION ALL
+      'music' AS type,
-  SELECT
+      'genre' AS section
-    CONCAT(s.title, ' (', s.year, ')') AS title,
+    FROM
-    s.url::TEXT AS url,
+      optimized_genres g
-    s.description AS description,
+    UNION ALL
-    s.tags,
+    SELECT
-    NULL AS genre_name,
+      CONCAT(s.title, ' (', s.year, ')') AS title,
-    NULL AS genre_url,
+      s.url::TEXT AS url,
-    NULL::TEXT AS total_plays,
+      s.description AS description,
-    s.last_watched_at AS content_date,
+      s.tags,
-    'tv' AS type,
+      NULL AS genre_name,
-    'show' AS section
+      NULL AS genre_url,
-  FROM
+      NULL::TEXT AS total_plays,
-    optimized_shows s
+      s.last_watched_at AS content_date,
-  WHERE
+      'tv' AS type,
-    s.last_watched_at IS NOT NULL
+      'show' AS section
-  UNION ALL
+    FROM
-  SELECT
+      optimized_shows s
-    CASE
+    WHERE
-      WHEN m.rating IS NOT NULL THEN CONCAT(m.title, ' (', m.rating, ')')
+      s.last_watched_at IS NOT NULL
-      ELSE CONCAT(m.title, ' (', m.year, ')')
+    UNION ALL
-    END AS title,
+    SELECT
-    m.url::TEXT AS url,
+      CASE
-    m.description AS description,
+        WHEN m.rating IS NOT NULL THEN CONCAT(m.title, ' (', m.rating, ')')
-    m.tags,
+        ELSE CONCAT(m.title, ' (', m.year, ')')
-    NULL AS genre_name,
+      END AS title,
-    NULL AS genre_url,
+      m.url::TEXT AS url,
-    NULL::TEXT AS total_plays,
+      m.description AS description,
-    m.last_watched AS content_date,
+      m.tags,
-    'movies' AS type,
+      NULL AS genre_name,
-    'movie' AS section
+      NULL AS genre_url,
-  FROM
+      NULL::TEXT AS total_plays,
-    optimized_movies m
+      m.last_watched AS content_date,
-  WHERE
+      'movies' AS type,
-    m.last_watched IS NOT NULL
+      'movie' AS section
-)
+    FROM
+      optimized_movies m
+    WHERE
+      m.last_watched IS NOT NULL
+  )
 SELECT
-  ROW_NUMBER() OVER (ORDER BY url) AS id,
+  ROW_NUMBER() OVER (
+    ORDER BY
+      url
+  ) AS id,
   *
 FROM
   search_data;

queries/views/feeds/sitemap.sql

@@ -1,49 +1,54 @@
 CREATE OR REPLACE VIEW optimized_sitemap AS
-WITH sitemap_data AS (
+WITH
-  SELECT
+  sitemap_data AS (
-    p.url::TEXT AS url
+    SELECT
-  FROM
+      p.url::TEXT AS url
-    optimized_posts p
+    FROM
-  UNION ALL
+      optimized_posts p
-  SELECT
+    UNION ALL
-    b.url::TEXT AS url
+    SELECT
-  FROM
+      b.url::TEXT AS url
-    optimized_books b
+    FROM
-  UNION ALL
+      optimized_books b
-  SELECT
+    UNION ALL
-    m.url::TEXT AS url
+    SELECT
-  FROM
+      m.url::TEXT AS url
-    optimized_movies m
+    FROM
-  UNION ALL
+      optimized_movies m
-  SELECT
+    UNION ALL
-    ar.url::TEXT AS url
+    SELECT
-  FROM
+      ar.url::TEXT AS url
-    optimized_artists ar
+    FROM
-  UNION ALL
+      optimized_artists ar
-  SELECT
+    UNION ALL
-    g.url::TEXT AS url
+    SELECT
-  FROM
+      g.url::TEXT AS url
-    optimized_genres g
+    FROM
-  UNION ALL
+      optimized_genres g
-  SELECT
+    UNION ALL
-    s.url::TEXT AS url
+    SELECT
-  FROM
+      s.url::TEXT AS url
-    optimized_shows s
+    FROM
-  UNION ALL
+      optimized_shows s
-  SELECT
+    UNION ALL
-    pa.permalink::TEXT AS url
+    SELECT
-  FROM
+      pa.permalink::TEXT AS url
-    optimized_pages pa
+    FROM
-  UNION ALL
+      optimized_pages pa
-  SELECT
+    UNION ALL
-    ss.slug AS url
+    SELECT
-  FROM
+      ss.slug AS url
-    static_slugs ss
+    FROM
-  UNION ALL
+      static_slugs ss
-    SELECT CONCAT('/tags/', LOWER(REPLACE(tag, ' ', '-'))) AS url
+    UNION ALL
-    FROM optimized_all_tags
+    SELECT
-    WHERE tag IS NOT NULL AND TRIM(tag) <> ''
+      CONCAT('/tags/', LOWER(REPLACE(tag, ' ', '-'))) AS url
-)
+    FROM
+      optimized_all_tags
+    WHERE
+      tag IS NOT NULL
+      AND TRIM(tag) <> ''
+  )
 SELECT
   url
 FROM

queries/views/feeds/stats.sql

@@ -1,190 +1,412 @@
 CREATE OR REPLACE VIEW optimized_stats AS
-WITH artist_stats AS (
+WITH
-  SELECT
+  artist_stats AS (
-    TO_CHAR(COUNT(DISTINCT artist_name), 'FM999,999,999') AS artist_count
+    SELECT
-  FROM optimized_listens
+      TO_CHAR(COUNT(DISTINCT artist_name), 'FM999,999,999') AS artist_count
-  WHERE artist_name IS NOT NULL
+    FROM
-),
+      optimized_listens
-track_stats AS (
+    WHERE
-  SELECT
+      artist_name IS NOT NULL
-    TO_CHAR(COUNT(*), 'FM999,999,999') AS listen_count
+  ),
-  FROM optimized_listens
+  track_stats AS (
-),
+    SELECT
-concert_stats AS (
+      TO_CHAR(COUNT(*), 'FM999,999,999') AS listen_count
-  SELECT
+    FROM
-    TO_CHAR(COUNT(*), 'FM999,999,999') AS concert_count
+      optimized_listens
-  FROM concerts
+  ),
-),
+  concert_stats AS (
-venue_stats AS (
+    SELECT
-  SELECT
+      TO_CHAR(COUNT(*), 'FM999,999,999') AS concert_count
-    TO_CHAR(COUNT(DISTINCT venue), 'FM999,999,999') AS venue_count
+    FROM
-  FROM concerts
+      concerts
-),
+  ),
-yearly_data AS (
+  venue_stats AS (
-  SELECT
+    SELECT
-    EXTRACT(YEAR FROM e.last_watched_at) AS year,
+      TO_CHAR(COUNT(DISTINCT venue), 'FM999,999,999') AS venue_count
-    0 AS artist_count,
+    FROM
-    0 AS listen_count,
+      concerts
-    0 AS genre_count,
+  ),
-    COUNT(DISTINCT e.show) AS show_count,
+  yearly_data AS (
-    COUNT(*) AS episode_count,
+    SELECT
-    0 AS post_count,
+      EXTRACT(
-    0 AS link_count,
+        YEAR
-    0 AS book_count,
+        FROM
-    0 AS movie_count,
+          e.last_watched_at
-    0 AS concert_count,
+      ) AS year,
-    0 AS venue_count
+      0 AS artist_count,
-  FROM episodes e
+      0 AS listen_count,
-  GROUP BY EXTRACT(YEAR FROM e.last_watched_at)
+      0 AS genre_count,
-  HAVING EXTRACT(YEAR FROM e.last_watched_at) >= 2023
+      COUNT(DISTINCT e.show) AS show_count,
-  UNION ALL
+      COUNT(*) AS episode_count,
-  SELECT
+      0 AS post_count,
-    EXTRACT(YEAR FROM p.date) AS year,
+      0 AS link_count,
-    0 AS artist_count,
+      0 AS book_count,
-    0 AS listen_count,
+      0 AS movie_count,
-    0 AS genre_count,
+      0 AS concert_count,
-    0 AS show_count,
+      0 AS venue_count
-    0 AS episode_count,
+    FROM
-    COUNT(*) AS post_count,
+      episodes e
-    0 AS link_count,
+    GROUP BY
-    0 AS book_count,
+      EXTRACT(
-    0 AS movie_count,
+        YEAR
-    0 AS concert_count,
+        FROM
-    0 AS venue_count
+          e.last_watched_at
-  FROM optimized_posts p
+      )
-  GROUP BY EXTRACT(YEAR FROM p.date)
+    HAVING
-  HAVING EXTRACT(YEAR FROM p.date) >= 2023
+      EXTRACT(
-  UNION ALL
+        YEAR
-  SELECT
+        FROM
-    EXTRACT(YEAR FROM o.date) AS year,
+          e.last_watched_at
-    0 AS artist_count,
+      ) >= 2023
-    0 AS listen_count,
+    UNION ALL
-    0 AS genre_count,
+    SELECT
-    0 AS show_count,
+      EXTRACT(
-    0 AS episode_count,
+        YEAR
-    0 AS post_count,
+        FROM
-    COUNT(*) AS link_count,
+          p.date
-    0 AS book_count,
+      ) AS year,
-    0 AS movie_count,
+      0 AS artist_count,
-    0 AS concert_count,
+      0 AS listen_count,
-    0 AS venue_count
+      0 AS genre_count,
-  FROM optimized_links o
+      0 AS show_count,
-  GROUP BY EXTRACT(YEAR FROM o.date)
+      0 AS episode_count,
-  HAVING EXTRACT(YEAR FROM o.date) >= 2023
+      COUNT(*) AS post_count,
-  UNION ALL
+      0 AS link_count,
-  SELECT
+      0 AS book_count,
-    EXTRACT(YEAR FROM b.date_finished) AS year,
+      0 AS movie_count,
-    0 AS artist_count,
+      0 AS concert_count,
-    0 AS listen_count,
+      0 AS venue_count
-    0 AS genre_count,
+    FROM
-    0 AS show_count,
+      optimized_posts p
-    0 AS episode_count,
+    GROUP BY
-    0 AS post_count,
+      EXTRACT(
-    0 AS link_count,
+        YEAR
-    COUNT(*) AS book_count,
+        FROM
-    0 AS movie_count,
+          p.date
-    0 AS concert_count,
+      )
-    0 AS venue_count
+    HAVING
-  FROM optimized_books b
+      EXTRACT(
-  WHERE LOWER(b.status) = 'finished'
+        YEAR
-  GROUP BY EXTRACT(YEAR FROM b.date_finished)
+        FROM
-  HAVING EXTRACT(YEAR FROM b.date_finished) >= 2023
+          p.date
-  UNION ALL
+      ) >= 2023
-  SELECT
+    UNION ALL
-    EXTRACT(YEAR FROM m.last_watched) AS year,
+    SELECT
-    0 AS artist_count,
+      EXTRACT(
-    0 AS listen_count,
+        YEAR
-    0 AS genre_count,
+        FROM
-    0 AS show_count,
+          o.date
-    0 AS episode_count,
+      ) AS year,
-    0 AS post_count,
+      0 AS artist_count,
-    0 AS link_count,
+      0 AS listen_count,
-    0 AS book_count,
+      0 AS genre_count,
-    COUNT(*) AS movie_count,
+      0 AS show_count,
-    0 AS concert_count,
+      0 AS episode_count,
-    0 AS venue_count
+      0 AS post_count,
-  FROM optimized_movies m
+      COUNT(*) AS link_count,
-  GROUP BY EXTRACT(YEAR FROM m.last_watched)
+      0 AS book_count,
-  HAVING EXTRACT(YEAR FROM m.last_watched) >= 2023
+      0 AS movie_count,
-  UNION ALL
+      0 AS concert_count,
-  SELECT
+      0 AS venue_count
-    EXTRACT(YEAR FROM TO_TIMESTAMP(l.listened_at)) AS year,
+    FROM
-    COUNT(DISTINCT l.artist_name) AS artist_count,
+      optimized_links o
-    COUNT(l.id) AS listen_count,
+    GROUP BY
-    COUNT(DISTINCT l.genre_name) AS genre_count,
+      EXTRACT(
-    0 AS show_count,
+        YEAR
-    0 AS episode_count,
+        FROM
-    0 AS post_count,
+          o.date
-    0 AS link_count,
+      )
-    0 AS book_count,
+    HAVING
-    0 AS movie_count,
+      EXTRACT(
-    0 AS concert_count,
+        YEAR
-    0 AS venue_count
+        FROM
-  FROM optimized_listens l
+          o.date
-  GROUP BY EXTRACT(YEAR FROM TO_TIMESTAMP(l.listened_at))
+      ) >= 2023
-  HAVING EXTRACT(YEAR FROM TO_TIMESTAMP(l.listened_at)) >= 2023
+    UNION ALL
-  UNION ALL
+    SELECT
-  SELECT
+      EXTRACT(
-    EXTRACT(YEAR FROM c.date) AS year,
+        YEAR
-    0 AS artist_count,
+        FROM
-    0 AS listen_count,
+          b.date_finished
-    0 AS genre_count,
+      ) AS year,
-    0 AS show_count,
+      0 AS artist_count,
-    0 AS episode_count,
+      0 AS listen_count,
-    0 AS post_count,
+      0 AS genre_count,
-    0 AS link_count,
+      0 AS show_count,
-    0 AS book_count,
+      0 AS episode_count,
-    0 AS movie_count,
+      0 AS post_count,
-    COUNT(*) AS concert_count,
+      0 AS link_count,
-    COUNT(DISTINCT c.venue) AS venue_count
+      COUNT(*) AS book_count,
-  FROM concerts c
+      0 AS movie_count,
-  GROUP BY EXTRACT(YEAR FROM c.date)
+      0 AS concert_count,
-  HAVING EXTRACT(YEAR FROM c.date) >= 2023
+      0 AS venue_count
-),
+    FROM
-aggregated_yearly_stats AS (
+      optimized_books b
-  SELECT
+    WHERE
-    year,
+      LOWER(b.status) = 'finished'
-    SUM(artist_count) AS artist_count,
+    GROUP BY
-    SUM(listen_count) AS listen_count,
+      EXTRACT(
-    SUM(genre_count) AS genre_count,
+        YEAR
-    SUM(show_count) AS show_count,
+        FROM
-    SUM(episode_count) AS episode_count,
+          b.date_finished
-    SUM(post_count) AS post_count,
+      )
-    SUM(link_count) AS link_count,
+    HAVING
-    SUM(book_count) AS book_count,
+      EXTRACT(
-    SUM(movie_count) AS movie_count,
+        YEAR
-    SUM(concert_count) AS concert_count,
+        FROM
-    SUM(venue_count) AS venue_count
+          b.date_finished
-  FROM yearly_data
+      ) >= 2023
-  GROUP BY year
+    UNION ALL
-  ORDER BY year DESC
+    SELECT
-)
+      EXTRACT(
+        YEAR
+        FROM
+          m.last_watched
+      ) AS year,
+      0 AS artist_count,
+      0 AS listen_count,
+      0 AS genre_count,
+      0 AS show_count,
+      0 AS episode_count,
+      0 AS post_count,
+      0 AS link_count,
+      0 AS book_count,
+      COUNT(*) AS movie_count,
+      0 AS concert_count,
+      0 AS venue_count
+    FROM
+      optimized_movies m
+    GROUP BY
+      EXTRACT(
+        YEAR
+        FROM
+          m.last_watched
+      )
+    HAVING
+      EXTRACT(
+        YEAR
+        FROM
+          m.last_watched
+      ) >= 2023
+    UNION ALL
+    SELECT
+      EXTRACT(
+        YEAR
+        FROM
+          TO_TIMESTAMP(l.listened_at)
+      ) AS year,
+      COUNT(DISTINCT l.artist_name) AS artist_count,
+      COUNT(l.id) AS listen_count,
+      COUNT(DISTINCT l.genre_name) AS genre_count,
+      0 AS show_count,
+      0 AS episode_count,
+      0 AS post_count,
+      0 AS link_count,
+      0 AS book_count,
+      0 AS movie_count,
+      0 AS concert_count,
+      0 AS venue_count
+    FROM
+      optimized_listens l
+    GROUP BY
+      EXTRACT(
+        YEAR
+        FROM
+          TO_TIMESTAMP(l.listened_at)
+      )
+    HAVING
+      EXTRACT(
+        YEAR
+        FROM
+          TO_TIMESTAMP(l.listened_at)
+      ) >= 2023
+    UNION ALL
+    SELECT
+      EXTRACT(
+        YEAR
+        FROM
+          c.date
+      ) AS year,
+      0 AS artist_count,
+      0 AS listen_count,
+      0 AS genre_count,
+      0 AS show_count,
+      0 AS episode_count,
+      0 AS post_count,
+      0 AS link_count,
+      0 AS book_count,
+      0 AS movie_count,
+      COUNT(*) AS concert_count,
+      COUNT(DISTINCT c.venue) AS venue_count
+    FROM
+      concerts c
+    GROUP BY
+      EXTRACT(
+        YEAR
+        FROM
+          c.date
+      )
+    HAVING
+      EXTRACT(
+        YEAR
+        FROM
+          c.date
+      ) >= 2023
+  ),
+  aggregated_yearly_stats AS (
+    SELECT
+      year,
+      SUM(artist_count) AS artist_count,
+      SUM(listen_count) AS listen_count,
+      SUM(genre_count) AS genre_count,
+      SUM(show_count) AS show_count,
+      SUM(episode_count) AS episode_count,
+      SUM(post_count) AS post_count,
+      SUM(link_count) AS link_count,
+      SUM(book_count) AS book_count,
+      SUM(movie_count) AS movie_count,
+      SUM(concert_count) AS concert_count,
+      SUM(venue_count) AS venue_count
+    FROM
+      yearly_data
+    GROUP BY
+      year
+    ORDER BY
+      year DESC
+  )
 SELECT
-  (SELECT artist_count FROM artist_stats) AS artist_count,
+  (
-  (SELECT listen_count FROM track_stats) AS listen_count,
+    SELECT
-  (SELECT concert_count FROM concert_stats) AS concert_count,
+      artist_count
-  (SELECT venue_count FROM venue_stats) AS venue_count,
+    FROM
-  (SELECT TO_CHAR(COUNT(DISTINCT e.show), 'FM999,999,999') FROM episodes e) AS show_count,
+      artist_stats
-  (SELECT TO_CHAR(COUNT(*), 'FM999,999,999') FROM episodes e) AS episode_count,
+  ) AS artist_count,
-  (SELECT TO_CHAR(COUNT(*), 'FM999,999,999') FROM optimized_posts) AS post_count,
+  (
-  (SELECT TO_CHAR(COUNT(*), 'FM999,999,999') FROM optimized_links) AS link_count,
+    SELECT
-  (SELECT TO_CHAR(COUNT(*), 'FM999,999,999') FROM optimized_books WHERE LOWER(status) = 'finished') AS book_count,
+      listen_count
-  (SELECT TO_CHAR(COUNT(*), 'FM999,999,999') FROM optimized_movies WHERE last_watched IS NOT NULL) AS movie_count,
+    FROM
-  (SELECT TO_CHAR(COUNT(DISTINCT genre_name), 'FM999,999,999') FROM optimized_listens WHERE genre_name IS NOT NULL) AS genre_count,
+      track_stats
+  ) AS listen_count,
+  (
+    SELECT
+      concert_count
+    FROM
+      concert_stats
+  ) AS concert_count,
+  (
+    SELECT
+      venue_count
+    FROM
+      venue_stats
+  ) AS venue_count,
+  (
+    SELECT
+      TO_CHAR(COUNT(DISTINCT e.show), 'FM999,999,999')
+    FROM
+      episodes e
+  ) AS show_count,
+  (
+    SELECT
+      TO_CHAR(COUNT(*), 'FM999,999,999')
+    FROM
+      episodes e
+  ) AS episode_count,
+  (
+    SELECT
+      TO_CHAR(COUNT(*), 'FM999,999,999')
+    FROM
+      optimized_posts
+  ) AS post_count,
+  (
+    SELECT
+      TO_CHAR(COUNT(*), 'FM999,999,999')
+    FROM
+      optimized_links
+  ) AS link_count,
+  (
+    SELECT
+      TO_CHAR(COUNT(*), 'FM999,999,999')
+    FROM
+      optimized_books
+    WHERE
+      LOWER(status) = 'finished'
+  ) AS book_count,
+  (
+    SELECT
+      TO_CHAR(COUNT(*), 'FM999,999,999')
+    FROM
+      optimized_movies
+    WHERE
+      last_watched IS NOT NULL
+  ) AS movie_count,
+  (
+    SELECT
+      TO_CHAR(COUNT(DISTINCT genre_name), 'FM999,999,999')
+    FROM
+      optimized_listens
+    WHERE
+      genre_name IS NOT NULL
+  ) AS genre_count,
   JSON_AGG(
     JSON_BUILD_OBJECT(
-      'year', ys.year,
+      'year',
-      'artist_count', CASE WHEN ys.artist_count > 0 THEN TO_CHAR(ys.artist_count, 'FM999,999,999') ELSE NULL END,
+      ys.year,
-      'listen_count', CASE WHEN ys.listen_count > 0 THEN TO_CHAR(ys.listen_count, 'FM999,999,999') ELSE NULL END,
+      'artist_count',
-      'genre_count', CASE WHEN ys.genre_count > 0 THEN TO_CHAR(ys.genre_count, 'FM999,999,999') ELSE NULL END,
+      CASE
-      'show_count', CASE WHEN ys.show_count > 0 THEN TO_CHAR(ys.show_count, 'FM999,999,999') ELSE NULL END,
+        WHEN ys.artist_count > 0 THEN TO_CHAR(ys.artist_count, 'FM999,999,999')
-      'episode_count', CASE WHEN ys.episode_count > 0 THEN TO_CHAR(ys.episode_count, 'FM999,999,999') ELSE NULL END,
+        ELSE NULL
-      'post_count', CASE WHEN ys.post_count > 0 THEN TO_CHAR(ys.post_count, 'FM999,999,999') ELSE NULL END,
+      END,
-      'link_count', CASE WHEN ys.link_count > 0 THEN TO_CHAR(ys.link_count, 'FM999,999,999') ELSE NULL END,
+      'listen_count',
-      'book_count', CASE WHEN ys.book_count > 0 THEN TO_CHAR(ys.book_count, 'FM999,999,999') ELSE NULL END,
+      CASE
-      'movie_count', CASE WHEN ys.movie_count > 0 THEN TO_CHAR(ys.movie_count, 'FM999,999,999') ELSE NULL END,
+        WHEN ys.listen_count > 0 THEN TO_CHAR(ys.listen_count, 'FM999,999,999')
-      'concert_count', CASE WHEN ys.concert_count > 0 THEN TO_CHAR(ys.concert_count, 'FM999,999,999') ELSE NULL END,
+        ELSE NULL
-      'venue_count', CASE WHEN ys.venue_count > 0 THEN TO_CHAR(ys.venue_count, 'FM999,999,999') ELSE NULL END
+      END,
+      'genre_count',
+      CASE
+        WHEN ys.genre_count > 0 THEN TO_CHAR(ys.genre_count, 'FM999,999,999')
+        ELSE NULL
+      END,
+      'show_count',
+      CASE
+        WHEN ys.show_count > 0 THEN TO_CHAR(ys.show_count, 'FM999,999,999')
+        ELSE NULL
+      END,
+      'episode_count',
+      CASE
+        WHEN ys.episode_count > 0 THEN TO_CHAR(ys.episode_count, 'FM999,999,999')
+        ELSE NULL
+      END,
+      'post_count',
+      CASE
+        WHEN ys.post_count > 0 THEN TO_CHAR(ys.post_count, 'FM999,999,999')
+        ELSE NULL
+      END,
+      'link_count',
+      CASE
+        WHEN ys.link_count > 0 THEN TO_CHAR(ys.link_count, 'FM999,999,999')
+        ELSE NULL
+      END,
+      'book_count',
+      CASE
+        WHEN ys.book_count > 0 THEN TO_CHAR(ys.book_count, 'FM999,999,999')
+        ELSE NULL
+      END,
+      'movie_count',
+      CASE
+        WHEN ys.movie_count > 0 THEN TO_CHAR(ys.movie_count, 'FM999,999,999')
+        ELSE NULL
+      END,
+      'concert_count',
+      CASE
+        WHEN ys.concert_count > 0 THEN TO_CHAR(ys.concert_count, 'FM999,999,999')
+        ELSE NULL
+      END,
+      'venue_count',
+      CASE
+        WHEN ys.venue_count > 0 THEN TO_CHAR(ys.venue_count, 'FM999,999,999')
+        ELSE NULL
+      END
     )
   ) AS yearly_breakdown
-FROM aggregated_yearly_stats ys;
+FROM
+  aggregated_yearly_stats ys;

queries/views/feeds/syndication.sql

@@ -1,93 +1,153 @@
 CREATE OR REPLACE VIEW optimized_syndication AS
-WITH syndication_data AS (
+WITH
-  SELECT
+  syndication_data AS (
-    p.date AS content_date,
+    SELECT
-    json_build_object(
+      p.date AS content_date,
-      'title', CONCAT('📝 ', p.title, ' ', (
+      json_build_object(
-        SELECT array_to_string(
+        'title',
-          array_agg('#' || initcap(replace(trim(tag_part), ' ', ''))),
+        CONCAT(
-          ' '
+          '📝 ',
-        )
+          p.title,
-        FROM unnest(p.tags) AS t(name),
+          ' ',
-             regexp_split_to_table(t.name, '\s*&\s*') AS tag_part
+          (
-      )),
+            SELECT
-      'description', p.description,
+              array_to_string(
-      'url', p.url,
-      'image', p.image,
-      'date', p.date
-    ) AS feed
-  FROM optimized_posts p
-  UNION ALL
-  SELECT
-    l.date AS content_date,
-    json_build_object(
-      'title', CONCAT('🔗 ', l.title, CASE
-        WHEN l.mastodon IS NOT NULL THEN ' via @' || split_part(l.mastodon, '@', 2) || '@' || split_part(split_part(l.mastodon, 'https://', 2), '/', 1)
-        ELSE CONCAT(' via ', l.name)
-      END, ' ', (
-        SELECT array_to_string(
-          array_agg('#' || initcap(replace(trim(tag_part), ' ', ''))),
-          ' '
-        )
-        FROM unnest(l.tags) AS t(name),
-             regexp_split_to_table(t.name, '\s*&\s*') AS tag_part
-      )),
-      'description', l.description,
-      'url', l.link,
-      'date', l.date
-    ) AS feed
-  FROM optimized_links l
-  UNION ALL
-  SELECT
-    b.date_finished AS content_date,
-    CASE
-      WHEN LOWER(b.status) = 'finished' THEN
-        json_build_object(
-          'title', CONCAT('📖 ', b.title, CASE
-            WHEN b.rating IS NOT NULL THEN ' (' || b.rating || ')' ELSE '' END, ' ', (
-              SELECT array_to_string(
                 array_agg('#' || initcap(replace(trim(tag_part), ' ', ''))),
                 ' '
               )
-              FROM unnest(b.tags) AS t(name),
+            FROM
-                   regexp_split_to_table(t.name, '\s*&\s*') AS tag_part
+              unnest(p.tags) AS t (name),
-            )
+              regexp_split_to_table(t.name, '\s*&\s*') AS tag_part
-          ),
+          )
-          'description', b.description,
+        ),
-          'url', b.url,
+        'description',
-          'image', b.image,
+        p.description,
-          'date', b.date_finished
+        'url',
-        )
+        p.url,
-      ELSE NULL
+        'image',
-    END AS feed
+        p.image,
-  FROM optimized_books b
+        'date',
-  UNION ALL
+        p.date
-  SELECT
+      ) AS feed
-    m.last_watched AS content_date,
+    FROM
-    CASE
+      optimized_posts p
-      WHEN m.last_watched IS NOT NULL THEN
+    UNION ALL
-        json_build_object(
+    SELECT
-          'title', CONCAT('🎥 ', m.title, CASE
+      l.date AS content_date,
-            WHEN m.rating IS NOT NULL THEN ' (' || m.rating || ')' ELSE '' END, ' ', (
+      json_build_object(
-              SELECT array_to_string(
+        'title',
+        CONCAT(
+          '🔗 ',
+          l.title,
+          CASE
+            WHEN l.mastodon IS NOT NULL THEN ' via @' || split_part(l.mastodon, '@', 2) || '@' || split_part(split_part(l.mastodon, 'https://', 2), '/', 1)
+            ELSE CONCAT(' via ', l.name)
+          END,
+          ' ',
+          (
+            SELECT
+              array_to_string(
                 array_agg('#' || initcap(replace(trim(tag_part), ' ', ''))),
                 ' '
               )
-              FROM unnest(m.tags) AS t(name),
+            FROM
-                   regexp_split_to_table(t.name, '\s*&\s*') AS tag_part
+              unnest(l.tags) AS t (name),
+              regexp_split_to_table(t.name, '\s*&\s*') AS tag_part
+          )
+        ),
+        'description',
+        l.description,
+        'url',
+        l.link,
+        'date',
+        l.date
+      ) AS feed
+    FROM
+      optimized_links l
+    UNION ALL
+    SELECT
+      b.date_finished AS content_date,
+      CASE
+        WHEN LOWER(b.status) = 'finished' THEN json_build_object(
+          'title',
+          CONCAT(
+            '📖 ',
+            b.title,
+            CASE
+              WHEN b.rating IS NOT NULL THEN ' (' || b.rating || ')'
+              ELSE ''
+            END,
+            ' ',
+            (
+              SELECT
+                array_to_string(
+                  array_agg('#' || initcap(replace(trim(tag_part), ' ', ''))),
+                  ' '
+                )
+              FROM
+                unnest(b.tags) AS t (name),
+                regexp_split_to_table(t.name, '\s*&\s*') AS tag_part
             )
           ),
-          'description', m.description,
+          'description',
-          'url', m.url,
+          b.description,
-          'image', m.image,
+          'url',
-          'date', m.last_watched
+          b.url,
+          'image',
+          b.image,
+          'date',
+          b.date_finished
         )
-      ELSE NULL
+        ELSE NULL
-    END AS feed
+      END AS feed
-  FROM optimized_movies m
+    FROM
-)
+      optimized_books b
-SELECT feed
+    UNION ALL
-FROM syndication_data
+    SELECT
-WHERE feed IS NOT NULL
+      m.last_watched AS content_date,
-ORDER BY content_date DESC
+      CASE
-LIMIT 3;
+        WHEN m.last_watched IS NOT NULL THEN json_build_object(
+          'title',
+          CONCAT(
+            '🎥 ',
+            m.title,
+            CASE
+              WHEN m.rating IS NOT NULL THEN ' (' || m.rating || ')'
+              ELSE ''
+            END,
+            ' ',
+            (
+              SELECT
+                array_to_string(
+                  array_agg('#' || initcap(replace(trim(tag_part), ' ', ''))),
+                  ' '
+                )
+              FROM
+                unnest(m.tags) AS t (name),
+                regexp_split_to_table(t.name, '\s*&\s*') AS tag_part
+            )
+          ),
+          'description',
+          m.description,
+          'url',
+          m.url,
+          'image',
+          m.image,
+          'date',
+          m.last_watched
+        )
+        ELSE NULL
+      END AS feed
+    FROM
+      optimized_movies m
+  )
+SELECT
+  feed
+FROM
+  syndication_data
+WHERE
+  feed IS NOT NULL
+ORDER BY
+  content_date DESC
+LIMIT
+  3;

queries/views/feeds/tagged_content.sql

@@ -10,7 +10,8 @@ SELECT
   p.tags::TEXT[],
   'article'::TEXT AS type,
   'Post'::TEXT AS label
-FROM optimized_posts p
+FROM
+  optimized_posts p
 UNION ALL
 SELECT
   unnest(l.tags) AS tag,
@@ -23,7 +24,8 @@ SELECT
   l.tags::TEXT[],
   'link'::TEXT AS type,
   'Link'::TEXT AS label
-FROM optimized_links l
+FROM
+  optimized_links l
 UNION ALL
 SELECT
   unnest(b.tags) AS tag,
@@ -36,8 +38,10 @@ SELECT
   b.tags::TEXT[],
   'books'::TEXT AS type,
   'Book'::TEXT AS label
-FROM optimized_books b
+FROM
-WHERE LOWER(b.status) = 'finished'
+  optimized_books b
+WHERE
+  LOWER(b.status) = 'finished'
 UNION ALL
 SELECT
   unnest(m.tags) AS tag,
@@ -50,8 +54,10 @@ SELECT
   m.tags::TEXT[],
   'movies'::TEXT AS type,
   'Movie'::TEXT AS label
-FROM optimized_movies m
+FROM
-WHERE m.last_watched IS NOT NULL
+  optimized_movies m
+WHERE
+  m.last_watched IS NOT NULL
 UNION ALL
 SELECT
   unnest(s.tags) AS tag,
@@ -64,5 +70,7 @@ SELECT
   s.tags::TEXT[],
   'tv'::TEXT AS type,
   'Show'::TEXT AS label
-FROM optimized_shows s
+FROM
-WHERE s.last_watched_at IS NOT NULL;
+  optimized_shows s
+WHERE
+  s.last_watched_at IS NOT NULL;

queries/views/feeds/tags.sql

@@ -2,6 +2,9 @@ CREATE OR REPLACE VIEW optimized_all_tags AS
 SELECT
   tag,
   COUNT(*) AS uses
-FROM optimized_tagged_content
+FROM
-GROUP BY tag
+  optimized_tagged_content
-ORDER BY tag ASC;
+GROUP BY
+  tag
+ORDER BY
+  tag ASC;

queries/views/globals/index.sql

@@ -1,40 +1,48 @@
 CREATE OR REPLACE VIEW optimized_globals AS
-SELECT *
+SELECT
-FROM (
+  *
-  SELECT
+FROM
-    g.site_name,
+  (
-    g.site_description,
+    SELECT
-    g.intro,
+      g.site_name,
-    g.author,
+      g.site_description,
-    g.email,
+      g.intro,
-    g.mastodon,
+      g.author,
-    g.url,
+      g.email,
-    g.cdn_url,
+      g.mastodon,
-    g.sitemap_uri,
+      g.url,
-    g.theme_color,
+      g.cdn_url,
-    g.site_type,
+      g.sitemap_uri,
-    g.locale,
+      g.theme_color,
-    g.lang,
+      g.site_type,
-    g.webfinger_username,
+      g.locale,
-    g.webfinger_hostname,
+      g.lang,
-    CONCAT(g.cdn_url, '/', df.filename_disk) AS avatar,
+      g.webfinger_username,
-    CONCAT(g.cdn_url, '/', df2.filename_disk) AS avatar_transparent,
+      g.webfinger_hostname,
-    CONCAT(g.cdn_url, '/', df3.filename_disk) AS avatar_header,
+      CONCAT(g.cdn_url, '/', df.filename_disk) AS avatar,
-  json_build_object(
+      CONCAT(g.cdn_url, '/', df2.filename_disk) AS avatar_transparent,
-    'open_graph_image', CASE
+      CONCAT(g.cdn_url, '/', df3.filename_disk) AS avatar_header,
-      WHEN df.filename_disk IS NOT NULL AND df.filename_disk != '' AND df.filename_disk != '/' THEN
+      json_build_object(
-        CONCAT('/', df.filename_disk)
+        'open_graph_image',
-      ELSE NULL
+        CASE
-    END,
+          WHEN df.filename_disk IS NOT NULL
-    'open_graph_image_transparent', CASE
+          AND df.filename_disk != ''
-      WHEN df2.filename_disk IS NOT NULL AND df2.filename_disk != '' AND df2.filename_disk != '/' THEN
+          AND df.filename_disk != '/' THEN CONCAT('/', df.filename_disk)
-        CONCAT('/', df2.filename_disk)
+          ELSE NULL
-      ELSE NULL
+        END,
-    END
+        'open_graph_image_transparent',
-  ) AS metadata
+        CASE
-  FROM globals g
+          WHEN df2.filename_disk IS NOT NULL
-  LEFT JOIN directus_files df ON g.avatar = df.id
+          AND df2.filename_disk != ''
-  LEFT JOIN directus_files df2 ON g.avatar_transparent = df2.id
+          AND df2.filename_disk != '/' THEN CONCAT('/', df2.filename_disk)
-  LEFT JOIN directus_files df3 ON g.avatar_header = df3.id
+          ELSE NULL
-  LIMIT 1
+        END
-) sub;
+      ) AS metadata
+    FROM
+      globals g
+      LEFT JOIN directus_files df ON g.avatar = df.id
+      LEFT JOIN directus_files df2 ON g.avatar_transparent = df2.id
+      LEFT JOIN directus_files df3 ON g.avatar_header = df3.id
+    LIMIT
+      1
+  ) sub;

queries/views/globals/pages.sql

@@ -5,68 +5,102 @@ SELECT
   p.permalink,
   p.description,
   json_build_object(
-    'title', CONCAT(p.title, ' • ', globals.site_name),
+    'title',
-    'description', LEFT(
+    CONCAT(p.title, ' • ', globals.site_name),
+    'description',
+    LEFT(
       regexp_replace(
         regexp_replace(
           regexp_replace(p.description, E'[*_`~#>-]', '', 'g'),
-          E'\\[(.*?)\\]\\((.*?)\\)', '\\1', 'g'
+          E'\\[(.*?)\\]\\((.*?)\\)',
+          '\\1',
+          'g'
         ),
-        E'!\\[(.*?)\\]\\((.*?)\\)', '', 'g'
+        E'!\\[(.*?)\\]\\((.*?)\\)',
+        '',
+        'g'
       ),
       250
     ),
-    'open_graph_image', CASE
+    'open_graph_image',
-      WHEN df.filename_disk IS NOT NULL AND df.filename_disk != '' AND df.filename_disk != '/' THEN
+    CASE
-        CONCAT('/', df.filename_disk)
+      WHEN df.filename_disk IS NOT NULL
-      ELSE globals.metadata->>'open_graph_image'
+      AND df.filename_disk != ''
+      AND df.filename_disk != '/' THEN CONCAT('/', df.filename_disk)
+      ELSE globals.metadata ->> 'open_graph_image'
     END,
-    'url', CONCAT(globals.url, p.permalink),
+    'url',
-    'type', 'page'
+    CONCAT(globals.url, p.permalink),
+    'type',
+    'page'
   ) AS metadata,
-(
+  (
     SELECT
       json_agg(
-        CASE WHEN pb.collection = 'youtube_player' THEN
+        CASE
-          json_build_object('type', pb.collection, 'url', yp.url)
+          WHEN pb.collection = 'youtube_player' THEN json_build_object('type', pb.collection, 'url', yp.url)
-        WHEN pb.collection = 'forgejo_banner' THEN
+          WHEN pb.collection = 'forgejo_banner' THEN json_build_object('type', pb.collection, 'url', fb.url)
-          json_build_object('type', pb.collection, 'url', fb.url)
+          WHEN pb.collection = 'github_banner' THEN json_build_object('type', pb.collection, 'url', gb.url)
-        WHEN pb.collection = 'github_banner' THEN
+          WHEN pb.collection = 'npm_banner' THEN json_build_object(
-          json_build_object('type', pb.collection, 'url', gb.url)
+            'type',
-        WHEN pb.collection = 'npm_banner' THEN
+            pb.collection,
-          json_build_object('type', pb.collection, 'url', nb.url, 'command', nb.command)
+            'url',
-        WHEN pb.collection = 'rss_banner' THEN
+            nb.url,
-          json_build_object('type', pb.collection, 'url', rb.url, 'text', rb.text)
+            'command',
-        WHEN pb.collection = 'calendar_banner' THEN
+            nb.command
-          json_build_object('type', pb.collection, 'url', cb.url, 'text', cb.text)
+          )
-        WHEN pb.collection = 'hero' THEN
+          WHEN pb.collection = 'rss_banner' THEN json_build_object(
-          json_build_object('type', pb.collection, 'image', CONCAT('/', df_hero.filename_disk), 'alt', h.alt_text)
+            'type',
-        WHEN pb.collection = 'markdown' THEN
+            pb.collection,
-          json_build_object('type', pb.collection, 'text', md.text)
+            'url',
-        ELSE
+            rb.url,
-          json_build_object('type', pb.collection)
+            'text',
-        END ORDER BY pb.sort)
+            rb.text
+          )
+          WHEN pb.collection = 'calendar_banner' THEN json_build_object(
+            'type',
+            pb.collection,
+            'url',
+            cb.url,
+            'text',
+            cb.text
+          )
+          WHEN pb.collection = 'hero' THEN json_build_object(
+            'type',
+            pb.collection,
+            'image',
+            CONCAT('/', df_hero.filename_disk),
+            'alt',
+            h.alt_text
+          )
+          WHEN pb.collection = 'markdown' THEN json_build_object('type', pb.collection, 'text', md.text)
+          ELSE json_build_object('type', pb.collection)
+        END
+        ORDER BY
+          pb.sort
+      )
     FROM
       pages_blocks pb
-  LEFT JOIN youtube_player yp ON pb.collection = 'youtube_player'
+      LEFT JOIN youtube_player yp ON pb.collection = 'youtube_player'
-    AND yp.id = pb.item::integer
+      AND yp.id = pb.item::integer
-  LEFT JOIN forgejo_banner fb ON pb.collection = 'forgejo_banner'
+      LEFT JOIN forgejo_banner fb ON pb.collection = 'forgejo_banner'
-    AND fb.id = pb.item::integer
+      AND fb.id = pb.item::integer
-  LEFT JOIN github_banner gb ON pb.collection = 'github_banner'
+      LEFT JOIN github_banner gb ON pb.collection = 'github_banner'
-    AND gb.id = pb.item::integer
+      AND gb.id = pb.item::integer
-  LEFT JOIN npm_banner nb ON pb.collection = 'npm_banner'
+      LEFT JOIN npm_banner nb ON pb.collection = 'npm_banner'
-    AND nb.id = pb.item::integer
+      AND nb.id = pb.item::integer
-  LEFT JOIN rss_banner rb ON pb.collection = 'rss_banner'
+      LEFT JOIN rss_banner rb ON pb.collection = 'rss_banner'
-    AND rb.id = pb.item::integer
+      AND rb.id = pb.item::integer
-  LEFT JOIN calendar_banner cb ON pb.collection = 'calendar_banner'
+      LEFT JOIN calendar_banner cb ON pb.collection = 'calendar_banner'
-    AND cb.id = pb.item::integer
+      AND cb.id = pb.item::integer
-  LEFT JOIN hero h ON pb.collection = 'hero'
+      LEFT JOIN hero h ON pb.collection = 'hero'
-    AND h.id = pb.item::integer
+      AND h.id = pb.item::integer
-  LEFT JOIN directus_files df_hero ON h.image = df_hero.id
+      LEFT JOIN directus_files df_hero ON h.image = df_hero.id
-  LEFT JOIN markdown md ON pb.collection = 'markdown'
+      LEFT JOIN markdown md ON pb.collection = 'markdown'
-    AND md.id = pb.item::integer
+      AND md.id = pb.item::integer
-WHERE
+    WHERE
-  pb.pages_id = p.id) AS blocks
+      pb.pages_id = p.id
+  ) AS blocks
 FROM
   pages p
   LEFT JOIN directus_files df ON p.open_graph_image = df.id
@@ -77,4 +111,4 @@ GROUP BY
   globals.cdn_url,
   globals.site_name,
   globals.url,
-  globals.metadata->>'open_graph_image';
+  globals.metadata ->> 'open_graph_image';

queries/views/media/books.sql

@@ -1,7 +1,11 @@
 CREATE OR REPLACE VIEW optimized_books AS
 SELECT
   b.date_finished,
-  EXTRACT(YEAR FROM b.date_finished) AS year,
+  EXTRACT(
+    YEAR
+    FROM
+      b.date_finished
+  ) AS year,
   b.author,
   b.description,
   b.title,
@@ -14,184 +18,341 @@ SELECT
   b.favorite,
   b.tattoo,
   (
-    SELECT array_agg(t.name)
+    SELECT
-    FROM books_tags bt
+      array_agg(t.name)
-    LEFT JOIN tags t ON bt.tags_id = t.id
+    FROM
-    WHERE bt.books_id = b.id
+      books_tags bt
+      LEFT JOIN tags t ON bt.tags_id = t.id
+    WHERE
+      bt.books_id = b.id
   ) AS tags,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'name', a.name_string,
+        json_build_object(
-        'url', a.slug,
+          'name',
-        'country', a.country,
+          a.name_string,
-        'total_plays', a.total_plays,
+          'url',
-        'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          a.slug,
-        'grid', json_build_object(
+          'country',
-          'title', a.name_string,
+          a.country,
-          'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          'total_plays',
-          'alt', CASE WHEN a.total_plays > 0 THEN CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays of ', a.name_string) ELSE CONCAT('Artwork of ', a.name_string) END,
+          a.total_plays,
-          'subtext', CASE WHEN a.total_plays > 0 THEN CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays') ELSE NULL END,
+          'image',
-          'url', a.slug
+          CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
-        ),
+          'grid',
-        'type', 'music'
+          json_build_object(
+            'title',
+            a.name_string,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+            'alt',
+            CASE
+              WHEN a.total_plays > 0 THEN CONCAT(
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays of ',
+                a.name_string
+              )
+              ELSE CONCAT('Artwork of ', a.name_string)
+            END,
+            'subtext',
+            CASE
+              WHEN a.total_plays > 0 THEN CONCAT(
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays'
+              )
+              ELSE NULL
+            END,
+            'url',
+            a.slug
+          ),
+          'type',
+          'music'
+        )
+        ORDER BY
+          a.total_plays DESC
       )
-      ORDER BY a.total_plays DESC
+    FROM
-    )
+      books_artists ba
-    FROM books_artists ba
+      LEFT JOIN artists a ON ba.artists_id = a.id
-    LEFT JOIN artists a ON ba.artists_id = a.id
+      LEFT JOIN directus_files df_artist ON a.art = df_artist.id
-    LEFT JOIN directus_files df_artist ON a.art = df_artist.id
+    WHERE
-    WHERE ba.books_id = b.id
+      ba.books_id = b.id
   ) AS artists,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', m.title,
+        json_build_object(
-        'year', m.year,
+          'title',
-        'url', m.slug,
+          m.title,
-        'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          'year',
-        'grid', json_build_object(
+          m.year,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          m.slug,
-          'alt', CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+          'image',
-          'subtext', CASE WHEN m.star_rating IS NOT NULL THEN m.star_rating::text ELSE m.year::text END,
+          CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
-          'url', m.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'movies'
+            'title',
+            NULL,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+            'alt',
+            CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+            'subtext',
+            CASE
+              WHEN m.star_rating IS NOT NULL THEN m.star_rating::text
+              ELSE m.year::text
+            END,
+            'url',
+            m.slug
+          ),
+          'type',
+          'movies'
+        )
+        ORDER BY
+          m.year ASC
       )
-      ORDER BY m.year ASC
+    FROM
-    )
+      movies_books mb
-    FROM movies_books mb
+      LEFT JOIN movies m ON mb.movies_id = m.id
-    LEFT JOIN movies m ON mb.movies_id = m.id
+      LEFT JOIN directus_files df_movie ON m.art = df_movie.id
-    LEFT JOIN directus_files df_movie ON m.art = df_movie.id
+    WHERE
-    WHERE mb.books_id = b.id
+      mb.books_id = b.id
       AND m.last_watched IS NOT NULL
   ) AS movies,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object('name', g.name, 'url', g.slug)
+      json_agg(
-      ORDER BY g.name ASC
+        json_build_object('name', g.name, 'url', g.slug)
-    )
+        ORDER BY
-    FROM genres_books gb
+          g.name ASC
-    LEFT JOIN genres g ON gb.genres_id = g.id
+      )
-    WHERE gb.books_id = b.id
+    FROM
+      genres_books gb
+      LEFT JOIN genres g ON gb.genres_id = g.id
+    WHERE
+      gb.books_id = b.id
   ) AS genres,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', s.title,
+        json_build_object(
-        'year', s.year,
+          'title',
-        'url', s.slug,
+          s.title,
-        'image', CONCAT(globals.cdn_url, '/', df_show.filename_disk),
+          'year',
-        'grid', json_build_object(
+          s.year,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_show.filename_disk),
+          s.slug,
-          'alt', CONCAT('Artwork for ', s.title),
+          'image',
-          'subtext', CASE
+          CONCAT(globals.cdn_url, '/', df_show.filename_disk),
-            WHEN (
+          'grid',
-              SELECT MAX(e1.last_watched_at)
+          json_build_object(
-              FROM episodes e1
+            'title',
-              WHERE e1.show = s.id
+            NULL,
-            ) >= NOW() - INTERVAL '90 days' THEN (
+            'image',
-              SELECT CONCAT('S', e2.season_number, 'E', e2.episode_number)
+            CONCAT(globals.cdn_url, '/', df_show.filename_disk),
-              FROM episodes e2
+            'alt',
-              WHERE e2.show = s.id
+            CONCAT('Artwork for ', s.title),
-              ORDER BY e2.last_watched_at DESC, e2.season_number DESC, e2.episode_number DESC
+            'subtext',
-              LIMIT 1
+            CASE
-            )
+              WHEN (
-            ELSE s.year::text
+                SELECT
-          END,
+                  MAX(e1.last_watched_at)
-          'url', s.slug
+                FROM
-        ),
+                  episodes e1
-        'type', 'tv'
+                WHERE
+                  e1.show = s.id
+              ) >= NOW() - INTERVAL '90 days' THEN (
+                SELECT
+                  CONCAT('S', e2.season_number, 'E', e2.episode_number)
+                FROM
+                  episodes e2
+                WHERE
+                  e2.show = s.id
+                ORDER BY
+                  e2.last_watched_at DESC,
+                  e2.season_number DESC,
+                  e2.episode_number DESC
+                LIMIT
+                  1
+              )
+              ELSE s.year::text
+            END,
+            'url',
+            s.slug
+          ),
+          'type',
+          'tv'
+        )
+        ORDER BY
+          s.year ASC
       )
-      ORDER BY s.year ASC
+    FROM
-    )
+      shows_books sb
-    FROM shows_books sb
+      LEFT JOIN shows s ON sb.shows_id = s.id
-    LEFT JOIN shows s ON sb.shows_id = s.id
+      LEFT JOIN directus_files df_show ON s.art = df_show.id
-    LEFT JOIN directus_files df_show ON s.art = df_show.id
+    WHERE
-    WHERE sb.books_id = b.id
+      sb.books_id = b.id
       AND EXISTS (
-        SELECT 1
+        SELECT
-        FROM episodes e
+          1
-        WHERE e.show = s.id
+        FROM
+          episodes e
+        WHERE
+          e.show = s.id
           AND e.last_watched_at IS NOT NULL
       )
   ) AS shows,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object('title', p.title, 'date', p.date, 'url', p.slug)
+      json_agg(
-      ORDER BY p.date DESC
+        json_build_object('title', p.title, 'date', p.date, 'url', p.slug)
-    )
+        ORDER BY
-    FROM posts_books pb
+          p.date DESC
-    LEFT JOIN posts p ON pb.posts_id = p.id
+      )
-    WHERE pb.books_id = b.id
+    FROM
+      posts_books pb
+      LEFT JOIN posts p ON pb.posts_id = p.id
+    WHERE
+      pb.books_id = b.id
   ) AS posts,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', rb.title,
+        json_build_object(
-        'author', rb.author,
+          'title',
-        'url', rb.slug,
+          rb.title,
-        'image', CONCAT(globals.cdn_url, '/', df_rb.filename_disk),
+          'author',
-        'grid', json_build_object(
+          rb.author,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_rb.filename_disk),
+          rb.slug,
-          'alt', CONCAT('Cover for ', rb.title, ' by ', rb.author),
+          'image',
-          'subtext', CASE WHEN rb.star_rating IS NOT NULL THEN rb.star_rating ELSE NULL END,
+          CONCAT(globals.cdn_url, '/', df_rb.filename_disk),
-          'url', rb.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'books'
+            'title',
+            NULL,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_rb.filename_disk),
+            'alt',
+            CONCAT('Cover for ', rb.title, ' by ', rb.author),
+            'subtext',
+            CASE
+              WHEN rb.star_rating IS NOT NULL THEN rb.star_rating
+              ELSE NULL
+            END,
+            'url',
+            rb.slug
+          ),
+          'type',
+          'books'
+        )
+        ORDER BY
+          rb.title ASC
       )
-      ORDER BY rb.title ASC
+    FROM
-    )
+      related_books rbk
-    FROM related_books rbk
+      LEFT JOIN books rb ON rbk.related_books_id = rb.id
-    LEFT JOIN books rb ON rbk.related_books_id = rb.id
+      LEFT JOIN directus_files df_rb ON rb.art = df_rb.id
-    LEFT JOIN directus_files df_rb ON rb.art = df_rb.id
+    WHERE
-    WHERE rbk.books_id = b.id
+      rbk.books_id = b.id
       AND LOWER(b.read_status) = 'finished'
   ) AS related_books,
   json_build_object(
-    'title', NULL,
+    'title',
-    'image', CONCAT(globals.cdn_url, '/', df.filename_disk),
+    NULL,
-    'url', b.slug,
+    'image',
-    'alt', CONCAT('Book cover from ', b.title, ' by ', b.author),
+    CONCAT(globals.cdn_url, '/', df.filename_disk),
-    'subtext', CASE WHEN b.star_rating IS NOT NULL THEN b.star_rating::text ELSE NULL END,
+    'url',
-    'type', 'books'
+    b.slug,
+    'alt',
+    CONCAT('Book cover from ', b.title, ' by ', b.author),
+    'subtext',
+    CASE
+      WHEN b.star_rating IS NOT NULL THEN b.star_rating::text
+      ELSE NULL
+    END,
+    'type',
+    'books'
   ) AS grid,
   CASE
-    WHEN LOWER(b.read_status) = 'finished' AND b.star_rating IS NOT NULL THEN
+    WHEN LOWER(b.read_status) = 'finished'
-      json_build_object(
+    AND b.star_rating IS NOT NULL THEN json_build_object(
-        'title', CONCAT(b.title, ' by ', b.author, ' (', b.star_rating, ')'),
+      'title',
-        'url', b.slug,
+      CONCAT(
-        'date', b.date_finished,
+        b.title,
-        'description', COALESCE(b.review, b.description),
+        ' by ',
-        'image', CONCAT(globals.cdn_url, '/', df.filename_disk),
+        b.author,
-        'rating', b.star_rating
+        ' (',
-      )
+        b.star_rating,
+        ')'
+      ),
+      'url',
+      b.slug,
+      'date',
+      b.date_finished,
+      'description',
+      COALESCE(b.review, b.description),
+      'image',
+      CONCAT(globals.cdn_url, '/', df.filename_disk),
+      'rating',
+      b.star_rating
+    )
     ELSE NULL
   END AS feed,
-  (SELECT TO_CHAR(days_read, 'FM999G999G999') FROM reading_streak LIMIT 1) AS days_read,
+  (
+    SELECT
+      TO_CHAR(days_read, 'FM999G999G999')
+    FROM
+      reading_streak
+    LIMIT
+      1
+  ) AS days_read,
   json_build_object(
-    'title', CONCAT('Book • ', b.title, ' by ', b.author, ' • ', globals.site_name),
+    'title',
-    'description', LEFT(
+    CONCAT(
+      'Book • ',
+      b.title,
+      ' by ',
+      b.author,
+      ' • ',
+      globals.site_name
+    ),
+    'description',
+    LEFT(
       regexp_replace(
         regexp_replace(
-          regexp_replace( b.description, E'[*_`~#>-]', '', 'g'),
+          regexp_replace(b.description, E'[*_`~#>-]', '', 'g'),
-          E'\\[(.*?)\\]\\((.*?)\\)', E'\\1', 'g'
+          E'\\[(.*?)\\]\\((.*?)\\)',
+          E'\\1',
+          'g'
         ),
-        E'!\\[(.*?)\\]\\((.*?)\\)', '', 'g'
+        E'!\\[(.*?)\\]\\((.*?)\\)',
+        '',
+        'g'
       ),
       250
     ),
-    'open_graph_image', CASE
+    'open_graph_image',
-      WHEN df.filename_disk IS NOT NULL AND df.filename_disk != '' AND df.filename_disk != '/' THEN CONCAT('/', df.filename_disk)
+    CASE
+      WHEN df.filename_disk IS NOT NULL
+      AND df.filename_disk != ''
+      AND df.filename_disk != '/' THEN CONCAT('/', df.filename_disk)
       ELSE NULL
     END,
-    'url', CONCAT(globals.url, b.slug),
+    'url',
-    'type', 'book'
+    CONCAT(globals.url, b.slug),
+    'type',
+    'book'
   ) AS metadata
-FROM books b
+FROM
-LEFT JOIN directus_files df ON b.art = df.id
+  books b
-CROSS JOIN optimized_globals globals
+  LEFT JOIN directus_files df ON b.art = df.id
-GROUP BY b.id, df.filename_disk, globals.cdn_url, globals.site_name, globals.url;
+  CROSS JOIN optimized_globals globals
+GROUP BY
+  b.id,
+  df.filename_disk,
+  globals.cdn_url,
+  globals.site_name,
+  globals.url;

queries/views/media/movies.sql

@@ -15,192 +15,322 @@ SELECT
   CONCAT(globals.cdn_url, '/', df.filename_disk) AS image,
   CONCAT(globals.cdn_url, '/', df2.filename_disk) AS backdrop,
   json_build_object(
-    'title', m.title,
+    'title',
-    'url', m.slug,
+    m.title,
-    'image', CONCAT(globals.cdn_url, '/', df.filename_disk),
+    'url',
-    'backdrop', CONCAT(globals.cdn_url, '/', df2.filename_disk),
+    m.slug,
-    'alt', CONCAT('Poster from ', m.title),
+    'image',
-    'subtext', CASE
+    CONCAT(globals.cdn_url, '/', df.filename_disk),
+    'backdrop',
+    CONCAT(globals.cdn_url, '/', df2.filename_disk),
+    'alt',
+    CONCAT('Poster from ', m.title),
+    'subtext',
+    CASE
       WHEN m.last_watched >= NOW() - INTERVAL '90 days' THEN m.star_rating::text
       ELSE m.year::text
     END,
-    'type', 'movies'
+    'type',
+    'movies'
   ) AS grid,
   (
-    SELECT array_agg(t.name)
+    SELECT
-    FROM movies_tags mt
+      array_agg(t.name)
-    LEFT JOIN tags t ON mt.tags_id = t.id
+    FROM
-    WHERE mt.movies_id = m.id
+      movies_tags mt
+      LEFT JOIN tags t ON mt.tags_id = t.id
+    WHERE
+      mt.movies_id = m.id
   ) AS tags,
   (
-    SELECT json_agg(json_build_object('name', g.name, 'url', g.slug)
+    SELECT
-    ORDER BY g.name ASC)
+      json_agg(
-    FROM genres_movies gm
+        json_build_object('name', g.name, 'url', g.slug)
-    LEFT JOIN genres g ON gm.genres_id = g.id
+        ORDER BY
-    WHERE gm.movies_id = m.id
+          g.name ASC
+      )
+    FROM
+      genres_movies gm
+      LEFT JOIN genres g ON gm.genres_id = g.id
+    WHERE
+      gm.movies_id = m.id
   ) AS genres,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'name', a.name_string,
+        json_build_object(
-        'url', a.slug,
+          'name',
-        'country', a.country,
+          a.name_string,
-        'total_plays', a.total_plays,
+          'url',
-        'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          a.slug,
-        'grid', json_build_object(
+          'country',
-          'title', a.name_string,
+          a.country,
-          'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          'total_plays',
-          'alt', CASE
+          a.total_plays,
-            WHEN a.total_plays > 0 THEN CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays of ', a.name_string)
+          'image',
-            ELSE CONCAT('Artwork of ', a.name_string)
+          CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
-          END,
+          'grid',
-          'subtext', CASE
+          json_build_object(
-            WHEN a.total_plays > 0 THEN CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays')
+            'title',
-            ELSE NULL
+            a.name_string,
-          END,
+            'image',
-          'url', a.slug
+            CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
-        ),
+            'alt',
-        'type', 'music'
+            CASE
+              WHEN a.total_plays > 0 THEN CONCAT(
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays of ',
+                a.name_string
+              )
+              ELSE CONCAT('Artwork of ', a.name_string)
+            END,
+            'subtext',
+            CASE
+              WHEN a.total_plays > 0 THEN CONCAT(
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays'
+              )
+              ELSE NULL
+            END,
+            'url',
+            a.slug
+          ),
+          'type',
+          'music'
+        )
+        ORDER BY
+          a.total_plays DESC
       )
-      ORDER BY a.total_plays DESC
+    FROM
-    )
+      movies_artists ma
-    FROM movies_artists ma
+      LEFT JOIN artists a ON ma.artists_id = a.id
-    LEFT JOIN artists a ON ma.artists_id = a.id
+      LEFT JOIN directus_files df_artist ON a.art = df_artist.id
-    LEFT JOIN directus_files df_artist ON a.art = df_artist.id
+    WHERE
-    WHERE ma.movies_id = m.id
+      ma.movies_id = m.id
   ) AS artists,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', b.title,
+        json_build_object(
-        'author', b.author,
+          'title',
-        'url', b.slug,
+          b.title,
-        'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          'author',
-        'grid', json_build_object(
+          b.author,
-          'title', b.title,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          b.slug,
-          'alt', CONCAT('Cover for ', b.title, ' by ', b.author),
+          'image',
-          'subtext', b.author,
+          CONCAT(globals.cdn_url, '/', df_book.filename_disk),
-          'url', b.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'books'
+            'title',
+            b.title,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+            'alt',
+            CONCAT('Cover for ', b.title, ' by ', b.author),
+            'subtext',
+            b.author,
+            'url',
+            b.slug
+          ),
+          'type',
+          'books'
+        )
+        ORDER BY
+          b.title
       )
-      ORDER BY b.title
+    FROM
-    )
+      movies_books mb
-    FROM movies_books mb
+      LEFT JOIN books b ON mb.books_id = b.id
-    LEFT JOIN books b ON mb.books_id = b.id
+      LEFT JOIN directus_files df_book ON b.art = df_book.id
-    LEFT JOIN directus_files df_book ON b.art = df_book.id
+    WHERE
-    WHERE mb.movies_id = m.id
+      mb.movies_id = m.id
       AND LOWER(b.read_status) = 'finished'
   ) AS books,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', s.title,
+        json_build_object(
-        'year', s.year,
+          'title',
-        'url', s.slug,
+          s.title,
-        'image', CONCAT(globals.cdn_url, '/', df_show.filename_disk),
+          'year',
-        'grid', json_build_object(
+          s.year,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_show.filename_disk),
+          s.slug,
-          'alt', CONCAT('Artwork for ', s.title),
+          'image',
-          'subtext', CASE
+          CONCAT(globals.cdn_url, '/', df_show.filename_disk),
-            WHEN (
+          'grid',
-              SELECT MAX(e1.last_watched_at)
+          json_build_object(
-              FROM episodes e1
+            'title',
-              WHERE e1.show = s.id
+            NULL,
-            ) >= NOW() - INTERVAL '90 days' THEN (
+            'image',
-              SELECT CONCAT('S', e2.season_number, 'E', e2.episode_number)
+            CONCAT(globals.cdn_url, '/', df_show.filename_disk),
-              FROM episodes e2
+            'alt',
-              WHERE e2.show = s.id
+            CONCAT('Artwork for ', s.title),
-              ORDER BY e2.last_watched_at DESC, e2.season_number DESC, e2.episode_number DESC
+            'subtext',
-              LIMIT 1
+            CASE
-            )
+              WHEN (
-            ELSE s.year::text
+                SELECT
-          END,
+                  MAX(e1.last_watched_at)
-          'url', s.slug
+                FROM
-        ),
+                  episodes e1
-        'type', 'tv'
+                WHERE
+                  e1.show = s.id
+              ) >= NOW() - INTERVAL '90 days' THEN (
+                SELECT
+                  CONCAT('S', e2.season_number, 'E', e2.episode_number)
+                FROM
+                  episodes e2
+                WHERE
+                  e2.show = s.id
+                ORDER BY
+                  e2.last_watched_at DESC,
+                  e2.season_number DESC,
+                  e2.episode_number DESC
+                LIMIT
+                  1
+              )
+              ELSE s.year::text
+            END,
+            'url',
+            s.slug
+          ),
+          'type',
+          'tv'
+        )
+        ORDER BY
+          s.year ASC
       )
-      ORDER BY s.year ASC
+    FROM
-    )
+      shows_movies sm
-    FROM shows_movies sm
+      LEFT JOIN shows s ON sm.shows_id = s.id
-    LEFT JOIN shows s ON sm.shows_id = s.id
+      LEFT JOIN directus_files df_show ON s.art = df_show.id
-    LEFT JOIN directus_files df_show ON s.art = df_show.id
+    WHERE
-    WHERE sm.movies_id = m.id
+      sm.movies_id = m.id
       AND EXISTS (
-        SELECT 1
+        SELECT
-        FROM episodes e
+          1
-        WHERE e.show = s.id
+        FROM
+          episodes e
+        WHERE
+          e.show = s.id
           AND e.last_watched_at IS NOT NULL
       )
   ) AS shows,
   (
-    SELECT json_agg(json_build_object('title', p.title, 'date', p.date, 'url', p.slug)
+    SELECT
-    ORDER BY p.date DESC)
+      json_agg(
-    FROM posts_movies pm
+        json_build_object('title', p.title, 'date', p.date, 'url', p.slug)
-    LEFT JOIN posts p ON pm.posts_id = p.id
+        ORDER BY
-    WHERE pm.movies_id = m.id
+          p.date DESC
+      )
+    FROM
+      posts_movies pm
+      LEFT JOIN posts p ON pm.posts_id = p.id
+    WHERE
+      pm.movies_id = m.id
   ) AS posts,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', rm.title,
+        json_build_object(
-        'year', rm.year,
+          'title',
-        'url', rm.slug,
+          rm.title,
-        'image', CONCAT(globals.cdn_url, '/', df_related.filename_disk),
+          'year',
-        'grid', json_build_object(
+          rm.year,
-          'title', rm.title,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_related.filename_disk),
+          rm.slug,
-          'alt', CONCAT('Poster for ', rm.title),
+          'image',
-          'subtext', CASE WHEN rm.last_watched IS NOT NULL THEN rm.star_rating::text ELSE rm.year::text END,
+          CONCAT(globals.cdn_url, '/', df_related.filename_disk),
-          'url', rm.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'movies'
+            'title',
+            rm.title,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_related.filename_disk),
+            'alt',
+            CONCAT('Poster for ', rm.title),
+            'subtext',
+            CASE
+              WHEN rm.last_watched IS NOT NULL THEN rm.star_rating::text
+              ELSE rm.year::text
+            END,
+            'url',
+            rm.slug
+          ),
+          'type',
+          'movies'
+        )
+        ORDER BY
+          rm.year ASC
       )
-      ORDER BY rm.year ASC
+    FROM
-    )
+      related_movies r
-    FROM related_movies r
+      LEFT JOIN movies rm ON r.related_movies_id = rm.id
-    LEFT JOIN movies rm ON r.related_movies_id = rm.id
+      LEFT JOIN directus_files df_related ON rm.art = df_related.id
-    LEFT JOIN directus_files df_related ON rm.art = df_related.id
+    WHERE
-    WHERE r.movies_id = m.id
+      r.movies_id = m.id
       AND rm.last_watched IS NOT NULL
   ) AS related_movies,
   CASE
-    WHEN m.star_rating IS NOT NULL AND m.last_watched IS NOT NULL THEN
+    WHEN m.star_rating IS NOT NULL
-      json_build_object(
+    AND m.last_watched IS NOT NULL THEN json_build_object(
-        'title', CONCAT(m.title, ' (', m.star_rating, ')'),
+      'title',
-        'url', m.slug,
+      CONCAT(m.title, ' (', m.star_rating, ')'),
-        'date', m.last_watched,
+      'url',
-        'description', COALESCE(m.review, m.description),
+      m.slug,
-        'image', CONCAT(globals.cdn_url, '/', df.filename_disk),
+      'date',
-        'rating', m.star_rating
+      m.last_watched,
-      )
+      'description',
+      COALESCE(m.review, m.description),
+      'image',
+      CONCAT(globals.cdn_url, '/', df.filename_disk),
+      'rating',
+      m.star_rating
+    )
     ELSE NULL
   END AS feed,
   json_build_object(
-    'title', CONCAT('Movie • ', m.title, ' • ', globals.site_name),
+    'title',
-    'description', LEFT(
+    CONCAT('Movie • ', m.title, ' • ', globals.site_name),
+    'description',
+    LEFT(
       regexp_replace(
         regexp_replace(
           regexp_replace(m.description, E'[*_`~#>-]', '', 'g'),
-          E'\\[(.*?)\\]\\((.*?)\\)', E'\\1', 'g'
+          E'\\[(.*?)\\]\\((.*?)\\)',
+          E'\\1',
+          'g'
         ),
-        E'!\\[(.*?)\\]\\((.*?)\\)', '', 'g'
+        E'!\\[(.*?)\\]\\((.*?)\\)',
+        '',
+        'g'
       ),
       250
     ),
-    'open_graph_image', CASE
+    'open_graph_image',
-      WHEN df2.filename_disk IS NOT NULL AND df2.filename_disk != '' AND df2.filename_disk != '/' THEN
+    CASE
-        CONCAT('/', df2.filename_disk)
+      WHEN df2.filename_disk IS NOT NULL
+      AND df2.filename_disk != ''
+      AND df2.filename_disk != '/' THEN CONCAT('/', df2.filename_disk)
       ELSE NULL
     END,
-    'url', CONCAT(globals.url, m.slug),
+    'url',
-    'type', 'movie'
+    CONCAT(globals.url, m.slug),
+    'type',
+    'movie'
   ) AS metadata
-FROM movies m
+FROM
-LEFT JOIN directus_files df ON m.art = df.id
+  movies m
-LEFT JOIN directus_files df2 ON m.backdrop = df2.id
+  LEFT JOIN directus_files df ON m.art = df.id
-CROSS JOIN optimized_globals globals
+  LEFT JOIN directus_files df2 ON m.backdrop = df2.id
-GROUP BY m.id, df.filename_disk, df2.filename_disk, globals.cdn_url, globals.site_name, globals.url
+  CROSS JOIN optimized_globals globals
-ORDER BY m.last_watched DESC;
+GROUP BY
+  m.id,
+  df.filename_disk,
+  df2.filename_disk,
+  globals.cdn_url,
+  globals.site_name,
+  globals.url
+ORDER BY
+  m.last_watched DESC;

queries/views/media/music/album_releases.sql

@@ -5,14 +5,34 @@ SELECT
   COALESCE(a.release_link, ar.slug) AS url,
   a.total_plays,
   CONCAT('/', df.filename_disk) AS image,
-  json_build_object('name', ar.name_string, 'url', ar.slug, 'description', ar.description) AS artist,
-  EXTRACT(EPOCH FROM a.release_date) AS release_timestamp,
   json_build_object(
-    'title', a.name,
+    'name',
-    'image', CONCAT(globals.cdn_url, '/', df.filename_disk),
+    ar.name_string,
-    'url', COALESCE(a.release_link, ar.slug),
+    'url',
-    'alt', CONCAT(a.name, ' by ', ar.name_string),
+    ar.slug,
-    'subtext', CONCAT(ar.name_string, ' • ', TO_CHAR(a.release_date, 'Mon FMDD, YYYY'))
+    'description',
+    ar.description
+  ) AS artist,
+  EXTRACT(
+    EPOCH
+    FROM
+      a.release_date
+  ) AS release_timestamp,
+  json_build_object(
+    'title',
+    a.name,
+    'image',
+    CONCAT(globals.cdn_url, '/', df.filename_disk),
+    'url',
+    COALESCE(a.release_link, ar.slug),
+    'alt',
+    CONCAT(a.name, ' by ', ar.name_string),
+    'subtext',
+    CONCAT(
+      ar.name_string,
+      ' • ',
+      TO_CHAR(a.release_date, 'Mon FMDD, YYYY')
+    )
   ) AS grid
 FROM
   albums a

queries/views/media/music/albums.sql

@@ -8,23 +8,44 @@ SELECT
   ar.slug AS artist_url,
   CONCAT(globals.cdn_url, '/', df_album.filename_disk) AS image,
   json_build_object(
-    'title', al.name,
+    'title',
-    'image', CONCAT(globals.cdn_url, '/', df_album.filename_disk),
+    al.name,
-    'url', ar.slug,
+    'image',
-    'alt', CONCAT('Cover for ', al.name, ' by ', ar.name_string),
+    CONCAT(globals.cdn_url, '/', df_album.filename_disk),
-    'subtext', CONCAT(to_char(al.total_plays, 'FM999,999,999,999'), ' plays')
+    'url',
+    ar.slug,
+    'alt',
+    CONCAT('Cover for ', al.name, ' by ', ar.name_string),
+    'subtext',
+    CONCAT(
+      to_char(al.total_plays, 'FM999,999,999,999'),
+      ' plays'
+    )
   ) AS grid,
   json_build_object(
-    'title', al.name,
+    'title',
-    'artist', ar.name_string,
+    al.name,
-    'plays', to_char(al.total_plays, 'FM999,999,999,999'),
+    'artist',
-    'image', CONCAT(globals.cdn_url, '/', df_album.filename_disk),
+    ar.name_string,
-    'url', ar.slug,
+    'plays',
-    'year', al.release_year,
+    to_char(al.total_plays, 'FM999,999,999,999'),
-    'alt', CONCAT('Cover for ', al.name, ' by ', ar.name_string)
+    'image',
+    CONCAT(globals.cdn_url, '/', df_album.filename_disk),
+    'url',
+    ar.slug,
+    'year',
+    al.release_year,
+    'alt',
+    CONCAT('Cover for ', al.name, ' by ', ar.name_string)
   ) AS table
-FROM albums al
+FROM
-LEFT JOIN artists ar ON al.artist = ar.id
+  albums al
-LEFT JOIN directus_files df_album ON al.art = df_album.id
+  LEFT JOIN artists ar ON al.artist = ar.id
-CROSS JOIN optimized_globals globals
+  LEFT JOIN directus_files df_album ON al.art = df_album.id
-GROUP BY al.id, ar.name_string, ar.slug, df_album.filename_disk, globals.cdn_url;
+  CROSS JOIN optimized_globals globals
+GROUP BY
+  al.id,
+  ar.name_string,
+  ar.slug,
+  df_album.filename_disk,
+  globals.cdn_url;

queries/views/media/music/artists.sql

@@ -16,196 +16,383 @@ SELECT
   ar.tattoo,
   CONCAT(globals.cdn_url, '/', df.filename_disk) AS image,
   json_build_object(
-    'title', ar.name_string,
+    'title',
-    'image', CONCAT(globals.cdn_url, '/', df.filename_disk),
+    ar.name_string,
-    'url', ar.slug,
+    'image',
-    'alt', CASE WHEN ar.total_plays > 0 THEN CONCAT(to_char(ar.total_plays, 'FM999,999,999,999'), ' plays of ', ar.name_string) ELSE CONCAT('Artwork of ', ar.name_string) END,
+    CONCAT(globals.cdn_url, '/', df.filename_disk),
-    'subtext', CASE WHEN ar.total_plays > 0 THEN CONCAT(to_char(ar.total_plays, 'FM999,999,999,999'), ' plays') ELSE NULL END
+    'url',
+    ar.slug,
+    'alt',
+    CASE
+      WHEN ar.total_plays > 0 THEN CONCAT(
+        to_char(ar.total_plays, 'FM999,999,999,999'),
+        ' plays of ',
+        ar.name_string
+      )
+      ELSE CONCAT('Artwork of ', ar.name_string)
+    END,
+    'subtext',
+    CASE
+      WHEN ar.total_plays > 0 THEN CONCAT(
+        to_char(ar.total_plays, 'FM999,999,999,999'),
+        ' plays'
+      )
+      ELSE NULL
+    END
   ) AS grid,
   json_build_object(
-    'title', ar.name_string,
+    'title',
-    'genre', g.name,
+    ar.name_string,
-    'genre_url', g.slug,
+    'genre',
-    'emoji', COALESCE(ar.emoji, g.emoji),
+    g.name,
-    'plays', to_char(ar.total_plays, 'FM999,999,999,999'),
+    'genre_url',
-    'image', CONCAT(globals.cdn_url, '/', df.filename_disk),
+    g.slug,
-    'url', ar.slug,
+    'emoji',
-    'alt', CONCAT(to_char(ar.total_plays, 'FM999,999,999,999'), ' plays of ', ar.name_string)
+    COALESCE(ar.emoji, g.emoji),
+    'plays',
+    to_char(ar.total_plays, 'FM999,999,999,999'),
+    'image',
+    CONCAT(globals.cdn_url, '/', df.filename_disk),
+    'url',
+    ar.slug,
+    'alt',
+    CONCAT(
+      to_char(ar.total_plays, 'FM999,999,999,999'),
+      ' plays of ',
+      ar.name_string
+    )
   ) AS table,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'name', a.name,
+        json_build_object(
-        'release_year', a.release_year,
+          'name',
-        'total_plays', to_char(a.total_plays, 'FM999,999,999,999'),
+          a.name,
-        'art', df_album.filename_disk,
+          'release_year',
-        'grid', json_build_object(
+          a.release_year,
-          'title', a.name,
+          'total_plays',
-          'image', CONCAT(globals.cdn_url, '/', df_album.filename_disk),
+          to_char(a.total_plays, 'FM999,999,999,999'),
-          'alt', CASE WHEN a.total_plays > 0 THEN CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays of ', a.name) ELSE CONCAT('Artwork for ', a.name) END,
+          'art',
-          'subtext', CASE WHEN a.total_plays > 0 THEN CONCAT(a.release_year, ' • ', to_char(a.total_plays, 'FM999,999,999,999'), ' plays') ELSE a.release_year::text END
+          df_album.filename_disk,
-        ),
+          'grid',
-        'type', 'albums'
+          json_build_object(
+            'title',
+            a.name,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_album.filename_disk),
+            'alt',
+            CASE
+              WHEN a.total_plays > 0 THEN CONCAT(
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays of ',
+                a.name
+              )
+              ELSE CONCAT('Artwork for ', a.name)
+            END,
+            'subtext',
+            CASE
+              WHEN a.total_plays > 0 THEN CONCAT(
+                a.release_year,
+                ' • ',
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays'
+              )
+              ELSE a.release_year::text
+            END
+          ),
+          'type',
+          'albums'
+        )
+        ORDER BY
+          a.release_year
       )
-      ORDER BY a.release_year
+    FROM
-    )
+      albums a
-    FROM albums a
+      LEFT JOIN directus_files df_album ON a.art = df_album.id
-    LEFT JOIN directus_files df_album ON a.art = df_album.id
+    WHERE
-    WHERE a.artist = ar.id
+      a.artist = ar.id
   ) AS albums,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'id', c.id,
+        json_build_object(
-        'date', c.date,
+          'id',
-        'venue_name', v.name,
+          c.id,
-        'venue_name_short', trim(split_part(v.name, ',', 1)),
+          'date',
-        'venue_latitude', v.latitude,
+          c.date,
-        'venue_longitude', v.longitude,
+          'venue_name',
-        'notes', c.notes
+          v.name,
+          'venue_name_short',
+          trim(split_part(v.name, ',', 1)),
+          'venue_latitude',
+          v.latitude,
+          'venue_longitude',
+          v.longitude,
+          'notes',
+          c.notes
+        )
+        ORDER BY
+          c.date DESC
       )
-      ORDER BY c.date DESC
+    FROM
-    )
+      concerts c
-    FROM concerts c
+      LEFT JOIN venues v ON c.venue = v.id
-    LEFT JOIN venues v ON c.venue = v.id
+    WHERE
-    WHERE c.artist = ar.id
+      c.artist = ar.id
   ) AS concerts,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', b.title,
+        json_build_object(
-        'author', b.author,
+          'title',
-        'url', b.slug,
+          b.title,
-        'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          'author',
-        'grid', json_build_object(
+          b.author,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          b.slug,
-          'alt', CONCAT('Cover for ', b.title, ' by ', b.author),
+          'image',
-          'subtext', CASE WHEN b.star_rating IS NOT NULL THEN b.star_rating ELSE NULL END,
+          CONCAT(globals.cdn_url, '/', df_book.filename_disk),
-          'url', b.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'books'
+            'title',
+            NULL,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+            'alt',
+            CONCAT('Cover for ', b.title, ' by ', b.author),
+            'subtext',
+            CASE
+              WHEN b.star_rating IS NOT NULL THEN b.star_rating
+              ELSE NULL
+            END,
+            'url',
+            b.slug
+          ),
+          'type',
+          'books'
+        )
+        ORDER BY
+          b.title ASC
       )
-      ORDER BY b.title ASC
+    FROM
-    )
+      books_artists ba
-    FROM books_artists ba
+      LEFT JOIN books b ON ba.books_id = b.id
-    LEFT JOIN books b ON ba.books_id = b.id
+      LEFT JOIN directus_files df_book ON b.art = df_book.id
-    LEFT JOIN directus_files df_book ON b.art = df_book.id
+    WHERE
-    WHERE ba.artists_id = ar.id
+      ba.artists_id = ar.id
       AND LOWER(b.read_status) = 'finished'
   ) AS books,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', m.title,
+        json_build_object(
-        'year', m.year,
+          'title',
-        'url', m.slug,
+          m.title,
-        'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          'year',
-        'grid', json_build_object(
+          m.year,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          m.slug,
-          'alt', CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+          'image',
-          'subtext', CASE WHEN m.star_rating IS NOT NULL THEN m.star_rating::text ELSE m.year::text END,
+          CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
-          'url', m.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'movies'
+            'title',
+            NULL,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+            'alt',
+            CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+            'subtext',
+            CASE
+              WHEN m.star_rating IS NOT NULL THEN m.star_rating::text
+              ELSE m.year::text
+            END,
+            'url',
+            m.slug
+          ),
+          'type',
+          'movies'
+        )
+        ORDER BY
+          m.year ASC
       )
-      ORDER BY m.year ASC
+    FROM
-    )
+      movies_artists ma
-    FROM movies_artists ma
+      LEFT JOIN movies m ON ma.movies_id = m.id
-    LEFT JOIN movies m ON ma.movies_id = m.id
+      LEFT JOIN directus_files df_movie ON m.art = df_movie.id
-    LEFT JOIN directus_files df_movie ON m.art = df_movie.id
+    WHERE
-    WHERE ma.artists_id = ar.id
+      ma.artists_id = ar.id
       AND m.last_watched IS NOT NULL
   ) AS movies,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', s.title,
+        json_build_object(
-        'year', s.year,
+          'title',
-        'url', s.slug,
+          s.title,
-        'image', CONCAT(globals.cdn_url, '/', df_show.filename_disk),
+          'year',
-        'grid', json_build_object(
+          s.year,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_show.filename_disk),
+          s.slug,
-          'alt', CONCAT('Artwork for ', s.title),
+          'image',
-          'subtext', CASE
+          CONCAT(globals.cdn_url, '/', df_show.filename_disk),
-            WHEN (
+          'grid',
-              SELECT MAX(e1.last_watched_at)
+          json_build_object(
-              FROM episodes e1
+            'title',
-              WHERE e1.show = s.id
+            NULL,
-            ) >= NOW() - INTERVAL '90 days' THEN
+            'image',
-              (
+            CONCAT(globals.cdn_url, '/', df_show.filename_disk),
-                SELECT CONCAT('S', e2.season_number, 'E', e2.episode_number)
+            'alt',
-                FROM episodes e2
+            CONCAT('Artwork for ', s.title),
-                WHERE e2.show = s.id
+            'subtext',
-                ORDER BY e2.last_watched_at DESC, e2.season_number DESC, e2.episode_number DESC
+            CASE
-                LIMIT 1
+              WHEN (
+                SELECT
+                  MAX(e1.last_watched_at)
+                FROM
+                  episodes e1
+                WHERE
+                  e1.show = s.id
+              ) >= NOW() - INTERVAL '90 days' THEN (
+                SELECT
+                  CONCAT('S', e2.season_number, 'E', e2.episode_number)
+                FROM
+                  episodes e2
+                WHERE
+                  e2.show = s.id
+                ORDER BY
+                  e2.last_watched_at DESC,
+                  e2.season_number DESC,
+                  e2.episode_number DESC
+                LIMIT
+                  1
               )
-            ELSE s.year::text
+              ELSE s.year::text
-          END,
+            END,
-          'url', s.slug
+            'url',
-        ),
+            s.slug
-        'type', 'tv'
+          ),
+          'type',
+          'tv'
+        )
+        ORDER BY
+          s.year ASC
       )
-      ORDER BY s.year ASC
+    FROM
-    )
+      shows_artists sa
-    FROM shows_artists sa
+      LEFT JOIN shows s ON sa.shows_id = s.id
-    LEFT JOIN shows s ON sa.shows_id = s.id
+      LEFT JOIN directus_files df_show ON s.art = df_show.id
-    LEFT JOIN directus_files df_show ON s.art = df_show.id
+    WHERE
-    WHERE sa.artists_id = ar.id
+      sa.artists_id = ar.id
       AND EXISTS (
-        SELECT 1
+        SELECT
-        FROM episodes e
+          1
-        WHERE e.show = s.id
+        FROM
+          episodes e
+        WHERE
+          e.show = s.id
           AND e.last_watched_at IS NOT NULL
       )
   ) AS shows,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'name', related_ar.name_string,
+        json_build_object(
-        'url', related_ar.slug,
+          'name',
-        'country', related_ar.country,
+          related_ar.name_string,
-        'total_plays', to_char(related_ar.total_plays, 'FM999,999,999,999'),
+          'url',
-        'image', CONCAT(globals.cdn_url, '/', df_related.filename_disk),
+          related_ar.slug,
-        'grid', json_build_object(
+          'country',
-          'title', related_ar.name_string,
+          related_ar.country,
-          'image', CONCAT(globals.cdn_url, '/', df_related.filename_disk),
+          'total_plays',
-          'alt', CASE WHEN related_ar.total_plays > 0 THEN CONCAT(to_char(related_ar.total_plays, 'FM999,999,999,999'), ' plays of ', related_ar.name_string) ELSE CONCAT('Artwork of ', related_ar.name_string) END,
+          to_char(related_ar.total_plays, 'FM999,999,999,999'),
-          'subtext', CASE WHEN related_ar.total_plays > 0 THEN CONCAT(to_char(related_ar.total_plays, 'FM999,999,999,999'), ' plays') ELSE NULL END,
+          'image',
-          'url', related_ar.slug
+          CONCAT(globals.cdn_url, '/', df_related.filename_disk),
-        ),
+          'grid',
-        'type', 'music'
+          json_build_object(
+            'title',
+            related_ar.name_string,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_related.filename_disk),
+            'alt',
+            CASE
+              WHEN related_ar.total_plays > 0 THEN CONCAT(
+                to_char(related_ar.total_plays, 'FM999,999,999,999'),
+                ' plays of ',
+                related_ar.name_string
+              )
+              ELSE CONCAT('Artwork of ', related_ar.name_string)
+            END,
+            'subtext',
+            CASE
+              WHEN related_ar.total_plays > 0 THEN CONCAT(
+                to_char(related_ar.total_plays, 'FM999,999,999,999'),
+                ' plays'
+              )
+              ELSE NULL
+            END,
+            'url',
+            related_ar.slug
+          ),
+          'type',
+          'music'
+        )
+        ORDER BY
+          related_ar.total_plays DESC
       )
-      ORDER BY related_ar.total_plays DESC
+    FROM
-    )
+      related_artists ra
-    FROM related_artists ra
+      LEFT JOIN artists related_ar ON ra.related_artists_id = related_ar.id
-    LEFT JOIN artists related_ar ON ra.related_artists_id = related_ar.id
+      LEFT JOIN directus_files df_related ON related_ar.art = df_related.id
-    LEFT JOIN directus_files df_related ON related_ar.art = df_related.id
+    WHERE
-    WHERE ra.artists_id = ar.id
+      ra.artists_id = ar.id
   ) AS related_artists,
   json_build_object(
-    'title', CONCAT('Artist • ', ar.name_string, ' • ', globals.site_name),
+    'title',
-    'description', LEFT(
+    CONCAT(
+      'Artist • ',
+      ar.name_string,
+      ' • ',
+      globals.site_name
+    ),
+    'description',
+    LEFT(
       regexp_replace(
         regexp_replace(
           regexp_replace(ar.description, E'[*_`~#>-]', '', 'g'),
-          E'\\[(.*?)\\]\\((.*?)\\)', E'\\1', 'g'
+          E'\\[(.*?)\\]\\((.*?)\\)',
+          E'\\1',
+          'g'
         ),
-        E'!\\[(.*?)\\]\\((.*?)\\)', '', 'g'
+        E'!\\[(.*?)\\]\\((.*?)\\)',
+        '',
+        'g'
       ),
       250
     ),
-    'open_graph_image', CASE
+    'open_graph_image',
-      WHEN df.filename_disk IS NOT NULL AND df.filename_disk != '' AND df.filename_disk != '/' THEN CONCAT('/', df.filename_disk)
+    CASE
+      WHEN df.filename_disk IS NOT NULL
+      AND df.filename_disk != ''
+      AND df.filename_disk != '/' THEN CONCAT('/', df.filename_disk)
       ELSE NULL
     END,
-    'url', CONCAT(globals.url, ar.slug),
+    'url',
-    'type', 'artist'
+    CONCAT(globals.url, ar.slug),
+    'type',
+    'artist'
   ) AS metadata
-FROM artists ar
+FROM
-LEFT JOIN directus_files df ON ar.art = df.id
+  artists ar
-LEFT JOIN genres g ON ar.genres = g.id
+  LEFT JOIN directus_files df ON ar.art = df.id
-CROSS JOIN optimized_globals globals
+  LEFT JOIN genres g ON ar.genres = g.id
-GROUP BY ar.id, df.filename_disk, g.name, g.slug, g.emoji, globals.cdn_url, globals.site_name, globals.url;
+  CROSS JOIN optimized_globals globals
+GROUP BY
+  ar.id,
+  df.filename_disk,
+  g.name,
+  g.slug,
+  g.emoji,
+  globals.cdn_url,
+  globals.site_name,
+  globals.url;

queries/views/media/music/concerts.sql

@@ -2,12 +2,22 @@ CREATE OR REPLACE VIEW optimized_concerts AS
 SELECT
   c.id,
   c.date,
-  CASE WHEN c.artist IS NOT NULL THEN
+  CASE
-    json_build_object('name', a.name_string, 'url', a.slug)
+    WHEN c.artist IS NOT NULL THEN json_build_object('name', a.name_string, 'url', a.slug)
-  ELSE
+    ELSE json_build_object('name', c.artist_name_string, 'url', NULL)
-    json_build_object('name', c.artist_name_string, 'url', NULL)
   END AS artist,
-  json_build_object('name', v.name, 'name_short', trim(split_part(v.name, ',', 1)), 'latitude', v.latitude, 'longitude', v.longitude, 'notes', v.notes) AS venue,
+  json_build_object(
+    'name',
+    v.name,
+    'name_short',
+    trim(split_part(v.name, ',', 1)),
+    'latitude',
+    v.latitude,
+    'longitude',
+    v.longitude,
+    'notes',
+    v.notes
+  ) AS venue,
   c.notes AS concert_notes
 FROM
   concerts c

queries/views/media/music/genres.sql

@@ -8,131 +8,216 @@ SELECT
   g.wiki_link,
   g.slug AS url,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'name', a.name_string,
+        json_build_object(
-        'url', a.slug,
+          'name',
-        'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          a.name_string,
-        'total_plays', to_char(a.total_plays, 'FM999,999,999,999'),
+          'url',
-        'grid', json_build_object(
+          a.slug,
-          'title', a.name_string,
+          'image',
-          'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
-          'alt', CASE
+          'total_plays',
-            WHEN a.total_plays > 0 THEN CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays of ', a.name_string)
+          to_char(a.total_plays, 'FM999,999,999,999'),
-            ELSE CONCAT('Artwork of ', a.name_string)
+          'grid',
-          END,
+          json_build_object(
-          'subtext', CASE
+            'title',
-            WHEN a.total_plays > 0 THEN CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays')
+            a.name_string,
-            ELSE NULL
+            'image',
-          END,
+            CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
-          'url', a.slug
+            'alt',
-        ),
+            CASE
-        'type', 'music'
+              WHEN a.total_plays > 0 THEN CONCAT(
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays of ',
+                a.name_string
+              )
+              ELSE CONCAT('Artwork of ', a.name_string)
+            END,
+            'subtext',
+            CASE
+              WHEN a.total_plays > 0 THEN CONCAT(
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays'
+              )
+              ELSE NULL
+            END,
+            'url',
+            a.slug
+          ),
+          'type',
+          'music'
+        )
+        ORDER BY
+          a.total_plays DESC
       )
-      ORDER BY a.total_plays DESC
+    FROM
-    )
+      artists a
-    FROM artists a
+      LEFT JOIN directus_files df_artist ON a.art = df_artist.id
-    LEFT JOIN directus_files df_artist ON a.art = df_artist.id
+    WHERE
-    WHERE a.genres = g.id
+      a.genres = g.id
   ) AS artists,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', b.title,
+        json_build_object(
-        'author', b.author,
+          'title',
-        'url', b.slug,
+          b.title,
-        'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          'author',
-        'grid', json_build_object(
+          b.author,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          b.slug,
-          'alt', CONCAT('Cover for ', b.title, ' by ', b.author),
+          'image',
-          'subtext', CASE WHEN b.star_rating IS NOT NULL THEN b.star_rating ELSE NULL END,
+          CONCAT(globals.cdn_url, '/', df_book.filename_disk),
-          'url', b.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'books'
+            'title',
+            NULL,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+            'alt',
+            CONCAT('Cover for ', b.title, ' by ', b.author),
+            'subtext',
+            CASE
+              WHEN b.star_rating IS NOT NULL THEN b.star_rating
+              ELSE NULL
+            END,
+            'url',
+            b.slug
+          ),
+          'type',
+          'books'
+        )
+        ORDER BY
+          b.title ASC
       )
-      ORDER BY b.title ASC
+    FROM
-    )
+      books b
-    FROM books b
+      JOIN genres_books gb ON gb.books_id = b.id
-    JOIN genres_books gb ON gb.books_id = b.id
+      LEFT JOIN directus_files df_book ON b.art = df_book.id
-    LEFT JOIN directus_files df_book ON b.art = df_book.id
+    WHERE
-    WHERE gb.genres_id = g.id
+      gb.genres_id = g.id
       AND LOWER(b.read_status) = 'finished'
   ) AS books,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', m.title,
+        json_build_object(
-        'year', m.year,
+          'title',
-        'url', m.slug,
+          m.title,
-        'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          'year',
-        'grid', json_build_object(
+          m.year,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          m.slug,
-          'alt', CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+          'image',
-          'subtext', CASE WHEN m.star_rating IS NOT NULL THEN m.star_rating::text ELSE m.year::text END,
+          CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
-          'url', m.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'movies'
+            'title',
+            NULL,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+            'alt',
+            CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+            'subtext',
+            CASE
+              WHEN m.star_rating IS NOT NULL THEN m.star_rating::text
+              ELSE m.year::text
+            END,
+            'url',
+            m.slug
+          ),
+          'type',
+          'movies'
+        )
+        ORDER BY
+          m.year ASC
       )
-      ORDER BY m.year ASC
+    FROM
-    )
+      movies m
-    FROM movies m
+      JOIN genres_movies gm ON gm.movies_id = m.id
-    JOIN genres_movies gm ON gm.movies_id = m.id
+      LEFT JOIN directus_files df_movie ON m.art = df_movie.id
-    LEFT JOIN directus_files df_movie ON m.art = df_movie.id
+    WHERE
-    WHERE gm.genres_id = g.id
+      gm.genres_id = g.id
       AND m.last_watched IS NOT NULL
   ) AS movies,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', p.title,
+        json_build_object(
-        'date', p.date,
+          'title',
-        'url', p.slug,
+          p.title,
-        'grid', json_build_object(
+          'date',
-          'title', p.title,
+          p.date,
-          'image', CONCAT(globals.cdn_url, '/', df_post.filename_disk),
+          'url',
-          'alt', p.title,
+          p.slug,
-          'subtext', TO_CHAR(p.date, 'FMMonth DD, YYYY'),
+          'grid',
-          'url', p.slug
+          json_build_object(
-        ),
+            'title',
-        'type', 'posts'
+            p.title,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_post.filename_disk),
+            'alt',
+            p.title,
+            'subtext',
+            TO_CHAR(p.date, 'FMMonth DD, YYYY'),
+            'url',
+            p.slug
+          ),
+          'type',
+          'posts'
+        )
+        ORDER BY
+          p.date DESC
       )
-      ORDER BY p.date DESC
+    FROM
-    )
+      posts_genres pg
-    FROM posts_genres pg
+      LEFT JOIN posts p ON pg.posts_id = p.id
-    LEFT JOIN posts p ON pg.posts_id = p.id
+      LEFT JOIN directus_files df_post ON p.image = df_post.id
-    LEFT JOIN directus_files df_post ON p.image = df_post.id
+    WHERE
-    WHERE pg.genres_id = g.id
+      pg.genres_id = g.id
   ) AS posts,
   json_build_object(
-    'title', CONCAT('Genre • ', g.name, ' • ', globals.site_name),
+    'title',
-    'description', LEFT(
+    CONCAT('Genre • ', g.name, ' • ', globals.site_name),
+    'description',
+    LEFT(
       regexp_replace(
         regexp_replace(
-          regexp_replace(
+          regexp_replace(g.description, E'[*_`~#>-]', '', 'g'),
-            g.description,
+          E'\\[(.*?)\\]\\((.*?)\\)',
-            E'[*_`~#>-]', '', 'g'
+          E'\\1',
-          ),
+          'g'
-          E'\\[(.*?)\\]\\((.*?)\\)', E'\\1', 'g'
         ),
-        E'!\\[(.*?)\\]\\((.*?)\\)', '', 'g'
+        E'!\\[(.*?)\\]\\((.*?)\\)',
+        '',
+        'g'
       ),
       250
     ),
-    'open_graph_image', (
+    'open_graph_image',
-      SELECT CONCAT('/', df_artist.filename_disk)
+    (
-      FROM artists a
+      SELECT
-      LEFT JOIN directus_files df_artist ON a.art = df_artist.id
+        CONCAT('/', df_artist.filename_disk)
-      WHERE a.genres = g.id
+      FROM
+        artists a
+        LEFT JOIN directus_files df_artist ON a.art = df_artist.id
+      WHERE
+        a.genres = g.id
         AND df_artist.filename_disk IS NOT NULL
         AND df_artist.filename_disk != ''
-      ORDER BY a.total_plays DESC
+      ORDER BY
-      LIMIT 1
+        a.total_plays DESC
+      LIMIT
+        1
     ),
-    'url', CONCAT(globals.url, g.slug),
+    'url',
-    'type', 'genre'
+    CONCAT(globals.url, g.slug),
+    'type',
+    'genre'
   ) AS metadata
-FROM genres g
+FROM
-CROSS JOIN optimized_globals globals
+  genres g
-ORDER BY g.id ASC;
+  CROSS JOIN optimized_globals globals
+ORDER BY
+  g.id ASC;

queries/views/media/music/latest_listen.sql

@@ -9,11 +9,9 @@ SELECT
   NULL::FLOAT AS progress_ticks
 FROM
   listens l
-JOIN
+  JOIN artists a ON l.artist_name = a.name_string
-  artists a
+  LEFT JOIN genres g ON a.genres = g.id
-  ON l.artist_name = a.name_string
+ORDER BY
-LEFT JOIN
+  l.listened_at DESC
-  genres g
+LIMIT
-  ON a.genres = g.id
+  1;
-ORDER BY l.listened_at DESC
-LIMIT 1;

queries/views/media/music/listens.sql

@@ -1,6 +1,12 @@
 CREATE OR REPLACE VIEW optimized_listens AS
-SELECT DISTINCT ON (l.id, l.listened_at, l.track_name, l.artist_name, l.album_name)
+SELECT DISTINCT
-  l.id,
+  ON (
+    l.id,
+    l.listened_at,
+    l.track_name,
+    l.artist_name,
+    l.album_name
+  ) l.id,
   l.listened_at,
   l.track_name,
   l.artist_name,

queries/views/media/music/month/albums.sql

@@ -6,16 +6,23 @@ SELECT
   ol.album_art,
   ol.artist_url,
   json_build_object(
-    'title', ol.album_name,
+    'title',
-    'image', ol.album_art,
+    ol.album_name,
-    'url', ol.artist_url,
+    'image',
-    'alt', CONCAT(ol.album_name, ' by ', ol.artist_name),
+    ol.album_art,
-    'subtext', ol.artist_name
+    'url',
+    ol.artist_url,
+    'alt',
+    CONCAT(ol.album_name, ' by ', ol.artist_name),
+    'subtext',
+    ol.artist_name
   ) AS grid,
   json_build_object(
     'open_graph_image',
     CASE
-      WHEN ol.opengraph_image_album IS NOT NULL AND ol.opengraph_image_album != '' AND ol.opengraph_image_album != '/' THEN ol.opengraph_image_album
+      WHEN ol.opengraph_image_album IS NOT NULL
+      AND ol.opengraph_image_album != ''
+      AND ol.opengraph_image_album != '/' THEN ol.opengraph_image_album
       ELSE NULL
     END
   ) AS metadata

queries/views/media/music/month/artists.sql

@@ -6,16 +6,23 @@ SELECT
   ol.artist_url,
   ARRAY_AGG(DISTINCT ol.genre_name) AS genres,
   json_build_object(
-    'title', ol.artist_name,
+    'title',
-    'image', ol.artist_art,
+    ol.artist_name,
-    'url', ol.artist_url,
+    'image',
-    'alt', CONCAT(COUNT(*), ' plays of ', ol.artist_name),
+    ol.artist_art,
-    'subtext', CONCAT(COUNT(*), ' plays')
+    'url',
+    ol.artist_url,
+    'alt',
+    CONCAT(COUNT(*), ' plays of ', ol.artist_name),
+    'subtext',
+    CONCAT(COUNT(*), ' plays')
   ) AS grid,
   json_build_object(
     'open_graph_image',
     CASE
-      WHEN ol.opengraph_image_artist IS NOT NULL AND ol.opengraph_image_artist != '' AND ol.opengraph_image_artist != '/' THEN ol.opengraph_image_artist
+      WHEN ol.opengraph_image_artist IS NOT NULL
+      AND ol.opengraph_image_artist != ''
+      AND ol.opengraph_image_artist != '/' THEN ol.opengraph_image_artist
       ELSE NULL
     END
   ) AS metadata

queries/views/media/music/month/genres.sql

@@ -3,7 +3,12 @@ SELECT
   ol.genre_name,
   ol.genre_url,
   COUNT(*) AS plays,
-  json_build_object('alt', ol.genre_name, 'subtext', CONCAT(COUNT(*), ' plays')) AS grid
+  json_build_object(
+    'alt',
+    ol.genre_name,
+    'subtext',
+    CONCAT(COUNT(*), ' plays')
+  ) AS grid
 FROM
   optimized_listens ol
 WHERE
@@ -13,4 +18,3 @@ GROUP BY
   ol.genre_url
 ORDER BY
   plays DESC;
-

queries/views/media/music/month/tracks.sql

@@ -1,25 +1,26 @@
 CREATE OR REPLACE VIEW month_tracks AS
-WITH track_stats AS (
+WITH
-  SELECT
+  track_stats AS (
-  ol.track_name,
+    SELECT
-  ol.artist_name,
+      ol.track_name,
-  ol.album_name,
+      ol.artist_name,
-  COUNT(*) AS plays,
+      ol.album_name,
-  MAX(ol.listened_at) AS last_listened,
+      COUNT(*) AS plays,
-  ol.album_art,
+      MAX(ol.listened_at) AS last_listened,
-  ol.artist_url,
+      ol.album_art,
-  MAX(COUNT(*)) OVER () AS most_played
+      ol.artist_url,
-  FROM
+      MAX(COUNT(*)) OVER () AS most_played
-  optimized_listens ol
+    FROM
-  WHERE
+      optimized_listens ol
-  TO_TIMESTAMP(ol.listened_at) >= NOW() - INTERVAL '30 days'
+    WHERE
-  GROUP BY
+      TO_TIMESTAMP(ol.listened_at) >= NOW() - INTERVAL '30 days'
-  ol.track_name,
+    GROUP BY
-  ol.artist_name,
+      ol.track_name,
-  ol.album_name,
+      ol.artist_name,
-  ol.album_art,
+      ol.album_name,
-  ol.artist_url
+      ol.album_art,
-)
+      ol.artist_url
+  )
 SELECT
   track_name,
   artist_name,
@@ -28,10 +29,24 @@ SELECT
   last_listened,
   album_art,
   artist_url,
-  json_build_object('title', track_name, 'artist', artist_name, 'url', artist_url, 'plays', plays, 'alt', CONCAT(track_name, ' by ', artist_name), 'subtext', CONCAT(album_name, ' (', plays, ' plays)'), 'percentage', ROUND((plays::decimal / most_played) * 100, 2)) AS chart
+  json_build_object(
+    'title',
+    track_name,
+    'artist',
+    artist_name,
+    'url',
+    artist_url,
+    'plays',
+    plays,
+    'alt',
+    CONCAT(track_name, ' by ', artist_name),
+    'subtext',
+    CONCAT(album_name, ' (', plays, ' plays)'),
+    'percentage',
+    ROUND((plays::decimal / most_played) * 100, 2)
+  ) AS chart
 FROM
   track_stats
 ORDER BY
   plays DESC,
   last_listened DESC;
-

queries/views/media/music/recent_tracks.sql

@@ -13,11 +13,23 @@ SELECT
   ol.album_art,
   ol.artist_url,
   ol.genre_url,
-  json_build_object('title', ol.track_name, 'subtext', ol.artist_name, 'alt', CONCAT(ol.track_name, ' by ', ol.artist_name), 'url', ol.artist_url, 'image', ol.album_art, 'played_at', ol.listened_at) AS chart
+  json_build_object(
+    'title',
+    ol.track_name,
+    'subtext',
+    ol.artist_name,
+    'alt',
+    CONCAT(ol.track_name, ' by ', ol.artist_name),
+    'url',
+    ol.artist_url,
+    'image',
+    ol.album_art,
+    'played_at',
+    ol.listened_at
+  ) AS chart
 FROM
   optimized_listens ol
 WHERE
   TO_TIMESTAMP(ol.listened_at) >= NOW() - INTERVAL '7 days'
 ORDER BY
   TO_TIMESTAMP(ol.listened_at) DESC;
-

queries/views/media/music/week/albums.sql

@@ -6,16 +6,23 @@ SELECT
   ol.album_art,
   ol.artist_url,
   json_build_object(
-    'title', ol.album_name,
+    'title',
-    'image', ol.album_art,
+    ol.album_name,
-    'url', ol.artist_url,
+    'image',
-    'alt', CONCAT(ol.album_name, ' by ', ol.artist_name),
+    ol.album_art,
-    'subtext', ol.artist_name
+    'url',
+    ol.artist_url,
+    'alt',
+    CONCAT(ol.album_name, ' by ', ol.artist_name),
+    'subtext',
+    ol.artist_name
   ) AS grid,
   json_build_object(
     'open_graph_image',
     CASE
-      WHEN ol.opengraph_image_album IS NOT NULL AND ol.opengraph_image_album != '' AND ol.opengraph_image_album != '/' THEN ol.opengraph_image_album
+      WHEN ol.opengraph_image_album IS NOT NULL
+      AND ol.opengraph_image_album != ''
+      AND ol.opengraph_image_album != '/' THEN ol.opengraph_image_album
       ELSE NULL
     END
   ) AS metadata

queries/views/media/music/week/artists.sql

@@ -6,16 +6,23 @@ SELECT
   ol.artist_url,
   ARRAY_AGG(DISTINCT ol.genre_name) AS genres,
   json_build_object(
-    'title', ol.artist_name,
+    'title',
-    'image', ol.artist_art,
+    ol.artist_name,
-    'url', ol.artist_url,
+    'image',
-    'alt', CONCAT(COUNT(*), ' plays of ', ol.artist_name),
+    ol.artist_art,
-    'subtext', CONCAT(COUNT(*), ' plays')
+    'url',
+    ol.artist_url,
+    'alt',
+    CONCAT(COUNT(*), ' plays of ', ol.artist_name),
+    'subtext',
+    CONCAT(COUNT(*), ' plays')
   ) AS grid,
   json_build_object(
     'open_graph_image',
     CASE
-      WHEN ol.opengraph_image_artist IS NOT NULL AND ol.opengraph_image_artist != '' AND ol.opengraph_image_artist != '/' THEN ol.opengraph_image_artist
+      WHEN ol.opengraph_image_artist IS NOT NULL
+      AND ol.opengraph_image_artist != ''
+      AND ol.opengraph_image_artist != '/' THEN ol.opengraph_image_artist
       ELSE NULL
     END
   ) AS metadata

queries/views/media/music/week/genres.sql

@@ -3,7 +3,12 @@ SELECT
   ol.genre_name,
   ol.genre_url,
   COUNT(*) AS plays,
-  json_build_object('alt', ol.genre_name, 'subtext', CONCAT(COUNT(*), ' plays')) AS grid
+  json_build_object(
+    'alt',
+    ol.genre_name,
+    'subtext',
+    CONCAT(COUNT(*), ' plays')
+  ) AS grid
 FROM
   optimized_listens ol
 WHERE
@@ -13,4 +18,3 @@ GROUP BY
   ol.genre_url
 ORDER BY
   plays DESC;
-

queries/views/media/music/week/summary.sql

@@ -1,34 +1,111 @@
 CREATE OR REPLACE VIEW optimized_week_music AS
-SELECT json_build_object(
+SELECT
-  'week_artists', (
+  json_build_object(
-    SELECT json_agg(a ORDER BY a.plays DESC)
+    'week_artists',
-    FROM (
+    (
-      SELECT * FROM week_artists ORDER BY plays DESC LIMIT 8
+      SELECT
-    ) a
+        json_agg(
-  ),
+          a
-  'week_albums', (
+          ORDER BY
-    SELECT json_agg(al ORDER BY al.plays DESC)
+            a.plays DESC
-    FROM (
+        )
-      SELECT * FROM week_albums ORDER BY plays DESC LIMIT 8
+      FROM
-    ) al
+        (
-  ),
+          SELECT
-  'week_genres', (
+            *
-    SELECT json_agg(g ORDER BY g.plays DESC)
+          FROM
-    FROM (
+            week_artists
-      SELECT * FROM week_genres ORDER BY plays DESC LIMIT 5
+          ORDER BY
-    ) g
+            plays DESC
-  ),
+          LIMIT
-  'recent_tracks', (
+            8
-    SELECT json_agg(r ORDER BY r.listened_at DESC)
+        ) a
-    FROM (
+    ),
-      SELECT * FROM recent_tracks ORDER BY listened_at DESC LIMIT 10
+    'week_albums',
-    ) r
+    (
-  ),
+      SELECT
-  'week_summary', (
+        json_agg(
-    SELECT json_build_object(
+          al
-      'total_tracks', (SELECT COUNT(*) FROM week_tracks),
+          ORDER BY
-      'total_artists', (SELECT COUNT(*) FROM week_artists),
+            al.plays DESC
-      'total_albums', (SELECT COUNT(*) FROM week_albums)
+        )
+      FROM
+        (
+          SELECT
+            *
+          FROM
+            week_albums
+          ORDER BY
+            plays DESC
+          LIMIT
+            8
+        ) al
+    ),
+    'week_genres',
+    (
+      SELECT
+        json_agg(
+          g
+          ORDER BY
+            g.plays DESC
+        )
+      FROM
+        (
+          SELECT
+            *
+          FROM
+            week_genres
+          ORDER BY
+            plays DESC
+          LIMIT
+            5
+        ) g
+    ),
+    'recent_tracks',
+    (
+      SELECT
+        json_agg(
+          r
+          ORDER BY
+            r.listened_at DESC
+        )
+      FROM
+        (
+          SELECT
+            *
+          FROM
+            recent_tracks
+          ORDER BY
+            listened_at DESC
+          LIMIT
+            10
+        ) r
+    ),
+    'week_summary',
+    (
+      SELECT
+        json_build_object(
+          'total_tracks',
+          (
+            SELECT
+              COUNT(*)
+            FROM
+              week_tracks
+          ),
+          'total_artists',
+          (
+            SELECT
+              COUNT(*)
+            FROM
+              week_artists
+          ),
+          'total_albums',
+          (
+            SELECT
+              COUNT(*)
+            FROM
+              week_albums
+          )
+        )
     )
-  )
+  ) AS week_music;
-) AS week_music;

queries/views/media/music/week/tracks.sql

@@ -1,26 +1,31 @@
 CREATE OR REPLACE VIEW week_tracks AS
-WITH track_stats AS (
+WITH
-  SELECT
+  track_stats AS (
-    ol.track_name,
+    SELECT
-    ol.artist_name,
+      ol.track_name,
-    ol.album_name,
+      ol.artist_name,
-    COUNT(*) AS plays,
+      ol.album_name,
-    MAX(ol.listened_at) AS last_listened,
+      COUNT(*) AS plays,
-    ol.album_art,
+      MAX(ol.listened_at) AS last_listened,
-    ol.artist_url,
+      ol.album_art,
-    MAX(COUNT(*)) OVER () AS most_played,
+      ol.artist_url,
-    RANK() OVER (ORDER BY COUNT(*) DESC, MAX(ol.listened_at) DESC) AS rank
+      MAX(COUNT(*)) OVER () AS most_played,
-  FROM
+      RANK() OVER (
-    optimized_listens ol
+        ORDER BY
-  WHERE
+          COUNT(*) DESC,
-    TO_TIMESTAMP(ol.listened_at) >= NOW() - INTERVAL '7 days'
+          MAX(ol.listened_at) DESC
-  GROUP BY
+      ) AS rank
-    ol.track_name,
+    FROM
-    ol.artist_name,
+      optimized_listens ol
-    ol.album_name,
+    WHERE
-    ol.album_art,
+      TO_TIMESTAMP(ol.listened_at) >= NOW() - INTERVAL '7 days'
-    ol.artist_url
+    GROUP BY
-)
+      ol.track_name,
+      ol.artist_name,
+      ol.album_name,
+      ol.album_art,
+      ol.artist_url
+  )
 SELECT
   track_name,
   artist_name,
@@ -30,14 +35,22 @@ SELECT
   album_art,
   artist_url,
   json_build_object(
-    'title', track_name,
+    'title',
-    'artist', artist_name,
+    track_name,
-    'url', artist_url,
+    'artist',
-    'plays', plays,
+    artist_name,
-    'alt', CONCAT(track_name, ' by ', artist_name),
+    'url',
-    'subtext', CONCAT(album_name, ' (', plays, ' plays)'),
+    artist_url,
-    'percentage', ROUND((plays::decimal / most_played) * 100, 2),
+    'plays',
-    'rank', rank
+    plays,
+    'alt',
+    CONCAT(track_name, ' by ', artist_name),
+    'subtext',
+    CONCAT(album_name, ' (', plays, ' plays)'),
+    'percentage',
+    ROUND((plays::decimal / most_played) * 100, 2),
+    'rank',
+    rank
   ) AS chart
 FROM
   track_stats

queries/views/media/recent_media.sql

@@ -1,248 +1,383 @@
 CREATE OR REPLACE VIEW optimized_recent_media AS
-WITH ordered_artists AS (
+WITH
-  SELECT
+  ordered_artists AS (
-    wa.artist_name,
+    SELECT
-    wa.artist_art,
+      wa.artist_name,
-    wa.artist_url,
+      wa.artist_art,
-    wa.plays,
+      wa.artist_url,
-    json_build_object(
+      wa.plays,
-      'title', wa.artist_name,
+      json_build_object(
-      'image', wa.artist_art,
+        'title',
-      'url', wa.artist_url,
+        wa.artist_name,
-      'alt', CONCAT(wa.plays, ' plays of ', wa.artist_name),
+        'image',
-      'subtext', CONCAT(wa.plays, ' plays')
+        wa.artist_art,
-    ) AS grid
+        'url',
-  FROM week_artists wa
+        wa.artist_url,
-  ORDER BY wa.plays DESC, wa.artist_name ASC
+        'alt',
-),
+        CONCAT(wa.plays, ' plays of ', wa.artist_name),
-ordered_albums AS (
+        'subtext',
-  SELECT
+        CONCAT(wa.plays, ' plays')
-    wa.album_name,
+      ) AS grid
-    wa.album_art,
+    FROM
-    wa.artist_name,
+      week_artists wa
-    wa.artist_url,
+    ORDER BY
-    wa.plays,
+      wa.plays DESC,
-    json_build_object(
+      wa.artist_name ASC
-      'title', wa.album_name,
-      'image', wa.album_art,
-      'url', wa.artist_url,
-      'alt', CONCAT(wa.album_name, ' by ', wa.artist_name, ' (', wa.plays, ' plays)'),
-      'subtext', wa.artist_name
-    ) AS grid
-  FROM week_albums wa
-  ORDER BY wa.plays DESC, wa.album_name ASC
-),
-recent_music AS (
-  SELECT * FROM (
-    (
-      SELECT
-        artist_name AS title,
-        artist_art AS image,
-        artist_url AS url,
-        'music' AS type,
-        1 AS rank,
-        grid
-      FROM ordered_artists
-      LIMIT 1
-    )
-    UNION ALL
-    (
-      SELECT
-        album_name AS title,
-        album_art AS image,
-        artist_url AS url,
-        'music' AS type,
-        2 AS rank,
-        grid
-      FROM ordered_albums
-      LIMIT 1
-    )
-    UNION ALL
-    (
-      SELECT
-        artist_name AS title,
-        artist_art AS image,
-        artist_url AS url,
-        'music' AS type,
-        3 AS rank,
-        grid
-      FROM ordered_artists
-      OFFSET 1 LIMIT 1
-    )
-    UNION ALL
-    (
-      SELECT
-        album_name AS title,
-        album_art AS image,
-        artist_url AS url,
-        'music' AS type,
-        4 AS rank,
-        grid
-      FROM ordered_albums
-      OFFSET 1 LIMIT 1
-    )
-  ) AS recent_music_subquery
-),
-recent_watched_read AS (
-  SELECT * FROM (
-    (
-      SELECT
-        om.title,
-        om.image,
-        om.url,
-        'tv' AS type,
-        1 AS rank,
-        json_build_object(
-          'title', NULL,
-          'url', om.url,
-          'image', om.image,
-          'backdrop', om.backdrop,
-          'alt', CONCAT('Poster from ', om.title, ' (', om.year, ')'),
-          'subtext', CASE WHEN om.rating IS NOT NULL THEN
-            om.rating::text
-          ELSE
-            om.year::text
-          END
-        ) AS grid
-      FROM optimized_movies om
-      WHERE om.last_watched IS NOT NULL
-      ORDER BY om.last_watched DESC, om.title ASC
-      LIMIT 1
-    )
-    UNION ALL
-    (
-      SELECT
-        os.title,
-        os.image,
-        os.url,
-        'tv' AS type,
-        2 AS rank,
-        json_build_object(
-          'title', NULL,
-          'image', os.image,
-          'url', os.url,
-          'alt', CONCAT('Poster from ', os.title),
-          'subtext', (
-            SELECT CONCAT('S', e.season_number, 'E', e.episode_number)
-            FROM episodes e
-            WHERE e.show = os.id
-            ORDER BY e.last_watched_at DESC, e.season_number DESC, e.episode_number DESC
-            LIMIT 1
-          )
-        ) AS grid
-      FROM optimized_shows os
-      WHERE os.last_watched_at IS NOT NULL
-      ORDER BY os.last_watched_at DESC, os.title ASC
-      LIMIT 1
-    )
-    UNION ALL
-    (
-      SELECT
-        ob.title,
-        ob.image,
-        ob.url,
-        'books' AS type,
-        3 AS rank,
-        json_build_object(
-          'title', NULL,
-          'image', ob.image,
-          'url', ob.url,
-          'alt', CONCAT('Book cover from ', ob.title, ' by ', ob.author),
-          'subtext', CASE WHEN ob.rating IS NOT NULL THEN
-            ob.rating
-          ELSE
-            NULL
-          END
-        ) AS grid
-      FROM optimized_books ob
-      WHERE ob.status = 'finished'
-      ORDER BY ob.date_finished DESC, ob.title ASC
-      LIMIT 1
-    )
-    UNION ALL
-    (
-      SELECT
-        om.title,
-        om.image,
-        om.url,
-        'tv' AS type,
-        4 AS rank,
-        json_build_object(
-          'title', NULL,
-          'url', om.url,
-          'image', om.image,
-          'backdrop', om.backdrop,
-          'alt', CONCAT('Poster from ', om.title, ' (', om.year, ')'),
-          'subtext', CASE WHEN om.rating IS NOT NULL THEN
-            om.rating::text
-          ELSE
-            om.year::text
-          END
-        ) AS grid
-      FROM optimized_movies om
-      WHERE om.last_watched IS NOT NULL
-      ORDER BY om.last_watched DESC, om.title ASC
-      OFFSET 1 LIMIT 1
-    )
-    UNION ALL
-    (
-      SELECT
-        os.title,
-        os.image,
-        os.url,
-        'tv' AS type,
-        5 AS rank,
-        json_build_object(
-          'title', NULL,
-          'image', os.image,
-          'url', os.url,
-          'alt', CONCAT('Poster from ', os.title),
-          'subtext', (
-            SELECT CONCAT('S', e.season_number, 'E', e.episode_number)
-            FROM episodes e
-            WHERE e.show = os.id
-            ORDER BY e.last_watched_at DESC, e.season_number DESC, e.episode_number DESC
-            LIMIT 1
-          )
-        ) AS grid
-      FROM optimized_shows os
-      WHERE os.last_watched_at IS NOT NULL
-      ORDER BY os.last_watched_at DESC, os.title ASC
-      OFFSET 1 LIMIT 1
-    )
-    UNION ALL
-    (
-      SELECT
-        ob.title,
-        ob.image,
-        ob.url,
-        'books' AS type,
-        6 AS rank,
-        json_build_object(
-          'title', NULL,
-          'image', ob.image,
-          'url', ob.url,
-          'alt', CONCAT('Book cover from ', ob.title, ' by ', ob.author),
-          'subtext', CASE WHEN ob.rating IS NOT NULL THEN
-            ob.rating
-          ELSE
-            NULL
-          END
-        ) AS grid
-      FROM optimized_books ob
-      WHERE ob.status = 'finished'
-      ORDER BY ob.date_finished DESC, ob.title ASC
-      OFFSET 1 LIMIT 1
-    )
-  ) AS recent_watched_read_subquery
-)
-SELECT json_build_object(
-  'recentMusic', (
-    SELECT json_agg(m.* ORDER BY m.rank)
-    FROM recent_music m
   ),
-  'recentWatchedRead', (
+  ordered_albums AS (
-    SELECT json_agg(w.* ORDER BY w.rank)
+    SELECT
-    FROM recent_watched_read w
+      wa.album_name,
+      wa.album_art,
+      wa.artist_name,
+      wa.artist_url,
+      wa.plays,
+      json_build_object(
+        'title',
+        wa.album_name,
+        'image',
+        wa.album_art,
+        'url',
+        wa.artist_url,
+        'alt',
+        CONCAT(
+          wa.album_name,
+          ' by ',
+          wa.artist_name,
+          ' (',
+          wa.plays,
+          ' plays)'
+        ),
+        'subtext',
+        wa.artist_name
+      ) AS grid
+    FROM
+      week_albums wa
+    ORDER BY
+      wa.plays DESC,
+      wa.album_name ASC
+  ),
+  recent_music AS (
+    SELECT
+      *
+    FROM
+      (
+        (
+          SELECT
+            artist_name AS title,
+            artist_art AS image,
+            artist_url AS url,
+            'music' AS type,
+            1 AS rank,
+            grid
+          FROM
+            ordered_artists
+          LIMIT
+            1
+        )
+        UNION ALL
+        (
+          SELECT
+            album_name AS title,
+            album_art AS image,
+            artist_url AS url,
+            'music' AS type,
+            2 AS rank,
+            grid
+          FROM
+            ordered_albums
+          LIMIT
+            1
+        )
+        UNION ALL
+        (
+          SELECT
+            artist_name AS title,
+            artist_art AS image,
+            artist_url AS url,
+            'music' AS type,
+            3 AS rank,
+            grid
+          FROM
+            ordered_artists
+          OFFSET
+            1
+          LIMIT
+            1
+        )
+        UNION ALL
+        (
+          SELECT
+            album_name AS title,
+            album_art AS image,
+            artist_url AS url,
+            'music' AS type,
+            4 AS rank,
+            grid
+          FROM
+            ordered_albums
+          OFFSET
+            1
+          LIMIT
+            1
+        )
+      ) AS recent_music_subquery
+  ),
+  recent_watched_read AS (
+    SELECT
+      *
+    FROM
+      (
+        (
+          SELECT
+            om.title,
+            om.image,
+            om.url,
+            'tv' AS type,
+            1 AS rank,
+            json_build_object(
+              'title',
+              NULL,
+              'url',
+              om.url,
+              'image',
+              om.image,
+              'backdrop',
+              om.backdrop,
+              'alt',
+              CONCAT('Poster from ', om.title, ' (', om.year, ')'),
+              'subtext',
+              CASE
+                WHEN om.rating IS NOT NULL THEN om.rating::text
+                ELSE om.year::text
+              END
+            ) AS grid
+          FROM
+            optimized_movies om
+          WHERE
+            om.last_watched IS NOT NULL
+          ORDER BY
+            om.last_watched DESC,
+            om.title ASC
+          LIMIT
+            1
+        )
+        UNION ALL
+        (
+          SELECT
+            os.title,
+            os.image,
+            os.url,
+            'tv' AS type,
+            2 AS rank,
+            json_build_object(
+              'title',
+              NULL,
+              'image',
+              os.image,
+              'url',
+              os.url,
+              'alt',
+              CONCAT('Poster from ', os.title),
+              'subtext',
+              (
+                SELECT
+                  CONCAT('S', e.season_number, 'E', e.episode_number)
+                FROM
+                  episodes e
+                WHERE
+                  e.show = os.id
+                ORDER BY
+                  e.last_watched_at DESC,
+                  e.season_number DESC,
+                  e.episode_number DESC
+                LIMIT
+                  1
+              )
+            ) AS grid
+          FROM
+            optimized_shows os
+          WHERE
+            os.last_watched_at IS NOT NULL
+          ORDER BY
+            os.last_watched_at DESC,
+            os.title ASC
+          LIMIT
+            1
+        )
+        UNION ALL
+        (
+          SELECT
+            ob.title,
+            ob.image,
+            ob.url,
+            'books' AS type,
+            3 AS rank,
+            json_build_object(
+              'title',
+              NULL,
+              'image',
+              ob.image,
+              'url',
+              ob.url,
+              'alt',
+              CONCAT('Book cover from ', ob.title, ' by ', ob.author),
+              'subtext',
+              CASE
+                WHEN ob.rating IS NOT NULL THEN ob.rating
+                ELSE NULL
+              END
+            ) AS grid
+          FROM
+            optimized_books ob
+          WHERE
+            ob.status = 'finished'
+          ORDER BY
+            ob.date_finished DESC,
+            ob.title ASC
+          LIMIT
+            1
+        )
+        UNION ALL
+        (
+          SELECT
+            om.title,
+            om.image,
+            om.url,
+            'tv' AS type,
+            4 AS rank,
+            json_build_object(
+              'title',
+              NULL,
+              'url',
+              om.url,
+              'image',
+              om.image,
+              'backdrop',
+              om.backdrop,
+              'alt',
+              CONCAT('Poster from ', om.title, ' (', om.year, ')'),
+              'subtext',
+              CASE
+                WHEN om.rating IS NOT NULL THEN om.rating::text
+                ELSE om.year::text
+              END
+            ) AS grid
+          FROM
+            optimized_movies om
+          WHERE
+            om.last_watched IS NOT NULL
+          ORDER BY
+            om.last_watched DESC,
+            om.title ASC
+          OFFSET
+            1
+          LIMIT
+            1
+        )
+        UNION ALL
+        (
+          SELECT
+            os.title,
+            os.image,
+            os.url,
+            'tv' AS type,
+            5 AS rank,
+            json_build_object(
+              'title',
+              NULL,
+              'image',
+              os.image,
+              'url',
+              os.url,
+              'alt',
+              CONCAT('Poster from ', os.title),
+              'subtext',
+              (
+                SELECT
+                  CONCAT('S', e.season_number, 'E', e.episode_number)
+                FROM
+                  episodes e
+                WHERE
+                  e.show = os.id
+                ORDER BY
+                  e.last_watched_at DESC,
+                  e.season_number DESC,
+                  e.episode_number DESC
+                LIMIT
+                  1
+              )
+            ) AS grid
+          FROM
+            optimized_shows os
+          WHERE
+            os.last_watched_at IS NOT NULL
+          ORDER BY
+            os.last_watched_at DESC,
+            os.title ASC
+          OFFSET
+            1
+          LIMIT
+            1
+        )
+        UNION ALL
+        (
+          SELECT
+            ob.title,
+            ob.image,
+            ob.url,
+            'books' AS type,
+            6 AS rank,
+            json_build_object(
+              'title',
+              NULL,
+              'image',
+              ob.image,
+              'url',
+              ob.url,
+              'alt',
+              CONCAT('Book cover from ', ob.title, ' by ', ob.author),
+              'subtext',
+              CASE
+                WHEN ob.rating IS NOT NULL THEN ob.rating
+                ELSE NULL
+              END
+            ) AS grid
+          FROM
+            optimized_books ob
+          WHERE
+            ob.status = 'finished'
+          ORDER BY
+            ob.date_finished DESC,
+            ob.title ASC
+          OFFSET
+            1
+          LIMIT
+            1
+        )
+      ) AS recent_watched_read_subquery
   )
-) AS recent_activity;
+SELECT
+  json_build_object(
+    'recentMusic',
+    (
+      SELECT
+        json_agg(
+          m.*
+          ORDER BY
+            m.rank
+        )
+      FROM
+        recent_music m
+    ),
+    'recentWatchedRead',
+    (
+      SELECT
+        json_agg(
+          w.*
+          ORDER BY
+            w.rank
+        )
+      FROM
+        recent_watched_read w
+    )
+  ) AS recent_activity;

queries/views/media/shows/last_watched_episodes.sql

@@ -1,10 +1,14 @@
 CREATE OR REPLACE VIEW optimized_last_watched_episodes AS
-SELECT DISTINCT ON (e.show)
+SELECT DISTINCT
-  e.show AS show_id,
+  ON (e.show) e.show AS show_id,
   e.season_number,
   e.episode_number,
   e.last_watched_at,
   CONCAT('S', e.season_number, 'E', e.episode_number) AS last_watched_episode
-FROM episodes e
+FROM
-WHERE e.last_watched_at IS NOT NULL
+  episodes e
-ORDER BY e.show, e.last_watched_at DESC;
+WHERE
+  e.last_watched_at IS NOT NULL
+ORDER BY
+  e.show,
+  e.last_watched_at DESC;

queries/views/media/shows/scheduled_episodes.sql

@@ -6,21 +6,38 @@ SELECT
   se.status,
   se.air_date,
   (
-    SELECT CONCAT('S', se2.season_number, 'E', se2.episode_number)
+    SELECT
-    FROM scheduled_episodes se2
+      CONCAT('S', se2.season_number, 'E', se2.episode_number)
-    WHERE se2.show_id = se.show_id
+    FROM
+      scheduled_episodes se2
+    WHERE
+      se2.show_id = se.show_id
       AND se2.status IN ('upcoming', 'aired')
-    ORDER BY se2.air_date ASC
+    ORDER BY
-    LIMIT 1
+      se2.air_date ASC
+    LIMIT
+      1
   ) AS next_scheduled_episode,
   (
-    SELECT se2.air_date
+    SELECT
-    FROM scheduled_episodes se2
+      se2.air_date
-    WHERE se2.show_id = se.show_id
+    FROM
+      scheduled_episodes se2
+    WHERE
+      se2.show_id = se.show_id
       AND se2.status IN ('upcoming', 'aired')
-    ORDER BY se2.air_date ASC
+    ORDER BY
-    LIMIT 1
+      se2.air_date ASC
+    LIMIT
+      1
   ) AS next_air_date
-FROM scheduled_episodes se
+FROM
-WHERE se.status IN ('upcoming', 'aired')
+  scheduled_episodes se
-GROUP BY se.show_id, se.season_number, se.episode_number, se.status, se.air_date;
+WHERE
+  se.status IN ('upcoming', 'aired')
+GROUP BY
+  se.show_id,
+  se.season_number,
+  se.episode_number,
+  se.status,
+  se.air_date;

queries/views/media/shows/scheduled_shows.sql

@@ -1,207 +1,354 @@
 CREATE OR REPLACE VIEW optimized_scheduled_shows AS
-SELECT json_build_object(
+SELECT
-  'watching', (
+  json_build_object(
-    SELECT json_agg(watching) FROM (
+    'watching',
+    (
       SELECT
-        s.id,
+        json_agg(watching)
-        s.tmdb_id,
+      FROM
-        s.title,
+        (
-        s.year,
+          SELECT
-        s.ongoing,
+            s.id,
-        s.slug AS url,
+            s.tmdb_id,
-        CONCAT(globals.cdn_url, '/', df_art.filename_disk) AS image,
+            s.title,
-        CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk) AS backdrop,
+            s.year,
-        json_build_object(
+            s.ongoing,
-          'title', s.title,
+            s.slug AS url,
-          'image', CONCAT(globals.cdn_url, '/', df_art.filename_disk),
+            CONCAT(globals.cdn_url, '/', df_art.filename_disk) AS image,
-          'backdrop', CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk),
+            CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk) AS backdrop,
-          'url', s.slug,
+            json_build_object(
-          'alt', CONCAT('Poster from ', s.title),
+              'title',
-          'subtext', COALESCE(
+              s.title,
-            (SELECT CONCAT(
+              'image',
-              'S', se.season_number, 'E', se.episode_number, ' • ',
+              CONCAT(globals.cdn_url, '/', df_art.filename_disk),
-              CASE
+              'backdrop',
-                WHEN EXTRACT(YEAR FROM se.air_date) < EXTRACT(YEAR FROM CURRENT_DATE)
+              CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk),
-                THEN TO_CHAR(se.air_date, 'FMMM/FMDD/YY')
+              'url',
-                ELSE TO_CHAR(se.air_date, 'FMMM/FMDD')
+              s.slug,
-              END
+              'alt',
-            )
+              CONCAT('Poster from ', s.title),
-            FROM scheduled_episodes se
+              'subtext',
-            WHERE se.show_id = s.id
+              COALESCE(
-              AND se.status IN ('upcoming', 'aired')
+                (
-              AND NOT EXISTS (
+                  SELECT
-                SELECT 1 FROM episodes e
+                    CONCAT(
-                WHERE e.show = s.id
+                      'S',
-                  AND e.season_number = se.season_number
+                      se.season_number,
-                  AND e.episode_number = se.episode_number
+                      'E',
+                      se.episode_number,
+                      ' • ',
+                      CASE
+                        WHEN EXTRACT(
+                          YEAR
+                          FROM
+                            se.air_date
+                        ) < EXTRACT(
+                          YEAR
+                          FROM
+                            CURRENT_DATE
+                        ) THEN TO_CHAR(se.air_date, 'FMMM/FMDD/YY')
+                        ELSE TO_CHAR(se.air_date, 'FMMM/FMDD')
+                      END
+                    )
+                  FROM
+                    scheduled_episodes se
+                  WHERE
+                    se.show_id = s.id
+                    AND se.status IN ('upcoming', 'aired')
+                    AND NOT EXISTS (
+                      SELECT
+                        1
+                      FROM
+                        episodes e
+                      WHERE
+                        e.show = s.id
+                        AND e.season_number = se.season_number
+                        AND e.episode_number = se.episode_number
+                    )
+                  ORDER BY
+                    se.season_number ASC,
+                    se.episode_number ASC
+                  LIMIT
+                    1
+                ),
+                (
+                  SELECT
+                    CONCAT(
+                      'S',
+                      e.season_number,
+                      'E',
+                      e.episode_number,
+                      ' • ',
+                      CASE
+                        WHEN EXTRACT(
+                          YEAR
+                          FROM
+                            e.last_watched_at
+                        ) < EXTRACT(
+                          YEAR
+                          FROM
+                            CURRENT_DATE
+                        ) THEN TO_CHAR(e.last_watched_at, 'FMMM/FMDD/YY')
+                        ELSE TO_CHAR(e.last_watched_at, 'FMMM/FMDD')
+                      END
+                    )
+                  FROM
+                    episodes e
+                  WHERE
+                    e.show = s.id
+                  ORDER BY
+                    e.last_watched_at DESC,
+                    e.season_number DESC,
+                    e.episode_number DESC
+                  LIMIT
+                    1
+                ),
+                s.year::text
               )
-            ORDER BY se.season_number ASC, se.episode_number ASC
+            ) AS grid,
-            LIMIT 1),
+            json_build_object(
-            (SELECT CONCAT(
+              'title',
-              'S', e.season_number, 'E', e.episode_number, ' • ',
+              CONCAT('Show • ', s.title, ' • ', globals.site_name),
-              CASE
+              'description',
-                WHEN EXTRACT(YEAR FROM e.last_watched_at) < EXTRACT(YEAR FROM CURRENT_DATE)
+              LEFT(
-                THEN TO_CHAR(e.last_watched_at, 'FMMM/FMDD/YY')
+                regexp_replace(
-                ELSE TO_CHAR(e.last_watched_at, 'FMMM/FMDD')
+                  regexp_replace(
-              END
+                    regexp_replace(s.description, E'[*_`~#>-]', '', 'g'),
-            )
+                    E'\\[(.*?)\\]\\((.*?)\\)',
-            FROM episodes e
+                    E'\\1',
-            WHERE e.show = s.id
+                    'g'
-            ORDER BY e.last_watched_at DESC, e.season_number DESC, e.episode_number DESC
+                  ),
-            LIMIT 1),
+                  E'!\\[(.*?)\\]\\((.*?)\\)',
-            s.year::text
+                  '',
-          )
+                  'g'
-        ) AS grid,
+                ),
-        json_build_object(
+                250
-          'title', CONCAT('Show • ', s.title, ' • ', globals.site_name),
-          'description', LEFT(
-            regexp_replace(
-              regexp_replace(
-                regexp_replace(s.description, E'[*_`~#>-]', '', 'g'),
-                E'\\[(.*?)\\]\\((.*?)\\)', E'\\1', 'g'
               ),
-              E'!\\[(.*?)\\]\\((.*?)\\)', '', 'g'
+              'open_graph_image',
-            ),
+              CASE
-            250
+                WHEN df_backdrop.filename_disk IS NOT NULL
-          ),
+                AND df_backdrop.filename_disk != ''
-          'open_graph_image', CASE
+                AND df_backdrop.filename_disk != '/' THEN CONCAT('/', df_backdrop.filename_disk)
-            WHEN df_backdrop.filename_disk IS NOT NULL AND df_backdrop.filename_disk != '' AND df_backdrop.filename_disk != '/' THEN CONCAT('/', df_backdrop.filename_disk)
+                ELSE NULL
-            ELSE NULL
+              END,
-          END,
+              'url',
-          'url', CONCAT(globals.url, s.slug),
+              CONCAT(globals.url, s.slug),
-          'type', 'scheduled_show'
+              'type',
-        ) AS metadata,
+              'scheduled_show'
-        CASE
+            ) AS metadata,
-          WHEN (
+            CASE
-            SELECT se.air_date
+              WHEN (
-            FROM scheduled_episodes se
+                SELECT
-            WHERE se.show_id = s.id
+                  se.air_date
-              AND se.status IN ('upcoming', 'aired')
+                FROM
-              AND NOT EXISTS (
+                  scheduled_episodes se
-                SELECT 1 FROM episodes e
+                WHERE
-                WHERE e.show = s.id
+                  se.show_id = s.id
-                  AND e.season_number = se.season_number
+                  AND se.status IN ('upcoming', 'aired')
-                  AND e.episode_number = se.episode_number
+                  AND NOT EXISTS (
+                    SELECT
+                      1
+                    FROM
+                      episodes e
+                    WHERE
+                      e.show = s.id
+                      AND e.season_number = se.season_number
+                      AND e.episode_number = se.episode_number
+                  )
+                ORDER BY
+                  se.season_number ASC,
+                  se.episode_number ASC
+                LIMIT
+                  1
+              ) >= NOW() THEN (
+                SELECT
+                  se.air_date::timestamp
+                FROM
+                  scheduled_episodes se
+                WHERE
+                  se.show_id = s.id
+                  AND se.status IN ('upcoming', 'aired')
+                  AND NOT EXISTS (
+                    SELECT
+                      1
+                    FROM
+                      episodes e
+                    WHERE
+                      e.show = s.id
+                      AND e.season_number = se.season_number
+                      AND e.episode_number = se.episode_number
+                  )
+                ORDER BY
+                  se.season_number ASC,
+                  se.episode_number ASC
+                LIMIT
+                  1
               )
-            ORDER BY se.season_number ASC, se.episode_number ASC
+              ELSE (
-            LIMIT 1
+                SELECT
-          ) >= NOW()
+                  MIN(e.last_watched_at)::timestamp
-          THEN (
+                FROM
-            SELECT se.air_date::timestamp
+                  episodes e
-            FROM scheduled_episodes se
+                WHERE
-            WHERE se.show_id = s.id
+                  e.show = s.id
-              AND se.status IN ('upcoming', 'aired')
-              AND NOT EXISTS (
-                SELECT 1 FROM episodes e
-                WHERE e.show = s.id
-                  AND e.season_number = se.season_number
-                  AND e.episode_number = se.episode_number
               )
-            ORDER BY se.season_number ASC, se.episode_number ASC
+            END AS sort_date
-            LIMIT 1
+          FROM
-          )
+            shows s
-          ELSE (
+            LEFT JOIN directus_files df_art ON s.art = df_art.id
-            SELECT MIN(e.last_watched_at)::timestamp
+            LEFT JOIN directus_files df_backdrop ON s.backdrop = df_backdrop.id
-            FROM episodes e
+            CROSS JOIN optimized_globals globals
-            WHERE e.show = s.id
+          WHERE
-          )
+            s.ongoing = true
-        END AS sort_date
+            AND EXISTS (
-      FROM shows s
+              SELECT
-      LEFT JOIN directus_files df_art ON s.art = df_art.id
+                1
-      LEFT JOIN directus_files df_backdrop ON s.backdrop = df_backdrop.id
+              FROM
-      CROSS JOIN optimized_globals globals
+                scheduled_episodes se
-      WHERE s.ongoing = true
+              WHERE
-        AND EXISTS (
+                se.show_id = s.id
-          SELECT 1
-          FROM scheduled_episodes se
-          WHERE se.show_id = s.id
-            AND se.status IN ('upcoming', 'aired')
-        )
-        AND EXISTS (
-          SELECT 1
-          FROM episodes e
-          WHERE e.show = s.id
-        )
-      ORDER BY sort_date ASC NULLS LAST, s.title ASC NULLS LAST
-    ) watching
-  ),
-  'unstarted', (
-    SELECT json_agg(unstarted) FROM (
-      SELECT
-        s.id,
-        s.tmdb_id,
-        s.title,
-        s.year,
-        s.ongoing,
-        s.slug AS url,
-        CONCAT(globals.cdn_url, '/', df_art.filename_disk) AS image,
-        CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk) AS backdrop,
-        json_build_object(
-          'title', s.title,
-          'image', CONCAT(globals.cdn_url, '/', df_art.filename_disk),
-          'backdrop', CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk),
-          'url', s.slug,
-          'alt', CONCAT('Poster from ', s.title),
-          'subtext', COALESCE(
-            (
-              SELECT CONCAT(
-                'S', se.season_number, 'E', se.episode_number, ' • ',
-                CASE
-                  WHEN EXTRACT(YEAR FROM se.air_date) < EXTRACT(YEAR FROM CURRENT_DATE)
-                  THEN TO_CHAR(se.air_date, 'FMMM/FMDD/YY')
-                  ELSE TO_CHAR(se.air_date, 'FMMM/FMDD')
-                END
-              )
-              FROM scheduled_episodes se
-              WHERE se.show_id = s.id
                 AND se.status IN ('upcoming', 'aired')
-              ORDER BY se.season_number ASC, se.episode_number ASC
+            )
-              LIMIT 1
+            AND EXISTS (
-            ),
+              SELECT
-            s.year::text
+                1
-          )
+              FROM
-        ) AS grid,
+                episodes e
-        json_build_object(
+              WHERE
-          'title', CONCAT('Show • ', s.title, ' • ', globals.site_name),
+                e.show = s.id
-          'description', LEFT(
+            )
-            regexp_replace(
+          ORDER BY
-              regexp_replace(
+            sort_date ASC NULLS LAST,
-                regexp_replace(s.description, E'[*_`~#>-]', '', 'g'),
+            s.title ASC NULLS LAST
-                E'\\[(.*?)\\]\\((.*?)\\)', E'\\1', 'g'
+        ) watching
+    ),
+    'unstarted',
+    (
+      SELECT
+        json_agg(unstarted)
+      FROM
+        (
+          SELECT
+            s.id,
+            s.tmdb_id,
+            s.title,
+            s.year,
+            s.ongoing,
+            s.slug AS url,
+            CONCAT(globals.cdn_url, '/', df_art.filename_disk) AS image,
+            CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk) AS backdrop,
+            json_build_object(
+              'title',
+              s.title,
+              'image',
+              CONCAT(globals.cdn_url, '/', df_art.filename_disk),
+              'backdrop',
+              CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk),
+              'url',
+              s.slug,
+              'alt',
+              CONCAT('Poster from ', s.title),
+              'subtext',
+              COALESCE(
+                (
+                  SELECT
+                    CONCAT(
+                      'S',
+                      se.season_number,
+                      'E',
+                      se.episode_number,
+                      ' • ',
+                      CASE
+                        WHEN EXTRACT(
+                          YEAR
+                          FROM
+                            se.air_date
+                        ) < EXTRACT(
+                          YEAR
+                          FROM
+                            CURRENT_DATE
+                        ) THEN TO_CHAR(se.air_date, 'FMMM/FMDD/YY')
+                        ELSE TO_CHAR(se.air_date, 'FMMM/FMDD')
+                      END
+                    )
+                  FROM
+                    scheduled_episodes se
+                  WHERE
+                    se.show_id = s.id
+                    AND se.status IN ('upcoming', 'aired')
+                  ORDER BY
+                    se.season_number ASC,
+                    se.episode_number ASC
+                  LIMIT
+                    1
+                ),
+                s.year::text
+              )
+            ) AS grid,
+            json_build_object(
+              'title',
+              CONCAT('Show • ', s.title, ' • ', globals.site_name),
+              'description',
+              LEFT(
+                regexp_replace(
+                  regexp_replace(
+                    regexp_replace(s.description, E'[*_`~#>-]', '', 'g'),
+                    E'\\[(.*?)\\]\\((.*?)\\)',
+                    E'\\1',
+                    'g'
+                  ),
+                  E'!\\[(.*?)\\]\\((.*?)\\)',
+                  '',
+                  'g'
+                ),
+                250
               ),
-              E'!\\[(.*?)\\]\\((.*?)\\)', '', 'g'
+              'open_graph_image',
-            ),
+              CASE
-            250
+                WHEN df_backdrop.filename_disk IS NOT NULL
-          ),
+                AND df_backdrop.filename_disk != ''
-          'open_graph_image', CASE
+                AND df_backdrop.filename_disk != '/' THEN CONCAT('/', df_backdrop.filename_disk)
-            WHEN df_backdrop.filename_disk IS NOT NULL AND df_backdrop.filename_disk != '' AND df_backdrop.filename_disk != '/' THEN CONCAT('/', df_backdrop.filename_disk)
+                ELSE NULL
-            ELSE NULL
+              END,
-          END,
+              'url',
-          'url', CONCAT(globals.url, s.slug),
+              CONCAT(globals.url, s.slug),
-          'type', 'scheduled_show'
+              'type',
-        ) AS metadata
+              'scheduled_show'
-      FROM shows s
+            ) AS metadata
-      LEFT JOIN directus_files df_art ON s.art = df_art.id
+          FROM
-      LEFT JOIN directus_files df_backdrop ON s.backdrop = df_backdrop.id
+            shows s
-      CROSS JOIN optimized_globals globals
+            LEFT JOIN directus_files df_art ON s.art = df_art.id
-      WHERE s.ongoing = true
+            LEFT JOIN directus_files df_backdrop ON s.backdrop = df_backdrop.id
-        AND EXISTS (
+            CROSS JOIN optimized_globals globals
-          SELECT 1
+          WHERE
-          FROM scheduled_episodes se
+            s.ongoing = true
-          WHERE se.show_id = s.id
+            AND EXISTS (
-            AND se.status IN ('upcoming', 'aired')
+              SELECT
-        )
+                1
-        AND NOT EXISTS (
+              FROM
-          SELECT 1
+                scheduled_episodes se
-          FROM episodes e
+              WHERE
-          WHERE e.show = s.id
+                se.show_id = s.id
-        )
+                AND se.status IN ('upcoming', 'aired')
-      ORDER BY (
+            )
-        SELECT MIN(se.air_date)
+            AND NOT EXISTS (
-        FROM scheduled_episodes se
+              SELECT
-        WHERE se.show_id = s.id
+                1
-          AND se.status IN ('upcoming', 'aired')
+              FROM
-      ) ASC NULLS LAST
+                episodes e
-    ) unstarted
+              WHERE
-  )
+                e.show = s.id
-) AS scheduled_shows
+            )
+          ORDER BY
+            (
+              SELECT
+                MIN(se.air_date)
+              FROM
+                scheduled_episodes se
+              WHERE
+                se.show_id = s.id
+                AND se.status IN ('upcoming', 'aired')
+            ) ASC NULLS LAST
+        ) unstarted
+    )
+  ) AS scheduled_shows

queries/views/media/shows/shows.sql

@@ -13,194 +13,355 @@ SELECT
   CONCAT(globals.cdn_url, '/', df_art.filename_disk) AS image,
   CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk) AS backdrop,
   json_build_object(
-    'title', NULL,
+    'title',
-    'image', CONCAT(globals.cdn_url, '/', df_art.filename_disk),
+    NULL,
-    'backdrop', CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk),
+    'image',
-    'url', s.slug,
+    CONCAT(globals.cdn_url, '/', df_art.filename_disk),
-    'alt', CONCAT('Artwork for ', s.title),
+    'backdrop',
-    'subtext', CASE
+    CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk),
+    'url',
+    s.slug,
+    'alt',
+    CONCAT('Artwork for ', s.title),
+    'subtext',
+    CASE
       WHEN (
-        SELECT MAX(e1.last_watched_at)
+        SELECT
-        FROM episodes e1
+          MAX(e1.last_watched_at)
-        WHERE e1.show = s.id
+        FROM
-      ) >= NOW() - INTERVAL '90 days' THEN
+          episodes e1
-        (SELECT CONCAT('S', e2.season_number, 'E', e2.episode_number)
+        WHERE
-         FROM episodes e2
+          e1.show = s.id
-         WHERE e2.show = s.id
+      ) >= NOW() - INTERVAL '90 days' THEN (
-         ORDER BY e2.last_watched_at DESC, e2.season_number DESC, e2.episode_number DESC
+        SELECT
-         LIMIT 1)
+          CONCAT('S', e2.season_number, 'E', e2.episode_number)
+        FROM
+          episodes e2
+        WHERE
+          e2.show = s.id
+        ORDER BY
+          e2.last_watched_at DESC,
+          e2.season_number DESC,
+          e2.episode_number DESC
+        LIMIT
+          1
+      )
       ELSE s.year::text
     END,
-    'type', 'tv'
+    'type',
+    'tv'
   ) AS grid,
   json_build_object(
-    'title', s.title,
+    'title',
-    'year', s.year,
+    s.title,
-    'url', s.slug,
+    'year',
-    'image', CONCAT(globals.cdn_url, '/', df_art.filename_disk),
+    s.year,
-    'backdrop', CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk),
+    'url',
-    'formatted_episode', COALESCE((
+    s.slug,
-      SELECT CONCAT('S', e2.season_number, 'E', e2.episode_number)
+    'image',
-      FROM episodes e2
+    CONCAT(globals.cdn_url, '/', df_art.filename_disk),
-      WHERE e2.show = s.id
+    'backdrop',
-      ORDER BY e2.last_watched_at DESC, e2.season_number DESC, e2.episode_number DESC
+    CONCAT(globals.cdn_url, '/', df_backdrop.filename_disk),
-      LIMIT 1
+    'formatted_episode',
-    ), NULL),
+    COALESCE(
-    'last_watched_at', (
+      (
-      SELECT MAX(e3.last_watched_at)
+        SELECT
-      FROM episodes e3
+          CONCAT('S', e2.season_number, 'E', e2.episode_number)
-      WHERE e3.show = s.id
+        FROM
+          episodes e2
+        WHERE
+          e2.show = s.id
+        ORDER BY
+          e2.last_watched_at DESC,
+          e2.season_number DESC,
+          e2.episode_number DESC
+        LIMIT
+          1
+      ),
+      NULL
+    ),
+    'last_watched_at',
+    (
+      SELECT
+        MAX(e3.last_watched_at)
+      FROM
+        episodes e3
+      WHERE
+        e3.show = s.id
     )
   ) AS episode,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', m.title,
+        json_build_object(
-        'year', m.year,
+          'title',
-        'url', m.slug,
+          m.title,
-        'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          'year',
-        'grid', json_build_object(
+          m.year,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+          m.slug,
-          'alt', CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+          'image',
-          'subtext', CASE WHEN m.star_rating IS NOT NULL THEN m.star_rating::text ELSE m.year::text END,
+          CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
-          'url', m.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'movies'
+            'title',
+            NULL,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_movie.filename_disk),
+            'alt',
+            CONCAT('Poster for ', m.title, ' (', m.year, ')'),
+            'subtext',
+            CASE
+              WHEN m.star_rating IS NOT NULL THEN m.star_rating::text
+              ELSE m.year::text
+            END,
+            'url',
+            m.slug
+          ),
+          'type',
+          'movies'
+        )
+        ORDER BY
+          m.year ASC
       )
-      ORDER BY m.year ASC
+    FROM
-    )
+      shows_movies sm
-    FROM shows_movies sm
+      LEFT JOIN movies m ON sm.movies_id = m.id
-    LEFT JOIN movies m ON sm.movies_id = m.id
+      LEFT JOIN directus_files df_movie ON m.art = df_movie.id
-    LEFT JOIN directus_files df_movie ON m.art = df_movie.id
+    WHERE
-    WHERE sm.shows_id = s.id AND m.last_watched IS NOT NULL
+      sm.shows_id = s.id
+      AND m.last_watched IS NOT NULL
   ) AS movies,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', b.title,
+        json_build_object(
-        'author', b.author,
+          'title',
-        'url', b.slug,
+          b.title,
-        'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          'author',
-        'grid', json_build_object(
+          b.author,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+          b.slug,
-          'alt', CONCAT('Cover for ', b.title, ' by ', b.author),
+          'image',
-          'subtext', CASE WHEN b.star_rating IS NOT NULL THEN b.star_rating ELSE NULL END,
+          CONCAT(globals.cdn_url, '/', df_book.filename_disk),
-          'url', b.slug
+          'grid',
-        ),
+          json_build_object(
-        'type', 'books'
+            'title',
+            NULL,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_book.filename_disk),
+            'alt',
+            CONCAT('Cover for ', b.title, ' by ', b.author),
+            'subtext',
+            CASE
+              WHEN b.star_rating IS NOT NULL THEN b.star_rating
+              ELSE NULL
+            END,
+            'url',
+            b.slug
+          ),
+          'type',
+          'books'
+        )
+        ORDER BY
+          b.title
       )
-      ORDER BY b.title
+    FROM
-    )
+      shows_books sb
-    FROM shows_books sb
+      LEFT JOIN books b ON sb.books_id = b.id
-    LEFT JOIN books b ON sb.books_id = b.id
+      LEFT JOIN directus_files df_book ON b.art = df_book.id
-    LEFT JOIN directus_files df_book ON b.art = df_book.id
+    WHERE
-    WHERE sb.shows_id = s.id AND LOWER(b.read_status) = 'finished'
+      sb.shows_id = s.id
+      AND LOWER(b.read_status) = 'finished'
   ) AS books,
   (
-    SELECT json_agg(json_build_object('title', p.title, 'date', p.date, 'url', p.slug) ORDER BY p.date DESC)
+    SELECT
-    FROM posts_shows ps
+      json_agg(
-    LEFT JOIN posts p ON ps.posts_id = p.id
+        json_build_object('title', p.title, 'date', p.date, 'url', p.slug)
-    WHERE ps.shows_id = s.id
+        ORDER BY
+          p.date DESC
+      )
+    FROM
+      posts_shows ps
+      LEFT JOIN posts p ON ps.posts_id = p.id
+    WHERE
+      ps.shows_id = s.id
   ) AS posts,
   (
-    SELECT array_agg(t.name)
+    SELECT
-    FROM shows_tags st
+      array_agg(t.name)
-    LEFT JOIN tags t ON st.tags_id = t.id
+    FROM
-    WHERE st.shows_id = s.id
+      shows_tags st
+      LEFT JOIN tags t ON st.tags_id = t.id
+    WHERE
+      st.shows_id = s.id
   ) AS tags,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'title', rs.title,
+        json_build_object(
-        'year', rs.year,
+          'title',
-        'url', rs.slug,
+          rs.title,
-        'image', CONCAT(globals.cdn_url, '/', df_related.filename_disk),
+          'year',
-        'grid', json_build_object(
+          rs.year,
-          'title', NULL,
+          'url',
-          'image', CONCAT(globals.cdn_url, '/', df_related.filename_disk),
+          rs.slug,
-          'alt', CONCAT('Artwork for ', rs.title),
+          'image',
-          'subtext', CASE
+          CONCAT(globals.cdn_url, '/', df_related.filename_disk),
-            WHEN (
+          'grid',
-              SELECT MAX(e1.last_watched_at)
+          json_build_object(
-              FROM episodes e1
+            'title',
-              WHERE e1.show = rs.id
+            NULL,
-            ) >= NOW() - INTERVAL '90 days' THEN
+            'image',
-              (
+            CONCAT(globals.cdn_url, '/', df_related.filename_disk),
-                SELECT CONCAT('S', e2.season_number, 'E', e2.episode_number)
+            'alt',
-                FROM episodes e2
+            CONCAT('Artwork for ', rs.title),
-                WHERE e2.show = rs.id
+            'subtext',
-                ORDER BY e2.last_watched_at DESC, e2.season_number DESC, e2.episode_number DESC
+            CASE
-                LIMIT 1
+              WHEN (
+                SELECT
+                  MAX(e1.last_watched_at)
+                FROM
+                  episodes e1
+                WHERE
+                  e1.show = rs.id
+              ) >= NOW() - INTERVAL '90 days' THEN (
+                SELECT
+                  CONCAT('S', e2.season_number, 'E', e2.episode_number)
+                FROM
+                  episodes e2
+                WHERE
+                  e2.show = rs.id
+                ORDER BY
+                  e2.last_watched_at DESC,
+                  e2.season_number DESC,
+                  e2.episode_number DESC
+                LIMIT
+                  1
               )
-            ELSE rs.year::text
+              ELSE rs.year::text
-          END,
+            END,
-          'url', rs.slug
+            'url',
-        ),
+            rs.slug
-        'type', 'tv'
+          ),
+          'type',
+          'tv'
+        )
+        ORDER BY
+          rs.year ASC
       )
-      ORDER BY rs.year ASC
+    FROM
-    )
+      related_shows sr
-    FROM related_shows sr
+      LEFT JOIN shows rs ON sr.related_shows_id = rs.id
-    LEFT JOIN shows rs ON sr.related_shows_id = rs.id
+      LEFT JOIN directus_files df_related ON rs.art = df_related.id
-    LEFT JOIN directus_files df_related ON rs.art = df_related.id
+    WHERE
-    WHERE sr.shows_id = s.id
+      sr.shows_id = s.id
       AND EXISTS (
-        SELECT 1
+        SELECT
-        FROM episodes e
+          1
-        WHERE e.show = rs.id
+        FROM
+          episodes e
+        WHERE
+          e.show = rs.id
           AND e.last_watched_at IS NOT NULL
       )
   ) AS related_shows,
   (
-    SELECT json_agg(
+    SELECT
-      json_build_object(
+      json_agg(
-        'name', a.name_string,
+        json_build_object(
-        'url', a.slug,
+          'name',
-        'country', a.country,
+          a.name_string,
-        'total_plays', a.total_plays,
+          'url',
-        'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          a.slug,
-        'grid', json_build_object(
+          'country',
-          'title', a.name_string,
+          a.country,
-          'image', CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+          'total_plays',
-          'alt', CASE WHEN a.total_plays > 0 THEN CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays of ', a.name_string) ELSE CONCAT('Artwork of ', a.name_string) END,
+          a.total_plays,
-          'subtext', CASE WHEN a.total_plays > 0 THEN CONCAT(to_char(a.total_plays, 'FM999,999,999,999'), ' plays') ELSE NULL END,
+          'image',
-          'url', a.slug
+          CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
-        ),
+          'grid',
-        'type', 'music'
+          json_build_object(
+            'title',
+            a.name_string,
+            'image',
+            CONCAT(globals.cdn_url, '/', df_artist.filename_disk),
+            'alt',
+            CASE
+              WHEN a.total_plays > 0 THEN CONCAT(
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays of ',
+                a.name_string
+              )
+              ELSE CONCAT('Artwork of ', a.name_string)
+            END,
+            'subtext',
+            CASE
+              WHEN a.total_plays > 0 THEN CONCAT(
+                to_char(a.total_plays, 'FM999,999,999,999'),
+                ' plays'
+              )
+              ELSE NULL
+            END,
+            'url',
+            a.slug
+          ),
+          'type',
+          'music'
+        )
+        ORDER BY
+          a.total_plays DESC
       )
-      ORDER BY a.total_plays DESC
+    FROM
-    )
+      shows_artists sa
-    FROM shows_artists sa
+      LEFT JOIN artists a ON sa.artists_id = a.id
-    LEFT JOIN artists a ON sa.artists_id = a.id
+      LEFT JOIN directus_files df_artist ON a.art = df_artist.id
-    LEFT JOIN directus_files df_artist ON a.art = df_artist.id
+    WHERE
-    WHERE sa.shows_id = s.id
+      sa.shows_id = s.id
   ) AS artists,
   MAX(e.last_watched_at) AS last_watched_at,
   json_build_object(
-    'title', CONCAT('Show • ', s.title, ' • ', globals.site_name),
+    'title',
-    'description', LEFT(
+    CONCAT('Show • ', s.title, ' • ', globals.site_name),
+    'description',
+    LEFT(
       regexp_replace(
         regexp_replace(
           regexp_replace(s.description, E'[*_`~#>-]', '', 'g'),
-          E'\\[(.*?)\\]\\((.*?)\\)', E'\\1', 'g'
+          E'\\[(.*?)\\]\\((.*?)\\)',
+          E'\\1',
+          'g'
         ),
-        E'!\\[(.*?)\\]\\((.*?)\\)', '', 'g'
+        E'!\\[(.*?)\\]\\((.*?)\\)',
+        '',
+        'g'
       ),
       250
     ),
-    'open_graph_image', CASE
+    'open_graph_image',
-      WHEN df_backdrop.filename_disk IS NOT NULL AND df_backdrop.filename_disk != '' AND df_backdrop.filename_disk != '/' THEN CONCAT('/', df_backdrop.filename_disk)
+    CASE
+      WHEN df_backdrop.filename_disk IS NOT NULL
+      AND df_backdrop.filename_disk != ''
+      AND df_backdrop.filename_disk != '/' THEN CONCAT('/', df_backdrop.filename_disk)
       ELSE NULL
     END,
-    'url', CONCAT(globals.url, s.slug),
+    'url',
-    'type', 'show'
+    CONCAT(globals.url, s.slug),
+    'type',
+    'show'
   ) AS metadata
-FROM shows s
+FROM
-LEFT JOIN episodes e ON s.id = e.show
+  shows s
-LEFT JOIN directus_files df_art ON s.art = df_art.id
+  LEFT JOIN episodes e ON s.id = e.show
-LEFT JOIN directus_files df_backdrop ON s.backdrop = df_backdrop.id
+  LEFT JOIN directus_files df_art ON s.art = df_art.id
-CROSS JOIN optimized_globals globals
+  LEFT JOIN directus_files df_backdrop ON s.backdrop = df_backdrop.id
-GROUP BY s.id, df_art.filename_disk, df_backdrop.filename_disk, globals.cdn_url, globals.site_name, globals.url
+  CROSS JOIN optimized_globals globals
-ORDER BY MAX(e.last_watched_at) DESC;
+GROUP BY
+  s.id,
+  df_art.filename_disk,
+  df_backdrop.filename_disk,
+  globals.cdn_url,
+  globals.site_name,
+  globals.url
+ORDER BY
+  MAX(e.last_watched_at) DESC;