Defining Relationships in Low-Level Design

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

// Example: Validating relationships for an e-commerce system
// Requirement: "A customer can view their order history"
 
// VALIDATION:
// ✓ Customer → Orders: Need 1:* (Customer has many Orders)
// ✓ Navigability: Customer needs to find their orders? YES
// ✓ Order → Customer: Each order belongs to exactly one customer? YES
 
// Requirement: "An order shows all items with product details"
 
// VALIDATION:
// ✓ Order → OrderItems: Need 1:* (Order has many OrderItems)
// ✓ OrderItem → Product: Need *:1 (Item references Product)
// ✓ Can we traverse Order → OrderItems → Products? YES
 
// Let's verify with code that the model supports the requirements
 
interface OrderHistory {
    customerId: string;
    orders: Array<{
        orderId: string;
        date: Date;
        items: Array<{
            productName: string;
            quantity: number;
            price: number;
        }>;
    }>;
}
 
class CustomerService {
    constructor(private customerRepo: CustomerRepository) {}
    
    // This method VALIDATES that our model supports the requirement
    async getOrderHistory(customerId: string): Promise<OrderHistory> {
        const customer = await this.customerRepo.findById(customerId);
        if (!customer) throw new Error("Customer not found");
        
        // Can we traverse Customer → Orders? ✓
        const orders = customer.getOrders();
        
        return {
            customerId: customer.id,
            orders: orders.map(order => ({
                orderId: order.id,
                date: order.createdAt,
                // Can we traverse Order → OrderItems → Product? ✓
                items: order.getItems().map(item => ({
                    productName: item.getProduct().name,
                    quantity: item.quantity,
                    price: item.unitPrice
                }))
            }))
        };
    }
}

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

// ANTI-PATTERN: Missing Intermediate Entity
// Many-to-many without association class
 
// BAD: Where does enrollment date go?
class Student {
    courses: Course[] = [];
    // enrollmentDates: Map<Course, Date> = ??? // Awkward!
}
 
class Course {
    students: Student[] = [];
}
 
// GOOD: Association class holds relationship data
class Enrollment {
    constructor(
        public readonly student: Student,
        public readonly course: Course,
        public readonly enrolledAt: Date,
        public grade?: string
    ) {}
}
 
class Student {
    enrollments: Enrollment[] = [];
    
    getCourses(): Course[] {
        return this.enrollments.map(e => e.course);
    }
}
 
// -------------------------------------------
 
// ANTI-PATTERN: Implicit Relationships (ID-based only)
 
// BAD: Related by ID but no real relationship
class OrderBad {
    customerId: string; // Just an ID, no real connection
    
    // To get customer, must query separately
    // No compile-time guarantee that customer exists
}
 
// GOOD: Explicit relationship
class OrderGood {
    customer: Customer; // Real reference
    
    constructor(customer: Customer) {
        this.customer = customer;
        // Relationship is explicit and type-safe
    }
}
 
// -------------------------------------------
 
// ANTI-PATTERN: Redundant Relationships
 
// BAD: Multiple paths to same data
class Project {
    team: Team;
    members: Employee[]; // Redundant! Team already has members
    lead: Employee;      // Could be derived from team
}
 
// GOOD: Single source of truth
class Project {
    team: Team;
    
    getMembers(): Employee[] {
        return this.team.getMembers();
    }
    
    getLead(): Employee {
        return this.team.getLead();
    }
}

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

// Enforcing relationship constraints in code
 
class Team {
    private members: Set<Employee> = new Set();
    private lead: Employee | null = null;
    
    addMember(employee: Employee): void {
        this.members.add(employee);
    }
    
    // SUBSET CONSTRAINT: Lead must be a member
    setLead(employee: Employee): void {
        if (!this.members.has(employee)) {
            throw new Error("Lead must be a team member. Add them first.");
        }
        this.lead = employee;
    }
    
    removeMember(employee: Employee): void {
        // CONSTRAINT: Cannot remove lead
        if (this.lead === employee) {
            throw new Error("Cannot remove team lead. Assign new lead first.");
        }
        this.members.delete(employee);
    }
}
 
// EXCLUSION CONSTRAINT: Self-referential validation
class Employee {
    private manager: Employee | null = null;
    
    setManager(manager: Employee): void {
        // Cannot manage yourself
        if (manager === this) {
            throw new Error("An employee cannot be their own manager");
        }
        
        // Prevent circular management chains
        let current: Employee | null = manager;
        while (current !== null) {
            if (current === this) {
                throw new Error("Circular management chain detected");
            }
            current = current.manager;
        }
        
        this.manager = manager;
    }
}
 
// UNIQUENESS CONSTRAINT: No duplicate enrollments
class Course {
    private enrollments: Map<string, Enrollment> = new Map();
    
    enroll(student: Student): Enrollment {
        if (this.enrollments.has(student.id)) {
            throw new Error("Student is already enrolled in this course");
        }
        
        const enrollment = new Enrollment(student, this, new Date());
        this.enrollments.set(student.id, enrollment);
        return enrollment;
    }
}
 
// TEMPORAL CONSTRAINT: Date-based validation
class Project {
    constructor(
        public readonly startDate: Date,
        public readonly endDate: Date
    ) {}
    
    addMember(employee: Employee, joinDate: Date): void {
        if (joinDate > this.endDate) {
            throw new Error("Cannot join a project after its end date");
        }
        if (joinDate < this.startDate) {
            throw new Error("Cannot join a project before its start date");
        }
        // Add member...
    }
}

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

// Testing relationship invariants
 
describe('Department-Employee Relationship', () => {
    // Test cardinality: 1:* (department has 0 or more employees)
    test('department can exist without employees', () => {
        const dept = new Department('D1', 'Engineering');
        expect(dept.getEmployeeCount()).toBe(0);
    });
    
    test('department can have multiple employees', () => {
        const dept = new Department('D1', 'Engineering');
        dept.hire(new Employee('E1', 'Alice'));
        dept.hire(new Employee('E2', 'Bob'));
        expect(dept.getEmployeeCount()).toBe(2);
    });
    
    // Test bidirectional consistency
    test('adding employee updates both sides', () => {
        const dept = new Department('D1', 'Engineering');
        const emp = new Employee('E1', 'Alice');
        
        dept.hire(emp);
        
        expect(dept.getEmployees()).toContain(emp);
        expect(emp.getDepartment()).toBe(dept);
    });
    
    test('transferring employee updates all references', () => {
        const engineering = new Department('D1', 'Engineering');
        const product = new Department('D2', 'Product');
        const emp = new Employee('E1', 'Alice');
        
        engineering.hire(emp);
        emp.transferTo(product);
        
        expect(engineering.getEmployees()).not.toContain(emp);
        expect(product.getEmployees()).toContain(emp);
        expect(emp.getDepartment()).toBe(product);
    });
    
    // Test constraint enforcement
    test('throws when violating constraint', () => {
        const team = new Team('T1', 'Alpha Team');
        const nonMember = new Employee('E1', 'Alice');
        
        expect(() => team.setLead(nonMember))
            .toThrow('Lead must be a team member');
    });
    
    // Test edge cases
    test('removing last item from 1..* relationship throws', () => {
        const order = new Order('O1', initialItem);
        
        expect(() => order.removeItem(initialItem.id))
            .toThrow('Order must have at least one item');
    });
});