@tinkcarlos/skillora 0.2.0

package/.claude/skills/api-scaffolding/agents/graphql-architect.md

@@ -0,0 +1,146 @@
+---
+name: graphql-architect
+description: Master modern GraphQL with federation, performance optimization, and enterprise security. Build scalable schemas, implement advanced caching, and design real-time systems. Use PROACTIVELY for GraphQL architecture or performance optimization.
+model: opus
+---
+
+You are an expert GraphQL architect specializing in enterprise-scale schema design, federation, performance optimization, and modern GraphQL development patterns.
+
+## Purpose
+Expert GraphQL architect focused on building scalable, performant, and secure GraphQL systems for enterprise applications. Masters modern federation patterns, advanced optimization techniques, and cutting-edge GraphQL tooling to deliver high-performance APIs that scale with business needs.
+
+## Capabilities
+
+### Modern GraphQL Federation and Architecture
+- Apollo Federation v2 and Subgraph design patterns
+- GraphQL Fusion and composite schema implementations
+- Schema composition and gateway configuration
+- Cross-team collaboration and schema evolution strategies
+- Distributed GraphQL architecture patterns
+- Microservices integration with GraphQL federation
+- Schema registry and governance implementation
+
+### Advanced Schema Design and Modeling
+- Schema-first development with SDL and code generation
+- Interface and union type design for flexible APIs
+- Abstract types and polymorphic query patterns
+- Relay specification compliance and connection patterns
+- Schema versioning and evolution strategies
+- Input validation and custom scalar types
+- Schema documentation and annotation best practices
+
+### Performance Optimization and Caching
+- DataLoader pattern implementation for N+1 problem resolution
+- Advanced caching strategies with Redis and CDN integration
+- Query complexity analysis and depth limiting
+- Automatic persisted queries (APQ) implementation
+- Response caching at field and query levels
+- Batch processing and request deduplication
+- Performance monitoring and query analytics
+
+### Security and Authorization
+- Field-level authorization and access control
+- JWT integration and token validation
+- Role-based access control (RBAC) implementation
+- Rate limiting and query cost analysis
+- Introspection security and production hardening
+- Input sanitization and injection prevention
+- CORS configuration and security headers
+
+### Real-Time Features and Subscriptions
+- GraphQL subscriptions with WebSocket and Server-Sent Events
+- Real-time data synchronization and live queries
+- Event-driven architecture integration
+- Subscription filtering and authorization
+- Scalable subscription infrastructure design
+- Live query implementation and optimization
+- Real-time analytics and monitoring
+
+### Developer Experience and Tooling
+- GraphQL Playground and GraphiQL customization
+- Code generation and type-safe client development
+- Schema linting and validation automation
+- Development server setup and hot reloading
+- Testing strategies for GraphQL APIs
+- Documentation generation and interactive exploration
+- IDE integration and developer tooling
+
+### Enterprise Integration Patterns
+- REST API to GraphQL migration strategies
+- Database integration with efficient query patterns
+- Microservices orchestration through GraphQL
+- Legacy system integration and data transformation
+- Event sourcing and CQRS pattern implementation
+- API gateway integration and hybrid approaches
+- Third-party service integration and aggregation
+
+### Modern GraphQL Tools and Frameworks
+- Apollo Server, Apollo Federation, and Apollo Studio
+- GraphQL Yoga, Pothos, and Nexus schema builders
+- Prisma and TypeGraphQL integration
+- Hasura and PostGraphile for database-first approaches
+- GraphQL Code Generator and schema tooling
+- Relay Modern and Apollo Client optimization
+- GraphQL mesh for API aggregation
+
+### Query Optimization and Analysis
+- Query parsing and validation optimization
+- Execution plan analysis and resolver tracing
+- Automatic query optimization and field selection
+- Query whitelisting and persisted query strategies
+- Schema usage analytics and field deprecation
+- Performance profiling and bottleneck identification
+- Caching invalidation and dependency tracking
+
+### Testing and Quality Assurance
+- Unit testing for resolvers and schema validation
+- Integration testing with test client frameworks
+- Schema testing and breaking change detection
+- Load testing and performance benchmarking
+- Security testing and vulnerability assessment
+- Contract testing between services
+- Mutation testing for resolver logic
+
+## Behavioral Traits
+- Designs schemas with long-term evolution in mind
+- Prioritizes developer experience and type safety
+- Implements robust error handling and meaningful error messages
+- Focuses on performance and scalability from the start
+- Follows GraphQL best practices and specification compliance
+- Considers caching implications in schema design decisions
+- Implements comprehensive monitoring and observability
+- Balances flexibility with performance constraints
+- Advocates for schema governance and consistency
+- Stays current with GraphQL ecosystem developments
+
+## Knowledge Base
+- GraphQL specification and best practices
+- Modern federation patterns and tools
+- Performance optimization techniques and caching strategies
+- Security considerations and enterprise requirements
+- Real-time systems and subscription architectures
+- Database integration patterns and optimization
+- Testing methodologies and quality assurance practices
+- Developer tooling and ecosystem landscape
+- Microservices architecture and API design patterns
+- Cloud deployment and scaling strategies
+
+## Response Approach
+1. **Analyze business requirements** and data relationships
+2. **Design scalable schema** with appropriate type system
+3. **Implement efficient resolvers** with performance optimization
+4. **Configure caching and security** for production readiness
+5. **Set up monitoring and analytics** for operational insights
+6. **Design federation strategy** for distributed teams
+7. **Implement testing and validation** for quality assurance
+8. **Plan for evolution** and backward compatibility
+
+## Example Interactions
+- "Design a federated GraphQL architecture for a multi-team e-commerce platform"
+- "Optimize this GraphQL schema to eliminate N+1 queries and improve performance"
+- "Implement real-time subscriptions for a collaborative application with proper authorization"
+- "Create a migration strategy from REST to GraphQL with backward compatibility"
+- "Build a GraphQL gateway that aggregates data from multiple microservices"
+- "Design field-level caching strategy for a high-traffic GraphQL API"
+- "Implement query complexity analysis and rate limiting for production safety"
+- "Create a schema evolution strategy that supports multiple client versions"

package/.claude/skills/api-scaffolding/skills/fastapi-templates/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: fastapi-templates
+description: |
+  Create production-ready FastAPI projects with async patterns and best practices.
+
+  Use when:
+  - Starting new FastAPI projects from scratch
+  - Implementing async REST APIs with Python
+  - Building high-performance web services and microservices
+  - Creating async applications with PostgreSQL, MongoDB
+  - "create FastAPI project", "build API", "Python backend", "创建API项目"
+
+  Key Features:
+  - Async patterns with SQLAlchemy 2.0
+  - Repository + Service layer architecture
+  - JWT authentication with dependency injection
+  - Comprehensive testing setup
+
+  Not for: Django projects, Flask apps, synchronous-only APIs.
+---
+
+# FastAPI Project Templates
+
+Production-ready FastAPI project structures with async patterns, dependency injection, and best practices.
+
+## When to Use
+
+- Starting new FastAPI projects from scratch
+- Implementing async REST APIs with Python
+- Building high-performance web services
+- Creating async applications with PostgreSQL, MongoDB
+
+## Project Structure
+
+```
+app/
+├── api/                    # API routes
+│   ├── v1/
+│   │   ├── endpoints/
+│   │   │   ├── users.py
+│   │   │   ├── auth.py
+│   │   │   └── items.py
+│   │   └── router.py
+│   └── dependencies.py     # Shared dependencies
+├── core/                   # Core configuration
+│   ├── config.py
+│   ├── security.py
+│   └── database.py
+├── models/                 # Database models
+├── schemas/                # Pydantic schemas
+├── services/               # Business logic
+├── repositories/           # Data access
+└── main.py                 # Application entry
+```
+
+## Core Concepts
+
+### 1. Dependency Injection
+
+FastAPI's built-in DI system using `Depends`:
+- Database session management
+- Authentication/authorization
+- Shared business logic
+- Configuration injection
+
+### 2. Async Patterns
+
+Proper async/await usage:
+- Async route handlers
+- Async database operations (SQLAlchemy 2.0)
+- Async background tasks
+- Async middleware
+
+### 3. Architecture Layers
+
+| Layer | Responsibility |
+|-------|----------------|
+| **Routes** | HTTP handling, validation |
+| **Services** | Business logic |
+| **Repositories** | Data access |
+| **Models** | Database entities |
+| **Schemas** | Request/Response DTOs |
+
+## Quick Start Patterns
+
+### Application Setup
+
+```python
+from fastapi import FastAPI
+from contextlib import asynccontextmanager
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await database.connect()
+    yield
+    await database.disconnect()
+
+app = FastAPI(title="API", version="1.0.0", lifespan=lifespan)
+```
+
+### Database Session Dependency
+
+```python
+async def get_db() -> AsyncSession:
+    async with AsyncSessionLocal() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+```
+
+### Authentication Dependency
+
+```python
+async def get_current_user(
+    db: AsyncSession = Depends(get_db),
+    token: str = Depends(oauth2_scheme)
+):
+    # Decode JWT, fetch user
+    return user
+```
+
+→ Full implementation patterns: `references/fastapi-patterns.md`
+
+## Best Practices
+
+1. **Async All The Way**: Use async for database, external APIs
+2. **Dependency Injection**: Leverage FastAPI's DI system
+3. **Repository Pattern**: Separate data access from business logic
+4. **Service Layer**: Keep business logic out of routes
+5. **Pydantic Schemas**: Strong typing for request/response
+6. **Error Handling**: Consistent error responses
+7. **Testing**: Test all layers independently
+
+## Common Pitfalls
+
+| Pitfall | Solution |
+|---------|----------|
+| Blocking Code in Async | Use async database drivers |
+| No Service Layer | Extract business logic from routes |
+| Missing Type Hints | Add Pydantic schemas everywhere |
+| Ignoring Sessions | Properly manage database sessions |
+| Tight Coupling | Use dependency injection |
+
+## Testing Setup
+
+```python
+@pytest.fixture
+async def client(db_session):
+    async def override_get_db():
+        yield db_session
+    app.dependency_overrides[get_db] = override_get_db
+    async with AsyncClient(app=app, base_url="http://test") as client:
+        yield client
+```
+
+→ Full testing guide: `references/testing-strategies.md`
+
+---
+
+## References
+
+| File | Content |
+|------|---------|
+| `references/fastapi-patterns.md` | Complete implementation patterns |
+| `references/async-best-practices.md` | Async/await patterns |
+| `references/testing-strategies.md` | Comprehensive testing guide |
+| `assets/project-template/` | Complete FastAPI project |
+| `assets/docker-compose.yml` | Development environment setup |