TypeScript Protected Fields — Leaked via Subclass Getters

// A real-world bank account — classic OOP demo done properly
class BankAccount {
  // private: only methods inside this class can touch the balance
  private balance: number;

  // public: anyone can read the account holder's name
  public readonly accountHolder: string;

  // protected: subclasses (e.g. SavingsAccount) can access this too
  protected transactionHistory: string[];

  // The shorthand constructor: TypeScript declares AND assigns in one line
  constructor(
    accountHolder: string,
    initialDeposit: number
  ) {
    this.accountHolder = accountHolder;
    // Guard against negative opening balances at construction time
    if (initialDeposit < 0) {
      throw new Error('Initial deposit cannot be negative');
    }
    this.balance = initialDeposit;
    this.transactionHistory = [`Account opened with $${initialDeposit}`];
  }

  // Public method: this is the ONLY way outsiders can change the balance
  public deposit(amount: number): void {
    if (amount <= 0) {
      throw new Error('Deposit amount must be positive');
    }
    this.balance += amount;
    this.transactionHistory.push(`Deposited $${amount}`);
    console.log(`Deposited $${amount}. New balance: $${this.balance}`);
  }

  public withdraw(amount: number): void {
    if (amount > this.balance) {
      throw new Error('Insufficient funds');
    }
    this.balance -= amount;
    this.transactionHistory.push(`Withdrew $${amount}`);
    console.log(`Withdrew $${amount}. New balance: $${this.balance}`);
  }

  // A getter exposes balance as read-only to the outside world
  public get currentBalance(): number {
    return this.balance;
  }
}

// --- Usage ---
const myAccount = new BankAccount('Alice', 500);
myAccount.deposit(200);
myAccount.withdraw(100);

console.log(`Balance: $${myAccount.currentBalance}`);
console.log(`Holder: ${myAccount.accountHolder}`);

// This line would cause a TypeScript COMPILE ERROR — balance is private:
// console.log(myAccount.balance); // Error: Property 'balance' is private

// Abstract class: defines the contract, can't be instantiated directly
abstract class PaymentProcessor {
  // Shared data every processor needs
  constructor(
    protected readonly providerName: string,
    protected readonly feesPercentage: number
  ) {}

  // Concrete method: shared logic all subclasses inherit as-is
  public calculateFee(amount: number): number {
    return parseFloat((amount * this.feesPercentage).toFixed(2));
  }

  // Abstract method: every subclass MUST implement this — or TypeScript errors
  public abstract processPayment(amount: number, recipient: string): void;

  // Template method pattern: calls the abstract method inside a shared wrapper
  public initiateTransaction(amount: number, recipient: string): void {
    const fee = this.calculateFee(amount);
    console.log(`\n[${this.providerName}] Starting transaction...`);
    console.log(`Amount: $${amount} | Fee: $${fee} | Total: $${amount + fee}`);
    // Delegates to the subclass-specific implementation
    this.processPayment(amount, recipient);
  }
}

// Concrete subclass: must implement processPayment
class StripeProcessor extends PaymentProcessor {
  private apiKey: string;

  constructor(apiKey: string) {
    // Call parent constructor first — mandatory
    super('Stripe', 0.029); // Stripe's 2.9% fee
    this.apiKey = apiKey;
  }

  // Fulfilling the abstract contract with Stripe-specific logic
  public processPayment(amount: number, recipient: string): void {
    console.log(`Stripe API call → charging $${amount} to ${recipient}`);
    console.log(`Using key: ${this.apiKey.substring(0, 8)}...`);
  }
}

class PayPalProcessor extends PaymentProcessor {
  constructor() {
    super('PayPal', 0.034); // PayPal's 3.4% fee
  }

  public processPayment(amount: number, recipient: string): void {
    console.log(`PayPal redirect → sending $${amount} to ${recipient}'s email`);
  }
}

// --- Usage ---
const stripe = new StripeProcessor('sk_live_abc123xyz');
stripe.initiateTransaction(100, 'vendor@shop.com');

const paypal = new PayPalProcessor();
paypal.initiateTransaction(50, 'buyer@email.com');

// This would be a compile error — can't instantiate an abstract class:
// const processor = new PaymentProcessor('Generic', 0.01); // ERROR

// The contract — no implementation, just the shape
interface IUserRepository {
  findById(id: string): User | undefined;
  save(user: User): void;
  delete(id: string): boolean;
}

// A simple User type for context
type User = {
  id: string;
  name: string;
  email: string;
};

// Concrete implementation 1: talks to a real database (simplified)
class PostgresUserRepository implements IUserRepository {
  // In real life this would hold a DB connection
  private db: Map<string, User> = new Map();

  public findById(id: string): User | undefined {
    console.log(`[Postgres] Querying users table for id: ${id}`);
    return this.db.get(id);
  }

  public save(user: User): void {
    console.log(`[Postgres] Inserting/updating user: ${user.email}`);
    this.db.set(user.id, user);
  }

  public delete(id: string): boolean {
    console.log(`[Postgres] Deleting user id: ${id}`);
    return this.db.delete(id);
  }
}

// Concrete implementation 2: lives entirely in memory — perfect for unit tests
class InMemoryUserRepository implements IUserRepository {
  private store: Map<string, User> = new Map();

  public findById(id: string): User | undefined {
    return this.store.get(id);
  }

  public save(user: User): void {
    this.store.set(user.id, user);
  }

  public delete(id: string): boolean {
    return this.store.delete(id);
  }
}

// UserService depends on the INTERFACE, not a concrete class
// Swap Postgres for InMemory and this class never changes — that's the power
class UserService {
  constructor(private readonly userRepo: IUserRepository) {}

  public registerUser(name: string, email: string): User {
    const newUser: User = {
      id: `user_${Date.now()}`,
      name,
      email,
    };
    this.userRepo.save(newUser);
    console.log(`User registered: ${newUser.name} (${newUser.email})`);
    return newUser;
  }

  public getUser(id: string): User | undefined {
    return this.userRepo.findById(id);
  }
}

// --- Production usage: plug in the real DB implementation ---
const prodRepo = new PostgresUserRepository();
const prodService = new UserService(prodRepo);
const alice = prodService.registerUser('Alice', 'alice@example.com');

console.log('Found user:', prodService.getUser(alice.id)?.name);

// --- Test usage: swap to in-memory, zero infrastructure needed ---
const testRepo = new InMemoryUserRepository();
const testService = new UserService(testRepo);
testService.registerUser('Bob', 'bob@example.com');

// A generic, type-safe cache — works for any type you give it
class DataCache<T> {
  // Static counter tracks how many caches have been created across the app
  private static instanceCount: number = 0;

  private readonly cacheId: number;
  private store: Map<string, T> = new Map();
  private hitCount: number = 0;

  constructor(private readonly cacheName: string) {
    // Static member accessed on the class, not on 'this'
    DataCache.instanceCount++;
    this.cacheId = DataCache.instanceCount;
    console.log(`Cache #${this.cacheId} created: "${cacheName}"`);
  }

  // Static factory method: named constructor pattern — clearer intent than 'new'
  public static create<U>(name: string): DataCache<U> {
    return new DataCache<U>(name);
  }

  public set(key: string, value: T): void {
    this.store.set(key, value);
  }

  // TypeScript knows the return type is T (whatever you chose), not 'any'
  public get(key: string): T | undefined {
    const value = this.store.get(key);
    if (value !== undefined) {
      this.hitCount++;
    }
    return value;
  }

  public getStats(): string {
    return `Cache "${this.cacheName}" | Keys: ${this.store.size} | Hits: ${this.hitCount}`;
  }

  // Static method: relevant to the class concept, needs no instance data
  public static getTotalCaches(): number {
    return DataCache.instanceCount;
  }
}

// --- Usage: two separate typed caches ---

type Product = { id: string; name: string; price: number };

// TypeScript now knows this cache only holds Product objects
const productCache = DataCache.create<Product>('ProductCache');
productCache.set('prod_001', { id: 'prod_001', name: 'Keyboard', price: 79 });
productCache.set('prod_002', { id: 'prod_002', name: 'Mouse', price: 45 });

// TypeScript knows this cache only holds strings
const sessionCache = DataCache.create<string>('SessionCache');
sessionCache.set('session_abc', 'user_123');

// Retrieve — TypeScript infers the correct type automatically
const keyboard = productCache.get('prod_001');
console.log(`Found: ${keyboard?.name} at $${keyboard?.price}`);

const session = sessionCache.get('session_abc');
console.log(`Session maps to user: ${session}`);

console.log(productCache.getStats());
console.log(sessionCache.getStats());

// Static method called on the class, not an instance
console.log(`Total caches created: ${DataCache.getTotalCaches()}`);

// This would be a compile error — wrong type for this cache:
// productCache.set('bad_key', 'just a string'); // Error: string not assignable to Product

// Using the PaymentProcessor abstract class from earlier
// Polymorphism: treat all processors through the base type

function processAllPayments(processors: PaymentProcessor[], amount: number, recipient: string): void {
  for (const processor of processors) {
    // The same method call—different behaviour for each subclass
    processor.initiateTransaction(amount, recipient);
  }
}

const stripe = new StripeProcessor('sk_live_abc123xyz');
const paypal = new PayPalProcessor();

const processors: PaymentProcessor[] = [stripe, paypal];

processAllPayments(processors, 100, 'vendor@shop.com');

// --- Output ---
// [Stripe] Starting transaction...
// Amount: $100 | Fee: $2.9 | Total: $102.9
// Stripe API call → charging $100 to vendor@shop.com
// Using key: sk_live_...
//
// [PayPal] Starting transaction...
// Amount: $100 | Fee: $3.4 | Total: $103.4
// PayPal redirect → sending $100 to vendor@shop.com's email

// Liskov Substitution violation example (TypeScript compiles but breaks at runtime):
class BrokenProcessor extends PaymentProcessor {
  constructor() {
    super('Broken', 0.01);
  }

  public processPayment(amount: number, recipient: string): void {
    // Throws a new error type not expected by the base class contract
    throw { code: 'UNEXPECTED', detail: 'Simulated break' };
    // This violates LSP: callers expecting a normal Error object may crash
  }
}

// io.thecodeforge
class TaxCalculator {
  #baseRate = 0.2; // ES2024 private field — runtime enforced
  #surchargeRate = 0.05;

  constructor(public readonly jurisdiction: string) {}

  calculate(amount: number): number {
    return amount * (this.#baseRate + this.#surchargeRate);
  }

  // Controlled exposure — not direct property access
  setSurcharge(rate: number): void {
    if (rate < 0 || rate > 0.3) {
      throw new Error(`Surcharge ${rate} out of allowed range`);
    }
    this.#surchargeRate = rate;
  }
}

// Production use
const calc = new TaxCalculator('NY');
console.log(calc.calculate(1000)); // 250
// calc.#baseRate = 0.5; // SyntaxError in strict mode — cannot touch private field
calc.setSurcharge(0.1);
console.log(calc.calculate(1000)); // 300

// io.thecodeforge
class Engine {
  start(): string { return 'Engine running'; }
}

class DroneController {
  lift(): string { return 'Ascending'; }
}

class DeliveryVehicle {
  constructor(
    private engine: Engine,
    private drone?: DroneController
  ) {}

  deliver(): string {
    const status = this.engine.start();
    if (this.drone) {
      return `${status} | ${this.drone.lift()} for last-mile`;
    }
    return `${status} | driving`;
  }
}

// Day 1: standard truck
const truck = new DeliveryVehicle(new Engine());
console.log(truck.deliver());

// Day 2: drone mode added - no inheritance changes
const droneTruck = new DeliveryVehicle(new Engine(), new DroneController());
console.log(droneTruck.deliver());