create-tigra 1.1.0 → 2.0.1

package/template/server/src/modules/auth/auth.service.test.ts

@@ -1,119 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import * as authService from './auth.service';
-import * as authRepo from './auth.repo';
-import bcrypt from 'bcryptjs';
-import jwt from 'jsonwebtoken';
-import { env } from '../../config/env.js';
-import { ConflictError, UnauthorizedError } from '../../utils/errors.js';
-
-// Mock dependencies
-vi.mock('./auth.repo');
-vi.mock('bcryptjs');
-vi.mock('jsonwebtoken');
-vi.mock('@/libs/logger', () => ({
-    default: {
-        info: vi.fn(),
-        error: vi.fn(),
-        warn: vi.fn(),
-    },
-}));
-
-describe('Auth Service', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-        // Setup default env mocks if needed
-        env.JWT_SECRET = 'test-secret';
-        env.JWT_ACCESS_EXPIRATION = '15m';
-        env.JWT_REFRESH_EXPIRATION = '7d';
-        env.JWT_ISSUER = 'test-issuer';
-    });
-
-    describe('register', () => {
-        const registerData = {
-            email: 'test@example.com',
-            password: 'Password123!',
-            name: 'Test User',
-        };
-
-        it('should successfully register a new user', async () => {
-            // Mocks
-            vi.mocked(authRepo.findUserByEmail).mockResolvedValue(null);
-            vi.mocked(bcrypt.hash).mockResolvedValue('hashed_password' as any);
-            vi.mocked(authRepo.createUser).mockResolvedValue({
-                id: 'user-123',
-                email: registerData.email,
-                name: registerData.name,
-                role: 'USER',
-                emailVerified: false,
-                createdAt: new Date(),
-                updatedAt: new Date(),
-            });
-            vi.mocked(jwt.sign).mockReturnValue('mock_token' as any);
-            vi.mocked(authRepo.createSession).mockResolvedValue({} as any);
-
-            // Execute
-            const result = await authService.register(registerData);
-
-            // Assert
-            expect(result).toBeDefined();
-            expect(result.user.email).toBe(registerData.email);
-            expect(result.tokens.accessToken).toBe('mock_token');
-            expect(authRepo.createUser).toHaveBeenCalled();
-            expect(authRepo.createSession).toHaveBeenCalled();
-        });
-
-        it('should throw ConflictError if email already exists', async () => {
-            // Mocks
-            vi.mocked(authRepo.findUserByEmail).mockResolvedValue({ id: 'existing' } as any);
-
-            // Execute & Assert
-            await expect(authService.register(registerData))
-                .rejects
-                .toThrow(ConflictError);
-        });
-    });
-
-    describe('login', () => {
-        const loginData = {
-            email: 'test@example.com',
-            password: 'Password123!',
-        };
-
-        it('should successfully login user', async () => {
-            // Mocks
-            vi.mocked(authRepo.findUserByEmailWithPassword).mockResolvedValue({
-                id: 'user-123',
-                email: loginData.email,
-                password: 'hashed_password', // Match what bcrypt.compare expects
-                role: 'USER',
-            } as any);
-            vi.mocked(bcrypt.compare).mockResolvedValue(true as any);
-            vi.mocked(authRepo.findUserById).mockResolvedValue({
-                id: 'user-123',
-                email: loginData.email,
-                role: 'USER',
-            } as any);
-            vi.mocked(jwt.sign).mockReturnValue('mock_token' as any);
-            vi.mocked(authRepo.createSession).mockResolvedValue({} as any);
-
-            const result = await authService.login(loginData);
-
-            expect(result).toBeDefined();
-            expect(result.user.id).toBe('user-123');
-            expect(result.tokens.accessToken).toBeDefined();
-        });
-
-        it('should throw UnauthorizedError on invalid password', async () => {
-            // Mocks
-            vi.mocked(authRepo.findUserByEmailWithPassword).mockResolvedValue({
-                id: 'user-123',
-                password: 'hashed_password',
-            } as any);
-            vi.mocked(bcrypt.compare).mockResolvedValue(false as any);
-
-            await expect(authService.login(loginData))
-                .rejects
-                .toThrow(UnauthorizedError);
-        });
-    });
-});

package/template/server/src/modules/auth/auth.types.ts

@@ -1,97 +0,0 @@
-/**
- * Authentication Types
- * 
- * TypeScript types and interfaces for authentication module.
- * These types are used throughout the auth flow.
- */
-
-/**
- * User Role Enum
- */
-export type UserRole = 'USER' | 'ADMIN';
-
-/**
- * User object (without sensitive fields like password)
- * 
- * This is the safe user representation returned to clients.
- */
-export interface User {
-    id: string;
-    email: string;
-    name: string | null;
-    role: UserRole;
-    emailVerified: boolean;
-    createdAt: Date;
-    updatedAt: Date;
-}
-
-/**
- * Login Request Payload
- */
-export interface LoginRequest {
-    email: string;
-    password: string;
-}
-
-/**
- * Register Request Payload
- */
-export interface RegisterRequest {
-    email: string;
-    password: string;
-    name: string;
-}
-
-/**
- * Token Response
- * 
- * Contains JWT tokens and expiration info.
- */
-export interface TokenResponse {
-    accessToken: string;
-    refreshToken: string;
-    expiresIn: number; // Seconds until access token expires
-}
-
-/**
- * Authentication Response
- * 
- * Complete response after successful login/register.
- * Contains user info and tokens.
- */
-export interface AuthResponse {
-    user: User;
-    tokens: TokenResponse;
-}
-
-/**
- * Refresh Token Request Payload
- */
-export interface RefreshTokenRequest {
-    refreshToken: string;
-}
-
-/**
- * JWT Payload
- * 
- * Data stored inside the JWT access token.
- */
-export interface JwtPayload {
-    userId: string;
-    email: string;
-    role: UserRole;
-    iat?: number; // Issued at
-    exp?: number; // Expiration
-}
-
-/**
- * JWT Refresh Payload
- * 
- * Data stored inside the JWT refresh token.
- */
-export interface JwtRefreshPayload {
-    userId: string;
-    sessionId: string;
-    iat?: number;
-    exp?: number;
-}

package/template/server/src/modules/resources/resources.controller.ts

@@ -1,218 +0,0 @@
-/**
- * Resources Controller
- * 
- * HTTP request handlers for resources endpoints.
- * Controllers should ONLY handle HTTP concerns, no business logic.
- * 
- * @see /mnt/project/02-general-rules.md
- * @see /mnt/project/04-pagination.md
- * @see /mnt/project/06-response-handling.md
- */
-
-import type { FastifyRequest, FastifyReply } from 'fastify';
-import { successResponse } from '../../utils/response.js';
-import { paginatedResponse } from '../../utils/pagination.js';
-import * as resourceService from './resources.service.js';
-import {
-    CreateResourceSchema,
-    UpdateResourceSchema,
-    ResourceFiltersSchema,
-    PaginationSchema,
-} from './resources.schemas.js';
-import type {
-    CreateResourceInput,
-    UpdateResourceInput,
-    ResourceFiltersInput,
-    PaginationInput,
-} from './resources.schemas.js';
-
-/**
- * List resources with filters and pagination
- * 
- * @route GET /resources
- * @access Public
- */
-export async function listResources(
-    request: FastifyRequest<{
-        Querystring: ResourceFiltersInput & PaginationInput;
-    }>,
-    reply: FastifyReply
-): Promise<FastifyReply> {
-    // Parse and validate query parameters
-    const filters = ResourceFiltersSchema.parse({
-        status: request.query.status,
-        minPrice: request.query.minPrice,
-        maxPrice: request.query.maxPrice,
-        ownerId: request.query.ownerId,
-        search: request.query.search,
-    });
-
-    const pagination = PaginationSchema.parse({
-        page: request.query.page,
-        limit: request.query.limit,
-    });
-
-    // Call service
-    const { items, totalItems } = await resourceService.getResources(
-        filters,
-        pagination.page,
-        pagination.limit
-    );
-
-    // Return paginated response (EXACT format from 04-pagination.md)
-    return reply.status(200).send(
-        paginatedResponse(
-            'Resources retrieved successfully',
-            items,
-            pagination.page,
-            pagination.limit,
-            totalItems
-        )
-    );
-}
-
-/**
- * Get resource by ID
- * 
- * @route GET /resources/:id
- * @access Public
- */
-export async function getResource(
-    request: FastifyRequest<{
-        Params: { id: string };
-    }>,
-    reply: FastifyReply
-): Promise<FastifyReply> {
-    const { id } = request.params;
-
-    // Call service
-    const resource = await resourceService.getResource(id);
-
-    // Return success response
-    return reply.status(200).send(
-        successResponse('Resource retrieved successfully', resource)
-    );
-}
-
-/**
- * Create a new resource
- * 
- * @route POST /resources
- * @access Private (requires authentication)
- */
-export async function createResource(
-    request: FastifyRequest<{
-        Body: CreateResourceInput;
-    }>,
-    reply: FastifyReply
-): Promise<FastifyReply> {
-    // Validate request body
-    const body = CreateResourceSchema.parse(request.body);
-
-    // Get user ID from authenticated request
-    const userId = (request.user as any)?.userId;
-
-    // Call service
-    const resource = await resourceService.createResource(body, userId);
-
-    // Return success response
-    return reply.status(201).send(
-        successResponse('Resource created successfully', resource)
-    );
-}
-
-/**
- * Update a resource
- * 
- * @route PATCH /resources/:id
- * @access Private (requires authentication and ownership)
- */
-export async function updateResource(
-    request: FastifyRequest<{
-        Params: { id: string };
-        Body: UpdateResourceInput;
-    }>,
-    reply: FastifyReply
-): Promise<FastifyReply> {
-    const { id } = request.params;
-
-    // Validate request body
-    const body = UpdateResourceSchema.parse(request.body);
-
-    // Get user ID from authenticated request
-    const userId = (request.user as any)?.userId;
-
-    // Call service (includes ownership verification)
-    const resource = await resourceService.updateResource(id, userId, body);
-
-    // Return success response
-    return reply.status(200).send(
-        successResponse('Resource updated successfully', resource)
-    );
-}
-
-/**
- * Delete a resource
- * 
- * @route DELETE /resources/:id
- * @access Private (requires authentication and ownership)
- */
-export async function deleteResource(
-    request: FastifyRequest<{
-        Params: { id: string };
-    }>,
-    reply: FastifyReply
-): Promise<FastifyReply> {
-    const { id } = request.params;
-
-    // Get user ID from authenticated request
-    const userId = (request.user as any)?.userId;
-
-    // Call service (includes ownership verification)
-    const resource = await resourceService.deleteResource(id, userId);
-
-    // Return success response
-    return reply.status(200).send(
-        successResponse('Resource deleted successfully', resource)
-    );
-}
-
-/**
- * Get current user's resources
- * 
- * @route GET /resources/my
- * @access Private (requires authentication)
- */
-export async function getMyResources(
-    request: FastifyRequest<{
-        Querystring: PaginationInput;
-    }>,
-    reply: FastifyReply
-): Promise<FastifyReply> {
-    // Parse pagination parameters
-    const pagination = PaginationSchema.parse({
-        page: request.query.page,
-        limit: request.query.limit,
-    });
-
-    // Get user ID from authenticated request
-    const userId = (request.user as any)?.userId;
-
-    // Call service
-    const { items, totalItems } = await resourceService.getMyResources(
-        userId,
-        pagination.page,
-        pagination.limit
-    );
-
-    // Return paginated response (EXACT format from 04-pagination.md)
-    return reply.status(200).send(
-        paginatedResponse(
-            'Your resources retrieved successfully',
-            items,
-            pagination.page,
-            pagination.limit,
-            totalItems
-        )
-    );
-}

package/template/server/src/modules/resources/resources.repo.ts

@@ -1,253 +0,0 @@
-/**
- * Resources Repository
- * 
- * Database operations for resources module.
- * Handles all Prisma queries related to resources.
- * 
- * @see /mnt/project/02-general-rules.md
- */
-
-import { prisma } from '../../libs/db.js';
-import type { Resource as PrismaResource } from '@prisma/client';
-import type { ResourceFilters, Resource, ResourceWithOwner } from './resources.types.js';
-import type { CreateResourceInput, UpdateResourceInput } from './resources.schemas.js';
-
-/**
- * Find many resources with filters and pagination
- * 
- * @param filters - Filter criteria
- * @param page - Page number (1-indexed)
- * @param limit - Items per page
- * @returns Array of resources
- */
-export async function findMany(
-    filters: ResourceFilters,
-    page: number,
-    limit: number
-): Promise<Resource[]> {
-    // Build where clause
-    const where: any = {};
-
-    // Status filter
-    if (filters.status) {
-        where.status = filters.status;
-    }
-
-    // Price range filters
-    if (filters.minPrice !== undefined || filters.maxPrice !== undefined) {
-        where.price = {};
-        if (filters.minPrice !== undefined) {
-            where.price.gte = filters.minPrice;
-        }
-        if (filters.maxPrice !== undefined) {
-            where.price.lte = filters.maxPrice;
-        }
-    }
-
-    // Owner filter
-    if (filters.ownerId) {
-        where.ownerId = filters.ownerId;
-    }
-
-    // Search filter (title contains)
-    if (filters.search) {
-        where.title = {
-            contains: filters.search,
-            mode: 'insensitive', // Case-insensitive search
-        };
-    }
-
-    // Calculate offset
-    const skip = (page - 1) * limit;
-
-    // Execute query
-    const resources = await prisma.resource.findMany({
-        where,
-        skip,
-        take: limit,
-        orderBy: {
-            createdAt: 'desc',
-        },
-    });
-
-    return resources;
-}
-
-/**
- * Count resources with filters
- * 
- * @param filters - Filter criteria
- * @returns Total count of resources matching filters
- */
-export async function count(filters: ResourceFilters): Promise<number> {
-    // Build where clause (same as findMany)
-    const where: any = {};
-
-    if (filters.status) {
-        where.status = filters.status;
-    }
-
-    if (filters.minPrice !== undefined || filters.maxPrice !== undefined) {
-        where.price = {};
-        if (filters.minPrice !== undefined) {
-            where.price.gte = filters.minPrice;
-        }
-        if (filters.maxPrice !== undefined) {
-            where.price.lte = filters.maxPrice;
-        }
-    }
-
-    if (filters.ownerId) {
-        where.ownerId = filters.ownerId;
-    }
-
-    if (filters.search) {
-        where.title = {
-            contains: filters.search,
-            mode: 'insensitive',
-        };
-    }
-
-    // Execute count query
-    const total = await prisma.resource.count({ where });
-
-    return total;
-}
-
-/**
- * Find resource by ID
- * 
- * @param id - Resource ID
- * @returns Resource with owner relation, or null if not found
- */
-export async function findById(id: string): Promise<ResourceWithOwner | null> {
-    const resource = await prisma.resource.findUnique({
-        where: { id },
-        include: {
-            owner: {
-                select: {
-                    id: true,
-                    email: true,
-                    name: true,
-                },
-            },
-        },
-    });
-
-    return resource;
-}
-
-/**
- * Create a new resource
- * 
- * @param data - Resource creation data
- * @param ownerId - Owner user ID
- * @returns Created resource
- */
-export async function create(
-    data: CreateResourceInput,
-    ownerId: string
-): Promise<Resource> {
-    const resource = await prisma.resource.create({
-        data: {
-            title: data.title,
-            summary: data.summary || null,
-            price: data.price,
-            ownerId,
-            status: 'active',
-        },
-    });
-
-    return resource;
-}
-
-/**
- * Update a resource
- * 
- * @param id - Resource ID
- * @param data - Update data (partial)
- * @returns Updated resource
- */
-export async function update(
-    id: string,
-    data: UpdateResourceInput
-): Promise<Resource> {
-    const resource = await prisma.resource.update({
-        where: { id },
-        data: {
-            ...(data.title !== undefined && { title: data.title }),
-            ...(data.summary !== undefined && { summary: data.summary }),
-            ...(data.price !== undefined && { price: data.price }),
-        },
-    });
-
-    return resource;
-}
-
-/**
- * Delete a resource (soft delete)
- * 
- * Sets status to 'deleted' instead of removing from database.
- * 
- * @param id - Resource ID
- * @returns Deleted resource
- */
-export async function deleteResource(id: string): Promise<Resource> {
-    const resource = await prisma.resource.update({
-        where: { id },
-        data: {
-            status: 'deleted',
-        },
-    });
-
-    return resource;
-}
-
-/**
- * Hard delete a resource
- * 
- * Permanently removes resource from database.
- * Use with caution - prefer soft delete.
- * 
- * @param id - Resource ID
- */
-export async function hardDelete(id: string): Promise<void> {
-    await prisma.resource.delete({
-        where: { id },
-    });
-}
-
-/**
- * Check if resource exists
- * 
- * @param id - Resource ID
- * @returns True if resource exists, false otherwise
- */
-export async function exists(id: string): Promise<boolean> {
-    const count = await prisma.resource.count({
-        where: { id },
-    });
-
-    return count > 0;
-}
-
-/**
- * Check if user owns resource
- * 
- * @param resourceId - Resource ID
- * @param userId - User ID
- * @returns True if user owns resource, false otherwise
- */
-export async function isOwner(
-    resourceId: string,
-    userId: string
-): Promise<boolean> {
-    const count = await prisma.resource.count({
-        where: {
-            id: resourceId,
-            ownerId: userId,
-        },
-    });
-
-    return count > 0;
-}