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

// Interface defines the contract - behavior-focused
interface IVehicle {
    readonly licensePlate: string;
    readonly type: VehicleType;
    getCompatibleSpotTypes(): SpotType[];
    getPreferredSpotType(): SpotType;
}
 
// Concrete implementation - data-focused
class Vehicle implements IVehicle {
    readonly licensePlate: string;
    readonly type: VehicleType;
    
    // Type-specific logic encapsulated in a strategy/map
    private static readonly COMPATIBILITY_MAP: Map<VehicleType, SpotType[]> = 
        new Map([
            [VehicleType.MOTORCYCLE, [SpotType.MOTORCYCLE, SpotType.COMPACT, SpotType.LARGE]],
            [VehicleType.CAR, [SpotType.COMPACT, SpotType.LARGE]],
            [VehicleType.BUS, [SpotType.LARGE]],
        ]);
    
    constructor(licensePlate: string, type: VehicleType) {
        this.licensePlate = licensePlate;
        this.type = type;
    }
    
    getCompatibleSpotTypes(): SpotType[] {
        return Vehicle.COMPATIBILITY_MAP.get(this.type) || [];
    }
    
    getPreferredSpotType(): SpotType {
        return this.getCompatibleSpotTypes()[0];
    }
}
 
// If we needed inheritance later for special behavior:
class ElectricVehicle extends Vehicle {
    readonly batteryLevel: number;
    readonly chargingRequired: boolean;
    
    constructor(licensePlate: string, batteryLevel: number) {
        super(licensePlate, VehicleType.CAR); // or ELECTRIC_CAR
        this.batteryLevel = batteryLevel;
        this.chargingRequired = batteryLevel < 20;
    }
    
    // Override to prefer electric spots when available
    getCompatibleSpotTypes(): SpotType[] {
        if (this.chargingRequired) {
            return [SpotType.ELECTRIC, ...super.getCompatibleSpotTypes()];
        }
        return super.getCompatibleSpotTypes();
    }
}

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

// COMPOSITION: ParkingLot owns ParkingSpots
// Spots are created BY the lot, lifetime bound to lot
class ParkingLot {
    // Composition - spots created in constructor, no external injection
    private readonly spots: Map<string, ParkingSpot> = new Map();
    
    constructor(config: ParkingLotConfig) {
        // Spots created as part of lot initialization
        // They cannot exist without this lot instance
        this.initializeSpots(config);
    }
    
    private initializeSpots(config: ParkingLotConfig): void {
        for (let floor = 1; floor <= config.floors; floor++) {
            for (const [type, count] of config.spotsPerFloor) {
                for (let i = 1; i <= count; i++) {
                    // Spot lifecycle tied to this lot
                    const spot = new ParkingSpot(floor, 1, i, type);
                    this.spots.set(spot.id, spot);
                }
            }
        }
    }
    
    // When ParkingLot is garbage collected, spots go with it
    // No need for explicit cleanup
}
 
// AGGREGATION: ParkingSpot holds Vehicle temporarily
// Vehicle exists independently of spot
class ParkingSpot {
    // Aggregation - vehicle passed in, exists independently
    private parkedVehicle: IVehicle | null = null;
    
    // Vehicle is passed in - we don't create it
    park(vehicle: IVehicle): void {
        this.parkedVehicle = vehicle;
        // Vehicle continues to exist in the outside world
    }
    
    // Vehicle is returned - it continues to exist after
    vacate(): IVehicle | null {
        const vehicle = this.parkedVehicle;
        this.parkedVehicle = null;
        return vehicle; // Vehicle still exists after this
    }
}
 
// VALUE COPY: Ticket copies vehicle information
// No ongoing object reference - just data snapshot
class Ticket {
    // These are values, not object references
    readonly vehicleLicensePlate: string;  // Copied
    readonly vehicleType: VehicleType;      // Copied
    
    constructor(vehicle: IVehicle, spot: ParkingSpot) {
        // Copy relevant data at construction time
        this.vehicleLicensePlate = vehicle.licensePlate;
        this.vehicleType = vehicle.type;
        
        // We don't store: private vehicle: IVehicle
        // Because we don't need ongoing access to the Vehicle object
        // And doing so would create unnecessary coupling
    }
}

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

// Strategy interfaces define contracts
interface IPricingStrategy {
    calculateFee(ticket: Ticket): Money;
}
 
interface IAllocationStrategy {
    findSpot(
        vehicle: IVehicle, 
        spotsByType: Map<SpotType, IParkingSpot[]>
    ): IParkingSpot | null;
}
 
// ParkingLot accepts strategies via constructor (Dependency Injection)
class ParkingLot {
    private readonly pricingStrategy: IPricingStrategy;
    private readonly allocationStrategy: IAllocationStrategy;
    
    constructor(
        config: ParkingLotConfig,
        pricingStrategy: IPricingStrategy,      // Injected
        allocationStrategy: IAllocationStrategy  // Injected
    ) {
        this.pricingStrategy = pricingStrategy;
        this.allocationStrategy = allocationStrategy;
        // ... initialization
    }
    
    // ParkingLot delegates to strategies, doesn't implement logic
    parkVehicle(vehicle: IVehicle): Ticket {
        // Delegate spot finding to strategy
        const spot = this.allocationStrategy.findSpot(
            vehicle, 
            this.spotsByType
        );
        // ...
    }
    
    exitVehicle(ticket: Ticket): Money {
        // Delegate fee calculation to strategy
        return this.pricingStrategy.calculateFee(ticket);
    }
}
 
// Usage with dependency injection
const lot = new ParkingLot(
    config,
    new HourlyPricingStrategy(rates),        // Concrete strategy
    new FirstAvailableAllocationStrategy()  // Concrete strategy
);
 
// Testing with mock strategies
const mockPricing: IPricingStrategy = {
    calculateFee: (_ticket) => new Money(10) // Always $10 for testing
};
 
const testLot = new ParkingLot(
    testConfig,
    mockPricing,                              // Mock for testing
    new FirstAvailableAllocationStrategy()
);

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

// ParkingLot as Aggregate Root
// All access to spots goes through the lot
 
class ParkingLot {
    // Private - spots not directly accessible from outside
    private readonly spots: Map<string, ParkingSpot> = new Map();
    
    // ✓ External code uses these methods
    parkVehicle(vehicle: IVehicle): Ticket { /* ... */ }
    exitVehicle(ticket: Ticket): Money { /* ... */ }
    getAvailableSpotsByType(type: SpotType): number { /* ... */ }
    
    // ✓ Read-only spot information is OK
    getSpotInfo(spotId: string): SpotInfo | null {
        const spot = this.spots.get(spotId);
        if (!spot) return null;
        
        // Return a read-only view, not the actual spot
        return {
            id: spot.id,
            type: spot.type,
            floor: spot.floor,
            isAvailable: spot.isAvailable(),
        };
    }
    
    // ✗ NEVER expose the actual spot objects
    // getSpot(spotId: string): ParkingSpot { ... }  // BAD!
    // getAllSpots(): ParkingSpot[] { ... }          // BAD!
}
 
// Read-only DTO for spot information
interface SpotInfo {
    readonly id: string;
    readonly type: SpotType;
    readonly floor: number;
    readonly isAvailable: boolean;
}
 
// Why this matters:
// 
// BAD: Direct access breaks encapsulation
// const spot = lot.getSpot('F1-R1-S5');
// spot.park(vehicle);  // Bypasses lot's availability tracking!
// 
// GOOD: All modifications through aggregate root
// const ticket = lot.parkVehicle(vehicle);
// // Lot maintains invariants, updates counters, creates ticket

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

// Segregated interfaces for different clients
 
// For entry gate systems
interface IEntryGate {
    hasAvailableSpot(vehicleType: VehicleType): boolean;
    parkVehicle(vehicle: IVehicle): Ticket;
}
 
// For exit gate systems  
interface IExitGate {
    exitVehicle(ticket: Ticket): Money;
    validateTicket(ticketId: string): boolean;
}
 
// For display systems
interface IDisplayBoard {
    getAvailableSpotsByType(): Map<SpotType, number>;
    getTotalCapacity(): number;
    getCurrentOccupancy(): number;
    isFull(): boolean;
}
 
// For admin systems (extends others)
interface IAdminPanel extends IEntryGate, IExitGate, IDisplayBoard {
    getActiveTickets(): Ticket[];
    getRevenueForPeriod(start: Date, end: Date): Money;
    reconfigurePricing(strategy: IPricingStrategy): void;
}
 
// ParkingLot implements all interfaces
class ParkingLot implements IEntryGate, IExitGate, IDisplayBoard {
    // ... implementation
    
    hasAvailableSpot(vehicleType: VehicleType): boolean { /* ... */ }
    parkVehicle(vehicle: IVehicle): Ticket { /* ... */ }
    exitVehicle(ticket: Ticket): Money { /* ... */ }
    validateTicket(ticketId: string): boolean { /* ... */ }
    getAvailableSpotsByType(): Map<SpotType, number> { /* ... */ }
    // ... etc
}
 
// Usage: Each system receives only the interface it needs
class EntryGateController {
    private readonly lot: IEntryGate;  // Only entry operations exposed
    
    constructor(lot: IEntryGate) {
        this.lot = lot;
    }
    
    handleVehicleEntry(vehicle: IVehicle): EntryResult {
        if (!this.lot.hasAvailableSpot(vehicle.type)) {
            return { success: false, message: 'Lot is full' };
        }
        const ticket = this.lot.parkVehicle(vehicle);
        return { success: true, ticket };
    }
}
 
class DisplayController {
    private readonly board: IDisplayBoard;  // Only display operations
    
    constructor(board: IDisplayBoard) {
        this.board = board;
    }
    
    updateDisplays(): void {
        const available = this.board.getAvailableSpotsByType();
        const isFull = this.board.isFull();
        // ... update physical displays
    }
}

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

// ❌ BIDIRECTIONAL (Problematic)
class ParkingSpotBad {
    private lot: ParkingLot;  // Back-reference to parent
    
    constructor(lot: ParkingLot) {
        this.lot = lot;
        lot.addSpot(this);  // Must update both sides
    }
    
    // If we need lot info, we access via this.lot
    notifyLotOfChange(): void {
        this.lot.handleSpotChange(this);
    }
}
 
class ParkingLotBad {
    private spots: ParkingSpot[] = [];
    
    addSpot(spot: ParkingSpot): void {
        this.spots.push(spot);
        // Careful: spot already has reference to us
        // Don't create circular setup!
    }
}
 
 
// ✓ UNIDIRECTIONAL (Preferred)
class ParkingSpotGood {
    readonly id: string;
    readonly lotId: string;  // Store ID, not object reference
    
    constructor(id: string, lotId: string) {
        this.id = id;
        this.lotId = lotId;  // Just an identifier
    }
    
    // If we truly need lot, look it up through a service
    // But usually, we don't need it at all!
}
 
class ParkingLotGood {
    private spots: Map<string, ParkingSpotGood> = new Map();
    
    addSpot(spot: ParkingSpotGood): void {
        this.spots.set(spot.id, spot);
        // No circular reference!
    }
    
    // Spot changes are handled by the lot (aggregate root pattern)
    handleParkingAt(spotId: string, vehicle: IVehicle): void {
        const spot = this.spots.get(spotId);
        if (spot) {
            spot.park(vehicle);
            this.updateCounters();
            this.emitEvent('parked', { spotId, vehicle });
        }
    }
}
 
// When spot truly needs lot context, use callback/event patterns
interface SpotEventHandler {
    onSpotOccupied(spotId: string): void;
    onSpotVacated(spotId: string): void;
}
 
class SmartParkingSpot {
    private eventHandler?: SpotEventHandler;
    
    setEventHandler(handler: SpotEventHandler): void {
        this.eventHandler = handler;
    }
    
    park(vehicle: IVehicle): void {
        // ... parking logic
        this.eventHandler?.onSpotOccupied(this.id);
    }
}