Deep Dive Protokol SOAP dan Kapan Menggunakannya Dibanding REST, GraphQL, atau 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="id">Jumlah pembayaran tidak valid</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>

import { Injectable, Logger } from '@nestjs/common';
import { randomUUID } from 'crypto';
 
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;
}
 
@Injectable()
export class PaymentService {
  private readonly logger = new Logger(PaymentService.name);
  private readonly processedPayments = new Map<string, ProcessPaymentResponse>();
 
  async processPayment(request: ProcessPaymentRequest): Promise<ProcessPaymentResponse> {
    this.logger.log(`Memproses pembayaran: ${JSON.stringify(request)}`);
 
    if (request.amount <= 0) {
      throw new Error('Jumlah harus lebih besar dari nol');
    }
 
    const validCurrencies = ['USD', 'EUR', 'IDR'];
    if (!validCurrencies.includes(request.currency)) {
      throw new Error(`Mata uang tidak valid: ${request.currency}`);
    }
 
    await this.simulateGatewayDelay();
 
    const authorizationCode = this.generateAuthCode();
 
    const response: ProcessPaymentResponse = {
      success: true,
      transactionId: request.transactionId,
      authorizationCode,
      timestamp: new Date(),
    };
 
    this.processedPayments.set(request.transactionId, response);
 
    this.logger.log(`Pembayaran berhasil diproses: ${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 { 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();
    }
    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 dipanggil');
              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' },
                },
              };
            }
          },
        },
      },
    };
 
    this.soapServer = soap.listen(null, '/soap/payment', serviceImplementation, wsdl);
    this.logger.log('SOAP server diinisialisasi');
  }
}

import * as soap from 'soap';
 
async function testPaymentService() {
  const url = 'http://localhost:3000/soap/payment';
  
  try {
    const client = await soap.createClientAsync(url);
    
    console.log('Metode tersedia:', Object.keys(client));
    
    console.log('\n--- Testing ProcessPayment ---');
    const paymentRequest = {
      parameters: {
        transactionId: 'TXN-' + Date.now(),
        amount: 99.99,
        currency: 'IDR',
        customerId: 'CUST-12345',
        paymentMethod: 'CREDIT_CARD',
      },
    };
    
    const paymentResult = await client.ProcessPaymentAsync(paymentRequest);
    console.log('Hasil Pembayaran:', JSON.stringify(paymentResult, null, 2));
    
  } catch (error) {
    console.error('Test gagal:', error);
  }
}
 
testPaymentService();

<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('Pembayaran gagal');

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

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

<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);
  
  // Simulasi integrasi payment gateway
  private readonly processedPayments = new Map<string, ProcessPaymentResponse>();
 
  async processPayment(
    request: ProcessPaymentRequest,
  ): Promise<ProcessPaymentResponse> {
    this.logger.log(`Memproses pembayaran: ${JSON.stringify(request)}`);
 
    // Validasi amount
    if (request.amount <= 0) {
      throw new Error('Jumlah harus lebih besar dari nol');
    }
 
    // Validasi currency
    const validCurrencies = ['USD', 'EUR', 'IDR', 'GBP'];
    if (!validCurrencies.includes(request.currency)) {
      throw new Error(`Mata uang tidak valid: ${request.currency}`);
    }
 
    // Simulasi panggilan payment gateway
    await this.simulateGatewayDelay();
 
    // Generate authorization code
    const authorizationCode = this.generateAuthCode();
 
    const response: ProcessPaymentResponse = {
      success: true,
      transactionId: request.transactionId,
      authorizationCode,
      timestamp: new Date(),
    };
 
    // Simpan untuk refund lookup
    this.processedPayments.set(request.transactionId, response);
 
    this.logger.log(`Pembayaran berhasil diproses: ${authorizationCode}`);
    return response;
  }
 
  async refundPayment(
    request: RefundPaymentRequest,
  ): Promise<RefundPaymentResponse> {
    this.logger.log(`Memproses refund: ${JSON.stringify(request)}`);
 
    // Verifikasi transaksi original ada
    const originalPayment = this.processedPayments.get(
      request.originalTransactionId,
    );
 
    if (!originalPayment) {
      throw new Error(
        `Transaksi original tidak ditemukan: ${request.originalTransactionId}`,
      );
    }
 
    // Validasi refund amount
    if (request.amount <= 0) {
      throw new Error('Jumlah refund harus lebih besar dari nol');
    }
 
    // Simulasi pemrosesan refund
    await this.simulateGatewayDelay();
 
    const response: RefundPaymentResponse = {
      success: true,
      refundId: randomUUID(),
      timestamp: new Date(),
    };
 
    this.logger.log(`Refund berhasil diproses: ${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 { 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);
  
  // Aktifkan XML body parsing untuk SOAP
  app.use(xmlparser());
  
  await app.listen(3000);
  console.log('SOAP Payment Service berjalan di http://localhost:3000');
  console.log('WSDL tersedia di http://localhost:3000/soap/payment');
}
bootstrap();

import * as soap from 'soap';
 
async function testPaymentService() {
  const url = 'http://localhost:3000/soap/payment';
  
  try {
    // Buat SOAP client
    const client = await soap.createClientAsync(url);
    
    console.log('Metode tersedia:', Object.keys(client));
    
    // Test ProcessPayment
    console.log('\n--- Testing ProcessPayment ---');
    const paymentRequest = {
      parameters: {
        transactionId: 'TXN-' + Date.now(),
        amount: 99.99,
        currency: 'IDR',
        customerId: 'CUST-12345',
        paymentMethod: 'CREDIT_CARD',
      },
    };
    
    const paymentResult = await client.ProcessPaymentAsync(paymentRequest);
    console.log('Hasil Pembayaran:', JSON.stringify(paymentResult, null, 2));
    
    // Test RefundPayment
    console.log('\n--- Testing RefundPayment ---');
    const refundRequest = {
      parameters: {
        originalTransactionId: paymentRequest.parameters.transactionId,
        amount: 99.99,
        reason: 'Customer meminta refund',
      },
    };
    
    const refundResult = await client.RefundPaymentAsync(refundRequest);
    console.log('Hasil Refund:', JSON.stringify(refundResult, null, 2));
    
    // Test error handling
    console.log('\n--- Testing Error Handling ---');
    try {
      await client.ProcessPaymentAsync({
        parameters: {
          transactionId: 'TXN-ERROR',
          amount: -10, // Amount tidak valid
          currency: 'IDR',
          customerId: 'CUST-12345',
          paymentMethod: 'CREDIT_CARD',
        },
      });
    } catch (error) {
      console.log('Error yang diharapkan:', error.message);
    }
    
  } catch (error) {
    console.error('Test gagal:', error);
  }
}
 
testPaymentService();

Metode tersedia: [ 'ProcessPayment', 'RefundPayment' ]
 
--- Testing ProcessPayment ---
Hasil Pembayaran: {
  "parameters": {
    "success": true,
    "transactionId": "TXN-1709395200000",
    "authorizationCode": "AUTH-1709395200123-X7K9P",
    "timestamp": "2026-03-02T10:00:00.000Z"
  }
}
 
--- Testing RefundPayment ---
Hasil Refund: {
  "parameters": {
    "success": true,
    "refundId": "550e8400-e29b-41d4-a716-446655440000",
    "timestamp": "2026-03-02T10:00:01.000Z"
  }
}
 
--- Testing Error Handling ---
Error yang diharapkan: Jumlah harus lebih besar dari nol

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')
      );
      
      // Cek umur token (maksimal 5 menit)
      const age = Date.now() - decoded.timestamp;
      if (age > 5 * 60 * 1000) {
        return false;
      }
      
      // Verifikasi 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 dan validasi WS-Security header
    const authHeader = req.headers['x-ws-security-token'];
    
    if (!authHeader || !this.security.validateToken(authHeader as string)) {
      this.logger.warn('Request SOAP tidak terotorisasi');
      res.status(401).send(this.createSoapFault('Tidak terotorisasi', '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>`;
  }
}

if (paymentFailed) {
  res.status(402).send(soapResponse); // Jangan lakukan ini
}

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>

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,
      });
 
      // Tambahkan 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 diinisialisasi');
    }
  }
 
  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(`Gagal mengambil saldo akun: ${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(`Memproses pembayaran: ${JSON.stringify(request)}`);
 
    // Validasi amount
    if (request.amount <= 0) {
      throw new Error('Jumlah harus lebih besar dari nol');
    }
 
    // Untuk bank transfers, verifikasi dana via SOAP call
    if (request.paymentMethod === 'BANK_TRANSFER') {
      const hasFunds = await this.bankClient.verifyFunds(
        request.customerId, // Menggunakan customerId sebagai account number untuk demo
        request.customerId,
        request.amount,
      );
 
      if (!hasFunds) {
        throw new Error('Dana tidak mencukupi di akun');
      }
 
      this.logger.log('Dana berhasil diverifikasi');
    }
 
    // Simulasi pemrosesan pembayaran
    await this.simulateGatewayDelay();
 
    const authorizationCode = this.generateAuthCode();
 
    const response: ProcessPaymentResponse = {
      success: true,
      transactionId: request.transactionId,
      authorizationCode,
      timestamp: new Date(),
    };
 
    this.logger.log(`Pembayaran berhasil diproses: ${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 menit
 
  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 memasuki state HALF_OPEN');
        this.state = CircuitState.HALF_OPEN;
      } else {
        throw new Error('Circuit breaker OPEN - service tidak tersedia');
      }
    }
 
    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 menutup setelah panggilan berhasil');
      this.state = CircuitState.CLOSED;
    }
  }
 
  private onFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
 
    if (this.failureCount >= this.failureThreshold) {
      this.logger.warn(`Circuit breaker membuka setelah ${this.failureCount} kegagalan`);
      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('harus mengembalikan saldo akun dengan sukses', async () => {
      const mockResponse = [{
        parameters: {
          accountNumber: 'ACC-12345',
          availableBalance: '1000.00',
          currency: 'IDR',
          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: 'IDR',
        lastUpdated: expect.any(Date),
      });
    });
 
    it('harus menangani SOAP faults', async () => {
      mockSoapClient.GetAccountBalanceAsync.mockRejectedValue(
        new Error('Akun tidak ditemukan')
      );
 
      await expect(
        client.getAccountBalance({
          accountNumber: 'INVALID',
          customerId: 'CUST-12345',
        })
      ).rejects.toThrow('Gagal mengambil saldo akun');
    });
  });
 
  describe('verifyFunds', () => {
    it('harus mengembalikan true ketika dana mencukupi', async () => {
      mockSoapClient.GetAccountBalanceAsync.mockResolvedValue([{
        parameters: {
          accountNumber: 'ACC-12345',
          availableBalance: '1000.00',
          currency: 'IDR',
          lastUpdated: '2026-03-02T10:00:00Z',
        },
      }]);
 
      const result = await client.verifyFunds('ACC-12345', 'CUST-12345', 500);
      expect(result).toBe(true);
    });
 
    it('harus mengembalikan false ketika dana tidak mencukupi', async () => {
      mockSoapClient.GetAccountBalanceAsync.mockResolvedValue([{
        parameters: {
          accountNumber: 'ACC-12345',
          availableBalance: '100.00',
          currency: 'IDR',
          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);
  
  // Aktifkan kompresi GZIP
  app.use(compression({
    filter: (req, res) => {
      if (req.headers['x-no-compression']) {
        return false;
      }
      return compression.filter(req, res);
    },
    threshold: 1024, // Hanya kompres response > 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 sekali
    return readFileSync(path, 'utf8');
  }
}

<soap:Body>
  <BatchRequest xmlns="http://example.com/payment">
    <Operations>
      <ProcessPayment>
        <transactionId>TXN-001</transactionId>
        <amount>100.00</amount>
      </ProcessPayment>
      <ProcessPayment>
        <transactionId>TXN-002</transactionId>
        <amount>200.00</amount>
      </ProcessPayment>
    </Operations>
  </BatchRequest>
</soap:Body>

import { Injectable, Logger } from '@nestjs/common';
 
@Injectable()
export class SoapLogger {
  private readonly logger = new Logger('SOAP');
 
  logRequest(operation: string, request: any, correlationId: string) {
    this.logger.log({
      event: 'soap_request',
      operation,
      correlationId,
      timestamp: new Date().toISOString(),
      requestSize: JSON.stringify(request).length,
    });
  }
 
  logResponse(operation: string, response: any, correlationId: string, duration: number) {
    this.logger.log({
      event: 'soap_response',
      operation,
      correlationId,
      timestamp: new Date().toISOString(),
      duration,
      responseSize: JSON.stringify(response).length,
      success: true,
    });
  }
 
  logError(operation: string, error: Error, correlationId: string, duration: number) {
    this.logger.error({
      event: 'soap_error',
      operation,
      correlationId,
      timestamp: new Date().toISOString(),
      duration,
      error: error.message,
      stack: error.stack,
    });
  }
}

import { Controller, Get } from '@nestjs/common';
import { BankSoapClient } from '../integrations/bank/bank-soap.client';
 
@Controller('health')
export class HealthController {
  constructor(private readonly bankClient: BankSoapClient) {}
 
  @Get()
  async check() {
    const checks = {
      status: 'ok',
      timestamp: new Date().toISOString(),
      services: {
        bankApi: await this.checkBankApi(),
      },
    };
 
    return checks;
  }
 
  private async checkBankApi(): Promise<{ status: string; latency?: number }> {
    const start = Date.now();
    try {
      await this.bankClient.initialize();
      return {
        status: 'healthy',
        latency: Date.now() - start,
      };
    } catch (error) {
      return {
        status: 'unhealthy',
        latency: Date.now() - start,
      };
    }
  }
}

import { Injectable } from '@nestjs/common';
import { Counter, Histogram, register } from 'prom-client';
 
@Injectable()
export class MetricsService {
  private readonly requestCounter = new Counter({
    name: 'soap_requests_total',
    help: 'Total number of SOAP requests',
    labelNames: ['operation', 'status'],
  });
 
  private readonly requestDuration = new Histogram({
    name: 'soap_request_duration_seconds',
    help: 'SOAP request duration in seconds',
    labelNames: ['operation'],
    buckets: [0.1, 0.5, 1, 2, 5],
  });
 
  recordRequest(operation: string, duration: number, success: boolean) {
    this.requestCounter.inc({
      operation,
      status: success ? 'success' : 'error',
    });
 
    this.requestDuration.observe({ operation }, duration / 1000);
  }
 
  async getMetrics(): Promise<string> {
    return register.metrics();
  }
}