cleanup types, constants, utils

netlify/functions/batch-search-actors.ts

···
 import { successResponse } from "./shared/utils";
 import { withAuthErrorHandling } from "./shared/middleware";
 import { ValidationError } from "./shared/constants/errors";
+import { normalize } from "./shared/utils/string.utils";
 
 const batchSearchHandler: AuthenticatedHandler = async (context) => {
   // Parse batch request
···
       });
 
       // Filter and rank matches
-      const normalize = (s: string) => s.toLowerCase().replace(/[._-]/g, "");
       const normalizedUsername = normalize(username);
 
       const rankedActors = response.data.actors

netlify/functions/save-results.ts

···
   MatchRepository,
 } from "./shared/repositories";
 import { successResponse } from "./shared/utils";
+import { normalize } from "./shared/utils";
 import { withAuthErrorHandling } from "./shared/middleware";
 import { ValidationError } from "./shared/constants/errors";
 
···
   // BULK OPERATION 2: Link all users to source accounts
   const links = results
     .map((result) => {
-      const normalized = result.sourceUser.username
-        .toLowerCase()
-        .replace(/[._-]/g, "");
+      const normalized = normalize(result.sourceUser.username);
       const sourceAccountId = sourceAccountIdMap.get(normalized);
       return {
         sourceAccountId: sourceAccountId!,
···
   const matchedSourceAccountIds: number[] = [];
 
   for (const result of results) {
-    const normalized = result.sourceUser.username
-      .toLowerCase()
-      .replace(/[._-]/g, "");
+    const normalized = normalize(result.sourceUser.username);
     const sourceAccountId = sourceAccountIdMap.get(normalized);
 
     if (

netlify/functions/shared/repositories/SourceAccountRepository.ts

···
 import { BaseRepository } from "./BaseRepository";
-import { SourceAccountRow } from "../types";
+import { normalize } from "../utils";
 
 export class SourceAccountRepository extends BaseRepository {
   /**
···
     sourcePlatform: string,
     sourceUsername: string,
   ): Promise<number> {
-    const normalized = sourceUsername.toLowerCase().replace(/[._-]/g, "");
+    const normalized = normalize(sourceUsername);
 
     const result = await this.sql`
       INSERT INTO source_accounts (source_platform, source_username, normalized_username)
···
     const values = usernames.map((username) => ({
       platform: sourcePlatform,
       username: username,
-      normalized: username.toLowerCase().replace(/[._-]/g, ""),
+      normalized: normalize(username),
     }));
 
     const platforms = values.map((v) => v.platform);

netlify/functions/shared/services/oauth/config.ts

···
 import { OAuthConfig } from "../../types";
+import { configCache } from "../../utils/cache.utils";
 
 export function getOAuthConfig(event?: {
   headers: Record<string, string | undefined>;
 }): OAuthConfig {
+  // Create a cache key based on the environment
+  const host = event?.headers?.host || "default";
+  const cacheKey = `oauth-config-${host}`;
+
+  // Check cache first
+  const cached = configCache.get(cacheKey) as OAuthConfig | undefined;
+  if (cached) {
+    return cached;
+  }
+
   let baseUrl: string | undefined;
   let deployContext: string | undefined;
 
···
     deployContext = event.headers["x-nf-deploy-context"];
 
     // For Netlify deploys, construct URL from host header
-    const host = event.headers.host;
     const forwardedProto = event.headers["x-forwarded-proto"] || "https";
 
     if (host && !host.includes("localhost") && !host.includes("127.0.0.1")) {
···
   const isLocalhost =
     !baseUrl || baseUrl.includes("localhost") || baseUrl.includes("127.0.0.1");
 
+  let config: OAuthConfig;
+
   if (isLocalhost) {
     const port = process.env.PORT || "8888";
     const clientId = `http://localhost?${new URLSearchParams([
···
 
     console.log("Using loopback OAuth for local development");
 
-    return {
+    config = {
       clientId: clientId,
       redirectUri: `http://127.0.0.1:${port}/.netlify/functions/oauth-callback`,
       jwksUri: undefined,
       clientType: "loopback",
     };
-  }
+  } else {
+    // Production/Preview: discoverable client
+    if (!baseUrl) {
+      throw new Error("No public URL available for OAuth configuration");
+    }
+
+    console.log("Using confidential OAuth client for:", baseUrl);
 
-  // Production/Preview: discoverable client
-  if (!baseUrl) {
-    throw new Error("No public URL available for OAuth configuration");
+    config = {
+      clientId: `${baseUrl}/oauth-client-metadata.json`,
+      redirectUri: `${baseUrl}/.netlify/functions/oauth-callback`,
+      jwksUri: `${baseUrl}/.netlify/functions/jwks`,
+      clientType: "discoverable",
+      usePrivateKey: true,
+    };
   }
 
-  console.log("Using confidential OAuth client for:", baseUrl);
+  // Cache the config for 5 minutes (300000ms)
+  configCache.set(cacheKey, config, 300000);
 
-  return {
-    clientId: `${baseUrl}/oauth-client-metadata.json`,
-    redirectUri: `${baseUrl}/.netlify/functions/oauth-callback`,
-    jwksUri: `${baseUrl}/.netlify/functions/jwks`,
-    clientType: "discoverable",
-    usePrivateKey: true,
-  };
+  return config;
 }

netlify/functions/shared/utils/cache.utils.ts

···
+/**
+ * Simple in-memory cache with TTL support
+ **/
+class SimpleCache<T> {
+  private cache = new Map<string, { value: T; expires: number }>();
+
+  set(key: string, value: T, ttlMs: number): void {
+    this.cache.set(key, {
+      value,
+      expires: Date.now() + ttlMs,
+    });
+  }
+
+  get(key: string): T | undefined {
+    const entry = this.cache.get(key);
+    if (!entry) return undefined;
+
+    if (Date.now() > entry.expires) {
+      this.cache.delete(key);
+      return undefined;
+    }
+
+    return entry.value;
+  }
+
+  has(key: string): boolean {
+    return this.get(key) !== undefined;
+  }
+
+  delete(key: string): void {
+    this.cache.delete(key);
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  // Clean up expired entries
+  cleanup(): void {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.expires) {
+        this.cache.delete(key);
+      }
+    }
+  }
+}
+
+export const configCache = new SimpleCache<any>();

netlify/functions/shared/utils/index.ts

···
 export * from "./response.utils";
+export * from "./cache.utils";
+export * from "./string.utils";

netlify/functions/shared/utils/string.utils.ts

···
+/**
+ * Normalize a string for comparison purposes
+ *
+ * @param str - The string to normalize
+ * @returns Normalized lowercase string
+ **/
+export function normalize(str: string): string {
+  return str.toLowerCase().replace(/[._-]/g, "");
+}

src/components/HistoryTab.tsx

···
 import type { Upload as UploadType } from "../types";
 import FaviconIcon from "../components/FaviconIcon";
 import type { UserSettings } from "../types/settings";
+import { getPlatformColor } from "../lib/utils/platform";
 
 interface HistoryTabProps {
   uploads: UploadType[];
···
       hour: "2-digit",
       minute: "2-digit",
     });
-  };
-
-  const getPlatformColor = (platform: string) => {
-    const colors: Record<string, string> = {
-      tiktok: "from-black via-gray-800 to-cyan-400",
-      twitter: "from-blue-400 to-blue-600",
-      instagram: "from-pink-500 via-purple-500 to-orange-500",
-    };
-    return colors[platform] || "from-gray-400 to-gray-600";
   };
 
   return (

src/components/SearchResultCard.tsx

···
   ChevronDown,
   UserCheck,
 } from "lucide-react";
-import { PLATFORMS } from "../constants/platforms";
-import { ATPROTO_APPS } from "../constants/atprotoApps";
 import type { SearchResult } from "../types";
+import { getPlatform, getAtprotoAppWithFallback } from "../lib/utils/platform";
 import type { AtprotoAppId } from "../types/settings";
 
 interface SearchResultCardProps {
···
     ? result.atprotoMatches
     : result.atprotoMatches.slice(0, 1);
   const hasMoreMatches = result.atprotoMatches.length > 1;
-  const platform = PLATFORMS[sourcePlatform] || PLATFORMS.tiktok;
-
-  // Get current follow lexicon
-  const currentApp = ATPROTO_APPS[destinationAppId];
+  const currentApp = getAtprotoAppWithFallback(destinationAppId);
   const currentLexicon = currentApp?.followLexicon || "app.bsky.graph.follow";
 
   return (

src/constants/atprotoApps.ts

···
 import type { AtprotoApp } from "../types/settings";
 
+// Re-export for convenience
+export type { AtprotoApp } from "../types/settings";
+
 export const ATPROTO_APPS: Record<string, AtprotoApp> = {
   bluesky: {
     id: "bluesky",
···
     enabled: false, // Not yet implemented
   },
 };
-
-export function getAppById(id: string): AtprotoApp | undefined {
-  return ATPROTO_APPS[id];
-}
-
-export function getEnabledApps(): AtprotoApp[] {
-  return Object.values(ATPROTO_APPS).filter((app) => app.enabled);
-}

src/constants/platforms.ts

···
 export const FOLLOW_CONFIG = {
   BATCH_SIZE: 50,
 };
+
+/**
+ * @deprecated Use getPlatformColor from lib/utils/platform instead
+ **/
+export function getLegacyPlatformColor(platform: string): string {
+  const colors: Record<string, string> = {
+    tiktok: "from-black via-gray-800 to-cyan-400",
+    twitter: "from-blue-400 to-blue-600",
+    instagram: "from-pink-500 via-purple-500 to-orange-500",
+  };
+  return colors[platform] || "from-gray-400 to-gray-600";
+}

src/lib/parserLogic.ts

···
  * @param content The string content (HTML or plain text) to search within.
  * @param regexPattern The regex string defining the capture group for the username.
  * @returns An array of extracted usernames.
- */
+ **/
 export function parseTextOrHtml(
   content: string,
   regexPattern: string,

src/lib/utils/index.ts

···
+export * from "./platform";

src/lib/utils/platform.ts

···
+import { PLATFORMS, type PlatformConfig } from "../../constants/platforms";
+import { ATPROTO_APPS, type AtprotoApp } from "../../constants/atprotoApps";
+import type { AtprotoAppId } from "../../types/settings";
+
+/**
+ * Get platform configuration by key
+ *
+ * @param platformKey - The platform identifier (e.g., "tiktok", "instagram")
+ * @returns Platform configuration or default to TikTok
+ **/
+export function getPlatform(platformKey: string): PlatformConfig {
+  return PLATFORMS[platformKey] || PLATFORMS.tiktok;
+}
+
+/**
+ * Get platform gradient color classes for UI
+ *
+ * @param platformKey - The platform identifier
+ * @returns Tailwind gradient classes for the platform
+ **/
+export function getPlatformColor(platformKey: string): string {
+  const colors: Record<string, string> = {
+    tiktok: "from-black via-gray-800 to-cyan-400",
+    twitter: "from-blue-400 to-blue-600",
+    instagram: "from-pink-500 via-purple-500 to-orange-500",
+    tumblr: "from-indigo-600 to-blue-800",
+    twitch: "from-purple-600 to-purple-800",
+    youtube: "from-red-600 to-red-700",
+  };
+  return colors[platformKey] || "from-gray-400 to-gray-600";
+}
+
+/**
+ * Get ATProto app configuration by ID
+ *
+ * @param appId - The app identifier
+ * @returns App configuration or undefined if not found
+ **/
+export function getAtprotoApp(appId: AtprotoAppId): AtprotoApp | undefined {
+  return ATPROTO_APPS[appId];
+}
+
+/**
+ * Get ATProto app with fallback to default
+ *
+ * @param appId - The app identifier
+ * @param defaultApp - Default app ID to use as fallback
+ * @returns App configuration, falling back to default or Bluesky
+ **/
+export function getAtprotoAppWithFallback(
+  appId: AtprotoAppId,
+  defaultApp: AtprotoAppId = "bluesky",
+): AtprotoApp {
+  return (
+    ATPROTO_APPS[appId] || ATPROTO_APPS[defaultApp] || ATPROTO_APPS.bluesky
+  );
+}
+
+/**
+ * Get all enabled ATProto apps
+ *
+ * @returns Array of enabled app configurations
+ **/
+export function getEnabledAtprotoApps(): AtprotoApp[] {
+  return Object.values(ATPROTO_APPS).filter((app) => app.enabled);
+}
+
+/**
+ * Get all enabled platforms
+ *
+ * @returns Array of [key, config] tuples for enabled platforms
+ **/
+export function getEnabledPlatforms(): Array<[string, PlatformConfig]> {
+  return Object.entries(PLATFORMS).filter(([_, config]) => config.enabled);
+}
+
+/**
+ * Check if a platform is enabled
+ *
+ * @param platformKey - The platform identifier
+ * @returns True if platform is enabled
+ **/
+export function isPlatformEnabled(platformKey: string): boolean {
+  return PLATFORMS[platformKey]?.enabled || false;
+}
+
+/**
+ * Check if an app is enabled
+ *
+ * @param appId - The app identifier
+ * @returns True if app is enabled
+ **/
+export function isAppEnabled(appId: AtprotoAppId): boolean {
+  return ATPROTO_APPS[appId]?.enabled || false;
+}

src/pages/Loading.tsx

···
 import AppHeader from "../components/AppHeader";
-import { PLATFORMS } from "../constants/platforms";
+import { getPlatform } from "../lib/utils/platform";
 
 interface atprotoSession {
   did: string;
···
   onToggleTheme,
   onToggleMotion,
 }: LoadingPageProps) {
-  const platform = PLATFORMS[sourcePlatform] || PLATFORMS.tiktok;
+  const platform = getPlatform(sourcePlatform);
   const PlatformIcon = platform.icon;
 
   return (

src/pages/Results.tsx

···
 import { Sparkles } from "lucide-react";
 import { useMemo } from "react";
-import { PLATFORMS } from "../constants/platforms";
-import { ATPROTO_APPS } from "../constants/atprotoApps";
 import AppHeader from "../components/AppHeader";
 import SearchResultCard from "../components/SearchResultCard";
 import FaviconIcon from "../components/FaviconIcon";
 import type { AtprotoAppId } from "../types/settings";
+import { getPlatform, getAtprotoApp } from "../lib/utils/platform";
 
 interface atprotoSession {
   did: string;
···
   onToggleTheme,
   onToggleMotion,
 }: ResultsPageProps) {
-  const platform = PLATFORMS[sourcePlatform] || PLATFORMS.tiktok;
+  const platform = getPlatform(sourcePlatform);
+  const destinationApp = getAtprotoApp(destinationAppId);
   const PlatformIcon = platform.icon;
-  const destinationApp = ATPROTO_APPS[destinationAppId];
 
   // Memoize sorted results to avoid re-sorting on every render
   const sortedResults = useMemo(() => {

src/types/auth.types.ts

···
+// Authentication and session types
+
+export interface AtprotoSession {
+  did: string;
+  handle: string;
+  displayName?: string;
+  avatar?: string;
+  description?: string;
+}
+
+export interface UserSessionData {
+  did: string;
+}
+
+export interface OAuthConfig {
+  clientId: string;
+  redirectUri: string;
+  jwksUri?: string;
+  clientType: "loopback" | "discoverable";
+  usePrivateKey?: boolean;
+}
+
+export interface StateData {
+  dpopKey: any;
+  verifier: string;
+  appState?: string;
+}
+
+export interface SessionData {
+  dpopKey: any;
+  tokenSet: any;
+}

src/types/common.types.ts

···
+// Common shared types
+
+export type AppStep =
+  | "checking"
+  | "login"
+  | "home"
+  | "upload"
+  | "loading"
+  | "results";
+
+export interface Upload {
+  uploadId: string;
+  sourcePlatform: string;
+  createdAt: string;
+  totalUsers: number;
+  matchedUsers: number;
+  unmatchedUsers: number;
+}
+
+export interface SaveResultsResponse {
+  success: boolean;
+  uploadId: string;
+  totalUsers: number;
+  matchedUsers: number;
+  unmatchedUsers: number;
+}

src/types/index.ts

···
 // Session and Auth Types
-export interface AtprotoSession {
-  did: string;
-  handle: string;
-  displayName?: string;
-  avatar?: string;
-  description?: string;
-}
-
-// TikTok Data Types
-export interface SourceUser {
-  username: string;
-  date: string;
-}
+export * from "./auth.types";
 
 // Search and Match Types
-export interface AtprotoMatch {
-  did: string;
-  handle: string;
-  displayName?: string;
-  avatar?: string;
-  matchScore: number;
-  description?: string;
-  followed?: boolean; // DEPRECATED - kept for backward compatibility
-  followStatus?: Record<string, boolean>;
-  postCount?: number;
-  followerCount?: number;
-  foundAt?: string;
-}
+export * from "./search.types";
 
-export interface SearchResult {
-  sourceUser: SourceUser;
-  atprotoMatches: AtprotoMatch[];
-  isSearching: boolean;
-  error?: string;
-  selectedMatches?: Set<string>;
-  sourcePlatform: string;
-}
-
-// Progress Tracking
-export interface SearchProgress {
-  searched: number;
-  found: number;
-  total: number;
-}
-
-// App State
-export type AppStep =
-  | "checking"
-  | "login"
-  | "home"
-  | "upload"
-  | "loading"
-  | "results";
-
-// API Response Types
-export interface BatchSearchResult {
-  username: string;
-  actors: AtprotoMatch[];
-  error?: string;
-}
-
-export interface BatchFollowResult {
-  did: string;
-  success: boolean;
-  alreadyFollowing?: boolean;
-  error: string | null;
-}
-
-export interface SaveResultsResponse {
-  success: boolean;
-  uploadId: string;
-  totalUsers: number;
-  matchedUsers: number;
-  unmatchedUsers: number;
-}
-
-export interface Upload {
-  uploadId: string;
-  sourcePlatform: string;
-  createdAt: string;
-  totalUsers: number;
-  matchedUsers: number;
-  unmatchedUsers: number;
-}
+// Common Types
+export * from "./common.types";
 
 // Re-export settings types for convenience
 export type {

src/types/search.types.ts

···
+export interface SourceUser {
+  username: string;
+  date: string;
+}
+
+export interface AtprotoMatch {
+  did: string;
+  handle: string;
+  displayName?: string;
+  avatar?: string;
+  matchScore: number;
+  description?: string;
+  followed?: boolean; // DEPRECATED - kept for backward compatibility
+  followStatus?: Record<string, boolean>;
+  postCount?: number;
+  followerCount?: number;
+  foundAt?: string;
+}
+
+export interface SearchResult {
+  sourceUser: SourceUser;
+  atprotoMatches: AtprotoMatch[];
+  isSearching: boolean;
+  error?: string;
+  selectedMatches?: Set<string>;
+  sourcePlatform: string;
+}
+
+export interface SearchProgress {
+  searched: number;
+  found: number;
+  total: number;
+}
+
+export interface BatchSearchResult {
+  username: string;
+  actors: AtprotoMatch[];
+  error?: string;
+}
+
+export interface BatchFollowResult {
+  did: string;
+  success: boolean;
+  alreadyFollowing?: boolean;
+  error: string | null;
+}