Fullstack Workspace Init

{
  "name": "fullstack-workspace-init",
  "version": "1.0.0",
  "description": "Scaffold a production-ready full-stack monorepo with working MVP features, tests, and CI/CD. Generat",
  "author": {
    "name": "Ship Shit Dev",
    "email": "hello@shipshit.dev",
    "url": "https://shipshit.dev"
  },
  "license": "MIT",
  "skills": "."
}

name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  lint:
    name: Lint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - name: Run linter
        run: bun run lint

  test-api:
    name: Test API
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: api
    steps:
      - uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - name: Run tests with coverage
        run: bun run test:coverage

      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          files: ./api/coverage/lcov.info
          flags: api
          fail_ci_if_error: false

  test-frontend:
    name: Test Frontend
    runs-on: ubuntu-latest
    defaults:
      run:
        working-directory: frontend
    steps:
      - uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - name: Run tests with coverage
        run: bun run test:coverage

      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          files: ./frontend/coverage/lcov.info
          flags: frontend
          fail_ci_if_error: false

  build:
    name: Build
    runs-on: ubuntu-latest
    needs: [lint, test-api, test-frontend]
    steps:
      - uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - name: Build API
        run: cd api && bun run build

      - name: Build Frontend
        run: cd frontend && bun run build
        env:
          NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY: ${{ secrets.NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY }}
          NEXT_PUBLIC_API_URL: ${{ secrets.NEXT_PUBLIC_API_URL }}

  typecheck:
    name: Type Check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v2
        with:
          bun-version: latest

      - name: Install dependencies
        run: bun install --frozen-lockfile

      - name: Type check API
        run: cd api && bun run typecheck

      - name: Type check Frontend
        run: cd frontend && bun run typecheck

/**
 * Clerk Auth Guard Template
 *
 * Place this at: api/apps/api/src/auth/guards/clerk-auth.guard.ts
 */

import {
  Injectable,
  CanActivate,
  ExecutionContext,
  UnauthorizedException,
} from "@nestjs/common";
import { Clerk } from "@clerk/clerk-sdk-node";

@Injectable()
export class ClerkAuthGuard implements CanActivate {
  private clerk: Clerk;

  constructor() {
    this.clerk = new Clerk({
      secretKey: process.env.CLERK_SECRET_KEY || "",
    });
  }

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const request = context.switchToHttp().getRequest();
    const authHeader = request.headers.authorization;

    if (!authHeader || !authHeader.startsWith("Bearer ")) {
      throw new UnauthorizedException("No authorization token provided");
    }

    const token = authHeader.replace("Bearer ", "");

    try {
      const session = await this.clerk.verifyToken(token);
      request.user = {
        userId: session.sub,
        sessionId: session.sid,
      };
      return true;
    } catch (error) {
      throw new UnauthorizedException("Invalid or expired token");
    }
  }
}

/**
 * Clerk Provider Template
 *
 * Place this at: frontend/apps/dashboard/providers/clerk-provider.tsx
 */

"use client";

import { ClerkProvider as BaseClerkProvider } from "@clerk/nextjs";
import { dark } from "@clerk/themes";

interface ClerkProviderProps {
  children: React.ReactNode;
}

export function ClerkProvider({ children }: ClerkProviderProps) {
  return (
    <BaseClerkProvider
      appearance={{
        baseTheme: dark,
        variables: {
          colorPrimary: "#3b82f6",
          colorBackground: "#0f172a",
          colorInputBackground: "#1e293b",
          colorInputText: "#f8fafc",
        },
        elements: {
          formButtonPrimary:
            "bg-blue-600 hover:bg-blue-700 text-white font-medium",
          card: "bg-slate-900 border border-slate-800",
          headerTitle: "text-white",
          headerSubtitle: "text-slate-400",
          socialButtonsBlockButton:
            "bg-slate-800 border-slate-700 text-white hover:bg-slate-700",
          formFieldLabel: "text-slate-300",
          formFieldInput: "bg-slate-800 border-slate-700 text-white",
          footerActionLink: "text-blue-500 hover:text-blue-400",
        },
      }}
    >
      {children}
    </BaseClerkProvider>
  );
}

/**
 * React Form Component Template
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{FIELDS}} with actual form fields
 */

"use client";

import { useState } from "react";
import { {{Entity}} } from "@interfaces/{{entity}}.interface";
import { Button, Input } from "@agenticindiedev/ui";

interface {{Entity}}FormProps {
  {{entity}}?: {{Entity}};
  onSubmit: (data: Partial<{{Entity}}>) => Promise<void>;
  onCancel: () => void;
}

export function {{Entity}}Form({ {{entity}}, onSubmit, onCancel }: {{Entity}}FormProps) {
  const [loading, setLoading] = useState(false);
  const [formData, setFormData] = useState<Partial<{{Entity}}>>({
    // Initialize with existing data or defaults
    // {{FIELDS}}
    ...{{entity}},
  });

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    setLoading(true);
    try {
      await onSubmit(formData);
    } finally {
      setLoading(false);
    }
  };

  const handleChange = (field: keyof {{Entity}}, value: unknown) => {
    setFormData((prev) => ({ ...prev, [field]: value }));
  };

  return (
    <form onSubmit={handleSubmit} className="space-y-4 p-4 border rounded-lg">
      {/**
       * FORM FIELD EXAMPLES:
       *
       * Text input:
       * <div>
       *   <label className="block text-sm font-medium mb-1">Title</label>
       *   <Input
       *     value={formData.title || ""}
       *     onChange={(e) => handleChange("title", e.target.value)}
       *     placeholder="Enter title"
       *     required
       *   />
       * </div>
       *
       * Textarea:
       * <div>
       *   <label className="block text-sm font-medium mb-1">Description</label>
       *   <textarea
       *     className="w-full p-2 border rounded"
       *     value={formData.description || ""}
       *     onChange={(e) => handleChange("description", e.target.value)}
       *     rows={3}
       *   />
       * </div>
       *
       * Select:
       * <div>
       *   <label className="block text-sm font-medium mb-1">Priority</label>
       *   <select
       *     className="w-full p-2 border rounded"
       *     value={formData.priority || "medium"}
       *     onChange={(e) => handleChange("priority", e.target.value)}
       *   >
       *     <option value="low">Low</option>
       *     <option value="medium">Medium</option>
       *     <option value="high">High</option>
       *   </select>
       * </div>
       *
       * Date:
       * <div>
       *   <label className="block text-sm font-medium mb-1">Due Date</label>
       *   <Input
       *     type="date"
       *     value={formData.dueDate || ""}
       *     onChange={(e) => handleChange("dueDate", e.target.value)}
       *   />
       * </div>
       */}

      {/* {{FIELDS}} */}

      <div className="flex gap-2 justify-end">
        <Button type="button" variant="ghost" onClick={onCancel}>
          Cancel
        </Button>
        <Button type="submit" disabled={loading}>
          {loading ? "Saving..." : {{entity}} ? "Update" : "Create"}
        </Button>
      </div>
    </form>
  );
}

/**
 * React List Component Template
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 */

"use client";

import { useEffect, useState } from "react";
import { {{Entity}}Service } from "@services/{{entity}}.service";
import { {{Entity}} } from "@interfaces/{{entity}}.interface";
import { {{Entity}}Item } from "./{{entity}}-item";
import { {{Entity}}Form } from "./{{entity}}-form";
import { Button } from "@agenticindiedev/ui";

export function {{Entity}}List() {
  const [{{entities}}, set{{Entity}}s] = useState<{{Entity}}[]>([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
  const [showForm, setShowForm] = useState(false);

  const fetch{{Entity}}s = async () => {
    try {
      setLoading(true);
      const controller = new AbortController();
      const data = await {{Entity}}Service.getAll({ signal: controller.signal });
      set{{Entity}}s(data);
      setError(null);
    } catch (err) {
      if (err instanceof Error && err.name !== "AbortError") {
        setError(err.message);
      }
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    const controller = new AbortController();

    {{Entity}}Service.getAll({ signal: controller.signal })
      .then(set{{Entity}}s)
      .catch((err) => {
        if (err.name !== "AbortError") {
          setError(err.message);
        }
      })
      .finally(() => setLoading(false));

    return () => controller.abort();
  }, []);

  const handleCreate = async (data: Partial<{{Entity}}>) => {
    try {
      await {{Entity}}Service.create(data);
      setShowForm(false);
      fetch{{Entity}}s();
    } catch (err) {
      setError(err instanceof Error ? err.message : "Failed to create");
    }
  };

  const handleUpdate = async (id: string, data: Partial<{{Entity}}>) => {
    try {
      await {{Entity}}Service.update(id, data);
      fetch{{Entity}}s();
    } catch (err) {
      setError(err instanceof Error ? err.message : "Failed to update");
    }
  };

  const handleDelete = async (id: string) => {
    try {
      await {{Entity}}Service.delete(id);
      fetch{{Entity}}s();
    } catch (err) {
      setError(err instanceof Error ? err.message : "Failed to delete");
    }
  };

  if (loading) {
    return (
      <div className="flex items-center justify-center p-8">
        <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary" />
      </div>
    );
  }

  if (error) {
    return (
      <div className="p-4 bg-red-50 text-red-600 rounded-lg">
        Error: {error}
      </div>
    );
  }

  return (
    <div className="space-y-4">
      <div className="flex items-center justify-between">
        <h2 className="text-2xl font-bold">{{Entity}}s</h2>
        <Button onClick={() => setShowForm(true)}>
          Add {{Entity}}
        </Button>
      </div>

      {showForm && (
        <{{Entity}}Form
          onSubmit={handleCreate}
          onCancel={() => setShowForm(false)}
        />
      )}

      {{{entities}}.length === 0 ? (
        <div className="text-center py-8 text-gray-500">
          No {{entities}} yet. Create your first one!
        </div>
      ) : (
        <div className="space-y-2">
          {{{entities}}.map(({{entity}}) => (
            <{{Entity}}Item
              key={{{entity}}._id}
              {{entity}}={{{entity}}}
              onUpdate={handleUpdate}
              onDelete={handleDelete}
            />
          ))}
        </div>
      )}
    </div>
  );
}

/**
 * React Component Test Template (Vitest + Testing Library)
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 *
 * Requires: npm install -D @testing-library/react @testing-library/jest-dom jsdom
 */

import { describe, it, expect, beforeEach, vi } from "vitest";
import { render, screen, fireEvent, waitFor } from "@testing-library/react";
import { {{Entity}}List } from "./{{entity}}-list";
import { {{Entity}}Form } from "./{{entity}}-form";
import { {{Entity}}Service } from "@services/{{entity}}.service";

// Mock the service
vi.mock("@services/{{entity}}.service", () => ({
  {{Entity}}Service: {
    getAll: vi.fn(),
    create: vi.fn(),
    update: vi.fn(),
    delete: vi.fn(),
  },
}));

// Mock Clerk
vi.mock("@clerk/nextjs", () => ({
  useAuth: () => ({
    getToken: vi.fn().mockResolvedValue("test-token"),
    isSignedIn: true,
  }),
  useUser: () => ({
    user: { id: "user-123", firstName: "Test" },
  }),
}));

describe("{{Entity}}List", () => {
  const mock{{Entity}}s = [
    { _id: "1", title: "{{Entity}} 1", userId: "user-123" },
    { _id: "2", title: "{{Entity}} 2", userId: "user-123" },
  ];

  beforeEach(() => {
    vi.clearAllMocks();
    ({{Entity}}Service.getAll as any).mockResolvedValue(mock{{Entity}}s);
  });

  it("should render loading state initially", () => {
    render(<{{Entity}}List />);

    expect(screen.getByText(/loading/i)).toBeInTheDocument();
  });

  it("should render {{entities}} after loading", async () => {
    render(<{{Entity}}List />);

    await waitFor(() => {
      expect(screen.getByText("{{Entity}} 1")).toBeInTheDocument();
      expect(screen.getByText("{{Entity}} 2")).toBeInTheDocument();
    });
  });

  it("should handle empty state", async () => {
    ({{Entity}}Service.getAll as any).mockResolvedValue([]);

    render(<{{Entity}}List />);

    await waitFor(() => {
      expect(screen.getByText(/no {{entities}} found/i)).toBeInTheDocument();
    });
  });

  it("should handle error state", async () => {
    ({{Entity}}Service.getAll as any).mockRejectedValue(new Error("Failed to fetch"));

    render(<{{Entity}}List />);

    await waitFor(() => {
      expect(screen.getByText(/error/i)).toBeInTheDocument();
    });
  });

  it("should delete a {{entity}}", async () => {
    ({{Entity}}Service.delete as any).mockResolvedValue(undefined);

    render(<{{Entity}}List />);

    await waitFor(() => {
      expect(screen.getByText("{{Entity}} 1")).toBeInTheDocument();
    });

    const deleteButtons = screen.getAllByRole("button", { name: /delete/i });
    fireEvent.click(deleteButtons[0]);

    await waitFor(() => {
      expect({{Entity}}Service.delete).toHaveBeenCalledWith("1", expect.any(Object));
    });
  });
});

describe("{{Entity}}Form", () => {
  const mockOnSubmit = vi.fn();
  const mockOnCancel = vi.fn();

  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("should render empty form for new {{entity}}", () => {
    render(<{{Entity}}Form onSubmit={mockOnSubmit} onCancel={mockOnCancel} />);

    expect(screen.getByLabelText(/title/i)).toHaveValue("");
  });

  it("should render populated form for editing", () => {
    const {{entity}} = { _id: "1", title: "Existing {{Entity}}" };

    render(
      <{{Entity}}Form
        initialData={{ entity }}
        onSubmit={mockOnSubmit}
        onCancel={mockOnCancel}
      />
    );

    expect(screen.getByLabelText(/title/i)).toHaveValue("Existing {{Entity}}");
  });

  it("should call onSubmit with form data", async () => {
    render(<{{Entity}}Form onSubmit={mockOnSubmit} onCancel={mockOnCancel} />);

    const titleInput = screen.getByLabelText(/title/i);
    fireEvent.change(titleInput, { target: { value: "New {{Entity}}" } });

    const submitButton = screen.getByRole("button", { name: /save|submit/i });
    fireEvent.click(submitButton);

    await waitFor(() => {
      expect(mockOnSubmit).toHaveBeenCalledWith(
        expect.objectContaining({ title: "New {{Entity}}" })
      );
    });
  });

  it("should call onCancel when cancel button clicked", () => {
    render(<{{Entity}}Form onSubmit={mockOnSubmit} onCancel={mockOnCancel} />);

    const cancelButton = screen.getByRole("button", { name: /cancel/i });
    fireEvent.click(cancelButton);

    expect(mockOnCancel).toHaveBeenCalled();
  });

  it("should show validation errors for empty required fields", async () => {
    render(<{{Entity}}Form onSubmit={mockOnSubmit} onCancel={mockOnCancel} />);

    const submitButton = screen.getByRole("button", { name: /save|submit/i });
    fireEvent.click(submitButton);

    await waitFor(() => {
      expect(screen.getByText(/title is required/i)).toBeInTheDocument();
    });

    expect(mockOnSubmit).not.toHaveBeenCalled();
  });
});

/**
 * NestJS Controller Test Template (Vitest)
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 */

import { describe, it, expect, beforeEach, vi } from "vitest";
import { Test, TestingModule } from "@nestjs/testing";
import { {{Entity}}sController } from "./{{entities}}.controller";
import { {{Entity}}sService } from "./{{entities}}.service";
import { Create{{Entity}}Dto } from "./dto/create-{{entity}}.dto";
import { Update{{Entity}}Dto } from "./dto/update-{{entity}}.dto";

describe("{{Entity}}sController", () => {
  let controller: {{Entity}}sController;
  let service: {{Entity}}sService;

  const mockUser = { userId: "user-123" };
  const mock{{Entity}} = {
    _id: "{{entity}}-123",
    title: "Test {{Entity}}",
    userId: mockUser.userId,
    createdAt: new Date().toISOString(),
    updatedAt: new Date().toISOString(),
  };

  const mock{{Entity}}sService = {
    create: vi.fn(),
    findAll: vi.fn(),
    findOne: vi.fn(),
    update: vi.fn(),
    remove: vi.fn(),
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [{{Entity}}sController],
      providers: [
        {
          provide: {{Entity}}sService,
          useValue: mock{{Entity}}sService,
        },
      ],
    }).compile();

    controller = module.get<{{Entity}}sController>({{Entity}}sController);
    service = module.get<{{Entity}}sService>({{Entity}}sService);

    // Reset mocks
    vi.clearAllMocks();
  });

  it("should be defined", () => {
    expect(controller).toBeDefined();
  });

  describe("create", () => {
    it("should create a new {{entity}}", async () => {
      const createDto: Create{{Entity}}Dto = {
        title: "New {{Entity}}",
      };

      mock{{Entity}}sService.create.mockResolvedValue(mock{{Entity}});

      const result = await controller.create(createDto, mockUser);

      expect(service.create).toHaveBeenCalledWith(createDto, mockUser.userId);
      expect(result).toEqual(mock{{Entity}});
    });
  });

  describe("findAll", () => {
    it("should return all {{entities}} for user", async () => {
      const {{entities}} = [mock{{Entity}}];
      mock{{Entity}}sService.findAll.mockResolvedValue({{entities}});

      const result = await controller.findAll(mockUser);

      expect(service.findAll).toHaveBeenCalledWith(mockUser.userId);
      expect(result).toEqual({{entities}});
    });
  });

  describe("findOne", () => {
    it("should return a single {{entity}}", async () => {
      mock{{Entity}}sService.findOne.mockResolvedValue(mock{{Entity}});

      const result = await controller.findOne("{{entity}}-123", mockUser);

      expect(service.findOne).toHaveBeenCalledWith("{{entity}}-123", mockUser.userId);
      expect(result).toEqual(mock{{Entity}});
    });
  });

  describe("update", () => {
    it("should update a {{entity}}", async () => {
      const updateDto: Update{{Entity}}Dto = { title: "Updated" };
      const updated{{Entity}} = { ...mock{{Entity}}, ...updateDto };

      mock{{Entity}}sService.update.mockResolvedValue(updated{{Entity}});

      const result = await controller.update("{{entity}}-123", updateDto, mockUser);

      expect(service.update).toHaveBeenCalledWith("{{entity}}-123", updateDto, mockUser.userId);
      expect(result.title).toBe("Updated");
    });
  });

  describe("remove", () => {
    it("should delete a {{entity}}", async () => {
      mock{{Entity}}sService.remove.mockResolvedValue(undefined);

      await controller.remove("{{entity}}-123", mockUser);

      expect(service.remove).toHaveBeenCalledWith("{{entity}}-123", mockUser.userId);
    });
  });
});

/**
 * NestJS Controller Template
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 */

import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  Query,
  UseGuards,
} from "@nestjs/common";
import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery } from "@nestjs/swagger";
import { {{Entity}}sService } from "./{{entities}}.service";
import { Create{{Entity}}Dto } from "./dto/create-{{entity}}.dto";
import { Update{{Entity}}Dto } from "./dto/update-{{entity}}.dto";
import { ClerkAuthGuard } from "../auth/guards/clerk-auth.guard";
import { CurrentUser } from "../auth/decorators/current-user.decorator";

@ApiTags("{{entities}}")
@ApiBearerAuth()
@UseGuards(ClerkAuthGuard)
@Controller("{{entities}}")
export class {{Entity}}sController {
  constructor(private readonly {{entities}}Service: {{Entity}}sService) {}

  @Post()
  @ApiOperation({ summary: "Create a new {{entity}}" })
  create(
    @Body() create{{Entity}}Dto: Create{{Entity}}Dto,
    @CurrentUser() user: { userId: string },
  ) {
    return this.{{entities}}Service.create(create{{Entity}}Dto, user.userId);
  }

  @Get()
  @ApiOperation({ summary: "Get all {{entities}}" })
  findAll(@CurrentUser() user: { userId: string }) {
    return this.{{entities}}Service.findAll(user.userId);
  }

  @Get(":id")
  @ApiOperation({ summary: "Get a {{entity}} by ID" })
  findOne(
    @Param("id") id: string,
    @CurrentUser() user: { userId: string },
  ) {
    return this.{{entities}}Service.findOne(id, user.userId);
  }

  @Patch(":id")
  @ApiOperation({ summary: "Update a {{entity}}" })
  update(
    @Param("id") id: string,
    @Body() update{{Entity}}Dto: Update{{Entity}}Dto,
    @CurrentUser() user: { userId: string },
  ) {
    return this.{{entities}}Service.update(id, update{{Entity}}Dto, user.userId);
  }

  @Delete(":id")
  @ApiOperation({ summary: "Delete a {{entity}}" })
  remove(
    @Param("id") id: string,
    @CurrentUser() user: { userId: string },
  ) {
    return this.{{entities}}Service.remove(id, user.userId);
  }
}

/**
 * Current User Decorator Template
 *
 * Place this at: api/apps/api/src/auth/decorators/current-user.decorator.ts
 */

import { createParamDecorator, ExecutionContext } from "@nestjs/common";

export interface CurrentUserPayload {
  userId: string;
  sessionId?: string;
}

export const CurrentUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext): CurrentUserPayload => {
    const request = ctx.switchToHttp().getRequest();
    return request.user;
  },
);

/**
 * DTO Templates
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{FIELDS}} with actual field definitions
 */

// === create-{{entity}}.dto.ts ===

import {
  IsString,
  IsOptional,
  IsEnum,
  IsArray,
  IsDateString,
  IsBoolean,
  IsNumber,
} from "class-validator";

/**
 * FIELD EXAMPLES - Replace with actual fields:
 *
 * Required string:
 * @IsString()
 * title: string;
 *
 * Optional string:
 * @IsString()
 * @IsOptional()
 * description?: string;
 *
 * Enum:
 * @IsEnum(Priority)
 * @IsOptional()
 * priority?: Priority;
 *
 * Date string:
 * @IsDateString()
 * @IsOptional()
 * dueDate?: string;
 *
 * Boolean:
 * @IsBoolean()
 * @IsOptional()
 * isCompleted?: boolean;
 *
 * Number:
 * @IsNumber()
 * @IsOptional()
 * order?: number;
 *
 * Array of strings:
 * @IsArray()
 * @IsString({ each: true })
 * @IsOptional()
 * tags?: string[];
 */

export class Create{{Entity}}Dto {
  // {{FIELDS}}
}

// === update-{{entity}}.dto.ts ===

import { PartialType } from "@nestjs/swagger";
import { Create{{Entity}}Dto } from "./create-{{entity}}.dto";

export class Update{{Entity}}Dto extends PartialType(Create{{Entity}}Dto) {}

/**
 * NestJS E2E Test Template (Vitest + Supertest)
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 *
 * Requires: npm install -D supertest @types/supertest
 */

import { describe, it, expect, beforeAll, afterAll, beforeEach } from "vitest";
import { Test, TestingModule } from "@nestjs/testing";
import { INestApplication, ValidationPipe } from "@nestjs/common";
import * as request from "supertest";
import { AppModule } from "../app.module";
import { MongoMemoryServer } from "mongodb-memory-server";
import { MongooseModule } from "@nestjs/mongoose";

describe("{{Entity}}s E2E", () => {
  let app: INestApplication;
  let mongod: MongoMemoryServer;
  let authToken: string;

  // Mock auth token for testing
  const mockAuthToken = "Bearer test-token";

  beforeAll(async () => {
    // Start in-memory MongoDB
    mongod = await MongoMemoryServer.create();
    const mongoUri = mongod.getUri();

    const moduleFixture: TestingModule = await Test.createTestingModule({
      imports: [AppModule],
    })
      .overrideProvider("MONGODB_URI")
      .useValue(mongoUri)
      .compile();

    app = moduleFixture.createNestApplication();

    // Apply same configuration as main.ts
    app.useGlobalPipes(
      new ValidationPipe({
        whitelist: true,
        transform: true,
        forbidNonWhitelisted: true,
      })
    );

    await app.init();
  });

  afterAll(async () => {
    await app.close();
    await mongod.stop();
  });

  describe("POST /{{entities}}", () => {
    it("should create a new {{entity}}", async () => {
      const create{{Entity}}Dto = {
        title: "Test {{Entity}}",
        // Add other required fields
      };

      const response = await request(app.getHttpServer())
        .post("/{{entities}}")
        .set("Authorization", mockAuthToken)
        .send(create{{Entity}}Dto)
        .expect(201);

      expect(response.body).toHaveProperty("_id");
      expect(response.body.title).toBe(create{{Entity}}Dto.title);
    });

    it("should return 401 without auth token", async () => {
      await request(app.getHttpServer())
        .post("/{{entities}}")
        .send({ title: "Test" })
        .expect(401);
    });

    it("should return 400 for invalid data", async () => {
      await request(app.getHttpServer())
        .post("/{{entities}}")
        .set("Authorization", mockAuthToken)
        .send({}) // Missing required fields
        .expect(400);
    });
  });

  describe("GET /{{entities}}", () => {
    it("should return all {{entities}} for user", async () => {
      const response = await request(app.getHttpServer())
        .get("/{{entities}}")
        .set("Authorization", mockAuthToken)
        .expect(200);

      expect(Array.isArray(response.body)).toBe(true);
    });

    it("should return 401 without auth token", async () => {
      await request(app.getHttpServer())
        .get("/{{entities}}")
        .expect(401);
    });
  });

  describe("GET /{{entities}}/:id", () => {
    let created{{Entity}}Id: string;

    beforeEach(async () => {
      // Create a {{entity}} first
      const response = await request(app.getHttpServer())
        .post("/{{entities}}")
        .set("Authorization", mockAuthToken)
        .send({ title: "Test {{Entity}}" });

      created{{Entity}}Id = response.body._id;
    });

    it("should return a {{entity}} by id", async () => {
      const response = await request(app.getHttpServer())
        .get(`/{{entities}}/${created{{Entity}}Id}`)
        .set("Authorization", mockAuthToken)
        .expect(200);

      expect(response.body._id).toBe(created{{Entity}}Id);
    });

    it("should return 404 for non-existent {{entity}}", async () => {
      await request(app.getHttpServer())
        .get("/{{entities}}/nonexistent-id")
        .set("Authorization", mockAuthToken)
        .expect(404);
    });
  });

  describe("PATCH /{{entities}}/:id", () => {
    let created{{Entity}}Id: string;

    beforeEach(async () => {
      const response = await request(app.getHttpServer())
        .post("/{{entities}}")
        .set("Authorization", mockAuthToken)
        .send({ title: "Test {{Entity}}" });

      created{{Entity}}Id = response.body._id;
    });

    it("should update a {{entity}}", async () => {
      const updateDto = { title: "Updated {{Entity}}" };

      const response = await request(app.getHttpServer())
        .patch(`/{{entities}}/${created{{Entity}}Id}`)
        .set("Authorization", mockAuthToken)
        .send(updateDto)
        .expect(200);

      expect(response.body.title).toBe(updateDto.title);
    });

    it("should return 404 for non-existent {{entity}}", async () => {
      await request(app.getHttpServer())
        .patch("/{{entities}}/nonexistent-id")
        .set("Authorization", mockAuthToken)
        .send({ title: "Updated" })
        .expect(404);
    });
  });

  describe("DELETE /{{entities}}/:id", () => {
    let created{{Entity}}Id: string;

    beforeEach(async () => {
      const response = await request(app.getHttpServer())
        .post("/{{entities}}")
        .set("Authorization", mockAuthToken)
        .send({ title: "Test {{Entity}}" });

      created{{Entity}}Id = response.body._id;
    });

    it("should delete a {{entity}}", async () => {
      await request(app.getHttpServer())
        .delete(`/{{entities}}/${created{{Entity}}Id}`)
        .set("Authorization", mockAuthToken)
        .expect(200);

      // Verify deletion
      await request(app.getHttpServer())
        .get(`/{{entities}}/${created{{Entity}}Id}`)
        .set("Authorization", mockAuthToken)
        .expect(404);
    });

    it("should return 404 for non-existent {{entity}}", async () => {
      await request(app.getHttpServer())
        .delete("/{{entities}}/nonexistent-id")
        .set("Authorization", mockAuthToken)
        .expect(404);
    });
  });
});

/**
 * React Hook Test Template (Vitest + Testing Library)
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 *
 * Requires: npm install -D @testing-library/react-hooks
 */

import { describe, it, expect, beforeEach, vi } from "vitest";
import { renderHook, act, waitFor } from "@testing-library/react";
import { use{{Entity}}s } from "./use-{{entities}}";
import { {{Entity}}Service } from "@services/{{entity}}.service";

// Mock the service
vi.mock("@services/{{entity}}.service", () => ({
  {{Entity}}Service: {
    getAll: vi.fn(),
    create: vi.fn(),
    update: vi.fn(),
    delete: vi.fn(),
  },
}));

// Mock Clerk
vi.mock("@clerk/nextjs", () => ({
  useAuth: () => ({
    getToken: vi.fn().mockResolvedValue("test-token"),
  }),
}));

describe("use{{Entity}}s", () => {
  const mock{{Entity}}s = [
    { _id: "1", title: "{{Entity}} 1", userId: "user-123" },
    { _id: "2", title: "{{Entity}} 2", userId: "user-123" },
  ];

  beforeEach(() => {
    vi.clearAllMocks();
    ({{Entity}}Service.getAll as any).mockResolvedValue(mock{{Entity}}s);
  });

  it("should fetch {{entities}} on mount", async () => {
    const { result } = renderHook(() => use{{Entity}}s());

    expect(result.current.loading).toBe(true);

    await waitFor(() => {
      expect(result.current.loading).toBe(false);
    });

    expect(result.current.{{entities}}).toEqual(mock{{Entity}}s);
    expect(result.current.error).toBeNull();
  });

  it("should handle fetch error", async () => {
    const errorMessage = "Failed to fetch";
    ({{Entity}}Service.getAll as any).mockRejectedValue(new Error(errorMessage));

    const { result } = renderHook(() => use{{Entity}}s());

    await waitFor(() => {
      expect(result.current.loading).toBe(false);
    });

    expect(result.current.error).toBe(errorMessage);
    expect(result.current.{{entities}}).toEqual([]);
  });

  it("should create a new {{entity}}", async () => {
    const new{{Entity}} = { _id: "3", title: "New {{Entity}}", userId: "user-123" };
    ({{Entity}}Service.create as any).mockResolvedValue(new{{Entity}});

    const { result } = renderHook(() => use{{Entity}}s());

    await waitFor(() => {
      expect(result.current.loading).toBe(false);
    });

    await act(async () => {
      await result.current.create{{ Entity }}({ title: "New {{Entity}}" });
    });

    expect({{Entity}}Service.create).toHaveBeenCalledWith(
      { title: "New {{Entity}}" },
      expect.any(Object)
    );
  });

  it("should update a {{entity}}", async () => {
    const updated{{Entity}} = { ...mock{{Entity}}s[0], title: "Updated" };
    ({{Entity}}Service.update as any).mockResolvedValue(updated{{Entity}});

    const { result } = renderHook(() => use{{Entity}}s());

    await waitFor(() => {
      expect(result.current.loading).toBe(false);
    });

    await act(async () => {
      await result.current.update{{Entity}}("1", { title: "Updated" });
    });

    expect({{Entity}}Service.update).toHaveBeenCalledWith(
      "1",
      { title: "Updated" },
      expect.any(Object)
    );
  });

  it("should delete a {{entity}}", async () => {
    ({{Entity}}Service.delete as any).mockResolvedValue(undefined);

    const { result } = renderHook(() => use{{Entity}}s());

    await waitFor(() => {
      expect(result.current.loading).toBe(false);
    });

    await act(async () => {
      await result.current.delete{{Entity}}("1");
    });

    expect({{Entity}}Service.delete).toHaveBeenCalledWith("1", expect.any(Object));
  });

  it("should refetch {{entities}}", async () => {
    const { result } = renderHook(() => use{{Entity}}s());

    await waitFor(() => {
      expect(result.current.loading).toBe(false);
    });

    ({{Entity}}Service.getAll as any).mockClear();

    await act(async () => {
      await result.current.refetch();
    });

    expect({{Entity}}Service.getAll).toHaveBeenCalledTimes(1);
  });
});

/**
 * NestJS Module Template
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 */

import { Module } from "@nestjs/common";
import { MongooseModule } from "@nestjs/mongoose";
import { {{Entity}}sController } from "./{{entities}}.controller";
import { {{Entity}}sService } from "./{{entities}}.service";
import { {{Entity}}, {{Entity}}Schema } from "./schemas/{{entity}}.schema";

@Module({
  imports: [
    MongooseModule.forFeature([
      { name: {{Entity}}.name, schema: {{Entity}}Schema },
    ]),
  ],
  controllers: [{{Entity}}sController],
  providers: [{{Entity}}sService],
  exports: [{{Entity}}sService],
})
export class {{Entity}}sModule {}

/**
 * Next.js proxy.ts Template for Clerk Auth (Next.js 16)
 *
 * Place this at: frontend/apps/dashboard/proxy.ts
 */

import { clerkMiddleware, createRouteMatcher } from "@clerk/nextjs/server";

// Define public routes that don't require authentication
const isPublicRoute = createRouteMatcher([
  "/",
  "/sign-in(.*)",
  "/sign-up(.*)",
  "/api/public(.*)",
]);

export default clerkMiddleware(async (auth, request) => {
  // Protect all routes except public ones
  if (!isPublicRoute(request)) {
    await auth.protect();
  }
});

export const config = {
  matcher: [
    // Skip Next.js internals and static files
    "/((?!_next|[^?]*\\.(?:html?|css|js(?!on)|jpe?g|webp|png|gif|svg|ttf|woff2?|ico|csv|docx?|xlsx?|zip|webmanifest)).*)",
    // Always run for API routes
    "/(api|trpc)(.*)",
  ],
};

/**
 * Mongoose Schema Template
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{FIELDS}} with actual field definitions
 */

import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
import { Document } from "mongoose";

export type {{Entity}}Document = {{Entity}} & Document;

@Schema({ timestamps: true })
export class {{Entity}} {
  /**
   * FIELD EXAMPLES - Replace with actual fields:
   *
   * Required string:
   * @Prop({ required: true })
   * title: string;
   *
   * Optional string:
   * @Prop()
   * description?: string;
   *
   * Enum:
   * @Prop({ required: true, default: 'medium', enum: ['low', 'medium', 'high'] })
   * priority: string;
   *
   * Date:
   * @Prop()
   * dueDate?: Date;
   *
   * Boolean:
   * @Prop({ default: false })
   * isCompleted: boolean;
   *
   * Array of strings:
   * @Prop({ type: [String], default: [] })
   * tags?: string[];
   *
   * Reference to another collection:
   * @Prop()
   * projectId?: string;
   */

  // {{FIELDS}}

  // Always include userId for multi-tenancy
  @Prop({ required: true })
  userId: string;
}

export const {{Entity}}Schema = SchemaFactory.createForClass({{Entity}});

// Add indexes for common queries
{{Entity}}Schema.index({ userId: 1 });
{{Entity}}Schema.index({ userId: 1, createdAt: -1 });

/**
 * Frontend API Service Template
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 */

import { {{Entity}} } from "@interfaces/{{entity}}.interface";

const API_URL = process.env.NEXT_PUBLIC_API_URL || "http://localhost:3001";

interface RequestOptions {
  signal?: AbortSignal;
}

async function getAuthHeaders(): Promise<HeadersInit> {
  // Get token from Clerk
  const token = await window.Clerk?.session?.getToken();

  return {
    "Content-Type": "application/json",
    ...(token ? { Authorization: `Bearer ${token}` } : {}),
  };
}

async function handleResponse<T>(response: Response): Promise<T> {
  if (!response.ok) {
    const error = await response.json().catch(() => ({ message: "Request failed" }));
    throw new Error(error.message || `HTTP ${response.status}`);
  }
  return response.json();
}

export const {{Entity}}Service = {
  async getAll(options?: RequestOptions): Promise<{{Entity}}[]> {
    const headers = await getAuthHeaders();
    const response = await fetch(`${API_URL}/{{entities}}`, {
      headers,
      signal: options?.signal,
    });
    return handleResponse<{{Entity}}[]>(response);
  },

  async getById(id: string, options?: RequestOptions): Promise<{{Entity}}> {
    const headers = await getAuthHeaders();
    const response = await fetch(`${API_URL}/{{entities}}/${id}`, {
      headers,
      signal: options?.signal,
    });
    return handleResponse<{{Entity}}>(response);
  },

  async create(data: Partial<{{Entity}}>): Promise<{{Entity}}> {
    const headers = await getAuthHeaders();
    const response = await fetch(`${API_URL}/{{entities}}`, {
      method: "POST",
      headers,
      body: JSON.stringify(data),
    });
    return handleResponse<{{Entity}}>(response);
  },

  async update(id: string, data: Partial<{{Entity}}>): Promise<{{Entity}}> {
    const headers = await getAuthHeaders();
    const response = await fetch(`${API_URL}/{{entities}}/${id}`, {
      method: "PATCH",
      headers,
      body: JSON.stringify(data),
    });
    return handleResponse<{{Entity}}>(response);
  },

  async delete(id: string): Promise<void> {
    const headers = await getAuthHeaders();
    const response = await fetch(`${API_URL}/{{entities}}/${id}`, {
      method: "DELETE",
      headers,
    });
    if (!response.ok) {
      const error = await response.json().catch(() => ({ message: "Delete failed" }));
      throw new Error(error.message);
    }
  },
};

/**
 * NestJS Service Test Template (Vitest)
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 */

import { describe, it, expect, beforeEach, vi } from "vitest";
import { Test, TestingModule } from "@nestjs/testing";
import { getModelToken } from "@nestjs/mongoose";
import { NotFoundException } from "@nestjs/common";
import { {{Entity}}sService } from "./{{entities}}.service";
import { {{Entity}} } from "./schemas/{{entity}}.schema";

describe("{{Entity}}sService", () => {
  let service: {{Entity}}sService;
  let mockModel: any;

  const mockUserId = "user-123";
  const mock{{Entity}} = {
    _id: "{{entity}}-123",
    title: "Test {{Entity}}",
    userId: mockUserId,
    createdAt: new Date(),
    save: vi.fn().mockResolvedValue(this),
  };

  beforeEach(async () => {
    mockModel = {
      new: vi.fn().mockResolvedValue(mock{{Entity}}),
      constructor: vi.fn().mockResolvedValue(mock{{Entity}}),
      find: vi.fn(),
      findOne: vi.fn(),
      findOneAndUpdate: vi.fn(),
      deleteOne: vi.fn(),
    };

    // Mock the constructor behavior
    mockModel.mockImplementation = vi.fn().mockReturnValue(mock{{Entity}});

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        {{Entity}}sService,
        {
          provide: getModelToken({{Entity}}.name),
          useValue: {
            ...mockModel,
            new: vi.fn().mockImplementation((data) => ({
              ...data,
              save: vi.fn().mockResolvedValue({ ...data, _id: "new-id" }),
            })),
          },
        },
      ],
    }).compile();

    service = module.get<{{Entity}}sService>({{Entity}}sService);
  });

  it("should be defined", () => {
    expect(service).toBeDefined();
  });

  describe("findAll", () => {
    it("should return all {{entities}} for a user", async () => {
      const mock{{Entity}}s = [mock{{Entity}}];
      mockModel.find.mockReturnValue({
        sort: vi.fn().mockReturnValue({
          exec: vi.fn().mockResolvedValue(mock{{Entity}}s),
        }),
      });

      const result = await service.findAll(mockUserId);

      expect(result).toEqual(mock{{Entity}}s);
      expect(mockModel.find).toHaveBeenCalledWith({ userId: mockUserId });
    });
  });

  describe("findOne", () => {
    it("should return a {{entity}} by id", async () => {
      mockModel.findOne.mockReturnValue({
        exec: vi.fn().mockResolvedValue(mock{{Entity}}),
      });

      const result = await service.findOne("{{entity}}-123", mockUserId);

      expect(result).toEqual(mock{{Entity}});
      expect(mockModel.findOne).toHaveBeenCalledWith({
        _id: "{{entity}}-123",
        userId: mockUserId,
      });
    });

    it("should throw NotFoundException if {{entity}} not found", async () => {
      mockModel.findOne.mockReturnValue({
        exec: vi.fn().mockResolvedValue(null),
      });

      await expect(
        service.findOne("nonexistent", mockUserId),
      ).rejects.toThrow(NotFoundException);
    });
  });

  describe("update", () => {
    it("should update a {{entity}}", async () => {
      const updated{{Entity}} = { ...mock{{Entity}}, title: "Updated" };
      mockModel.findOneAndUpdate.mockReturnValue({
        exec: vi.fn().mockResolvedValue(updated{{Entity}}),
      });

      const result = await service.update(
        "{{entity}}-123",
        { title: "Updated" },
        mockUserId,
      );

      expect(result.title).toBe("Updated");
    });

    it("should throw NotFoundException if {{entity}} not found", async () => {
      mockModel.findOneAndUpdate.mockReturnValue({
        exec: vi.fn().mockResolvedValue(null),
      });

      await expect(
        service.update("nonexistent", { title: "Test" }, mockUserId),
      ).rejects.toThrow(NotFoundException);
    });
  });

  describe("remove", () => {
    it("should delete a {{entity}}", async () => {
      mockModel.deleteOne.mockReturnValue({
        exec: vi.fn().mockResolvedValue({ deletedCount: 1 }),
      });

      await expect(
        service.remove("{{entity}}-123", mockUserId),
      ).resolves.not.toThrow();
    });

    it("should throw NotFoundException if {{entity}} not found", async () => {
      mockModel.deleteOne.mockReturnValue({
        exec: vi.fn().mockResolvedValue({ deletedCount: 0 }),
      });

      await expect(
        service.remove("nonexistent", mockUserId),
      ).rejects.toThrow(NotFoundException);
    });
  });
});

/**
 * NestJS Service Template
 *
 * Replace {{Entity}} with PascalCase entity name (e.g., Task)
 * Replace {{entity}} with camelCase entity name (e.g., task)
 * Replace {{entities}} with plural camelCase (e.g., tasks)
 */

import { Injectable, NotFoundException } from "@nestjs/common";
import { InjectModel } from "@nestjs/mongoose";
import { Model } from "mongoose";
import { {{Entity}}, {{Entity}}Document } from "./schemas/{{entity}}.schema";
import { Create{{Entity}}Dto } from "./dto/create-{{entity}}.dto";
import { Update{{Entity}}Dto } from "./dto/update-{{entity}}.dto";

@Injectable()
export class {{Entity}}sService {
  constructor(
    @InjectModel({{Entity}}.name) private {{entity}}Model: Model<{{Entity}}Document>,
  ) {}

  async create(create{{Entity}}Dto: Create{{Entity}}Dto, userId: string): Promise<{{Entity}}> {
    const {{entity}} = new this.{{entity}}Model({
      ...create{{Entity}}Dto,
      userId,
    });
    return {{entity}}.save();
  }

  async findAll(userId: string): Promise<{{Entity}}[]> {
    const query = this.{{entity}}Model.find({ userId }).sort({ createdAt: -1 });
    return query.then((docs) => docs);
  }

  async findOne(id: string, userId: string): Promise<{{Entity}}> {
    const query = this.{{entity}}Model.findOne({ _id: id, userId });
    const {{entity}} = await query.then((doc) => doc);

    if (!{{entity}}) {
      throw new NotFoundException(`{{Entity}} with ID ${id} not found`);
    }

    return {{entity}};
  }

  async update(
    id: string,
    update{{Entity}}Dto: Update{{Entity}}Dto,
    userId: string,
  ): Promise<{{Entity}}> {
    const query = this.{{entity}}Model.findOneAndUpdate(
      { _id: id, userId },
      update{{Entity}}Dto,
      { new: true },
    );
    const {{entity}} = await query.then((doc) => doc);

    if (!{{entity}}) {
      throw new NotFoundException(`{{Entity}} with ID ${id} not found`);
    }

    return {{entity}};
  }

  async remove(id: string, userId: string): Promise<void> {
    const query = this.{{entity}}Model.deleteOne({ _id: id, userId });
    const result = await query.then((res) => res);

    if (result.deletedCount === 0) {
      throw new NotFoundException(`{{Entity}} with ID ${id} not found`);
    }
  }
}

/**
 * Test Setup Template for Frontend (React Testing Library)
 *
 * Place this at src/test/setup.ts or test/setup.ts
 */

import "@testing-library/jest-dom/vitest";
import { cleanup } from "@testing-library/react";
import { afterEach, vi } from "vitest";

// Cleanup after each test
afterEach(() => {
  cleanup();
});

// Mock next/navigation
vi.mock("next/navigation", () => ({
  useRouter: () => ({
    push: vi.fn(),
    replace: vi.fn(),
    prefetch: vi.fn(),
    back: vi.fn(),
    forward: vi.fn(),
  }),
  useSearchParams: () => ({
    get: vi.fn(),
  }),
  usePathname: () => "/",
}));

// Mock next/image
vi.mock("next/image", () => ({
  default: ({ src, alt, ...props }: any) => {
    // eslint-disable-next-line @next/next/no-img-element
    return <img src={src} alt={alt} {...props} />;
  },
}));

// Mock Clerk
vi.mock("@clerk/nextjs", () => ({
  useAuth: () => ({
    isLoaded: true,
    isSignedIn: true,
    userId: "test-user-id",
    getToken: vi.fn().mockResolvedValue("test-token"),
  }),
  useUser: () => ({
    isLoaded: true,
    isSignedIn: true,
    user: {
      id: "test-user-id",
      firstName: "Test",
      lastName: "User",
      emailAddresses: [{ emailAddress: "test@example.com" }],
    },
  }),
  SignIn: () => <div data-testid="clerk-sign-in">Sign In</div>,
  SignUp: () => <div data-testid="clerk-sign-up">Sign Up</div>,
  SignedIn: ({ children }: { children: React.ReactNode }) => <>{children}</>,
  SignedOut: ({ children }: { children: React.ReactNode }) => <>{children}</>,
  UserButton: () => <button data-testid="clerk-user-button">User</button>,
  ClerkProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
}));

// Mock window.matchMedia
Object.defineProperty(window, "matchMedia", {
  writable: true,
  value: vi.fn().mockImplementation((query) => ({
    matches: false,
    media: query,
    onchange: null,
    addListener: vi.fn(),
    removeListener: vi.fn(),
    addEventListener: vi.fn(),
    removeEventListener: vi.fn(),
    dispatchEvent: vi.fn(),
  })),
});

// Mock ResizeObserver
global.ResizeObserver = vi.fn().mockImplementation(() => ({
  observe: vi.fn(),
  unobserve: vi.fn(),
  disconnect: vi.fn(),
}));

// Mock IntersectionObserver
global.IntersectionObserver = vi.fn().mockImplementation(() => ({
  observe: vi.fn(),
  unobserve: vi.fn(),
  disconnect: vi.fn(),
}));

// Suppress console errors in tests (optional)
const originalError = console.error;
console.error = (...args: any[]) => {
  if (
    typeof args[0] === "string" &&
    args[0].includes("Warning: ReactDOM.render is no longer supported")
  ) {
    return;
  }
  originalError.call(console, ...args);
};

/**
 * Vitest Configuration Template for Frontend (React/Next.js)
 *
 * Copy this to your frontend project and adjust paths as needed.
 * This configuration enforces 80% coverage thresholds.
 */

import { defineConfig } from "vitest/config";
import react from "@vitejs/plugin-react";
import path from "path";

export default defineConfig({
  plugins: [react()],
  test: {
    // Use global test APIs (describe, it, expect)
    globals: true,

    // Environment for React tests
    environment: "jsdom",

    // Setup files for React Testing Library
    setupFiles: ["./src/test/setup.ts"],

    // Test file patterns
    include: [
      "src/**/*.{test,spec}.{ts,tsx}",
      "components/**/*.{test,spec}.{ts,tsx}",
      "hooks/**/*.{test,spec}.{ts,tsx}",
    ],

    // Exclude patterns
    exclude: ["node_modules", "dist", ".next", "build", "e2e"],

    // Coverage configuration
    coverage: {
      // Use V8 provider
      provider: "v8",

      // Output formats
      reporter: ["text", "json", "html", "lcov"],

      // Files to include in coverage
      include: [
        "src/**/*.{ts,tsx}",
        "components/**/*.{ts,tsx}",
        "hooks/**/*.{ts,tsx}",
        "lib/**/*.{ts,tsx}",
      ],

      // Files to exclude from coverage
      exclude: [
        "**/*.test.{ts,tsx}",
        "**/*.spec.{ts,tsx}",
        "**/*.d.ts",
        "**/test/**",
        "**/__mocks__/**",
        "**/types/**",
        "**/*.stories.{ts,tsx}",
      ],

      // Coverage thresholds - fail if below these
      thresholds: {
        lines: 80,
        functions: 80,
        branches: 75,
        statements: 80,
      },
    },

    // Timeout for tests (ms)
    testTimeout: 10000,

    // CSS handling
    css: true,

    // Path aliases (match tsconfig/next.config)
    alias: {
      "@": path.resolve(__dirname, "./src"),
      "@components": path.resolve(__dirname, "./components"),
      "@hooks": path.resolve(__dirname, "./hooks"),
      "@lib": path.resolve(__dirname, "./lib"),
      "@services": path.resolve(__dirname, "./services"),
    },
  },
});