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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

// Subject Interface - defines all document operations
interface DocumentProcessor {
    readonly documentId: string;
    
    // Lightweight operations (can use metadata)
    getTitle(): string;
    getPageCount(): number;
    getMetadata(): DocumentMetadata;
    getThumbnail(): ImageData;
    
    // Heavy operations (require full document)
    getPageContent(pageNumber: number): PageContent;
    renderPage(pageNumber: number, options: RenderOptions): Canvas;
    searchContent(query: string): SearchResult[];
    extractText(): string;
    exportToPDF(options: ExportOptions): Uint8Array;
}
 
interface DocumentMetadata {
    title: string;
    author: string;
    pageCount: number;
    createdAt: Date;
    modifiedAt: Date;
    fileSize: number;
    format: 'PDF' | 'DOCX' | 'ODT';
}
 
// RealSubject - expensive to create, holds all data
class RealDocumentProcessor implements DocumentProcessor {
    private content: DocumentContent;
    private parsedPages: Map<number, PageContent> = new Map();
    
    constructor(public readonly documentId: string) {
        console.log(`[RealDocumentProcessor] Loading document ${documentId}...`);
        
        // EXPENSIVE: Load entire document from storage
        const startTime = performance.now();
        const rawData = FileSystem.read(`/documents/${documentId}`);
        
        // EXPENSIVE: Parse document structure
        this.content = DocumentParser.parse(rawData);
        
        // EXPENSIVE: Build search index
        this.buildSearchIndex();
        
        console.log(`[RealDocumentProcessor] Document loaded in ${performance.now() - startTime}ms`);
    }
    
    private buildSearchIndex(): void {
        // CPU-intensive indexing operation
        for (let i = 0; i < this.content.pageCount; i++) {
            this.parsedPages.set(i, this.content.parsePage(i));
        }
    }
    
    getTitle(): string {
        return this.content.metadata.title;
    }
    
    getPageCount(): number {
        return this.content.pageCount;
    }
    
    getMetadata(): DocumentMetadata {
        return this.content.metadata;
    }
    
    getThumbnail(): ImageData {
        return this.renderPage(0, { width: 150, height: 200 }).toImageData();
    }
    
    getPageContent(pageNumber: number): PageContent {
        return this.parsedPages.get(pageNumber)!;
    }
    
    renderPage(pageNumber: number, options: RenderOptions): Canvas {
        const page = this.parsedPages.get(pageNumber)!;
        return Renderer.renderPage(page, options);
    }
    
    searchContent(query: string): SearchResult[] {
        const results: SearchResult[] = [];
        for (const [pageNum, content] of this.parsedPages) {
            const matches = content.search(query);
            results.push(...matches.map(m => ({ pageNumber: pageNum, ...m })));
        }
        return results;
    }
    
    extractText(): string {
        let text = '';
        for (const content of this.parsedPages.values()) {
            text += content.text + '
 
';
        }
        return text;
    }
    
    exportToPDF(options: ExportOptions): Uint8Array {
        return PDFExporter.export(this.content, options);
    }
}

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

// Virtual Proxy - defers expensive creation
class DocumentProcessorProxy implements DocumentProcessor {
    // Lightweight metadata - loaded immediately
    private metadata: DocumentMetadata | null = null;
    private thumbnail: ImageData | null = null;
    
    // Real processor - created only when needed
    private realProcessor: RealDocumentProcessor | null = null;
    private isLoading: boolean = false;
    private loadError: Error | null = null;
    
    constructor(public readonly documentId: string) {
        // Proxy is cheap - just stores the ID
        console.log(`[Proxy] Created lightweight proxy for ${documentId}`);
    }
    
    // Lazy initialization with error handling
    private ensureRealProcessor(): RealDocumentProcessor {
        if (this.loadError) {
            throw this.loadError;
        }
        
        if (!this.realProcessor) {
            try {
                console.log(`[Proxy] First heavy access - creating real processor`);
                this.realProcessor = new RealDocumentProcessor(this.documentId);
            } catch (error) {
                this.loadError = error as Error;
                throw error;
            }
        }
        
        return this.realProcessor;
    }
    
    // Async version for non-blocking loading
    private async ensureRealProcessorAsync(): Promise<RealDocumentProcessor> {
        if (this.loadError) {
            throw this.loadError;
        }
        
        if (!this.realProcessor && !this.isLoading) {
            this.isLoading = true;
            
            // Create in background
            return new Promise((resolve, reject) => {
                setTimeout(() => {
                    try {
                        this.realProcessor = new RealDocumentProcessor(this.documentId);
                        this.isLoading = false;
                        resolve(this.realProcessor);
                    } catch (error) {
                        this.loadError = error as Error;
                        this.isLoading = false;
                        reject(error);
                    }
                }, 0);
            });
        }
        
        // Wait if already loading
        while (this.isLoading) {
            await new Promise(r => setTimeout(r, 10));
        }
        
        return this.realProcessor!;
    }
    
    // ===== LIGHTWEIGHT OPERATIONS =====
    // These can be satisfied from metadata without loading full document
    
    getTitle(): string {
        return this.getMetadata().title;
    }
    
    getPageCount(): number {
        return this.getMetadata().pageCount;
    }
    
    getMetadata(): DocumentMetadata {
        if (!this.metadata) {
            // Read just metadata header - much cheaper than full load
            console.log(`[Proxy] Loading lightweight metadata`);
            this.metadata = MetadataReader.readQuick(`/documents/${this.documentId}`);
        }
        return this.metadata;
    }
    
    getThumbnail(): ImageData {
        if (!this.thumbnail) {
            // Try to read cached thumbnail first
            const cached = ThumbnailCache.get(this.documentId);
            if (cached) {
                this.thumbnail = cached;
            } else {
                // Only if no cache, trigger full load
                console.log(`[Proxy] No cached thumbnail - triggering full load`);
                this.thumbnail = this.ensureRealProcessor().getThumbnail();
                ThumbnailCache.set(this.documentId, this.thumbnail);
            }
        }
        return this.thumbnail;
    }
    
    // ===== HEAVY OPERATIONS =====
    // These require the full document to be loaded
    
    getPageContent(pageNumber: number): PageContent {
        console.log(`[Proxy] getPageContent requires full load`);
        return this.ensureRealProcessor().getPageContent(pageNumber);
    }
    
    renderPage(pageNumber: number, options: RenderOptions): Canvas {
        console.log(`[Proxy] renderPage requires full load`);
        return this.ensureRealProcessor().renderPage(pageNumber, options);
    }
    
    searchContent(query: string): SearchResult[] {
        console.log(`[Proxy] searchContent requires full load`);
        return this.ensureRealProcessor().searchContent(query);
    }
    
    extractText(): string {
        console.log(`[Proxy] extractText requires full load`);
        return this.ensureRealProcessor().extractText();
    }
    
    exportToPDF(options: ExportOptions): Uint8Array {
        console.log(`[Proxy] exportToPDF requires full load`);
        return this.ensureRealProcessor().exportToPDF(options);
    }
    
    // ===== PROXY-SPECIFIC UTILITIES =====
    
    /** Check if the heavy document is loaded */
    isFullyLoaded(): boolean {
        return this.realProcessor !== null;
    }
    
    /** Pre-load in background for anticipated use */
    async preload(): Promise<void> {
        if (!this.realProcessor) {
            await this.ensureRealProcessorAsync();
        }
    }
    
    /** Release memory by unloading (can be re-loaded later) */
    unload(): void {
        if (this.realProcessor) {
            console.log(`[Proxy] Unloading document to free memory`);
            this.realProcessor = null;
        }
    }
}

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

// Types for our banking domain
interface User {
    id: string;
    name: string;
    roles: UserRole[];
    department: string;
}
 
type UserRole = 'TELLER' | 'MANAGER' | 'ADMIN' | 'AUDITOR' | 'CUSTOMER';
 
interface AuditEntry {
    timestamp: Date;
    userId: string;
    action: string;
    accountNumber: string;
    details: Record<string, unknown>;
    outcome: 'SUCCESS' | 'DENIED' | 'ERROR';
}
 
// Subject Interface
interface BankAccount {
    readonly accountNumber: string;
    
    // Read operations
    getBalance(): Money;
    getTransactionHistory(days: number): Transaction[];
    getAccountDetails(): AccountDetails;
    
    // Write operations
    deposit(amount: Money, description: string): TransactionResult;
    withdraw(amount: Money, description: string): TransactionResult;
    transfer(targetAccount: string, amount: Money, description: string): TransactionResult;
    
    // Administrative operations
    freeze(): void;
    unfreeze(): void;
    setDailyLimit(amount: Money): void;
    closeAccount(): CloseResult;
}
 
// RealSubject - actual bank account with no security
class RealBankAccount implements BankAccount {
    private balance: Money;
    private transactions: Transaction[] = [];
    private isFrozen: boolean = false;
    private dailyLimit: Money = Money.fromDollars(10000);
    
    constructor(
        public readonly accountNumber: string,
        initialBalance: Money
    ) {
        this.balance = initialBalance;
    }
    
    getBalance(): Money {
        return this.balance;
    }
    
    getTransactionHistory(days: number): Transaction[] {
        const cutoff = new Date();
        cutoff.setDate(cutoff.getDate() - days);
        return this.transactions.filter(t => t.timestamp >= cutoff);
    }
    
    getAccountDetails(): AccountDetails {
        return {
            accountNumber: this.accountNumber,
            balance: this.balance,
            isFrozen: this.isFrozen,
            dailyLimit: this.dailyLimit,
            openedDate: this.transactions[0]?.timestamp ?? new Date(),
        };
    }
    
    deposit(amount: Money, description: string): TransactionResult {
        if (this.isFrozen) {
            return { success: false, error: 'Account is frozen' };
        }
        
        this.balance = this.balance.add(amount);
        this.recordTransaction('DEPOSIT', amount, description);
        return { success: true, newBalance: this.balance };
    }
    
    withdraw(amount: Money, description: string): TransactionResult {
        if (this.isFrozen) {
            return { success: false, error: 'Account is frozen' };
        }
        
        if (amount.greaterThan(this.balance)) {
            return { success: false, error: 'Insufficient funds' };
        }
        
        this.balance = this.balance.subtract(amount);
        this.recordTransaction('WITHDRAWAL', amount, description);
        return { success: true, newBalance: this.balance };
    }
    
    transfer(targetAccount: string, amount: Money, description: string): TransactionResult {
        const withdrawResult = this.withdraw(amount, `Transfer to ${targetAccount}: ${description}`);
        if (!withdrawResult.success) {
            return withdrawResult;
        }
        
        // In real system, would interact with target account
        return { success: true, newBalance: this.balance };
    }
    
    freeze(): void {
        this.isFrozen = true;
    }
    
    unfreeze(): void {
        this.isFrozen = false;
    }
    
    setDailyLimit(amount: Money): void {
        this.dailyLimit = amount;
    }
    
    closeAccount(): CloseResult {
        if (this.balance.greaterThan(Money.zero())) {
            return { success: false, error: 'Account has remaining balance' };
        }
        return { success: true };
    }
    
    private recordTransaction(type: string, amount: Money, description: string): void {
        this.transactions.push({
            id: generateId(),
            timestamp: new Date(),
            type,
            amount,
            description,
        });
    }
}

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241

// Permission definitions
const PERMISSIONS = {
    // Read permissions
    VIEW_BALANCE: ['TELLER', 'MANAGER', 'ADMIN', 'AUDITOR', 'CUSTOMER'],
    VIEW_HISTORY: ['TELLER', 'MANAGER', 'ADMIN', 'AUDITOR', 'CUSTOMER'],
    VIEW_DETAILS: ['MANAGER', 'ADMIN', 'AUDITOR'],
    
    // Write permissions
    DEPOSIT: ['TELLER', 'MANAGER', 'ADMIN'],
    WITHDRAW: ['TELLER', 'MANAGER', 'ADMIN'],
    TRANSFER: ['TELLER', 'MANAGER', 'ADMIN'],
    
    // Admin permissions
    FREEZE: ['MANAGER', 'ADMIN'],
    UNFREEZE: ['ADMIN'],  // Only admin can unfreeze
    SET_LIMIT: ['MANAGER', 'ADMIN'],
    CLOSE_ACCOUNT: ['ADMIN'],
} as const;
 
type Permission = keyof typeof PERMISSIONS;
 
// Protection Proxy with comprehensive security
class SecureBankAccountProxy implements BankAccount {
    private auditLog: AuditEntry[] = [];
    
    constructor(
        private readonly realAccount: RealBankAccount,
        private readonly currentUser: User,
        private readonly auditService: AuditService
    ) {}
    
    get accountNumber(): string {
        return this.realAccount.accountNumber;
    }
    
    // ===== PERMISSION CHECKING =====
    
    private hasPermission(permission: Permission): boolean {
        const allowedRoles = PERMISSIONS[permission];
        return this.currentUser.roles.some(role => 
            allowedRoles.includes(role)
        );
    }
    
    private checkPermission(permission: Permission, action: string): void {
        if (!this.hasPermission(permission)) {
            this.audit(action, { permission }, 'DENIED');
            
            throw new UnauthorizedError(
                `User ${this.currentUser.name} lacks permission: ${permission}`
            );
        }
    }
    
    private audit(
        action: string, 
        details: Record<string, unknown>,
        outcome: 'SUCCESS' | 'DENIED' | 'ERROR'
    ): void {
        const entry: AuditEntry = {
            timestamp: new Date(),
            userId: this.currentUser.id,
            action,
            accountNumber: this.accountNumber,
            details,
            outcome,
        };
        
        this.auditService.log(entry);
    }
    
    // ===== READ OPERATIONS =====
    
    getBalance(): Money {
        this.checkPermission('VIEW_BALANCE', 'getBalance');
        
        const result = this.realAccount.getBalance();
        this.audit('getBalance', { balance: result.toString() }, 'SUCCESS');
        
        return result;
    }
    
    getTransactionHistory(days: number): Transaction[] {
        this.checkPermission('VIEW_HISTORY', 'getTransactionHistory');
        
        // Additional check: customers can only see 90 days
        const effectiveDays = this.currentUser.roles.includes('CUSTOMER')
            ? Math.min(days, 90)
            : days;
        
        const result = this.realAccount.getTransactionHistory(effectiveDays);
        this.audit('getTransactionHistory', { 
            requestedDays: days, 
            effectiveDays,
            resultCount: result.length 
        }, 'SUCCESS');
        
        return result;
    }
    
    getAccountDetails(): AccountDetails {
        this.checkPermission('VIEW_DETAILS', 'getAccountDetails');
        
        const result = this.realAccount.getAccountDetails();
        this.audit('getAccountDetails', {}, 'SUCCESS');
        
        return result;
    }
    
    // ===== WRITE OPERATIONS =====
    
    deposit(amount: Money, description: string): TransactionResult {
        this.checkPermission('DEPOSIT', 'deposit');
        
        // Additional validation
        if (amount.greaterThan(Money.fromDollars(50000))) {
            // Large deposits require manager approval
            if (!this.currentUser.roles.includes('MANAGER') && 
                !this.currentUser.roles.includes('ADMIN')) {
                this.audit('deposit', { amount: amount.toString(), reason: 'NEEDS_APPROVAL' }, 'DENIED');
                throw new ApprovalRequiredError('Deposits over $50,000 require manager approval');
            }
        }
        
        const result = this.realAccount.deposit(amount, description);
        this.audit('deposit', { 
            amount: amount.toString(), 
            description,
            success: result.success 
        }, result.success ? 'SUCCESS' : 'ERROR');
        
        return result;
    }
    
    withdraw(amount: Money, description: string): TransactionResult {
        this.checkPermission('WITHDRAW', 'withdraw');
        
        // Rate limiting: max 5 withdrawals per hour per teller
        if (this.currentUser.roles.includes('TELLER')) {
            const recentWithdrawals = this.auditService.countRecent(
                this.currentUser.id, 
                'withdraw',
                60 // minutes
            );
            
            if (recentWithdrawals >= 5) {
                this.audit('withdraw', { reason: 'RATE_LIMITED' }, 'DENIED');
                throw new RateLimitError('Maximum withdrawal operations exceeded');
            }
        }
        
        const result = this.realAccount.withdraw(amount, description);
        this.audit('withdraw', { 
            amount: amount.toString(),
            description,
            success: result.success 
        }, result.success ? 'SUCCESS' : 'ERROR');
        
        return result;
    }
    
    transfer(targetAccount: string, amount: Money, description: string): TransactionResult {
        this.checkPermission('TRANSFER', 'transfer');
        
        // Large transfers require dual authorization
        if (amount.greaterThan(Money.fromDollars(100000))) {
            const hasSecondApproval = this.checkDualAuthorization(targetAccount, amount);
            if (!hasSecondApproval) {
                this.audit('transfer', { 
                    targetAccount, 
                    amount: amount.toString(),
                    reason: 'NEEDS_DUAL_AUTH' 
                }, 'DENIED');
                throw new DualAuthorizationError(
                    'Transfers over $100,000 require dual authorization'
                );
            }
        }
        
        const result = this.realAccount.transfer(targetAccount, amount, description);
        this.audit('transfer', { 
            targetAccount,
            amount: amount.toString(),
            description,
            success: result.success 
        }, result.success ? 'SUCCESS' : 'ERROR');
        
        return result;
    }
    
    // ===== ADMIN OPERATIONS =====
    
    freeze(): void {
        this.checkPermission('FREEZE', 'freeze');
        
        this.realAccount.freeze();
        this.audit('freeze', { reason: 'Manual freeze by authorized user' }, 'SUCCESS');
        
        // Trigger notification
        NotificationService.notify(
            `Account ${this.accountNumber} frozen by ${this.currentUser.name}`
        );
    }
    
    unfreeze(): void {
        this.checkPermission('UNFREEZE', 'unfreeze');
        
        this.realAccount.unfreeze();
        this.audit('unfreeze', { reason: 'Manual unfreeze by admin' }, 'SUCCESS');
    }
    
    setDailyLimit(amount: Money): void {
        this.checkPermission('SET_LIMIT', 'setDailyLimit');
        
        const previousLimit = this.realAccount.getAccountDetails().dailyLimit;
        this.realAccount.setDailyLimit(amount);
        this.audit('setDailyLimit', { 
            previousLimit: previousLimit.toString(),
            newLimit: amount.toString()
        }, 'SUCCESS');
    }
    
    closeAccount(): CloseResult {
        this.checkPermission('CLOSE_ACCOUNT', 'closeAccount');
        
        const result = this.realAccount.closeAccount();
        this.audit('closeAccount', { success: result.success }, 
            result.success ? 'SUCCESS' : 'ERROR');
        
        return result;
    }
    
    private checkDualAuthorization(target: string, amount: Money): boolean {
        // Check if another authorized user has approved this specific transfer
        return DualAuthService.hasApproval(
            this.accountNumber,
            target,
            amount
        );
    }
}

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262

// Subject Interface - same for local and remote
interface InventoryService {
    // Query operations
    checkStock(productId: string): Promise<StockInfo>;
    getProduct(productId: string): Promise<Product | null>;
    searchProducts(criteria: SearchCriteria): Promise<ProductSearchResult>;
    
    // Mutation operations
    reserveStock(productId: string, quantity: number): Promise<ReservationResult>;
    releaseReservation(reservationId: string): Promise<void>;
    updateStock(productId: string, delta: number, reason: string): Promise<StockInfo>;
}
 
interface StockInfo {
    productId: string;
    available: number;
    reserved: number;
    inTransit: number;
    lastUpdated: Date;
}
 
interface ReservationResult {
    success: boolean;
    reservationId?: string;
    expiresAt?: Date;
    error?: string;
}
 
// Network layer types
interface RpcRequest {
    id: string;
    method: string;
    params: unknown[];
    timestamp: number;
}
 
interface RpcResponse<T = unknown> {
    id: string;
    result?: T;
    error?: RpcError;
}
 
interface RpcError {
    code: number;
    message: string;
    data?: unknown;
}
 
// Remote Proxy Implementation
class InventoryServiceProxy implements InventoryService {
    private readonly requestTimeout = 30000; // 30 seconds
    private readonly maxRetries = 3;
    
    // Circuit breaker state
    private failureCount = 0;
    private lastFailureTime = 0;
    private circuitOpen = false;
    private readonly failureThreshold = 5;
    private readonly resetTimeout = 60000; // 1 minute
    
    constructor(
        private readonly serviceUrl: string,
        private readonly loadBalancer: LoadBalancer,
        private readonly connectionPool: ConnectionPool
    ) {}
    
    // ===== PUBLIC INTERFACE METHODS =====
    
    async checkStock(productId: string): Promise<StockInfo> {
        return this.callRemote<StockInfo>('checkStock', [productId]);
    }
    
    async getProduct(productId: string): Promise<Product | null> {
        return this.callRemote<Product | null>('getProduct', [productId]);
    }
    
    async searchProducts(criteria: SearchCriteria): Promise<ProductSearchResult> {
        return this.callRemote<ProductSearchResult>('searchProducts', [criteria]);
    }
    
    async reserveStock(productId: string, quantity: number): Promise<ReservationResult> {
        // Mutations don't retry to avoid duplicates
        return this.callRemote<ReservationResult>(
            'reserveStock', 
            [productId, quantity],
            { retryable: false }
        );
    }
    
    async releaseReservation(reservationId: string): Promise<void> {
        await this.callRemote<void>('releaseReservation', [reservationId]);
    }
    
    async updateStock(
        productId: string, 
        delta: number, 
        reason: string
    ): Promise<StockInfo> {
        return this.callRemote<StockInfo>(
            'updateStock', 
            [productId, delta, reason],
            { retryable: false }
        );
    }
    
    // ===== REMOTE CALL INFRASTRUCTURE =====
    
    private async callRemote<T>(
        method: string, 
        params: unknown[],
        options: { retryable?: boolean } = {}
    ): Promise<T> {
        const { retryable = true } = options;
        
        // Check circuit breaker
        if (this.isCircuitOpen()) {
            throw new ServiceUnavailableError(
                `Inventory service circuit breaker open. Try again later.`
            );
        }
        
        const request: RpcRequest = {
            id: generateRequestId(),
            method,
            params,
            timestamp: Date.now(),
        };
        
        let lastError: Error | null = null;
        const attempts = retryable ? this.maxRetries : 1;
        
        for (let attempt = 1; attempt <= attempts; attempt++) {
            try {
                const response = await this.sendRequest<T>(request);
                
                // Success - reset circuit breaker
                this.recordSuccess();
                
                return response;
                
            } catch (error) {
                lastError = error as Error;
                console.warn(`[RemoteProxy] Attempt ${attempt} failed: ${lastError.message}`);
                
                // Don't retry non-retryable operations
                if (!retryable || !this.isRetryableError(error)) {
                    break;
                }
                
                // Exponential backoff
                if (attempt < attempts) {
                    const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
                    await this.sleep(delay);
                }
            }
        }
        
        // Record failure for circuit breaker
        this.recordFailure();
        
        throw new RemoteCallError(
            `Remote call to ${method} failed after ${attempts} attempts`,
            lastError
        );
    }
    
    private async sendRequest<T>(request: RpcRequest): Promise<T> {
        // Get connection from pool
        const connection = await this.connectionPool.acquire();
        
        try {
            // Select server via load balancer
            const server = await this.loadBalancer.selectServer();
            
            // Serialize request
            const serialized = JSON.stringify(request);
            
            // Send with timeout
            const responsePromise = connection.send(server, serialized);
            const timeoutPromise = this.createTimeout(request.id);
            
            const rawResponse = await Promise.race([
                responsePromise,
                timeoutPromise,
            ]) as string;
            
            // Deserialize response
            const response = JSON.parse(rawResponse) as RpcResponse<T>;
            
            // Check for RPC-level errors
            if (response.error) {
                throw new RpcCallError(
                    response.error.code,
                    response.error.message,
                    response.error.data
                );
            }
            
            return response.result as T;
            
        } finally {
            // Always return connection to pool
            this.connectionPool.release(connection);
        }
    }
    
    // ===== CIRCUIT BREAKER =====
    
    private isCircuitOpen(): boolean {
        if (!this.circuitOpen) {
            return false;
        }
        
        // Check if reset timeout has passed
        if (Date.now() - this.lastFailureTime > this.resetTimeout) {
            console.log('[RemoteProxy] Circuit breaker half-open, allowing test request');
            this.circuitOpen = false;
            this.failureCount = 0;
            return false;
        }
        
        return true;
    }
    
    private recordSuccess(): void {
        this.failureCount = 0;
        this.circuitOpen = false;
    }
    
    private recordFailure(): void {
        this.failureCount++;
        this.lastFailureTime = Date.now();
        
        if (this.failureCount >= this.failureThreshold) {
            console.error(`[RemoteProxy] Circuit breaker opened after ${this.failureCount} failures`);
            this.circuitOpen = true;
        }
    }
    
    // ===== UTILITIES =====
    
    private isRetryableError(error: unknown): boolean {
        if (error instanceof RpcCallError) {
            // Don't retry business logic errors
            return error.code >= 500; // Only server errors
        }
        // Network errors are retryable
        return error instanceof NetworkError || error instanceof TimeoutError;
    }
    
    private createTimeout(requestId: string): Promise<never> {
        return new Promise((_, reject) => {
            setTimeout(() => {
                reject(new TimeoutError(`Request ${requestId} timed out`));
            }, this.requestTimeout);
        });
    }
    
    private sleep(ms: number): Promise<void> {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
}

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

// Caching Proxy with TTL and cache invalidation
class CachingServiceProxy<T extends object> {
    private cache: Map<string, CacheEntry<unknown>> = new Map();
    
    constructor(
        private readonly realService: T,
        private readonly defaultTTL: number = 60000, // 1 minute
        private readonly maxCacheSize: number = 1000
    ) {
        return this.createProxy();
    }
    
    private createProxy(): T {
        return new Proxy(this.realService, {
            get: (target, prop, receiver) => {
                const value = Reflect.get(target, prop, receiver);
                
                if (typeof value !== 'function') {
                    return value;
                }
                
                // Return wrapped function that checks cache
                return async (...args: unknown[]) => {
                    const cacheKey = this.buildCacheKey(prop as string, args);
                    
                    // Check cache
                    const cached = this.getFromCache(cacheKey);
                    if (cached !== undefined) {
                        console.log(`[Cache] HIT: ${cacheKey}`);
                        return cached;
                    }
                    
                    // Cache miss - call real service
                    console.log(`[Cache] MISS: ${cacheKey}`);
                    const result = await value.apply(target, args);
                    
                    // Store in cache
                    this.setInCache(cacheKey, result);
                    
                    return result;
                };
            }
        }) as T;
    }
    
    private buildCacheKey(method: string, args: unknown[]): string {
        return `${method}:${JSON.stringify(args)}`;
    }
    
    private getFromCache(key: string): unknown | undefined {
        const entry = this.cache.get(key);
        
        if (!entry) return undefined;
        
        if (Date.now() > entry.expiresAt) {
            this.cache.delete(key);
            return undefined;
        }
        
        return entry.value;
    }
    
    private setInCache(key: string, value: unknown, ttl?: number): void {
        // Evict oldest entries if at capacity
        if (this.cache.size >= this.maxCacheSize) {
            const oldestKey = this.cache.keys().next().value;
            this.cache.delete(oldestKey);
        }
        
        this.cache.set(key, {
            value,
            expiresAt: Date.now() + (ttl ?? this.defaultTTL),
            createdAt: Date.now(),
        });
    }
    
    // Public cache management methods
    invalidate(pattern?: string): void {
        if (!pattern) {
            this.cache.clear();
            return;
        }
        
        for (const key of this.cache.keys()) {
            if (key.includes(pattern)) {
                this.cache.delete(key);
            }
        }
    }
    
    getStats(): CacheStats {
        return {
            size: this.cache.size,
            maxSize: this.maxCacheSize,
        };
    }
}
 
interface CacheEntry<T> {
    value: T;
    expiresAt: number;
    createdAt: number;
}
 
// Usage
const weatherService = new CachingServiceProxy(
    new RealWeatherService(),
    300000 // 5 minute TTL for weather data
);
 
// First call hits API
const weather1 = await weatherService.getCurrentWeather('NYC');
 
// Second call returns cached result instantly
const weather2 = await weatherService.getCurrentWeather('NYC');

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// Comprehensive logging proxy with performance metrics
function createLoggingProxy<T extends object>(
    target: T,
    serviceName: string,
    options: LoggingOptions = {}
): T {
    const {
        logLevel = 'info',
        includeArgs = true,
        includeResult = false,
        performanceThresholdMs = 1000,
    } = options;
    
    return new Proxy(target, {
        get(obj, prop, receiver) {
            const value = Reflect.get(obj, prop, receiver);
            
            if (typeof value !== 'function') {
                return value;
            }
            
            return function(...args: unknown[]) {
                const callId = generateCallId();
                const methodName = String(prop);
                const startTime = performance.now();
                
                // Log entry
                Logger[logLevel]({
                    event: 'method_call_start',
                    callId,
                    service: serviceName,
                    method: methodName,
                    args: includeArgs ? sanitizeArgs(args) : undefined,
                    timestamp: new Date().toISOString(),
                });
                
                try {
                    const result = value.apply(obj, args);
                    
                    // Handle promises
                    if (result instanceof Promise) {
                        return result
                            .then(asyncResult => {
                                logSuccess(callId, methodName, startTime, asyncResult);
                                return asyncResult;
                            })
                            .catch(error => {
                                logError(callId, methodName, startTime, error);
                                throw error;
                            });
                    }
                    
                    // Synchronous result
                    logSuccess(callId, methodName, startTime, result);
                    return result;
                    
                } catch (error) {
                    logError(callId, methodName, startTime, error as Error);
                    throw error;
                }
            };
            
            function logSuccess(
                callId: string, 
                method: string, 
                startTime: number,
                result: unknown
            ): void {
                const duration = performance.now() - startTime;
                
                const entry = {
                    event: 'method_call_success',
                    callId,
                    service: serviceName,
                    method,
                    durationMs: Math.round(duration * 100) / 100,
                    result: includeResult ? sanitizeResult(result) : undefined,
                };
                
                if (duration > performanceThresholdMs) {
                    Logger.warn({
                        ...entry,
                        slow: true,
                        threshold: performanceThresholdMs,
                    });
                } else {
                    Logger[logLevel](entry);
                }
            }
            
            function logError(
                callId: string,
                method: string,
                startTime: number,
                error: Error
            ): void {
                Logger.error({
                    event: 'method_call_error',
                    callId,
                    service: serviceName,
                    method,
                    durationMs: Math.round((performance.now() - startTime) * 100) / 100,
                    error: {
                        name: error.name,
                        message: error.message,
                        stack: error.stack,
                    },
                });
            }
        }
    }) as T;
}
 
// Usage - wrap any service with comprehensive logging
const orderService = createLoggingProxy(
    new OrderService(),
    'OrderService',
    {
        logLevel: 'debug',
        performanceThresholdMs: 500,
    }
);
 
// All calls now automatically logged
await orderService.createOrder(order);
// Logs: { event: 'method_call_start', service: 'OrderService', method: 'createOrder', ... }
// Logs: { event: 'method_call_success', durationMs: 42.35, ... }

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

// Combining multiple proxy types
function createProductService(user: User): ProductService {
    // Layer 1: Remote proxy handles network communication
    const remoteProxy = new ProductServiceRemoteProxy(
        'https://products.api.internal:8080'
    );
    
    // Layer 2: Caching proxy adds performance optimization
    const cachingProxy = new CachingServiceProxy(
        remoteProxy,
        60000 // 1 minute cache
    );
    
    // Layer 3: Protection proxy adds security (outermost layer)
    const protectionProxy = new ProductServiceSecurityProxy(
        cachingProxy,
        user
    );
    
    return protectionProxy;
}
 
// Client uses simple interface, unaware of all the infrastructure
const productService = createProductService(currentUser);
const product = await productService.getProduct('SKU-123');
 
// Behind the scenes:
// 1. Protection proxy checks user.canRead('products')
// 2. Caching proxy checks if 'SKU-123' is cached
// 3. If not cached, remote proxy makes HTTP call with retry/circuit breaker
// 4. Result flows back through layers, getting cached along the way