fastapi-fullstack 0.1.7__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/stores/auth-store.test.ts

@@ -0,0 +1,72 @@
+{%- if cookiecutter.use_frontend and cookiecutter.use_jwt %}
+import { describe, it, expect, beforeEach } from "vitest";
+import { useAuthStore } from "./auth-store";
+import type { User } from "@/types";
+
+const createMockUser = (overrides?: Partial<User>): User => ({
+  id: "test-id",
+  email: "test@example.com",
+  is_active: true,
+  created_at: new Date().toISOString(),
+  ...overrides,
+});
+
+describe("Auth Store", () => {
+  beforeEach(() => {
+    // Reset store before each test
+    useAuthStore.setState({
+      user: null,
+      isAuthenticated: false,
+      isLoading: false,
+    });
+  });
+
+  it("should have initial state", () => {
+    const state = useAuthStore.getState();
+    expect(state.user).toBeNull();
+    expect(state.isAuthenticated).toBe(false);
+    expect(state.isLoading).toBe(false);
+  });
+
+  it("should set user on setUser", () => {
+    const testUser = createMockUser();
+
+    useAuthStore.getState().setUser(testUser);
+
+    const state = useAuthStore.getState();
+    expect(state.user).toEqual(testUser);
+    expect(state.isAuthenticated).toBe(true);
+  });
+
+  it("should clear user on logout", () => {
+    // First set a user
+    useAuthStore.getState().setUser(createMockUser());
+
+    // Then logout
+    useAuthStore.getState().logout();
+
+    const state = useAuthStore.getState();
+    expect(state.user).toBeNull();
+    expect(state.isAuthenticated).toBe(false);
+  });
+
+  it("should set loading state", () => {
+    useAuthStore.getState().setLoading(true);
+    expect(useAuthStore.getState().isLoading).toBe(true);
+
+    useAuthStore.getState().setLoading(false);
+    expect(useAuthStore.getState().isLoading).toBe(false);
+  });
+});
+{%- elif cookiecutter.use_frontend %}
+import { describe, it, expect } from "vitest";
+
+describe("Auth Store", () => {
+  it.skip("JWT authentication not enabled", () => {
+    // Skip auth store tests when JWT is not configured
+  });
+});
+{%- else %}
+/* Auth store tests - frontend not configured */
+export {};
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/stores/auth-store.ts

@@ -0,0 +1,64 @@
+"use client";
+
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import type { User } from "@/types";
+
+interface AuthState {
+  user: User | null;
+  isAuthenticated: boolean;
+  isLoading: boolean;
+
+  setUser: (user: User | null) => void;
+  setLoading: (loading: boolean) => void;
+  checkAuth: () => Promise<void>;
+  logout: () => void;
+}
+
+export const useAuthStore = create<AuthState>()(
+  persist(
+    (set) => ({
+      user: null,
+      isAuthenticated: false,
+      isLoading: true,
+
+      setUser: (user) =>
+        set({
+          user,
+          isAuthenticated: user !== null,
+          isLoading: false,
+        }),
+
+      setLoading: (loading) => set({ isLoading: loading }),
+
+      checkAuth: async () => {
+        try {
+          set({ isLoading: true });
+          const response = await fetch("/api/auth/me");
+          if (response.ok) {
+            const user = await response.json();
+            set({ user, isAuthenticated: true, isLoading: false });
+          } else {
+            set({ user: null, isAuthenticated: false, isLoading: false });
+          }
+        } catch {
+          set({ user: null, isAuthenticated: false, isLoading: false });
+        }
+      },
+
+      logout: () =>
+        set({
+          user: null,
+          isAuthenticated: false,
+          isLoading: false,
+        }),
+    }),
+    {
+      name: "auth-storage",
+      partialize: (state) => ({
+        user: state.user,
+        isAuthenticated: state.isAuthenticated,
+      }),
+    }
+  )
+);

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/stores/chat-sidebar-store.ts

@@ -0,0 +1,17 @@
+"use client";
+
+import { create } from "zustand";
+
+interface ChatSidebarState {
+  isOpen: boolean;
+  open: () => void;
+  close: () => void;
+  toggle: () => void;
+}
+
+export const useChatSidebarStore = create<ChatSidebarState>((set) => ({
+  isOpen: false,
+  open: () => set({ isOpen: true }),
+  close: () => set({ isOpen: false }),
+  toggle: () => set((state) => ({ isOpen: !state.isOpen })),
+}));

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/stores/chat-store.ts

@@ -0,0 +1,65 @@
+"use client";
+
+import { create } from "zustand";
+import type { ChatMessage, ToolCall } from "@/types";
+
+interface ChatState {
+  messages: ChatMessage[];
+  isStreaming: boolean;
+
+  addMessage: (message: ChatMessage) => void;
+  updateMessage: (
+    id: string,
+    updater: (msg: ChatMessage) => ChatMessage
+  ) => void;
+  addToolCall: (messageId: string, toolCall: ToolCall) => void;
+  updateToolCall: (
+    messageId: string,
+    toolCallId: string,
+    update: Partial<ToolCall>
+  ) => void;
+  setStreaming: (streaming: boolean) => void;
+  clearMessages: () => void;
+}
+
+export const useChatStore = create<ChatState>((set) => ({
+  messages: [],
+  isStreaming: false,
+
+  addMessage: (message) =>
+    set((state) => ({
+      messages: [...state.messages, message],
+    })),
+
+  updateMessage: (id, updater) =>
+    set((state) => ({
+      messages: state.messages.map((msg) => (msg.id === id ? updater(msg) : msg)),
+    })),
+
+  addToolCall: (messageId, toolCall) =>
+    set((state) => ({
+      messages: state.messages.map((msg) =>
+        msg.id === messageId
+          ? { ...msg, toolCalls: [...(msg.toolCalls || []), toolCall] }
+          : msg
+      ),
+    })),
+
+  updateToolCall: (messageId, toolCallId, update) =>
+    set((state) => ({
+      messages: state.messages.map((msg) =>
+        msg.id === messageId
+          ? {
+              ...msg,
+              toolCalls: msg.toolCalls?.map((tc) =>
+                tc.id === toolCallId ? { ...tc, ...update } : tc
+              ),
+            }
+          : msg
+      ),
+    })),
+
+  setStreaming: (streaming) => set({ isStreaming: streaming }),
+
+  clearMessages: () => set({ messages: [] }),
+}));

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/stores/conversation-store.ts

@@ -0,0 +1,76 @@
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+"use client";
+
+import { create } from "zustand";
+import type { Conversation, ConversationMessage } from "@/types";
+
+interface ConversationState {
+  conversations: Conversation[];
+  currentConversationId: string | null;
+  currentMessages: ConversationMessage[];
+  isLoading: boolean;
+  error: string | null;
+
+  // Actions
+  setConversations: (conversations: Conversation[]) => void;
+  addConversation: (conversation: Conversation) => void;
+  updateConversation: (id: string, updates: Partial<Conversation>) => void;
+  removeConversation: (id: string) => void;
+  setCurrentConversationId: (id: string | null) => void;
+  setCurrentMessages: (messages: ConversationMessage[]) => void;
+  addMessage: (message: ConversationMessage) => void;
+  setLoading: (loading: boolean) => void;
+  setError: (error: string | null) => void;
+  reset: () => void;
+}
+
+const initialState = {
+  conversations: [],
+  currentConversationId: null,
+  currentMessages: [],
+  isLoading: false,
+  error: null,
+};
+
+export const useConversationStore = create<ConversationState>((set) => ({
+  ...initialState,
+
+  setConversations: (conversations) => set({ conversations }),
+
+  addConversation: (conversation) =>
+    set((state) => ({
+      conversations: [conversation, ...(state.conversations || [])],
+    })),
+
+  updateConversation: (id, updates) =>
+    set((state) => ({
+      conversations: (state.conversations || []).map((conv) =>
+        conv.id === id ? { ...conv, ...updates } : conv
+      ),
+    })),
+
+  removeConversation: (id) =>
+    set((state) => ({
+      conversations: (state.conversations || []).filter((conv) => conv.id !== id),
+      currentConversationId:
+        state.currentConversationId === id ? null : state.currentConversationId,
+    })),
+
+  setCurrentConversationId: (id) => set({ currentConversationId: id }),
+
+  setCurrentMessages: (messages) => set({ currentMessages: messages }),
+
+  addMessage: (message) =>
+    set((state) => ({
+      currentMessages: [...(state.currentMessages || []), message],
+    })),
+
+  setLoading: (loading) => set({ isLoading: loading }),
+
+  setError: (error) => set({ error }),
+
+  reset: () => set(initialState),
+}));
+{%- else %}
+// Conversation store - not configured (enable_conversation_persistence is false)
+{%- endif %}

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

@@ -0,0 +1,9 @@
+export { useAuthStore } from "./auth-store";
+export { useChatStore } from "./chat-store";
+export { useThemeStore } from "./theme-store";
+export { useLocalChatStore } from "./local-chat-store";
+export { useSidebarStore } from "./sidebar-store";
+export { useChatSidebarStore } from "./chat-sidebar-store";
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+export { useConversationStore } from "./conversation-store";
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/stores/local-chat-store.ts

@@ -0,0 +1,255 @@
+"use client";
+
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import { nanoid } from "nanoid";
+import type { ChatMessage, ToolCall } from "@/types";
+
+const STORAGE_KEY = "{{ cookiecutter.project_slug }}-local-chats";
+
+export interface LocalConversation {
+  id: string;
+  title: string | null;
+  messages: ChatMessage[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface LocalChatState {
+  conversations: LocalConversation[];
+  currentConversationId: string | null;
+
+  createConversation: () => string;
+  selectConversation: (id: string | null) => void;
+  deleteConversation: (id: string) => void;
+  renameConversation: (id: string, title: string) => void;
+  getCurrentConversation: () => LocalConversation | null;
+  getCurrentMessages: () => ChatMessage[];
+
+  addMessage: (message: ChatMessage) => void;
+  updateMessage: (
+    id: string,
+    updater: (msg: ChatMessage) => ChatMessage
+  ) => void;
+  addToolCall: (messageId: string, toolCall: ToolCall) => void;
+  updateToolCall: (
+    messageId: string,
+    toolCallId: string,
+    update: Partial<ToolCall>
+  ) => void;
+  clearCurrentMessages: () => void;
+
+  reset: () => void;
+}
+
+const initialState = {
+  conversations: [] as LocalConversation[],
+  currentConversationId: null as string | null,
+};
+
+export const useLocalChatStore = create<LocalChatState>()(
+  persist(
+    (set, get) => ({
+      ...initialState,
+
+      createConversation: () => {
+        const id = nanoid();
+        const now = new Date().toISOString();
+        const newConversation: LocalConversation = {
+          id,
+          title: null,
+          messages: [],
+          createdAt: now,
+          updatedAt: now,
+        };
+        set((state) => ({
+          conversations: [newConversation, ...state.conversations],
+          currentConversationId: id,
+        }));
+        return id;
+      },
+
+      selectConversation: (id) => {
+        set({ currentConversationId: id });
+      },
+
+      deleteConversation: (id) => {
+        set((state) => ({
+          conversations: state.conversations.filter((c) => c.id !== id),
+          currentConversationId:
+            state.currentConversationId === id
+              ? null
+              : state.currentConversationId,
+        }));
+      },
+
+      renameConversation: (id, title) => {
+        set((state) => ({
+          conversations: state.conversations.map((c) =>
+            c.id === id ? { ...c, title, updatedAt: new Date().toISOString() } : c
+          ),
+        }));
+      },
+
+      getCurrentConversation: () => {
+        const state = get();
+        return (
+          state.conversations.find((c) => c.id === state.currentConversationId) ||
+          null
+        );
+      },
+
+      getCurrentMessages: () => {
+        const state = get();
+        const conversation = state.conversations.find(
+          (c) => c.id === state.currentConversationId
+        );
+        return conversation?.messages || [];
+      },
+
+      addMessage: (message) => {
+        set((state) => {
+          const convId = state.currentConversationId;
+          if (!convId) return state;
+
+          return {
+            conversations: state.conversations.map((c) =>
+              c.id === convId
+                ? {
+                    ...c,
+                    messages: [...c.messages, message],
+                    updatedAt: new Date().toISOString(),
+                    title:
+                      c.title ||
+                      (message.role === "user"
+                        ? message.content.slice(0, 50) +
+                          (message.content.length > 50 ? "..." : "")
+                        : null),
+                  }
+                : c
+            ),
+          };
+        });
+      },
+
+      updateMessage: (id, updater) => {
+        set((state) => {
+          const convId = state.currentConversationId;
+          if (!convId) return state;
+
+          return {
+            conversations: state.conversations.map((c) =>
+              c.id === convId
+                ? {
+                    ...c,
+                    messages: c.messages.map((msg) =>
+                      msg.id === id ? updater(msg) : msg
+                    ),
+                    updatedAt: new Date().toISOString(),
+                  }
+                : c
+            ),
+          };
+        });
+      },
+
+      addToolCall: (messageId, toolCall) => {
+        set((state) => {
+          const convId = state.currentConversationId;
+          if (!convId) return state;
+
+          return {
+            conversations: state.conversations.map((c) =>
+              c.id === convId
+                ? {
+                    ...c,
+                    messages: c.messages.map((msg) =>
+                      msg.id === messageId
+                        ? {
+                            ...msg,
+                            toolCalls: [...(msg.toolCalls || []), toolCall],
+                          }
+                        : msg
+                    ),
+                    updatedAt: new Date().toISOString(),
+                  }
+                : c
+            ),
+          };
+        });
+      },
+
+      updateToolCall: (messageId, toolCallId, update) => {
+        set((state) => {
+          const convId = state.currentConversationId;
+          if (!convId) return state;
+
+          return {
+            conversations: state.conversations.map((c) =>
+              c.id === convId
+                ? {
+                    ...c,
+                    messages: c.messages.map((msg) =>
+                      msg.id === messageId
+                        ? {
+                            ...msg,
+                            toolCalls: msg.toolCalls?.map((tc) =>
+                              tc.id === toolCallId ? { ...tc, ...update } : tc
+                            ),
+                          }
+                        : msg
+                    ),
+                    updatedAt: new Date().toISOString(),
+                  }
+                : c
+            ),
+          };
+        });
+      },
+
+      clearCurrentMessages: () => {
+        set((state) => {
+          const convId = state.currentConversationId;
+          if (!convId) return state;
+
+          return {
+            conversations: state.conversations.map((c) =>
+              c.id === convId
+                ? { ...c, messages: [], updatedAt: new Date().toISOString() }
+                : c
+            ),
+          };
+        });
+      },
+
+      reset: () => set(initialState),
+    }),
+    {
+      name: STORAGE_KEY,
+      partialize: (state) => ({
+        conversations: state.conversations.map((c) => ({
+          ...c,
+          messages: c.messages.map((m) => ({
+            ...m,
+            timestamp:
+              m.timestamp instanceof Date
+                ? m.timestamp.toISOString()
+                : m.timestamp,
+          })),
+        })),
+        currentConversationId: state.currentConversationId,
+      }),
+      onRehydrateStorage: () => (state) => {
+        if (state) {
+          state.conversations = state.conversations.map((c) => ({
+            ...c,
+            messages: c.messages.map((m) => ({
+              ...m,
+              timestamp: new Date(m.timestamp as unknown as string),
+            })),
+          }));
+        }
+      },
+    }
+  )
+);

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/stores/sidebar-store.ts

@@ -0,0 +1,17 @@
+"use client";
+
+import { create } from "zustand";
+
+interface SidebarState {
+  isOpen: boolean;
+  open: () => void;
+  close: () => void;
+  toggle: () => void;
+}
+
+export const useSidebarStore = create<SidebarState>((set) => ({
+  isOpen: false,
+  open: () => set({ isOpen: true }),
+  close: () => set({ isOpen: false }),
+  toggle: () => set((state) => ({ isOpen: !state.isOpen })),
+}));

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/stores/theme-store.ts

@@ -0,0 +1,44 @@
+{%- if cookiecutter.use_frontend %}
+"use client";
+
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+
+export type Theme = "light" | "dark" | "system";
+
+interface ThemeState {
+  theme: Theme;
+  setTheme: (theme: Theme) => void;
+}
+
+export const useThemeStore = create<ThemeState>()(
+  persist(
+    (set) => ({
+      theme: "system",
+      setTheme: (theme) => set({ theme }),
+    }),
+    {
+      name: "theme-storage",
+    }
+  )
+);
+
+/**
+ * Get the resolved theme (light or dark) based on the current theme setting.
+ * When theme is "system", it checks the user's system preference.
+ */
+export function getResolvedTheme(theme: Theme): "light" | "dark" {
+  if (theme === "system") {
+    if (typeof window !== "undefined") {
+      return window.matchMedia("(prefers-color-scheme: dark)").matches
+        ? "dark"
+        : "light";
+    }
+    return "light";
+  }
+  return theme;
+}
+{%- else %}
+/* Theme store - frontend not configured */
+export {};
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/types/api.ts

@@ -0,0 +1,27 @@
+/**
+ * API response types.
+ */
+
+export interface ApiResponse<T> {
+  data: T;
+  message?: string;
+}
+
+export interface PaginatedResponse<T> {
+  items: T[];
+  total: number;
+  page: number;
+  size: number;
+  pages: number;
+}
+
+export interface HealthResponse {
+  status: string;
+  version?: string;
+  database?: string;
+}
+
+export interface ErrorResponse {
+  detail: string;
+  status_code?: number;
+}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/types/auth.ts

@@ -0,0 +1,52 @@
+/**
+ * Authentication types.
+ */
+
+export interface User {
+  id: string;
+  email: string;
+  name?: string;
+  is_active: boolean;
+  is_superuser?: boolean;
+  created_at: string;
+}
+
+export interface LoginRequest {
+  email: string;
+  password: string;
+}
+
+export interface LoginResponse {
+  access_token: string;
+  refresh_token: string;
+  token_type: string;
+  user: User;
+}
+
+export interface RegisterRequest {
+  email: string;
+  password: string;
+  name?: string;
+}
+
+export interface RegisterResponse {
+  id: string;
+  email: string;
+  name?: string;
+}
+
+export interface RefreshTokenRequest {
+  refresh_token: string;
+}
+
+export interface RefreshTokenResponse {
+  access_token: string;
+  token_type: string;
+}
+
+export interface AuthState {
+  user: User | null;
+  accessToken: string | null;
+  isAuthenticated: boolean;
+  isLoading: boolean;
+}