fastapi-fullstack 0.1.2__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/api/auth/me/route.ts

@@ -0,0 +1,39 @@
+{% raw %}import { NextRequest, NextResponse } from "next/server";
+import { backendFetch, BackendApiError } from "@/lib/server-api";
+import type { User } from "@/types";
+
+export async function GET(request: NextRequest) {
+  try {
+    const accessToken = request.cookies.get("access_token")?.value;
+
+    if (!accessToken) {
+      return NextResponse.json({ detail: "Not authenticated" }, { status: 401 });
+    }
+
+    const data = await backendFetch<User>("/api/v1/auth/me", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    return NextResponse.json(data);
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      if (error.status === 401) {
+        // Token expired, try to refresh
+        return NextResponse.json(
+          { detail: "Token expired" },
+          { status: 401 }
+        );
+      }
+      return NextResponse.json(
+        { detail: "Failed to get user" },
+        { status: error.status }
+      );
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}{% endraw %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/api/auth/oauth-callback/route.ts

@@ -0,0 +1,50 @@
+{%- if cookiecutter.enable_oauth %}
+import { cookies } from "next/headers";
+import { NextRequest, NextResponse } from "next/server";
+
+export async function POST(request: NextRequest) {
+  try {
+    const { accessToken, refreshToken } = await request.json();
+
+    if (!accessToken || !refreshToken) {
+      return NextResponse.json(
+        { error: "Missing tokens" },
+        { status: 400 }
+      );
+    }
+
+    const cookieStore = await cookies();
+
+    // Set access token cookie
+    cookieStore.set("access_token", accessToken, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      maxAge: 60 * 60 * 24, // 24 hours
+      path: "/",
+    });
+
+    // Set refresh token cookie
+    cookieStore.set("refresh_token", refreshToken, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      maxAge: 60 * 60 * 24 * 7, // 7 days
+      path: "/",
+    });
+
+    return NextResponse.json({ success: true });
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to process OAuth callback" },
+      { status: 500 }
+    );
+  }
+}
+{%- else %}
+import { NextResponse } from "next/server";
+
+export async function POST() {
+  return NextResponse.json({ error: "OAuth not enabled" }, { status: 404 });
+}
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/api/auth/refresh/route.ts

@@ -0,0 +1,54 @@
+{% raw %}import { NextRequest, NextResponse } from "next/server";
+import { backendFetch, BackendApiError } from "@/lib/server-api";
+import type { RefreshTokenResponse } from "@/types";
+
+export async function POST(request: NextRequest) {
+  try {
+    const refreshToken = request.cookies.get("refresh_token")?.value;
+
+    if (!refreshToken) {
+      return NextResponse.json(
+        { detail: "No refresh token" },
+        { status: 401 }
+      );
+    }
+
+    const data = await backendFetch<RefreshTokenResponse>(
+      "/api/v1/auth/refresh",
+      {
+        method: "POST",
+        body: JSON.stringify({ refresh_token: refreshToken }),
+      }
+    );
+
+    const response = NextResponse.json({ message: "Token refreshed" });
+
+    // Update access token cookie
+    response.cookies.set("access_token", data.access_token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      maxAge: 60 * 15, // 15 minutes
+      path: "/",
+    });
+
+    return response;
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      // Clear cookies on refresh failure
+      const response = NextResponse.json(
+        { detail: "Session expired" },
+        { status: 401 }
+      );
+
+      response.cookies.set("access_token", "", { maxAge: 0, path: "/" });
+      response.cookies.set("refresh_token", "", { maxAge: 0, path: "/" });
+
+      return response;
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}{% endraw %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/api/auth/register/route.ts

@@ -0,0 +1,26 @@
+{% raw %}import { NextRequest, NextResponse } from "next/server";
+import { backendFetch, BackendApiError } from "@/lib/server-api";
+import type { RegisterResponse } from "@/types";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+
+    const data = await backendFetch<RegisterResponse>("/api/v1/auth/register", {
+      method: "POST",
+      body: JSON.stringify(body),
+    });
+
+    return NextResponse.json(data, { status: 201 });
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      const detail =
+        (error.data as { detail?: string })?.detail || "Registration failed";
+      return NextResponse.json({ detail }, { status: error.status });
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}{% endraw %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/api/conversations/[id]/messages/route.ts

@@ -0,0 +1,41 @@
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+{% raw %}import { NextRequest, NextResponse } from "next/server";
+import { backendFetch, BackendApiError } from "@/lib/server-api";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const accessToken = request.cookies.get("access_token")?.value;
+
+    if (!accessToken) {
+      return NextResponse.json({ detail: "Not authenticated" }, { status: 401 });
+    }
+
+    const { id } = await params;
+
+    const data = await backendFetch(`/api/v1/conversations/${id}/messages`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    return NextResponse.json(data);
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      return NextResponse.json(
+        { detail: error.message || "Failed to fetch messages" },
+        { status: error.status }
+      );
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}{% endraw %}
+{%- else %}
+// Conversation messages API route - not configured (enable_conversation_persistence is false)
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/api/conversations/[id]/route.ts

@@ -0,0 +1,108 @@
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+{% raw %}import { NextRequest, NextResponse } from "next/server";
+import { backendFetch, BackendApiError } from "@/lib/server-api";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+export async function GET(request: NextRequest, { params }: RouteParams) {
+  try {
+    const accessToken = request.cookies.get("access_token")?.value;
+
+    if (!accessToken) {
+      return NextResponse.json({ detail: "Not authenticated" }, { status: 401 });
+    }
+
+    const { id } = await params;
+
+    const data = await backendFetch(`/api/v1/conversations/${id}`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    return NextResponse.json(data);
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      return NextResponse.json(
+        { detail: error.message || "Failed to fetch conversation" },
+        { status: error.status }
+      );
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PATCH(request: NextRequest, { params }: RouteParams) {
+  try {
+    const accessToken = request.cookies.get("access_token")?.value;
+
+    if (!accessToken) {
+      return NextResponse.json({ detail: "Not authenticated" }, { status: 401 });
+    }
+
+    const { id } = await params;
+    const body = await request.json();
+
+    const data = await backendFetch(`/api/v1/conversations/${id}`, {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    return NextResponse.json(data);
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      return NextResponse.json(
+        { detail: error.message || "Failed to update conversation" },
+        { status: error.status }
+      );
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function DELETE(request: NextRequest, { params }: RouteParams) {
+  try {
+    const accessToken = request.cookies.get("access_token")?.value;
+
+    if (!accessToken) {
+      return NextResponse.json({ detail: "Not authenticated" }, { status: 401 });
+    }
+
+    const { id } = await params;
+
+    await backendFetch(`/api/v1/conversations/${id}`, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    return new NextResponse(null, { status: 204 });
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      return NextResponse.json(
+        { detail: error.message || "Failed to delete conversation" },
+        { status: error.status }
+      );
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}{% endraw %}
+{%- else %}
+// Conversation detail API route - not configured (enable_conversation_persistence is false)
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/api/conversations/route.ts

@@ -0,0 +1,73 @@
+{%- if cookiecutter.enable_conversation_persistence and cookiecutter.use_database %}
+{% raw %}import { NextRequest, NextResponse } from "next/server";
+import { backendFetch, BackendApiError } from "@/lib/server-api";
+
+export async function GET(request: NextRequest) {
+  try {
+    const accessToken = request.cookies.get("access_token")?.value;
+
+    if (!accessToken) {
+      return NextResponse.json({ detail: "Not authenticated" }, { status: 401 });
+    }
+
+    const searchParams = request.nextUrl.searchParams;
+    const skip = searchParams.get("skip") || "0";
+    const limit = searchParams.get("limit") || "50";
+
+    const data = await backendFetch(`/api/v1/conversations?skip=${skip}&limit=${limit}`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+
+    return NextResponse.json(data);
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      return NextResponse.json(
+        { detail: error.message || "Failed to fetch conversations" },
+        { status: error.status }
+      );
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const accessToken = request.cookies.get("access_token")?.value;
+
+    if (!accessToken) {
+      return NextResponse.json({ detail: "Not authenticated" }, { status: 401 });
+    }
+
+    const body = await request.json();
+
+    const data = await backendFetch("/api/v1/conversations", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+
+    return NextResponse.json(data, { status: 201 });
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      return NextResponse.json(
+        { detail: error.message || "Failed to create conversation" },
+        { status: error.status }
+      );
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}{% endraw %}
+{%- else %}
+// Conversations API route - not configured (enable_conversation_persistence is false)
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/api/health/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from "next/server";
+import { backendFetch, BackendApiError } from "@/lib/server-api";
+import type { HealthResponse } from "@/types";
+
+export async function GET() {
+  try {
+    const data = await backendFetch<HealthResponse>("/api/v1/health");
+    return NextResponse.json(data);
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      return NextResponse.json(
+        { detail: "Backend service unavailable" },
+        { status: error.status }
+      );
+    }
+    return NextResponse.json(
+      { detail: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/auth/callback/page.tsx

@@ -0,0 +1,96 @@
+{%- if cookiecutter.enable_oauth %}
+"use client";
+
+import { useEffect, useState } from "react";
+import { useRouter, useSearchParams } from "next/navigation";
+import { useAuthStore } from "@/stores/auth-store";
+import { Card, CardContent } from "@/components/ui";
+import { ROUTES } from "@/lib/constants";
+
+export default function AuthCallbackPage() {
+  const router = useRouter();
+  const searchParams = useSearchParams();
+  const [error, setError] = useState<string | null>(null);
+  const { checkAuth } = useAuthStore();
+
+  useEffect(() => {
+    const handleCallback = async () => {
+      const accessToken = searchParams.get("access_token");
+      const refreshToken = searchParams.get("refresh_token");
+      const errorParam = searchParams.get("error");
+
+      if (errorParam) {
+        setError(errorParam);
+        setTimeout(() => {
+          router.push(ROUTES.LOGIN);
+        }, 3000);
+        return;
+      }
+
+      if (accessToken && refreshToken) {
+        // Store tokens - the API route will handle this
+        try {
+          const response = await fetch("/api/auth/oauth-callback", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ accessToken, refreshToken }),
+          });
+
+          if (response.ok) {
+            // Refresh auth state
+            await checkAuth();
+            router.push(ROUTES.DASHBOARD);
+          } else {
+            setError("Failed to complete authentication");
+            setTimeout(() => {
+              router.push(ROUTES.LOGIN);
+            }, 3000);
+          }
+        } catch {
+          setError("Authentication error");
+          setTimeout(() => {
+            router.push(ROUTES.LOGIN);
+          }, 3000);
+        }
+      } else {
+        setError("Missing authentication tokens");
+        setTimeout(() => {
+          router.push(ROUTES.LOGIN);
+        }, 3000);
+      }
+    };
+
+    handleCallback();
+  }, [searchParams, router, checkAuth]);
+
+  return (
+    <div className="min-h-screen flex items-center justify-center">
+      <Card className="w-full max-w-md">
+        <CardContent className="pt-6">
+          {error ? (
+            <div className="text-center">
+              <p className="text-destructive mb-2">{error}</p>
+              <p className="text-sm text-muted-foreground">
+                Redirecting to login...
+              </p>
+            </div>
+          ) : (
+            <div className="text-center">
+              <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary mx-auto mb-4" />
+              <p className="text-muted-foreground">
+                Completing authentication...
+              </p>
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+{%- else %}
+export default function AuthCallbackPage() {
+  return <div>OAuth not enabled</div>;
+}
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/globals.css

@@ -0,0 +1,108 @@
+@import "tailwindcss";
+
+@theme {
+  --color-background: oklch(100% 0 0);
+  --color-foreground: oklch(14.5% 0 0);
+  --color-card: oklch(100% 0 0);
+  --color-card-foreground: oklch(14.5% 0 0);
+  --color-popover: oklch(100% 0 0);
+  --color-popover-foreground: oklch(14.5% 0 0);
+  --color-primary: oklch(20.5% 0 0);
+  --color-primary-foreground: oklch(98.5% 0 0);
+  --color-secondary: oklch(96.5% 0 0);
+  --color-secondary-foreground: oklch(20.5% 0 0);
+  --color-muted: oklch(96.5% 0 0);
+  --color-muted-foreground: oklch(55.6% 0 0);
+  --color-accent: oklch(96.5% 0 0);
+  --color-accent-foreground: oklch(20.5% 0 0);
+  --color-destructive: oklch(57.7% 0.245 27.325);
+  --color-destructive-foreground: oklch(98.5% 0 0);
+  --color-border: oklch(91.4% 0 0);
+  --color-input: oklch(91.4% 0 0);
+  --color-ring: oklch(14.5% 0 0);
+  --radius: 0.5rem;
+}
+
+/* Dark theme - triggered by system preference or .dark class */
+@media (prefers-color-scheme: dark) {
+  :root:not(.light) {
+    --color-background: oklch(14.5% 0 0);
+    --color-foreground: oklch(98.5% 0 0);
+    --color-card: oklch(14.5% 0 0);
+    --color-card-foreground: oklch(98.5% 0 0);
+    --color-popover: oklch(14.5% 0 0);
+    --color-popover-foreground: oklch(98.5% 0 0);
+    --color-primary: oklch(98.5% 0 0);
+    --color-primary-foreground: oklch(20.5% 0 0);
+    --color-secondary: oklch(26.9% 0 0);
+    --color-secondary-foreground: oklch(98.5% 0 0);
+    --color-muted: oklch(26.9% 0 0);
+    --color-muted-foreground: oklch(70.7% 0 0);
+    --color-accent: oklch(26.9% 0 0);
+    --color-accent-foreground: oklch(98.5% 0 0);
+    --color-destructive: oklch(57.7% 0.245 27.325);
+    --color-destructive-foreground: oklch(98.5% 0 0);
+    --color-border: oklch(26.9% 0 0);
+    --color-input: oklch(26.9% 0 0);
+    --color-ring: oklch(83.9% 0 0);
+  }
+}
+
+/* Manual dark mode via .dark class */
+:root.dark {
+  --color-background: oklch(14.5% 0 0);
+  --color-foreground: oklch(98.5% 0 0);
+  --color-card: oklch(14.5% 0 0);
+  --color-card-foreground: oklch(98.5% 0 0);
+  --color-popover: oklch(14.5% 0 0);
+  --color-popover-foreground: oklch(98.5% 0 0);
+  --color-primary: oklch(98.5% 0 0);
+  --color-primary-foreground: oklch(20.5% 0 0);
+  --color-secondary: oklch(26.9% 0 0);
+  --color-secondary-foreground: oklch(98.5% 0 0);
+  --color-muted: oklch(26.9% 0 0);
+  --color-muted-foreground: oklch(70.7% 0 0);
+  --color-accent: oklch(26.9% 0 0);
+  --color-accent-foreground: oklch(98.5% 0 0);
+  --color-destructive: oklch(57.7% 0.245 27.325);
+  --color-destructive-foreground: oklch(98.5% 0 0);
+  --color-border: oklch(26.9% 0 0);
+  --color-input: oklch(26.9% 0 0);
+  --color-ring: oklch(83.9% 0 0);
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+
+/* Custom scrollbar */
+@layer utilities {
+  .scrollbar-thin {
+    scrollbar-width: thin;
+    scrollbar-color: oklch(50% 0 0 / 0.3) transparent;
+  }
+
+  .scrollbar-thin::-webkit-scrollbar {
+    width: 6px;
+    height: 6px;
+  }
+
+  .scrollbar-thin::-webkit-scrollbar-track {
+    background: transparent;
+    border-radius: 3px;
+  }
+
+  .scrollbar-thin::-webkit-scrollbar-thumb {
+    background: oklch(50% 0 0 / 0.3);
+    border-radius: 3px;
+  }
+
+  .scrollbar-thin::-webkit-scrollbar-thumb:hover {
+    background: oklch(50% 0 0 / 0.5);
+  }
+}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/layout.tsx

@@ -0,0 +1,25 @@
+import type { Metadata } from "next";
+import { Inter } from "next/font/google";
+import "./globals.css";
+import { Providers } from "./providers";
+
+const inter = Inter({ subsets: ["latin"] });
+
+export const metadata: Metadata = {
+  title: "{{ cookiecutter.project_name }}",
+  description: "{{ cookiecutter.project_description }}",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <body className={inter.className}>
+        <Providers>{children}</Providers>
+      </body>
+    </html>
+  );
+}