create-tigra 1.0.0 → 1.0.2

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

@@ -1,25 +1,14 @@
 /**
  * Authentication Routes
- * 
+ *
  * Fastify route definitions for authentication endpoints.
- * Includes Swagger documentation and rate limiting.
- * 
- * @see /mnt/project/09-api-documentation-v2.md
+ * Includes rate limiting for security.
+ *
  * @see /mnt/project/11-rate-limiting-v2.md
  */
 
 import type { FastifyInstance } from 'fastify';
-import { toJsonSchema, getDefinition } from '@/libs/swagger-schemas';
 import * as authController from './auth.controller';
-import {
-    RegisterSchema,
-    LoginSchema,
-    RefreshTokenSchema,
-    AuthResponseSchema,
-    UserResponseSchema,
-    TokenResponseSchema,
-    ErrorResponseSchema,
-} from './auth.schemas';
 
 /**
  * Register authentication routes
@@ -29,27 +18,10 @@ import {
 export async function authRoutes(fastify: FastifyInstance): Promise<void> {
     /**
      * POST /auth/register
-     * 
+     *
      * Register a new user account
      */
     fastify.post('/register', {
-        schema: {
-            description: 'Register a new user account',
-            tags: ['auth'],
-            summary: 'Register user',
-            body: toJsonSchema(RegisterSchema, 'RegisterRequest'),
-            response: {
-                201: getDefinition(AuthResponseSchema, 'AuthResponse'),
-                400: {
-                    description: 'Validation error',
-                    ...getDefinition(ErrorResponseSchema, 'ErrorResponse'),
-                },
-                409: {
-                    description: 'Email already registered',
-                    ...getDefinition(ErrorResponseSchema, 'ErrorResponse'),
-                },
-            },
-        },
         config: {
             rateLimit: {
                 max: 3,
@@ -61,23 +33,10 @@ export async function authRoutes(fastify: FastifyInstance): Promise<void> {
 
     /**
      * POST /auth/login
-     * 
+     *
      * Login with email and password
      */
     fastify.post('/login', {
-        schema: {
-            description: 'Login with email and password',
-            tags: ['auth'],
-            summary: 'Login user',
-            body: toJsonSchema(LoginSchema, 'LoginRequest'),
-            response: {
-                200: getDefinition(AuthResponseSchema, 'AuthResponse'),
-                401: {
-                    description: 'Invalid credentials',
-                    ...getDefinition(ErrorResponseSchema, 'ErrorResponse'),
-                },
-            },
-        },
         config: {
             rateLimit: {
                 max: 5,
@@ -89,37 +48,10 @@ export async function authRoutes(fastify: FastifyInstance): Promise<void> {
 
     /**
      * POST /auth/refresh
-     * 
+     *
      * Refresh access token using refresh token
      */
     fastify.post('/refresh', {
-        schema: {
-            description: 'Refresh access token using refresh token',
-            tags: ['auth'],
-            summary: 'Refresh tokens',
-            body: toJsonSchema(RefreshTokenSchema, 'RefreshTokenRequest'),
-            response: {
-                200: {
-                    description: 'Tokens refreshed successfully',
-                    type: 'object',
-                    properties: {
-                        success: { type: 'boolean', enum: [true] },
-                        message: { type: 'string' },
-                        data: {
-                            type: 'object',
-                            properties: {
-                                accessToken: { type: 'string' },
-                                refreshToken: { type: 'string' },
-                            },
-                        },
-                    },
-                },
-                401: {
-                    description: 'Invalid or expired refresh token',
-                    ...getDefinition(ErrorResponseSchema, 'ErrorResponse'),
-                },
-            },
-        },
         config: {
             rateLimit: {
                 max: 10,
@@ -131,73 +63,20 @@ export async function authRoutes(fastify: FastifyInstance): Promise<void> {
 
     /**
      * POST /auth/logout
-     * 
+     *
      * Logout user by invalidating refresh token
      */
     fastify.post('/logout', {
-        schema: {
-            description: 'Logout user by invalidating refresh token',
-            tags: ['auth'],
-            summary: 'Logout user',
-            body: toJsonSchema(RefreshTokenSchema, 'RefreshTokenRequest'),
-            response: {
-                200: {
-                    description: 'Logout successful',
-                    type: 'object',
-                    properties: {
-                        success: { type: 'boolean', enum: [true] },
-                        message: { type: 'string' },
-                        data: { type: 'null' },
-                    },
-                },
-            },
-        },
         handler: authController.logout,
     });
 
     /**
      * GET /auth/me
-     * 
+     *
      * Get current authenticated user information
      * Requires authentication
      */
     fastify.get('/me', {
-        schema: {
-            description: 'Get current authenticated user information',
-            tags: ['auth'],
-            summary: 'Get current user',
-            security: [{ bearerAuth: [] }],
-            response: {
-                200: {
-                    description: 'User retrieved successfully',
-                    type: 'object',
-                    properties: {
-                        success: { type: 'boolean', enum: [true] },
-                        message: { type: 'string' },
-                        data: {
-                            type: 'object',
-                            properties: {
-                                id: { type: 'string', format: 'uuid' },
-                                email: { type: 'string', format: 'email' },
-                                name: { type: 'string', nullable: true },
-                                role: { type: 'string' },
-                                emailVerified: { type: 'boolean' },
-                                createdAt: { type: 'string', format: 'date-time' },
-                                updatedAt: { type: 'string', format: 'date-time' },
-                            },
-                        },
-                    },
-                },
-                401: {
-                    description: 'Unauthorized - Invalid or missing token',
-                    ...getDefinition(ErrorResponseSchema, 'ErrorResponse'),
-                },
-                404: {
-                    description: 'User not found',
-                    ...getDefinition(ErrorResponseSchema, 'ErrorResponse'),
-                },
-            },
-        },
         preHandler: [fastify.authenticate],
         handler: authController.getMe,
     });

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

@@ -1,127 +1,27 @@
 /**
  * Resources Routes
- * 
+ *
  * Fastify route definitions for resources endpoints.
- * Includes comprehensive Swagger documentation and rate limiting.
- * 
- * @see /mnt/project/09-api-documentation-v2.md
+ * Includes rate limiting for security.
+ *
  * @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,
@@ -133,28 +33,11 @@ export async function resourceRoutes(fastify: FastifyInstance): Promise<void> {
 
     /**
      * 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,
@@ -167,36 +50,10 @@ export async function resourceRoutes(fastify: FastifyInstance): Promise<void> {
 
     /**
      * 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,
@@ -208,32 +65,11 @@ export async function resourceRoutes(fastify: FastifyInstance): Promise<void> {
 
     /**
      * 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,
@@ -246,51 +82,11 @@ export async function resourceRoutes(fastify: FastifyInstance): Promise<void> {
 
     /**
      * 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,
@@ -303,46 +99,11 @@ export async function resourceRoutes(fastify: FastifyInstance): Promise<void> {
 
     /**
      * 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,

package/template/.agent/rules/server/09-api-documentation-v2.md

@@ -1,168 +0,0 @@
----
-trigger: always_on
----
-
-> **SCOPE**: These rules apply specifically to the **server** directory.
-
-# API Documentation
-
-## Stack
-
-```json
-{
-  "dependencies": {
-    "@fastify/swagger": "^8.12.0",
-    "@fastify/swagger-ui": "^2.0.0",
-    "zod-to-json-schema": "^3.22.0"
-  }
-}
-```
-
-## Setup
-
-```typescript
-// app.ts
-import swagger from '@fastify/swagger';
-import swaggerUI from '@fastify/swagger-ui';
-
-await app.register(swagger, {
-  openapi: {
-    info: {
-      title: 'API Server',
-      version: '1.0.0',
-    },
-    servers: [
-      { url: 'http://localhost:3000', description: 'Development' },
-    ],
-    tags: [
-      { name: 'auth', description: 'Authentication' },
-      { name: 'resources', description: 'Resource operations' },
-    ],
-    components: {
-      securitySchemes: {
-        bearerAuth: { type: 'http', scheme: 'bearer', bearerFormat: 'JWT' },
-      },
-    },
-  },
-});
-
-await app.register(swaggerUI, {
-  routePrefix: '/docs',
-  uiConfig: { docExpansion: 'list', deepLinking: true },
-});
-```
-
-**Access:** `http://localhost:3000/docs`
-
-## Route Documentation Pattern
-
-```typescript
-// modules/resources/resources.schemas.ts
-import { z } from 'zod';
-
-export const CreateResourceSchema = z.object({
-  title: z.string().min(1).max(200),
-  price: z.number().positive(),
-});
-
-export const ResourceResponseSchema = z.object({
-  success: z.literal(true),
-  message: z.string(),
-  data: z.object({
-    id: z.string().uuid(),
-    title: z.string(),
-    price: z.number(),
-  }),
-});
-```
-
-```typescript
-// modules/resources/resources.routes.ts
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import * as schemas from './resources.schemas';
-
-app.post('/resources', {
-  schema: {
-    description: 'Create a new resource',
-    tags: ['resources'],
-    summary: 'Create resource',
-    body: zodToJsonSchema(schemas.CreateResourceSchema, 'CreateResource'),
-    response: {
-      201: zodToJsonSchema(schemas.ResourceResponseSchema, 'ResourceResponse'),
-      400: {
-        description: 'Validation error',
-        type: 'object',
-        properties: {
-          success: { type: 'boolean', enum: [false] },
-          error: {
-            type: 'object',
-            properties: {
-              code: { type: 'string' },
-              message: { type: 'string' },
-            },
-          },
-        },
-      },
-    },
-    security: [{ bearerAuth: [] }],
-  },
-  handler: resourceController.createResource,
-});
-```
-
-## Document All Responses
-
-```typescript
-response: {
-  200: successSchema,
-  400: validationErrorSchema,
-  401: unauthorizedSchema,
-  404: notFoundSchema,
-  500: internalErrorSchema,
-}
-```
-
-## Production Config
-
-```typescript
-if (process.env.NODE_ENV === 'production') {
-  // Option 1: Disable docs
-  // Don't register swagger-ui
-  
-  // Option 2: Require auth for docs
-  await app.register(swaggerUI, {
-    routePrefix: '/docs',
-    transformSpecification: (swaggerObject, request, reply) => {
-      if (!request.headers.authorization) {
-        reply.code(401).send({ error: 'Unauthorized' });
-      }
-      return swaggerObject;
-    },
-  });
-}
-```
-
-## Best Practices
-
-### ✅ DO:
-- Use Zod schemas for all routes
-- Document all error responses
-- Add descriptions and summaries
-- Include security requirements
-- Tag routes by domain
-
-### ❌ DON'T:
-- Skip documentation on routes
-- Forget error response schemas
-- Expose docs publicly in production
-- Use generic descriptions
-
-## Checklist
-
-- [ ] Swagger and Swagger UI registered
-- [ ] All routes have schemas
-- [ ] Zod schemas converted to JSON Schema
-- [ ] Error responses documented
-- [ ] Tags used for grouping
-- [ ] Security requirements documented
-- [ ] Production docs secured