create-tigra 1.0.0

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

@@ -0,0 +1,253 @@
+/**
+ * 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';
+import type { Resource as PrismaResource } from '@prisma/client';
+import type { ResourceFilters, Resource, ResourceWithOwner } from './resources.types';
+import type { CreateResourceInput, UpdateResourceInput } from './resources.schemas';
+
+/**
+ * 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;
+}

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

@@ -0,0 +1,355 @@
+/**
+ * Resources Routes
+ * 
+ * Fastify route definitions for resources endpoints.
+ * Includes comprehensive Swagger documentation and rate limiting.
+ * 
+ * @see /mnt/project/09-api-documentation-v2.md
+ * @see /mnt/project/11-rate-limiting-v2.md
+ */
+
+import type { FastifyInstance } from 'fastify';
+import { toJsonSchema, getDefinition } from '@/libs/swagger-schemas';
+import * as resourceController from './resources.controller';
+import {
+    CreateResourceSchema,
+    UpdateResourceSchema,
+    ResourceFiltersSchema,
+    PaginationSchema,
+    ResourceResponseSchema,
+    ResourceWithOwnerResponseSchema,
+} from './resources.schemas';
+
+/**
+ * Error response schema for Swagger
+ */
+const ErrorResponseSchema = {
+    type: 'object',
+    properties: {
+        success: { type: 'boolean', enum: [false] },
+        error: {
+            type: 'object',
+            properties: {
+                code: { type: 'string' },
+                message: { type: 'string' },
+            },
+        },
+    },
+};
+
+/**
+ * Paginated resources response schema
+ */
+const PaginatedResourcesResponseSchema = {
+    type: 'object',
+    properties: {
+        success: { type: 'boolean', enum: [true] },
+        message: { type: 'string' },
+        data: {
+            type: 'object',
+            properties: {
+                items: {
+                    type: 'array',
+                    items: getDefinition(ResourceResponseSchema, 'ResourceResponseSchema'),
+                },
+                pagination: {
+                    type: 'object',
+                    properties: {
+                        page: { type: 'integer' },
+                        limit: { type: 'integer' },
+                        totalItems: { type: 'integer' },
+                        totalPages: { type: 'integer' },
+                        hasNextPage: { type: 'boolean' },
+                        hasPreviousPage: { type: 'boolean' },
+                    },
+                },
+            },
+        },
+    },
+};
+
+/**
+ * Single resource response schema
+ */
+const ResourceSuccessResponseSchema = {
+    type: 'object',
+    properties: {
+        success: { type: 'boolean', enum: [true] },
+        message: { type: 'string' },
+        data: getDefinition(ResourceResponseSchema, 'ResourceResponseSchema'),
+    },
+};
+
+/**
+ * Resource with owner response schema
+ */
+const ResourceWithOwnerSuccessResponseSchema = {
+    type: 'object',
+    properties: {
+        success: { type: 'boolean', enum: [true] },
+        message: { type: 'string' },
+        data: getDefinition(ResourceWithOwnerResponseSchema, 'ResourceWithOwnerResponseSchema'),
+    },
+};
+
+/**
+ * Register resources routes
+ * 
+ * @param fastify - Fastify instance
+ */
+export async function resourceRoutes(fastify: FastifyInstance): Promise<void> {
+    /**
+     * GET /resources
+     * 
+     * Get paginated list of resources with optional filters
+     */
+    fastify.get('/', {
+        schema: {
+            description: 'Get paginated list of resources with optional filters',
+            tags: ['resources'],
+            summary: 'List resources',
+            querystring: {
+                type: 'object',
+                properties: {
+                    ...(toJsonSchema(ResourceFiltersSchema, 'ResourceFiltersSchema') as any).properties,
+                    ...(toJsonSchema(PaginationSchema, 'PaginationSchema') as any).properties,
+                },
+            },
+            response: {
+                200: {
+                    description: 'Resources retrieved successfully',
+                    ...PaginatedResourcesResponseSchema,
+                },
+            },
+        },
+        config: {
+            rateLimit: {
+                max: 100,
+                timeWindow: '15 minutes',
+            },
+        },
+        handler: resourceController.listResources,
+    });
+
+    /**
+     * GET /resources/my
+     * 
+     * Get current user's resources
+     * Requires authentication
+     */
+    fastify.get('/my', {
+        schema: {
+            description: "Get current user's resources",
+            tags: ['resources'],
+            summary: 'Get my resources',
+            security: [{ bearerAuth: [] }],
+            querystring: toJsonSchema(PaginationSchema, 'PaginationSchema'),
+            response: {
+                200: {
+                    description: 'User resources retrieved successfully',
+                    ...PaginatedResourcesResponseSchema,
+                },
+                401: {
+                    description: 'Unauthorized - Invalid or missing token',
+                    ...ErrorResponseSchema,
+                },
+            },
+        },
+        config: {
+            rateLimit: {
+                max: 1000,
+                timeWindow: '15 minutes',
+            },
+        },
+        preHandler: [fastify.authenticate, fastify.requireAny()],
+        handler: resourceController.getMyResources,
+    });
+
+    /**
+     * GET /resources/:id
+     * 
+     * Get single resource by ID with owner information
+     */
+    fastify.get('/:id', {
+        schema: {
+            description: 'Get single resource by ID with owner information',
+            tags: ['resources'],
+            summary: 'Get resource by ID',
+            params: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        format: 'uuid',
+                        description: 'Resource ID',
+                    },
+                },
+                required: ['id'],
+            },
+            response: {
+                200: {
+                    description: 'Resource retrieved successfully',
+                    ...ResourceWithOwnerSuccessResponseSchema,
+                },
+                404: {
+                    description: 'Resource not found',
+                    ...ErrorResponseSchema,
+                },
+            },
+        },
+        config: {
+            rateLimit: {
+                max: 100,
+                timeWindow: '15 minutes',
+            },
+        },
+        handler: resourceController.getResource,
+    });
+
+    /**
+     * POST /resources
+     * 
+     * Create a new resource
+     * Requires authentication
+     */
+    fastify.post('/', {
+        schema: {
+            description: 'Create a new resource',
+            tags: ['resources'],
+            summary: 'Create resource',
+            security: [{ bearerAuth: [] }],
+            body: toJsonSchema(CreateResourceSchema, 'CreateResourceRequest'),
+            response: {
+                201: {
+                    description: 'Resource created successfully',
+                    ...ResourceSuccessResponseSchema,
+                },
+                400: {
+                    description: 'Validation error',
+                    ...ErrorResponseSchema,
+                },
+                401: {
+                    description: 'Unauthorized - Invalid or missing token',
+                    ...ErrorResponseSchema,
+                },
+            },
+        },
+        config: {
+            rateLimit: {
+                max: 1000,
+                timeWindow: '15 minutes',
+            },
+        },
+        preHandler: [fastify.authenticate, fastify.requireAny()],
+        handler: resourceController.createResource,
+    });
+
+    /**
+     * PATCH /resources/:id
+     * 
+     * Update a resource (owner only)
+     * Requires authentication
+     */
+    fastify.patch('/:id', {
+        schema: {
+            description: 'Update a resource (owner only)',
+            tags: ['resources'],
+            summary: 'Update resource',
+            security: [{ bearerAuth: [] }],
+            params: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        format: 'uuid',
+                        description: 'Resource ID',
+                    },
+                },
+                required: ['id'],
+            },
+            body: toJsonSchema(UpdateResourceSchema, 'UpdateResourceRequest'),
+            response: {
+                200: {
+                    description: 'Resource updated successfully',
+                    ...ResourceSuccessResponseSchema,
+                },
+                400: {
+                    description: 'Validation error',
+                    ...ErrorResponseSchema,
+                },
+                401: {
+                    description: 'Unauthorized - Invalid or missing token',
+                    ...ErrorResponseSchema,
+                },
+                403: {
+                    description: 'Forbidden - You do not own this resource',
+                    ...ErrorResponseSchema,
+                },
+                404: {
+                    description: 'Resource not found',
+                    ...ErrorResponseSchema,
+                },
+            },
+        },
+        config: {
+            rateLimit: {
+                max: 1000,
+                timeWindow: '15 minutes',
+            },
+        },
+        preHandler: [fastify.authenticate, fastify.requireAny()],
+        handler: resourceController.updateResource,
+    });
+
+    /**
+     * DELETE /resources/:id
+     * 
+     * Delete a resource (owner only, soft delete)
+     * Requires authentication
+     */
+    fastify.delete('/:id', {
+        schema: {
+            description: 'Delete a resource (owner only, soft delete)',
+            tags: ['resources'],
+            summary: 'Delete resource',
+            security: [{ bearerAuth: [] }],
+            params: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        format: 'uuid',
+                        description: 'Resource ID',
+                    },
+                },
+                required: ['id'],
+            },
+            response: {
+                200: {
+                    description: 'Resource deleted successfully',
+                    ...ResourceSuccessResponseSchema,
+                },
+                401: {
+                    description: 'Unauthorized - Invalid or missing token',
+                    ...ErrorResponseSchema,
+                },
+                403: {
+                    description: 'Forbidden - You do not own this resource',
+                    ...ErrorResponseSchema,
+                },
+                404: {
+                    description: 'Resource not found',
+                    ...ErrorResponseSchema,
+                },
+            },
+        },
+        config: {
+            rateLimit: {
+                max: 1000,
+                timeWindow: '15 minutes',
+            },
+        },
+        preHandler: [fastify.authenticate, fastify.requireAny()],
+        handler: resourceController.deleteResource,
+    });
+}