fastapi-fullstack 0.1.7__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/components/ui/input.tsx

@@ -0,0 +1,21 @@
+import * as React from "react";
+import { cn } from "@/lib/utils";
+
+const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<"input">>(
+  ({ className, type, ...props }, ref) => {
+    return (
+      <input
+        type={type}
+        className={cn(
+          "flex h-9 w-full rounded-md border border-input bg-transparent px-3 py-1 text-base shadow-sm transition-colors file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+          className
+        )}
+        ref={ref}
+        {...props}
+      />
+    );
+  }
+);
+Input.displayName = "Input";
+
+export { Input };

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/components/ui/label.tsx

@@ -0,0 +1,21 @@
+import * as React from "react";
+import { cn } from "@/lib/utils";
+
+const Label = React.forwardRef<
+  HTMLLabelElement,
+  React.LabelHTMLAttributes<HTMLLabelElement>
+>(({ className, ...props }, ref) => {
+  return (
+    <label
+      ref={ref}
+      className={cn(
+        "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70",
+        className
+      )}
+      {...props}
+    />
+  );
+});
+Label.displayName = "Label";
+
+export { Label };

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/components/ui/sheet.tsx

@@ -0,0 +1,109 @@
+"use client";
+
+import * as React from "react";
+import { cn } from "@/lib/utils";
+import { X } from "lucide-react";
+
+interface SheetProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  children: React.ReactNode;
+}
+
+interface SheetContentProps {
+  children: React.ReactNode;
+  className?: string;
+  side?: "left" | "right";
+}
+
+export function Sheet({ open, onOpenChange, children }: SheetProps) {
+  React.useEffect(() => {
+    if (open) {
+      document.body.style.overflow = "hidden";
+    } else {
+      document.body.style.overflow = "";
+    }
+    return () => {
+      document.body.style.overflow = "";
+    };
+  }, [open]);
+
+  if (!open) return null;
+
+  return (
+    <div className="fixed inset-0 z-50">
+      <div
+        className="fixed inset-0 bg-black/50 backdrop-blur-sm"
+        onClick={() => onOpenChange(false)}
+        aria-hidden="true"
+      />
+      {children}
+    </div>
+  );
+}
+
+export function SheetContent({
+  children,
+  className,
+  side = "left",
+}: SheetContentProps) {
+  return (
+    <div
+      className={cn(
+        "fixed inset-y-0 z-50 flex w-72 flex-col bg-background shadow-lg",
+        "animate-in duration-300",
+        side === "left" ? "left-0 slide-in-from-left" : "right-0 slide-in-from-right",
+        className
+      )}
+    >
+      {children}
+    </div>
+  );
+}
+
+export function SheetHeader({
+  children,
+  className,
+}: {
+  children: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <div className={cn("flex items-center justify-between border-b p-4", className)}>
+      {children}
+    </div>
+  );
+}
+
+export function SheetTitle({
+  children,
+  className,
+}: {
+  children: React.ReactNode;
+  className?: string;
+}) {
+  return <h2 className={cn("text-lg font-semibold", className)}>{children}</h2>;
+}
+
+export function SheetClose({
+  onClick,
+  className,
+}: {
+  onClick: () => void;
+  className?: string;
+}) {
+  return (
+    <button
+      onClick={onClick}
+      className={cn(
+        "rounded-sm opacity-70 ring-offset-background transition-opacity",
+        "hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
+        "h-10 w-10 flex items-center justify-center",
+        className
+      )}
+    >
+      <X className="h-5 w-5" />
+      <span className="sr-only">Close</span>
+    </button>
+  );
+}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/hooks/index.ts

@@ -0,0 +1,7 @@
+export { useAuth } from "./use-auth";
+export { useWebSocket } from "./use-websocket";
+export { useChat } from "./use-chat";
+export { useLocalChat } from "./use-local-chat";
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+export { useConversations } from "./use-conversations";
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/hooks/use-auth.ts

@@ -0,0 +1,97 @@
+"use client";
+
+import { useCallback, useEffect } from "react";
+import { useRouter } from "next/navigation";
+import { useAuthStore } from "@/stores";
+import { apiClient, ApiError } from "@/lib/api-client";
+import type { User, LoginRequest, RegisterRequest } from "@/types";
+import { ROUTES } from "@/lib/constants";
+
+export function useAuth() {
+  const router = useRouter();
+  const { user, isAuthenticated, isLoading, setUser, setLoading, logout } =
+    useAuthStore();
+
+  // Check auth status on mount
+  useEffect(() => {
+    const checkAuth = async () => {
+      try {
+        const userData = await apiClient.get<User>("/auth/me");
+        setUser(userData);
+      } catch {
+        setUser(null);
+      }
+    };
+
+    if (isLoading) {
+      checkAuth();
+    }
+  }, [isLoading, setUser]);
+
+  const login = useCallback(
+    async (credentials: LoginRequest) => {
+      setLoading(true);
+      try {
+        const response = await apiClient.post<{ user: User; message: string }>(
+          "/auth/login",
+          credentials
+        );
+        setUser(response.user);
+        router.push(ROUTES.DASHBOARD);
+        return response;
+      } catch (error) {
+        setLoading(false);
+        throw error;
+      }
+    },
+    [router, setUser, setLoading]
+  );
+
+  const register = useCallback(
+    async (data: RegisterRequest) => {
+      const response = await apiClient.post<{ id: string; email: string }>(
+        "/auth/register",
+        data
+      );
+      return response;
+    },
+    []
+  );
+
+  const handleLogout = useCallback(async () => {
+    try {
+      await apiClient.post("/auth/logout");
+    } catch {
+      // Ignore logout errors
+    } finally {
+      logout();
+      router.push(ROUTES.LOGIN);
+    }
+  }, [logout, router]);
+
+  const refreshToken = useCallback(async () => {
+    try {
+      await apiClient.post("/auth/refresh");
+      // Re-fetch user after token refresh
+      const userData = await apiClient.get<User>("/auth/me");
+      setUser(userData);
+      return true;
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 401) {
+        logout();
+        router.push(ROUTES.LOGIN);
+      }
+      return false;
+    }
+  }, [logout, router, setUser]);
+
+  return {
+    user,
+    isAuthenticated,
+    isLoading,
+    login,
+    register,
+    logout: handleLogout,
+    refreshToken,
+  };
+}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/hooks/use-chat.ts

@@ -0,0 +1,203 @@
+"use client";
+
+import { useCallback, useState } from "react";
+import { nanoid } from "nanoid";
+import { useWebSocket } from "./use-websocket";
+import { useChatStore } from "@/stores";
+import type { ChatMessage, ToolCall, WSEvent } from "@/types";
+import { WS_URL } from "@/lib/constants";
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+import { useConversationStore } from "@/stores";
+{%- endif %}
+
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+interface UseChatOptions {
+  conversationId?: string | null;
+  onConversationCreated?: (conversationId: string) => void;
+}
+
+export function useChat(options: UseChatOptions = {}) {
+  const { conversationId, onConversationCreated } = options;
+  const { setCurrentConversationId } = useConversationStore();
+{%- else %}
+export function useChat() {
+{%- endif %}
+  const {
+    messages,
+    addMessage,
+    updateMessage,
+    addToolCall,
+    updateToolCall,
+    clearMessages,
+  } = useChatStore();
+
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [currentMessageId, setCurrentMessageId] = useState<string | null>(null);
+
+  const handleWebSocketMessage = useCallback(
+    (event: MessageEvent) => {
+      const wsEvent: WSEvent = JSON.parse(event.data);
+
+      switch (wsEvent.type) {
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+        case "conversation_created": {
+          // Handle new conversation created by backend
+          const { conversation_id } = wsEvent.data as { conversation_id: string };
+          setCurrentConversationId(conversation_id);
+          onConversationCreated?.(conversation_id);
+          break;
+        }
+
+        case "message_saved": {
+          // Message was saved to database, update local ID if needed
+          // We don't need to do anything special here for now
+          break;
+        }
+{%- endif %}
+
+        case "model_request_start": {
+          // Create new assistant message placeholder
+          const newMsgId = nanoid();
+          setCurrentMessageId(newMsgId);
+          addMessage({
+            id: newMsgId,
+            role: "assistant",
+            content: "",
+            timestamp: new Date(),
+            isStreaming: true,
+            toolCalls: [],
+          });
+          break;
+        }
+
+        case "text_delta": {
+          // Append text delta to current message
+          if (currentMessageId) {
+            const content = (wsEvent.data as { index: number; content: string }).content;
+            updateMessage(currentMessageId, (msg) => ({
+              ...msg,
+              content: msg.content + content,
+            }));
+          }
+          break;
+        }
+
+        case "tool_call": {
+          // Add tool call to current message
+          if (currentMessageId) {
+            const { tool_name, args, tool_call_id } = wsEvent.data as {
+              tool_name: string;
+              args: Record<string, unknown>;
+              tool_call_id: string;
+            };
+            const toolCall: ToolCall = {
+              id: tool_call_id,
+              name: tool_name,
+              args,
+              status: "running",
+            };
+            addToolCall(currentMessageId, toolCall);
+          }
+          break;
+        }
+
+        case "tool_result": {
+          // Update tool call with result
+          if (currentMessageId) {
+            const { tool_call_id, content } = wsEvent.data as {
+              tool_call_id: string;
+              content: string;
+            };
+            updateToolCall(currentMessageId, tool_call_id, {
+              result: content,
+              status: "completed",
+            });
+          }
+          break;
+        }
+
+        case "final_result": {
+          // Finalize message
+          if (currentMessageId) {
+            updateMessage(currentMessageId, (msg) => ({
+              ...msg,
+              isStreaming: false,
+            }));
+          }
+          setIsProcessing(false);
+          setCurrentMessageId(null);
+          break;
+        }
+
+        case "error": {
+          // Handle error
+          if (currentMessageId) {
+            updateMessage(currentMessageId, (msg) => ({
+              ...msg,
+              content: msg.content + "\n\n[Error occurred]",
+              isStreaming: false,
+            }));
+          }
+          setIsProcessing(false);
+          break;
+        }
+
+        case "complete": {
+          setIsProcessing(false);
+          break;
+        }
+      }
+    },
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+    [currentMessageId, addMessage, updateMessage, addToolCall, updateToolCall, setCurrentConversationId, onConversationCreated]
+{%- else %}
+    [currentMessageId, addMessage, updateMessage, addToolCall, updateToolCall]
+{%- endif %}
+  );
+
+  const wsUrl = `${WS_URL}/api/v1/ws/agent`;
+
+  const { isConnected, connect, disconnect, sendMessage } = useWebSocket({
+    url: wsUrl,
+    onMessage: handleWebSocketMessage,
+  });
+
+  const sendChatMessage = useCallback(
+    (content: string) => {
+      // Add user message
+      const userMessage: ChatMessage = {
+        id: nanoid(),
+        role: "user",
+        content,
+        timestamp: new Date(),
+      };
+      addMessage(userMessage);
+
+      // Send to WebSocket
+      setIsProcessing(true);
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+      sendMessage({
+        message: content,
+        conversation_id: conversationId || null,
+      });
+{%- else %}
+      sendMessage({ message: content });
+{%- endif %}
+    },
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+    [addMessage, sendMessage, conversationId]
+{%- else %}
+    [addMessage, sendMessage]
+{%- endif %}
+  );
+
+  return {
+    messages,
+    isConnected,
+    isProcessing,
+    connect,
+    disconnect,
+    sendMessage: sendChatMessage,
+    clearMessages,
+  };
+}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/hooks/use-conversations.ts

@@ -0,0 +1,181 @@
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+"use client";
+
+import { useCallback } from "react";
+import { apiClient } from "@/lib/api-client";
+import { useConversationStore, useChatStore } from "@/stores";
+import type {
+  Conversation,
+  ConversationMessage,
+  ConversationListResponse,
+} from "@/types";
+
+interface CreateConversationResponse {
+  id: string;
+  title?: string;
+  created_at: string;
+  updated_at: string;
+  is_archived: boolean;
+}
+
+interface MessagesResponse {
+  items: ConversationMessage[];
+  total: number;
+}
+
+export function useConversations() {
+  const {
+    conversations,
+    currentConversationId,
+    currentMessages,
+    isLoading,
+    error,
+    setConversations,
+    addConversation,
+    updateConversation,
+    removeConversation,
+    setCurrentConversationId,
+    setCurrentMessages,
+    setLoading,
+    setError,
+  } = useConversationStore();
+  const { clearMessages } = useChatStore();
+
+  const fetchConversations = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await apiClient.get<ConversationListResponse>(
+        "/conversations"
+      );
+      setConversations(response.items);
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : "Failed to fetch conversations";
+      setError(message);
+    } finally {
+      setLoading(false);
+    }
+  }, [setConversations, setLoading, setError]);
+
+  const createConversation = useCallback(
+    async (title?: string): Promise<Conversation | null> => {
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await apiClient.post<CreateConversationResponse>(
+          "/conversations",
+          { title }
+        );
+        const newConversation: Conversation = {
+          id: response.id,
+          title: response.title,
+          created_at: response.created_at,
+          updated_at: response.updated_at,
+          is_archived: response.is_archived,
+        };
+        addConversation(newConversation);
+        return newConversation;
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to create conversation";
+        setError(message);
+        return null;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [addConversation, setLoading, setError]
+  );
+
+  const selectConversation = useCallback(
+    async (id: string) => {
+      setCurrentConversationId(id);
+      clearMessages();
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await apiClient.get<MessagesResponse>(
+          `/conversations/${id}/messages`
+        );
+        setCurrentMessages(response.items);
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to fetch messages";
+        setError(message);
+      } finally {
+        setLoading(false);
+      }
+    },
+    [setCurrentConversationId, clearMessages, setCurrentMessages, setLoading, setError]
+  );
+
+  const archiveConversation = useCallback(
+    async (id: string) => {
+      try {
+        await apiClient.patch(`/conversations/${id}`, { is_archived: true });
+        updateConversation(id, { is_archived: true });
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to archive conversation";
+        setError(message);
+      }
+    },
+    [updateConversation, setError]
+  );
+
+  const deleteConversation = useCallback(
+    async (id: string) => {
+      try {
+        await apiClient.delete(`/conversations/${id}`);
+        removeConversation(id);
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to delete conversation";
+        setError(message);
+      }
+    },
+    [removeConversation, setError]
+  );
+
+  const renameConversation = useCallback(
+    async (id: string, title: string) => {
+      try {
+        await apiClient.patch(`/conversations/${id}`, { title });
+        updateConversation(id, { title });
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Failed to rename conversation";
+        setError(message);
+      }
+    },
+    [updateConversation, setError]
+  );
+
+  const startNewChat = useCallback(async () => {
+    clearMessages();
+    setCurrentMessages([]);
+    const newConversation = await createConversation();
+    if (newConversation) {
+      setCurrentConversationId(newConversation.id);
+    }
+  }, [clearMessages, setCurrentMessages, createConversation, setCurrentConversationId]);
+
+  return {
+    conversations,
+    currentConversationId,
+    currentMessages,
+    isLoading,
+    error,
+    fetchConversations,
+    createConversation,
+    selectConversation,
+    archiveConversation,
+    deleteConversation,
+    renameConversation,
+    startNewChat,
+  };
+}
+{%- else %}
+// Conversations hook - not configured (enable_conversation_persistence is false)
+{%- endif %}