fastapi-fullstack 0.1.2__py3-none-any.whl

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,175 @@
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+"use client";
+
+import { useCallback } from "react";
+import { apiClient } from "@/lib/api-client";
+import { useConversationStore } 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 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);
+      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, 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(() => {
+    setCurrentConversationId(null);
+    setCurrentMessages([]);
+  }, [setCurrentConversationId, setCurrentMessages]);
+
+  return {
+    conversations,
+    currentConversationId,
+    currentMessages,
+    isLoading,
+    error,
+    fetchConversations,
+    createConversation,
+    selectConversation,
+    archiveConversation,
+    deleteConversation,
+    renameConversation,
+    startNewChat,
+  };
+}
+{%- else %}
+// Conversations hook - not configured (enable_conversation_persistence is false)
+{%- endif %}

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

@@ -0,0 +1,105 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+interface UseWebSocketOptions {
+  url: string;
+  onMessage?: (event: MessageEvent) => void;
+  onOpen?: () => void;
+  onClose?: () => void;
+  onError?: (error: Event) => void;
+  reconnect?: boolean;
+  reconnectInterval?: number;
+  maxReconnectAttempts?: number;
+}
+
+export function useWebSocket({
+  url,
+  onMessage,
+  onOpen,
+  onClose,
+  onError,
+  reconnect = true,
+  reconnectInterval = 3000,
+  maxReconnectAttempts = 5,
+}: UseWebSocketOptions) {
+  const [isConnected, setIsConnected] = useState(false);
+  const wsRef = useRef<WebSocket | null>(null);
+  const reconnectTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+  const reconnectAttemptsRef = useRef(0);
+
+  // Use refs for callbacks to avoid recreating connect function
+  const onMessageRef = useRef(onMessage);
+  const onOpenRef = useRef(onOpen);
+  const onCloseRef = useRef(onClose);
+  const onErrorRef = useRef(onError);
+
+  // Keep refs updated
+  useEffect(() => {
+    onMessageRef.current = onMessage;
+    onOpenRef.current = onOpen;
+    onCloseRef.current = onClose;
+    onErrorRef.current = onError;
+  }, [onMessage, onOpen, onClose, onError]);
+
+  const connect = useCallback(() => {
+    if (wsRef.current?.readyState === WebSocket.OPEN) return;
+
+    const ws = new WebSocket(url);
+    wsRef.current = ws;
+
+    ws.onopen = () => {
+      setIsConnected(true);
+      reconnectAttemptsRef.current = 0;
+      onOpenRef.current?.();
+    };
+
+    ws.onmessage = (event) => {
+      onMessageRef.current?.(event);
+    };
+
+    ws.onclose = () => {
+      setIsConnected(false);
+      onCloseRef.current?.();
+
+      if (reconnect && reconnectAttemptsRef.current < maxReconnectAttempts) {
+        reconnectTimeoutRef.current = setTimeout(() => {
+          reconnectAttemptsRef.current += 1;
+          connect();
+        }, reconnectInterval);
+      }
+    };
+
+    ws.onerror = (error) => {
+      onErrorRef.current?.(error);
+    };
+  }, [url, reconnect, reconnectInterval, maxReconnectAttempts]);
+
+  const disconnect = useCallback(() => {
+    if (reconnectTimeoutRef.current) {
+      clearTimeout(reconnectTimeoutRef.current);
+    }
+    wsRef.current?.close();
+    wsRef.current = null;
+  }, []);
+
+  const sendMessage = useCallback((data: string | object) => {
+    if (wsRef.current?.readyState === WebSocket.OPEN) {
+      const message = typeof data === "string" ? data : JSON.stringify(data);
+      wsRef.current.send(message);
+    }
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      disconnect();
+    };
+  }, [disconnect]);
+
+  return {
+    isConnected,
+    connect,
+    disconnect,
+    sendMessage,
+  };
+}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/i18n.ts

@@ -0,0 +1,32 @@
+{%- if cookiecutter.enable_i18n %}
+import { notFound } from 'next/navigation';
+import { getRequestConfig } from 'next-intl/server';
+
+// Supported locales
+export const locales = ['en', 'pl'] as const;
+export type Locale = (typeof locales)[number];
+
+export const defaultLocale: Locale = 'en';
+
+export default getRequestConfig(async ({ locale }) => {
+  // Validate that the incoming `locale` parameter is valid
+  if (!locales.includes(locale as Locale)) notFound();
+
+  return {
+    messages: (await import(`../messages/${locale}.json`)).default
+  };
+});
+
+export function getLocaleLabel(locale: Locale): string {
+  const labels: Record<Locale, string> = {
+    en: 'English',
+    pl: 'Polski',
+  };
+  return labels[locale];
+}
+{%- else %}
+// i18n is disabled
+export const locales = ['en'] as const;
+export type Locale = (typeof locales)[number];
+export const defaultLocale: Locale = 'en';
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/lib/api-client.ts

@@ -0,0 +1,90 @@
+/**
+ * Client-side API client.
+ * All requests go through Next.js API routes (/api/*), never directly to the backend.
+ * This keeps the backend URL hidden from the browser.
+ */
+
+export class ApiError extends Error {
+  constructor(
+    public status: number,
+    public message: string,
+    public data?: unknown
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+}
+
+interface RequestOptions extends Omit<RequestInit, "body"> {
+  params?: Record<string, string>;
+  body?: unknown;
+}
+
+class ApiClient {
+  private async request<T>(
+    endpoint: string,
+    options: RequestOptions = {}
+  ): Promise<T> {
+    const { params, body, ...fetchOptions } = options;
+
+    let url = `/api${endpoint}`;
+
+    if (params) {
+      const searchParams = new URLSearchParams(params);
+      url += `?${searchParams.toString()}`;
+    }
+
+    const response = await fetch(url, {
+      ...fetchOptions,
+      headers: {
+        "Content-Type": "application/json",
+        ...fetchOptions.headers,
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!response.ok) {
+      let errorData;
+      try {
+        errorData = await response.json();
+      } catch {
+        errorData = null;
+      }
+      throw new ApiError(
+        response.status,
+        errorData?.detail || errorData?.message || "Request failed",
+        errorData
+      );
+    }
+
+    // Handle empty responses
+    const text = await response.text();
+    if (!text) {
+      return null as T;
+    }
+
+    return JSON.parse(text);
+  }
+
+  get<T>(endpoint: string, options?: RequestOptions) {
+    return this.request<T>(endpoint, { ...options, method: "GET" });
+  }
+
+  post<T>(endpoint: string, body?: unknown, options?: RequestOptions) {
+    return this.request<T>(endpoint, { ...options, method: "POST", body });
+  }
+
+  put<T>(endpoint: string, body?: unknown, options?: RequestOptions) {
+    return this.request<T>(endpoint, { ...options, method: "PUT", body });
+  }
+
+  patch<T>(endpoint: string, body?: unknown, options?: RequestOptions) {
+    return this.request<T>(endpoint, { ...options, method: "PATCH", body });
+  }
+
+  delete<T>(endpoint: string, options?: RequestOptions) {
+    return this.request<T>(endpoint, { ...options, method: "DELETE" });
+  }
+}
+
+export const apiClient = new ApiClient();

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/lib/constants.ts

@@ -0,0 +1,39 @@
+/**
+ * Application constants.
+ */
+
+export const APP_NAME = "{{ cookiecutter.project_name }}";
+export const APP_DESCRIPTION = "{{ cookiecutter.project_description }}";
+
+// API Routes (Next.js internal routes)
+export const API_ROUTES = {
+  // Auth
+  LOGIN: "/auth/login",
+  REGISTER: "/auth/register",
+  LOGOUT: "/auth/logout",
+  REFRESH: "/auth/refresh",
+  ME: "/auth/me",
+
+  // Health
+  HEALTH: "/health",
+
+  // Users
+  USERS: "/users",
+
+  // Chat (AI Agent)
+  CHAT: "/chat",
+} as const;
+
+// Navigation routes
+export const ROUTES = {
+  HOME: "/",
+  LOGIN: "/login",
+  REGISTER: "/register",
+  DASHBOARD: "/dashboard",
+  CHAT: "/chat",
+  PROFILE: "/profile",
+  SETTINGS: "/settings",
+} as const;
+
+// WebSocket URL (for chat - this needs to be direct to backend for WS)
+export const WS_URL = process.env.NEXT_PUBLIC_WS_URL || "ws://localhost:8000";