SOAP Protocol Deep Dive and When to Use It Over REST, GraphQL, or gRPC

<?xml version="1.0"?>
<soap:Envelope 
  xmlns:soap="http://www.w3.org/2003/05/soap-envelope"
  xmlns:example="http://example.com/payment">
  
  <soap:Header>
    <example:Authentication>
      <example:Token>abc123xyz</example:Token>
    </example:Authentication>
  </soap:Header>
  
  <soap:Body>
    <example:ProcessPayment>
      <example:Amount>100.00</example:Amount>
      <example:Currency>USD</example:Currency>
    </example:ProcessPayment>
  </soap:Body>
</soap:Envelope>

<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
  <soap:Body>
    <soap:Fault>
      <soap:Code>
        <soap:Value>soap:Sender</soap:Value>
      </soap:Code>
      <soap:Reason>
        <soap:Text xml:lang="en">Invalid payment amount</soap:Text>
      </soap:Reason>
      <soap:Detail>
        <example:PaymentError>
          <example:ErrorCode>INVALID_AMOUNT</example:ErrorCode>
          <example:MinAmount>1.00</example:MinAmount>
        </example:PaymentError>
      </soap:Detail>
    </soap:Fault>
  </soap:Body>
</soap:Envelope>

<soap:Body>
  <ns:CreateOrder xmlns:ns="http://example.com/orders">
    <ns:Order>
      <ns:CustomerId>12345</ns:CustomerId>
      <ns:Items>
        <ns:Item>
          <ns:ProductId>ABC</ns:ProductId>
          <ns:Quantity>2</ns:Quantity>
        </ns:Item>
      </ns:Items>
    </ns:Order>
  </ns:CreateOrder>
</soap:Body>

<soap:Body>
  <ns:CreateOrder xmlns:ns="http://example.com/orders">
    <customerId xsi:type="xsd:int">12345</customerId>
    <items xsi:type="ns:ArrayOfItem">
      <item xsi:type="ns:Item">
        <productId xsi:type="xsd:string">ABC</productId>
        <quantity xsi:type="xsd:int">2</quantity>
      </item>
    </items>
  </ns:CreateOrder>
</soap:Body>

export enum PaymentMethod {
  CREDIT_CARD = 'CREDIT_CARD',
  DEBIT_CARD = 'DEBIT_CARD',
  BANK_TRANSFER = 'BANK_TRANSFER',
}
 
export interface ProcessPaymentRequest {
  transactionId: string;
  amount: number;
  currency: string;
  customerId: string;
  paymentMethod: PaymentMethod;
}
 
export interface ProcessPaymentResponse {
  success: boolean;
  transactionId: string;
  authorizationCode: string;
  timestamp: Date;
}
 
export interface RefundPaymentRequest {
  originalTransactionId: string;
  amount: number;
  reason: string;
}
 
export interface RefundPaymentResponse {
  success: boolean;
  refundId: string;
  timestamp: Date;
}

import { Injectable, Logger } from '@nestjs/common';
import {
  ProcessPaymentRequest,
  ProcessPaymentResponse,
  RefundPaymentRequest,
  RefundPaymentResponse,
} from './dto/payment.dto';
import { randomUUID } from 'crypto';
 
@Injectable()
export class PaymentService {
  private readonly logger = new Logger(PaymentService.name);
  
  // Simulate payment gateway integration
  private readonly processedPayments = new Map<string, ProcessPaymentResponse>();
 
  async processPayment(
    request: ProcessPaymentRequest,
  ): Promise<ProcessPaymentResponse> {
    this.logger.log(`Processing payment: ${JSON.stringify(request)}`);
 
    // Validate amount
    if (request.amount <= 0) {
      throw new Error('Amount must be greater than zero');
    }
 
    // Validate currency
    const validCurrencies = ['USD', 'EUR', 'GBP'];
    if (!validCurrencies.includes(request.currency)) {
      throw new Error(`Invalid currency: ${request.currency}`);
    }
 
    // Simulate payment gateway call
    await this.simulateGatewayDelay();
 
    // Generate authorization code
    const authorizationCode = this.generateAuthCode();
 
    const response: ProcessPaymentResponse = {
      success: true,
      transactionId: request.transactionId,
      authorizationCode,
      timestamp: new Date(),
    };
 
    // Store for refund lookup
    this.processedPayments.set(request.transactionId, response);
 
    this.logger.log(`Payment processed successfully: ${authorizationCode}`);
    return response;
  }
 
  async refundPayment(
    request: RefundPaymentRequest,
  ): Promise<RefundPaymentResponse> {
    this.logger.log(`Processing refund: ${JSON.stringify(request)}`);
 
    // Verify original transaction exists
    const originalPayment = this.processedPayments.get(
      request.originalTransactionId,
    );
 
    if (!originalPayment) {
      throw new Error(
        `Original transaction not found: ${request.originalTransactionId}`,
      );
    }
 
    // Validate refund amount
    if (request.amount <= 0) {
      throw new Error('Refund amount must be greater than zero');
    }
 
    // Simulate refund processing
    await this.simulateGatewayDelay();
 
    const response: RefundPaymentResponse = {
      success: true,
      refundId: randomUUID(),
      timestamp: new Date(),
    };
 
    this.logger.log(`Refund processed successfully: ${response.refundId}`);
    return response;
  }
 
  private generateAuthCode(): string {
    return `AUTH-${Date.now()}-${Math.random().toString(36).substring(7).toUpperCase()}`;
  }
 
  private async simulateGatewayDelay(): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, 100));
  }
}

import { Controller, Post, Req, Res, Get, Logger } from '@nestjs/common';
import { Request, Response } from 'express';
import * as soap from 'soap';
import { PaymentService } from './payment.service';
import { readFileSync } from 'fs';
import { join } from 'path';
 
@Controller('soap/payment')
export class PaymentSoapController {
  private readonly logger = new Logger(PaymentSoapController.name);
  private soapServer: soap.Server;
 
  constructor(private readonly paymentService: PaymentService) {}
 
  @Get()
  getWsdl(@Res() res: Response) {
    const wsdlPath = join(__dirname, '../../wsdl/payment-service.wsdl');
    const wsdl = readFileSync(wsdlPath, 'utf8');
    res.type('application/xml');
    res.send(wsdl);
  }
 
  @Post()
  async handleSoapRequest(@Req() req: Request, @Res() res: Response) {
    if (!this.soapServer) {
      await this.initializeSoapServer();
    }
 
    // Let soap library handle the request
    this.soapServer.emit('request', req, res);
  }
 
  private async initializeSoapServer() {
    const wsdlPath = join(__dirname, '../../wsdl/payment-service.wsdl');
    const wsdl = readFileSync(wsdlPath, 'utf8');
 
    const serviceImplementation = {
      PaymentService: {
        PaymentServicePort: {
          ProcessPayment: async (args: any) => {
            try {
              this.logger.log('SOAP ProcessPayment called');
              const request = args.parameters;
              const response = await this.paymentService.processPayment({
                transactionId: request.transactionId,
                amount: parseFloat(request.amount),
                currency: request.currency,
                customerId: request.customerId,
                paymentMethod: request.paymentMethod,
              });
 
              return {
                parameters: {
                  success: response.success,
                  transactionId: response.transactionId,
                  authorizationCode: response.authorizationCode,
                  timestamp: response.timestamp.toISOString(),
                },
              };
            } catch (error) {
              this.logger.error(`ProcessPayment error: ${error.message}`);
              throw {
                Fault: {
                  Code: {
                    Value: 'soap:Sender',
                  },
                  Reason: {
                    Text: error.message,
                  },
                  Detail: {
                    ErrorCode: 'PAYMENT_PROCESSING_ERROR',
                  },
                },
              };
            }
          },
 
          RefundPayment: async (args: any) => {
            try {
              this.logger.log('SOAP RefundPayment called');
              const request = args.parameters;
              const response = await this.paymentService.refundPayment({
                originalTransactionId: request.originalTransactionId,
                amount: parseFloat(request.amount),
                reason: request.reason,
              });
 
              return {
                parameters: {
                  success: response.success,
                  refundId: response.refundId,
                  timestamp: response.timestamp.toISOString(),
                },
              };
            } catch (error) {
              this.logger.error(`RefundPayment error: ${error.message}`);
              throw {
                Fault: {
                  Code: {
                    Value: 'soap:Sender',
                  },
                  Reason: {
                    Text: error.message,
                  },
                  Detail: {
                    ErrorCode: 'REFUND_PROCESSING_ERROR',
                  },
                },
              };
            }
          },
        },
      },
    };
 
    this.soapServer = soap.listen(null, '/soap/payment', serviceImplementation, wsdl);
    this.logger.log('SOAP server initialized');
  }
}

import { Module } from '@nestjs/common';
import { PaymentService } from './payment.service';
import { PaymentSoapController } from './payment-soap.controller';
 
@Module({
  controllers: [PaymentSoapController],
  providers: [PaymentService],
  exports: [PaymentService],
})
export class PaymentModule {}

import { Module } from '@nestjs/common';
import { PaymentModule } from './payment/payment.module';
 
@Module({
  imports: [PaymentModule],
})
export class AppModule {}

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as xmlparser from 'express-xml-bodyparser';
 
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  
  // Enable XML body parsing for SOAP
  app.use(xmlparser());
  
  await app.listen(3000);
  console.log('SOAP Payment Service running on http://localhost:3000');
  console.log('WSDL available at http://localhost:3000/soap/payment');
}
bootstrap();

import * as soap from 'soap';
 
async function testPaymentService() {
  const url = 'http://localhost:3000/soap/payment';
  
  try {
    // Create SOAP client
    const client = await soap.createClientAsync(url);
    
    console.log('Available methods:', Object.keys(client));
    
    // Test ProcessPayment
    console.log('\n--- Testing ProcessPayment ---');
    const paymentRequest = {
      parameters: {
        transactionId: 'TXN-' + Date.now(),
        amount: 99.99,
        currency: 'USD',
        customerId: 'CUST-12345',
        paymentMethod: 'CREDIT_CARD',
      },
    };
    
    const paymentResult = await client.ProcessPaymentAsync(paymentRequest);
    console.log('Payment Result:', JSON.stringify(paymentResult, null, 2));
    
    // Test RefundPayment
    console.log('\n--- Testing RefundPayment ---');
    const refundRequest = {
      parameters: {
        originalTransactionId: paymentRequest.parameters.transactionId,
        amount: 99.99,
        reason: 'Customer requested refund',
      },
    };
    
    const refundResult = await client.RefundPaymentAsync(refundRequest);
    console.log('Refund Result:', JSON.stringify(refundResult, null, 2));
    
    // Test error handling
    console.log('\n--- Testing Error Handling ---');
    try {
      await client.ProcessPaymentAsync({
        parameters: {
          transactionId: 'TXN-ERROR',
          amount: -10, // Invalid amount
          currency: 'USD',
          customerId: 'CUST-12345',
          paymentMethod: 'CREDIT_CARD',
        },
      });
    } catch (error) {
      console.log('Expected error:', error.message);
    }
    
  } catch (error) {
    console.error('Test failed:', error);
  }
}
 
testPaymentService();

Available methods: [ 'ProcessPayment', 'RefundPayment' ]
 
--- Testing ProcessPayment ---
Payment Result: {
  "parameters": {
    "success": true,
    "transactionId": "TXN-1709395200000",
    "authorizationCode": "AUTH-1709395200123-X7K9P",
    "timestamp": "2026-03-02T10:00:00.000Z"
  }
}
 
--- Testing RefundPayment ---
Refund Result: {
  "parameters": {
    "success": true,
    "refundId": "550e8400-e29b-41d4-a716-446655440000",
    "timestamp": "2026-03-02T10:00:01.000Z"
  }
}
 
--- Testing Error Handling ---
Expected error: Amount must be greater than zero

import * as crypto from 'crypto';
 
export class WsSecurityHandler {
  private readonly validTokens = new Set<string>();
 
  constructor(private readonly secretKey: string) {}
 
  generateToken(username: string): string {
    const timestamp = Date.now();
    const nonce = crypto.randomBytes(16).toString('base64');
    const digest = this.createDigest(username, timestamp, nonce);
    
    const token = Buffer.from(
      JSON.stringify({ username, timestamp, nonce, digest })
    ).toString('base64');
    
    this.validTokens.add(token);
    return token;
  }
 
  validateToken(token: string): boolean {
    try {
      const decoded = JSON.parse(
        Buffer.from(token, 'base64').toString('utf8')
      );
      
      // Check token age (5 minutes max)
      const age = Date.now() - decoded.timestamp;
      if (age > 5 * 60 * 1000) {
        return false;
      }
      
      // Verify digest
      const expectedDigest = this.createDigest(
        decoded.username,
        decoded.timestamp,
        decoded.nonce
      );
      
      return decoded.digest === expectedDigest;
    } catch {
      return false;
    }
  }
 
  private createDigest(username: string, timestamp: number, nonce: string): string {
    const data = `${username}:${timestamp}:${nonce}:${this.secretKey}`;
    return crypto.createHash('sha256').update(data).digest('base64');
  }
}

import { Controller, Post, Req, Res, Get, Logger, UnauthorizedException } from '@nestjs/common';
import { Request, Response } from 'express';
import * as soap from 'soap';
import { WsSecurityHandler } from './security/ws-security';
 
@Controller('soap/payment')
export class PaymentSoapController {
  private readonly logger = new Logger(PaymentSoapController.name);
  private soapServer: soap.Server;
  private readonly security: WsSecurityHandler;
 
  constructor(private readonly paymentService: PaymentService) {
    this.security = new WsSecurityHandler(process.env.WS_SECURITY_KEY || 'default-secret');
  }
 
  @Post()
  async handleSoapRequest(@Req() req: Request, @Res() res: Response) {
    // Extract and validate WS-Security header
    const authHeader = req.headers['x-ws-security-token'];
    
    if (!authHeader || !this.security.validateToken(authHeader as string)) {
      this.logger.warn('Unauthorized SOAP request');
      res.status(401).send(this.createSoapFault('Unauthorized', 'soap:Sender'));
      return;
    }
 
    if (!this.soapServer) {
      await this.initializeSoapServer();
    }
 
    this.soapServer.emit('request', req, res);
  }
 
  private createSoapFault(message: string, code: string): string {
    return `<?xml version="1.0"?>
      <soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
        <soap:Body>
          <soap:Fault>
            <soap:Code><soap:Value>${code}</soap:Value></soap:Code>
            <soap:Reason><soap:Text>${message}</soap:Text></soap:Reason>
          </soap:Fault>
        </soap:Body>
      </soap:Envelope>`;
  }
}

<soap:Body soap:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
  <m:GetPrice xmlns:m="http://example.com">
    <m:Item xsi:type="xsd:string">Widget</m:Item>
  </m:GetPrice>
</soap:Body>

<soap:Body>
  <GetPriceRequest xmlns="http://example.com">
    <Item>Widget</Item>
  </GetPriceRequest>
</soap:Body>

throw new Error('Payment failed');

throw {
  Fault: {
    Code: { Value: 'soap:Sender' },
    Reason: { Text: 'Payment failed' },
    Detail: { ErrorCode: 'INSUFFICIENT_FUNDS' }
  }
};

import { parseString } from 'xml2js';
import { validate } from 'xsd-schema-validator';
 
async function validateSoapRequest(xml: string, xsdPath: string): Promise<boolean> {
  try {
    const result = await validate(xml, xsdPath);
    return result.valid;
  } catch (error) {
    throw new Error(`Schema validation failed: ${error.message}`);
  }
}

if (paymentFailed) {
  res.status(402).send(soapResponse); // Don't do this
}

res.status(200).send(soapFaultResponse);

<ProcessPayment>
  <Amount>100</Amount>
</ProcessPayment>

<tns:ProcessPayment xmlns:tns="http://example.com/payment">
  <tns:Amount>100</tns:Amount>
</tns:ProcessPayment>

<definitions 
  targetNamespace="http://example.com/payment/v2"
  name="PaymentServiceV2">

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';
 
@Injectable()
export class SoapLoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    const startTime = Date.now();
    
    // Capture request body
    let requestBody = '';
    req.on('data', chunk => requestBody += chunk);
    
    // Capture response
    const originalSend = res.send;
    res.send = function(data) {
      const duration = Date.now() - startTime;
      
      console.log({
        timestamp: new Date().toISOString(),
        method: req.method,
        url: req.url,
        requestBody,
        responseBody: data,
        duration,
        statusCode: res.statusCode,
      });
      
      return originalSend.call(this, data);
    };
    
    next();
  }
}

import * as soap from 'soap';
 
export class SoapClientPool {
  private clients = new Map<string, soap.Client>();
 
  async getClient(wsdlUrl: string): Promise<soap.Client> {
    if (!this.clients.has(wsdlUrl)) {
      const client = await soap.createClientAsync(wsdlUrl, {
        connection: 'keep-alive',
        timeout: 30000,
      });
      this.clients.set(wsdlUrl, client);
    }
    return this.clients.get(wsdlUrl);
  }
}

@Injectable()
export class PaymentService {
  private readonly processedTransactions = new Map<string, ProcessPaymentResponse>();
 
  async processPayment(request: ProcessPaymentRequest): Promise<ProcessPaymentResponse> {
    // Check if already processed
    const existing = this.processedTransactions.get(request.transactionId);
    if (existing) {
      this.logger.log(`Returning cached result for ${request.transactionId}`);
      return existing;
    }
 
    // Process payment
    const response = await this.executePayment(request);
    
    // Cache result
    this.processedTransactions.set(request.transactionId, response);
    
    return response;
  }
}

const client = await soap.createClientAsync(wsdlUrl, {
  timeout: 30000, // 30 seconds for network
  connectionTimeout: 5000, // 5 seconds to establish connection
});
 
// Per-operation timeout
client.setTimeout(60000); // 60 seconds for long operations

import { Injectable } from '@nestjs/common';
 
@Injectable()
export class SoapMetricsService {
  private metrics = {
    totalRequests: 0,
    successfulRequests: 0,
    failedRequests: 0,
    averageResponseTime: 0,
    operationCounts: new Map<string, number>(),
  };
 
  recordRequest(operation: string, duration: number, success: boolean) {
    this.metrics.totalRequests++;
    
    if (success) {
      this.metrics.successfulRequests++;
    } else {
      this.metrics.failedRequests++;
    }
    
    // Update average response time
    this.metrics.averageResponseTime = 
      (this.metrics.averageResponseTime * (this.metrics.totalRequests - 1) + duration) 
      / this.metrics.totalRequests;
    
    // Track per-operation counts
    const count = this.metrics.operationCounts.get(operation) || 0;
    this.metrics.operationCounts.set(operation, count + 1);
  }
 
  getMetrics() {
    return {
      ...this.metrics,
      successRate: (this.metrics.successfulRequests / this.metrics.totalRequests) * 100,
    };
  }
}

import { Injectable, Logger } from '@nestjs/common';
import * as soap from 'soap';
 
export interface AccountBalanceRequest {
  accountNumber: string;
  customerId: string;
}
 
export interface AccountBalanceResponse {
  accountNumber: string;
  availableBalance: number;
  currency: string;
  lastUpdated: Date;
}
 
@Injectable()
export class BankSoapClient {
  private readonly logger = new Logger(BankSoapClient.name);
  private client: soap.Client;
  private readonly wsdlUrl = process.env.BANK_WSDL_URL || 'http://bank-api.example.com/soap?wsdl';
 
  async initialize() {
    if (!this.client) {
      this.client = await soap.createClientAsync(this.wsdlUrl, {
        timeout: 30000,
        connectionTimeout: 5000,
      });
 
      // Add WS-Security
      const wsSecurity = new soap.WSSecurity(
        process.env.BANK_USERNAME,
        process.env.BANK_PASSWORD,
        {
          hasTimeStamp: true,
          hasTokenCreated: true,
        }
      );
      this.client.setSecurity(wsSecurity);
 
      this.logger.log('Bank SOAP client initialized');
    }
  }
 
  async getAccountBalance(request: AccountBalanceRequest): Promise<AccountBalanceResponse> {
    await this.initialize();
 
    try {
      const result = await this.client.GetAccountBalanceAsync({
        parameters: {
          accountNumber: request.accountNumber,
          customerId: request.customerId,
        },
      });
 
      const response = result[0].parameters;
      
      return {
        accountNumber: response.accountNumber,
        availableBalance: parseFloat(response.availableBalance),
        currency: response.currency,
        lastUpdated: new Date(response.lastUpdated),
      };
    } catch (error) {
      this.logger.error(`Bank API error: ${error.message}`);
      throw new Error(`Failed to retrieve account balance: ${error.message}`);
    }
  }
 
  async verifyFunds(accountNumber: string, customerId: string, requiredAmount: number): Promise<boolean> {
    const balance = await this.getAccountBalance({ accountNumber, customerId });
    return balance.availableBalance >= requiredAmount;
  }
}

import { Injectable, Logger } from '@nestjs/common';
import {
  ProcessPaymentRequest,
  ProcessPaymentResponse,
} from './dto/payment.dto';
import { BankSoapClient } from '../integrations/bank/bank-soap.client';
import { randomUUID } from 'crypto';
 
@Injectable()
export class PaymentService {
  private readonly logger = new Logger(PaymentService.name);
 
  constructor(private readonly bankClient: BankSoapClient) {}
 
  async processPayment(
    request: ProcessPaymentRequest,
  ): Promise<ProcessPaymentResponse> {
    this.logger.log(`Processing payment: ${JSON.stringify(request)}`);
 
    // Validate amount
    if (request.amount <= 0) {
      throw new Error('Amount must be greater than zero');
    }
 
    // For bank transfers, verify funds via SOAP call
    if (request.paymentMethod === 'BANK_TRANSFER') {
      const hasFunds = await this.bankClient.verifyFunds(
        request.customerId, // Using customerId as account number for demo
        request.customerId,
        request.amount,
      );
 
      if (!hasFunds) {
        throw new Error('Insufficient funds in account');
      }
 
      this.logger.log('Funds verified successfully');
    }
 
    // Simulate payment processing
    await this.simulateGatewayDelay();
 
    const authorizationCode = this.generateAuthCode();
 
    const response: ProcessPaymentResponse = {
      success: true,
      transactionId: request.transactionId,
      authorizationCode,
      timestamp: new Date(),
    };
 
    this.logger.log(`Payment processed successfully: ${authorizationCode}`);
    return response;
  }
 
  private generateAuthCode(): string {
    return `AUTH-${Date.now()}-${Math.random().toString(36).substring(7).toUpperCase()}`;
  }
 
  private async simulateGatewayDelay(): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, 100));
  }
}

import { Injectable, Logger } from '@nestjs/common';
 
enum CircuitState {
  CLOSED = 'CLOSED',
  OPEN = 'OPEN',
  HALF_OPEN = 'HALF_OPEN',
}
 
@Injectable()
export class CircuitBreaker {
  private readonly logger = new Logger(CircuitBreaker.name);
  private state: CircuitState = CircuitState.CLOSED;
  private failureCount = 0;
  private lastFailureTime: number = 0;
  private readonly failureThreshold = 5;
  private readonly resetTimeout = 60000; // 1 minute
 
  async execute<T>(operation: () => Promise<T>): Promise<T> {
    if (this.state === CircuitState.OPEN) {
      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
        this.logger.log('Circuit breaker entering HALF_OPEN state');
        this.state = CircuitState.HALF_OPEN;
      } else {
        throw new Error('Circuit breaker is OPEN - service unavailable');
      }
    }
 
    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }
 
  private onSuccess() {
    this.failureCount = 0;
    if (this.state === CircuitState.HALF_OPEN) {
      this.logger.log('Circuit breaker closing after successful call');
      this.state = CircuitState.CLOSED;
    }
  }
 
  private onFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
 
    if (this.failureCount >= this.failureThreshold) {
      this.logger.warn(`Circuit breaker opening after ${this.failureCount} failures`);
      this.state = CircuitState.OPEN;
    }
  }
 
  getState(): CircuitState {
    return this.state;
  }
}

@Injectable()
export class BankSoapClient {
  private readonly logger = new Logger(BankSoapClient.name);
  private client: soap.Client;
  private readonly circuitBreaker = new CircuitBreaker();
 
  async getAccountBalance(request: AccountBalanceRequest): Promise<AccountBalanceResponse> {
    return this.circuitBreaker.execute(async () => {
      await this.initialize();
      
      const result = await this.client.GetAccountBalanceAsync({
        parameters: request,
      });
      
      return this.parseBalanceResponse(result);
    });
  }
}

import { Test, TestingModule } from '@nestjs/testing';
import { BankSoapClient } from './bank-soap.client';
import * as soap from 'soap';
 
jest.mock('soap');
 
describe('BankSoapClient', () => {
  let client: BankSoapClient;
  let mockSoapClient: any;
 
  beforeEach(async () => {
    mockSoapClient = {
      GetAccountBalanceAsync: jest.fn(),
      setSecurity: jest.fn(),
    };
 
    (soap.createClientAsync as jest.Mock).mockResolvedValue(mockSoapClient);
 
    const module: TestingModule = await Test.createTestingModule({
      providers: [BankSoapClient],
    }).compile();
 
    client = module.get<BankSoapClient>(BankSoapClient);
  });
 
  describe('getAccountBalance', () => {
    it('should return account balance successfully', async () => {
      const mockResponse = [{
        parameters: {
          accountNumber: 'ACC-12345',
          availableBalance: '1000.00',
          currency: 'USD',
          lastUpdated: '2026-03-02T10:00:00Z',
        },
      }];
 
      mockSoapClient.GetAccountBalanceAsync.mockResolvedValue(mockResponse);
 
      const result = await client.getAccountBalance({
        accountNumber: 'ACC-12345',
        customerId: 'CUST-12345',
      });
 
      expect(result).toEqual({
        accountNumber: 'ACC-12345',
        availableBalance: 1000.00,
        currency: 'USD',
        lastUpdated: expect.any(Date),
      });
    });
 
    it('should handle SOAP faults', async () => {
      mockSoapClient.GetAccountBalanceAsync.mockRejectedValue(
        new Error('Account not found')
      );
 
      await expect(
        client.getAccountBalance({
          accountNumber: 'INVALID',
          customerId: 'CUST-12345',
        })
      ).rejects.toThrow('Failed to retrieve account balance');
    });
  });
 
  describe('verifyFunds', () => {
    it('should return true when sufficient funds', async () => {
      mockSoapClient.GetAccountBalanceAsync.mockResolvedValue([{
        parameters: {
          accountNumber: 'ACC-12345',
          availableBalance: '1000.00',
          currency: 'USD',
          lastUpdated: '2026-03-02T10:00:00Z',
        },
      }]);
 
      const result = await client.verifyFunds('ACC-12345', 'CUST-12345', 500);
      expect(result).toBe(true);
    });
 
    it('should return false when insufficient funds', async () => {
      mockSoapClient.GetAccountBalanceAsync.mockResolvedValue([{
        parameters: {
          accountNumber: 'ACC-12345',
          availableBalance: '100.00',
          currency: 'USD',
          lastUpdated: '2026-03-02T10:00:00Z',
        },
      }]);
 
      const result = await client.verifyFunds('ACC-12345', 'CUST-12345', 500);
      expect(result).toBe(false);
    });
  });
});

npm run test

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import * as compression from 'compression';
 
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  
  // Enable GZIP compression
  app.use(compression({
    filter: (req, res) => {
      if (req.headers['x-no-compression']) {
        return false;
      }
      return compression.filter(req, res);
    },
    threshold: 1024, // Only compress responses > 1KB
  }));
  
  await app.listen(3000);
}
bootstrap();

import { createReadStream } from 'fs';
import { pipeline } from 'stream/promises';
 
@Get('large-report')
async getLargeReport(@Res() res: Response) {
  res.setHeader('Content-Type', 'application/soap+xml');
  
  const xmlStream = createReadStream('./large-report.xml');
  await pipeline(xmlStream, res);
}

@Injectable()
export class WsdlCacheService {
  private readonly cache = new Map<string, any>();
 
  async getWsdl(path: string): Promise<any> {
    if (!this.cache.has(path)) {
      const wsdl = await this.parseWsdl(path);
      this.cache.set(path, wsdl);
    }
    return this.cache.get(path);
  }
 
  private async parseWsdl(path: string): Promise<any> {
    // Parse WSDL once
    return readFileSync(path, 'utf8');
  }
}