nextjs-hackathon-stack 0.1.11 → 0.1.13

package/template/src/features/auth/__tests__/login.action.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mockSignInWithPassword = vi.fn();
+const mockRedirect = vi.fn();
+
+vi.mock("@/shared/lib/supabase/server", () => ({
+  createClient: vi.fn(() =>
+    Promise.resolve({
+      auth: { signInWithPassword: mockSignInWithPassword },
+    })
+  ),
+}));
+
+vi.mock("next/navigation", () => ({
+  redirect: (url: string) => mockRedirect(url),
+}));
+
+describe("loginAction", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns error when email is invalid", async () => {
+    // Arrange
+    const { loginAction } = await import("../actions/login.action");
+    const fd = new FormData();
+    fd.set("email", "not-an-email");
+    fd.set("password", "password123");
+
+    // Act
+    const result = await loginAction({ status: "idle" }, fd);
+
+    // Assert
+    expect(result.status).toBe("error");
+  });
+
+  it("returns error when password is too short", async () => {
+    // Arrange
+    const { loginAction } = await import("../actions/login.action");
+    const fd = new FormData();
+    fd.set("email", "user@example.com");
+    fd.set("password", "short");
+
+    // Act
+    const result = await loginAction({ status: "idle" }, fd);
+
+    // Assert
+    expect(result.status).toBe("error");
+  });
+
+  it("returns error on auth failure", async () => {
+    // Arrange
+    mockSignInWithPassword.mockResolvedValue({
+      error: { message: "Invalid credentials" },
+    });
+    const { loginAction } = await import("../actions/login.action");
+    const fd = new FormData();
+    fd.set("email", "user@example.com");
+    fd.set("password", "password123");
+
+    // Act
+    const result = await loginAction({ status: "idle" }, fd);
+
+    // Assert
+    expect(result).toEqual({ status: "error", message: "Invalid credentials" });
+  });
+
+  it("redirects to / on successful login", async () => {
+    // Arrange
+    mockSignInWithPassword.mockResolvedValue({ error: null });
+    const { loginAction } = await import("../actions/login.action");
+    const fd = new FormData();
+    fd.set("email", "user@example.com");
+    fd.set("password", "password123");
+
+    // Act
+    await loginAction({ status: "idle" }, fd);
+
+    // Assert
+    expect(mockRedirect).toHaveBeenCalledWith("/");
+  });
+});

package/template/src/features/auth/__tests__/logout.action.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mockSignOut = vi.fn();
+const mockRedirect = vi.fn();
+
+vi.mock("@/shared/lib/supabase/server", () => ({
+  createClient: vi.fn(() =>
+    Promise.resolve({
+      auth: { signOut: mockSignOut },
+    })
+  ),
+}));
+
+vi.mock("next/navigation", () => ({
+  redirect: (url: string) => mockRedirect(url),
+}));
+
+describe("logoutAction", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSignOut.mockResolvedValue({});
+  });
+
+  it("calls signOut and redirects to /login", async () => {
+    const { logoutAction } = await import("../actions/logout.action");
+
+    await logoutAction();
+
+    expect(mockSignOut).toHaveBeenCalled();
+    expect(mockRedirect).toHaveBeenCalledWith("/login");
+  });
+});

package/template/src/features/auth/actions/login.action.ts

@@ -25,7 +25,7 @@ export async function loginAction(
   });
 
   if (!parsed.success) {
-    return { status: "error", message: parsed.error.issues[0]?.message ?? "Invalid input" };
+    return { status: "error", message: parsed.error.issues[0]!.message };
   }
 
   const supabase = await createClient();

package/template/src/features/auth/components/login-form.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { zodResolver } from "@hookform/resolvers/zod";
-import { useActionState } from "react";
+import { useActionState, useTransition } from "react";
 import { useForm } from "react-hook-form";
 import { z } from "zod";
 
@@ -22,7 +22,8 @@ type FormValues = z.infer<typeof schema>;
 const initialState: LoginActionState = { status: "idle" };
 
 export function LoginForm() {
-  const [state, formAction, isPending] = useActionState(loginAction, initialState);
+  const [state, formAction] = useActionState(loginAction, initialState);
+  const [isPending, startTransition] = useTransition();
 
   const {
     register,
@@ -34,7 +35,7 @@ export function LoginForm() {
     const fd = new FormData();
     fd.set("email", data.email);
     fd.set("password", data.password);
-    formAction(fd);
+    startTransition(() => formAction(fd));
   });
 
   return (

package/template/src/features/chat/__tests__/chat-ui.test.tsx

@@ -3,29 +3,119 @@ import { describe, it, expect, vi } from "vitest";
 
 import { ChatUi } from "../components/chat-ui";
 
+const mockUseChat = vi.fn(() => ({
+  messages: [] as { id: string; role: string; content: string }[],
+  input: "",
+  handleInputChange: vi.fn(),
+  handleSubmit: vi.fn(),
+  status: "idle",
+}));
+
 vi.mock("@ai-sdk/react", () => ({
-  useChat: vi.fn(() => ({
-    messages: [],
-    input: "",
-    handleInputChange: vi.fn(),
-    handleSubmit: vi.fn(),
-    isLoading: false,
-  })),
+  useChat: (...args: unknown[]) => mockUseChat(...args),
 }));
 
 describe("ChatUi", () => {
   it("renders chat input", () => {
+    // Arrange + Act
     render(<ChatUi />);
+
+    // Assert
     expect(screen.getByTestId("chat-input")).toBeInTheDocument();
   });
 
   it("renders send button", () => {
+    // Arrange + Act
     render(<ChatUi />);
+
+    // Assert
     expect(screen.getByRole("button", { name: /send/i })).toBeInTheDocument();
   });
 
   it("renders messages list area", () => {
+    // Arrange + Act
     render(<ChatUi />);
+
+    // Assert
     expect(screen.getByTestId("chat-ui")).toBeInTheDocument();
   });
+
+  it("renders user and assistant messages", () => {
+    // Arrange
+    mockUseChat.mockReturnValueOnce({
+      messages: [
+        { id: "1", role: "user", content: "Hello" },
+        { id: "2", role: "assistant", content: "Hi there!" },
+      ],
+      input: "",
+      handleInputChange: vi.fn(),
+      handleSubmit: vi.fn(),
+      status: "idle",
+    });
+
+    // Act
+    render(<ChatUi />);
+
+    // Assert
+    expect(screen.getByText("Hello")).toBeInTheDocument();
+    expect(screen.getByText("Hi there!")).toBeInTheDocument();
+  });
+
+  it("shows loading indicator when status is streaming", () => {
+    // Arrange
+    mockUseChat.mockReturnValueOnce({
+      messages: [],
+      input: "",
+      handleInputChange: vi.fn(),
+      handleSubmit: vi.fn(),
+      status: "streaming",
+    });
+
+    // Act
+    render(<ChatUi />);
+
+    // Assert
+    expect(screen.getByText(/thinking/i)).toBeInTheDocument();
+  });
+
+  it("shows loading indicator when status is submitted", () => {
+    // Arrange
+    mockUseChat.mockReturnValueOnce({
+      messages: [],
+      input: "",
+      handleInputChange: vi.fn(),
+      handleSubmit: vi.fn(),
+      status: "submitted",
+    });
+
+    // Act
+    render(<ChatUi />);
+
+    // Assert
+    expect(screen.getByText(/thinking/i)).toBeInTheDocument();
+  });
+
+  it("strips <think> tags from message content", () => {
+    // Arrange
+    mockUseChat.mockReturnValueOnce({
+      messages: [
+        {
+          id: "1",
+          role: "assistant",
+          content: "<think>internal reasoning</think>Visible answer",
+        },
+      ],
+      input: "",
+      handleInputChange: vi.fn(),
+      handleSubmit: vi.fn(),
+      status: "idle",
+    });
+
+    // Act
+    render(<ChatUi />);
+
+    // Assert
+    expect(screen.getByText("Visible answer")).toBeInTheDocument();
+    expect(screen.queryByText(/internal reasoning/)).not.toBeInTheDocument();
+  });
 });

package/template/src/features/chat/__tests__/route.test.ts

@@ -1,8 +1,13 @@
 import { describe, it, expect, vi } from "vitest";
 
+let capturedGetErrorMessage: ((error: unknown) => string) | undefined;
+
 vi.mock("ai", () => ({
   streamText: vi.fn(() => ({
-    toDataStreamResponse: vi.fn(() => new Response("data: done\n\n")),
+    toDataStreamResponse: vi.fn((opts?: { getErrorMessage?: (e: unknown) => string }) => {
+      capturedGetErrorMessage = opts?.getErrorMessage;
+      return new Response("data: done\n\n");
+    }),
   })),
 }));
 
@@ -11,9 +16,67 @@ vi.mock("@/shared/lib/ai", () => ({
 }));
 
 describe("chat route", () => {
-  it("module is importable", async () => {
-    const mod = await import("../api/route");
+  it("exports runtime as edge and POST handler", async () => {
+    // Arrange + Act
+    const mod = await import("../../../app/api/chat/route");
+
+    // Assert
     expect(mod.runtime).toBe("edge");
     expect(typeof mod.POST).toBe("function");
   });
+
+  it("calls streamText and returns a response", async () => {
+    // Arrange
+    const mod = await import("../../../app/api/chat/route");
+    const req = new Request("http://localhost/api/chat", {
+      method: "POST",
+      body: JSON.stringify({ messages: [{ role: "user", content: "hello" }] }),
+    });
+
+    // Act
+    const response = await mod.POST(req);
+
+    // Assert
+    expect(response).toBeInstanceOf(Response);
+  });
+
+  it("getErrorMessage returns error.message for Error instances", async () => {
+    // Arrange
+    const mod = await import("../../../app/api/chat/route");
+    const req = new Request("http://localhost/api/chat", {
+      method: "POST",
+      body: JSON.stringify({ messages: [] }),
+    });
+    await mod.POST(req);
+
+    // Act + Assert
+    expect(capturedGetErrorMessage).toBeDefined();
+    expect(capturedGetErrorMessage!(new Error("boom"))).toBe("boom");
+  });
+
+  it("getErrorMessage returns JSON for plain objects", async () => {
+    // Arrange
+    const mod = await import("../../../app/api/chat/route");
+    const req = new Request("http://localhost/api/chat", {
+      method: "POST",
+      body: JSON.stringify({ messages: [] }),
+    });
+    await mod.POST(req);
+
+    // Act + Assert
+    expect(capturedGetErrorMessage!({ code: 42 })).toBe('{"code":42}');
+  });
+
+  it("getErrorMessage returns String() for primitives", async () => {
+    // Arrange
+    const mod = await import("../../../app/api/chat/route");
+    const req = new Request("http://localhost/api/chat", {
+      method: "POST",
+      body: JSON.stringify({ messages: [] }),
+    });
+    await mod.POST(req);
+
+    // Act + Assert
+    expect(capturedGetErrorMessage!("plain string")).toBe("plain string");
+  });
 });

package/template/src/features/chat/__tests__/use-chat.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect, vi } from "vitest";
+
+vi.mock("@ai-sdk/react", () => ({
+  useChat: vi.fn(() => ({ messages: [], input: "" })),
+}));
+
+describe("use-chat re-export", () => {
+  it("re-exports useChat from @ai-sdk/react", async () => {
+    // Arrange + Act
+    const mod = await import("../hooks/use-chat");
+
+    // Assert
+    expect(typeof mod.useChat).toBe("function");
+  });
+});

package/template/src/features/chat/components/chat-ui.tsx

@@ -18,7 +18,7 @@ export function ChatUi() {
               message.role === "user" ? "bg-primary/10 ml-8" : "bg-muted mr-8"
             }`}
           >
-            <p className="text-sm">{message.content}</p>
+            <p className="text-sm">{message.content.replace(/<think>[\s\S]*?<\/think>\s*/g, "")}</p>
           </div>
         ))}
         {isLoading && (

package/template/src/shared/__tests__/middleware.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect, vi } from "vitest";
+import { NextRequest } from "next/server";
+
+const mockUpdateSession = vi.fn();
+
+vi.mock("@/shared/lib/supabase/middleware", () => ({
+  updateSession: (...args: unknown[]) => mockUpdateSession(...args),
+}));
+
+describe("middleware", () => {
+  it("delegates to updateSession", async () => {
+    // Arrange
+    const mockResponse = new Response(null, { status: 200 });
+    mockUpdateSession.mockResolvedValue(mockResponse);
+    const { middleware } = await import("../../middleware");
+    const req = new NextRequest("http://localhost/dashboard");
+
+    // Act
+    const response = await middleware(req);
+
+    // Assert
+    expect(mockUpdateSession).toHaveBeenCalledWith(req);
+    expect(response).toBe(mockResponse);
+  });
+
+  it("exports a matcher config", async () => {
+    // Arrange + Act
+    const { config } = await import("../../middleware");
+
+    // Assert
+    expect(config.matcher).toBeDefined();
+    expect(Array.isArray(config.matcher)).toBe(true);
+  });
+});

package/template/src/shared/__tests__/schema.test.ts

@@ -4,16 +4,29 @@ import { insertProfileSchema, selectProfileSchema } from "../db/schema";
 
 describe("profiles schema", () => {
   it("insertProfileSchema validates required fields", () => {
-    const result = insertProfileSchema.safeParse({ id: "uuid", email: "test@example.com" });
+    // Arrange + Act
+    const result = insertProfileSchema.safeParse({
+      id: "123e4567-e89b-12d3-a456-426614174000",
+      email: "test@example.com",
+    });
+
+    // Assert
     expect(result.success).toBe(true);
   });
 
-  it("insertProfileSchema rejects invalid email", () => {
-    const result = insertProfileSchema.safeParse({ id: "uuid", email: "not-email" });
+  it("insertProfileSchema rejects invalid uuid", () => {
+    // Arrange + Act
+    const result = insertProfileSchema.safeParse({
+      id: "not-a-uuid",
+      email: "test@example.com",
+    });
+
+    // Assert
     expect(result.success).toBe(false);
   });
 
   it("selectProfileSchema is defined", () => {
+    // Arrange + Act + Assert
     expect(selectProfileSchema).toBeDefined();
   });
 });

package/template/src/shared/__tests__/supabase-middleware.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const mockGetUser = vi.fn();
+const mockCreateServerClient = vi.fn();
+const mockNextResponseNext = vi.fn();
+const mockNextResponseRedirect = vi.fn();
+
+vi.mock("@supabase/ssr", () => ({
+  createServerClient: (...args: unknown[]) => mockCreateServerClient(...args),
+}));
+
+vi.mock("next/server", async () => {
+  const actual = await vi.importActual<typeof import("next/server")>("next/server");
+  return {
+    ...actual,
+    NextResponse: {
+      next: (...args: unknown[]) => mockNextResponseNext(...args),
+      redirect: (...args: unknown[]) => mockNextResponseRedirect(...args),
+    },
+  };
+});
+
+type CookieOptions = { path?: string; maxAge?: number };
+type CookieItem = { name: string; value: string; options: CookieOptions };
+type CookieCallbacks = {
+  getAll: () => CookieItem[];
+  setAll: (cookies: CookieItem[]) => void;
+};
+
+function makeRequest(pathname: string) {
+  return {
+    nextUrl: {
+      pathname,
+      clone: () => ({ pathname, toString: () => `http://localhost${pathname}` }),
+    },
+    cookies: { getAll: vi.fn(() => []), set: vi.fn() },
+    headers: new Headers(),
+    url: `http://localhost${pathname}`,
+  } as unknown as import("next/server").NextRequest;
+}
+
+describe("supabase middleware (updateSession)", () => {
+  let capturedCookieCallbacks: CookieCallbacks | undefined;
+  const fakeResponse = {
+    cookies: { set: vi.fn(), getAll: vi.fn(() => []) },
+    status: 200,
+    headers: new Headers(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    capturedCookieCallbacks = undefined;
+    mockNextResponseNext.mockReturnValue(fakeResponse);
+    mockNextResponseRedirect.mockImplementation((url: unknown) => ({
+      status: 307,
+      headers: new Headers({ location: String(url) }),
+    }));
+    mockCreateServerClient.mockImplementation(
+      (_u: unknown, _k: unknown, opts: { cookies: CookieCallbacks }) => {
+        capturedCookieCallbacks = opts.cookies;
+        return { auth: { getUser: mockGetUser } };
+      }
+    );
+  });
+
+  it("returns nextResponse for authenticated user on protected route", async () => {
+    // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: { id: "user-1" } } });
+    const { updateSession } = await import("../lib/supabase/middleware");
+    const req = makeRequest("/dashboard");
+
+    // Act
+    const response = await updateSession(req);
+
+    // Assert
+    expect(response).toBeDefined();
+    expect(mockNextResponseRedirect).not.toHaveBeenCalled();
+  });
+
+  it("invokes getAll cookie callback", async () => {
+    // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: { id: "user-1" } } });
+    const { updateSession } = await import("../lib/supabase/middleware");
+    const req = makeRequest("/dashboard");
+    await updateSession(req);
+
+    // Act
+    capturedCookieCallbacks!.getAll();
+
+    // Assert
+    expect(req.cookies.getAll).toHaveBeenCalled();
+  });
+
+  it("invokes setAll cookie callback and updates request + response cookies", async () => {
+    // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: { id: "user-1" } } });
+    const { updateSession } = await import("../lib/supabase/middleware");
+    const req = makeRequest("/dashboard");
+    await updateSession(req);
+
+    // Act
+    capturedCookieCallbacks!.setAll([
+      { name: "sb-token", value: "abc", options: { path: "/" } },
+    ]);
+
+    // Assert
+    expect(req.cookies.set).toHaveBeenCalledWith("sb-token", "abc");
+    expect(fakeResponse.cookies.set).toHaveBeenCalledWith("sb-token", "abc", { path: "/" });
+  });
+
+  it("redirects unauthenticated user from protected route", async () => {
+    // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: null } });
+    const { updateSession } = await import("../lib/supabase/middleware");
+    const req = makeRequest("/dashboard");
+
+    // Act
+    await updateSession(req);
+
+    // Assert
+    expect(mockNextResponseRedirect).toHaveBeenCalled();
+  });
+
+  it("does not redirect unauthenticated user on login route", async () => {
+    // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: null } });
+    const { updateSession } = await import("../lib/supabase/middleware");
+    const req = makeRequest("/login");
+
+    // Act
+    await updateSession(req);
+
+    // Assert
+    expect(mockNextResponseRedirect).not.toHaveBeenCalled();
+  });
+
+  it("does not redirect unauthenticated user on root path", async () => {
+    // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: null } });
+    const { updateSession } = await import("../lib/supabase/middleware");
+    const req = makeRequest("/");
+
+    // Act
+    await updateSession(req);
+
+    // Assert
+    expect(mockNextResponseRedirect).not.toHaveBeenCalled();
+  });
+
+  it("does not redirect on /api/auth routes", async () => {
+    // Arrange
+    mockGetUser.mockResolvedValue({ data: { user: null } });
+    const { updateSession } = await import("../lib/supabase/middleware");
+    const req = makeRequest("/api/auth/callback");
+
+    // Act
+    await updateSession(req);
+
+    // Assert
+    expect(mockNextResponseRedirect).not.toHaveBeenCalled();
+  });
+});