moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-domain-backend/SKILL.md

@@ -1,27 +1,33 @@
 ---
-name: moai-domain-backend
-description: Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns
+name: "moai-domain-backend"
+description: "Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns"
 version: 1.0.0
-category: domain
-allowed-tools: Read, Write, Edit, Bash, Grep, Glob
-tags:
- - backend
- - api
- - database
- - microservices
- - architecture
-updated: 2025-12-06
-status: active
-author: MoAI-ADK Team
+category: "domain"
+modularized: false
+user-invocable: false
+tags: ['backend', 'api', 'database', 'microservices', 'architecture']
+updated: 2026-01-11
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+  - Glob
+  - mcp__context7__resolve-library-id
+  - mcp__context7__get-library-docs
+status: "active"
+author: "MoAI-ADK Team"
 ---
 
 # Backend Development Specialist
 
-## Quick Reference (30 seconds)
+## Quick Reference
 
 Backend Development Mastery - Comprehensive backend development patterns covering API design, database integration, microservices, and modern architecture patterns.
 
 Core Capabilities:
+
 - API Design: REST, GraphQL, gRPC with OpenAPI 3.1
 - Database Integration: PostgreSQL, MongoDB, Redis, caching strategies
 - Microservices: Service mesh, distributed patterns, event-driven architecture
@@ -29,6 +35,7 @@ Core Capabilities:
 - Performance: Caching, optimization, monitoring, scaling
 
 When to Use:
+
 - Backend API development and architecture
 - Database design and optimization
 - Microservices implementation
@@ -42,145 +49,32 @@ When to Use:
 ### API Design Patterns
 
 RESTful API Architecture:
-```python
-from fastapi import FastAPI, Depends, HTTPException
-from fastapi.security import HTTPBearer
-from pydantic import BaseModel
-from typing import List, Optional
-
-app = FastAPI(title="Modern API", version="2.0.0")
-security = HTTPBearer()
-
-class UserResponse(BaseModel):
- id: int
- email: str
- name: str
-
-@app.get("/users", response_model=List[UserResponse])
-async def list_users(token: str = Depends(security)):
- """List users with authentication."""
- return await user_service.get_all_users()
-
-@app.post("/users", response_model=UserResponse)
-async def create_user(user: UserCreate):
- """Create new user with validation."""
- return await user_service.create(user)
-```
-
-GraphQL Implementation:
-```python
-import strawberry
-from typing import List
 
-@strawberry.type
-class User:
- id: int
- email: str
- name: str
+Create a FastAPI application with authentication and response models. Define a Pydantic UserResponse model with id, email, and name fields. Implement list_users and create_user endpoints with HTTPBearer security dependency. The list endpoint returns a list of UserResponse objects, while the create endpoint accepts a UserCreate model and returns a single UserResponse.
 
-@strawberry.type
-class Query:
- @strawberry.field
- async def users(self) -> List[User]:
- return await user_service.get_all_users()
+GraphQL Implementation:
 
-schema = strawberry.Schema(query=Query)
-```
+Use Strawberry to define GraphQL types. Create a User type with id, email, and name fields. Define a Query type with a users resolver that returns a list of User objects asynchronously. Generate the schema by passing the Query type to strawberry.Schema.
 
 ### Database Integration Patterns
 
 PostgreSQL with SQLAlchemy:
-```python
-from sqlalchemy import create_engine, Column, Integer, String
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-
-Base = declarative_base()
 
-class User(Base):
- __tablename__ = "users"
-
- id = Column(Integer, primary_key=True)
- email = Column(String, unique=True)
- name = Column(String)
-
-# Connection pooling and optimization
-engine = create_engine(
- DATABASE_URL,
- pool_size=20,
- max_overflow=30,
- pool_pre_ping=True
-)
-```
+Define SQLAlchemy models using declarative_base. Create a User model with id as primary key, email as unique string, and name as string column. Configure the engine with connection pooling parameters including pool_size of 20, max_overflow of 30, and pool_pre_ping enabled for connection health checks.
 
 MongoDB with Motor:
-```python
-from motor.motor_asyncio import AsyncIOMotorClient
-from pymongo import IndexModel
-
-class UserService:
- def __init__(self, client: AsyncIOMotorClient):
- self.db = client.myapp
- self.users = self.db.users
-
- # Index optimization
- self.users.create_indexes([
- IndexModel("email", unique=True),
- IndexModel("created_at")
- ])
-
- async def create_user(self, user_data: dict) -> str:
- result = await self.users.insert_one(user_data)
- return str(result.inserted_id)
-```
+
+Create a UserService class that initializes with an AsyncIOMotorClient. Set up the database and users collection in the constructor. Create indexes for email (unique) and created_at fields. Implement create_user method that inserts a document and returns the inserted_id as string.
 
 ### Microservices Architecture
 
 Service Discovery with Consul:
-```python
-import consul
-
-class ServiceRegistry:
- def __init__(self, consul_host="localhost", consul_port=8500):
- self.consul = consul.Consul(host=consul_host, port=consul_port)
-
- def register_service(self, service_name: str, service_id: str, port: int):
- self.consul.agent.service.register(
- name=service_name,
- service_id=service_id,
- port=port,
- check=consul.Check.http(f"http://localhost:{port}/health", interval="10s")
- )
-
- def discover_service(self, service_name: str) -> List[str]:
- _, services = self.consul.health.service(service_name, passing=True)
- return [f"{s['Service']['Address']}:{s['Service']['Port']}" for s in services]
-```
+
+Create a ServiceRegistry class that connects to Consul. Implement register_service method that registers a service with name, id, port, and health check endpoint. Implement discover_service method that queries healthy services and returns list of address:port strings.
 
 Event-Driven Architecture:
-```python
-import asyncio
-from aio_pika import connect_robust
-
-class EventBus:
- def __init__(self, amqp_url: str):
- self.connection = None
- self.channel = None
- self.amqp_url = amqp_url
-
- async def connect(self):
- self.connection = await connect_robust(self.amqp_url)
- self.channel = await self.connection.channel()
-
- async def publish_event(self, event_type: str, data: dict):
- await self.channel.default_exchange.publish(
- aio_pika.Message(
- json.dumps({"type": event_type, "data": data}).encode(),
- content_type="application/json"
- ),
- routing_key=event_type
- )
-```
+
+Create an EventBus class using aio_pika for AMQP messaging. Implement connect method to establish connection and channel. Implement publish_event method that serializes event type and data as JSON and publishes to the default exchange with routing_key matching the event type.
 
 ---
 
@@ -189,99 +83,20 @@ class EventBus:
 ### Caching Strategies
 
 Redis Integration:
-```python
-import redis.asyncio as redis
-from functools import wraps
-import json
-import hashlib
-
-class CacheManager:
- def __init__(self, redis_url: str):
- self.redis = redis.from_url(redis_url)
-
- def cache_result(self, ttl: int = 3600):
- def decorator(func):
- @wraps(func)
- async def wrapper(*args, kwargs):
- cache_key = self._generate_cache_key(func.__name__, args, kwargs)
-
- # Try to get from cache
- cached = await self.redis.get(cache_key)
- if cached:
- return json.loads(cached)
-
- # Execute function and cache result
- result = await func(*args, kwargs)
- await self.redis.setex(
- cache_key,
- ttl,
- json.dumps(result, default=str)
- )
- return result
- return wrapper
- return decorator
-```
+
+Create a CacheManager class with Redis connection. Implement a cache_result decorator that accepts ttl parameter. The decorator generates cache keys from function name and arguments, checks Redis for cached results, executes the function on cache miss, and stores results with expiration. Use json.loads and json.dumps for serialization.
 
 ### Security Implementation
 
 JWT Authentication:
-```python
-import jwt
-from datetime import datetime, timedelta
-from passlib.context import CryptContext
-
-class SecurityManager:
- def __init__(self, secret_key: str):
- self.secret_key = secret_key
- self.pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
- def hash_password(self, password: str) -> str:
- return self.pwd_context.hash(password)
-
- def verify_password(self, plain_password: str, hashed_password: str) -> bool:
- return self.pwd_context.verify(plain_password, hashed_password)
-
- def create_access_token(self, data: dict, expires_delta: timedelta = None) -> str:
- to_encode = data.copy()
- if expires_delta:
- expire = datetime.utcnow() + expires_delta
- else:
- expire = datetime.utcnow() + timedelta(minutes=15)
 
- to_encode.update({"exp": expire})
- return jwt.encode(to_encode, self.secret_key, algorithm="HS256")
-```
+Create a SecurityManager class with CryptContext for bcrypt password hashing. Implement hash_password and verify_password methods using the context. Implement create_access_token that encodes a JWT with expiration time using HS256 algorithm. Default expiration is 15 minutes if not specified.
 
 ### Performance Optimization
 
 Database Connection Pooling:
-```python
-from sqlalchemy.pool import QueuePool
-from sqlalchemy import event
-
-def create_optimized_engine(database_url: str):
- engine = create_engine(
- database_url,
- poolclass=QueuePool,
- pool_size=20,
- max_overflow=30,
- pool_pre_ping=True,
- pool_recycle=3600,
- echo=False
- )
-
- @event.listens_for(engine, "before_cursor_execute")
- def receive_before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
- context._query_start_time = time.time()
-
- @event.listens_for(engine, "after_cursor_execute")
- def receive_after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
- total = time.time() - context._query_start_time
- if total > 0.1: # Log slow queries
- logger.warning(f"Slow query: {total:.2f}s - {statement[:100]}")
-
- return engine
-```
+
+Create an optimized SQLAlchemy engine with QueuePool, pool_size 20, max_overflow 30, pool_pre_ping enabled, and pool_recycle of 3600 seconds. Add event listeners for before_cursor_execute and after_cursor_execute to track query timing. Log warnings for queries exceeding 100ms threshold.
 
 ---
 
@@ -298,6 +113,7 @@ def create_optimized_engine(database_url: str):
 ## Technology Stack
 
 Primary Technologies:
+
 - Languages: Python 3.13+, Node.js 20+, Go 1.23
 - Frameworks: FastAPI, Django, Express.js, Gin
 - Databases: PostgreSQL 16+, MongoDB 7+, Redis 7+
@@ -306,6 +122,7 @@ Primary Technologies:
 - Monitoring: Prometheus, Grafana, OpenTelemetry
 
 Integration Patterns:
+
 - RESTful APIs with OpenAPI 3.1
 - GraphQL with Apollo Federation
 - gRPC for high-performance services
@@ -315,6 +132,10 @@ Integration Patterns:
 
 ---
 
+## Resources
+
+For working code examples, see [examples.md](examples.md).
+
 Status: Production Ready
-Last Updated: 2025-11-30
+Last Updated: 2026-01-11
 Maintained by: MoAI-ADK Backend Team