Reformat files to comply with Checkstyle rules

Author: codesungrape

src/main/java/com/codesungrape/hmcts/bookapi/BookApiApplication.java

@@ -11,8 +11,8 @@
 @SpringBootApplication
 public class BookApiApplication {
   /**
-  * * Main entry point — starts the Spring Boot application.
-  */
+   * * Main entry point — starts the Spring Boot application.
+   */
   public static void main(String[] args) {
     SpringApplication.run(BookApiApplication.class, args);
   }

src/main/java/com/codesungrape/hmcts/bookapi/entity/Book.java

@@ -1,23 +1,39 @@
 package com.codesungrape.hmcts.bookapi.entity;
 
-import jakarta.persistence.*;
-import java.util.UUID;
-import lombok.*;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.PrePersist;
+import jakarta.persistence.PreUpdate;
+import jakarta.persistence.Table;
 import java.time.Instant;
+import java.util.UUID;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
 
 /**
- * JPA Entity representing the Book table in PostgreSQL.
- * This holds the persisted state of the resource.
- * HMCTS Rule Check: IDs must be opaque strings. Using UUID for distributed ID generation.
- * @Entity: Marks the class as a JPA entity - tells hibernate to map Java classes to database tables.
- * @Table: Defines which database table this entity maps to. HMCTS Naming: Lowercase, singular table name is common practice.
- * Lombok annotations:
- * @Getter: Automatically generates getters for all fields.
- * @Setter: Automatically generates setters.
- * @AllArgsConstructor: Generates a no-argument constructor (required by JPA).
- *                      JPA needs to instantiate the entity using reflection. 'PROTECTED' prevents misuse.
- * @Builder: Adds a builder pattern for clean object creation.
-*            You can do Book.builder().title("A").author("B").build();
+ * Represents the Book table in PostgreSQL as a JPA entity.
+ * Stores the persisted state of a Book resource.
+ * HMCTS Rule: IDs must be opaque; using UUID for distributed ID generation.
+ *
+ * @Entity: Marks the class as a JPA entity for Hibernate table mapping.
+ * @Table: Specifies the database table; HMCTS: lowercase, singular table name.
+ *     Lombok Annotations:
+ * @Getter: Generates getters for all fields.
+ * @Setter: Generates setters for all fields.
+ * @NoArgsConstructor: Protected no-arg constructor for JPA instantiation.
+ * @AllArgsConstructor: Constructor with all fields for test convenience.
+ * @Builder: Adds builder pattern for easy object creation.
+ *     Example: Book.builder()
+ *     .title("A")
+ *     .author("B")
+ *     .build();
  */
 @Entity
 @Table(name = "book")
@@ -28,49 +44,53 @@
 @Builder // For convenience in creating instances
 public class Book {
 
-    @Id // Primary key of the table
-    @GeneratedValue(strategy = GenerationType.UUID)
-    @Column(name = "id", nullable = false) // maps the field to a database column named 'id' + 'nullable =false' database column cannot be NULL.
-    private UUID id;
-
-    @Column(name = "title", nullable = false)
-    private String title;
-
-    @Column(name = "synopsis", nullable = false, columnDefinition = "TEXT")
-    private String synopsis;
+  @Id // Primary key of the table
+  @GeneratedValue(strategy = GenerationType.UUID)
+  @Column(name = "id", nullable = false)
+  private UUID id;
 
-    @Column(name = "author", nullable = false)
-    private String author;
+  @Column(name = "title", nullable = false)
+  private String title;
 
-    // Soft delete - makes DELETE operations idempotent (safe to repeat)
-    // Soft delete - using @Builder.Default to ensure the builder
-    // respects this initialization if the field is not set explicitly.
-    @Column(name = "deleted", nullable = false)
-    @Builder.Default
-    private boolean deleted = false;
+  @Column(name = "synopsis", nullable = false, columnDefinition = "TEXT")
+  private String synopsis;
 
-    // `createdAt` is null upon object creation.
-    // It will be set by the `onCreate()` method right before persistence.
-    @Column(name = "created_at", nullable = false, updatable = false)
-    private Instant createdAt;
+  @Column(name = "author", nullable = false)
+  private String author;
 
-    @Column(name = "modified_at")
-    private java.time.Instant modifiedAt;
+  // Soft delete - makes DELETE operations idempotent (safe to repeat)
+  // Using @Builder.Default to ensure the builder respects this initialization
+  // if the field is not set explicitly.
+  @Column(name = "deleted", nullable = false)
+  @Builder.Default
+  private boolean deleted = false;
 
-    // --- JPA lifecycle callbacks ---
-    @PrePersist
-    protected void onCreate() {
-        this.createdAt = java.time.Instant.now();
-    }
+  // `createdAt` is null upon object creation.
+  // It will be set by the `onCreate()` method right before persistence.
+  @Column(name = "created_at", nullable = false, updatable = false)
+  private Instant createdAt;
 
-    // --- Business Logic Helper ---
-    // HMCTS mandates business logic in services, but a setter hook is acceptable.
-    // Lifecycle callback - special method runs automatically before Hibernate updates a record in the database.
-    @PreUpdate
-    protected void onUpdate() {
+  @Column(name = "modified_at")
+  private Instant modifiedAt;
 
-        this.modifiedAt = java.time.Instant.now();
-    }
+  // --- JPA lifecycle callbacks ---
+  /**
+   * Sets createdAt before persisting a new Book record.
+   */
+  @PrePersist
+  protected void onCreate() {
+    this.createdAt = Instant.now();
+  }
 
+  // --- Business Logic Helper ---
+  // HMCTS requires business logic to live in services; setter hooks are allowed.
+  // Lifecycle callback: runs automatically before Hibernate updates a database record.
 
-}
+  /**
+   * Updates modifiedAt before updating an existing Book record.
+   */
+  @PreUpdate
+  protected void onUpdate() {
+    this.modifiedAt = Instant.now();
+  }
+}

src/main/java/com/codesungrape/hmcts/bookapi/repository/BookRepository.java

@@ -1,24 +1,28 @@
 package com.codesungrape.hmcts.bookapi.repository;
 
+import com.codesungrape.hmcts.bookapi.entity.Book;
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
-
-import com.codesungrape.hmcts.bookapi.entity.Book;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
 /**
- * Repository interface for Book Entity.
- * Spring Data JPA automatically provides CRUD operations based on the Entity and ID type.
+ * Repository interface for Book entities.
+ * Provides CRUD operations and custom queries for non-deleted books.
+ * Spring Data JPA automatically implements this interface at runtime.
  */
 @Repository
 public interface BookRepository extends JpaRepository<Book, UUID> {
 
-    // Custom query to find books that have NOT been soft-deleted
-    List<Book> findAllByDeletedFalse();
+  /**
+   * Custom query retrieves all Book records that have not been soft-deleted.
+   */
+  List<Book> findAllByDeletedFalse();
 
-    // Custom query to find a specific, non-deleted book by ID.
-    Optional<Book> findByIdAndDeletedFalse(UUID id);
+  /**
+   * Retrieves a single Book by ID, if it exists and has not been soft-deleted.
+   */
+  Optional<Book> findByIdAndDeletedFalse(UUID id);
 
 }

src/main/java/com/codesungrape/hmcts/bookapi/service/BookService.java

@@ -1,11 +1,10 @@
 package com.codesungrape.hmcts.bookapi.service;
 
 import com.codesungrape.hmcts.bookapi.dto.BookRequest;
+import com.codesungrape.hmcts.bookapi.entity.Book;
 import com.codesungrape.hmcts.bookapi.repository.BookRepository;
-import org.springframework.stereotype.Service; // Marks a class as a Service Layer component.
 import lombok.RequiredArgsConstructor;
-
-import com.codesungrape.hmcts.bookapi.entity.Book;
+import org.springframework.stereotype.Service;
 
 /**
  * Service layer responsible for all business logic related to the Book resource.
@@ -14,43 +13,47 @@
 @RequiredArgsConstructor // Lombok creates constructor for dependency injection
 public class BookService {
 
-    // Create a field to store the repo
-    private final BookRepository bookRepository;
-
-    // 1. CREATE Operation (POST /books)
-    public Book createBook(BookRequest request) {
-        // Validation check for business rules (e.g., uniqueness, if required)
-        if (request == null) {
-            throw new NullPointerException("BookRequest cannot be null");
-        }
-
-
-        // REVISIT: Leaving this here for now as i haven't implemented the Controller Layer yet
-        // The service layer is duplicating validation that already exists in the
-        // BookRequest DTO with @notblank annotations. Since the DTO has validation
-        // constraints, this manual check is redundant when Spring's validation
-        // framework is properly configured in the controller layer.
-        // Consider removing this duplication or adding a comment explaining
-        // why service-level validation is necessary in addition to DTO validation.
-        if (request.getTitle() == null || request.getTitle().isBlank()) {
-            throw new IllegalArgumentException("Book title cannot be null or blank");
-        }
-
-        // Map DTO to Entity
-        Book newBook = Book.builder()
-                .title(request.getTitle())
-                .author(request.getAuthor())
-                .synopsis(request.getSynopsis())
-                // ID and created_at are auto-generated by JPA/DB
-                .build();
-
-        Book savedBook = bookRepository.save(newBook);
-
-        // Defensive check (even though it "shouldn't" happen aka follows JPA contract)
-        if (savedBook == null) {
-            throw new IllegalStateException("Failed to save book - repository returned null");
-        }
-
-        return savedBook;
+  // Create a field to store the repo
+  private final BookRepository bookRepository;
+
+  /**
+   * Creates a new Book entity from the given BookRequest DTO and persists it.
+   *
+   * @param request DTO containing book details (title, author, synopsis)
+   * @return The saved Book entity
+   * @throws NullPointerException if request is null
+   * @throws IllegalArgumentException if title is null or blank
+   * @throws IllegalStateException if the repository fails to save the book
+   */
+
+  public Book createBook(BookRequest request) {
+    // Validation check for business rules (e.g., uniqueness, if required)
+    if (request == null) {
+      throw new NullPointerException("BookRequest cannot be null");
     }
+
+
+    // TODO: Leaving this here for now as i haven't implemented the Controller Layer yet
+    // The service layer is duplicating validation that already exists in the
+    // BookRequest DTO with @notblank annotations. Since the DTO has validation
+    // constraints, this manual check is redundant when Spring's validation
+    // framework is properly configured in the controller layer.
+    // Consider removing this duplication or adding a comment explaining
+    // why service-level validation is necessary in addition to DTO validation.
+    if (request.title() == null || request.title().isBlank()) {
+      throw new IllegalArgumentException("Book title cannot be null or blank");
+    }
+
+    // Map DTO to Entity
+    Book newBook = Book.builder()
+        .title(request.title())
+        .author(request.author())
+        .synopsis(request.synopsis())
+        // ID and created_at are auto-generated by JPA/DB
+        .build();
+
+    Book savedBook = bookRepository.save(newBook);
+
+    return savedBook;
+  }
 }

src/test/java/com/codesungrape/hmcts/bookapi/BookApiApplicationTests.java

@@ -8,8 +8,8 @@
 @ActiveProfiles("test")
 class BookApiApplicationTests {
 
-	@Test
-	void contextLoads() {
-	}
+  @Test
+  void contextLoads() {
+  }
 
 }