fastapi-fullstack 0.1.7__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/src/app/[locale]/page.tsx

@@ -0,0 +1,73 @@
+import Link from "next/link";
+import { Button, Card, CardHeader, CardTitle, CardContent } from "@/components/ui";
+import { ROUTES } from "@/lib/constants";
+
+export default function HomePage() {
+  return (
+    <div className="min-h-screen bg-background">
+      <div className="container mx-auto py-16 px-4">
+        <div className="text-center mb-12">
+          <h1 className="text-4xl font-bold mb-4">
+            {{ cookiecutter.project_name }}
+          </h1>
+          <p className="text-xl text-muted-foreground max-w-2xl mx-auto">
+            {{ cookiecutter.project_description }}
+          </p>
+        </div>
+
+        <div className="grid gap-6 md:grid-cols-2 lg:grid-cols-3 max-w-5xl mx-auto">
+          {% if cookiecutter.use_jwt %}
+          <Card>
+            <CardHeader>
+              <CardTitle>Authentication</CardTitle>
+            </CardHeader>
+            <CardContent>
+              <p className="mb-4 text-muted-foreground">
+                Secure JWT-based authentication system
+              </p>
+              <div className="flex gap-2">
+                <Button asChild>
+                  <Link href={ROUTES.LOGIN}>Login</Link>
+                </Button>
+                <Button variant="outline" asChild>
+                  <Link href={ROUTES.REGISTER}>Register</Link>
+                </Button>
+              </div>
+            </CardContent>
+          </Card>
+          {% endif %}
+
+          {% if cookiecutter.enable_ai_agent %}
+          <Card>
+            <CardHeader>
+              <CardTitle>AI Assistant</CardTitle>
+            </CardHeader>
+            <CardContent>
+              <p className="mb-4 text-muted-foreground">
+                Chat with our AI assistant powered by PydanticAI
+              </p>
+              <Button asChild>
+                <Link href={ROUTES.CHAT}>Start Chat</Link>
+              </Button>
+            </CardContent>
+          </Card>
+          {% endif %}
+
+          <Card>
+            <CardHeader>
+              <CardTitle>Dashboard</CardTitle>
+            </CardHeader>
+            <CardContent>
+              <p className="mb-4 text-muted-foreground">
+                View your dashboard and manage your account
+              </p>
+              <Button variant="outline" asChild>
+                <Link href={ROUTES.DASHBOARD}>Go to Dashboard</Link>
+              </Button>
+            </CardContent>
+          </Card>
+        </div>
+      </div>
+    </div>
+  );
+}

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

@@ -0,0 +1,58 @@
+{% raw %}import { NextRequest, NextResponse } from "next/server";
+import { backendFetch, BackendApiError } from "@/lib/server-api";
+import type { LoginResponse } from "@/types";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+
+    // Backend expects OAuth2 form data format
+    const formData = new URLSearchParams();
+    formData.append("username", body.email);
+    formData.append("password", body.password);
+
+    const data = await backendFetch<LoginResponse>("/api/v1/auth/login", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: formData.toString(),
+    });
+
+    // Set HTTP-only cookies for tokens
+    const response = NextResponse.json({
+      user: data.user,
+      message: "Login successful",
+    });
+
+    // Set access token cookie (short-lived)
+    response.cookies.set("access_token", data.access_token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      maxAge: 60 * 15, // 15 minutes
+      path: "/",
+    });
+
+    // Set refresh token cookie (long-lived)
+    response.cookies.set("refresh_token", data.refresh_token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "lax",
+      maxAge: 60 * 60 * 24 * 7, // 7 days
+      path: "/",
+    });
+
+    return response;
+  } catch (error) {
+    if (error instanceof BackendApiError) {
+      const detail =
+        (error.data as { detail?: string })?.detail || "Login 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/auth/logout/route.ts

@@ -0,0 +1,24 @@
+import { NextResponse } from "next/server";
+
+export async function POST() {
+  const response = NextResponse.json({ message: "Logged out successfully" });
+
+  // Clear auth cookies
+  response.cookies.set("access_token", "", {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax",
+    maxAge: 0,
+    path: "/",
+  });
+
+  response.cookies.set("refresh_token", "", {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax",
+    maxAge: 0,
+    path: "/",
+  });
+
+  return response;
+}

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 }
+    );
+  }
+}