Invariants in Inheritance

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class EmailAddress {
    private address: string;
    
    // INVARIANT: address matches email format
    
    constructor(address: string) {
        // VIOLATION: No validation!
        this.address = address;  // Could be "not-an-email"
    }
}
 
// Object created in invalid state
const invalid = new EmailAddress("this is not an email");
// invalid exists, but violates its own invariant
 
// Later, code trusts the invariant
function sendEmail(to: EmailAddress): void {
    // Assumes address is valid for email protocol
    // Fails mysteriously due to invalid format
}

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

class CircularBuffer<T> {
    private items: (T | undefined)[];
    private head: number = 0;
    private tail: number = 0;
    private count: number = 0;
    
    // INVARIANT: 0 <= count <= items.length
    // INVARIANT: head and tail are valid indices
    // INVARIANT: count accurately reflects number of items
    
    constructor(capacity: number) {
        this.items = new Array(capacity);
    }
    
    push(item: T): void {
        // VIOLATION: No bounds check for count
        this.items[this.tail] = item;
        this.tail = (this.tail + 1) % this.items.length;
        this.count++;  // Can exceed capacity if push called too many times!
    }
    
    pop(): T | undefined {
        if (this.count === 0) return undefined;
        
        const item = this.items[this.head];
        this.head = (this.head + 1) % this.items.length;
        this.count--;
        return item;
    }
}
 
const buffer = new CircularBuffer<number>(3);
buffer.push(1); buffer.push(2); buffer.push(3);  // At capacity
buffer.push(4);  // VIOLATION: count is now 4, but capacity is 3
 
// Invariant broken: count (4) > items.length (3)
// All subsequent operations produce wrong results

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

abstract class Animal {
    protected name: string;
    protected age: number;
    
    // INVARIANT: name is non-empty
    // INVARIANT: age >= 0
    
    constructor(name: string, age: number) {
        if (!name || name.trim().length === 0) {
            throw new Error("Name cannot be empty");
        }
        if (age < 0) {
            throw new Error("Age cannot be negative");
        }
        this.name = name;
        this.age = age;
    }
    
    abstract makeSound(): string;
}
 
class Dog extends Animal {
    private breed: string;
    
    constructor(name: string, age: number, breed: string) {
        super(name, age);
        this.breed = breed;
    }
    
    makeSound(): string {
        return "Woof!";
    }
}
 
// VIOLATION: Subclass with weaker construction
class StrayDog extends Animal {
    constructor() {
        // VIOLATION: Bypasses parent validation
        super("temp", 0);  // Satisfy parent
        this.name = "";    // Then break invariant
        this.age = -1;     // And this one too
    }
    
    makeSound(): string {
        return "...";
    }
}
 
// Client code trusts Animal invariants
function createPetProfile(pet: Animal): string {
    // Trusts that name is non-empty and age is non-negative
    return `${pet.name}, ${pet.age} years old`;  // Returns ", -1 years old"
}

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

class SortedArray {
    private items: number[];
    
    // INVARIANT: items is sorted in ascending order
    
    constructor(initial: number[] = []) {
        this.items = [...initial].sort((a, b) => a - b);
    }
    
    add(item: number): void {
        // Binary search insert to maintain sort
        const index = this.findInsertionPoint(item);
        this.items.splice(index, 0, item);
    }
    
    // DANGER: Returns reference to internal array!
    getItems(): number[] {
        return this.items;  // Should return copy!
    }
    
    private findInsertionPoint(item: number): number {
        let left = 0, right = this.items.length;
        while (left < right) {
            const mid = Math.floor((left + right) / 2);
            if (this.items[mid] < item) left = mid + 1;
            else right = mid;
        }
        return left;
    }
    
    binarySearch(item: number): number {
        // Relies on sort invariant for correctness!
        let left = 0, right = this.items.length - 1;
        while (left <= right) {
            const mid = Math.floor((left + right) / 2);
            if (this.items[mid] === item) return mid;
            if (this.items[mid] < item) left = mid + 1;
            else right = mid - 1;
        }
        return -1;
    }
}
 
const sorted = new SortedArray([1, 3, 5, 7, 9]);
 
// External code breaks invariant through leaked reference
const internal = sorted.getItems();
internal[2] = 100;  // Now array is [1, 3, 100, 7, 9] - NOT SORTED!
 
// Binary search now returns wrong results
sorted.binarySearch(7);  // Returns -1 (not found) even though 7 is present!

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

// LAYER 1: Repository with invariant-violating subclass
class UserRepository {
    async findById(id: string): Promise<User> {
        // Returns User with invariant: email is valid
        const data = await this.db.query(`SELECT * FROM users WHERE id = ?`, [id]);
        return new User(data.name, data.email);
    }
}
 
class CachedUserRepository extends UserRepository {
    private cache: Map<string, User> = new Map();
    
    async findById(id: string): Promise<User> {
        if (this.cache.has(id)) {
            return this.cache.get(id)!;
        }
        
        // VIOLATION: Caching partially-constructed user for "performance"
        const placeholder = new PartialUser(id); // email is null!
        this.cache.set(id, placeholder);
        
        const fullUser = await super.findById(id);
        this.cache.set(id, fullUser);
        return fullUser;
    }
}
 
// LAYER 2: Service trusts repository's guaranteed invariant
class UserService {
    constructor(private repo: UserRepository) {}
    
    async getEmailDomain(userId: string): Promise<string> {
        const user = await this.repo.findById(userId);
        // Trusts email is valid - crashes on null email
        return user.email.split('@')[1];  // TypeError: Cannot read 'split' of null
    }
}
 
// LAYER 3: Notification trusts user has valid email
class NotificationService {
    async sendWelcome(user: User): Promise<void> {
        // Trusts user.email is a valid address
        await this.mailer.send(user.email, "Welcome!");
        // Fails: invalid email format or null
    }
}
 
// LAYER 4: Reporting trusts email invariant for grouping
class ReportGenerator {
    generateDomainReport(users: User[]): Map<string, number> {
        const domains = new Map<string, number>();
        
        for (const user of users) {
            // Trusts all emails are valid with @ sign
            const domain = user.email.split('@')[1];  // Crashes or produces undefined
            domains.set(domain, (domains.get(domain) ?? 0) + 1);
        }
        
        return domains;  // Contains 'undefined' as a key!
    }
}
 
// LAYER 5: Analytics sees corrupted data
class Analytics {
    processReport(report: Map<string, number>): void {
        // Iterates over domains, assumes all are valid strings
        for (const [domain, count] of report) {
            this.track(domain, count);  // Tracks "undefined" as a domain
        }
        // Data is now permanently corrupted in analytics 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

// SYMPTOM 1: "Impossible" state in logs
// Log entry: "Processing order with total: -$523.47"
// Invariant violated: Order.total >= 0
 
// SYMPTOM 2: Null errors on guaranteed fields
function processPayment(order: Order): void {
    // Order.customer should NEVER be null (invariant)
    const email = order.customer.email;  // TypeError: Cannot read 'email' of null
}
 
// SYMPTOM 3: Type confusion
class Amount {
    // INVARIANT: value is a number
    constructor(public value: number) {}
}
 
// Somewhere, invariant was violated
const corrupted = new Amount("100" as any);  // Actually a string!
 
function sum(a: Amount, b: Amount): Amount {
    return new Amount(a.value + b.value);  // "100" + 50 = "10050" (string concat!)
}
 
// SYMPTOM 4: Intermittent failures
class Config {
    // INVARIANT: all keys have non-empty values
    get(key: string): string {
        return this.values.get(key)!;  // Works 99% of time
        // Fails when FastConfig subclass allows empty values
    }
}
 
// SYMPTOM 5: Subtype-specific failures
function render(shapes: Shape[]): void {
    for (const shape of shapes) {
        shape.draw();  // Works for Circle, Rectangle
        // Crashes for BrokenShape subclass that has null renderer
    }
}
 
// SYMPTOM 6: Degradation over time
class Counter {
    private count: number = 0;
    
    // INVARIANT: count accurately reflects calls
    
    increment(): void {
        this.count++;
    }
    
    // Bug: forgetful decrement
    decrement(): void {
        // Bug: missing check for count > 0
        this.count--;  // Can go negative, violating invariant
    }
    
    // After many operations: count is -47, makes no sense
}

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

class Product {
    private price: number;
    private quantity: number;
    
    // INVARIANT: price >= 0, quantity >= 0
    
    constructor(price: number, quantity: number) {
        this.validateAndSet(price, quantity);
    }
    
    private validateAndSet(price: number, quantity: number): void {
        if (price < 0) throw new Error("Price cannot be negative");
        if (quantity < 0) throw new Error("Quantity cannot be negative");
        this.price = price;
        this.quantity = quantity;
    }
    
    update(price: number, quantity: number): void {
        this.validateAndSet(price, quantity);
    }
}
 
// "Optimized" bulk loader that skips validation
class ProductBulkLoader {
    // Direct database load for "performance"
    loadFromDatabase(rows: any[]): Product[] {
        return rows.map(row => {
            // VIOLATION: Bypasses validation for speed
            const product = Object.create(Product.prototype);
            product.price = row.price;    // Could be -99.99!
            product.quantity = row.qty;   // Could be -50!
            return product;
        });
    }
}
 
// Data corruption propagates through inventory system
const products = loader.loadFromDatabase(rawData);
// Some products have negative prices/quantities
// Inventory calculations go haywire
// Orders get processed with wrong totals

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

class UserSession {
    private userId: string;
    private expiresAt: Date;
    private isRevoked: boolean;
    
    // INVARIANT: if isRevoked === true, session is invalid
    // INVARIANT: expiresAt is in the future when session is valid
    // INVARIANT: userId is never empty
    
    constructor(userId: string, durationMinutes: number) {
        if (!userId) throw new Error("User ID required");
        if (durationMinutes <= 0) throw new Error("Duration must be positive");
        
        this.userId = userId;
        this.expiresAt = new Date(Date.now() + durationMinutes * 60 * 1000);
        this.isRevoked = false;
    }
    
    isValid(): boolean {
        return !this.isRevoked && this.expiresAt > new Date();
    }
}
 
// Deserialization from Redis cache
function loadSessionFromCache(json: string): UserSession {
    // VIOLATION: Parse JSON directly, bypass constructor
    const data = JSON.parse(json);
    
    // Object.assign creates object with wrong prototype or state
    const session = Object.assign(new UserSession("temp", 1), data);
    
    // Problem 1: expiresAt is now a string, not a Date!
    // Problem 2: userId could be empty if data is corrupted
    // Problem 3: Invariants never checked
    
    return session;
}
 
// Later...
const session = loadSessionFromCache(cached);
if (session.isValid()) {
    // expiresAt is a string, comparison "2024-01-01" > Date fails weirdly
    grantAccess(session.userId);
}

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

// UI Component with invariant
class PaymentForm {
    private amount: number = 0;
    private currency: string = "USD";
    private isInitialized: boolean = false;
    
    // INVARIANT: If isInitialized, then amount and currency are set
    
    initialize(amount: number, currency: string): void {
        this.amount = amount;
        this.currency = currency;
        this.isInitialized = true;
    }
    
    submit(): PaymentRequest {
        if (!this.isInitialized) {
            throw new Error("Form not initialized");
        }
        return { amount: this.amount, currency: this.currency };
    }
}
 
// Framework subclass that breaks lifecycle
class ReactivePaymentForm extends PaymentForm {
    // Framework calls this BEFORE initialize()
    render(): string {
        // VIOLATION: Access state before invariant is established
        return `Pay ${this.amount} ${this.currency}`;  // Shows "Pay 0 USD"
    }
    
    // Framework calls this on any state change
    onStateChange(): void {
        // May be called between partial state updates
        // Invariant temporarily violated during updates
        this.autoSubmit();  // Submits with wrong data!
    }
}

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

class BankAccount {
    private balance: number;
    
    // INVARIANT: balance >= 0
    
    constructor(initial: number) {
        if (initial < 0) throw new Error("Negative balance");
        this.balance = initial;
    }
    
    async withdraw(amount: number): Promise<boolean> {
        // Check invariant
        if (this.balance >= amount) {
            // TIME GAP: Another async call could run here!
            await this.log(`Withdrawing ${amount}`);
            
            // By now, another withdrawal might have occurred
            this.balance -= amount;
            // VIOLATION: balance could now be negative!
            
            return true;
        }
        return false;
    }
    
    private async log(message: string): Promise<void> {
        await fetch('/audit', { body: message, method: 'POST' });
    }
}
 
// Two concurrent withdrawals
const account = new BankAccount(100);
 
// Both check passes at balance=100, both proceed
Promise.all([
    account.withdraw(80),  // Checks: 100 >= 80 ✓, then pauses at await
    account.withdraw(60),  // Checks: 100 >= 60 ✓, then pauses at await
]);
 
// After both complete: balance = 100 - 80 - 60 = -40
// Invariant violated!

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

class TransactionLog {
    private entries: LogEntry[] = [];
    private totalCredits: number = 0;
    private totalDebits: number = 0;
    
    // INVARIANT: sum(credits) - sum(debits) === balance
    // INVARIANT: entries are chronologically ordered
    
    private checkInvariant(): void {
        // Sum all entries
        let computedCredits = 0;
        let computedDebits = 0;
        
        for (let i = 0; i < this.entries.length; i++) {
            const entry = this.entries[i];
            
            // Check chronological order
            if (i > 0 && entry.timestamp < this.entries[i-1].timestamp) {
                throw new Error(`Invariant violated: entries out of order at index ${i}`);
            }
            
            if (entry.type === 'credit') computedCredits += entry.amount;
            else computedDebits += entry.amount;
        }
        
        // Check totals match
        if (computedCredits !== this.totalCredits) {
            throw new Error(`Invariant violated: totalCredits mismatch`);
        }
        if (computedDebits !== this.totalDebits) {
            throw new Error(`Invariant violated: totalDebits mismatch`);
        }
    }
    
    addEntry(entry: LogEntry): void {
        // Check invariant BEFORE operation (precondition)
        if (process.env.NODE_ENV === 'development') {
            this.checkInvariant();
        }
        
        // Perform operation
        this.entries.push(entry);
        if (entry.type === 'credit') {
            this.totalCredits += entry.amount;
        } else {
            this.totalDebits += entry.amount;
        }
        
        // Check invariant AFTER operation (postcondition)
        if (process.env.NODE_ENV === 'development') {
            this.checkInvariant();
        }
    }
}

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

// Instead of a number that "should" be positive,
// use a branded type that MUST be positive
 
type PositiveNumber = number & { __brand: 'positive' };
 
function toPositive(n: number): PositiveNumber {
    if (n <= 0) {
        throw new Error("Number must be positive");
    }
    return n as PositiveNumber;
}
 
class SafeAccount {
    private balance: PositiveNumber;
    
    constructor(initial: PositiveNumber) {
        this.balance = initial;  // Type system ensures it's positive
    }
    
    // Can only deposit positive amounts
    deposit(amount: PositiveNumber): void {
        this.balance = toPositive(this.balance + amount);
    }
}
 
// Usage - type system catches violations
const account = new SafeAccount(toPositive(100));
// account.deposit(-50);  // Compile error: number is not PositiveNumber
account.deposit(toPositive(50));  // OK
 
// Pattern: NonEmptyString
type NonEmptyString = string & { __brand: 'nonempty' };
 
function toNonEmpty(s: string): NonEmptyString {
    if (!s || s.trim().length === 0) {
        throw new Error("String must be non-empty");
    }
    return s as NonEmptyString;
}
 
class User {
    constructor(
        public readonly name: NonEmptyString,
        public readonly email: NonEmptyString
    ) {}
}
 
// new User("", "a@b.com");  // Compile error
// new User(toNonEmpty(""), "a@b.com");  // Runtime error at toNonEmpty

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

import * as fc from 'fast-check';
 
// Property: After any sequence of operations, invariants hold
describe('BinarySearchTree invariants', () => {
    it('maintains BST property after any inserts', () => {
        fc.assert(
            fc.property(
                fc.array(fc.integer()),
                (numbers) => {
                    const tree = new BinarySearchTree<number>((a, b) => a - b);
                    
                    for (const n of numbers) {
                        tree.insert(n);
                        
                        // After EVERY insert, verify BST property
                        if (!isBSTPropertySatisfied(tree.root)) {
                            return false;  // Invariant violated!
                        }
                    }
                    
                    return true;
                }
            )
        );
    });
    
    it('maintains size invariant', () => {
        fc.assert(
            fc.property(
                fc.array(fc.integer()),
                (numbers) => {
                    const tree = new BinarySearchTree<number>((a, b) => a - b);
                    const uniqueNumbers = new Set(numbers);
                    
                    for (const n of numbers) {
                        tree.insert(n);
                    }
                    
                    // INVARIANT: size equals number of unique inserted values
                    return tree.size() === uniqueNumbers.size;
                }
            )
        );
    });
});
 
function isBSTPropertySatisfied<T>(
    node: TreeNode<T> | null,
    comparator: (a: T, b: T) => number,
    min?: T,
    max?: T
): boolean {
    if (!node) return true;
    
    if (min !== undefined && comparator(node.value, min) <= 0) return false;
    if (max !== undefined && comparator(node.value, max) >= 0) return false;
    
    return isBSTPropertySatisfied(node.left, comparator, min, node.value) &&
           isBSTPropertySatisfied(node.right, comparator, node.value, max);
}