autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/spring-boot.md

@@ -0,0 +1,416 @@
+# Spring Boot Skill
+
+## Project Structure
+\`\`\`
+src/main/java/com/example/
+├── Application.java
+├── config/
+│   ├── SecurityConfig.java
+│   └── WebConfig.java
+├── controller/
+│   └── UserController.java
+├── service/
+│   ├── UserService.java
+│   └── impl/UserServiceImpl.java
+├── repository/
+│   └── UserRepository.java
+├── entity/
+│   └── User.java
+├── dto/
+│   ├── CreateUserRequest.java
+│   └── UserResponse.java
+└── exception/
+    ├── GlobalExceptionHandler.java
+    └── NotFoundException.java
+\`\`\`
+
+## Controller Layer
+\`\`\`java
+@RestController
+@RequestMapping("/api/v1/users")
+@RequiredArgsConstructor  // Lombok for constructor injection
+public class UserController {
+    private final UserService userService;
+
+    @GetMapping
+    public ResponseEntity<Page<UserResponse>> listUsers(
+            @RequestParam(defaultValue = "0") int page,
+            @RequestParam(defaultValue = "20") int size) {
+        Page<UserResponse> users = userService.findAll(PageRequest.of(page, size));
+        return ResponseEntity.ok(users);
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<UserResponse> getUser(@PathVariable String id) {
+        return ResponseEntity.ok(userService.findById(id));
+    }
+
+    @PostMapping
+    public ResponseEntity<UserResponse> createUser(
+            @Valid @RequestBody CreateUserRequest request) {
+        UserResponse user = userService.create(request);
+        URI location = ServletUriComponentsBuilder
+            .fromCurrentRequest()
+            .path("/{id}")
+            .buildAndExpand(user.id())
+            .toUri();
+        return ResponseEntity.created(location).body(user);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<UserResponse> updateUser(
+            @PathVariable String id,
+            @Valid @RequestBody UpdateUserRequest request) {
+        return ResponseEntity.ok(userService.update(id, request));
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteUser(@PathVariable String id) {
+        userService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+}
+\`\`\`
+
+## Service Layer
+\`\`\`java
+public interface UserService {
+    Page<UserResponse> findAll(Pageable pageable);
+    UserResponse findById(String id);
+    UserResponse create(CreateUserRequest request);
+    UserResponse update(String id, UpdateUserRequest request);
+    void delete(String id);
+}
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class UserServiceImpl implements UserService {
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    @Override
+    public Page<UserResponse> findAll(Pageable pageable) {
+        return userRepository.findAll(pageable)
+            .map(UserResponse::from);
+    }
+
+    @Override
+    public UserResponse findById(String id) {
+        return userRepository.findById(id)
+            .map(UserResponse::from)
+            .orElseThrow(() -> new NotFoundException("User not found: " + id));
+    }
+
+    @Override
+    @Transactional
+    public UserResponse create(CreateUserRequest request) {
+        if (userRepository.existsByEmail(request.email())) {
+            throw new ConflictException("Email already exists");
+        }
+
+        User user = User.builder()
+            .email(request.email())
+            .name(request.name())
+            .passwordHash(passwordEncoder.encode(request.password()))
+            .isActive(true)
+            .build();
+
+        return UserResponse.from(userRepository.save(user));
+    }
+
+    @Override
+    @Transactional
+    public UserResponse update(String id, UpdateUserRequest request) {
+        User user = userRepository.findById(id)
+            .orElseThrow(() -> new NotFoundException("User not found: " + id));
+
+        if (request.name() != null) {
+            user.setName(request.name());
+        }
+        if (request.email() != null) {
+            user.setEmail(request.email());
+        }
+
+        return UserResponse.from(userRepository.save(user));
+    }
+
+    @Override
+    @Transactional
+    public void delete(String id) {
+        if (!userRepository.existsById(id)) {
+            throw new NotFoundException("User not found: " + id);
+        }
+        userRepository.deleteById(id);
+    }
+}
+\`\`\`
+
+## DTOs with Validation
+\`\`\`java
+public record CreateUserRequest(
+    @NotBlank @Email String email,
+    @NotBlank @Size(min = 2, max = 100) String name,
+    @NotBlank @Size(min = 8) String password
+) {}
+
+public record UpdateUserRequest(
+    @Email String email,
+    @Size(min = 2, max = 100) String name
+) {}
+
+public record UserResponse(
+    String id,
+    String email,
+    String name,
+    boolean isActive,
+    Instant createdAt
+) {
+    public static UserResponse from(User user) {
+        return new UserResponse(
+            user.getId(),
+            user.getEmail(),
+            user.getName(),
+            user.isActive(),
+            user.getCreatedAt()
+        );
+    }
+}
+\`\`\`
+
+## Global Exception Handling
+\`\`\`java
+@RestControllerAdvice
+@Slf4j
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(NotFoundException.class)
+    public ResponseEntity<ErrorResponse> handleNotFound(NotFoundException ex) {
+        return ResponseEntity.status(HttpStatus.NOT_FOUND)
+            .body(new ErrorResponse("NOT_FOUND", ex.getMessage()));
+    }
+
+    @ExceptionHandler(ConflictException.class)
+    public ResponseEntity<ErrorResponse> handleConflict(ConflictException ex) {
+        return ResponseEntity.status(HttpStatus.CONFLICT)
+            .body(new ErrorResponse("CONFLICT", ex.getMessage()));
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<ValidationErrorResponse> handleValidation(
+            MethodArgumentNotValidException ex) {
+        Map<String, String> errors = ex.getBindingResult()
+            .getFieldErrors()
+            .stream()
+            .collect(Collectors.toMap(
+                FieldError::getField,
+                e -> e.getDefaultMessage() != null ? e.getDefaultMessage() : "Invalid value"
+            ));
+
+        return ResponseEntity.badRequest()
+            .body(new ValidationErrorResponse("VALIDATION_ERROR", "Validation failed", errors));
+    }
+
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<ErrorResponse> handleGeneral(Exception ex) {
+        log.error("Unexpected error", ex);
+        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+            .body(new ErrorResponse("INTERNAL_ERROR", "An unexpected error occurred"));
+    }
+}
+
+public record ErrorResponse(String code, String message) {}
+
+public record ValidationErrorResponse(
+    String code,
+    String message,
+    Map<String, String> errors
+) {}
+\`\`\`
+
+## Configuration
+\`\`\`java
+// application.yml
+spring:
+  datasource:
+    url: \${DATABASE_URL}
+    username: \${DATABASE_USER}
+    password: \${DATABASE_PASSWORD}
+  jpa:
+    hibernate:
+      ddl-auto: validate
+    open-in-view: false
+  jackson:
+    serialization:
+      write-dates-as-timestamps: false
+
+// AppConfig.java
+@Configuration
+public class AppConfig {
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+}
+\`\`\`
+
+## Security Configuration
+\`\`\`java
+@Configuration
+@EnableWebSecurity
+@RequiredArgsConstructor
+public class SecurityConfig {
+    private final JwtAuthenticationFilter jwtFilter;
+
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
+        return http
+            .csrf(csrf -> csrf.disable())
+            .sessionManagement(session ->
+                session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+            .authorizeHttpRequests(auth -> auth
+                .requestMatchers("/api/v1/auth/**").permitAll()
+                .requestMatchers("/actuator/health").permitAll()
+                .anyRequest().authenticated()
+            )
+            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)
+            .build();
+    }
+}
+
+@Component
+@RequiredArgsConstructor
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+    private final JwtService jwtService;
+    private final UserDetailsService userDetailsService;
+
+    @Override
+    protected void doFilterInternal(
+            HttpServletRequest request,
+            HttpServletResponse response,
+            FilterChain filterChain) throws ServletException, IOException {
+
+        String authHeader = request.getHeader("Authorization");
+        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
+            filterChain.doFilter(request, response);
+            return;
+        }
+
+        String token = authHeader.substring(7);
+        String username = jwtService.extractUsername(token);
+
+        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
+            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
+            if (jwtService.isTokenValid(token, userDetails)) {
+                var authToken = new UsernamePasswordAuthenticationToken(
+                    userDetails, null, userDetails.getAuthorities());
+                SecurityContextHolder.getContext().setAuthentication(authToken);
+            }
+        }
+
+        filterChain.doFilter(request, response);
+    }
+}
+\`\`\`
+
+## Testing
+\`\`\`java
+@WebMvcTest(UserController.class)
+class UserControllerTest {
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private UserService userService;
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    @Test
+    void getUser_whenExists_returnsUser() throws Exception {
+        var response = new UserResponse("1", "test@example.com", "Test", true, Instant.now());
+        when(userService.findById("1")).thenReturn(response);
+
+        mockMvc.perform(get("/api/v1/users/1"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.email").value("test@example.com"));
+    }
+
+    @Test
+    void getUser_whenNotExists_returns404() throws Exception {
+        when(userService.findById("999"))
+            .thenThrow(new NotFoundException("User not found"));
+
+        mockMvc.perform(get("/api/v1/users/999"))
+            .andExpect(status().isNotFound());
+    }
+
+    @Test
+    void createUser_withValidData_returns201() throws Exception {
+        var request = new CreateUserRequest("test@example.com", "Test", "password123");
+        var response = new UserResponse("1", "test@example.com", "Test", true, Instant.now());
+        when(userService.create(any())).thenReturn(response);
+
+        mockMvc.perform(post("/api/v1/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(request)))
+            .andExpect(status().isCreated())
+            .andExpect(header().exists("Location"));
+    }
+
+    @Test
+    void createUser_withInvalidEmail_returns400() throws Exception {
+        var request = Map.of("email", "invalid", "name", "Test", "password", "password123");
+
+        mockMvc.perform(post("/api/v1/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(request)))
+            .andExpect(status().isBadRequest())
+            .andExpect(jsonPath("$.errors.email").exists());
+    }
+}
+
+@SpringBootTest
+@AutoConfigureMockMvc
+class UserIntegrationTest {
+    @Autowired
+    private MockMvc mockMvc;
+
+    @Autowired
+    private UserRepository userRepository;
+
+    @BeforeEach
+    void setUp() {
+        userRepository.deleteAll();
+    }
+
+    @Test
+    void fullUserLifecycle() throws Exception {
+        // Create
+        mockMvc.perform(post("/api/v1/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content("{\\"email\\":\\"test@example.com\\",\\"name\\":\\"Test\\",\\"password\\":\\"password123\\"}"))
+            .andExpect(status().isCreated());
+
+        // Verify in database
+        assertThat(userRepository.findByEmail("test@example.com")).isPresent();
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use constructor injection (add @RequiredArgsConstructor with Lombok)
+- Use records for DTOs
+- Use @Transactional at service layer
+- Use @Valid for request validation
+- Return ResponseEntity for explicit status control
+- Use @RestControllerAdvice for global exception handling
+- Set \`spring.jpa.open-in-view=false\`
+
+## ❌ DON'T
+- Don't inject repositories directly into controllers
+- Don't expose entities in API responses (use DTOs)
+- Don't catch exceptions in controllers (use @RestControllerAdvice)
+- Don't use field injection (@Autowired on fields)
+- Don't return null - throw exceptions or use Optional
+- Don't put business logic in controllers

package/.claude/skills/sqlalchemy.md

@@ -0,0 +1,269 @@
+# SQLAlchemy Skill
+
+## SQLAlchemy 2.0 Model Definition
+\`\`\`python
+from datetime import datetime
+from sqlalchemy import String, ForeignKey, func
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+
+class Base(DeclarativeBase):
+    pass
+
+class User(Base):
+    __tablename__ = "users"
+
+    # Mapped columns with type annotations
+    id: Mapped[int] = mapped_column(primary_key=True)
+    email: Mapped[str] = mapped_column(String(255), unique=True, index=True)
+    name: Mapped[str] = mapped_column(String(100))
+    is_active: Mapped[bool] = mapped_column(default=True)
+    created_at: Mapped[datetime] = mapped_column(server_default=func.now())
+
+    # Relationships
+    posts: Mapped[list["Post"]] = relationship(back_populates="author", cascade="all, delete-orphan")
+
+    def __repr__(self) -> str:
+        return f"User(id={self.id}, email={self.email!r})"
+
+class Post(Base):
+    __tablename__ = "posts"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    title: Mapped[str] = mapped_column(String(200))
+    content: Mapped[str]
+    author_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
+
+    author: Mapped["User"] = relationship(back_populates="posts")
+\`\`\`
+
+## Async Engine & Session
+\`\`\`python
+from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
+
+# Create async engine
+engine = create_async_engine(
+    "postgresql+asyncpg://user:pass@localhost/db",
+    echo=True,  # Log SQL
+    pool_size=5,
+    max_overflow=10,
+)
+
+# Session factory
+async_session = async_sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False,
+)
+
+# Dependency for FastAPI
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session() as session:
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+\`\`\`
+
+## Async Queries (SQLAlchemy 2.0)
+\`\`\`python
+from sqlalchemy import select
+from sqlalchemy.orm import selectinload, joinedload
+
+# Select with type hints
+async def get_user(session: AsyncSession, user_id: int) -> User | None:
+    result = await session.execute(
+        select(User).where(User.id == user_id)
+    )
+    return result.scalar_one_or_none()
+
+# Select all with filtering
+async def get_active_users(session: AsyncSession) -> list[User]:
+    result = await session.execute(
+        select(User)
+        .where(User.is_active == True)
+        .order_by(User.created_at.desc())
+    )
+    return list(result.scalars().all())
+
+# Eager loading relationships
+async def get_user_with_posts(session: AsyncSession, user_id: int) -> User | None:
+    result = await session.execute(
+        select(User)
+        .options(selectinload(User.posts))  # Async-safe loading
+        .where(User.id == user_id)
+    )
+    return result.scalar_one_or_none()
+
+# Pagination
+async def get_users_paginated(
+    session: AsyncSession,
+    page: int = 1,
+    per_page: int = 10,
+) -> list[User]:
+    result = await session.execute(
+        select(User)
+        .offset((page - 1) * per_page)
+        .limit(per_page)
+    )
+    return list(result.scalars().all())
+\`\`\`
+
+## CRUD Operations
+\`\`\`python
+# Create
+async def create_user(session: AsyncSession, email: str, name: str) -> User:
+    user = User(email=email, name=name)
+    session.add(user)
+    await session.flush()  # Get ID without committing
+    return user
+
+# Update
+async def update_user(session: AsyncSession, user_id: int, **data) -> User | None:
+    user = await get_user(session, user_id)
+    if user:
+        for key, value in data.items():
+            setattr(user, key, value)
+        await session.flush()
+    return user
+
+# Delete
+async def delete_user(session: AsyncSession, user_id: int) -> bool:
+    user = await get_user(session, user_id)
+    if user:
+        await session.delete(user)
+        return True
+    return False
+
+# Bulk insert
+async def create_users_bulk(session: AsyncSession, users_data: list[dict]) -> None:
+    session.add_all([User(**data) for data in users_data])
+    await session.flush()
+\`\`\`
+
+## Transactions
+\`\`\`python
+from sqlalchemy.exc import IntegrityError
+
+# Explicit transaction
+async def transfer_posts(session: AsyncSession, from_id: int, to_id: int):
+    async with session.begin():  # Auto-commit or rollback
+        from_user = await get_user(session, from_id)
+        to_user = await get_user(session, to_id)
+
+        for post in from_user.posts:
+            post.author_id = to_id
+
+        # Changes committed when exiting context
+
+# Savepoints for partial rollbacks
+async def create_with_fallback(session: AsyncSession, data: dict):
+    try:
+        async with session.begin_nested():  # Savepoint
+            user = User(**data)
+            session.add(user)
+            await session.flush()
+    except IntegrityError:
+        # Rollback to savepoint, outer transaction continues
+        pass
+\`\`\`
+
+## Complex Queries
+\`\`\`python
+from sqlalchemy import func, and_, or_, case
+
+# Aggregation
+async def get_post_counts(session: AsyncSession):
+    result = await session.execute(
+        select(User.id, User.name, func.count(Post.id).label('post_count'))
+        .join(Post, isouter=True)
+        .group_by(User.id)
+        .having(func.count(Post.id) > 0)
+    )
+    return result.all()
+
+# Subqueries
+async def get_users_with_recent_posts(session: AsyncSession):
+    subq = (
+        select(Post.author_id)
+        .where(Post.created_at > func.now() - timedelta(days=7))
+        .distinct()
+        .subquery()
+    )
+
+    result = await session.execute(
+        select(User).where(User.id.in_(select(subq)))
+    )
+    return result.scalars().all()
+
+# Case expressions
+async def get_users_by_activity(session: AsyncSession):
+    result = await session.execute(
+        select(
+            User,
+            case(
+                (func.count(Post.id) > 10, 'active'),
+                (func.count(Post.id) > 0, 'moderate'),
+                else_='inactive'
+            ).label('activity')
+        )
+        .join(Post, isouter=True)
+        .group_by(User.id)
+    )
+    return result.all()
+\`\`\`
+
+## Relationships In-Depth
+\`\`\`python
+# Many-to-Many
+user_roles = Table(
+    'user_roles',
+    Base.metadata,
+    Column('user_id', ForeignKey('users.id'), primary_key=True),
+    Column('role_id', ForeignKey('roles.id'), primary_key=True),
+)
+
+class Role(Base):
+    __tablename__ = 'roles'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(String(50), unique=True)
+    users: Mapped[list["User"]] = relationship(secondary=user_roles, back_populates="roles")
+
+class User(Base):
+    # ... other fields
+    roles: Mapped[list["Role"]] = relationship(secondary=user_roles, back_populates="users")
+
+# Self-referential (followers)
+followers = Table(
+    'followers',
+    Base.metadata,
+    Column('follower_id', ForeignKey('users.id'), primary_key=True),
+    Column('followed_id', ForeignKey('users.id'), primary_key=True),
+)
+
+class User(Base):
+    # ... other fields
+    following: Mapped[list["User"]] = relationship(
+        secondary=followers,
+        primaryjoin=id == followers.c.follower_id,
+        secondaryjoin=id == followers.c.followed_id,
+        backref="followers",
+    )
+\`\`\`
+
+## ❌ DON'T
+- Use session.query() (legacy, use select())
+- Forget eager loading (N+1 problem)
+- Use sync operations in async code
+- Commit inside functions (let caller decide)
+
+## ✅ DO
+- Use SQLAlchemy 2.0 style (Mapped, select)
+- Use async for web applications
+- Use selectinload for async relationship loading
+- Use transactions for multi-step operations
+- Use indices on frequently queried columns
+- Use connection pooling