autoworkflow 3.1.5 → 3.6.0

package/.claude/skills/jpa.md

@@ -0,0 +1,282 @@
+# JPA Skill (Spring Data JPA)
+
+## Repository Interface
+\`\`\`java
+public interface UserRepository extends JpaRepository<User, String> {
+
+    // Derived query methods
+    Optional<User> findByEmail(String email);
+
+    List<User> findByIsActiveTrueOrderByCreatedAtDesc();
+
+    boolean existsByEmail(String email);
+
+    long countByIsActiveTrue();
+
+    // Query methods with @Query
+    @Query("SELECT u FROM User u WHERE u.isActive = true")
+    List<User> findActiveUsers();
+
+    @Query("SELECT u FROM User u LEFT JOIN FETCH u.posts WHERE u.id = :id")
+    Optional<User> findByIdWithPosts(@Param("id") String id);
+
+    @Query(value = "SELECT * FROM users WHERE email ILIKE %:query%", nativeQuery = true)
+    List<User> searchByEmail(@Param("query") String query);
+
+    // Modifying queries
+    @Modifying
+    @Query("UPDATE User u SET u.isActive = false WHERE u.id = :id")
+    int deactivateUser(@Param("id") String id);
+
+    @Modifying
+    @Query("DELETE FROM User u WHERE u.isActive = false AND u.createdAt < :date")
+    int deleteInactiveOlderThan(@Param("date") Instant date);
+
+    // Pagination
+    Page<User> findByIsActiveTrue(Pageable pageable);
+
+    Slice<User> findByRolesName(String roleName, Pageable pageable);
+}
+\`\`\`
+
+## Specifications (Dynamic Queries)
+\`\`\`java
+// Repository with Specification support
+public interface UserRepository extends
+        JpaRepository<User, String>,
+        JpaSpecificationExecutor<User> {
+}
+
+// Specification definitions
+public class UserSpecifications {
+
+    public static Specification<User> hasEmail(String email) {
+        return (root, query, cb) -> email == null ? null :
+            cb.equal(root.get("email"), email);
+    }
+
+    public static Specification<User> emailContains(String search) {
+        return (root, query, cb) -> search == null ? null :
+            cb.like(cb.lower(root.get("email")), "%" + search.toLowerCase() + "%");
+    }
+
+    public static Specification<User> isActive() {
+        return (root, query, cb) -> cb.isTrue(root.get("isActive"));
+    }
+
+    public static Specification<User> createdAfter(Instant date) {
+        return (root, query, cb) -> date == null ? null :
+            cb.greaterThan(root.get("createdAt"), date);
+    }
+
+    public static Specification<User> hasRole(String roleName) {
+        return (root, query, cb) -> {
+            if (roleName == null) return null;
+            Join<User, Role> roles = root.join("roles");
+            return cb.equal(roles.get("name"), roleName);
+        };
+    }
+}
+
+// Usage in service
+public Page<User> searchUsers(UserSearchCriteria criteria, Pageable pageable) {
+    Specification<User> spec = Specification
+        .where(emailContains(criteria.getEmail()))
+        .and(isActive())
+        .and(createdAfter(criteria.getCreatedAfter()))
+        .and(hasRole(criteria.getRole()));
+
+    return userRepository.findAll(spec, pageable);
+}
+\`\`\`
+
+## Projections
+\`\`\`java
+// Interface-based projection (closed)
+public interface UserSummary {
+    String getId();
+    String getEmail();
+    String getName();
+
+    // Computed value
+    @Value("#{\${target.firstName} + ' ' + \${target.lastName}}")
+    String getFullName();
+}
+
+// Class-based projection (DTO)
+public record UserDto(String id, String email, String name) {}
+
+// Dynamic projection
+public interface UserRepository extends JpaRepository<User, String> {
+
+    // Returns different projections based on type parameter
+    <T> Optional<T> findById(String id, Class<T> type);
+
+    <T> List<T> findByIsActiveTrue(Class<T> type);
+
+    // Interface projection
+    List<UserSummary> findAllProjectedBy();
+
+    // DTO projection with JPQL
+    @Query("SELECT new com.example.dto.UserDto(u.id, u.email, u.name) FROM User u WHERE u.isActive = true")
+    List<UserDto> findActiveUserDtos();
+}
+
+// Usage
+UserSummary summary = userRepository.findById("123", UserSummary.class).orElseThrow();
+UserDto dto = userRepository.findById("123", UserDto.class).orElseThrow();
+\`\`\`
+
+## Auditing
+\`\`\`java
+// Enable auditing
+@Configuration
+@EnableJpaAuditing
+public class JpaConfig {
+
+    @Bean
+    public AuditorAware<String> auditorProvider() {
+        return () -> Optional.ofNullable(SecurityContextHolder.getContext())
+            .map(SecurityContext::getAuthentication)
+            .filter(Authentication::isAuthenticated)
+            .map(Authentication::getName);
+    }
+}
+
+// Auditable base entity
+@MappedSuperclass
+@EntityListeners(AuditingEntityListener.class)
+public abstract class AuditableEntity {
+
+    @CreatedDate
+    @Column(name = "created_at", nullable = false, updatable = false)
+    private Instant createdAt;
+
+    @LastModifiedDate
+    @Column(name = "updated_at")
+    private Instant updatedAt;
+
+    @CreatedBy
+    @Column(name = "created_by", updatable = false)
+    private String createdBy;
+
+    @LastModifiedBy
+    @Column(name = "updated_by")
+    private String updatedBy;
+
+    // Getters...
+}
+
+// Entity extending auditable
+@Entity
+public class User extends AuditableEntity {
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    private String id;
+
+    private String email;
+    private String name;
+}
+\`\`\`
+
+## Query by Example
+\`\`\`java
+public interface UserRepository extends
+        JpaRepository<User, String>,
+        QueryByExampleExecutor<User> {
+}
+
+// Usage
+User probe = new User();
+probe.setIsActive(true);
+probe.setEmail("@example.com");
+
+ExampleMatcher matcher = ExampleMatcher.matching()
+    .withStringMatcher(ExampleMatcher.StringMatcher.ENDING)
+    .withIgnoreCase()
+    .withIgnoreNullValues();
+
+Example<User> example = Example.of(probe, matcher);
+
+List<User> users = userRepository.findAll(example);
+\`\`\`
+
+## Custom Repository Implementation
+\`\`\`java
+// Custom repository interface
+public interface UserRepositoryCustom {
+    List<User> findUsersWithComplexCriteria(UserSearchCriteria criteria);
+    void batchUpdateStatus(List<String> ids, boolean isActive);
+}
+
+// Implementation
+public class UserRepositoryImpl implements UserRepositoryCustom {
+
+    @PersistenceContext
+    private EntityManager em;
+
+    @Override
+    public List<User> findUsersWithComplexCriteria(UserSearchCriteria criteria) {
+        CriteriaBuilder cb = em.getCriteriaBuilder();
+        CriteriaQuery<User> cq = cb.createQuery(User.class);
+        Root<User> user = cq.from(User.class);
+
+        List<Predicate> predicates = new ArrayList<>();
+        // Build predicates...
+
+        cq.where(predicates.toArray(new Predicate[0]));
+        return em.createQuery(cq).getResultList();
+    }
+
+    @Override
+    @Transactional
+    public void batchUpdateStatus(List<String> ids, boolean isActive) {
+        em.createQuery("UPDATE User u SET u.isActive = :status WHERE u.id IN :ids")
+            .setParameter("status", isActive)
+            .setParameter("ids", ids)
+            .executeUpdate();
+    }
+}
+
+// Main repository extends both
+public interface UserRepository extends
+        JpaRepository<User, String>,
+        UserRepositoryCustom {
+}
+\`\`\`
+
+## Stream Results for Large Datasets
+\`\`\`java
+public interface UserRepository extends JpaRepository<User, String> {
+
+    @Query("SELECT u FROM User u WHERE u.isActive = true")
+    Stream<User> findAllActiveAsStream();
+}
+
+// Usage - must be in transaction
+@Transactional(readOnly = true)
+public void processAllUsers() {
+    try (Stream<User> stream = userRepository.findAllActiveAsStream()) {
+        stream.forEach(user -> {
+            // Process each user
+            // EntityManager clears automatically with @Modifying(clearAutomatically = true)
+        });
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use derived query methods for simple queries
+- Use \`@Query\` for complex queries
+- Use Specifications for dynamic queries
+- Use projections to fetch only needed fields
+- Use \`@Transactional(readOnly = true)\` for read operations
+- Use pagination for large result sets
+- Use \`@EntityGraph\` or \`JOIN FETCH\` to avoid N+1
+
+## ❌ DON'T
+- Don't return entities directly from controllers (use DTOs)
+- Don't use \`findAll()\` without pagination on large tables
+- Don't forget \`@Modifying\` on UPDATE/DELETE queries
+- Don't use \`@Query\` with \`nativeQuery=true\` unless necessary
+- Don't ignore the N+1 problem - use eager fetching strategically

package/.claude/skills/kotlin.md

@@ -0,0 +1,347 @@
+# Kotlin Skill
+
+## Data Classes and Records
+\`\`\`kotlin
+// Immutable data class
+data class User(
+    val id: String,
+    val email: String,
+    val name: String,
+    val isActive: Boolean = true,
+    val createdAt: Instant = Instant.now()
+)
+
+// With validation in init block
+data class Email(val value: String) {
+    init {
+        require(value.contains("@")) { "Invalid email format" }
+    }
+}
+
+// Copy with modifications
+val updatedUser = user.copy(name = "New Name", isActive = false)
+
+// Destructuring
+val (id, email, name) = user
+users.forEach { (id, email) -> println("$id: $email") }
+\`\`\`
+
+## Null Safety
+\`\`\`kotlin
+// Nullable types
+var name: String? = null
+
+// Safe call operator
+val length = name?.length  // Returns null if name is null
+
+// Elvis operator
+val displayName = user.name ?: "Anonymous"
+val email = user.email ?: throw IllegalStateException("Email required")
+
+// Safe cast
+val result = obj as? String  // Returns null if cast fails
+
+// Not-null assertion (use sparingly!)
+val length = name!!.length  // Throws NPE if null
+
+// let for null checks
+user?.let {
+    sendEmail(it.email)
+    logAction(it.id)
+}
+
+// Early return with Elvis
+fun process(user: User?): Result {
+    val u = user ?: return Result.failure("User required")
+    return processUser(u)
+}
+
+// Platform types (Java interop)
+// Use @Nullable/@NotNull annotations or treat as nullable
+fun handleJavaResult(result: String?) {
+    result?.let { process(it) }
+}
+\`\`\`
+
+## Sealed Classes and When
+\`\`\`kotlin
+// Sealed class for restricted hierarchies
+sealed class Result<out T> {
+    data class Success<T>(val data: T) : Result<T>()
+    data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()
+    data object Loading : Result<Nothing>()
+}
+
+// Exhaustive when (compiler ensures all cases handled)
+fun handleResult(result: Result<User>): String = when (result) {
+    is Result.Success -> "Got user: \${result.data.name}"
+    is Result.Error -> "Error: \${result.message}"
+    is Result.Loading -> "Loading..."
+}
+
+// Sealed interface
+sealed interface ApiResponse {
+    data class Success(val body: String) : ApiResponse
+    data class Error(val code: Int, val message: String) : ApiResponse
+}
+
+// When with complex conditions
+fun describe(user: User) = when {
+    user.isActive && user.roles.contains("ADMIN") -> "Active Admin"
+    user.isActive -> "Active User"
+    else -> "Inactive"
+}
+\`\`\`
+
+## Scope Functions
+\`\`\`kotlin
+// let - transform nullable, use 'it'
+val email = user?.email?.let { validateEmail(it) }
+
+// run - execute block with 'this', return result
+val result = user.run {
+    validate()
+    save()
+    toResponse()
+}
+
+// apply - configure object, return 'this'
+val user = User().apply {
+    email = "test@example.com"
+    name = "Test"
+    isActive = true
+}
+
+// also - side effects, return 'this'
+val user = createUser()
+    .also { log.info("Created user: \${it.id}") }
+    .also { metrics.increment("users.created") }
+
+// with - operate on object, return result
+val description = with(user) {
+    "User $name ($email) - Active: $isActive"
+}
+
+// takeIf / takeUnless
+val activeUser = user.takeIf { it.isActive }
+val inactiveUser = user.takeUnless { it.isActive }
+
+// Chaining
+val result = input
+    ?.takeIf { it.isNotBlank() }
+    ?.let { parse(it) }
+    ?.also { validate(it) }
+    ?: defaultValue
+\`\`\`
+
+## Extension Functions
+\`\`\`kotlin
+// Add functions to existing types
+fun String.toSlug(): String =
+    lowercase()
+        .replace(Regex("[^a-z0-9\\\\s-]"), "")
+        .replace(Regex("\\\\s+"), "-")
+
+fun String.isValidEmail(): Boolean =
+    matches(Regex("^[A-Za-z0-9+_.-]+@(.+)$"))
+
+// Extension on nullable type
+fun String?.orEmpty(): String = this ?: ""
+
+fun <T> List<T>?.orEmpty(): List<T> = this ?: emptyList()
+
+// Extension properties
+val String.firstWord: String
+    get() = split(" ").first()
+
+// Generic extensions
+fun <T> T.log(tag: String = "DEBUG"): T = also {
+    println("[$tag] $it")
+}
+
+// Scoped extensions
+class UserService {
+    // Only available within UserService
+    private fun User.toResponse() = UserResponse(id, email, name)
+
+    fun getUser(id: String): UserResponse =
+        repository.findById(id).toResponse()
+}
+\`\`\`
+
+## Collections
+\`\`\`kotlin
+// Immutable by default
+val list = listOf(1, 2, 3)
+val set = setOf("a", "b", "c")
+val map = mapOf("key1" to "value1", "key2" to "value2")
+
+// Mutable when needed
+val mutableList = mutableListOf(1, 2, 3)
+mutableList.add(4)
+
+// Transformations
+val emails = users
+    .filter { it.isActive }
+    .map { it.email }
+    .distinct()
+    .sorted()
+
+// Grouping
+val byDomain = users.groupBy { it.email.substringAfter("@") }
+
+// Aggregation
+val totalAge = users.sumOf { it.age }
+val averageAge = users.map { it.age }.average()
+val oldest = users.maxByOrNull { it.age }
+
+// Partition
+val (active, inactive) = users.partition { it.isActive }
+
+// Associate
+val userById = users.associateBy { it.id }
+val idToEmail = users.associate { it.id to it.email }
+
+// Sequences for large collections (lazy evaluation)
+val result = users.asSequence()
+    .filter { it.isActive }
+    .map { it.email }
+    .take(10)
+    .toList()
+
+// Null-safe operations
+val firstActive = users.firstOrNull { it.isActive }
+val emails = users.mapNotNull { it.email }  // Filters nulls
+\`\`\`
+
+## Coroutines
+\`\`\`kotlin
+import kotlinx.coroutines.*
+
+// Suspend function
+suspend fun fetchUser(id: String): User = withContext(Dispatchers.IO) {
+    repository.findById(id)
+}
+
+// Launching coroutines
+fun main() = runBlocking {
+    val job = launch {
+        delay(1000)
+        println("World!")
+    }
+    println("Hello,")
+    job.join()
+}
+
+// Async for concurrent operations
+suspend fun fetchUserWithPosts(userId: String): UserWithPosts = coroutineScope {
+    val userDeferred = async { fetchUser(userId) }
+    val postsDeferred = async { fetchPosts(userId) }
+
+    UserWithPosts(
+        user = userDeferred.await(),
+        posts = postsDeferred.await()
+    )
+}
+
+// Error handling
+suspend fun safeFetch(id: String): Result<User> = try {
+    Result.success(fetchUser(id))
+} catch (e: Exception) {
+    Result.failure(e)
+}
+
+// Flow for streams
+fun observeUsers(): Flow<User> = flow {
+    while (true) {
+        emit(fetchLatestUser())
+        delay(5000)
+    }
+}.flowOn(Dispatchers.IO)
+
+// Collecting flows
+suspend fun collectUsers() {
+    observeUsers()
+        .filter { it.isActive }
+        .map { it.email }
+        .catch { e -> log.error("Error", e) }
+        .collect { email -> sendNotification(email) }
+}
+
+// StateFlow and SharedFlow
+class UserViewModel {
+    private val _users = MutableStateFlow<List<User>>(emptyList())
+    val users: StateFlow<List<User>> = _users.asStateFlow()
+
+    fun loadUsers() {
+        viewModelScope.launch {
+            _users.value = repository.getUsers()
+        }
+    }
+}
+\`\`\`
+
+## Spring Boot with Kotlin
+\`\`\`kotlin
+@RestController
+@RequestMapping("/api/v1/users")
+class UserController(
+    private val userService: UserService  // Constructor injection
+) {
+    @GetMapping
+    suspend fun listUsers(): List<UserResponse> =
+        userService.findAll()
+
+    @GetMapping("/{id}")
+    suspend fun getUser(@PathVariable id: String): UserResponse =
+        userService.findById(id)
+            ?: throw ResponseStatusException(HttpStatus.NOT_FOUND)
+
+    @PostMapping
+    suspend fun createUser(@Valid @RequestBody request: CreateUserRequest): ResponseEntity<UserResponse> {
+        val user = userService.create(request)
+        return ResponseEntity.created(URI.create("/api/v1/users/\${user.id}"))
+            .body(user)
+    }
+}
+
+@Service
+class UserService(
+    private val userRepository: UserRepository
+) {
+    suspend fun findAll(): List<UserResponse> =
+        userRepository.findAll().map { it.toResponse() }
+
+    suspend fun findById(id: String): UserResponse? =
+        userRepository.findById(id)?.toResponse()
+
+    @Transactional
+    suspend fun create(request: CreateUserRequest): UserResponse {
+        val user = User(
+            email = request.email,
+            name = request.name,
+            passwordHash = passwordEncoder.encode(request.password)
+        )
+        return userRepository.save(user).toResponse()
+    }
+
+    private fun User.toResponse() = UserResponse(id, email, name, isActive)
+}
+\`\`\`
+
+## ✅ DO
+- Use \`val\` by default, \`var\` only when necessary
+- Use data classes for DTOs and value objects
+- Use sealed classes for restricted type hierarchies
+- Use scope functions appropriately (let, run, apply, also, with)
+- Use \`?.let\` instead of null checks
+- Use extension functions to enhance readability
+- Use coroutines for async operations
+
+## ❌ DON'T
+- Don't use \`!!\` without good reason (prefer safe calls)
+- Don't use mutable collections when immutable suffice
+- Don't use \`lateinit\` when nullable is appropriate
+- Don't ignore nullability in Java interop
+- Don't block coroutines with blocking calls (use \`withContext(Dispatchers.IO)\`)
+- Don't use \`GlobalScope\` (prefer structured concurrency)