Relationships & DTOs

1
package com.example.library.author;
2

3
import java.util.UUID;
4
import com.github.f4b6a3.uuid.UuidCreator;
5
import jakarta.persistence.Entity;
6
import jakarta.persistence.Id;
7
import lombok.AccessLevel;
8
import lombok.EqualsAndHashCode;
9
import lombok.Getter;
10
import lombok.NoArgsConstructor;
11
import lombok.Setter;
12

13
@Entity
14
@Getter
15
@Setter
16
@NoArgsConstructor(access = AccessLevel.PROTECTED)
17
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
18
public class Author {
19

20
    @Id
21
    @EqualsAndHashCode.Include
22
    private UUID id = UuidCreator.getTimeOrderedEpoch();
23

24
    private String name;
25

26
    public Author(String name) {
27
        this.name = name;
28
    }
29
}

1
package com.example.library.book;
2

3
import java.util.HashSet;
4
import java.util.Set;
5
import java.util.UUID;
6
import com.example.library.author.Author;
7
import com.github.f4b6a3.uuid.UuidCreator;
8
import jakarta.persistence.Entity;
9
import jakarta.persistence.FetchType;
10
import jakarta.persistence.Id;
11
import jakarta.persistence.JoinColumn;
12
import jakarta.persistence.JoinTable;
13
import jakarta.persistence.ManyToMany;
17 collapsed lines
14
import lombok.AccessLevel;
15
import lombok.EqualsAndHashCode;
16
import lombok.Getter;
17
import lombok.NoArgsConstructor;
18
import lombok.Setter;
19

20
@Entity
21
@Getter
22
@Setter
23
@NoArgsConstructor(access = AccessLevel.PROTECTED)   // JPA needs it; protected discourages app code from using it
24
@EqualsAndHashCode(onlyExplicitlyIncluded = true)    // identity is the id, and ONLY the id
25
public class Book {
26

27
    @Id
28
    @EqualsAndHashCode.Include
29
    private UUID id = UuidCreator.getTimeOrderedEpoch();   // a fresh UUIDv7, set at construction
30

31
    private String title;
32
    private int year;
33

34
    // The relationship gets its own table. This side declares it, so this side writes its rows.
35
    @ManyToMany(fetch = FetchType.LAZY)
36
    @JoinTable(
37
        name = "book_author",
38
        joinColumns = @JoinColumn(name = "book_id"),
39
        inverseJoinColumns = @JoinColumn(name = "author_id"))
40
    private Set<Author> authors = new HashSet<>();
41

42
    // A book always comes with its authors: there is no way to build one without saying who wrote it.
43
    public Book(String title, int year, Set<Author> authors) {   // was Book(String title, String author, int year)
44
        this.title = title;
45
        this.year = year;
46
        this.authors.addAll(authors);   // copy in - never keep the caller's set
47
    }
48
}

1
databaseChangeLog:
2
  - changeSet:
3
      id: 002-create-author-table
4
      author: roman
5
      changes:
6
        - createTable:
7
            tableName: author
8
            columns:
9
              - column:
10
                  name: id
11
                  type: uuid
12
                  constraints:
13
                    primaryKey: true
14
                    nullable: false
15
              - column:
16
                  name: name
17
                  type: varchar(255)

1
databaseChangeLog:
2
  - changeSet:
3
      id: 003-link-books-to-authors
4
      author: roman
5
      changes:
6
        # 1. Expand: a many-to-many can't live as a column in either table, so it gets its own.
7
        - createTable:
8
            tableName: book_author
9
            columns:
10
              - column:
11
                  name: book_id
12
                  type: uuid
13
                  constraints:
14
                    nullable: false
15
              - column:
16
                  name: author_id
17
                  type: uuid
18
                  constraints:
19
                    nullable: false
20
        # One row per (book, author) pair - the pair itself is the key, so no duplicates.
21
        - addPrimaryKey:
22
            tableName: book_author
23
            columnNames: book_id, author_id
24
            constraintName: pk_book_author
25
        - addForeignKeyConstraint:
26
            baseTableName: book_author
27
            baseColumnNames: book_id
28
            constraintName: fk_book_author_book
29
            referencedTableName: book
30
            referencedColumnNames: id
31
        - addForeignKeyConstraint:
32
            baseTableName: book_author
33
            baseColumnNames: author_id
34
            constraintName: fk_book_author_author
35
            referencedTableName: author
36
            referencedColumnNames: id
37
        # 2. Migrate: carry the existing data across. Each distinct author text becomes
38
        #    an author row; each book gets a join row pointing at its author.
39
        - sql:
40
            sql: |
41
              INSERT INTO author (id, name)
42
              SELECT uuidv7(), author FROM book WHERE author IS NOT NULL GROUP BY author;
43
              INSERT INTO book_author (book_id, author_id)
44
              SELECT b.id, a.id FROM book b JOIN author a ON a.name = b.author;
45
        # 3. Contract: only now, with nothing left in it that isn't also in the join table,
46
        #    is the free-text column safe to drop.
47
        - dropColumn:
48
            tableName: book
49
            columnName: author

1
databaseChangeLog:
2
  - include:
3
      file: changes/001-create-book-table.yaml
4
      relativeToChangelogFile: true
5
  - include:
6
      file: changes/002-create-author-table.yaml
7
      relativeToChangelogFile: true
8
  - include:
9
      file: changes/003-link-books-to-authors.yaml
10
      relativeToChangelogFile: true

1
package com.example.library.book;
2

3
import java.util.Set;
4
import java.util.UUID;
5

6
// What we ACCEPT on POST/PUT. No id field -> nothing for a client to smuggle.
7
public record CreateBookRequest(String title, int year, Set<UUID> authorIds) {}

1
package com.example.library.author;
2

3
import java.util.UUID;
4

5
// What we SEND BACK for an author - on its own, or nested inside a book.
6
public record AuthorResponse(UUID id, String name) {
7
    public static AuthorResponse from(Author author) {
8
        return new AuthorResponse(author.getId(), author.getName());
9
    }
10
}

1
package com.example.library.book;
2

3
import java.util.Comparator;
4
import java.util.List;
5
import java.util.UUID;
6
import com.example.library.author.AuthorResponse;
7

8
// What we SEND BACK. Authors as a list, sorted by name so the JSON order is stable.
9
public record BookResponse(UUID id, String title, int year, List<AuthorResponse> authors) {
10
    public static BookResponse from(Book book) {
11
        List<AuthorResponse> authors = book.getAuthors().stream()
12
            .map(AuthorResponse::from)
13
            .sorted(Comparator.comparing(AuthorResponse::name))
14
            .toList();
15
        return new BookResponse(book.getId(), book.getTitle(), book.getYear(), authors);
16
    }
17
}

1
package com.example.library.author;
2

3
public record CreateAuthorRequest(String name) {}

1
package com.example.library.book;
2

3
import java.util.List;
4
import java.util.UUID;
5
import org.springframework.data.jpa.repository.JpaRepository;
6

7
public interface BookRepository extends JpaRepository<Book, UUID> {
8

9
    // Traverses the collection: WHERE any of the book's authors has this id
10
    List<Book> findByAuthorsId(UUID authorId);
11
}

1
package com.example.library.author;
2

3
import java.util.UUID;
4
import org.springframework.data.jpa.repository.JpaRepository;
5

6
public interface AuthorRepository extends JpaRepository<Author, UUID> {}

1
package com.example.library.book;
2

3
import java.util.HashSet;
4
import java.util.List;
5
import java.util.NoSuchElementException;
6
import java.util.Optional;
7
import java.util.Set;
8
import java.util.UUID;
9
import com.example.library.author.Author;
10
import com.example.library.author.AuthorRepository;
11
import org.springframework.stereotype.Service;
12

13
@Service
14
public class BookService {
15

16
    private final BookRepository books;
17
    private final AuthorRepository authors;            // new: to resolve author ids
18

19
    public BookService(BookRepository books, AuthorRepository authors) {
20
        this.books = books;
21
        this.authors = authors;
22
    }
23

24
    public List<Book> findAll(UUID authorId) {
25
        return (authorId == null) ? books.findAll() : books.findByAuthorsId(authorId);
26
    }
27

28
    public Optional<Book> findById(UUID id) {
29
        return books.findById(id);
30
    }
31

32
    public Book create(String title, int year, Set<UUID> authorIds) {
33
        Book book = new Book(title, year, requireAuthors(authorIds));
34
        return books.save(book);
35
    }
36

37
    public Optional<Book> replace(UUID id, String title, int year, Set<UUID> authorIds) {
38
        if (!books.existsById(id)) {
39
            return Optional.empty();
40
        }
41
        Book book = new Book(title, year, requireAuthors(authorIds));
42
        book.setId(id);                                // pin the path id, then upsert
43
        return Optional.of(books.save(book));
44
    }
45

46
    public boolean delete(UUID id) {
47
        if (!books.existsById(id)) {
48
            return false;
49
        }
50
        books.deleteById(id);
51
        return true;
52
    }
53

54
    // Every id must resolve to a real author, or the book isn't created at all.
55
    private Set<Author> requireAuthors(Set<UUID> authorIds) {
56
        List<Author> found = authors.findAllById(authorIds);
57
        if (found.size() != authorIds.size()) {
58
            Set<UUID> missing = new HashSet<>(authorIds);
59
            found.forEach(a -> missing.remove(a.getId()));
60
            throw new NoSuchElementException("No author with id " + missing);
61
        }
62
        return new HashSet<>(found);
63
    }
64
}

1
package com.example.library.book;
2

3
import java.net.URI;
4
import java.util.List;
5
import java.util.UUID;
6
import org.springframework.http.ResponseEntity;
7
import org.springframework.web.bind.annotation.DeleteMapping;
8
import org.springframework.web.bind.annotation.GetMapping;
9
import org.springframework.web.bind.annotation.PathVariable;
10
import org.springframework.web.bind.annotation.PostMapping;
11
import org.springframework.web.bind.annotation.PutMapping;
12
import org.springframework.web.bind.annotation.RequestBody;
13
import org.springframework.web.bind.annotation.RequestMapping;
14
import org.springframework.web.bind.annotation.RequestParam;
15
import org.springframework.web.bind.annotation.RestController;
16

17
@RestController
18
@RequestMapping("/api/books")
19
public class BookController {
20

21
    private final BookService books;
22

23
    public BookController(BookService books) {
24
        this.books = books;
25
    }
26

27
    @GetMapping                                          // GET /api/books  or  ?authorId=...
28
    public List<BookResponse> all(@RequestParam(required = false) UUID authorId) {
29
        return books.findAll(authorId).stream().map(BookResponse::from).toList();
30
    }
31

32
    @GetMapping("/{id}")
33
    public ResponseEntity<BookResponse> byId(@PathVariable UUID id) {
34
        return books.findById(id)
35
            .map(BookResponse::from)
36
            .map(ResponseEntity::ok)
37
            .orElse(ResponseEntity.notFound().build());
38
    }
39

40
    @PostMapping                                         // POST /api/books
41
    public ResponseEntity<BookResponse> create(@RequestBody CreateBookRequest req) {
42
        Book saved = books.create(req.title(), req.year(), req.authorIds());
43
        URI location = URI.create("/api/books/" + saved.getId());
44
        return ResponseEntity.created(location).body(BookResponse.from(saved));
45
    }
46

47
    @PutMapping("/{id}")                                 // PUT /api/books/{id}
48
    public ResponseEntity<BookResponse> replace(@PathVariable UUID id, @RequestBody CreateBookRequest req) {
49
        return books.replace(id, req.title(), req.year(), req.authorIds())
50
            .map(BookResponse::from)
51
            .map(ResponseEntity::ok)
52
            .orElse(ResponseEntity.notFound().build());
53
    }
54

55
    @DeleteMapping("/{id}")                     // DELETE /api/books/{id}
56
    public ResponseEntity<Void> delete(@PathVariable UUID id) {
57
        return books.delete(id)
58
                ? ResponseEntity.noContent().build()
59
                : ResponseEntity.notFound().build();
60
    }
61
}

1
package com.example.library.author;
2

3
import java.util.List;
4
import java.util.Optional;
5
import java.util.UUID;
6
import org.springframework.stereotype.Service;
7

8
@Service
9
public class AuthorService {
10

11
    private final AuthorRepository authors;
12

13
    public AuthorService(AuthorRepository authors) {
14
        this.authors = authors;
15
    }
16

17
    public List<Author> findAll() {
18
        return authors.findAll();
19
    }
20

21
    public Optional<Author> findById(UUID id) {
22
        return authors.findById(id);
23
    }
24

25
    public Author create(String name) {
26
        return authors.save(new Author(name));
27
    }
28

29
    public Optional<Author> replace(UUID id, String name) {
30
        if (!authors.existsById(id)) {
31
            return Optional.empty();
32
        }
33
        Author author = new Author(name);
34
        author.setId(id);                              // pin the path id, then upsert
35
        return Optional.of(authors.save(author));
36
    }
37

38
    public boolean delete(UUID id) {
39
        if (!authors.existsById(id)) {
40
            return false;
41
        }
42
        authors.deleteById(id);
43
        return true;
44
    }
45
}

1
package com.example.library.author;
2

3
import java.net.URI;
4
import java.util.List;
5
import java.util.UUID;
6
import org.springframework.http.ResponseEntity;
7
import org.springframework.web.bind.annotation.DeleteMapping;
8
import org.springframework.web.bind.annotation.GetMapping;
9
import org.springframework.web.bind.annotation.PathVariable;
10
import org.springframework.web.bind.annotation.PostMapping;
11
import org.springframework.web.bind.annotation.PutMapping;
12
import org.springframework.web.bind.annotation.RequestBody;
13
import org.springframework.web.bind.annotation.RequestMapping;
14
import org.springframework.web.bind.annotation.RestController;
15

16
@RestController
17
@RequestMapping("/api/authors")
18
public class AuthorController {
19

20
    private final AuthorService authors;
21

22
    public AuthorController(AuthorService authors) {
23
        this.authors = authors;
24
    }
25

26
    @GetMapping
27
    public List<AuthorResponse> all() {
28
        return authors.findAll().stream().map(AuthorResponse::from).toList();
29
    }
30

31
    @GetMapping("/{id}")
32
    public ResponseEntity<AuthorResponse> byId(@PathVariable UUID id) {
33
        return authors.findById(id)
34
            .map(AuthorResponse::from)
35
            .map(ResponseEntity::ok)
36
            .orElse(ResponseEntity.notFound().build());
37
    }
38

39
    @PostMapping
40
    public ResponseEntity<AuthorResponse> create(@RequestBody CreateAuthorRequest req) {
41
        Author saved = authors.create(req.name());
42
        URI location = URI.create("/api/authors/" + saved.getId());
43
        return ResponseEntity.created(location).body(AuthorResponse.from(saved));
44
    }
45

46
    @PutMapping("/{id}")
47
    public ResponseEntity<AuthorResponse> replace(@PathVariable UUID id, @RequestBody CreateAuthorRequest req) {
48
        return authors.replace(id, req.name())
49
            .map(AuthorResponse::from)
50
            .map(ResponseEntity::ok)
51
            .orElse(ResponseEntity.notFound().build());
52
    }
53

54
    @DeleteMapping("/{id}")
55
    public ResponseEntity<Void> delete(@PathVariable UUID id) {
56
        return authors.delete(id)
57
            ? ResponseEntity.noContent().build()
58
            : ResponseEntity.notFound().build();
59
    }
60
}

1
package com.example.library;
2

3
import java.util.HashSet;
4
import java.util.Set;
5
import com.example.library.author.Author;
6
import com.example.library.author.AuthorRepository;
7
import com.example.library.book.Book;
8
import com.example.library.book.BookRepository;
9
import org.springframework.boot.CommandLineRunner;
10
import org.springframework.stereotype.Component;
11

12
@Component
13
public class DataSeeder implements CommandLineRunner {
14

15
    private final AuthorRepository authors;
16
    private final BookRepository books;          // now need both repositories
17

18
    public DataSeeder(AuthorRepository authors, BookRepository books) {
19
        this.authors = authors;
20
        this.books = books;
21
    }
22

23
    @Override
24
    public void run(String... args) {
25
        if (authors.count() > 0) {
26
            return;   // seed once
27
        }
28
        add("Clean Code", 2008, "Robert C. Martin");
29
        add("Effective Java", 2018, "Joshua Bloch");
30
        add("Domain-Driven Design", 2003, "Eric Evans");
31
    }
32

33
    private void add(String title, int year, String... authorNames) {
34
        Set<Author> bookAuthors = new HashSet<>();
35
        for (String name : authorNames) {
36
            bookAuthors.add(authors.save(new Author(name)));   // 1. the authors must exist...
37
        }
38
        Book book = new Book(title, year, bookAuthors);        // 2. ...before the book points at them...
39
        books.save(book);                                      // 3. ...and only then is saved
40
    }
41
}