autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/diesel.md

@@ -0,0 +1,392 @@
+# Diesel ORM Skill
+
+## Setup and Configuration
+\`\`\`bash
+# Install diesel CLI
+cargo install diesel_cli --no-default-features --features postgres
+
+# Initialize diesel
+diesel setup
+
+# Create migration
+diesel migration generate create_users
+
+# Run migrations
+diesel migration run
+
+# Revert migration
+diesel migration revert
+\`\`\`
+
+## Schema Definition (schema.rs - auto-generated)
+\`\`\`rust
+// src/schema.rs - Generated by diesel migration run
+diesel::table! {
+    users (id) {
+        id -> Uuid,
+        email -> Varchar,
+        name -> Varchar,
+        password_hash -> Varchar,
+        is_active -> Bool,
+        created_at -> Timestamptz,
+        updated_at -> Timestamptz,
+    }
+}
+
+diesel::table! {
+    posts (id) {
+        id -> Uuid,
+        title -> Varchar,
+        content -> Text,
+        published -> Bool,
+        author_id -> Uuid,
+        created_at -> Timestamptz,
+        updated_at -> Timestamptz,
+    }
+}
+
+diesel::table! {
+    comments (id) {
+        id -> Uuid,
+        post_id -> Uuid,
+        user_id -> Uuid,
+        content -> Text,
+        created_at -> Timestamptz,
+    }
+}
+
+diesel::joinable!(posts -> users (author_id));
+diesel::joinable!(comments -> posts (post_id));
+diesel::joinable!(comments -> users (user_id));
+
+diesel::allow_tables_to_appear_in_same_query!(
+    users,
+    posts,
+    comments,
+);
+\`\`\`
+
+## Model Definitions
+\`\`\`rust
+use diesel::prelude::*;
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+// Queryable - for SELECT queries
+#[derive(Debug, Clone, Queryable, Selectable, Serialize)]
+#[diesel(table_name = crate::schema::users)]
+pub struct User {
+    pub id: Uuid,
+    pub email: String,
+    pub name: String,
+    #[serde(skip_serializing)]
+    pub password_hash: String,
+    pub is_active: bool,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+
+// Insertable - for INSERT queries
+#[derive(Debug, Insertable)]
+#[diesel(table_name = crate::schema::users)]
+pub struct NewUser {
+    pub id: Uuid,
+    pub email: String,
+    pub name: String,
+    pub password_hash: String,
+    pub is_active: bool,
+}
+
+impl NewUser {
+    pub fn new(email: &str, name: &str, password: &str) -> Result<Self, AppError> {
+        let password_hash = hash_password(password)?;
+        Ok(Self {
+            id: Uuid::new_v4(),
+            email: email.to_string(),
+            name: name.to_string(),
+            password_hash,
+            is_active: true,
+        })
+    }
+}
+
+// AsChangeset - for UPDATE queries
+#[derive(Debug, AsChangeset)]
+#[diesel(table_name = crate::schema::users)]
+pub struct UpdateUser {
+    pub name: Option<String>,
+    pub email: Option<String>,
+    pub is_active: Option<bool>,
+    pub updated_at: DateTime<Utc>,
+}
+
+// Associations
+#[derive(Debug, Queryable, Selectable, Associations, Serialize)]
+#[diesel(table_name = crate::schema::posts)]
+#[diesel(belongs_to(User, foreign_key = author_id))]
+pub struct Post {
+    pub id: Uuid,
+    pub title: String,
+    pub content: String,
+    pub published: bool,
+    pub author_id: Uuid,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+\`\`\`
+
+## Connection Pool
+\`\`\`rust
+use diesel::pg::PgConnection;
+use diesel::r2d2::{self, ConnectionManager, Pool, PooledConnection};
+use std::env;
+
+pub type DbPool = Pool<ConnectionManager<PgConnection>>;
+pub type DbConnection = PooledConnection<ConnectionManager<PgConnection>>;
+
+pub fn create_pool() -> DbPool {
+    let database_url = env::var("DATABASE_URL")
+        .expect("DATABASE_URL must be set");
+
+    let manager = ConnectionManager::<PgConnection>::new(database_url);
+
+    Pool::builder()
+        .max_size(10)
+        .min_idle(Some(2))
+        .build(manager)
+        .expect("Failed to create pool")
+}
+
+// Get connection from pool
+pub fn get_conn(pool: &DbPool) -> Result<DbConnection, AppError> {
+    pool.get().map_err(|e| AppError::Database(e.to_string()))
+}
+\`\`\`
+
+## CRUD Operations
+\`\`\`rust
+use diesel::prelude::*;
+use crate::schema::users::dsl::*;
+
+pub struct UserRepository;
+
+impl UserRepository {
+    // Create
+    pub fn create(conn: &mut PgConnection, new_user: NewUser) -> Result<User, AppError> {
+        diesel::insert_into(users)
+            .values(&new_user)
+            .returning(User::as_returning())
+            .get_result(conn)
+            .map_err(|e| AppError::Database(e.to_string()))
+    }
+
+    // Read by ID
+    pub fn find_by_id(conn: &mut PgConnection, user_id: Uuid) -> Result<Option<User>, AppError> {
+        users
+            .filter(id.eq(user_id))
+            .select(User::as_select())
+            .first(conn)
+            .optional()
+            .map_err(|e| AppError::Database(e.to_string()))
+    }
+
+    // Read by email
+    pub fn find_by_email(conn: &mut PgConnection, user_email: &str) -> Result<Option<User>, AppError> {
+        users
+            .filter(email.eq(user_email))
+            .select(User::as_select())
+            .first(conn)
+            .optional()
+            .map_err(|e| AppError::Database(e.to_string()))
+    }
+
+    // List with pagination
+    pub fn list(
+        conn: &mut PgConnection,
+        page: i64,
+        per_page: i64,
+    ) -> Result<(Vec<User>, i64), AppError> {
+        let offset = (page - 1) * per_page;
+
+        let results = users
+            .filter(is_active.eq(true))
+            .order(created_at.desc())
+            .offset(offset)
+            .limit(per_page)
+            .select(User::as_select())
+            .load(conn)
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        let total: i64 = users
+            .filter(is_active.eq(true))
+            .count()
+            .get_result(conn)
+            .map_err(|e| AppError::Database(e.to_string()))?;
+
+        Ok((results, total))
+    }
+
+    // Update
+    pub fn update(
+        conn: &mut PgConnection,
+        user_id: Uuid,
+        changeset: UpdateUser,
+    ) -> Result<User, AppError> {
+        diesel::update(users.filter(id.eq(user_id)))
+            .set(&changeset)
+            .returning(User::as_returning())
+            .get_result(conn)
+            .map_err(|e| AppError::Database(e.to_string()))
+    }
+
+    // Delete
+    pub fn delete(conn: &mut PgConnection, user_id: Uuid) -> Result<usize, AppError> {
+        diesel::delete(users.filter(id.eq(user_id)))
+            .execute(conn)
+            .map_err(|e| AppError::Database(e.to_string()))
+    }
+}
+\`\`\`
+
+## Complex Queries
+\`\`\`rust
+use diesel::prelude::*;
+use crate::schema::{users, posts, comments};
+
+// Join queries
+pub fn get_user_with_posts(
+    conn: &mut PgConnection,
+    user_id: Uuid,
+) -> Result<(User, Vec<Post>), AppError> {
+    let user = users::table
+        .filter(users::id.eq(user_id))
+        .select(User::as_select())
+        .first(conn)?;
+
+    let user_posts = Post::belonging_to(&user)
+        .select(Post::as_select())
+        .load(conn)?;
+
+    Ok((user, user_posts))
+}
+
+// Load posts with authors
+pub fn get_posts_with_authors(
+    conn: &mut PgConnection,
+) -> Result<Vec<(Post, User)>, AppError> {
+    posts::table
+        .inner_join(users::table)
+        .filter(posts::published.eq(true))
+        .order(posts::created_at.desc())
+        .select((Post::as_select(), User::as_select()))
+        .load(conn)
+        .map_err(|e| AppError::Database(e.to_string()))
+}
+
+// Aggregate query
+pub fn get_post_stats(conn: &mut PgConnection, post_id: Uuid) -> Result<PostStats, AppError> {
+    use diesel::dsl::count;
+
+    let comment_count: i64 = comments::table
+        .filter(comments::post_id.eq(post_id))
+        .select(count(comments::id))
+        .first(conn)?;
+
+    Ok(PostStats { comment_count })
+}
+
+// Raw SQL when needed
+use diesel::sql_query;
+use diesel::sql_types::{Uuid as SqlUuid, BigInt};
+
+#[derive(QueryableByName, Debug)]
+pub struct UserStats {
+    #[diesel(sql_type = SqlUuid)]
+    pub user_id: Uuid,
+    #[diesel(sql_type = BigInt)]
+    pub post_count: i64,
+    #[diesel(sql_type = BigInt)]
+    pub comment_count: i64,
+}
+
+pub fn get_user_stats(conn: &mut PgConnection, user_id: Uuid) -> Result<UserStats, AppError> {
+    sql_query(r#"
+        SELECT
+            u.id as user_id,
+            COUNT(DISTINCT p.id) as post_count,
+            COUNT(DISTINCT c.id) as comment_count
+        FROM users u
+        LEFT JOIN posts p ON p.author_id = u.id
+        LEFT JOIN comments c ON c.user_id = u.id
+        WHERE u.id = $1
+        GROUP BY u.id
+    "#)
+    .bind::<SqlUuid, _>(user_id)
+    .get_result(conn)
+    .map_err(|e| AppError::Database(e.to_string()))
+}
+\`\`\`
+
+## Transactions
+\`\`\`rust
+use diesel::Connection;
+
+pub fn create_user_with_profile(
+    conn: &mut PgConnection,
+    new_user: NewUser,
+    new_profile: NewProfile,
+) -> Result<(User, Profile), AppError> {
+    conn.transaction(|conn| {
+        let user = diesel::insert_into(users::table)
+            .values(&new_user)
+            .returning(User::as_returning())
+            .get_result(conn)?;
+
+        let profile = diesel::insert_into(profiles::table)
+            .values(&NewProfile { user_id: user.id, ..new_profile })
+            .returning(Profile::as_returning())
+            .get_result(conn)?;
+
+        Ok((user, profile))
+    })
+    .map_err(|e: diesel::result::Error| AppError::Database(e.to_string()))
+}
+
+// Nested transaction with savepoints
+pub fn complex_operation(conn: &mut PgConnection) -> Result<(), AppError> {
+    conn.transaction(|conn| {
+        // First operation
+        create_user(conn, user1)?;
+
+        // Savepoint for nested transaction
+        let result = conn.transaction(|conn| {
+            create_user(conn, user2)
+        });
+
+        // Handle nested transaction failure
+        if let Err(e) = result {
+            tracing::warn!("Nested transaction failed: {:?}", e);
+            // Outer transaction continues
+        }
+
+        Ok(())
+    })
+}
+\`\`\`
+
+## ✅ DO
+- Use \`Queryable\` and \`Selectable\` for SELECT
+- Use \`Insertable\` for INSERT
+- Use \`AsChangeset\` for UPDATE
+- Use \`#[diesel(belongs_to(...))]\` for associations
+- Use connection pools (r2d2) in production
+- Use transactions for multi-step operations
+- Use \`.optional()\` for queries that may return no results
+
+## ❌ DON'T
+- Don't use \`.get_result()\` when you don't need the result
+- Don't forget to run \`diesel migration run\` after schema changes
+- Don't manually write schema.rs (it's auto-generated)
+- Don't use \`.first()\` without \`.optional()\` unless you're sure it exists
+- Don't hold connections longer than necessary

package/.claude/skills/django.md

@@ -0,0 +1,301 @@
+# Django Skill
+
+## Project Structure
+\`\`\`
+myproject/
+├── manage.py
+├── config/                  # Project settings
+│   ├── __init__.py
+│   ├── settings/
+│   │   ├── base.py
+│   │   ├── development.py
+│   │   └── production.py
+│   ├── urls.py
+│   └── wsgi.py
+└── apps/
+    └── users/
+        ├── __init__.py
+        ├── admin.py
+        ├── apps.py
+        ├── models.py
+        ├── views.py
+        ├── serializers.py    # DRF
+        ├── urls.py
+        ├── signals.py
+        ├── tasks.py          # Celery
+        └── tests/
+            ├── test_models.py
+            └── test_views.py
+\`\`\`
+
+## Models
+\`\`\`python
+from django.db import models
+from django.contrib.auth.models import AbstractUser
+
+class User(AbstractUser):
+    email = models.EmailField(unique=True)
+    bio = models.TextField(blank=True)
+    avatar = models.ImageField(upload_to='avatars/', null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    USERNAME_FIELD = 'email'
+    REQUIRED_FIELDS = ['username']
+
+    class Meta:
+        ordering = ['-created_at']
+        indexes = [
+            models.Index(fields=['email']),
+            models.Index(fields=['-created_at']),
+        ]
+
+    def __str__(self):
+        return self.email
+
+    @property
+    def full_name(self):
+        return f"{self.first_name} {self.last_name}".strip()
+
+class Post(models.Model):
+    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='posts')
+    title = models.CharField(max_length=200)
+    content = models.TextField()
+    published = models.BooleanField(default=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        ordering = ['-created_at']
+
+    # Manager for common queries
+    objects = models.Manager()
+
+    class PublishedManager(models.Manager):
+        def get_queryset(self):
+            return super().get_queryset().filter(published=True)
+
+    published_objects = PublishedManager()
+\`\`\`
+
+## Django REST Framework
+\`\`\`python
+# serializers.py
+from rest_framework import serializers
+
+class UserSerializer(serializers.ModelSerializer):
+    full_name = serializers.ReadOnlyField()
+    posts_count = serializers.SerializerMethodField()
+
+    class Meta:
+        model = User
+        fields = ['id', 'email', 'username', 'full_name', 'posts_count', 'created_at']
+        read_only_fields = ['id', 'created_at']
+
+    def get_posts_count(self, obj):
+        return obj.posts.count()
+
+class UserCreateSerializer(serializers.ModelSerializer):
+    password = serializers.CharField(write_only=True, min_length=8)
+
+    class Meta:
+        model = User
+        fields = ['email', 'username', 'password']
+
+    def create(self, validated_data):
+        return User.objects.create_user(**validated_data)
+
+# views.py
+from rest_framework import viewsets, permissions, status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+
+class UserViewSet(viewsets.ModelViewSet):
+    queryset = User.objects.all()
+    permission_classes = [permissions.IsAuthenticated]
+
+    def get_serializer_class(self):
+        if self.action == 'create':
+            return UserCreateSerializer
+        return UserSerializer
+
+    def get_queryset(self):
+        # Optimize queries
+        return User.objects.prefetch_related('posts').all()
+
+    @action(detail=False, methods=['get'])
+    def me(self, request):
+        serializer = self.get_serializer(request.user)
+        return Response(serializer.data)
+
+    @action(detail=True, methods=['post'])
+    def follow(self, request, pk=None):
+        user = self.get_object()
+        request.user.following.add(user)
+        return Response({'status': 'following'})
+
+# urls.py
+from rest_framework.routers import DefaultRouter
+
+router = DefaultRouter()
+router.register('users', UserViewSet)
+
+urlpatterns = router.urls
+\`\`\`
+
+## Views (Class-Based)
+\`\`\`python
+from django.views.generic import ListView, DetailView, CreateView
+from django.contrib.auth.mixins import LoginRequiredMixin
+
+class PostListView(ListView):
+    model = Post
+    template_name = 'posts/list.html'
+    context_object_name = 'posts'
+    paginate_by = 10
+
+    def get_queryset(self):
+        return Post.published_objects.select_related('author')
+
+class PostDetailView(DetailView):
+    model = Post
+    template_name = 'posts/detail.html'
+
+class PostCreateView(LoginRequiredMixin, CreateView):
+    model = Post
+    fields = ['title', 'content']
+    success_url = '/posts/'
+
+    def form_valid(self, form):
+        form.instance.author = self.request.user
+        return super().form_valid(form)
+\`\`\`
+
+## Signals
+\`\`\`python
+# signals.py
+from django.db.models.signals import post_save, pre_delete
+from django.dispatch import receiver
+from django.core.mail import send_mail
+
+@receiver(post_save, sender=User)
+def send_welcome_email(sender, instance, created, **kwargs):
+    if created:
+        send_mail(
+            'Welcome!',
+            'Thanks for signing up.',
+            'noreply@example.com',
+            [instance.email],
+        )
+
+@receiver(pre_delete, sender=User)
+def cleanup_user_data(sender, instance, **kwargs):
+    # Clean up related data
+    instance.posts.all().delete()
+
+# apps.py - Register signals
+class UsersConfig(AppConfig):
+    name = 'apps.users'
+
+    def ready(self):
+        import apps.users.signals  # noqa
+\`\`\`
+
+## Middleware
+\`\`\`python
+# middleware.py
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+class RequestTimingMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        start_time = time.time()
+        response = self.get_response(request)
+        duration = time.time() - start_time
+        logger.info(f"{request.method} {request.path} - {duration:.2f}s")
+        return response
+
+class CurrentUserMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        # Make user available in thread-local
+        from threading import local
+        _thread_locals = local()
+        _thread_locals.user = request.user
+        return self.get_response(request)
+\`\`\`
+
+## Admin Customization
+\`\`\`python
+from django.contrib import admin
+from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
+
+@admin.register(User)
+class UserAdmin(BaseUserAdmin):
+    list_display = ['email', 'username', 'is_active', 'created_at']
+    list_filter = ['is_active', 'is_staff', 'created_at']
+    search_fields = ['email', 'username']
+    ordering = ['-created_at']
+
+    fieldsets = BaseUserAdmin.fieldsets + (
+        ('Profile', {'fields': ('bio', 'avatar')}),
+    )
+
+@admin.register(Post)
+class PostAdmin(admin.ModelAdmin):
+    list_display = ['title', 'author', 'published', 'created_at']
+    list_filter = ['published', 'created_at']
+    search_fields = ['title', 'content']
+    raw_id_fields = ['author']
+    date_hierarchy = 'created_at'
+
+    actions = ['publish_posts']
+
+    @admin.action(description='Publish selected posts')
+    def publish_posts(self, request, queryset):
+        queryset.update(published=True)
+\`\`\`
+
+## Query Optimization
+\`\`\`python
+# ❌ N+1 Problem
+posts = Post.objects.all()
+for post in posts:
+    print(post.author.name)  # Query per post!
+
+# ✅ select_related (ForeignKey, OneToOne)
+posts = Post.objects.select_related('author').all()
+
+# ✅ prefetch_related (ManyToMany, reverse FK)
+users = User.objects.prefetch_related('posts').all()
+
+# ✅ Only select needed fields
+users = User.objects.only('id', 'email').all()
+users = User.objects.values('id', 'email')
+
+# ✅ Aggregate queries
+from django.db.models import Count, Avg
+User.objects.annotate(post_count=Count('posts'))
+\`\`\`
+
+## ❌ DON'T
+- Put business logic in views
+- Use raw SQL without parameterization
+- Forget migrations after model changes
+- Skip select_related/prefetch_related
+- Use synchronous code in async views
+
+## ✅ DO
+- Fat models, thin views
+- Use select_related/prefetch_related
+- Use Django REST Framework for APIs
+- Use signals for decoupled logic
+- Customize admin for easy management
+- Use class-based views for reusability
+- Write tests for models and views