Library Management System

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

class Book {
    private readonly copies: BookCopy[] = [];
 
    /**
     * Factory method for creating copies
     * Only Book can create BookCopy instances
     */
    addCopy(barcode: string, rackLocation: string): BookCopy {
        const copyId = this.generateCopyId();
        
        // BookCopy constructor is package-private in practice
        // Only Book can instantiate BookCopy
        const copy = new BookCopy(copyId, barcode, this, rackLocation);
        this.copies.push(copy);
        return copy;
    }
 
    /**
     * Removes a copy - enforces business constraints
     */
    removeCopy(copyId: string): void {
        const copy = this.findCopy(copyId);
        if (!copy) {
            throw new BookCopyNotFoundError(copyId);
        }
        
        // Composition lifecycle: can't remove if "in use"
        if (copy.isCurrentlyLoaned()) {
            throw new InvalidOperationError(
                'Cannot remove a copy that is currently loaned'
            );
        }
        
        const index = this.copies.indexOf(copy);
        this.copies.splice(index, 1);
        
        // In some languages, we might explicitly dispose of 'copy' here
        // In JS/TS, it becomes eligible for garbage collection
    }
 
    private generateCopyId(): string {
        return `${this.id}-COPY-${Date.now()}-${this.copies.length + 1}`;
    }
}
 
/**
 * BookCopy holds a reference back to its parent Book.
 * This reference is set at construction and never changes.
 */
class BookCopy {
    private readonly book: Book;  // Immutable parent reference
    
    constructor(
        id: string,
        barcode: string,
        book: Book,  // Required - cannot exist without Book
        rackLocation: string
    ) {
        this.id = id;
        this.barcode = barcode;
        this.book = book;
        this.rackLocation = rackLocation;
        this.status = BookCopyStatus.AVAILABLE;
    }
    
    /**
     * Always has access to parent Book
     * Enables navigation: copy.getBook().getTitle()
     */
    getBook(): Book {
        return this.book;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

class Member {
    private readonly activeLoans: Loan[] = [];
    private readonly loanHistory: Loan[] = [];
 
    /**
     * Adds an existing Loan to member's active loans
     * Note: Member doesn't CREATE the loan, just receives it
     */
    addLoan(loan: Loan): void {
        // Validate business rules
        const eligibility = this.canBorrow();
        if (!eligibility.eligible) {
            throw new BorrowingNotAllowedError(eligibility.reason);
        }
        
        // Member doesn't own Loan creation - just tracks the association
        this.activeLoans.push(loan);
    }
 
    /**
     * Moves loan from active to history
     * Loan continues to exist - it's just in a different collection
     */
    completeLoan(loan: Loan): void {
        const index = this.activeLoans.indexOf(loan);
        if (index === -1) {
            throw new LoanNotFoundError(
                'Loan not found in active loans'
            );
        }
        
        // Move to history, not delete
        this.activeLoans.splice(index, 1);
        this.loanHistory.push(loan);
    }
 
    /**
     * Gets active loans (returns copies to protect encapsulation)
     */
    getActiveLoans(): ReadonlyArray<Loan> {
        return [...this.activeLoans];
    }
}
 
/**
 * Loan has references to Member, BookCopy, and Librarian
 * It's associated with all three, owned by none
 */
class Loan {
    private readonly member: Member;     // Who borrowed
    private readonly bookCopy: BookCopy; // What was borrowed
    private readonly processedBy: Librarian; // Who processed
    
    constructor(
        id: string,
        member: Member,
        bookCopy: BookCopy,
        processedBy: Librarian
    ) {
        this.id = id;
        this.member = member;
        this.bookCopy = bookCopy;
        this.processedBy = processedBy;
        // ... initialization
    }
    
    // Loan can be queried independently
    // No entity "owns" Loan exclusively
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

class Book {
    private readonly reservations: Reservation[] = [];
 
    /**
     * Adds a reservation to the queue
     * New reservations go to the back
     */
    addReservation(reservation: Reservation): void {
        // Prevent duplicate reservations by same member
        const existingReservation = this.reservations.find(
            r => r.getMember().getId() === reservation.getMember().getId() &&
                 r.getStatus() === ReservationStatus.PENDING
        );
        
        if (existingReservation) {
            throw new DuplicateReservationError(
                'Member already has a pending reservation for this book'
            );
        }
        
        this.reservations.push(reservation);
    }
 
    /**
     * Gets the next reservation in queue (FIFO)
     * Returns null if no pending reservations
     */
    getNextPendingReservation(): Reservation | null {
        return this.reservations.find(
            r => r.getStatus() === ReservationStatus.PENDING
        ) || null;
    }
 
    /**
     * Checks if there are pending reservations
     * Used to determine if renewals are allowed
     */
    hasPendingReservations(): boolean {
        return this.reservations.some(
            r => r.getStatus() === ReservationStatus.PENDING ||
                 r.getStatus() === ReservationStatus.READY
        );
    }
 
    /**
     * Processes the queue when a copy is returned
     * Notifies the next member and places book on hold
     */
    processReservationQueue(returnedCopy: BookCopy): Reservation | null {
        const nextReservation = this.getNextPendingReservation();
        
        if (nextReservation) {
            nextReservation.markReady();
            returnedCopy.placeOnHold();
            // Trigger notification (handled by service layer)
            return nextReservation;
        }
        
        return null;
    }
 
    /**
     * Removes expired or cancelled reservations
     */
    cleanupReservations(): void {
        // Filter to keep only active reservations
        const activeStatuses = [
            ReservationStatus.PENDING,
            ReservationStatus.READY
        ];
        
        // Move inactive to separate collection if needed for history
        this.reservations
            .filter(r => !activeStatuses.includes(r.getStatus()))
            .forEach(r => {/* Archive logic */});
        
        // Keep only active
        this.reservations.splice(
            0, 
            this.reservations.length,
            ...this.reservations.filter(
                r => activeStatuses.includes(r.getStatus())
            )
        );
    }
}
 
/**
 * A reservation connects a Member who wants a Book
 */
class Reservation {
    private readonly member: Member;
    private readonly book: Book;
    private status: ReservationStatus;
    private readonly createdAt: Date;
    private notifiedAt: Date | null = null;
    private expiresAt: Date | null = null;
 
    constructor(id: string, member: Member, book: Book) {
        this.id = id;
        this.member = member;
        this.book = book;
        this.status = ReservationStatus.PENDING;
        this.createdAt = new Date();
        
        // Also add to member's reservations
        member.addReservation(this);
    }
 
    /**
     * Queue position based on creation time
     */
    getQueuePosition(): number {
        return this.book.getReservations()
            .filter(r => r.getStatus() === ReservationStatus.PENDING)
            .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime())
            .indexOf(this) + 1;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

/**
 * Book is an Aggregate Root.
 * External code must go through Book to access BookCopies.
 */
class Book {
    private readonly copies: BookCopy[] = [];
 
    // ✅ Good: Access copies through aggregate root methods
    findAvailableCopy(): BookCopy | null {
        return this.copies.find(c => c.isAvailable()) || null;
    }
 
    getCopyByBarcode(barcode: string): BookCopy | null {
        return this.copies.find(c => c.getBarcode() === barcode) || null;
    }
 
    // ✅ Good: Modifications go through aggregate root
    addCopy(barcode: string, location: string): BookCopy {
        // Business logic here
        const copy = new BookCopy(/*...*/);
        this.copies.push(copy);
        return copy;
    }
 
    // ✅ Good: Returns read-only view
    getCopies(): ReadonlyArray<BookCopy> {
        return [...this.copies];
    }
}
 
/**
 * BookRepository works with Book aggregate root.
 * Never provides direct access to BookCopy.
 */
interface BookRepository {
    findById(id: string): Promise<Book | null>;
    findByIsbn(isbn: string): Promise<Book | null>;
    save(book: Book): Promise<void>;
    
    // ❌ Wrong: This bypasses the aggregate root
    // findCopyByBarcode(barcode: string): Promise<BookCopy | null>;
    
    // ✅ Correct: Search through Book, get copy from result
    findByBarcode(barcode: string): Promise<Book | null>;
}
 
// Usage example:
async function checkoutBook(barcode: string, memberId: string) {
    // Get aggregate root first
    const book = await bookRepository.findByBarcode(barcode);
    if (!book) throw new BookNotFoundError();
    
    // Access copy through aggregate root
    const copy = book.getCopyByBarcode(barcode);
    if (!copy || !copy.isAvailable()) {
        throw new CopyNotAvailableError();
    }
    
    // Proceed with checkout...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

/**
 * Author has no back-reference to Book.
 * If we need "books by author", we query BookRepository.
 */
class Author {
    private readonly id: string;
    private name: string;
    
    // No books: Book[] here - unidirectional from Book to Author
    
    constructor(id: string, name: string) {
        this.id = id;
        this.name = name;
    }
}
 
class Book {
    private authors: Author[] = [];  // Book knows its authors
    
    addAuthor(author: Author): void {
        if (!this.authors.includes(author)) {
            this.authors.push(author);
        }
    }
    
    getAuthors(): ReadonlyArray<Author> {
        return [...this.authors];
    }
}
 
// If needed: "Find all books by author"
interface BookRepository {
    findByAuthor(authorId: string): Promise<Book[]>;
}
 
// Usage:
const authorBooks = await bookRepository.findByAuthor(author.getId());
// No need for author.getBooks() - repository handles this query