feat: magazine and news database (#209)

* feat: prepare structured press articles

* feat: add versatile article handling

* feat: update styling

* fix: article og generator

* chore: update error log

* chore: bump version

* chore: add caching

* feat: update sitemap generator

* chore: remove comment

Author: flaming-codes

web/app/data/article.service.server.ts

@@ -1,12 +1,107 @@
-import { BASE_URL } from "../modules/app";
+import { slog } from "../modules/observability.server";
+import { articleSlugSchema, PressArticleContentSection } from "./article.shape";
+import { supabase } from "./supabase.server";
+import { Enums, Tables } from "./supabase.types.generated";
 
 export class ArticleService {
   static async checkNewsArticleExists(
     articleSlug: string,
-    requestUrl?: string,
+    articleType?: Enums<"press_article_type"> | (string & {}),
   ): Promise<boolean> {
-    const url = `${requestUrl || BASE_URL}/press/news/${encodeURIComponent(articleSlug)}`;
-    const res = await fetch(url, { method: "HEAD" });
-    return res.ok;
+    articleSlugSchema.parse(articleSlug);
+
+    const query = supabase
+      .from("press_articles")
+      .select("slug", { head: true, count: "exact" })
+      .eq("slug", articleSlug);
+
+    if (articleType) {
+      query.eq("type", articleType);
+    }
+
+    const { count, error } = await query.maybeSingle();
+
+    if (error) {
+      slog.error("Error checking if news article exists", { error });
+      return false;
+    }
+
+    return count === 1;
+  }
+
+  static async getArticleBySlug(
+    articleSlug: string,
+    articleType?: Enums<"press_article_type"> | (string & {}),
+  ) {
+    articleSlugSchema.parse(articleSlug);
+
+    const query = supabase
+      .from("press_articles")
+      .select("*, authors:press_authors!inner(*)")
+      .eq("slug", articleSlug);
+
+    if (articleType) {
+      query.eq("type", articleType);
+    }
+
+    const { data, error } = await query.maybeSingle();
+
+    if (error || !data) {
+      slog.error("Error getting news article by slug", {
+        articleSlug,
+        articleType,
+        error,
+      });
+      return null;
+    }
+
+    return {
+      ...data,
+      authors: data.authors as Tables<"press_authors">[],
+      sections: data.sections as PressArticleContentSection[],
+    };
+  }
+
+  static async getAllArticlePreviews(
+    articleType: Enums<"press_article_type"> | (string & {}),
+  ) {
+    const query = supabase
+      .from("press_articles")
+      .select(
+        [
+          "slug",
+          "title",
+          "subline",
+          "created_at",
+          "categories",
+          "synopsis_html",
+          "type",
+        ].join(","),
+      )
+      .order("created_at", { ascending: false });
+
+    if (articleType) {
+      query.eq("type", articleType);
+    }
+
+    const { data, error } = await query;
+
+    if (error) {
+      slog.error("Error getting all news articles", { error });
+      return [];
+    }
+
+    return data as unknown as Array<
+      Pick<
+        Tables<"press_articles">,
+        | "slug"
+        | "title"
+        | "subline"
+        | "created_at"
+        | "categories"
+        | "synopsis_html"
+        | "type"
+      >
+    >;
   }
 }

web/app/data/article.shape.ts

@@ -1,3 +1,25 @@
 import { z } from "zod";
 
-export const articleSlugSchema = z.string().min(1).max(100);
+export const articleSlugSchema = z.string().min(1).max(255);
+
+export type PressArticleContentSection = {
+  headline: string;
+  fragment: string;
+  body: PressArticleContentBody;
+};
+
+export type PressArticleContentBody = Array<
+  | {
+      type: "html";
+      value: string;
+    }
+  | {
+      type: "image";
+      value: PressArticleContentBodyImage;
+    }
+>;
+
+export type PressArticleContentBodyImage = {
+  src: string;
+  caption: string;
+};

web/app/data/supabase.types.generated.ts

@@ -381,11 +381,102 @@ export type Database = {
           },
         ];
       };
+      press_article_authors: {
+        Row: {
+          author_slug: string;
+          press_article_slug: string;
+        };
+        Insert: {
+          author_slug: string;
+          press_article_slug: string;
+        };
+        Update: {
+          author_slug?: string;
+          press_article_slug?: string;
+        };
+        Relationships: [
+          {
+            foreignKeyName: "press_article_authors_author_slug_fkey";
+            columns: ["author_slug"];
+            referencedRelation: "press_authors";
+            referencedColumns: ["slug"];
+          },
+          {
+            foreignKeyName: "press_article_authors_press_article_slug_fkey";
+            columns: ["press_article_slug"];
+            referencedRelation: "press_articles";
+            referencedColumns: ["slug"];
+          },
+        ];
+      };
+      press_articles: {
+        Row: {
+          categories: Database["public"]["Enums"]["press_article_category"][];
+          created_at: string;
+          sections: Json;
+          slug: string;
+          subline: string | null;
+          synopsis_html: string;
+          title: string;
+          type: Database["public"]["Enums"]["press_article_type"];
+          updated_at: string | null;
+        };
+        Insert: {
+          categories: Database["public"]["Enums"]["press_article_category"][];
+          created_at: string;
+          sections: Json;
+          slug: string;
+          subline?: string | null;
+          synopsis_html: string;
+          title: string;
+          type: Database["public"]["Enums"]["press_article_type"];
+          updated_at?: string | null;
+        };
+        Update: {
+          categories?: Database["public"]["Enums"]["press_article_category"][];
+          created_at?: string;
+          sections?: Json;
+          slug?: string;
+          subline?: string | null;
+          synopsis_html?: string;
+          title?: string;
+          type?: Database["public"]["Enums"]["press_article_type"];
+          updated_at?: string | null;
+        };
+        Relationships: [];
+      };
+      press_authors: {
+        Row: {
+          name: string;
+          slug: string;
+        };
+        Insert: {
+          name: string;
+          slug: string;
+        };
+        Update: {
+          name?: string;
+          slug?: string;
+        };
+        Relationships: [];
+      };
     };
     Views: {
       [_ in never]: never;
     };
     Functions: {
+      dmetaphone: {
+        Args: {
+          "": string;
+        };
+        Returns: string;
+      };
+      dmetaphone_alt: {
+        Args: {
+          "": string;
+        };
+        Returns: string;
+      };
       find_closest_authors: {
         Args: {
           search_term: string;
@@ -408,6 +499,64 @@ export type Database = {
           levenshtein_distance: number;
         }[];
       };
+      gtrgm_compress: {
+        Args: {
+          "": unknown;
+        };
+        Returns: unknown;
+      };
+      gtrgm_decompress: {
+        Args: {
+          "": unknown;
+        };
+        Returns: unknown;
+      };
+      gtrgm_in: {
+        Args: {
+          "": unknown;
+        };
+        Returns: unknown;
+      };
+      gtrgm_options: {
+        Args: {
+          "": unknown;
+        };
+        Returns: undefined;
+      };
+      gtrgm_out: {
+        Args: {
+          "": unknown;
+        };
+        Returns: unknown;
+      };
+      set_limit: {
+        Args: {
+          "": number;
+        };
+        Returns: number;
+      };
+      show_limit: {
+        Args: Record<PropertyKey, never>;
+        Returns: number;
+      };
+      show_trgm: {
+        Args: {
+          "": string;
+        };
+        Returns: string[];
+      };
+      soundex: {
+        Args: {
+          "": string;
+        };
+        Returns: string;
+      };
+      text_soundex: {
+        Args: {
+          "": string;
+        };
+        Returns: string;
+      };
     };
     Enums: {
       ai_model_modality:
@@ -429,6 +578,8 @@ export type Database = {
         | "reverse_suggests"
         | "reverse_enhances"
         | "reverse_linking_to";
+      press_article_category: "general" | "announcement";
+      press_article_type: "news" | "magazine";
     };
     CompositeTypes: {
       [_ in never]: never;