{
  "tenantId": "tenant-001",
  "requestId": "req-20260702-001",
  "configurationSnapshotId": "cfgsnap-001",
  "customerId": "cust-001",
  "market": "ID",
  "channel": "DIRECT_SALES",
  "currency": "IDR",
  "pricingDate": "2026-07-02",
  "contractTermMonths": 24,
  "quantity": 10
}

{
  "pricingSnapshotId": "pricesnap-001",
  "currency": "IDR",
  "listTotal": "12000000.00",
  "discountTotal": "1200000.00",
  "netTotal": "10800000.00",
  "recurringMonthlyTotal": "450000.00",
  "oneTimeTotal": "0.00",
  "effectiveDate": "2026-07-02",
  "priceBookVersion": "PB-ID-2026-Q3-v4",
  "breakdown": []
}

public record Money(String currency, BigDecimal amount) {

    public Money {
        if (currency == null || !currency.matches("[A-Z]{3}")) {
            throw new IllegalArgumentException("currency must be ISO-like 3 uppercase letters");
        }
        if (amount == null) {
            throw new IllegalArgumentException("amount is required");
        }
        amount = amount.setScale(2, RoundingMode.HALF_UP);
    }

    public Money add(Money other) {
        requireSameCurrency(other);
        return new Money(currency, amount.add(other.amount));
    }

    public Money subtract(Money other) {
        requireSameCurrency(other);
        return new Money(currency, amount.subtract(other.amount));
    }

    public Money multiply(BigDecimal multiplier) {
        return new Money(currency, amount.multiply(multiplier));
    }

    private void requireSameCurrency(Money other) {
        if (!currency.equals(other.currency)) {
            throw new IllegalArgumentException("currency mismatch");
        }
    }
}

public interface CurrencyScalePolicy {
    int scaleOf(String currency);
    RoundingMode roundingModeOf(String currency);
}

create table price_book (
    price_book_id uuid primary key,
    tenant_id uuid not null,
    code text not null,
    version int not null,
    market text not null,
    channel text not null,
    customer_segment text,
    currency char(3) not null,
    effective_from date not null,
    effective_to date,
    status text not null,
    created_at timestamptz not null default now(),
    published_at timestamptz,
    unique (tenant_id, code, version),
    check (status in ('DRAFT', 'PUBLISHED', 'RETIRED', 'CANCELLED')),
    check (effective_to is null or effective_to >= effective_from)
);

create index idx_price_book_resolution
    on price_book (tenant_id, market, channel, currency, status, effective_from desc);

create table price_entry (
    price_entry_id uuid primary key,
    tenant_id uuid not null,
    price_book_id uuid not null references price_book(price_book_id),
    item_ref_type text not null,
    item_ref_id text not null,
    charge_type text not null,
    charge_period text,
    charge_basis text not null,
    unit_amount numeric(19, 4) not null,
    min_quantity numeric(19, 4),
    max_quantity numeric(19, 4),
    metadata jsonb not null default '{}'::jsonb,
    created_at timestamptz not null default now(),
    check (item_ref_type in ('OFFER', 'COMPONENT', 'OPTION', 'ATTRIBUTE')),
    check (charge_type in ('ONE_TIME', 'RECURRING', 'USAGE_ESTIMATED', 'ADJUSTMENT', 'CREDIT')),
    check (charge_basis in ('FLAT', 'PER_UNIT', 'PER_USER', 'TIERED_VOLUME', 'TIERED_GRADUATED', 'PERCENTAGE'))
);

create index idx_price_entry_lookup
    on price_entry (tenant_id, price_book_id, item_ref_type, item_ref_id);

public record PricingContext(
    UUID tenantId,
    String market,
    String channel,
    String customerSegment,
    String currency,
    LocalDate pricingDate,
    int contractTermMonths
) {}

public interface PricingPipeline {
    PricingResult calculate(PricingRequest request);
}

public record PricingRequest(
    UUID tenantId,
    UUID requestId,
    UUID configurationSnapshotId,
    UUID customerId,
    PricingContext context,
    List<SelectedItem> selectedItems,
    List<RequestedDiscount> requestedDiscounts,
    List<ManualAdjustment> manualAdjustments
) {}

public record PricingResult(
    UUID pricingSnapshotId,
    UUID priceBookId,
    String priceBookVersion,
    String currency,
    List<PricedLine> lines,
    PriceTotals totals,
    List<PricingExplanation> explanations,
    List<ApprovalSignal> approvalSignals
) {}

discountStackingPolicy:
  sequence:
    - PROMOTION
    - CONTRACTUAL
    - SALES_DISCRETIONARY
    - MANUAL_OVERRIDE
  allowMultipleSameType: false
  maxEffectiveDiscountPercent: 35
  approvalThresholdPercent: 20

100 - 10% - 20 fixed = 70
100 - 20 fixed - 10% = 72

create table discount_policy (
    discount_policy_id uuid primary key,
    tenant_id uuid not null,
    code text not null,
    version int not null,
    discount_type text not null,
    discount_scope text not null,
    priority int not null,
    max_percent numeric(9, 4),
    requires_approval boolean not null default false,
    eligibility_expression jsonb not null default '{}'::jsonb,
    effective_from date not null,
    effective_to date,
    status text not null,
    unique (tenant_id, code, version),
    check (discount_type in ('PERCENTAGE', 'FIXED_AMOUNT', 'FREE_MONTHS', 'PRICE_OVERRIDE', 'PROMOTION')),
    check (discount_scope in ('LINE', 'BUNDLE', 'QUOTE', 'CHARGE_TYPE')),
    check (status in ('DRAFT', 'PUBLISHED', 'RETIRED'))
);

create table pricing_snapshot (
    pricing_snapshot_id uuid primary key,
    tenant_id uuid not null,
    request_id uuid not null,
    configuration_snapshot_id uuid not null,
    price_book_id uuid not null,
    price_book_version text not null,
    currency char(3) not null,
    list_total numeric(19, 4) not null,
    discount_total numeric(19, 4) not null,
    net_total numeric(19, 4) not null,
    estimated_tax_total numeric(19, 4),
    gross_total numeric(19, 4),
    contract_term_months int not null,
    pricing_date date not null,
    calculation_hash text not null,
    created_at timestamptz not null default now(),
    unique (tenant_id, request_id)
);

create table pricing_snapshot_line (
    pricing_snapshot_line_id uuid primary key,
    pricing_snapshot_id uuid not null references pricing_snapshot(pricing_snapshot_id),
    line_ref text not null,
    item_ref_type text not null,
    item_ref_id text not null,
    charge_type text not null,
    charge_period text,
    quantity numeric(19, 4) not null,
    unit_amount numeric(19, 4) not null,
    list_amount numeric(19, 4) not null,
    discount_amount numeric(19, 4) not null,
    net_amount numeric(19, 4) not null,
    explanation jsonb not null
);

public String calculationHash(PricingResult result) {
    String canonical = canonicalJson(result.withoutGeneratedIdsAndTimestamps());
    return sha256(canonical);
}

paths:
  /pricing/calculate:
    post:
      operationId: calculatePricing
      summary: Calculate pricing for a finalized configuration snapshot
      parameters:
        - name: Idempotency-Key
          in: header
          required: true
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CalculatePricingRequest'
      responses:
        '201':
          description: Pricing snapshot created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PricingSnapshot'
        '200':
          description: Existing pricing snapshot returned for same idempotency key
        '409':
          description: Conflicting idempotent request
        '422':
          description: Pricing cannot be calculated from provided input

  /pricing-snapshots/{pricingSnapshotId}/reprice-preview:
    post:
      operationId: previewRepricing
      summary: Preview repricing without mutating an accepted quote

@Path("/pricing")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public class PricingResource {

    private final PricingApplicationService pricingApplicationService;

    @POST
    @Path("/calculate")
    public Response calculate(
        @HeaderParam("Idempotency-Key") String idempotencyKey,
        CalculatePricingRequestDto request
    ) {
        CalculatePricingCommand command = CalculatePricingCommand.from(idempotencyKey, request);
        PricingSnapshotDto result = pricingApplicationService.calculate(command);
        return Response.status(result.reused() ? Response.Status.OK : Response.Status.CREATED)
            .entity(result)
            .build();
    }
}

<select id="findApplicablePriceBooks" resultMap="PriceBookRowMap">
    select *
    from price_book
    where tenant_id = #{tenantId}
      and market = #{market}
      and channel = #{channel}
      and currency = #{currency}
      and status = 'PUBLISHED'
      and effective_from <= #{pricingDate}
      and (effective_to is null or effective_to >= #{pricingDate})
      and (customer_segment = #{customerSegment} or customer_segment is null)
    order by
      case when customer_segment = #{customerSegment} then 0 else 1 end,
      version desc
</select>

<insert id="insertPricingSnapshot">
    insert into pricing_snapshot (
        pricing_snapshot_id,
        tenant_id,
        request_id,
        configuration_snapshot_id,
        price_book_id,
        price_book_version,
        currency,
        list_total,
        discount_total,
        net_total,
        estimated_tax_total,
        gross_total,
        contract_term_months,
        pricing_date,
        calculation_hash
    ) values (
        #{pricingSnapshotId},
        #{tenantId},
        #{requestId},
        #{configurationSnapshotId},
        #{priceBookId},
        #{priceBookVersion},
        #{currency},
        #{listTotal},
        #{discountTotal},
        #{netTotal},
        #{estimatedTaxTotal},
        #{grossTotal},
        #{contractTermMonths},
        #{pricingDate},
        #{calculationHash}
    )
</insert>

{
  "eventId": "evt-001",
  "eventType": "PricingCalculated",
  "eventVersion": 1,
  "tenantId": "tenant-001",
  "occurredAt": "2026-07-02T10:15:30Z",
  "aggregateType": "PricingSnapshot",
  "aggregateId": "pricesnap-001",
  "payload": {
    "pricingSnapshotId": "pricesnap-001",
    "configurationSnapshotId": "cfgsnap-001",
    "priceBookVersion": "PB-ID-2026-Q3-v4",
    "currency": "IDR",
    "listTotal": "12000000.00",
    "discountTotal": "1200000.00",
    "netTotal": "10800000.00",
    "approvalSignals": [
      {
        "code": "DISCOUNT_ABOVE_THRESHOLD",
        "severity": "APPROVAL_REQUIRED"
      }
    ]
  }
}

public record ApprovalSignal(
    String code,
    String severity,
    String message,
    Map<String, Object> evidence
) {}

create table pricing_idempotency_key (
    tenant_id uuid not null,
    idempotency_key text not null,
    request_hash text not null,
    pricing_snapshot_id uuid,
    status text not null,
    created_at timestamptz not null default now(),
    primary key (tenant_id, idempotency_key),
    check (status in ('IN_PROGRESS', 'COMPLETED', 'FAILED'))
);

pricing-golden/
  enterprise-internet-24m-standard-discount/
    input.json
    expected-output.json
  bundle-with-optional-components/
    input.json
    expected-output.json

{
  "event": "pricing_calculated",
  "tenantId": "tenant-001",
  "pricingSnapshotId": "pricesnap-001",
  "priceBookVersion": "PB-ID-2026-Q3-v4",
  "lineCount": 8,
  "approvalSignals": 1,
  "durationMs": 42
}