2nd/10_Wiki/Topics/Domain_Programming/Architecture/복잡한 비즈니스 도메인 (금융 헬스케어 이커머스 등).md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-복잡한-비즈니스-도메인-금융-헬스케어-이커머스-등	복잡한 비즈니스 도메인 (금융, 헬스케어, 이커머스 등)	10_Wiki/Topics	verified	self	Complex Business Domains Domain-Heavy Systems	none	A	0.9	applied	domain-driven-design business-domain architecture ddd		2026-05-10	pending	language framework TypeScript NestJS / Spring Boot

복잡한 비즈니스 도메인 (금융, 헬스케어, 이커머스)

매 한 줄

"매 복잡한 도메인은 코드의 형태가 아니라 도메인 모델의 형태로 정복된다". 매 금융, 헬스케어, 이커머스는 각각 규제, 정확성, 동시성 압력이 다르며 매 DDD bounded context + invariant enforcement + event sourcing 이 2026 의 default approach.

매 핵심

매 도메인별 압력

• 금융: 매 정확성 (decimal arithmetic, no float), audit trail, regulatory (SOX, MiFID II, Basel III, K-AML), idempotency.
• 헬스케어: 매 PHI privacy (HIPAA, GDPR Art.9, K-MyData), HL7/FHIR interoperability, clinical decision support, audit immutability.
• 이커머스: 매 inventory consistency, payment idempotency, fraud detection, peak-load (Black Friday) elasticity, multi-currency/tax.

매 공통 architectural pillars

• Bounded Context: 매 Order, Payment, Inventory, Patient, Claim 의 명확한 ownership boundaries.
• Aggregate root + invariants: 매 transactional consistency unit, business rule enforcement.
• Event Sourcing + CQRS: 매 audit trail + read/write workload split.
• Sagas / Process Managers: 매 distributed transaction 대신 compensating actions.
• Anti-corruption layer: 매 legacy 시스템 (COBOL, HL7v2, EDI) 과의 격리.

매 응용

1. 매 금융: 매 ledger as append-only event log, double-entry bookkeeping, eventual consistency 위 strong invariants.
2. 매 헬스케어: 매 FHIR resource model + consent management + audit per-field-access.
3. 매 이커머스: 매 inventory reservation saga + payment authorization/capture + outbox pattern.

💻 패턴

Decimal money (금융)

import Decimal from 'decimal.js';

class Money {
  constructor(readonly amount: Decimal, readonly currency: string) {}
  static of(amount: string, currency: string) {
    return new Money(new Decimal(amount), currency);
  }
  add(other: Money): Money {
    if (other.currency !== this.currency) throw new Error('currency mismatch');
    return new Money(this.amount.plus(other.amount), this.currency);
  }
  // never use number — IEEE-754 binary float ruins cents
}

Aggregate with invariants (이커머스)

class Order {
  private items: OrderItem[] = [];
  private status: 'draft'|'placed'|'paid'|'fulfilled'|'cancelled' = 'draft';

  addItem(productId: string, qty: number, unitPrice: Money) {
    if (this.status !== 'draft') throw new Error('cannot modify placed order');
    if (qty <= 0) throw new Error('qty>0');
    this.items.push(new OrderItem(productId, qty, unitPrice));
  }

  place(): OrderPlaced {
    if (this.items.length === 0) throw new Error('empty order');
    this.status = 'placed';
    return { type: 'OrderPlaced', orderId: this.id, total: this.total() };
  }
}

Saga: payment + inventory (이커머스)

async function placeOrderSaga(orderId: string) {
  const reservation = await inventory.reserve(orderId);
  try {
    const payment = await payments.authorize(orderId);
    try {
      await inventory.commit(reservation.id);
      await payments.capture(payment.id);
    } catch (e) {
      await payments.void(payment.id);
      await inventory.release(reservation.id);
      throw e;
    }
  } catch (e) {
    await inventory.release(reservation.id);
    throw e;
  }
}

Event sourcing (금융 ledger)

type LedgerEvent =
  | { type: 'AccountOpened', accountId: string, currency: string }
  | { type: 'Debited', accountId: string, amount: string, txId: string }
  | { type: 'Credited', accountId: string, amount: string, txId: string };

function reduce(events: LedgerEvent[]): Account {
  return events.reduce((acc, e) => {
    if (e.type === 'AccountOpened') return { ...acc, currency: e.currency, balance: new Decimal(0) };
    if (e.type === 'Debited') return { ...acc, balance: acc.balance.minus(e.amount) };
    if (e.type === 'Credited') return { ...acc, balance: acc.balance.plus(e.amount) };
    return acc;
  }, {} as Account);
}

FHIR resource (헬스케어)

interface Patient {
  resourceType: 'Patient';
  id: string;
  identifier: Array<{ system: string; value: string }>;
  name: HumanName[];
  birthDate: string;            // ISO8601
  consent?: Reference<Consent>; // K-MyData / HIPAA consent linkage
}

Outbox pattern (이커머스 reliability)

await db.transaction(async tx => {
  await tx.insert('orders', order);
  await tx.insert('outbox', {
    id: ulid(),
    aggregateId: order.id,
    type: 'OrderPlaced',
    payload: JSON.stringify(event),
    createdAt: new Date(),
  });
});
// async outbox poller publishes to Kafka — at-least-once delivery

Anti-corruption layer (legacy HL7v2 → FHIR)

class HL7v2ToFhirAdapter {
  translate(adt: Hl7v2Message): Patient {
    const pid = adt.segment('PID');
    return {
      resourceType: 'Patient',
      id: pid.field(3).value(),
      name: [{ family: pid.field(5).component(1), given: [pid.field(5).component(2)] }],
      birthDate: this.parseHl7Date(pid.field(7).value()),
      identifier: [{ system: 'urn:hospital:mrn', value: pid.field(3).value() }],
    };
  }
}

Idempotency key (payments)

async function charge(req: ChargeRequest, idempotencyKey: string) {
  const existing = await db.idempotency.findOne({ key: idempotencyKey });
  if (existing) return existing.response;
  const result = await processor.charge(req);
  await db.idempotency.insert({ key: idempotencyKey, response: result, ttl: '24h' });
  return result;
}

매 결정 기준

상황	Approach
금융 ledger	Event sourcing + double-entry
헬스케어 record	FHIR + consent + audit log
이커머스 order flow	Saga + outbox + idempotency
Cross-domain integration	Anti-corruption layer
Strong invariant	Aggregate boundary, single-writer
High read throughput	CQRS read model

기본값: 매 Bounded Context first, Aggregate + invariants second, Events as integration third.

🔗 Graph

• 부모: Domain-Driven Design · Bounded_Context
• 변형: Event Sourcing · CQRS
• 응용: 이커머스의 실시간 재고 관리 · 엔터프라이즈 소프트웨어 개발
• Adjacent: ACID Transactions · 비기능 요구사항 (Non-functional Requirements)

🤖 LLM 활용

언제: 매 도메인 모델링, invariant 추출, ubiquitous language 정리, regulatory mapping (HIPAA → field-level access policy). 언제 X: 매 specific compliance interpretation (변호사·CISO 검토 필수), 매 production money handling (independent audit 필요).

❌ 안티패턴

• Anonymic domain model: 매 getter/setter 만 있는 비즈니스 로직 없는 entity → service 비대화.
• Float for money: 매 0.1 + 0.2 ≠ 0.3 의 IEEE-754 catastrophe.
• Distributed transaction (2PC): 매 micro-services 간 2PC → coordinator deadlock + low availability.
• One DB for all bounded contexts: 매 schema coupling 으로 deploy lock-step.
• PHI in logs: 매 healthcare/finance 의 unmasked PII/PHI 가 log 에 → instant compliance breach.

🧪 검증 / 중복

• Verified (Evans "Domain-Driven Design", Vernon "Implementing DDD", FHIR R5 spec, ISO 20022).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — finance/healthcare/ecommerce DDD patterns 정리