fastapi-fullstack 0.1.7__py3-none-any.whl

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/e2e/auth.spec.ts

@@ -0,0 +1,134 @@
+{%- if cookiecutter.use_frontend and cookiecutter.use_jwt %}
+import { test, expect } from "@playwright/test";
+
+test.describe("Authentication", () => {
+  test.describe("Login Page", () => {
+    test("should display login form", async ({ page }) => {
+      await page.goto("/login");
+
+      // Check for login form elements
+      await expect(page.getByRole("heading", { name: /sign in|log in/i })).toBeVisible();
+      await expect(page.getByLabel(/email/i)).toBeVisible();
+      await expect(page.getByLabel(/password/i)).toBeVisible();
+      await expect(page.getByRole("button", { name: /sign in|log in/i })).toBeVisible();
+    });
+
+    test("should show validation errors for empty form", async ({ page }) => {
+      await page.goto("/login");
+
+      // Submit empty form
+      await page.getByRole("button", { name: /sign in|log in/i }).click();
+
+      // Should show validation errors
+      await expect(page.getByText(/required|invalid/i)).toBeVisible();
+    });
+
+    test("should show error for invalid credentials", async ({ page }) => {
+      await page.goto("/login");
+
+      // Fill in invalid credentials
+      await page.getByLabel(/email/i).fill("invalid@example.com");
+      await page.getByLabel(/password/i).fill("wrongpassword");
+      await page.getByRole("button", { name: /sign in|log in/i }).click();
+
+      // Should show error message
+      await expect(
+        page.getByText(/invalid|incorrect|failed|error/i)
+      ).toBeVisible({ timeout: 5000 });
+    });
+
+    test("should have link to registration", async ({ page }) => {
+      await page.goto("/login");
+
+      // Should have link to register page
+      const registerLink = page.getByRole("link", { name: /sign up|register|create account/i });
+      await expect(registerLink).toBeVisible();
+    });
+  });
+
+  test.describe("Registration Page", () => {
+    test("should display registration form", async ({ page }) => {
+      await page.goto("/register");
+
+      // Check for registration form elements
+      await expect(page.getByRole("heading", { name: /sign up|register|create/i })).toBeVisible();
+      await expect(page.getByLabel(/email/i)).toBeVisible();
+      await expect(page.getByLabel(/password/i).first()).toBeVisible();
+      await expect(page.getByRole("button", { name: /sign up|register|create/i })).toBeVisible();
+    });
+
+    test("should validate password requirements", async ({ page }) => {
+      await page.goto("/register");
+
+      // Fill in weak password
+      await page.getByLabel(/email/i).fill("newuser@example.com");
+      await page.getByLabel(/password/i).first().fill("weak");
+
+      // Should show password requirements error
+      await page.getByRole("button", { name: /sign up|register|create/i }).click();
+      await expect(page.getByText(/password|characters|strong/i)).toBeVisible();
+    });
+
+    test("should have link to login", async ({ page }) => {
+      await page.goto("/register");
+
+      // Should have link to login page
+      const loginLink = page.getByRole("link", { name: /sign in|log in|already have/i });
+      await expect(loginLink).toBeVisible();
+    });
+  });
+
+  test.describe("Authenticated User", () => {
+    // Use authenticated state from setup
+    test.use({
+      storageState: ".playwright/.auth/user.json",
+    });
+
+    test("should redirect to dashboard after login", async ({ page }) => {
+      await page.goto("/");
+
+      // Should be redirected to dashboard or see dashboard content
+      await expect(page).toHaveURL(/dashboard|home/i);
+    });
+
+    test("should show user menu or profile", async ({ page }) => {
+      await page.goto("/dashboard");
+
+      // Should have user profile/menu element
+      await expect(
+        page.getByRole("button", { name: /profile|account|user/i }).or(
+          page.getByText(/@|user/i)
+        )
+      ).toBeVisible();
+    });
+
+    test("should be able to logout", async ({ page }) => {
+      await page.goto("/dashboard");
+
+      // Find and click logout button
+      const logoutButton = page.getByRole("button", { name: /log out|sign out/i }).or(
+        page.getByRole("link", { name: /log out|sign out/i })
+      );
+
+      if (await logoutButton.isVisible()) {
+        await logoutButton.click();
+
+        // Should be redirected to login or home
+        await expect(page).toHaveURL(/login|\/$/);
+      }
+    });
+  });
+});
+{%- elif cookiecutter.use_frontend %}
+import { test, expect } from "@playwright/test";
+
+test.describe("Public Access", () => {
+  test("should allow public access to main page", async ({ page }) => {
+    await page.goto("/");
+    await expect(page.getByRole("main")).toBeVisible();
+  });
+});
+{%- else %}
+/* Auth tests - frontend not configured */
+export {};
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/e2e/chat.spec.ts

@@ -0,0 +1,207 @@
+{%- if cookiecutter.use_frontend and cookiecutter.enable_ai_agent %}
+import { test, expect } from "@playwright/test";
+
+test.describe("AI Chat", () => {
+{%- if cookiecutter.use_jwt %}
+  // Use authenticated state
+  test.use({
+    storageState: ".playwright/.auth/user.json",
+  });
+{%- endif %}
+
+  test.beforeEach(async ({ page }) => {
+    await page.goto("/chat");
+  });
+
+  test.describe("Chat Interface", () => {
+    test("should display chat container", async ({ page }) => {
+      // Chat container should be visible
+      await expect(page.getByRole("main")).toBeVisible();
+
+      // Input should be present
+      const input = page.getByRole("textbox", { name: /message|type|ask/i }).or(
+        page.getByPlaceholder(/message|type|ask/i)
+      );
+      await expect(input).toBeVisible();
+    });
+
+    test("should have send button", async ({ page }) => {
+      const sendButton = page.getByRole("button", { name: /send|submit/i }).or(
+        page.locator('button[type="submit"]')
+      );
+      await expect(sendButton).toBeVisible();
+    });
+
+    test("should allow typing a message", async ({ page }) => {
+      const input = page.getByRole("textbox").first();
+      await input.fill("Hello, AI assistant!");
+      await expect(input).toHaveValue("Hello, AI assistant!");
+    });
+  });
+
+  test.describe("Chat Functionality", () => {
+    test("should send message and receive response", async ({ page }) => {
+      const input = page.getByRole("textbox").first();
+      const sendButton = page.getByRole("button", { name: /send|submit/i }).or(
+        page.locator('button[type="submit"]')
+      );
+
+      // Send a message
+      await input.fill("Hello!");
+      await sendButton.click();
+
+      // User message should appear in chat
+      await expect(page.getByText("Hello!")).toBeVisible();
+
+      // Wait for AI response (with reasonable timeout)
+      await expect(
+        page.locator("[data-role='assistant']").or(
+          page.getByText(/thinking|processing/i)
+        )
+      ).toBeVisible({ timeout: 30000 });
+    });
+
+    test("should show loading state while waiting for response", async ({ page }) => {
+      const input = page.getByRole("textbox").first();
+      const sendButton = page.getByRole("button", { name: /send|submit/i }).or(
+        page.locator('button[type="submit"]')
+      );
+
+      // Send a message
+      await input.fill("What is 2 + 2?");
+      await sendButton.click();
+
+      // Should show some loading indicator
+      await expect(
+        page.getByText(/thinking|loading|processing/i).or(
+          page.locator(".animate-pulse, .animate-spin")
+        )
+      ).toBeVisible();
+    });
+
+    test("should clear input after sending", async ({ page }) => {
+      const input = page.getByRole("textbox").first();
+      const sendButton = page.getByRole("button", { name: /send|submit/i }).or(
+        page.locator('button[type="submit"]')
+      );
+
+      await input.fill("Test message");
+      await sendButton.click();
+
+      // Input should be cleared
+      await expect(input).toHaveValue("");
+    });
+  });
+
+  test.describe("Message Display", () => {
+    test("should display user messages correctly", async ({ page }) => {
+      const input = page.getByRole("textbox").first();
+      const sendButton = page.getByRole("button", { name: /send|submit/i }).or(
+        page.locator('button[type="submit"]')
+      );
+
+      await input.fill("My test message");
+      await sendButton.click();
+
+      // Message should be styled as user message
+      const userMessage = page.locator("[data-role='user']").or(
+        page.getByText("My test message")
+      );
+      await expect(userMessage).toBeVisible();
+    });
+
+    test("should support multiple messages", async ({ page }) => {
+      const input = page.getByRole("textbox").first();
+      const sendButton = page.getByRole("button", { name: /send|submit/i }).or(
+        page.locator('button[type="submit"]')
+      );
+
+      // Send first message
+      await input.fill("First message");
+      await sendButton.click();
+      await expect(page.getByText("First message")).toBeVisible();
+
+      // Wait for response
+      await page.waitForTimeout(1000);
+
+      // Send second message
+      await input.fill("Second message");
+      await sendButton.click();
+      await expect(page.getByText("Second message")).toBeVisible();
+
+      // Both messages should be visible
+      await expect(page.getByText("First message")).toBeVisible();
+      await expect(page.getByText("Second message")).toBeVisible();
+    });
+  });
+
+  test.describe("Keyboard Navigation", () => {
+    test("should send message on Enter key", async ({ page }) => {
+      const input = page.getByRole("textbox").first();
+
+      await input.fill("Keyboard test");
+      await input.press("Enter");
+
+      // Message should be sent
+      await expect(page.getByText("Keyboard test")).toBeVisible();
+    });
+
+    test("should support Shift+Enter for new line", async ({ page }) => {
+      const input = page.getByRole("textbox").first();
+
+      await input.fill("Line 1");
+      await input.press("Shift+Enter");
+      await input.type("Line 2");
+
+      // Should contain multiline text (behavior may vary)
+      const value = await input.inputValue();
+      expect(value).toContain("Line 1");
+    });
+  });
+});
+
+{%- if cookiecutter.enable_conversation_persistence %}
+test.describe("Conversation Persistence", () => {
+{%- if cookiecutter.use_jwt %}
+  test.use({
+    storageState: ".playwright/.auth/user.json",
+  });
+{%- endif %}
+
+  test("should show conversation list", async ({ page }) => {
+    await page.goto("/chat");
+
+    // Should have some way to view conversation history
+    const conversationList = page.getByRole("list").or(
+      page.locator("[data-testid='conversation-list']")
+    );
+    // List may or may not be visible depending on UI
+  });
+
+  test("should create new conversation", async ({ page }) => {
+    await page.goto("/chat");
+
+    // Find new conversation button
+    const newChatButton = page.getByRole("button", { name: /new|create/i }).or(
+      page.getByText(/new chat/i)
+    );
+
+    if (await newChatButton.isVisible()) {
+      await newChatButton.click();
+      // Should start a new conversation
+    }
+  });
+});
+{%- endif %}
+{%- elif cookiecutter.use_frontend %}
+import { test, expect } from "@playwright/test";
+
+test.describe("Chat", () => {
+  test.skip("AI agent not enabled", async () => {
+    // Skip chat tests when AI agent is not configured
+  });
+});
+{%- else %}
+/* Chat tests - frontend not configured */
+export {};
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/e2e/home.spec.ts

@@ -0,0 +1,73 @@
+{%- if cookiecutter.use_frontend %}
+import { test, expect } from "@playwright/test";
+
+test.describe("Home Page", () => {
+  test("should load the home page", async ({ page }) => {
+    await page.goto("/");
+    await expect(page).toHaveTitle(/{{ cookiecutter.project_name }}/i);
+  });
+
+  test("should have navigation elements", async ({ page }) => {
+    await page.goto("/");
+
+    // Check for main navigation elements
+    const nav = page.getByRole("navigation");
+    await expect(nav).toBeVisible();
+  });
+
+  test("should be accessible", async ({ page }) => {
+    await page.goto("/");
+
+    // Basic accessibility checks
+    // Main landmark should exist
+    await expect(page.getByRole("main")).toBeVisible();
+
+    // Page should have a heading
+    const heading = page.getByRole("heading", { level: 1 });
+    await expect(heading).toBeVisible();
+  });
+});
+
+test.describe("Navigation", () => {
+{%- if cookiecutter.use_jwt %}
+  test("unauthenticated user should see login link", async ({ page }) => {
+    // Clear any stored auth state
+    await page.context().clearCookies();
+    await page.goto("/");
+
+    // Should have login/sign in link
+    const loginLink = page.getByRole("link", { name: /log in|sign in/i });
+    await expect(loginLink).toBeVisible();
+  });
+{%- endif %}
+
+  test("should navigate between pages", async ({ page }) => {
+    await page.goto("/");
+
+    // Test navigation to different sections
+    const links = await page.getByRole("link").all();
+    expect(links.length).toBeGreaterThan(0);
+  });
+});
+
+test.describe("Responsive Design", () => {
+  test("should work on mobile viewport", async ({ page }) => {
+    await page.setViewportSize({ width: 375, height: 667 });
+    await page.goto("/");
+
+    // Page should still be functional
+    await expect(page.getByRole("main")).toBeVisible();
+  });
+
+  test("should work on tablet viewport", async ({ page }) => {
+    await page.setViewportSize({ width: 768, height: 1024 });
+    await page.goto("/");
+
+    // Page should still be functional
+    await expect(page.getByRole("main")).toBeVisible();
+  });
+});
+{%- else %}
+/* Home tests - frontend not configured */
+export {};
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/instrumentation.ts

@@ -0,0 +1,14 @@
+{%- if cookiecutter.enable_logfire %}
+import { registerOTel } from "@vercel/otel";
+
+export function register() {
+  registerOTel({
+    serviceName: "{{ cookiecutter.project_slug }}-frontend",
+  });
+}
+{%- else %}
+// Logfire/OpenTelemetry instrumentation is disabled
+export function register() {
+  // No-op when Logfire is disabled
+}
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/messages/en.json

@@ -0,0 +1,84 @@
+{%- if cookiecutter.enable_i18n %}
+{
+  "common": {
+    "loading": "Loading...",
+    "error": "Error",
+    "success": "Success",
+    "save": "Save",
+    "cancel": "Cancel",
+    "delete": "Delete",
+    "edit": "Edit",
+    "create": "Create",
+    "search": "Search",
+    "back": "Back",
+    "next": "Next",
+    "previous": "Previous",
+    "submit": "Submit",
+    "close": "Close",
+    "confirm": "Confirm",
+    "yes": "Yes",
+    "no": "No"
+  },
+  "navigation": {
+    "home": "Home",
+    "dashboard": "Dashboard",
+    "profile": "Profile",
+    "settings": "Settings",
+    "logout": "Logout"
+  },
+  "auth": {
+    "login": "Login",
+    "register": "Register",
+    "email": "Email",
+    "password": "Password",
+    "confirmPassword": "Confirm Password",
+    "forgotPassword": "Forgot Password?",
+    "noAccount": "Don't have an account?",
+    "hasAccount": "Already have an account?",
+    "loginSuccess": "Successfully logged in",
+    "registerSuccess": "Account created successfully",
+    "logoutSuccess": "Successfully logged out",
+    "invalidCredentials": "Invalid email or password",
+    "emailRequired": "Email is required",
+    "passwordRequired": "Password is required",
+    "passwordMismatch": "Passwords do not match",
+    "continueWithGoogle": "Continue with Google"
+  },
+  "profile": {
+    "title": "Profile",
+    "personalInfo": "Personal Information",
+    "name": "Name",
+    "email": "Email",
+    "changePassword": "Change Password",
+    "currentPassword": "Current Password",
+    "newPassword": "New Password",
+    "updateProfile": "Update Profile",
+    "deleteAccount": "Delete Account",
+    "deleteAccountWarning": "This action cannot be undone. All your data will be permanently deleted."
+  },
+  "chat": {
+    "title": "Chat",
+    "newChat": "New Chat",
+    "sendMessage": "Send a message...",
+    "thinking": "Thinking...",
+    "noConversations": "No conversations yet",
+    "startNewChat": "Start a new chat",
+    "deleteConversation": "Delete conversation",
+    "archiveConversation": "Archive conversation",
+    "renameConversation": "Rename conversation"
+  },
+  "errors": {
+    "generic": "Something went wrong",
+    "notFound": "Page not found",
+    "unauthorized": "You are not authorized to view this page",
+    "forbidden": "Access forbidden",
+    "serverError": "Server error. Please try again later.",
+    "networkError": "Network error. Please check your connection."
+  },
+  "footer": {
+    "copyright": "All rights reserved"
+  }
+}
+{%- else %}
+{}
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/messages/pl.json

@@ -0,0 +1,84 @@
+{%- if cookiecutter.enable_i18n %}
+{
+  "common": {
+    "loading": "Ładowanie...",
+    "error": "Błąd",
+    "success": "Sukces",
+    "save": "Zapisz",
+    "cancel": "Anuluj",
+    "delete": "Usuń",
+    "edit": "Edytuj",
+    "create": "Utwórz",
+    "search": "Szukaj",
+    "back": "Wstecz",
+    "next": "Dalej",
+    "previous": "Wstecz",
+    "submit": "Wyślij",
+    "close": "Zamknij",
+    "confirm": "Potwierdź",
+    "yes": "Tak",
+    "no": "Nie"
+  },
+  "navigation": {
+    "home": "Strona główna",
+    "dashboard": "Panel",
+    "profile": "Profil",
+    "settings": "Ustawienia",
+    "logout": "Wyloguj"
+  },
+  "auth": {
+    "login": "Zaloguj się",
+    "register": "Zarejestruj się",
+    "email": "Email",
+    "password": "Hasło",
+    "confirmPassword": "Potwierdź hasło",
+    "forgotPassword": "Zapomniałeś hasła?",
+    "noAccount": "Nie masz konta?",
+    "hasAccount": "Masz już konto?",
+    "loginSuccess": "Zalogowano pomyślnie",
+    "registerSuccess": "Konto utworzone pomyślnie",
+    "logoutSuccess": "Wylogowano pomyślnie",
+    "invalidCredentials": "Nieprawidłowy email lub hasło",
+    "emailRequired": "Email jest wymagany",
+    "passwordRequired": "Hasło jest wymagane",
+    "passwordMismatch": "Hasła nie są takie same",
+    "continueWithGoogle": "Kontynuuj z Google"
+  },
+  "profile": {
+    "title": "Profil",
+    "personalInfo": "Dane osobowe",
+    "name": "Imię",
+    "email": "Email",
+    "changePassword": "Zmień hasło",
+    "currentPassword": "Obecne hasło",
+    "newPassword": "Nowe hasło",
+    "updateProfile": "Zaktualizuj profil",
+    "deleteAccount": "Usuń konto",
+    "deleteAccountWarning": "Tej akcji nie można cofnąć. Wszystkie Twoje dane zostaną trwale usunięte."
+  },
+  "chat": {
+    "title": "Czat",
+    "newChat": "Nowy czat",
+    "sendMessage": "Napisz wiadomość...",
+    "thinking": "Myślę...",
+    "noConversations": "Brak konwersacji",
+    "startNewChat": "Rozpocznij nowy czat",
+    "deleteConversation": "Usuń konwersację",
+    "archiveConversation": "Archiwizuj konwersację",
+    "renameConversation": "Zmień nazwę konwersacji"
+  },
+  "errors": {
+    "generic": "Coś poszło nie tak",
+    "notFound": "Strona nie znaleziona",
+    "unauthorized": "Nie masz uprawnień do wyświetlenia tej strony",
+    "forbidden": "Dostęp zabroniony",
+    "serverError": "Błąd serwera. Spróbuj ponownie później.",
+    "networkError": "Błąd sieci. Sprawdź połączenie."
+  },
+  "footer": {
+    "copyright": "Wszelkie prawa zastrzeżone"
+  }
+}
+{%- else %}
+{}
+{%- endif %}

fastapi_gen/template/{{cookiecutter.project_slug}}/frontend/next.config.ts

@@ -0,0 +1,76 @@
+import type { NextConfig } from "next";
+{%- if cookiecutter.enable_i18n %}
+import createNextIntlPlugin from 'next-intl/plugin';
+
+const withNextIntl = createNextIntlPlugin('./src/i18n.ts');
+{%- endif %}
+
+// Content Security Policy directives
+const ContentSecurityPolicy = `
+  default-src 'self';
+  script-src 'self' 'unsafe-eval' 'unsafe-inline';
+  style-src 'self' 'unsafe-inline';
+  img-src 'self' blob: data: https:;
+  font-src 'self' data:;
+  connect-src 'self' ws: wss: http://localhost:* https://localhost:*;
+  frame-ancestors 'none';
+  base-uri 'self';
+  form-action 'self';
+`.replace(/\n/g, " ").trim();
+
+const securityHeaders = [
+  {
+    key: "Content-Security-Policy",
+    value: ContentSecurityPolicy,
+  },
+  {
+    key: "X-Content-Type-Options",
+    value: "nosniff",
+  },
+  {
+    key: "X-Frame-Options",
+    value: "DENY",
+  },
+  {
+    key: "X-XSS-Protection",
+    value: "1; mode=block",
+  },
+  {
+    key: "Referrer-Policy",
+    value: "strict-origin-when-cross-origin",
+  },
+  {
+    key: "Permissions-Policy",
+    value: "camera=(), microphone=(), geolocation=()",
+  },
+];
+
+const nextConfig: NextConfig = {
+  output: "standalone",
+
+  // Security headers
+  async headers() {
+    return [
+      {
+        source: "/(.*)",
+        headers: securityHeaders,
+      },
+    ];
+  },
+
+  // Environment variables available on the server side only
+  serverRuntimeConfig: {
+    apiUrl: process.env.BACKEND_URL || "http://localhost:{{ cookiecutter.backend_port }}",
+  },
+
+  // Environment variables available on both server and client
+  publicRuntimeConfig: {
+    appName: "{{ cookiecutter.project_name }}",
+  },
+};
+
+{%- if cookiecutter.enable_i18n %}
+export default withNextIntl(nextConfig);
+{%- else %}
+export default nextConfig;
+{%- endif %}