chore: improve code quality with proper error handling and types (#491)

* chore: improve code quality with proper error handling and types

- Add console.warn to empty catch blocks in model.ts and app-sidebar.tsx
- Replace any[] with ChatFileAttachment type in pending-message.ts
- Replace any[] with ChatFileAttachment type in use-persistent-chat.ts
- Add OpenRouterModel interface for API response typing in model.ts
- Use proper Convex Id<"chats"> type in app-sidebar.tsx
- Remove unsafe 'as unknown as' type casts

* fix(deploy): run convex codegen before web build on Railway

The Railway build was failing because @server/convex/_generated/* imports
couldn't resolve - the Convex generated files don't exist during web-only builds.

Fix by running 'convex codegen' in the server directory first to generate
the required type files before building the web app.

Author: leoisadev1

apps/web/railway.toml

@@ -1,7 +1,7 @@
 [build]
 builder = "RAILPACK"
-buildCommand = "cd apps/web && bun run build"
-watchPatterns = ["apps/web/**"]
+buildCommand = "cd apps/server && bunx convex codegen && cd ../web && bun run build"
+watchPatterns = ["apps/web/**", "apps/server/convex/**"]
 
 [deploy]
 startCommand = "cd apps/web && bun .output/server/index.mjs"

apps/web/src/components/app-sidebar.tsx

@@ -18,12 +18,12 @@ import {
   useSidebar,
 } from "./ui/sidebar";
 import { PlusIcon, ChatIcon, SidebarIcon, ChevronRightIcon } from "@/components/icons";
+import type { Id } from "@server/convex/_generated/dataModel";
 
 const CHATS_CACHE_KEY = "openchat-chats-cache";
 
-// Group chats by time periods
 interface ChatItem {
-  _id: string;
+  _id: Id<"chats">;
   title: string;
   updatedAt: number;
   status?: string;
@@ -130,19 +130,23 @@ export function AppSidebar() {
       if (stored && !cachedChatsRef.current) {
         cachedChatsRef.current = JSON.parse(stored);
       }
-    } catch {}
+    } catch (e) {
+      console.warn("Failed to load chats from localStorage:", e);
+    }
   }, []);
 
   useEffect(() => {
     if (chatsResult?.chats && chatsResult.chats.length > 0) {
-      cachedChatsRef.current = chatsResult.chats as unknown as ChatItem[];
+      cachedChatsRef.current = chatsResult.chats;
       try {
         localStorage.setItem(CHATS_CACHE_KEY, JSON.stringify(chatsResult.chats));
-      } catch {}
+      } catch (e) {
+        console.warn("Failed to save chats to localStorage:", e);
+      }
     }
   }, [chatsResult?.chats]);
 
-  const chats = (chatsResult?.chats ?? cachedChatsRef.current ?? []) as unknown as ChatItem[];
+  const chats = chatsResult?.chats ?? cachedChatsRef.current ?? [];
 
   const hasCachedChats = chats.length > 0;
 

apps/web/src/hooks/use-persistent-chat.ts

@@ -12,6 +12,13 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { useChat } from "@ai-sdk/react";
 import { DefaultChatTransport } from "ai";
 import type { UIMessage } from "ai";
+
+interface ChatFileAttachment {
+  type: "file";
+  mediaType: string;
+  filename?: string;
+  url: string;
+}
 import { useQuery, useMutation } from "convex/react";
 import { convexClient } from "@/lib/convex";
 import { api } from "@server/convex/_generated/api";
@@ -31,7 +38,7 @@ export interface UsePersistentChatOptions {
 
 export interface UsePersistentChatReturn {
   messages: UIMessage[];
-  sendMessage: (message: { text: string; files?: any[] }) => Promise<void>;
+  sendMessage: (message: { text: string; files?: ChatFileAttachment[] }) => Promise<void>;
   status: "ready" | "submitted" | "streaming" | "error";
   error: Error | undefined;
   stop: () => void;
@@ -520,7 +527,7 @@ export function usePersistentChat({
 
   // Handle sending messages with new chat creation
   const handleSendMessage = useCallback(
-    async (message: { text: string; files?: any[] }) => {
+    async (message: { text: string; files?: ChatFileAttachment[] }) => {
       if (!convexUserId) return;
 
       if (!message.text.trim() && (!message.files || message.files.length === 0)) {

apps/web/src/stores/model.ts

@@ -16,6 +16,25 @@ import { analytics } from "@/lib/analytics";
 // Types
 // ============================================================================
 
+/** Raw model data from OpenRouter API */
+interface OpenRouterModel {
+  id: string;
+  name?: string;
+  description?: string;
+  context_length?: number;
+  pricing?: {
+    prompt?: string;
+    completion?: string;
+  };
+  top_provider?: {
+    max_completion_tokens?: number;
+  };
+  architecture?: {
+    modality?: string;
+  };
+  supported_parameters?: string[];
+}
+
 export interface Model {
   id: string;
   name: string;
@@ -151,15 +170,19 @@ function loadFromStorage(): { models: Model[] | null; timestamp: number } {
         return { models: parsed.models, timestamp: parsed.timestamp };
       }
     }
-  } catch {}
+  } catch (e) {
+    console.warn("Failed to load models from localStorage:", e);
+  }
   return { models: null, timestamp: 0 };
 }
 
 function saveToStorage(models: Model[], timestamp: number) {
   if (typeof window === "undefined") return;
   try {
     localStorage.setItem(STORAGE_KEY, JSON.stringify({ models, timestamp }));
-  } catch {}
+  } catch (e) {
+    console.warn("Failed to save models to localStorage:", e);
+  }
 }
 
 const stored = loadFromStorage();
@@ -242,7 +265,7 @@ function extractFamily(id: string, name: string): string | undefined {
   return undefined;
 }
 
-function transformModel(raw: any): Model {
+function transformModel(raw: OpenRouterModel): Model {
   const id = raw.id as string;
   const providerSlug = id.split("/")[0] || "unknown";
   const info = PROVIDER_INFO[providerSlug] || {
@@ -313,8 +336,8 @@ async function fetchAllModels(): Promise<Model[]> {
       const rawModels = data.data || [];
 
       // Transform all models
-      const models: Model[] = rawModels
-        .filter((m: any) => m.id && typeof m.id === "string")
+      const models: Model[] = (rawModels as OpenRouterModel[])
+        .filter((m): m is OpenRouterModel & { id: string } => !!m.id && typeof m.id === "string")
         .map(transformModel)
         // Sort: Popular first, then by provider priority, then alphabetically
         .sort((a: Model, b: Model) => {

apps/web/src/stores/pending-message.ts

@@ -12,10 +12,17 @@
 
 import { create } from "zustand";
 
+interface ChatFileAttachment {
+  type: "file";
+  mediaType: string;
+  filename?: string;
+  url: string;
+}
+
 interface PendingMessage {
   chatId: string;
   text: string;
-  files?: any[];
+  files?: ChatFileAttachment[];
 }
 
 interface PendingMessageStore {