@qazuor/claude-code-config 0.1.0

package/templates/skills/tech/vercel-specialist.md

@@ -0,0 +1,297 @@
+---
+name: deployment-platform-specialist
+category: tech
+description: Configure and optimize deployment platform settings for optimal performance and reliability
+usage: When deploying applications, configuring environments, optimizing builds, or troubleshooting deployments
+input: Deployment configuration, environment variables, build settings, platform type
+output: Platform configuration files, deployment strategy, optimization recommendations
+config_required:
+  - platform_name: "Deployment platform (e.g., Vercel, Netlify, AWS Amplify)"
+  - project_framework: "Framework being deployed (Astro, Next.js, etc.)"
+  - build_command: "Command to build the project"
+  - output_directory: "Build output directory"
+  - node_version: "Node.js version requirement"
+---
+
+# Deployment Platform Specialist
+
+## ⚙️ Configuration
+
+| Setting | Description | Example |
+|---------|-------------|---------|
+| `platform_name` | Deployment platform | `Vercel`, `Netlify`, `AWS Amplify` |
+| `project_framework` | Framework | `Astro`, `Next.js`, `TanStack Start` |
+| `build_command` | Build command | `pnpm build`, `npm run build` |
+| `output_directory` | Output folder | `dist`, `.next`, `build` |
+| `install_command` | Install command | `pnpm install`, `npm install` |
+| `node_version` | Node version | `18.x`, `20.x` |
+| `environment` | Target environment | `production`, `preview`, `development` |
+
+## Purpose
+
+Expert guidance on deployment platform configuration, environment management, build optimization, and production best practices.
+
+## Capabilities
+
+- Platform configuration and setup
+- Environment variable management
+- Build performance optimization
+- Preview and production deployments
+- Custom domain configuration
+- Edge function implementation
+- Monitoring and analytics setup
+
+## Project Configuration
+
+### Platform Config File
+
+```json
+{
+  "framework": "astro",
+  "buildCommand": "pnpm build",
+  "outputDirectory": "dist",
+  "installCommand": "pnpm install",
+  "devCommand": "pnpm dev",
+  "nodeVersion": "20.x",
+  "regions": ["iad1"],
+  "rewrites": [
+    { "source": "/api/:path*", "destination": "/api/:path*" }
+  ],
+  "headers": [
+    {
+      "source": "/(.*)",
+      "headers": [
+        { "key": "X-Content-Type-Options", "value": "nosniff" },
+        { "key": "X-Frame-Options", "value": "DENY" },
+        { "key": "X-XSS-Protection", "value": "1; mode=block" }
+      ]
+    }
+  ]
+}
+```
+
+## Environment Variables
+
+### Setup
+
+Configure via platform dashboard or CLI:
+
+```bash
+# Add variable
+platform-cli env add DATABASE_URL production
+
+# Pull variables locally
+platform-cli env pull .env.local
+
+# Set variable for all environments
+platform-cli env add API_KEY
+```
+
+### Organization
+
+| Environment | Purpose | Examples |
+|-------------|---------|----------|
+| `production` | Live site | Production DB, live API keys |
+| `preview` | PR previews | Staging DB, test API keys |
+| `development` | Local dev | Local DB, dev API keys |
+
+### Security
+
+- Never commit secrets to git
+- Use platform secret storage
+- Rotate keys regularly
+- Scope variables appropriately
+
+## Build Optimization
+
+### Caching Strategy
+
+```json
+{
+  "caching": {
+    "dependencies": true,
+    "buildOutputs": true,
+    "staticAssets": "max-age=31536000, immutable"
+  },
+  "build": {
+    "env": {
+      "NEXT_TELEMETRY_DISABLED": "1",
+      "NODE_ENV": "production"
+    }
+  }
+}
+```
+
+### Performance Targets
+
+| Metric | Target |
+|--------|--------|
+| Build time | < 3 minutes |
+| Cache hit rate | > 80% |
+| Bundle size | Optimized and analyzed |
+| Build success rate | > 99% |
+
+## Deployment Workflow
+
+### Git Integration
+
+```yaml
+# Auto-deploy configuration
+production_branch: main
+preview_branches:
+  - develop
+  - feature/*
+  - fix/*
+
+ignore_paths:
+  - "docs/**"
+  - "*.md"
+  - ".github/**"
+```
+
+### Preview Deployments
+
+- Automatic on PRs
+- Unique URL per deployment
+- Comment on PR with preview link
+- Run deployment checks
+
+## Edge Functions
+
+### Middleware Example
+
+```typescript
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+export function middleware(request: NextRequest) {
+  // Authentication check
+  const token = request.cookies.get('auth-token');
+
+  if (!token && request.nextUrl.pathname.startsWith('/dashboard')) {
+    return NextResponse.redirect(new URL('/login', request.url));
+  }
+
+  return NextResponse.next();
+}
+
+export const config = {
+  matcher: '/dashboard/:path*',
+};
+```
+
+## Custom Domains
+
+### DNS Configuration
+
+| Type | Name | Value | TTL |
+|------|------|-------|-----|
+| A | @ | Platform IP | 3600 |
+| CNAME | www | Platform domain | 3600 |
+
+### SSL/TLS
+
+- Automatic SSL certificate
+- Force HTTPS redirect
+- HTTP/2 enabled
+- Certificate auto-renewal
+
+## Monitoring
+
+### Analytics Setup
+
+```typescript
+// Enable platform analytics
+export const config = {
+  runtime: 'edge',
+  analytics: true,
+};
+```
+
+### Metrics to Track
+
+- Page load time
+- Core Web Vitals (LCP, FID, CLS)
+- Error rate
+- Build success rate
+- Bandwidth usage
+
+## Performance Optimization
+
+### Headers Configuration
+
+```json
+{
+  "headers": [
+    {
+      "source": "/static/(.*)",
+      "headers": [
+        { "key": "Cache-Control", "value": "public, max-age=31536000, immutable" }
+      ]
+    },
+    {
+      "source": "/(.*)",
+      "headers": [
+        { "key": "X-DNS-Prefetch-Control", "value": "on" },
+        { "key": "Strict-Transport-Security", "value": "max-age=63072000" }
+      ]
+    }
+  ]
+}
+```
+
+### Redirects
+
+```json
+{
+  "redirects": [
+    {
+      "source": "/old-path",
+      "destination": "/new-path",
+      "permanent": true
+    },
+    {
+      "source": "/blog/:slug",
+      "destination": "/articles/:slug",
+      "permanent": false
+    }
+  ]
+}
+```
+
+## Best Practices
+
+| Practice | Description |
+|----------|-------------|
+| **Preview First** | Test in preview before production |
+| **Environment Separation** | Different variables per environment |
+| **Build Caching** | Enable for faster builds |
+| **Security Headers** | Set proper security headers |
+| **Analytics** | Monitor real user performance |
+| **Edge Functions** | Use for auth and routing |
+| **Automatic Deployments** | CI/CD with git integration |
+| **Domain Management** | Configure DNS and SSL properly |
+
+## Troubleshooting
+
+### Common Issues
+
+| Issue | Solution |
+|-------|----------|
+| Build timeout | Optimize dependencies, enable caching |
+| Environment variable missing | Check scope (production/preview) |
+| Function timeout | Optimize code or upgrade plan |
+| Cache not working | Verify cache headers configuration |
+
+## Checklist
+
+- [ ] Build command configured
+- [ ] Output directory correct
+- [ ] Environment variables set
+- [ ] Git integration active
+- [ ] Preview deployments enabled
+- [ ] Security headers configured
+- [ ] Custom domain configured (if needed)
+- [ ] SSL certificate active
+- [ ] Analytics enabled
+- [ ] Build time < 3 minutes

package/templates/skills/testing/api-app-testing.md

@@ -0,0 +1,254 @@
+---
+name: api-app-testing
+category: testing
+description: Comprehensive testing workflow for API endpoints with integration, error handling, and validation
+usage: Use when implementing or updating API routes to ensure complete test coverage
+input: API route file path, service layer, database models, validation schemas
+output: Integration test files, coverage reports, test documentation
+config_required:
+  - TEST_FRAMEWORK: "Your test framework (e.g., Vitest, Jest)"
+  - TEST_COMMAND: "Command to run tests (e.g., pnpm test)"
+  - COVERAGE_COMMAND: "Command to run coverage (e.g., pnpm test:coverage)"
+  - COVERAGE_TARGET: "Minimum coverage percentage (e.g., 90%)"
+  - API_FRAMEWORK: "API framework used (e.g., Hono, Express)"
+  - TEST_DB_SETUP: "How test database is configured (e.g., transactions, in-memory)"
+---
+
+# API Application Testing
+
+## ⚙️ Configuration
+
+| Setting | Description | Example |
+|---------|-------------|---------|
+| TEST_FRAMEWORK | Test framework used | `Vitest`, `Jest` |
+| TEST_COMMAND | Command to run tests | `pnpm test`, `npm test` |
+| COVERAGE_COMMAND | Command to run coverage | `pnpm test:coverage` |
+| COVERAGE_TARGET | Minimum coverage required | `90%` |
+| API_FRAMEWORK | API framework | `Hono`, `Express`, `Fastify` |
+| TEST_DB_SETUP | Database setup strategy | `Transactions`, `In-memory`, `Mocks` |
+| ORM_TOOL | ORM/Query builder | `Drizzle`, `Prisma`, `TypeORM` |
+
+## Purpose
+
+Systematic testing approach for API endpoints ensuring functionality, error handling, validation, and documentation accuracy.
+
+## Capabilities
+
+- Test all HTTP methods (GET, POST, PUT, PATCH, DELETE)
+- Validate request/response schemas
+- Test error scenarios and edge cases
+- Verify authentication and authorization
+- Test database integration
+- Measure test coverage
+- Validate API documentation
+
+## Workflow
+
+### 1. Test Planning
+
+**Actions:**
+- List all endpoints and HTTP methods
+- Review validation schemas
+- Prepare test data fixtures
+- Set up test database
+
+**Validation:**
+- [ ] All endpoints documented
+- [ ] Test data covers happy path and edge cases
+- [ ] Database/mocks configured
+
+### 2. Happy Path Testing
+
+**Test successful scenarios:**
+
+**GET endpoints:**
+- Fetch single resource
+- Fetch collection with pagination
+- Filter and sort operations
+
+**POST endpoints:**
+- Create resource with valid data
+- Verify database record created
+- Test idempotency if applicable
+
+**PUT/PATCH endpoints:**
+- Update resource (full/partial)
+- Confirm database update
+
+**DELETE endpoints:**
+- Delete resource
+- Verify cascade operations
+- Confirm 404 on re-fetch
+
+**Validation:**
+- [ ] Correct status codes (200, 201, 204)
+- [ ] Response bodies match schemas
+- [ ] Database state reflects changes
+
+### 3. Error Handling Testing
+
+**Test error scenarios:**
+
+**Validation Errors (400):**
+- Missing required fields
+- Invalid field types
+- Out-of-range values
+
+**Authentication Errors (401):**
+- Unauthenticated requests
+- Expired tokens
+- Invalid credentials
+
+**Authorization Errors (403):**
+- Insufficient permissions
+- Accessing other users' resources
+
+**Not Found Errors (404):**
+- Non-existent resource IDs
+- Deleted resources
+
+**Conflict Errors (409):**
+- Duplicate creation
+- Business logic violations
+
+**Server Errors (500):**
+- Database failures (mocked)
+- Third-party service failures
+
+**Validation:**
+- [ ] Correct error status codes
+- [ ] Descriptive error messages
+- [ ] No sensitive data leaked
+- [ ] Consistent error format
+
+### 4. Request/Response Validation
+
+**Test schema enforcement:**
+- Request body validation
+- Query parameter validation
+- Path parameter validation
+- Response schema compliance
+- Content-type headers
+- Request size limits
+
+**Validation:**
+- [ ] Invalid requests rejected
+- [ ] Validation errors descriptive
+- [ ] Response schemas enforced
+
+### 5. Integration Testing
+
+**Test full request-response cycle:**
+- Database transactions
+- Cascade operations
+- Relationship loading
+- Search and filtering
+- Pagination
+- Sorting
+
+**Validation:**
+- [ ] Database state correct
+- [ ] Transactions rolled back on errors
+- [ ] Performance acceptable
+
+### 6. Coverage Analysis
+
+**Actions:**
+1. Run tests with coverage: `{{COVERAGE_COMMAND}}`
+2. Review coverage report
+3. Identify untested code paths
+4. Add tests for uncovered areas
+
+**Validation:**
+- [ ] Coverage >= {{COVERAGE_TARGET}}
+- [ ] All endpoints tested
+- [ ] All error paths tested
+
+## Test Structure Example
+
+```typescript
+import { describe, it, expect, beforeAll, afterAll } from '{{TEST_FRAMEWORK}}';
+import { app } from '../src/index';
+import { testDb } from '../helpers/test-db';
+
+describe('/api/resources', () => {
+  beforeAll(async () => {
+    await testDb.seed();
+  });
+
+  afterAll(async () => {
+    await testDb.cleanup();
+  });
+
+  describe('GET /api/resources', () => {
+    it('should return paginated resources', async () => {
+      const response = await app.request('/api/resources?page=1&limit=10');
+
+      expect(response.status).toBe(200);
+      const data = await response.json();
+
+      expect(data).toHaveProperty('items');
+      expect(data.items).toBeInstanceOf(Array);
+    });
+  });
+
+  describe('POST /api/resources', () => {
+    it('should create resource with valid data', async () => {
+      const resource = {
+        name: 'Test Resource',
+        value: 100
+      };
+
+      const response = await app.request('/api/resources', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(resource)
+      });
+
+      expect(response.status).toBe(201);
+      const data = await response.json();
+      expect(data).toHaveProperty('id');
+    });
+
+    it('should reject invalid data', async () => {
+      const response = await app.request('/api/resources', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ invalid: 'data' })
+      });
+
+      expect(response.status).toBe(400);
+    });
+  });
+});
+```
+
+## Best Practices
+
+1. **Test Isolation**: Each test should be independent
+2. **AAA Pattern**: Arrange, Act, Assert
+3. **Descriptive Names**: Test names explain behavior
+4. **Mock External Dependencies**: Don't test third-party services
+5. **Database Transactions**: Rollback after tests
+6. **Fast Tests**: Keep total time under 5 seconds
+7. **Realistic Data**: Use production-like test data
+
+## Output
+
+**Produces:**
+- Integration test files
+- Test coverage reports (>= {{COVERAGE_TARGET}})
+- Documentation validation results
+- Test data fixtures
+
+**Success Criteria:**
+- All tests passing
+- Coverage meets target
+- No console warnings
+- Error handling comprehensive
+
+## Related Skills
+
+- `tdd-methodology` - Test-Driven Development approach
+- `security-testing` - API security testing
+- `performance-testing` - API performance testing