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
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

/**
 * Represents a book title in the library catalog.
 * This is the intellectual work, not a physical copy.
 */
class Book {
    private readonly id: string;
    private isbn: string;
    private title: string;
    private authors: Author[];
    private publisher: string;
    private publicationYear: number;
    private subject: string;
    private description: string;
    private readonly copies: BookCopy[];
    private readonly createdAt: Date;
    private updatedAt: Date;
 
    constructor(
        id: string,
        isbn: string,
        title: string,
        authors: Author[],
        publisher: string,
        publicationYear: number,
        subject: string
    ) {
        this.id = id;
        this.isbn = isbn;
        this.title = title;
        this.authors = authors;
        this.publisher = publisher;
        this.publicationYear = publicationYear;
        this.subject = subject;
        this.description = "";
        this.copies = [];
        this.createdAt = new Date();
        this.updatedAt = new Date();
    }
 
    // ============ Core Behaviors ============
    
    /**
     * Adds a new physical copy of this book to the library
     */
    addCopy(barcode: string, rackLocation: string): BookCopy {
        const copy = new BookCopy(
            this.generateCopyId(),
            barcode,
            this,
            rackLocation
        );
        this.copies.push(copy);
        this.markUpdated();
        return copy;
    }
 
    /**
     * Removes a copy from circulation (damaged, lost, etc.)
     * Throws if copy has active loan
     */
    removeCopy(copyId: string): void {
        const copy = this.findCopy(copyId);
        if (!copy) {
            throw new Error(`Copy ${copyId} not found`);
        }
        if (copy.isCurrentlyLoaned()) {
            throw new Error('Cannot remove copy with active loan');
        }
        const index = this.copies.indexOf(copy);
        this.copies.splice(index, 1);
        this.markUpdated();
    }
 
    /**
     * Finds an available copy for checkout
     * Returns null if no copies available
     */
    findAvailableCopy(): BookCopy | null {
        return this.copies.find(copy => copy.isAvailable()) || null;
    }
 
    /**
     * Gets count of available copies
     */
    getAvailableCopyCount(): number {
        return this.copies.filter(copy => copy.isAvailable()).length;
    }
 
    /**
     * Gets total copy count in inventory
     */
    getTotalCopyCount(): number {
        return this.copies.length;
    }
 
    /**
     * Checks if any copy is available for borrowing
     */
    hasAvailableCopy(): boolean {
        return this.copies.some(copy => copy.isAvailable());
    }
 
    // ============ Catalog Operations ============
 
    updateDetails(
        title?: string,
        publisher?: string,
        description?: string
    ): void {
        if (title) this.title = title;
        if (publisher) this.publisher = publisher;
        if (description) this.description = description;
        this.markUpdated();
    }
 
    addAuthor(author: Author): void {
        if (!this.authors.includes(author)) {
            this.authors.push(author);
            this.markUpdated();
        }
    }
 
    // ============ Private Helpers ============
 
    private findCopy(copyId: string): BookCopy | undefined {
        return this.copies.find(c => c.getId() === copyId);
    }
 
    private generateCopyId(): string {
        return `${this.id}-COPY-${this.copies.length + 1}`;
    }
 
    private markUpdated(): void {
        this.updatedAt = new Date();
    }
 
    // ============ Getters ============
 
    getId(): string { return this.id; }
    getIsbn(): string { return this.isbn; }
    getTitle(): string { return this.title; }
    getAuthors(): Author[] { return [...this.authors]; }
    getPublisher(): string { return this.publisher; }
    getPublicationYear(): number { return this.publicationYear; }
    getSubject(): string { return this.subject; }
    getCopies(): BookCopy[] { return [...this.copies]; }
}

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

/**
 * Status of a physical book copy
 */
enum BookCopyStatus {
    AVAILABLE = 'AVAILABLE',   // Can be borrowed
    LOANED = 'LOANED',         // Currently checked out
    RESERVED = 'RESERVED',     // Held for pickup by reservation
    LOST = 'LOST',             // Reported lost
    DAMAGED = 'DAMAGED',       // Under repair
    REFERENCE = 'REFERENCE'    // Cannot leave library
}
 
/**
 * Represents a physical copy of a book.
 * This is what gets loaned to members.
 */
class BookCopy {
    private readonly id: string;
    private readonly barcode: string;
    private readonly book: Book;  // Reference to parent Book
    private status: BookCopyStatus;
    private rackLocation: string;
    private readonly addedDate: Date;
    private currentLoan: Loan | null;
 
    constructor(
        id: string,
        barcode: string,
        book: Book,
        rackLocation: string
    ) {
        this.id = id;
        this.barcode = barcode;
        this.book = book;
        this.rackLocation = rackLocation;
        this.status = BookCopyStatus.AVAILABLE;
        this.addedDate = new Date();
        this.currentLoan = null;
    }
 
    // ============ Status Management ============
 
    /**
     * Marks copy as loaned to a member
     */
    checkOut(loan: Loan): void {
        if (!this.isAvailable()) {
            throw new Error(
                `Cannot checkout copy ${this.id}: status is ${this.status}`
            );
        }
        this.status = BookCopyStatus.LOANED;
        this.currentLoan = loan;
    }
 
    /**
     * Marks copy as returned
     * @param hasReservation - if true, status becomes RESERVED
     */
    checkIn(hasReservation: boolean): void {
        if (this.status !== BookCopyStatus.LOANED) {
            throw new Error(
                `Cannot check in copy ${this.id}: not currently loaned`
            );
        }
        this.currentLoan = null;
        this.status = hasReservation 
            ? BookCopyStatus.RESERVED 
            : BookCopyStatus.AVAILABLE;
    }
 
    /**
     * Places copy on hold for reservation pickup
     */
    placeOnHold(): void {
        if (this.status !== BookCopyStatus.AVAILABLE) {
            throw new Error(
                `Cannot hold copy ${this.id}: status is ${this.status}`
            );
        }
        this.status = BookCopyStatus.RESERVED;
    }
 
    /**
     * Releases hold, making copy available again
     * Called when reservation expires or is cancelled
     */
    releaseHold(): void {
        if (this.status !== BookCopyStatus.RESERVED) {
            throw new Error(
                `Cannot release hold on copy ${this.id}: not reserved`
            );
        }
        this.status = BookCopyStatus.AVAILABLE;
    }
 
    /**
     * Marks copy as lost
     */
    reportLost(): void {
        this.status = BookCopyStatus.LOST;
        this.currentLoan = null;
    }
 
    /**
     * Marks copy as damaged
     */
    reportDamaged(): void {
        this.status = BookCopyStatus.DAMAGED;
    }
 
    // ============ Query Methods ============
 
    isAvailable(): boolean {
        return this.status === BookCopyStatus.AVAILABLE;
    }
 
    isCurrentlyLoaned(): boolean {
        return this.status === BookCopyStatus.LOANED;
    }
 
    canBeLoaned(): boolean {
        return this.status === BookCopyStatus.AVAILABLE ||
               this.status === BookCopyStatus.RESERVED;
    }
 
    // ============ Getters ============
 
    getId(): string { return this.id; }
    getBarcode(): string { return this.barcode; }
    getBook(): Book { return this.book; }
    getStatus(): BookCopyStatus { return this.status; }
    getRackLocation(): string { return this.rackLocation; }
    getCurrentLoan(): Loan | null { return this.currentLoan; }
}

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282

/**
 * Types of membership with different borrowing privileges
 */
enum MembershipType {
    STUDENT = 'STUDENT',
    FACULTY = 'FACULTY',
    GENERAL = 'GENERAL'
}
 
/**
 * Account status affecting borrowing ability
 */
enum MemberStatus {
    ACTIVE = 'ACTIVE',
    SUSPENDED = 'SUSPENDED',
    EXPIRED = 'EXPIRED',
    CLOSED = 'CLOSED'
}
 
/**
 * Represents a library member who can borrow books.
 */
class Member {
    private readonly id: string;
    private readonly cardNumber: string;
    private name: string;
    private email: string;
    private phone: string;
    private address: Address;
    private membershipType: MembershipType;
    private status: MemberStatus;
    private readonly activeLoans: Loan[];
    private readonly loanHistory: Loan[];
    private readonly reservations: Reservation[];
    private totalFinesOwed: number;
    private readonly memberSince: Date;
    private membershipExpiry: Date;
 
    constructor(
        id: string,
        cardNumber: string,
        name: string,
        email: string,
        membershipType: MembershipType
    ) {
        this.id = id;
        this.cardNumber = cardNumber;
        this.name = name;
        this.email = email;
        this.phone = "";
        this.address = new Address("", "", "", "");
        this.membershipType = membershipType;
        this.status = MemberStatus.ACTIVE;
        this.activeLoans = [];
        this.loanHistory = [];
        this.reservations = [];
        this.totalFinesOwed = 0;
        this.memberSince = new Date();
        this.membershipExpiry = this.calculateExpiryDate();
    }
 
    // ============ Borrowing Operations ============
 
    /**
     * Checks if member can borrow more books
     * Validates status, limit, and fine threshold
     */
    canBorrow(): BorrowEligibility {
        if (this.status !== MemberStatus.ACTIVE) {
            return { 
                eligible: false, 
                reason: `Account is ${this.status.toLowerCase()}` 
            };
        }
 
        if (this.isAtBorrowingLimit()) {
            return { 
                eligible: false, 
                reason: `At borrowing limit (${this.getBorrowingLimit()} books)` 
            };
        }
 
        if (this.hasExcessiveFines()) {
            return { 
                eligible: false, 
                reason: `Outstanding fines exceed threshold ($${this.totalFinesOwed})` 
            };
        }
 
        return { eligible: true };
    }
 
    /**
     * Records a new loan for this member
     */
    addLoan(loan: Loan): void {
        const eligibility = this.canBorrow();
        if (!eligibility.eligible) {
            throw new Error(`Cannot add loan: ${eligibility.reason}`);
        }
        this.activeLoans.push(loan);
    }
 
    /**
     * Marks a loan as returned and moves to history
     */
    completeLoan(loan: Loan): void {
        const index = this.activeLoans.indexOf(loan);
        if (index === -1) {
            throw new Error('Loan not found in active loans');
        }
        this.activeLoans.splice(index, 1);
        this.loanHistory.push(loan);
    }
 
    /**
     * Gets remaining borrowing capacity
     */
    getRemainingBorrowingCapacity(): number {
        return this.getBorrowingLimit() - this.activeLoans.length;
    }
 
    // ============ Fine Management ============
 
    /**
     * Adds a fine to the member's account
     */
    addFine(amount: number): void {
        if (amount <= 0) {
            throw new Error('Fine amount must be positive');
        }
        this.totalFinesOwed += amount;
        
        // Auto-suspend if over threshold
        if (this.hasExcessiveFines()) {
            this.suspend('Excessive unpaid fines');
        }
    }
 
    /**
     * Processes a fine payment
     */
    payFine(amount: number): void {
        if (amount <= 0) {
            throw new Error('Payment amount must be positive');
        }
        if (amount > this.totalFinesOwed) {
            throw new Error('Payment exceeds outstanding fines');
        }
        
        this.totalFinesOwed -= amount;
        
        // Reactivate if fines cleared and was suspended for fines
        if (this.totalFinesOwed === 0 && 
            this.status === MemberStatus.SUSPENDED) {
            this.reactivate();
        }
    }
 
    /**
     * Waives all or part of fines (librarian action)
     */
    waiveFine(amount: number): void {
        const waiveAmount = Math.min(amount, this.totalFinesOwed);
        this.totalFinesOwed -= waiveAmount;
    }
 
    // ============ Reservation Management ============
 
    /**
     * Adds a reservation for this member
     */
    addReservation(reservation: Reservation): void {
        if (this.reservations.length >= this.getMaxReservations()) {
            throw new Error(
                `Maximum reservations (${this.getMaxReservations()}) reached`
            );
        }
        this.reservations.push(reservation);
    }
 
    /**
     * Removes a reservation (fulfilled, cancelled, or expired)
     */
    removeReservation(reservation: Reservation): void {
        const index = this.reservations.indexOf(reservation);
        if (index !== -1) {
            this.reservations.splice(index, 1);
        }
    }
 
    // ============ Account Status ============
 
    suspend(reason: string): void {
        this.status = MemberStatus.SUSPENDED;
        // In real system: log reason, notify member
    }
 
    reactivate(): void {
        if (this.hasExcessiveFines()) {
            throw new Error('Cannot reactivate: outstanding fines');
        }
        this.status = MemberStatus.ACTIVE;
    }
 
    renewMembership(years: number = 1): void {
        const now = new Date();
        const baseDate = this.membershipExpiry > now 
            ? this.membershipExpiry 
            : now;
        this.membershipExpiry = new Date(
            baseDate.setFullYear(baseDate.getFullYear() + years)
        );
        if (this.status === MemberStatus.EXPIRED) {
            this.status = MemberStatus.ACTIVE;
        }
    }
 
    // ============ Membership Type Rules ============
 
    getBorrowingLimit(): number {
        switch (this.membershipType) {
            case MembershipType.FACULTY: return 10;
            case MembershipType.STUDENT: return 5;
            case MembershipType.GENERAL: return 3;
        }
    }
 
    getLoanPeriodDays(): number {
        switch (this.membershipType) {
            case MembershipType.FACULTY: return 30;
            case MembershipType.STUDENT: return 21;
            case MembershipType.GENERAL: return 14;
        }
    }
 
    getDailyFineRate(): number {
        switch (this.membershipType) {
            case MembershipType.FACULTY: return 0.10;
            case MembershipType.STUDENT: return 0.25;
            case MembershipType.GENERAL: return 0.50;
        }
    }
 
    getMaxReservations(): number {
        return 5; // Same for all types in our design
    }
 
    // ============ Private Helpers ============
 
    private isAtBorrowingLimit(): boolean {
        return this.activeLoans.length >= this.getBorrowingLimit();
    }
 
    private hasExcessiveFines(): boolean {
        const FINE_SUSPENSION_THRESHOLD = 25.00;
        return this.totalFinesOwed >= FINE_SUSPENSION_THRESHOLD;
    }
 
    private calculateExpiryDate(): Date {
        const expiry = new Date();
        expiry.setFullYear(expiry.getFullYear() + 1);
        return expiry;
    }
 
    // ============ Getters ============
 
    getId(): string { return this.id; }
    getCardNumber(): string { return this.cardNumber; }
    getName(): string { return this.name; }
    getEmail(): string { return this.email; }
    getMembershipType(): MembershipType { return this.membershipType; }
    getStatus(): MemberStatus { return this.status; }
    getActiveLoans(): Loan[] { return [...this.activeLoans]; }
    getTotalFinesOwed(): number { return this.totalFinesOwed; }
    getReservations(): Reservation[] { return [...this.reservations]; }
}
 
interface BorrowEligibility {
    eligible: boolean;
    reason?: string;
}

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238

/**
 * Loan status tracking the lifecycle of a borrowing transaction
 */
enum LoanStatus {
    ACTIVE = 'ACTIVE',       // Currently borrowed
    RETURNED = 'RETURNED',   // Returned on time
    OVERDUE = 'OVERDUE',     // Past due date (still active)
    LOST = 'LOST',           // Reported as lost
    COMPLETED = 'COMPLETED'  // Returned (may have been overdue)
}
 
/**
 * Represents a book borrowing transaction.
 * Tracks the complete lifecycle from checkout to return.
 */
class Loan {
    private readonly id: string;
    private readonly member: Member;
    private readonly bookCopy: BookCopy;
    private readonly checkoutDate: Date;
    private dueDate: Date;
    private returnDate: Date | null;
    private status: LoanStatus;
    private renewalCount: number;
    private fineAmount: number;
    private readonly processedBy: Librarian;
 
    private static readonly MAX_RENEWALS = 2;
 
    constructor(
        id: string,
        member: Member,
        bookCopy: BookCopy,
        processedBy: Librarian
    ) {
        this.id = id;
        this.member = member;
        this.bookCopy = bookCopy;
        this.processedBy = processedBy;
        this.checkoutDate = new Date();
        this.dueDate = this.calculateDueDate();
        this.returnDate = null;
        this.status = LoanStatus.ACTIVE;
        this.renewalCount = 0;
        this.fineAmount = 0;
    }
 
    // ============ Core Operations ============
 
    /**
     * Processes the return of this loan
     * Calculates fine if overdue
     */
    returnBook(): FineResult {
        if (this.status === LoanStatus.RETURNED || 
            this.status === LoanStatus.COMPLETED) {
            throw new Error('Loan already returned');
        }
 
        this.returnDate = new Date();
        
        const wasOverdue = this.isOverdue();
        if (wasOverdue) {
            this.fineAmount = this.calculateFine();
            this.member.addFine(this.fineAmount);
        }
 
        this.status = LoanStatus.COMPLETED;
        this.bookCopy.checkIn(false); // Reservation check done by service
 
        return {
            wasOverdue,
            fineAmount: this.fineAmount,
            daysOverdue: wasOverdue ? this.getOverdueDays() : 0
        };
    }
 
    /**
     * Renews the loan, extending the due date
     * @throws if renewal limit exceeded or book is reserved
     */
    renew(hasReservation: boolean): void {
        this.validateRenewal(hasReservation);
        
        // Extend from today, not from original due date
        this.dueDate = this.calculateDueDateFromNow();
        this.renewalCount++;
        
        // If was overdue, now back to active
        if (this.status === LoanStatus.OVERDUE) {
            this.status = LoanStatus.ACTIVE;
        }
    }
 
    /**
     * Reports the book as lost
     * Applies replacement fine
     */
    reportLost(): void {
        if (this.status !== LoanStatus.ACTIVE && 
            this.status !== LoanStatus.OVERDUE) {
            throw new Error('Cannot report lost: invalid loan status');
        }
 
        const LOST_BOOK_FINE = 50.00; // Replacement cost
        this.fineAmount = LOST_BOOK_FINE + this.calculateFine();
        this.member.addFine(this.fineAmount);
        
        this.status = LoanStatus.LOST;
        this.bookCopy.reportLost();
    }
 
    // ============ Status Checking ============
 
    /**
     * Checks if loan is past due date
     */
    isOverdue(): boolean {
        if (this.status === LoanStatus.RETURNED || 
            this.status === LoanStatus.COMPLETED) {
            return false;
        }
        
        const checkDate = this.returnDate || new Date();
        return checkDate > this.dueDate;
    }
 
    /**
     * Gets number of days overdue (0 if not overdue)
     */
    getOverdueDays(): number {
        if (!this.isOverdue()) return 0;
        
        const checkDate = this.returnDate || new Date();
        const diffTime = checkDate.getTime() - this.dueDate.getTime();
        return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
    }
 
    /**
     * Gets days remaining until due (negative if overdue)
     */
    getDaysRemaining(): number {
        const now = new Date();
        const diffTime = this.dueDate.getTime() - now.getTime();
        return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
    }
 
    /**
     * Checks if more renewals are allowed
     */
    canRenew(hasReservation: boolean): RenewalEligibility {
        if (this.renewalCount >= Loan.MAX_RENEWALS) {
            return { 
                canRenew: false, 
                reason: `Maximum renewals (${Loan.MAX_RENEWALS}) reached` 
            };
        }
        
        if (hasReservation) {
            return { 
                canRenew: false, 
                reason: 'Book has pending reservation' 
            };
        }
        
        if (this.status !== LoanStatus.ACTIVE && 
            this.status !== LoanStatus.OVERDUE) {
            return { 
                canRenew: false, 
                reason: 'Loan is no longer active' 
            };
        }
        
        return { canRenew: true };
    }
 
    // ============ Fine Calculation ============
 
    /**
     * Calculates fine based on overdue days and member rate
     */
    private calculateFine(): number {
        const days = this.getOverdueDays();
        const dailyRate = this.member.getDailyFineRate();
        const fine = days * dailyRate;
        
        // Optional: Cap fine at maximum
        const MAX_FINE_PER_ITEM = 25.00;
        return Math.min(fine, MAX_FINE_PER_ITEM);
    }
 
    // ============ Private Helpers ============
 
    private calculateDueDate(): Date {
        const due = new Date();
        due.setDate(due.getDate() + this.member.getLoanPeriodDays());
        return due;
    }
 
    private calculateDueDateFromNow(): Date {
        const due = new Date();
        due.setDate(due.getDate() + this.member.getLoanPeriodDays());
        return due;
    }
 
    private validateRenewal(hasReservation: boolean): void {
        const eligibility = this.canRenew(hasReservation);
        if (!eligibility.canRenew) {
            throw new Error(`Cannot renew: ${eligibility.reason}`);
        }
    }
 
    // ============ Getters ============
 
    getId(): string { return this.id; }
    getMember(): Member { return this.member; }
    getBookCopy(): BookCopy { return this.bookCopy; }
    getCheckoutDate(): Date { return new Date(this.checkoutDate); }
    getDueDate(): Date { return new Date(this.dueDate); }
    getReturnDate(): Date | null { 
        return this.returnDate ? new Date(this.returnDate) : null; 
    }
    getStatus(): LoanStatus { return this.status; }
    getRenewalCount(): number { return this.renewalCount; }
    getFineAmount(): number { return this.fineAmount; }
    getProcessedBy(): Librarian { return this.processedBy; }
}
 
interface FineResult {
    wasOverdue: boolean;
    fineAmount: number;
    daysOverdue: number;
}
 
interface RenewalEligibility {
    canRenew: boolean;
    reason?: string;
}

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

/**
 * Permission levels for librarians
 */
enum LibrarianRole {
    ASSISTANT = 'ASSISTANT',   // Basic checkout/return
    LIBRARIAN = 'LIBRARIAN',   // + catalog management, fine waiving
    SENIOR = 'SENIOR',         // + member management, reports
    ADMIN = 'ADMIN'            // Full access
}
 
/**
 * Represents a library staff member with system privileges.
 */
class Librarian {
    private readonly id: string;
    private readonly employeeId: string;
    private name: string;
    private email: string;
    private role: LibrarianRole;
    private isActive: boolean;
    private readonly hireDate: Date;
 
    constructor(
        id: string,
        employeeId: string,
        name: string,
        email: string,
        role: LibrarianRole = LibrarianRole.ASSISTANT
    ) {
        this.id = id;
        this.employeeId = employeeId;
        this.name = name;
        this.email = email;
        this.role = role;
        this.isActive = true;
        this.hireDate = new Date();
    }
 
    // ============ Permission Checks ============
 
    /**
     * Checks if librarian can perform checkout/return
     */
    canProcessLoans(): boolean {
        return this.isActive; // All roles can process loans
    }
 
    /**
     * Checks if librarian can modify catalog
     */
    canManageCatalog(): boolean {
        return this.isActive && 
               (this.role === LibrarianRole.LIBRARIAN ||
                this.role === LibrarianRole.SENIOR ||
                this.role === LibrarianRole.ADMIN);
    }
 
    /**
     * Checks if librarian can waive fines
     */
    canWaiveFines(): boolean {
        return this.isActive && 
               (this.role === LibrarianRole.LIBRARIAN ||
                this.role === LibrarianRole.SENIOR ||
                this.role === LibrarianRole.ADMIN);
    }
 
    /**
     * Checks if librarian can manage member accounts
     */
    canManageMembers(): boolean {
        return this.isActive && 
               (this.role === LibrarianRole.SENIOR ||
                this.role === LibrarianRole.ADMIN);
    }
 
    /**
     * Checks if librarian can access reports
     */
    canAccessReports(): boolean {
        return this.isActive && 
               (this.role === LibrarianRole.SENIOR ||
                this.role === LibrarianRole.ADMIN);
    }
 
    /**
     * Checks if librarian can manage other librarians
     */
    canManageStaff(): boolean {
        return this.isActive && this.role === LibrarianRole.ADMIN;
    }
 
    // ============ Account Management ============
 
    promote(newRole: LibrarianRole): void {
        this.role = newRole;
    }
 
    deactivate(): void {
        this.isActive = false;
    }
 
    reactivate(): void {
        this.isActive = true;
    }
 
    // ============ Getters ============
 
    getId(): string { return this.id; }
    getEmployeeId(): string { return this.employeeId; }
    getName(): string { return this.name; }
    getEmail(): string { return this.email; }
    getRole(): LibrarianRole { return this.role; }
    getIsActive(): boolean { return this.isActive; }
}

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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

/**
 * Reservation status lifecycle
 */
enum ReservationStatus {
    PENDING = 'PENDING',       // Waiting for book to become available
    READY = 'READY',           // Book available, waiting for pickup
    FULFILLED = 'FULFILLED',   // Member collected the book
    CANCELLED = 'CANCELLED',   // Cancelled by member or system
    EXPIRED = 'EXPIRED'        // Not collected within hold period
}
 
/**
 * Represents a member's request for a currently unavailable book.
 * Implements a queue system for fair distribution.
 */
class Reservation {
    private readonly id: string;
    private readonly member: Member;
    private readonly book: Book;  // Reservation is for a title, not specific copy
    private status: ReservationStatus;
    private readonly createdAt: Date;
    private notifiedAt: Date | null;
    private expiresAt: Date | null;
    private fulfilledByLoan: Loan | null;
 
    private static readonly HOLD_PERIOD_DAYS = 7;
 
    constructor(id: string, member: Member, book: Book) {
        this.id = id;
        this.member = member;
        this.book = book;
        this.status = ReservationStatus.PENDING;
        this.createdAt = new Date();
        this.notifiedAt = null;
        this.expiresAt = null;
        this.fulfilledByLoan = null;
    }
 
    /**
     * Marks reservation as ready (book returned)
     * Starts the hold period countdown
     */
    markReady(): void {
        if (this.status !== ReservationStatus.PENDING) {
            throw new Error('Can only mark pending reservations as ready');
        }
        this.status = ReservationStatus.READY;
        this.notifiedAt = new Date();
        this.expiresAt = new Date();
        this.expiresAt.setDate(
            this.expiresAt.getDate() + Reservation.HOLD_PERIOD_DAYS
        );
    }
 
    /**
     * Fulfills reservation when member borrows the book
     */
    fulfill(loan: Loan): void {
        if (this.status !== ReservationStatus.READY) {
            throw new Error('Can only fulfill ready reservations');
        }
        this.status = ReservationStatus.FULFILLED;
        this.fulfilledByLoan = loan;
        this.member.removeReservation(this);
    }
 
    /**
     * Cancels reservation (member request or system cleanup)
     */
    cancel(): void {
        if (this.status === ReservationStatus.FULFILLED) {
            throw new Error('Cannot cancel fulfilled reservation');
        }
        this.status = ReservationStatus.CANCELLED;
        this.member.removeReservation(this);
    }
 
    /**
     * Expires reservation if not collected in time
     */
    expire(): void {
        if (this.status !== ReservationStatus.READY) {
            throw new Error('Can only expire ready reservations');
        }
        this.status = ReservationStatus.EXPIRED;
        this.member.removeReservation(this);
    }
 
    /**
     * Checks if reservation has expired
     */
    isExpired(): boolean {
        if (this.status !== ReservationStatus.READY || !this.expiresAt) {
            return false;
        }
        return new Date() > this.expiresAt;
    }
 
    // Getters
    getId(): string { return this.id; }
    getMember(): Member { return this.member; }
    getBook(): Book { return this.book; }
    getStatus(): ReservationStatus { return this.status; }
    getCreatedAt(): Date { return new Date(this.createdAt); }
    getExpiresAt(): Date | null { 
        return this.expiresAt ? new Date(this.expiresAt) : null; 
    }
}
 
/**
 * Represents a book author.
 * Shared across multiple books.
 */
class Author {
    private readonly id: string;
    private name: string;
    private biography: string;
 
    constructor(id: string, name: string) {
        this.id = id;
        this.name = name;
        this.biography = "";
    }
 
    updateBiography(bio: string): void {
        this.biography = bio;
    }
 
    getId(): string { return this.id; }
    getName(): string { return this.name; }
    getBiography(): string { return this.biography; }
}
 
/**
 * Value Object: Address
 * No independent identity - defined entirely by its attributes.
 */
class Address {
    private readonly street: string;
    private readonly city: string;
    private readonly state: string;
    private readonly zipCode: string;
 
    constructor(
        street: string, 
        city: string, 
        state: string, 
        zipCode: string
    ) {
        this.street = street;
        this.city = city;
        this.state = state;
        this.zipCode = zipCode;
    }
 
    // Value objects are typically immutable
    // No setters - create new instance for changes
 
    getFullAddress(): string {
        return `${this.street}, ${this.city}, ${this.state} ${this.zipCode}`;
    }
 
    equals(other: Address): boolean {
        return this.street === other.street &&
               this.city === other.city &&
               this.state === other.state &&
               this.zipCode === other.zipCode;
    }
 
    getStreet(): string { return this.street; }
    getCity(): string { return this.city; }
    getState(): string { return this.state; }
    getZipCode(): string { return this.zipCode; }
}