fastapi-fullstack 0.1.2__py3-none-any.whl

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

@@ -0,0 +1,78 @@
+/**
+ * Server-side API client for calling the FastAPI backend.
+ * This module is used by Next.js API routes to proxy requests.
+ * IMPORTANT: This file should only be imported in server-side code (API routes, Server Components).
+ */
+
+const BACKEND_URL = process.env.BACKEND_URL || "http://localhost:8000";
+
+export class BackendApiError extends Error {
+  constructor(
+    public status: number,
+    public statusText: string,
+    public data?: unknown
+  ) {
+    super(`Backend API error: ${status} ${statusText}`);
+    this.name = "BackendApiError";
+  }
+}
+
+interface RequestOptions extends RequestInit {
+  params?: Record<string, string>;
+}
+
+/**
+ * Make a request to the FastAPI backend.
+ * This should only be called from Next.js API routes or Server Components.
+ */
+export async function backendFetch<T>(
+  endpoint: string,
+  options: RequestOptions = {}
+): Promise<T> {
+  const { params, ...fetchOptions } = options;
+
+  let url = `${BACKEND_URL}${endpoint}`;
+
+  if (params) {
+    const searchParams = new URLSearchParams(params);
+    url += `?${searchParams.toString()}`;
+  }
+
+  const response = await fetch(url, {
+    ...fetchOptions,
+    headers: {
+      "Content-Type": "application/json",
+      ...fetchOptions.headers,
+    },
+  });
+
+  if (!response.ok) {
+    let errorData;
+    try {
+      errorData = await response.json();
+    } catch {
+      errorData = null;
+    }
+    throw new BackendApiError(response.status, response.statusText, errorData);
+  }
+
+  // Handle empty responses
+  const text = await response.text();
+  if (!text) {
+    return null as T;
+  }
+
+  return JSON.parse(text);
+}
+
+/**
+ * Forward authorization header from the incoming request to the backend.
+ */
+export function getAuthHeaders(
+  authHeader: string | null
+): Record<string, string> {
+  if (!authHeader) {
+    return {};
+  }
+  return { Authorization: authHeader };
+}

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

@@ -0,0 +1,44 @@
+{%- if cookiecutter.use_frontend %}
+import { describe, it, expect } from "vitest";
+import { cn } from "./utils";
+
+describe("cn utility function", () => {
+  it("should merge class names", () => {
+    const result = cn("class1", "class2");
+    expect(result).toBe("class1 class2");
+  });
+
+  it("should handle conditional classes", () => {
+    const result = cn("base", { active: true, disabled: false });
+    expect(result).toContain("base");
+    expect(result).toContain("active");
+    expect(result).not.toContain("disabled");
+  });
+
+  it("should handle undefined and null values", () => {
+    const result = cn("base", undefined, null, "extra");
+    expect(result).toBe("base extra");
+  });
+
+  it("should merge tailwind classes correctly", () => {
+    // tailwind-merge should handle conflicting utilities
+    const result = cn("px-2 py-1", "px-4");
+    expect(result).toContain("px-4");
+    expect(result).toContain("py-1");
+  });
+
+  it("should handle empty input", () => {
+    const result = cn();
+    expect(result).toBe("");
+  });
+
+  it("should handle array of classes", () => {
+    const result = cn(["class1", "class2"]);
+    expect(result).toContain("class1");
+    expect(result).toContain("class2");
+  });
+});
+{%- else %}
+/* Utils tests - frontend not configured */
+export {};
+{%- endif %}

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

@@ -0,0 +1,44 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+/**
+ * Merge Tailwind CSS classes with clsx.
+ * This is the standard utility used by shadcn/ui components.
+ */
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+/**
+ * Format a date to a human-readable string.
+ */
+export function formatDate(date: Date | string): string {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  });
+}
+
+/**
+ * Format a date to include time.
+ */
+export function formatDateTime(date: Date | string): string {
+  const d = typeof date === "string" ? new Date(date) : date;
+  return d.toLocaleString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+/**
+ * Truncate a string to a maximum length.
+ */
+export function truncate(str: string, maxLength: number): string {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}

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

@@ -0,0 +1,33 @@
+{%- if cookiecutter.enable_i18n %}
+import createMiddleware from 'next-intl/middleware';
+import { locales, defaultLocale } from './i18n';
+
+export default createMiddleware({
+  // A list of all locales that are supported
+  locales,
+
+  // Used when no locale matches
+  defaultLocale,
+
+  // Prefix the default locale (e.g., /en/about instead of /about)
+  localePrefix: 'always',
+});
+
+export const config = {
+  // Match only internationalized pathnames
+  matcher: [
+    // Match all pathnames except for
+    // - /api (API routes)
+    // - /_next (Next.js internals)
+    // - /static (inside /public)
+    // - /_vercel (Vercel internals)
+    // - All root files like favicon.ico, robots.txt, etc.
+    '/((?!api|_next|_vercel|static|.*\\..*).*)',
+    // However, match all pathnames within `/api`, except for webhooks
+    // '/api/((?!webhooks).*)',
+  ],
+};
+{%- else %}
+// Middleware is disabled when i18n is not enabled
+export { };
+{%- endif %}

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,48 @@
+"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;
+  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 }),
+
+      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-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,6 @@
+export { useAuthStore } from "./auth-store";
+export { useChatStore } from "./chat-store";
+export { useThemeStore } from "./theme-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/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;
+}

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

@@ -0,0 +1,81 @@
+/**
+ * Chat and AI Agent types.
+ */
+
+export type MessageRole = "user" | "assistant" | "system";
+
+export interface ChatMessage {
+  id: string;
+  role: MessageRole;
+  content: string;
+  timestamp: Date;
+  toolCalls?: ToolCall[];
+  isStreaming?: boolean;
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  args: Record<string, unknown>;
+  result?: unknown;
+  status: "pending" | "running" | "completed" | "error";
+}
+
+// WebSocket event types from backend
+export type WSEventType =
+  | "user_prompt"
+  | "user_prompt_processed"
+  | "model_request_start"
+  | "part_start"
+  | "text_delta"
+  | "tool_call_delta"
+  | "call_tools_start"
+  | "tool_call"
+  | "tool_result"
+  | "final_result_start"
+  | "final_result"
+  | "complete"
+  | "error";
+
+export interface WSEvent {
+  type: WSEventType;
+  data?: unknown;
+  timestamp?: string;
+}
+
+export interface TextDeltaEvent {
+  type: "text_delta";
+  data: {
+    delta: string;
+  };
+}
+
+export interface ToolCallEvent {
+  type: "tool_call";
+  data: {
+    tool_name: string;
+    args: Record<string, unknown>;
+  };
+}
+
+export interface ToolResultEvent {
+  type: "tool_result";
+  data: {
+    tool_name: string;
+    result: unknown;
+  };
+}
+
+export interface FinalResultEvent {
+  type: "final_result";
+  data: {
+    output: string;
+    tool_events: ToolCall[];
+  };
+}
+
+export interface ChatState {
+  messages: ChatMessage[];
+  isConnected: boolean;
+  isProcessing: boolean;
+}