Structural Design Patterns

Author: Htunn Thu Thu

Date: January 4, 2026

Tags: #SoftwareDesign #TypeScript #DesignPatterns #Structural

Introduction

Structural patterns help compose objects and classes into larger structures while keeping these structures flexible and efficient. When building my MCP server and IoT platform, I constantly needed to integrate external APIs, add features to existing code, and simplify complex subsystems.

This guide covers four structural patterns I use regularly:

• Adapter Pattern - Making incompatible interfaces work together

• Decorator Pattern - Adding behavior to objects dynamically

• Facade Pattern - Providing simple interfaces to complex systems

• Proxy Pattern - Controlling access to objects

---

Adapter Pattern

Allows incompatible interfaces to work together by wrapping an object with a compatible interface.

The Problem I Had

In my Agentic LLM project, I needed to integrate DuckDuckGo's search API, but its response format didn't match my internal interfaces:

// ❌ BAD: Directly using external API format throughout codebase

interface DDGSearchResult {
  Text: string;        // Capital T
  FirstURL: string;    // Capital F, U
  Icon: {
    URL: string;
    Height: number;
    Width: number;
  };
}

class AgentService {
  async search(query: string): Promise<void> {
    const response = await fetch(`https://api.duckduckgo.com/?q=${query}&format=json`);
    const data = await response.json();
    
    // My code is coupled to DuckDuckGo's format
    data.RelatedTopics.forEach((topic: DDGSearchResult) => {
      console.log(topic.Text);           // Using their naming
      console.log(topic.FirstURL);       // Their capitalization
    });
  }
}

// Problem: If I switch search providers, I'd need to update code everywhere!

My Solution: Adapter Pattern

I created an adapter to convert between interfaces:

// ✅ GOOD: Adapter pattern

// My application's interface
interface SearchResult {
  title: string;
  url: string;
  snippet: string;
}

interface SearchProvider {
  search(query: string): Promise<SearchResult[]>;
}

// DuckDuckGo's actual response format
interface DDGResponse {
  RelatedTopics: DDGTopic[];
}

interface DDGTopic {
  Text: string;
  FirstURL: string;
  Icon?: {
    URL: string;
  };
}

// Adapter for DuckDuckGo
class DuckDuckGoAdapter implements SearchProvider {
  async search(query: string): Promise<SearchResult[]> {
    const response = await fetch(
      `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json`
    );
    const data: DDGResponse = await response.json();
    
    // Convert DuckDuckGo format to my application's format
    return data.RelatedTopics
      .filter(topic => topic.FirstURL && topic.Text)
      .map(topic => this.adaptTopic(topic));
  }
  
  private adaptTopic(topic: DDGTopic): SearchResult {
    return {
      title: this.extractTitle(topic.Text),
      url: topic.FirstURL,
      snippet: topic.Text
    };
  }
  
  private extractTitle(text: string): string {
    // Extract title from text (usually before the first '-')
    const parts = text.split(' - ');
    return parts[0] || text;
  }
}

// Clean client code that doesn't know about DuckDuckGo
class AgentService {
  constructor(private searchProvider: SearchProvider) {}
  
  async performSearch(query: string): Promise<SearchResult[]> {
    // Works with any search provider!
    return await this.searchProvider.search(query);
  }
}

// Usage
const ddgAdapter = new DuckDuckGoAdapter();
const agent = new AgentService(ddgAdapter);

const results = await agent.performSearch('TypeScript design patterns');
results.forEach(result => {
  console.log(result.title);    // My format
  console.log(result.url);      // My naming
});

Multiple Adapters Example

Later, I added Google Custom Search without changing existing code:

// Easy to add new search providers!

interface GoogleSearchResponse {
  items: GoogleSearchItem[];
}

interface GoogleSearchItem {
  title: string;
  link: string;
  snippet: string;
}

class GoogleSearchAdapter implements SearchProvider {
  constructor(private apiKey: string, private searchEngineId: string) {}
  
  async search(query: string): Promise<SearchResult[]> {
    const url = `https://www.googleapis.com/customsearch/v1?key=${this.apiKey}&cx=${this.searchEngineId}&q=${encodeURIComponent(query)}`;
    const response = await fetch(url);
    const data: GoogleSearchResponse = await response.json();
    
    // Adapt Google's format to my interface
    return data.items.map(item => ({
      title: item.title,
      url: item.link,
      snippet: item.snippet
    }));
  }
}

// Switch providers easily
const googleAdapter = new GoogleSearchAdapter(apiKey, searchEngineId);
const agent2 = new AgentService(googleAdapter);

---

Decorator Pattern

Adds new functionality to objects dynamically without modifying their structure.

The Problem I Had

In my MCP server, I needed to add logging, timing, and error handling to tools without modifying each tool class:

// ❌ BAD: Repeating cross-cutting concerns in every tool

class PortScanTool {
  async execute(params: ToolParams): Promise<ToolResult> {
    // Logging
    console.log(`[${new Date().toISOString()}] PortScanTool started`);
    const startTime = Date.now();
    
    try {
      // Actual logic
      const result = await this.scanPort(params.host, params.port);
      
      // More logging
      const duration = Date.now() - startTime;
      console.log(`[${new Date().toISOString()}] PortScanTool completed in ${duration}ms`);
      
      return { success: true, data: result };
    } catch (error) {
      // Error handling
      console.error(`[${new Date().toISOString()}] PortScanTool failed:`, error);
      return { success: false, error: (error as Error).message };
    }
  }
  
  private async scanPort(host: string, port: number): Promise<any> {
    // Actual implementation
  }
}

// Same boilerplate repeated in every tool!
class SSLCheckTool {
  async execute(params: ToolParams): Promise<ToolResult> {
    console.log(`[${new Date().toISOString()}] SSLCheckTool started`);
    const startTime = Date.now();
    // ... same pattern ...
  }
}

My Solution: Decorator Pattern

I created decorators for cross-cutting concerns:

// ✅ GOOD: Decorator pattern

interface Tool {
  execute(params: ToolParams): Promise<ToolResult>;
}

// Base tool - just business logic
class PortScanTool implements Tool {
  async execute(params: ToolParams): Promise<ToolResult> {
    // Pure business logic, no cross-cutting concerns
    const isOpen = await this.scanPort(params.host, params.port);
    return {
      success: true,
      data: { host: params.host, port: params.port, open: isOpen }
    };
  }
  
  private async scanPort(host: string, port: number): Promise<boolean> {
    return new Promise((resolve) => {
      const socket = new net.Socket();
      socket.setTimeout(5000);
      socket.on('connect', () => {
        socket.destroy();
        resolve(true);
      });
      socket.on('timeout', () => {
        socket.destroy();
        resolve(false);
      });
      socket.on('error', () => resolve(false));
      socket.connect(port, host);
    });
  }
}

// Logging decorator
class LoggingDecorator implements Tool {
  constructor(private tool: Tool) {}
  
  async execute(params: ToolParams): Promise<ToolResult> {
    console.log(`[${new Date().toISOString()}] Tool execution started`);
    const result = await this.tool.execute(params);
    console.log(`[${new Date().toISOString()}] Tool execution completed`);
    return result;
  }
}

// Timing decorator
class TimingDecorator implements Tool {
  constructor(private tool: Tool) {}
  
  async execute(params: ToolParams): Promise<ToolResult> {
    const startTime = Date.now();
    const result = await this.tool.execute(params);
    const duration = Date.now() - startTime;
    
    return {
      ...result,
      metadata: {
        ...result.metadata,
        executionTime: duration
      }
    };
  }
}

// Error handling decorator
class ErrorHandlingDecorator implements Tool {
  constructor(private tool: Tool) {}
  
  async execute(params: ToolParams): Promise<ToolResult> {
    try {
      return await this.tool.execute(params);
    } catch (error) {
      console.error('Tool execution failed:', error);
      return {
        success: false,
        error: (error as Error).message
      };
    }
  }
}

// Caching decorator
class CachingDecorator implements Tool {
  private cache = new Map<string, ToolResult>();
  
  constructor(private tool: Tool, private ttlMs: number = 60000) {}
  
  async execute(params: ToolParams): Promise<ToolResult> {
    const cacheKey = this.getCacheKey(params);
    const cached = this.cache.get(cacheKey);
    
    if (cached) {
      console.log('Cache hit');
      return { ...cached, metadata: { ...cached.metadata, fromCache: true } };
    }
    
    const result = await this.tool.execute(params);
    this.cache.set(cacheKey, result);
    
    // Clear cache after TTL
    setTimeout(() => this.cache.delete(cacheKey), this.ttlMs);
    
    return result;
  }
  
  private getCacheKey(params: ToolParams): string {
    return JSON.stringify(params);
  }
}

// Compose decorators as needed
let tool: Tool = new PortScanTool();
tool = new ErrorHandlingDecorator(tool);
tool = new TimingDecorator(tool);
tool = new LoggingDecorator(tool);
tool = new CachingDecorator(tool, 30000);

// Clean usage - all features applied
const result = await tool.execute({ host: 'example.com', port: 443 });

TypeScript Decorators

TypeScript also has native decorator syntax (experimental):

// Using TypeScript decorators for methods

function Timed(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  
  descriptor.value = async function(...args: any[]) {
    const start = Date.now();
    const result = await originalMethod.apply(this, args);
    const duration = Date.now() - start;
    console.log(`${propertyKey} took ${duration}ms`);
    return result;
  };
  
  return descriptor;
}

function Logged(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  
  descriptor.value = async function(...args: any[]) {
    console.log(`${propertyKey} called with:`, args);
    const result = await originalMethod.apply(this, args);
    console.log(`${propertyKey} returned:`, result);
    return result;
  };
  
  return descriptor;
}

class SensorService {
  @Timed
  @Logged
  async getData(sensorId: string): Promise<SensorData> {
    // Just business logic
    return await this.repository.findById(sensorId);
  }
}

---

Facade Pattern

Provides a simplified interface to a complex subsystem.

The Problem I Had

My IoT platform had complex interactions between MongoDB, LLM service, and data formatting:

// ❌ BAD: Client code deals with complexity

class DashboardController {
  async getSensorInsights(sensorId: string): Promise<any> {
    // Complex setup
    const dbClient = new MongoClient(process.env.MONGO_URI!);
    await dbClient.connect();
    const db = dbClient.db('iot');
    
    // Fetch data
    const sensorData = await db.collection('sensors')
      .find({ sensorId })
      .sort({ timestamp: -1 })
      .limit(100)
      .toArray();
    
    // Format data
    const formattedData = sensorData.map(d => ({
      temp: d.temperature,
      humidity: d.humidity,
      time: d.timestamp.toISOString()
    }));
    
    // Query LLM
    const llmClient = new LLMClient(process.env.LLM_ENDPOINT!);
    const context = JSON.stringify(formattedData);
    const analysis = await llmClient.query(
      `Analyze this sensor data: ${context}`
    );
    
    // Cleanup
    await dbClient.close();
    
    return {
      sensorId,
      data: formattedData,
      analysis
    };
  }
}

// Too much complexity exposed to the controller!

My Solution: Facade Pattern

I created a simple facade over the complex subsystem:

// ✅ GOOD: Facade pattern

class SensorInsightsFacade {
  private dbConnection: DatabaseConnection;
  private dataFormatter: DataFormatter;
  private llmService: LLMService;
  
  constructor() {
    this.dbConnection = DatabaseConnection.getInstance();
    this.dataFormatter = new DataFormatter();
    this.llmService = new LLMService();
  }
  
  async getInsights(sensorId: string): Promise<SensorInsights> {
    // Simple facade method hiding complexity
    const rawData = await this.fetchSensorData(sensorId);
    const formatted = this.dataFormatter.formatForLLM(rawData);
    const analysis = await this.llmService.analyzeSensorData(formatted);
    
    return {
      sensorId,
      data: formatted,
      analysis,
      generatedAt: new Date()
    };
  }
  
  private async fetchSensorData(sensorId: string): Promise<RawSensorData[]> {
    const db = this.dbConnection.getDatabase('iot');
    return await db.collection('sensors')
      .find({ sensorId })
      .sort({ timestamp: -1 })
      .limit(100)
      .toArray();
  }
}

// Clean client code
class DashboardController {
  private facade = new SensorInsightsFacade();
  
  async getSensorInsights(sensorId: string): Promise<SensorInsights> {
    // Simple one-liner!
    return await this.facade.getInsights(sensorId);
  }
}

Real-World Facade: MCP Server Tools

Here's how I used facade in my MCP server to simplify security scanning:

// Complex subsystem components
class PortScanner {
  async scan(host: string, ports: number[]): Promise<PortScanResult[]> {
    // Complex port scanning logic
    return [];
  }
}

class SSLChecker {
  async check(host: string): Promise<SSLInfo> {
    // Complex SSL certificate validation
    return {} as SSLInfo;
  }
}

class DNSResolver {
  async resolve(host: string): Promise<DNSInfo> {
    // Complex DNS lookup
    return {} as DNSInfo;
  }
}

class VulnerabilityScanner {
  async scan(host: string, services: string[]): Promise<Vulnerability[]> {
    // Complex vulnerability detection
    return [];
  }
}

// Facade providing simple interface
class SecurityScanFacade {
  private portScanner = new PortScanner();
  private sslChecker = new SSLChecker();
  private dnsResolver = new DNSResolver();
  private vulnScanner = new VulnerabilityScanner();
  
  async comprehensiveScan(host: string): Promise<SecurityReport> {
    console.log(`Starting comprehensive scan of ${host}`);
    
    // Orchestrate complex workflow
    const [dns, ssl, ports] = await Promise.all([
      this.dnsResolver.resolve(host),
      this.sslChecker.check(host).catch(() => null),
      this.portScanner.scan(host, [80, 443, 8080, 8443])
    ]);
    
    const openPorts = ports.filter(p => p.open);
    const services = openPorts.map(p => p.service).filter(Boolean);
    
    const vulnerabilities = services.length > 0
      ? await this.vulnScanner.scan(host, services as string[])
      : [];
    
    return {
      host,
      scannedAt: new Date(),
      dns,
      ssl,
      openPorts,
      vulnerabilities,
      riskScore: this.calculateRiskScore(vulnerabilities)
    };
  }
  
  async quickScan(host: string): Promise<QuickScanReport> {
    // Simplified scan for fast checks
    const ports = await this.portScanner.scan(host, [80, 443]);
    const ssl = ports.some(p => p.port === 443 && p.open)
      ? await this.sslChecker.check(host).catch(() => null)
      : null;
    
    return {
      host,
      portsOpen: ports.filter(p => p.open).length,
      hasSSL: !!ssl,
      sslValid: ssl?.valid ?? false
    };
  }
  
  private calculateRiskScore(vulnerabilities: Vulnerability[]): number {
    return vulnerabilities.reduce((score, vuln) => {
      return score + (vuln.severity === 'high' ? 10 : vuln.severity === 'medium' ? 5 : 1);
    }, 0);
  }
}

// Usage is simple
const securityFacade = new SecurityScanFacade();

// One method call instead of coordinating multiple subsystems
const report = await securityFacade.comprehensiveScan('example.com');
const quickCheck = await securityFacade.quickScan('example.com');

---

Proxy Pattern

Provides a surrogate or placeholder for another object to control access to it.

The Problem I Had

In my IoT platform, sensor data queries to the LLM were expensive and slow:

// ❌ BAD: Every query hits the LLM directly

class SensorQueryService {
  constructor(private llm: LLMService) {}
  
  async query(sensorId: string, question: string): Promise<string> {
    // Always expensive LLM call, even for repeated questions
    const data = await this.getSensorData(sensorId);
    return await this.llm.query(`${question}\nData: ${JSON.stringify(data)}`);
  }
  
  private async getSensorData(sensorId: string): Promise<any> {
    // Fetch data
    return {};
  }
}

// Problem: Asking the same question multiple times is wasteful

My Solution: Caching Proxy

I created a proxy to cache expensive operations:

// ✅ GOOD: Proxy pattern with caching

interface QueryService {
  query(sensorId: string, question: string): Promise<string>;
}

// Real service
class RealSensorQueryService implements QueryService {
  constructor(private llm: LLMService, private dataRepo: SensorRepository) {}
  
  async query(sensorId: string, question: string): Promise<string> {
    console.log('Executing real LLM query...');
    const data = await this.dataRepo.getRecentData(sensorId, 24);
    return await this.llm.query(`${question}\nData: ${JSON.stringify(data)}`);
  }
}

// Caching proxy
class CachingQueryProxy implements QueryService {
  private cache = new Map<string, CachedResult>();
  
  constructor(
    private realService: QueryService,
    private ttlMs: number = 300000 // 5 minutes
  ) {}
  
  async query(sensorId: string, question: string): Promise<string> {
    const cacheKey = `${sensorId}:${question}`;
    const cached = this.cache.get(cacheKey);
    
    if (cached && Date.now() - cached.timestamp < this.ttlMs) {
      console.log('Cache hit - returning cached result');
      return cached.result;
    }
    
    console.log('Cache miss - querying real service');
    const result = await this.realService.query(sensorId, question);
    
    this.cache.set(cacheKey, {
      result,
      timestamp: Date.now()
    });
    
    return result;
  }
}

interface CachedResult {
  result: string;
  timestamp: number;
}

// Usage
const realService = new RealSensorQueryService(llm, repo);
const proxy = new CachingQueryProxy(realService, 300000);

// First call - hits LLM
const answer1 = await proxy.query('sensor-01', 'What is the average temperature?');
// Second call within 5 minutes - returns cached result
const answer2 = await proxy.query('sensor-01', 'What is the average temperature?');

Virtual Proxy (Lazy Loading)

I also use proxies for lazy initialization of expensive resources:

// ✅ GOOD: Virtual proxy for lazy loading

interface LLMService {
  query(prompt: string): Promise<string>;
}

// Expensive to initialize
class RealLLMService implements LLMService {
  private model: any;
  
  constructor() {
    console.log('Loading large LLM model...');
    // Expensive initialization
    this.model = this.loadModel();
  }
  
  private loadModel(): any {
    // Load multi-gigabyte model
    return {};
  }
  
  async query(prompt: string): Promise<string> {
    // Use model
    return 'response';
  }
}

// Lazy loading proxy
class LazyLLMProxy implements LLMService {
  private realService?: RealLLMService;
  
  async query(prompt: string): Promise<string> {
    if (!this.realService) {
      console.log('First query - initializing LLM service');
      this.realService = new RealLLMService();
    }
    return await this.realService.query(prompt);
  }
}

// No initialization cost until first use
const llm = new LazyLLMProxy(); // Instant!

// Only now does it load the model
const result = await llm.query('Hello'); // Triggers initialization

Protection Proxy (Access Control)

In my MCP server, I use proxies to control access to sensitive operations:

// ✅ GOOD: Protection proxy

interface ScanTool {
  scan(host: string, ports: number[]): Promise<ScanResult>;
}

class RealScanTool implements ScanTool {
  async scan(host: string, ports: number[]): Promise<ScanResult> {
    // Actual scanning implementation
    return { host, openPorts: [] };
  }
}

class RateLimitingProxy implements ScanTool {
  private requests = new Map<string, number[]>();
  private readonly maxRequestsPerMinute = 10;
  
  constructor(private realTool: ScanTool) {}
  
  async scan(host: string, ports: number[]): Promise<ScanResult> {
    if (!this.checkRateLimit(host)) {
      throw new Error(`Rate limit exceeded for ${host}. Max ${this.maxRequestsPerMinute} requests per minute.`);
    }
    
    this.recordRequest(host);
    return await this.realTool.scan(host, ports);
  }
  
  private checkRateLimit(host: string): boolean {
    const now = Date.now();
    const requests = this.requests.get(host) || [];
    const recentRequests = requests.filter(time => now - time < 60000);
    return recentRequests.length < this.maxRequestsPerMinute;
  }
  
  private recordRequest(host: string): void {
    const now = Date.now();
    const requests = this.requests.get(host) || [];
    requests.push(now);
    this.requests.set(host, requests.filter(time => now - time < 60000));
  }
}

// Usage
const realTool = new RealScanTool();
const protectedTool = new RateLimitingProxy(realTool);

// Enforces rate limiting
await protectedTool.scan('example.com', [80, 443]);

---

Combining Structural Patterns

Here's a real example combining multiple structural patterns from my MCP server:

// Real-world combination of structural patterns

// External API with incompatible interface (Adapter needed)
interface NmapAPI {
  runScan(target: string, options: NmapOptions): Promise<NmapOutput>;
}

// My application's interface
interface PortScanner {
  scan(host: string, ports: number[]): Promise<PortScanResult[]>;
}

// Adapter
class NmapAdapter implements PortScanner {
  constructor(private nmapApi: NmapAPI) {}
  
  async scan(host: string, ports: number[]): Promise<PortScanResult[]> {
    const nmapOutput = await this.nmapApi.runScan(host, {
      ports: ports.join(','),
      timing: 'normal'
    });
    
    return this.convertOutput(nmapOutput);
  }
  
  private convertOutput(output: NmapOutput): PortScanResult[] {
    // Convert Nmap format to my format
    return [];
  }
}

// Decorator for logging
class LoggingDecorator implements PortScanner {
  constructor(private scanner: PortScanner) {}
  
  async scan(host: string, ports: number[]): Promise<PortScanResult[]> {
    console.log(`Scanning ${host} on ports ${ports.join(', ')}`);
    const result = await this.scanner.scan(host, ports);
    console.log(`Scan complete: ${result.length} results`);
    return result;
  }
}

// Proxy for caching and rate limiting
class SmartScanProxy implements PortScanner {
  private cache = new Map<string, CachedScan>();
  private lastScanTime = 0;
  private minScanInterval = 1000; // 1 second between scans
  
  constructor(private scanner: PortScanner) {}
  
  async scan(host: string, ports: number[]): Promise<PortScanResult[]> {
    // Check cache
    const cacheKey = `${host}:${ports.sort().join(',')}`;
    const cached = this.cache.get(cacheKey);
    
    if (cached && Date.now() - cached.timestamp < 60000) {
      console.log('Returning cached scan result');
      return cached.results;
    }
    
    // Rate limiting
    const timeSinceLastScan = Date.now() - this.lastScanTime;
    if (timeSinceLastScan < this.minScanInterval) {
      await this.sleep(this.minScanInterval - timeSinceLastScan);
    }
    
    // Perform scan
    const results = await this.scanner.scan(host, ports);
    this.lastScanTime = Date.now();
    
    // Cache results
    this.cache.set(cacheKey, { results, timestamp: Date.now() });
    
    return results;
  }
  
  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

interface CachedScan {
  results: PortScanResult[];
  timestamp: number;
}

// Facade to simplify usage
class SecurityToolsFacade {
  private scanner: PortScanner;
  
  constructor(nmapApi: NmapAPI) {
    // Compose patterns: Adapter -> Decorator -> Proxy
    let scanner: PortScanner = new NmapAdapter(nmapApi);
    scanner = new LoggingDecorator(scanner);
    scanner = new SmartScanProxy(scanner);
    
    this.scanner = scanner;
  }
  
  async quickScan(host: string): Promise<SecurityReport> {
    const results = await this.scanner.scan(host, [80, 443, 8080]);
    return {
      host,
      openPorts: results.filter(r => r.open),
      scannedAt: new Date()
    };
  }
  
  async fullScan(host: string): Promise<SecurityReport> {
    const commonPorts = [
      21, 22, 23, 25, 53, 80, 110, 143, 443,
      465, 587, 993, 995, 3306, 5432, 8080, 8443
    ];
    
    const results = await this.scanner.scan(host, commonPorts);
    return {
      host,
      openPorts: results.filter(r => r.open),
      scannedAt: new Date()
    };
  }
}

// Simple usage hiding all complexity
const facade = new SecurityToolsFacade(nmapApi);
const report = await facade.quickScan('example.com');

---

When to Use Each Pattern

Adapter Pattern

✅ Use when:

• Integrating third-party libraries with incompatible interfaces

• Working with legacy code

• Need to switch between alternative implementations

❌ Avoid when:

• You control both interfaces (just make them compatible)

• Conversion adds no value

Decorator Pattern

✅ Use when:

• Adding responsibilities to objects dynamically

• Need composable enhancements (logging, caching, timing)

• Want to avoid subclass explosion

❌ Avoid when:

• Simple inheritance is sufficient

• Behavior should be fixed at compile time

Facade Pattern

✅ Use when:

• Subsystem is complex with many interdependent classes

• Want to provide simple interface to complex functionality

• Need to decouple clients from subsystem implementation

❌ Avoid when:

• System is already simple

• Clients need fine-grained control

Proxy Pattern

✅ Use when:

• Need lazy initialization of expensive objects

• Want to add access control, caching, or logging

• Objects are remote or need controlled access

❌ Avoid when:

• Direct access is simpler and sufficient

• Indirection adds unnecessary complexity

---

Conclusion

Structural patterns help organize code effectively:

• Adapter: Bridges incompatible interfaces

• Decorator: Adds behavior flexibly

• Facade: Simplifies complex systems

• Proxy: Controls object access

I use these patterns constantly in my TypeScript projects to integrate APIs, add features cleanly, and manage complexity.

What's Next?

• Behavioral Design Patterns → - Patterns for object interaction

• Creational Design Patterns → - Patterns for object creation

• Component Design → - Building modular architectures

References

• My MCP Server - Adapter and Facade patterns

• Refactoring.Guru - Structural Patterns

---

Previous: ← Creational Patterns | Next: Behavioral Patterns →