ai-first-cli 1.1.3 → 1.2.0

package/test-projects/spring-boot-app/pom.xml

@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    
+    <parent>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-parent</artifactId>
+        <version>3.2.5</version>
+        <relativePath/>
+    </parent>
+    
+    <groupId>com.example</groupId>
+    <artifactId>demo</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>demo</name>
+    <description>Spring Boot REST API Blog Application</description>
+    
+    <properties>
+        <java.version>17</java.version>
+    </properties>
+    
+    <dependencies>
+        <!-- Spring Boot Starters -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-jpa</artifactId>
+        </dependency>
+        
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+        </dependency>
+        
+        <!-- Database -->
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>runtime</scope>
+        </dependency>
+        
+        <!-- Lombok -->
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        
+        <!-- Testing -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+    
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

package/test-projects/spring-boot-app/src/main/java/com/example/demo/DemoApplication.java

@@ -0,0 +1,12 @@
+package com.example.demo;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class DemoApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(DemoApplication.class, args);
+    }
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/controllers/CommentController.java

@@ -0,0 +1,89 @@
+package com.example.demo.controllers;
+
+import com.example.demo.models.Comment;
+import com.example.demo.repositories.CommentRepository;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/comments")
+@RequiredArgsConstructor
+public class CommentController {
+
+    private final CommentRepository commentRepository;
+
+    @GetMapping
+    public ResponseEntity<List<Comment>> getAllComments() {
+        return ResponseEntity.ok(commentRepository.findAll());
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Comment> getCommentById(@PathVariable Long id) {
+        return commentRepository.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @GetMapping("/post/{postId}")
+    public ResponseEntity<List<Comment>> getCommentsByPost(@PathVariable Long postId) {
+        return ResponseEntity.ok(commentRepository.findByPostId(postId));
+    }
+
+    @GetMapping("/user/{userId}")
+    public ResponseEntity<List<Comment>> getCommentsByUser(@PathVariable Long userId) {
+        return ResponseEntity.ok(commentRepository.findByUserId(userId));
+    }
+
+    @PostMapping
+    public ResponseEntity<Comment> createComment(@Valid @RequestBody CommentCreateRequest request) {
+        Comment comment = new Comment();
+        comment.setContent(request.content());
+        // Note: In a real application, you would set the post and user from the request
+        // This requires additional service logic
+        
+        Comment createdComment = commentRepository.save(comment);
+        return ResponseEntity.status(HttpStatus.CREATED).body(createdComment);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Comment> updateComment(@PathVariable Long id, @Valid @RequestBody CommentUpdateRequest request) {
+        return commentRepository.findById(id)
+                .map(comment -> {
+                    comment.setContent(request.content());
+                    return ResponseEntity.ok(commentRepository.save(comment));
+                })
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteComment(@PathVariable Long id) {
+        if (!commentRepository.existsById(id)) {
+            return ResponseEntity.notFound().build();
+        }
+        commentRepository.deleteById(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    public record CommentCreateRequest(
+            @NotBlank(message = "Content is required")
+            String content,
+            
+            @NotNull(message = "Post ID is required")
+            Long postId,
+            
+            @NotNull(message = "User ID is required")
+            Long userId
+    ) {}
+
+    public record CommentUpdateRequest(
+            @NotBlank(message = "Content is required")
+            String content
+    ) {}
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/controllers/PostController.java

@@ -0,0 +1,92 @@
+package com.example.demo.controllers;
+
+import com.example.demo.models.Post;
+import com.example.demo.services.PostService;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/posts")
+@RequiredArgsConstructor
+public class PostController {
+
+    private final PostService postService;
+
+    @GetMapping
+    public ResponseEntity<List<Post>> getAllPosts() {
+        return ResponseEntity.ok(postService.findAll());
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<Post> getPostById(@PathVariable Long id) {
+        return postService.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @GetMapping("/user/{userId}")
+    public ResponseEntity<List<Post>> getPostsByUser(@PathVariable Long userId) {
+        return ResponseEntity.ok(postService.findByUserId(userId));
+    }
+
+    @GetMapping("/published")
+    public ResponseEntity<List<Post>> getPublishedPosts() {
+        return ResponseEntity.ok(postService.findPublished());
+    }
+
+    @PostMapping
+    public ResponseEntity<Post> createPost(@Valid @RequestBody PostCreateRequest request) {
+        Post post = new Post();
+        post.setTitle(request.title());
+        post.setContent(request.content());
+        
+        Post createdPost = postService.create(post, request.userId());
+        return ResponseEntity.status(HttpStatus.CREATED).body(createdPost);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<Post> updatePost(@PathVariable Long id, @Valid @RequestBody PostUpdateRequest request) {
+        Post postDetails = new Post();
+        postDetails.setTitle(request.title());
+        postDetails.setContent(request.content());
+        
+        Post updatedPost = postService.update(id, postDetails);
+        return ResponseEntity.ok(updatedPost);
+    }
+
+    @PostMapping("/{id}/publish")
+    public ResponseEntity<Post> publishPost(@PathVariable Long id) {
+        Post publishedPost = postService.publish(id);
+        return ResponseEntity.ok(publishedPost);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deletePost(@PathVariable Long id) {
+        postService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    public record PostCreateRequest(
+            @NotBlank(message = "Title is required")
+            String title,
+            
+            String content,
+            
+            @NotNull(message = "User ID is required")
+            Long userId
+    ) {}
+
+    public record PostUpdateRequest(
+            @NotBlank(message = "Title is required")
+            String title,
+            
+            String content
+    ) {}
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/controllers/UserController.java

@@ -0,0 +1,84 @@
+package com.example.demo.controllers;
+
+import com.example.demo.models.User;
+import com.example.demo.services.UserService;
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.Email;
+import jakarta.validation.constraints.NotBlank;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/users")
+@RequiredArgsConstructor
+public class UserController {
+
+    private final UserService userService;
+
+    @GetMapping
+    public ResponseEntity<List<User>> getAllUsers() {
+        return ResponseEntity.ok(userService.findAll());
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<User> getUserById(@PathVariable Long id) {
+        return userService.findById(id)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @GetMapping("/email/{email}")
+    public ResponseEntity<User> getUserByEmail(@PathVariable String email) {
+        return userService.findByEmail(email)
+                .map(ResponseEntity::ok)
+                .orElse(ResponseEntity.notFound().build());
+    }
+
+    @PostMapping
+    public ResponseEntity<User> createUser(@Valid @RequestBody UserCreateRequest request) {
+        User user = new User();
+        user.setName(request.name());
+        user.setEmail(request.email());
+        
+        User createdUser = userService.create(user);
+        return ResponseEntity.status(HttpStatus.CREATED).body(createdUser);
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<User> updateUser(@PathVariable Long id, @Valid @RequestBody UserUpdateRequest request) {
+        User userDetails = new User();
+        userDetails.setName(request.name());
+        userDetails.setEmail(request.email());
+        
+        User updatedUser = userService.update(id, userDetails);
+        return ResponseEntity.ok(updatedUser);
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
+        userService.delete(id);
+        return ResponseEntity.noContent().build();
+    }
+
+    public record UserCreateRequest(
+            @NotBlank(message = "Name is required")
+            String name,
+            
+            @NotBlank(message = "Email is required")
+            @Email(message = "Invalid email format")
+            String email
+    ) {}
+
+    public record UserUpdateRequest(
+            @NotBlank(message = "Name is required")
+            String name,
+            
+            @NotBlank(message = "Email is required")
+            @Email(message = "Invalid email format")
+            String email
+    ) {}
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/models/Comment.java

@@ -0,0 +1,38 @@
+package com.example.demo.models;
+
+import jakarta.persistence.*;
+import lombok.*;
+import java.time.LocalDateTime;
+
+@Entity
+@Table(name = "comments")
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class Comment {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(length = 1000, nullable = false)
+    private String content;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "post_id", nullable = false)
+    private Post post;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
+
+    @Column(name = "created_at")
+    private LocalDateTime createdAt;
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = LocalDateTime.now();
+    }
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/models/Post.java

@@ -0,0 +1,56 @@
+package com.example.demo.models;
+
+import jakarta.persistence.*;
+import lombok.*;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Table(name = "posts")
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class Post {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String title;
+
+    @Column(length = 5000)
+    private String content;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "user_id", nullable = false)
+    private User user;
+
+    @OneToMany(mappedBy = "post", cascade = CascadeType.ALL, orphanRemoval = true)
+    @Builder.Default
+    private List<Comment> comments = new ArrayList<>();
+
+    @Column(name = "created_at")
+    private LocalDateTime createdAt;
+
+    @Column(name = "published_at")
+    private LocalDateTime publishedAt;
+
+    @PrePersist
+    protected void onCreate() {
+        createdAt = LocalDateTime.now();
+    }
+
+    public void addComment(Comment comment) {
+        comments.add(comment);
+        comment.setPost(this);
+    }
+
+    public void removeComment(Comment comment) {
+        comments.remove(comment);
+        comment.setPost(null);
+    }
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/models/User.java

@@ -0,0 +1,44 @@
+package com.example.demo.models;
+
+import jakarta.persistence.*;
+import lombok.*;
+import java.util.ArrayList;
+import java.util.List;
+
+@Entity
+@Table(name = "users")
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String name;
+
+    @Column(nullable = false, unique = true)
+    private String email;
+
+    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
+    @Builder.Default
+    private List<Post> posts = new ArrayList<>();
+
+    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
+    @Builder.Default
+    private List<Comment> comments = new ArrayList<>();
+
+    public void addPost(Post post) {
+        posts.add(post);
+        post.setUser(this);
+    }
+
+    public void removePost(Post post) {
+        posts.remove(post);
+        post.setUser(null);
+    }
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/repositories/CommentRepository.java

@@ -0,0 +1,21 @@
+package com.example.demo.repositories;
+
+import com.example.demo.models.Comment;
+import com.example.demo.models.Post;
+import com.example.demo.models.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface CommentRepository extends JpaRepository<Comment, Long> {
+
+    List<Comment> findByPost(Post post);
+
+    List<Comment> findByPostId(Long postId);
+
+    List<Comment> findByUser(User user);
+
+    List<Comment> findByUserId(Long userId);
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/repositories/PostRepository.java

@@ -0,0 +1,18 @@
+package com.example.demo.repositories;
+
+import com.example.demo.models.Post;
+import com.example.demo.models.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+
+@Repository
+public interface PostRepository extends JpaRepository<Post, Long> {
+
+    List<Post> findByUser(User user);
+
+    List<Post> findByUserId(Long userId);
+
+    List<Post> findByPublishedAtNotNullOrderByPublishedAtDesc();
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/repositories/UserRepository.java

@@ -0,0 +1,15 @@
+package com.example.demo.repositories;
+
+import com.example.demo.models.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.Optional;
+
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+
+    Optional<User> findByEmail(String email);
+
+    boolean existsByEmail(String email);
+}

package/test-projects/spring-boot-app/src/main/java/com/example/demo/services/PostService.java

@@ -0,0 +1,83 @@
+package com.example.demo.services;
+
+import com.example.demo.models.Post;
+import com.example.demo.models.User;
+import com.example.demo.repositories.PostRepository;
+import com.example.demo.repositories.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
+public class PostService {
+
+    private final PostRepository postRepository;
+    private final UserRepository userRepository;
+
+    public List<Post> findAll() {
+        return postRepository.findAll();
+    }
+
+    public Optional<Post> findById(Long id) {
+        return postRepository.findById(id);
+    }
+
+    public List<Post> findByUser(User user) {
+        return postRepository.findByUser(user);
+    }
+
+    public List<Post> findByUserId(Long userId) {
+        return postRepository.findByUserId(userId);
+    }
+
+    public List<Post> findPublished() {
+        return postRepository.findByPublishedAtNotNullOrderByPublishedAtDesc();
+    }
+
+    @Transactional
+    public Post create(Post post, Long userId) {
+        User user = userRepository.findById(userId)
+                .orElseThrow(() -> new IllegalArgumentException("User not found with id: " + userId));
+        
+        post.setUser(user);
+        return postRepository.save(post);
+    }
+
+    @Transactional
+    public Post publish(Long id) {
+        Post post = postRepository.findById(id)
+                .orElseThrow(() -> new IllegalArgumentException("Post not found with id: " + id));
+        
+        if (post.getPublishedAt() != null) {
+            throw new IllegalStateException("Post is already published");
+        }
+        
+        post.setPublishedAt(LocalDateTime.now());
+        return postRepository.save(post);
+    }
+
+    @Transactional
+    public Post update(Long id, Post postDetails) {
+        Post post = postRepository.findById(id)
+                .orElseThrow(() -> new IllegalArgumentException("Post not found with id: " + id));
+        
+        post.setTitle(postDetails.getTitle());
+        post.setContent(postDetails.getContent());
+        
+        return postRepository.save(post);
+    }
+
+    @Transactional
+    public void delete(Long id) {
+        if (!postRepository.existsById(id)) {
+            throw new IllegalArgumentException("Post not found with id: " + id);
+        }
+        postRepository.deleteById(id);
+    }
+}