nextjs-hackathon-stack 0.1.0

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

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest";
+import { aiModel } from "../lib/ai";
+
+describe("aiModel", () => {
+  it("exports aiModel", () => {
+    expect(aiModel).toBeDefined();
+  });
+});

package/template/src/shared/__tests__/minimax-media.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { generateVideo, synthesizeSpeech } from "../lib/minimax-media";
+
+const mockFetch = vi.fn();
+global.fetch = mockFetch;
+
+describe("generateVideo", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("returns task_id when API responds successfully", async () => {
+    // Arrange
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ task_id: "abc123" }),
+    });
+
+    // Act
+    const taskId = await generateVideo("A cat on the moon");
+
+    // Assert
+    expect(taskId).toBe("abc123");
+  });
+
+  it("throws when API returns non-ok response", async () => {
+    // Arrange
+    mockFetch.mockResolvedValue({ ok: false, statusText: "Bad Request" });
+
+    // Act + Assert
+    await expect(generateVideo("test")).rejects.toThrow("Video generation failed");
+  });
+});
+
+describe("synthesizeSpeech", () => {
+  it("returns audio_file URL when API responds successfully", async () => {
+    // Arrange
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({ audio_file: "https://example.com/audio.mp3" }),
+    });
+
+    // Act
+    const url = await synthesizeSpeech("Hello world");
+
+    // Assert
+    expect(url).toBe("https://example.com/audio.mp3");
+  });
+
+  it("throws when API returns non-ok response", async () => {
+    // Arrange
+    mockFetch.mockResolvedValue({ ok: false, statusText: "Server Error" });
+
+    // Act + Assert
+    await expect(synthesizeSpeech("test")).rejects.toThrow("TTS failed");
+  });
+});

package/template/src/shared/__tests__/providers.test.tsx

@@ -0,0 +1,14 @@
+import { render, screen } from "@testing-library/react";
+import { describe, it, expect } from "vitest";
+import { Providers } from "../components/providers";
+
+describe("Providers", () => {
+  it("renders children", () => {
+    render(
+      <Providers>
+        <div data-testid="child">Hello</div>
+      </Providers>
+    );
+    expect(screen.getByTestId("child")).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { insertProfileSchema, selectProfileSchema } from "../db/schema";
+
+describe("profiles schema", () => {
+  it("insertProfileSchema validates required fields", () => {
+    const result = insertProfileSchema.safeParse({ id: "uuid", email: "test@example.com" });
+    expect(result.success).toBe(true);
+  });
+
+  it("insertProfileSchema rejects invalid email", () => {
+    const result = insertProfileSchema.safeParse({ id: "uuid", email: "not-email" });
+    expect(result.success).toBe(false);
+  });
+
+  it("selectProfileSchema is defined", () => {
+    expect(selectProfileSchema).toBeDefined();
+  });
+});

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

@@ -0,0 +1,13 @@
+import { describe, it, expect, vi } from "vitest";
+
+vi.mock("@supabase/ssr", () => ({
+  createBrowserClient: vi.fn(() => ({ auth: {} })),
+}));
+
+describe("supabase client", () => {
+  it("createClient returns a supabase client", async () => {
+    const { createClient } = await import("../lib/supabase/client");
+    const client = createClient();
+    expect(client).toBeDefined();
+  });
+});

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

@@ -0,0 +1,22 @@
+import { describe, it, expect, vi } from "vitest";
+
+vi.mock("@supabase/ssr", () => ({
+  createServerClient: vi.fn(() => ({ auth: {} })),
+}));
+
+vi.mock("next/headers", () => ({
+  cookies: vi.fn(() =>
+    Promise.resolve({
+      getAll: () => [],
+      set: vi.fn(),
+    })
+  ),
+}));
+
+describe("supabase server", () => {
+  it("createClient returns a supabase client", async () => {
+    const { createClient } = await import("../lib/supabase/server");
+    const client = await createClient();
+    expect(client).toBeDefined();
+  });
+});

package/template/src/shared/components/providers.tsx

@@ -0,0 +1,19 @@
+"use client";
+
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { useState } from "react";
+
+export function Providers({ children }: { children: React.ReactNode }) {
+  const [queryClient] = useState(
+    () =>
+      new QueryClient({
+        defaultOptions: {
+          queries: {
+            staleTime: 60 * 1000,
+          },
+        },
+      })
+  );
+
+  return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
+}

package/template/src/shared/db/index.ts

@@ -0,0 +1,7 @@
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+import * as schema from "./schema";
+
+const client = postgres(process.env["DATABASE_URL"] ?? "");
+
+export const db = drizzle(client, { schema });

package/template/src/shared/db/schema.ts

@@ -0,0 +1,15 @@
+import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+
+export const profiles = pgTable("profiles", {
+  id: uuid("id").primaryKey(),
+  email: text("email").notNull().unique(),
+  createdAt: timestamp("created_at").notNull().defaultNow(),
+  updatedAt: timestamp("updated_at").notNull().defaultNow(),
+});
+
+export const insertProfileSchema = createInsertSchema(profiles);
+export const selectProfileSchema = createSelectSchema(profiles);
+
+export type InsertProfile = typeof profiles.$inferInsert;
+export type SelectProfile = typeof profiles.$inferSelect;

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

@@ -0,0 +1,8 @@
+import { createOpenAI } from "@ai-sdk/openai";
+
+const gateway = createOpenAI({
+  baseURL: process.env["AI_GATEWAY_URL"] ?? "https://api.minimaxi.chat/v1",
+  apiKey: process.env["MINIMAX_API_KEY"] ?? "",
+});
+
+export const aiModel = gateway("minimax/minimax-m2.7");

package/template/src/shared/lib/minimax-media.ts

@@ -0,0 +1,63 @@
+const MINIMAX_API_BASE = "https://api.minimaxi.chat/v1";
+
+interface VideoGenerationRequest {
+  model: string;
+  prompt: string;
+}
+
+interface VideoGenerationResponse {
+  task_id: string;
+}
+
+interface TtsRequest {
+  model: string;
+  text: string;
+  voice_id: string;
+}
+
+interface TtsResponse {
+  audio_file: string;
+}
+
+export async function generateVideo(prompt: string): Promise<string> {
+  const response = await fetch(`${MINIMAX_API_BASE}/video_generation`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${process.env["MINIMAX_API_KEY"] ?? ""}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      model: "video-01",
+      prompt,
+    } satisfies VideoGenerationRequest),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Video generation failed: ${response.statusText}`);
+  }
+
+  const data = (await response.json()) as VideoGenerationResponse;
+  return data.task_id;
+}
+
+export async function synthesizeSpeech(text: string, voiceId = "female-shaonv"): Promise<string> {
+  const response = await fetch(`${MINIMAX_API_BASE}/t2a_v2`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${process.env["MINIMAX_API_KEY"] ?? ""}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      model: "speech-02-hd",
+      text,
+      voice_id: voiceId,
+    } satisfies TtsRequest),
+  });
+
+  if (!response.ok) {
+    throw new Error(`TTS failed: ${response.statusText}`);
+  }
+
+  const data = (await response.json()) as TtsResponse;
+  return data.audio_file;
+}

package/template/src/shared/lib/supabase/client.ts

@@ -0,0 +1,8 @@
+import { createBrowserClient } from "@supabase/ssr";
+
+export function createClient() {
+  return createBrowserClient(
+    process.env["NEXT_PUBLIC_SUPABASE_URL"]!,
+    process.env["NEXT_PUBLIC_SUPABASE_ANON_KEY"]!
+  );
+}

package/template/src/shared/lib/supabase/middleware.ts

@@ -0,0 +1,40 @@
+import { createServerClient } from "@supabase/ssr";
+import { NextResponse, type NextRequest } from "next/server";
+
+export async function updateSession(request: NextRequest) {
+  let supabaseResponse = NextResponse.next({ request });
+
+  const supabase = createServerClient(
+    process.env["NEXT_PUBLIC_SUPABASE_URL"]!,
+    process.env["NEXT_PUBLIC_SUPABASE_ANON_KEY"]!,
+    {
+      cookies: {
+        getAll() {
+          return request.cookies.getAll();
+        },
+        setAll(cookiesToSet) {
+          cookiesToSet.forEach(({ name, value }) => request.cookies.set(name, value));
+          supabaseResponse = NextResponse.next({ request });
+          cookiesToSet.forEach(({ name, value, options }) =>
+            supabaseResponse.cookies.set(name, value, options)
+          );
+        },
+      },
+    }
+  );
+
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+
+  const isAuthRoute = request.nextUrl.pathname.startsWith("/login");
+  const isProtectedRoute = !isAuthRoute && !request.nextUrl.pathname.startsWith("/api/auth");
+
+  if (!user && isProtectedRoute && request.nextUrl.pathname !== "/") {
+    const redirectUrl = request.nextUrl.clone();
+    redirectUrl.pathname = "/login";
+    return NextResponse.redirect(redirectUrl);
+  }
+
+  return supabaseResponse;
+}

package/template/src/shared/lib/supabase/server.ts

@@ -0,0 +1,26 @@
+import { createServerClient } from "@supabase/ssr";
+import { cookies } from "next/headers";
+
+export async function createClient() {
+  const cookieStore = await cookies();
+
+  return createServerClient(
+    process.env["NEXT_PUBLIC_SUPABASE_URL"]!,
+    process.env["NEXT_PUBLIC_SUPABASE_ANON_KEY"]!,
+    {
+      cookies: {
+        getAll() {
+          return cookieStore.getAll();
+        },
+        setAll(cookiesToSet) {
+          try {
+            cookiesToSet.forEach(({ name, value, options }) =>
+              cookieStore.set(name, value, options)
+            );
+          } catch {
+          }
+        },
+      },
+    }
+  );
+}

package/template/src/test-setup.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom";

package/template/tailwind.css

@@ -0,0 +1,20 @@
+@import "tailwindcss";
+
+@theme {
+  --color-background: hsl(0 0% 100%);
+  --color-foreground: hsl(222.2 84% 4.9%);
+  --color-primary: hsl(222.2 47.4% 11.2%);
+  --color-primary-foreground: hsl(210 40% 98%);
+  --color-secondary: hsl(210 40% 96.1%);
+  --color-secondary-foreground: hsl(222.2 47.4% 11.2%);
+  --color-muted: hsl(210 40% 96.1%);
+  --color-muted-foreground: hsl(215.4 16.3% 46.9%);
+  --color-accent: hsl(210 40% 96.1%);
+  --color-accent-foreground: hsl(222.2 47.4% 11.2%);
+  --color-destructive: hsl(0 84.2% 60.2%);
+  --color-destructive-foreground: hsl(210 40% 98%);
+  --color-border: hsl(214.3 31.8% 91.4%);
+  --color-input: hsl(214.3 31.8% 91.4%);
+  --color-ring: hsl(222.2 84% 4.9%);
+  --radius: 0.5rem;
+}

package/template/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "plugins": [{ "name": "next" }],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}

package/template/vitest.config.ts

@@ -0,0 +1,33 @@
+import { defineConfig } from "vitest/config";
+import react from "@vitejs/plugin-react";
+import { resolve } from "path";
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: "jsdom",
+    setupFiles: ["./src/test-setup.ts"],
+    coverage: {
+      provider: "v8",
+      thresholds: {
+        branches: 100,
+        functions: 100,
+        lines: 100,
+        statements: 100,
+      },
+      exclude: [
+        "node_modules/**",
+        "src/e2e/**",
+        "src/shared/db/migrations/**",
+        "**/*.config.*",
+        "**/index.ts",
+        "src/app/globals.css",
+      ],
+    },
+  },
+  resolve: {
+    alias: {
+      "@": resolve(__dirname, "./src"),
+    },
+  },
+});