nextjs-hackathon-stack 0.1.11 → 0.1.12

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

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

@@ -1,22 +1,95 @@
 import { describe, it, expect, vi } from "vitest";
 
+const mockSet = vi.fn();
+const mockGetAll = vi.fn().mockReturnValue([]);
+const mockCreateServerClient = vi.fn();
+
 vi.mock("@supabase/ssr", () => ({
-  createServerClient: vi.fn(() => ({ auth: {} })),
+  createServerClient: (...args: unknown[]) => mockCreateServerClient(...args),
 }));
 
 vi.mock("next/headers", () => ({
   cookies: vi.fn(() =>
     Promise.resolve({
-      getAll: () => [],
-      set: vi.fn(),
+      getAll: mockGetAll,
+      set: mockSet,
     })
   ),
 }));
 
 describe("supabase server", () => {
   it("createClient returns a supabase client", async () => {
+    // Arrange
+    mockCreateServerClient.mockReturnValue({ auth: {} });
     const { createClient } = await import("../lib/supabase/server");
+
+    // Act
     const client = await createClient();
+
+    // Assert
     expect(client).toBeDefined();
   });
+
+  it("passes cookie getAll to server client config", async () => {
+    // Arrange
+    let capturedGetAll: (() => unknown) | undefined;
+    mockCreateServerClient.mockImplementation(
+      (_u: unknown, _k: unknown, opts: { cookies: { getAll: () => unknown } }) => {
+        capturedGetAll = opts.cookies.getAll;
+        return { auth: {} };
+      }
+    );
+    const { createClient } = await import("../lib/supabase/server");
+
+    // Act
+    await createClient();
+    capturedGetAll!();
+
+    // Assert
+    expect(mockGetAll).toHaveBeenCalled();
+  });
+
+  it("setAll sets cookies via cookieStore", async () => {
+    // Arrange
+    let capturedSetAll:
+      | ((cookies: { name: string; value: string; options: object }[]) => void)
+      | undefined;
+    mockCreateServerClient.mockImplementation(
+      (_u: unknown, _k: unknown, opts: { cookies: { setAll: (c: { name: string; value: string; options: object }[]) => void } }) => {
+        capturedSetAll = opts.cookies.setAll;
+        return { auth: {} };
+      }
+    );
+    const { createClient } = await import("../lib/supabase/server");
+    await createClient();
+
+    // Act
+    capturedSetAll!([{ name: "token", value: "abc", options: { path: "/" } }]);
+
+    // Assert
+    expect(mockSet).toHaveBeenCalledWith("token", "abc", { path: "/" });
+  });
+
+  it("setAll silently swallows errors from server components", async () => {
+    // Arrange
+    mockSet.mockImplementation(() => {
+      throw new Error("Cannot set cookie");
+    });
+    let capturedSetAll:
+      | ((cookies: { name: string; value: string; options: object }[]) => void)
+      | undefined;
+    mockCreateServerClient.mockImplementation(
+      (_u: unknown, _k: unknown, opts: { cookies: { setAll: (c: { name: string; value: string; options: object }[]) => void } }) => {
+        capturedSetAll = opts.cookies.setAll;
+        return { auth: {} };
+      }
+    );
+    const { createClient } = await import("../lib/supabase/server");
+    await createClient();
+
+    // Act + Assert
+    expect(() =>
+      capturedSetAll!([{ name: "token", value: "abc", options: {} }])
+    ).not.toThrow();
+  });
 });

package/template/src/shared/__tests__/ui-button.test.tsx

@@ -0,0 +1,52 @@
+import { render, screen } from "@testing-library/react";
+import { describe, it, expect } from "vitest";
+
+import { Button } from "../components/ui/button";
+
+describe("Button", () => {
+  it("renders with default variant", () => {
+    // Arrange + Act
+    render(<Button>Click me</Button>);
+
+    // Assert
+    expect(screen.getByRole("button", { name: /click me/i })).toBeInTheDocument();
+  });
+
+  it("renders as disabled when disabled prop is set", () => {
+    // Arrange + Act
+    render(<Button disabled>Submit</Button>);
+
+    // Assert
+    expect(screen.getByRole("button")).toBeDisabled();
+  });
+
+  it("renders with custom className", () => {
+    // Arrange + Act
+    render(<Button className="custom-class">Click</Button>);
+
+    // Assert
+    expect(screen.getByRole("button")).toHaveClass("custom-class");
+  });
+
+  it("renders as a Slot (asChild) when asChild is true", () => {
+    // Arrange + Act
+    render(
+      <Button asChild>
+        <a href="/home">Go home</a>
+      </Button>
+    );
+
+    // Assert
+    expect(screen.getByRole("link", { name: /go home/i })).toBeInTheDocument();
+  });
+
+  it("renders with destructive variant", () => {
+    // Arrange + Act
+    render(<Button variant="destructive">Delete</Button>);
+
+    // Assert
+    const btn = screen.getByRole("button", { name: /delete/i });
+    expect(btn).toBeInTheDocument();
+    expect(btn.className).toContain("destructive");
+  });
+});

package/template/src/shared/__tests__/ui-card.test.tsx

@@ -0,0 +1,78 @@
+import { render, screen } from "@testing-library/react";
+import { describe, it, expect } from "vitest";
+
+import {
+  Card,
+  CardAction,
+  CardContent,
+  CardDescription,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+} from "../components/ui/card";
+
+describe("Card components", () => {
+  it("renders Card with children", () => {
+    // Arrange + Act
+    render(<Card data-testid="card">content</Card>);
+
+    // Assert
+    expect(screen.getByTestId("card")).toBeInTheDocument();
+  });
+
+  it("renders CardHeader", () => {
+    // Arrange + Act
+    render(<CardHeader data-testid="header">header</CardHeader>);
+
+    // Assert
+    expect(screen.getByTestId("header")).toBeInTheDocument();
+  });
+
+  it("renders CardTitle", () => {
+    // Arrange + Act
+    render(<CardTitle>My Title</CardTitle>);
+
+    // Assert
+    expect(screen.getByText("My Title")).toBeInTheDocument();
+  });
+
+  it("renders CardDescription", () => {
+    // Arrange + Act
+    render(<CardDescription>My Description</CardDescription>);
+
+    // Assert
+    expect(screen.getByText("My Description")).toBeInTheDocument();
+  });
+
+  it("renders CardContent", () => {
+    // Arrange + Act
+    render(<CardContent data-testid="content">body</CardContent>);
+
+    // Assert
+    expect(screen.getByTestId("content")).toBeInTheDocument();
+  });
+
+  it("renders CardAction", () => {
+    // Arrange + Act
+    render(<CardAction data-testid="action">action</CardAction>);
+
+    // Assert
+    expect(screen.getByTestId("action")).toBeInTheDocument();
+  });
+
+  it("renders CardFooter", () => {
+    // Arrange + Act
+    render(<CardFooter data-testid="footer">footer</CardFooter>);
+
+    // Assert
+    expect(screen.getByTestId("footer")).toBeInTheDocument();
+  });
+
+  it("applies custom className to Card", () => {
+    // Arrange + Act
+    render(<Card className="custom-class" data-testid="card">content</Card>);
+
+    // Assert
+    expect(screen.getByTestId("card")).toHaveClass("custom-class");
+  });
+});

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

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+
+import { cn } from "../lib/utils";
+
+describe("cn", () => {
+  it("merges multiple class names", () => {
+    // Arrange + Act + Assert
+    expect(cn("foo", "bar")).toBe("foo bar");
+  });
+
+  it("omits falsy conditional classes", () => {
+    // Arrange + Act + Assert
+    expect(cn("foo", false && "bar", "baz")).toBe("foo baz");
+  });
+
+  it("handles undefined values", () => {
+    // Arrange + Act + Assert
+    expect(cn("foo", undefined, "bar")).toBe("foo bar");
+  });
+
+  it("deduplicates conflicting tailwind classes (last one wins)", () => {
+    // Arrange + Act + Assert
+    expect(cn("p-2", "p-4")).toBe("p-4");
+  });
+
+  it("handles empty call", () => {
+    // Arrange + Act + Assert
+    expect(cn()).toBe("");
+  });
+});

package/template/src/shared/lib/ai.ts

@@ -1,8 +1,8 @@
 import { createOpenAI } from "@ai-sdk/openai";
 
 const provider = createOpenAI({
-  baseURL: process.env.AI_BASE_URL ?? "https://api.minimaxi.chat/v1",
+  baseURL: process.env.AI_BASE_URL ?? "https://api.minimax.io/v1",
   apiKey: process.env.AI_API_KEY ?? "",
 });
 
-export const aiModel = provider(process.env.AI_MODEL ?? "MiniMax-M1");
+export const aiModel = provider(process.env.AI_MODEL ?? "MiniMax-M2.7");

package/template/vitest.config.ts

@@ -5,8 +5,10 @@ import { resolve } from "path";
 export default defineConfig({
   plugins: [react()],
   test: {
+    globals: true,
     environment: "jsdom",
     setupFiles: ["./src/test-setup.ts"],
+    exclude: ["node_modules/**", "src/e2e/**"],
     coverage: {
       provider: "v8",
       thresholds: {
@@ -22,6 +24,9 @@ export default defineConfig({
         "**/*.config.*",
         "**/index.ts",
         "src/app/globals.css",
+        ".next/**",
+        "next-env.d.ts",
+        "**/*.d.ts",
       ],
     },
   },