ISP and Dependency Management

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

// Level 1: Your code
// payment-processor.ts
import { OrderService } from './order-service';
 
class PaymentProcessor {
    constructor(private orderService: OrderService) {}
    
    processPayment(orderId: string): void {
        const order = this.orderService.getOrder(orderId);
        // Process payment...
    }
}
 
// Level 2: OrderService (your direct dependency)
// order-service.ts
import { UserService } from './user-service';
import { InventoryService } from './inventory-service';
import { NotificationService } from './notification-service';
import { AuditLogger } from './audit-logger';
import { PromotionEngine } from './promotion-engine';
 
export class OrderService {
    constructor(
        private userService: UserService,
        private inventoryService: InventoryService,
        private notificationService: NotificationService,
        private auditLogger: AuditLogger,
        private promotionEngine: PromotionEngine
    ) {}
    
    getOrder(orderId: string): Order { /* ... */ }
    createOrder(/* ... */): Order { /* ... */ }
    updateInventory(/* ... */): void { /* ... */ }
    notifyUser(/* ... */): void { /* ... */ }
    calculateDiscounts(/* ... */): Discount[] { /* ... */ }
}
 
// Level 3+: Each of those services has its own dependencies...
// UserService → DatabaseConnection, CacheService, AuthProvider, ...
// InventoryService → WarehouseAPI, SupplierIntegration, ...
// NotificationService → EmailProvider, SMSGateway, PushService, ...
 
// Your PaymentProcessor now transitively depends on:
// - Database drivers
// - Email services
// - SMS gateways
// - Warehouse APIs
// - Third-party auth providers
// - And dozens more...

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

// BAD: Fat interface forces all clients to depend on ALL types
interface IOrderManagement {
    // Order queries - depends on: Order, OrderFilter, PagedResult
    getOrder(id: string): Order;
    queryOrders(filter: OrderFilter): PagedResult<Order>;
    
    // Order mutations - depends on: CreateOrderRequest, UpdateOrderRequest
    createOrder(request: CreateOrderRequest): Order;
    updateOrder(id: string, request: UpdateOrderRequest): Order;
    
    // Inventory operations - depends on: InventoryItem, WarehouseLocation
    checkInventory(productId: string): InventoryItem;
    reserveInventory(orderId: string, location: WarehouseLocation): void;
    
    // Shipping - depends on: ShippingCarrier, TrackingInfo, Address
    calculateShipping(carrier: ShippingCarrier, address: Address): Money;
    getTracking(orderId: string): TrackingInfo;
    
    // Billing - depends on: PaymentMethod, Invoice, TaxCalculation
    processPayment(orderId: string, payment: PaymentMethod): Invoice;
    calculateTax(order: Order): TaxCalculation;
    
    // Notifications - depends on: NotificationChannel, NotificationTemplate
    sendConfirmation(orderId: string, channel: NotificationChannel): void;
    sendShippingUpdate(orderId: string, template: NotificationTemplate): void;
}
 
// A simple order display component only needs getOrder()
// But it now transitively depends on:
// - WarehouseLocation (from inventory)
// - ShippingCarrier (from shipping)  
// - PaymentMethod (from billing)
// - NotificationChannel (from notifications)
// - Plus everything THOSE types depend on
 
class OrderDisplayComponent {
    // We only call ONE method
    constructor(private orderManagement: IOrderManagement) {}
    
    showOrder(id: string): void {
        const order = this.orderManagement.getOrder(id);
        this.render(order);
    }
}
 
// If ShippingCarrier changes, OrderDisplayComponent must recompile
// even though it has absolutely nothing to do with shipping!

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

// VECTOR 1: Type Signature Dependencies
// Every type in the interface creates a hard compile-time dependency
 
interface IDocumentManager {
    // Anyone depending on IDocumentManager must know what these types are:
    createDocument(content: DocumentContent): Document;
    //             ↑ depends on DocumentContent  ↑ depends on Document
    
    convertToPdf(doc: Document): PdfDocument;
    //                           ↑ depends on PdfDocument
    
    signDocument(doc: Document, cert: SigningCertificate): SignedDocument;
    //                               ↑ depends on SigningCertificate
    //                                                    ↑ depends on SignedDocument
    
    archiveDocument(doc: Document, policy: ArchivalPolicy): ArchiveReceipt;
    //                                   ↑ depends on ArchivalPolicy
    //                                                      ↑ depends on ArchiveReceipt
}
 
// Even if a client only reads documents, they depend on:
// - SigningCertificate (cryptography libraries)
// - ArchivalPolicy (compliance frameworks)
// - PdfDocument (PDF processing libraries)
 
 
// VECTOR 2: Implementation Requirements
// The implementation must satisfy ALL methods, pulling in ALL dependencies
 
class DocumentManagerImpl implements IDocumentManager {
    constructor(
        private storage: StorageService,      // For createDocument
        private pdfConverter: PdfConverter,    // For convertToPdf
        private cryptoService: CryptoService,  // For signDocument
        private archiveClient: ArchiveClient,  // For archiveDocument
    ) {}
    
    // Even if no client ever calls signDocument(),
    // this class must still inject CryptoService!
    // That means the entire dependency tree of CryptoService
    // is pulled into this implementation.
}
 
 
// VECTOR 3: Behavioral Contract Dependencies
// Understanding how methods interact creates implicit dependencies
 
interface IInventoryManager {
    getStock(productId: string): StockLevel;
    reserveStock(productId: string, quantity: number): Reservation;
    releaseReservation(reservationId: string): void;
    adjustStock(productId: string, delta: number): StockLevel;
}
 
// A client calling getStock() must understand:
// - How reserveStock() affects reported stock levels
// - Whether adjustStock() can make stock negative
// - How long reservations last before auto-release
// 
// These behavioral dependencies aren't in the types, but they're real.

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

// Tools and techniques for measuring dependency reduction
 
// 1. Calculate direct type dependencies per interface
function calculateTypeFanOut(interfaceDeclaration: InterfaceNode): number {
    const types = new Set<string>();
    
    for (const method of interfaceDeclaration.methods) {
        // Count parameter types
        for (const param of method.parameters) {
            types.add(param.type.name);
        }
        // Count return type
        types.add(method.returnType.name);
    }
    
    return types.size;
}
 
// Before ISP: IOrderManagement has 12 unique types
// After ISP:  IOrderQueries has 3, IOrderShipping has 4, etc.
 
 
// 2. Measure transitive closure growth
interface DependencyMetrics {
    module: string;
    directDependencies: number;
    transitiveDependencies: number;
    closureRatio: number;  // transitive / direct
}
 
function analyzeModule(module: Module): DependencyMetrics {
    const directDeps = module.imports.length;
    const transitiveDeps = computeTransitiveClosure(module).size;
    
    return {
        module: module.name,
        directDependencies: directDeps,
        transitiveDependencies: transitiveDeps,
        closureRatio: transitiveDeps / directDeps
    };
}
 
// BEFORE ISP:
// PaymentProcessor: { direct: 1, transitive: 147, ratio: 147 }
// 
// AFTER ISP:
// PaymentProcessor: { direct: 1, transitive: 12, ratio: 12 }
 
 
// 3. Track recompilation impact
interface ChangeImpact {
    changedModule: string;
    affectedModules: string[];
    recompilationCount: number;
    percentageOfCodebase: number;
}
 
function assessChangeImpact(changedModule: Module): ChangeImpact {
    const affected = findAllDependents(changedModule);
    return {
        changedModule: changedModule.name,
        affectedModules: affected.map(m => m.name),
        recompilationCount: affected.length,
        percentageOfCodebase: (affected.length / totalModules) * 100
    };
}
 
// Tracking over time:
// Week 1: Average impact = 340 modules (34% of codebase)
// Week 4: Average impact = 89 modules (8.9% of codebase)
// Week 8: Average impact = 23 modules (2.3% of codebase)

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

// STRATEGY 1: Interface Extraction
// Start with fat interface, extract based on usage analysis
 
// Original fat interface
interface IUserService {
    getUser(id: string): User;
    updateUser(id: string, data: UpdateUserRequest): User;
    deleteUser(id: string): void;
    authenticateUser(credentials: Credentials): AuthToken;
    resetPassword(userId: string, request: PasswordResetRequest): void;
    getUserPermissions(userId: string): Permission[];
    generateReport(params: UserReportParams): UserReport;
}
 
// Step 1: Analyze client usage
// - ProfileView only calls getUser()
// - AuthController calls authenticateUser(), resetPassword()
// - AdminDashboard calls all methods
 
// Step 2: Extract client-specific interfaces
interface IUserReader {
    getUser(id: string): User;
}
 
interface IUserAuthenticator {
    authenticateUser(credentials: Credentials): AuthToken;
    resetPassword(userId: string, request: PasswordResetRequest): void;
}
 
interface IUserAdmin extends IUserReader, IUserAuthenticator {
    updateUser(id: string, data: UpdateUserRequest): User;
    deleteUser(id: string): void;
    getUserPermissions(userId: string): Permission[];
    generateReport(params: UserReportParams): UserReport;
}
 
// STRATEGY 3: Type Narrowing
// Reduce exposed types by returning minimal projections
 
// Before: Returns full Order with all dependencies
interface IOrderQueries {
    getOrder(id: string): Order;  // Order has 50+ fields including nested objects
}
 
// After: Returns only what's needed
interface IOrderSummaryQueries {
    getOrderSummary(id: string): OrderSummary;
}
 
interface OrderSummary {
    id: string;
    status: OrderStatus;
    totalAmount: Money;
    createdAt: Date;
    // Only 4 fields instead of 50
    // No nested objects that pull in more dependencies
}
 
 
// STRATEGY 4: Adapter Interfaces
// Create a minimal surface for external consumers
 
// Internal rich type (many dependencies)
interface InternalOrder {
    id: string;
    customer: Customer;          // Pulls in Customer dependencies
    items: OrderItem[];          // Pulls in Product dependencies
    shipping: ShippingDetails;   // Pulls in Address, Carrier dependencies
    payment: PaymentInfo;        // Pulls in PaymentMethod dependencies
    // ... more fields
}
 
// Adapter interface for external consumers
interface IExternalOrderAdapter {
    getOrderForDisplay(id: string): OrderDisplayDTO;
}
 
interface OrderDisplayDTO {
    id: string;
    customerName: string;        // String, not Customer object
    itemCount: number;           // Number, not OrderItem[]
    formattedTotal: string;      // String, not Money object
    statusLabel: string;         // String, not enum
}
 
// External consumers depend only on strings and primitives
// Zero transitive dependencies from domain model!

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

// THE PROBLEM: Payment service interface before ISP
// 34 methods, 47 types, every consumer gets everything
 
interface IPaymentService {
    // Card processing (depends on: Card, CardToken, CardNetwork, ...)
    tokenizeCard(card: CardDetails): CardToken;
    chargeCard(token: CardToken, amount: Money): ChargeResult;
    voidCharge(chargeId: string): VoidResult;
    captureCharge(chargeId: string, amount?: Money): CaptureResult;
    refundCharge(chargeId: string, amount?: Money): RefundResult;
    
    // Bank transfers (depends on: BankAccount, RoutingNumber, ACHDetails, ...)
    initiateACHTransfer(source: BankAccount, dest: BankAccount, amount: Money): ACHTransfer;
    getACHStatus(transferId: string): ACHStatus;
    
    // Digital wallets (depends on: WalletProvider, WalletToken, ApplePaySession, ...)
    createWalletSession(provider: WalletProvider): WalletSession;
    chargeWallet(session: WalletSession, amount: Money): ChargeResult;
    
    // Subscriptions (depends on: Subscription, BillingPlan, SubscriptionEvent, ...)
    createSubscription(customer: Customer, plan: BillingPlan): Subscription;
    updateSubscription(subId: string, plan: BillingPlan): Subscription;
    cancelSubscription(subId: string): CancelResult;
    
    // Invoicing (depends on: Invoice, LineItem, TaxCalculation, ...)
    createInvoice(customer: Customer, items: LineItem[]): Invoice;
    sendInvoice(invoiceId: string): SendResult;
    recordPayment(invoiceId: string, payment: PaymentRecord): Invoice;
    
    // Payouts (depends on: Payout, PayoutMethod, PayoutSchedule, ...)
    createPayout(recipient: Recipient, method: PayoutMethod): Payout;
    schedulePayout(payout: Payout, schedule: PayoutSchedule): ScheduledPayout;
    
    // Fraud (depends on: FraudSignal, RiskScore, FraudRule, ...)
    assessFraudRisk(transaction: Transaction): RiskAssessment;
    reportFraud(transactionId: string, signal: FraudSignal): FraudReport;
    
    // Reporting (depends on: Report, ReportParams, DateRange, ...)
    generateTransactionReport(params: ReportParams): Report;
    getPaymentAnalytics(dateRange: DateRange): Analytics;
    
    // ... 16 more methods
}
 
// IMPACT: A simple checkout service that only needs chargeCard()
// must import and potentially instantiate mocks for:
// - BankAccount, ACHTransfer, ACHStatus
// - WalletProvider, WalletSession
// - Subscription, BillingPlan
// - Invoice, LineItem, TaxCalculation
// - Payout, PayoutMethod, PayoutSchedule
// - FraudSignal, RiskScore
// - Report, Analytics
// ...and dozens more
 
// Compilation: 18 minutes (any payment change)
// Test setup: 4,000 lines of mock configuration
// Deployment: All 23 services must deploy together

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

// THE SOLUTION: Segregated payment interfaces
// Each consumer only gets what they need
 
// Core card processing - most common use case
interface ICardProcessor {
    tokenizeCard(card: CardDetails): CardToken;
    chargeCard(token: CardToken, amount: Money): ChargeResult;
    voidCharge(chargeId: string): VoidResult;
    captureCharge(chargeId: string, amount?: Money): CaptureResult;
    refundCharge(chargeId: string, amount?: Money): RefundResult;
}
// Types: CardDetails, CardToken, Money, ChargeResult, VoidResult, CaptureResult, RefundResult
// Total: 7 types
 
// Bank transfers - isolated from card processing
interface IBankTransferService {
    initiateACHTransfer(source: BankAccount, dest: BankAccount, amount: Money): ACHTransfer;
    getACHStatus(transferId: string): ACHStatus;
}
// Types: BankAccount, Money, ACHTransfer, ACHStatus
// Total: 4 types
 
// Digital wallets - separate authentication flow
interface IWalletService {
    createWalletSession(provider: WalletProvider): WalletSession;
    chargeWallet(session: WalletSession, amount: Money): ChargeResult;
}
// Types: WalletProvider, WalletSession, Money, ChargeResult
// Total: 4 types
 
// Subscription management - different domain
interface ISubscriptionManager {
    createSubscription(customerId: string, planId: string): Subscription;
    updateSubscription(subId: string, planId: string): Subscription;
    cancelSubscription(subId: string): CancelResult;
}
// Types: Subscription, CancelResult
// Total: 2 types (identifiers are strings, not objects!)
 
// Invoicing - B2B focused
interface IInvoicingService {
    createInvoice(customerId: string, items: InvoiceLineItem[]): Invoice;
    sendInvoice(invoiceId: string): SendResult;
    recordPayment(invoiceId: string, payment: PaymentRecord): Invoice;
}
// Types: InvoiceLineItem, Invoice, SendResult, PaymentRecord
// Total: 4 types
 
// Payouts - Marketplace/platform focused
interface IPayoutService {
    createPayout(recipientId: string, method: PayoutMethod): Payout;
    schedulePayout(payoutId: string, schedule: PayoutSchedule): ScheduledPayout;
}
// Types: PayoutMethod, Payout, PayoutSchedule, ScheduledPayout
// Total: 4 types
 
// Fraud prevention - Security focused
interface IFraudService {
    assessFraudRisk(transactionId: string): RiskAssessment;
    reportFraud(transactionId: string, signal: FraudSignal): FraudReport;
}
// Types: RiskAssessment, FraudSignal, FraudReport
// Total: 3 types
 
// RESULT: Checkout service with ICardProcessor only
// 
// Types needed: 7 (down from 47)
// Transitive dependencies: 23 (down from 312)
// Compilation time: 47 seconds (down from 18 minutes)
// Test setup: 200 lines (down from 4,000)
// Independent deployments: Yes!