SELECT q.quote_id,
       q.quote_number,
       q.status,
       q.customer_id,
       q.currency,
       q.total_amount_minor,
       q.created_at
FROM quote.quote q
WHERE q.tenant_id = #{tenantId}
  AND q.status = ANY(#{statuses})
  AND q.created_at >= #{createdFrom}
ORDER BY q.created_at DESC
LIMIT #{limit}

UPDATE quote SET status = 'ACCEPTED' WHERE quote_id = ?

UPDATE quote.quote
SET status = 'ACCEPTED',
    version = version + 1,
    accepted_at = #{acceptedAt},
    updated_at = #{now}
WHERE tenant_id = #{tenantId}
  AND quote_id = #{quoteId}
  AND status = 'APPROVED'
  AND version = #{expectedVersion}

services/quote-service/
  quote-api-contract/
    openapi/quote-api.yaml
    schemas/
  quote-domain/
    src/main/java/com/acme/cpq/quote/domain/
  quote-application/
    src/main/java/com/acme/cpq/quote/application/
  quote-persistence-mybatis/
    src/main/java/com/acme/cpq/quote/persistence/
    src/main/resources/mybatis/
    src/main/resources/sql/
  quote-app/
    src/main/java/com/acme/cpq/quote/app/

com.acme.cpq.quote.persistence
  config/
    DataSourceFactory.java
    MyBatisSqlSessionFactory.java
    TransactionManager.java
  mapper/
    QuoteMapper.java
    QuoteLineMapper.java
    QuoteSearchMapper.java
    IdempotencyMapper.java
    OutboxMapper.java
    AuditMapper.java
  row/
    QuoteRow.java
    QuoteLineRow.java
    QuoteChargeRow.java
    QuoteSnapshotRow.java
    IdempotencyRow.java
    OutboxRow.java
  repository/
    MyBatisQuoteRepository.java
    MyBatisIdempotencyRepository.java
    MyBatisOutboxRepository.java
  typehandler/
    UuidTypeHandler.java
    MoneyTypeHandler.java
    JsonbTypeHandler.java
    InstantTypeHandler.java
    QuoteStatusTypeHandler.java
  tx/
    TransactionBoundary.java
    SqlSessionUnitOfWork.java
  error/
    SqlErrorClassifier.java
    PersistenceExceptionMapper.java

package com.acme.cpq.quote.domain;

public final class Quote {
    private final QuoteId id;
    private final TenantId tenantId;
    private final QuoteStatus status;
    private final Version version;
    private final Money total;
    private final List<QuoteLine> lines;
    private final Instant expiresAt;

    public Quote accept(Instant now) {
        if (status != QuoteStatus.APPROVED) {
            throw new InvalidQuoteTransition(status, QuoteStatus.ACCEPTED);
        }
        if (!expiresAt.isAfter(now)) {
            throw new QuoteExpired(id);
        }
        return new Quote(id, tenantId, QuoteStatus.ACCEPTED, version.next(), total, lines, expiresAt);
    }
}

package com.acme.cpq.quote.persistence.row;

public record QuoteRow(
    UUID tenantId,
    UUID quoteId,
    String quoteNumber,
    String status,
    String currency,
    long totalAmountMinor,
    int currencyScale,
    int version,
    Instant createdAt,
    Instant updatedAt,
    Instant expiresAt
) {}

final class QuoteRowMapper {
    Quote toDomain(QuoteRow header, List<QuoteLineRow> lineRows, List<QuoteChargeRow> chargeRows) {
        var lines = lineRows.stream()
            .map(line -> toLine(line, chargesFor(line.lineId(), chargeRows)))
            .toList();

        return Quote.rehydrate(
            new TenantId(header.tenantId()),
            new QuoteId(header.quoteId()),
            QuoteStatus.valueOf(header.status()),
            Version.of(header.version()),
            Money.ofMinor(header.currency(), header.totalAmountMinor(), header.currencyScale()),
            lines,
            header.expiresAt()
        );
    }
}

public interface QuoteRepository {
    Optional<Quote> findById(TenantId tenantId, QuoteId quoteId);

    QuoteSaveResult saveDraft(Quote quote, ExpectedVersion expectedVersion);

    TransitionResult transitionStatus(
        TenantId tenantId,
        QuoteId quoteId,
        QuoteStatus from,
        QuoteStatus to,
        ExpectedVersion expectedVersion,
        Instant now
    );

    Page<QuoteSummary> search(QuoteSearchCriteria criteria, PageRequest pageRequest);
}

// buruk
List<QuoteRow> selectByStatus(String status);
int updateQuoteStatus(UUID quoteId, String status);

public interface QuoteMapper {
    QuoteRow findHeaderById(@Param("tenantId") UUID tenantId,
                            @Param("quoteId") UUID quoteId);

    List<QuoteLineRow> findLinesByQuoteId(@Param("tenantId") UUID tenantId,
                                           @Param("quoteId") UUID quoteId);

    int insertHeader(QuoteRow row);

    int updateHeaderIfVersionMatches(@Param("row") QuoteRow row,
                                     @Param("expectedVersion") int expectedVersion);

    int transitionStatus(@Param("tenantId") UUID tenantId,
                         @Param("quoteId") UUID quoteId,
                         @Param("fromStatus") String fromStatus,
                         @Param("toStatus") String toStatus,
                         @Param("expectedVersion") int expectedVersion,
                         @Param("now") Instant now);
}

src/main/resources/mybatis/mapper/QuoteMapper.xml
src/main/resources/mybatis/mapper/QuoteLineMapper.xml
src/main/resources/mybatis/mapper/OutboxMapper.xml
src/main/resources/mybatis/mapper/IdempotencyMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.acme.cpq.quote.persistence.mapper.QuoteMapper">

  <resultMap id="quoteHeaderResultMap" type="com.acme.cpq.quote.persistence.row.QuoteRow">
    <constructor>
      <arg column="tenant_id" javaType="java.util.UUID" />
      <arg column="quote_id" javaType="java.util.UUID" />
      <arg column="quote_number" javaType="java.lang.String" />
      <arg column="status" javaType="java.lang.String" />
      <arg column="currency" javaType="java.lang.String" />
      <arg column="total_amount_minor" javaType="long" />
      <arg column="currency_scale" javaType="int" />
      <arg column="version" javaType="int" />
      <arg column="created_at" javaType="java.time.Instant" />
      <arg column="updated_at" javaType="java.time.Instant" />
      <arg column="expires_at" javaType="java.time.Instant" />
    </constructor>
  </resultMap>

  <select id="findHeaderById" resultMap="quoteHeaderResultMap">
    SELECT tenant_id,
           quote_id,
           quote_number,
           status,
           currency,
           total_amount_minor,
           currency_scale,
           version,
           created_at,
           updated_at,
           expires_at
    FROM quote.quote
    WHERE tenant_id = #{tenantId}
      AND quote_id = #{quoteId}
  </select>

</mapper>

public Optional<Quote> findById(TenantId tenantId, QuoteId quoteId) {
    var header = quoteMapper.findHeaderById(tenantId.value(), quoteId.value());
    if (header == null) {
        return Optional.empty();
    }

    var lines = quoteLineMapper.findLinesByQuoteId(tenantId.value(), quoteId.value());
    var charges = quoteChargeMapper.findChargesByQuoteId(tenantId.value(), quoteId.value());
    var approvals = approvalMapper.findDecisionHistory(tenantId.value(), quoteId.value());

    return Optional.of(rowMapper.toDomain(header, lines, charges, approvals));
}

public record QuoteSummaryRow(
    UUID quoteId,
    String quoteNumber,
    String status,
    UUID customerId,
    String customerName,
    String currency,
    long totalAmountMinor,
    Instant createdAt,
    Instant expiresAt,
    int version
) {}

<select id="searchQuotes" resultMap="quoteSummaryResultMap">
  SELECT q.quote_id,
         q.quote_number,
         q.status,
         q.customer_id,
         c.display_name AS customer_name,
         q.currency,
         q.total_amount_minor,
         q.created_at,
         q.expires_at,
         q.version
  FROM quote.quote q
  JOIN customer.customer_projection c
    ON c.tenant_id = q.tenant_id
   AND c.customer_id = q.customer_id
  <where>
    q.tenant_id = #{criteria.tenantId}
    <if test="criteria.statuses != null and criteria.statuses.size() > 0">
      AND q.status IN
      <foreach item="status" collection="criteria.statuses" open="(" separator="," close=")">
        #{status}
      </foreach>
    </if>
    <if test="criteria.customerId != null">
      AND q.customer_id = #{criteria.customerId}
    </if>
    <if test="criteria.createdFrom != null">
      AND q.created_at &gt;= #{criteria.createdFrom}
    </if>
    <if test="criteria.createdTo != null">
      AND q.created_at &lt; #{criteria.createdTo}
    </if>
  </where>
  ORDER BY q.created_at DESC, q.quote_id DESC
  LIMIT #{page.limit}
</select>

ORDER BY ${sortBy} ${sortDirection}

public enum QuoteSortField {
    CREATED_AT("q.created_at"),
    EXPIRES_AT("q.expires_at"),
    TOTAL_AMOUNT("q.total_amount_minor"),
    QUOTE_NUMBER("q.quote_number");

    private final String sqlExpression;

    QuoteSortField(String sqlExpression) {
        this.sqlExpression = sqlExpression;
    }

    public String sqlExpression() {
        return sqlExpression;
    }
}

ORDER BY ${page.sortExpression} ${page.sortDirection}, q.quote_id DESC

public record QuoteId(UUID value) {
    public QuoteId {
        Objects.requireNonNull(value);
    }
}

quoteMapper.findHeaderById(tenantId.value(), quoteId.value());

public enum QuoteStatus {
    DRAFT,
    SUBMITTED,
    APPROVAL_PENDING,
    APPROVED,
    ACCEPTED,
    EXPIRED,
    CANCELLED
}

ALTER TABLE quote.quote
ADD CONSTRAINT quote_status_ck
CHECK (status IN (
  'DRAFT',
  'SUBMITTED',
  'APPROVAL_PENDING',
  'APPROVED',
  'ACCEPTED',
  'EXPIRED',
  'CANCELLED'
));

public final class JsonbTypeHandler extends BaseTypeHandler<JsonNode> {
    private final ObjectMapper objectMapper;

    public JsonbTypeHandler(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    @Override
    public void setNonNullParameter(
        PreparedStatement ps,
        int i,
        JsonNode parameter,
        JdbcType jdbcType
    ) throws SQLException {
        PGobject jsonObject = new PGobject();
        jsonObject.setType("jsonb");
        jsonObject.setValue(parameter.toString());
        ps.setObject(i, jsonObject);
    }

    @Override
    public JsonNode getNullableResult(ResultSet rs, String columnName) throws SQLException {
        String value = rs.getString(columnName);
        return parse(value);
    }

    @Override
    public JsonNode getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
        String value = rs.getString(columnIndex);
        return parse(value);
    }

    @Override
    public JsonNode getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
        String value = cs.getString(columnIndex);
        return parse(value);
    }

    private JsonNode parse(String value) throws SQLException {
        if (value == null) {
            return null;
        }
        try {
            return objectMapper.readTree(value);
        } catch (JsonProcessingException e) {
            throw new SQLException("Invalid JSONB payload", e);
        }
    }
}

currency CHAR(3) NOT NULL,
total_amount_minor BIGINT NOT NULL,
currency_scale SMALLINT NOT NULL,
CHECK (currency_scale >= 0 AND currency_scale <= 6)

public record Money(String currency, long amountMinor, int scale) {
    public Money {
        if (currency == null || !currency.matches("[A-Z]{3}")) {
            throw new IllegalArgumentException("Invalid currency");
        }
        if (scale < 0 || scale > 6) {
            throw new IllegalArgumentException("Invalid scale");
        }
    }
}

Money total = new Money(
    row.currency(),
    row.totalAmountMinor(),
    row.currencyScale()
);

public final class TransactionBoundary {
    private final SqlSessionFactory sqlSessionFactory;

    public <T> T required(Function<SqlSession, T> work) {
        try (SqlSession session = sqlSessionFactory.openSession(false)) {
            try {
                T result = work.apply(session);
                session.commit();
                return result;
            } catch (RuntimeException | Error e) {
                session.rollback();
                throw e;
            }
        }
    }
}

public AcceptQuoteResult accept(AcceptQuoteCommand command) {
    return tx.required(session -> {
        var quoteRepository = repositoryFactory.quoteRepository(session);
        var idempotencyRepository = repositoryFactory.idempotencyRepository(session);
        var outboxRepository = repositoryFactory.outboxRepository(session);

        var idem = idempotencyRepository.tryStart(command.idempotencyKey(), command.fingerprint());
        if (idem.isReplay()) {
            return idem.cachedResponse(AcceptQuoteResult.class);
        }

        var quote = quoteRepository.findById(command.tenantId(), command.quoteId())
            .orElseThrow(() -> new QuoteNotFound(command.quoteId()));

        var accepted = quote.accept(command.now());
        quoteRepository.saveAccepted(accepted, command.expectedVersion());

        outboxRepository.append(OutboxEvent.quoteAccepted(accepted));
        idempotencyRepository.complete(command.idempotencyKey(), AcceptQuoteResult.accepted(accepted.id()));

        return AcceptQuoteResult.accepted(accepted.id());
    });
}

CREATE TABLE quote.quote (
    tenant_id UUID NOT NULL,
    quote_id UUID NOT NULL,
    status TEXT NOT NULL,
    version INTEGER NOT NULL DEFAULT 0,
    updated_at TIMESTAMPTZ NOT NULL,
    PRIMARY KEY (tenant_id, quote_id)
);

<update id="updateHeaderIfVersionMatches">
  UPDATE quote.quote
  SET status = #{row.status},
      total_amount_minor = #{row.totalAmountMinor},
      version = version + 1,
      updated_at = #{row.updatedAt}
  WHERE tenant_id = #{row.tenantId}
    AND quote_id = #{row.quoteId}
    AND version = #{expectedVersion}
</update>

int updated = mapper.updateHeaderIfVersionMatches(row, expectedVersion.value());
if (updated != 1) {
    throw new OptimisticConcurrencyConflict(quote.id(), expectedVersion);
}

<update id="transitionStatus">
  UPDATE quote.quote
  SET status = #{toStatus},
      version = version + 1,
      updated_at = #{now}
  WHERE tenant_id = #{tenantId}
    AND quote_id = #{quoteId}
    AND status = #{fromStatus}
    AND version = #{expectedVersion}
</update>

public TransitionResult transitionStatus(
    TenantId tenantId,
    QuoteId quoteId,
    QuoteStatus from,
    QuoteStatus to,
    ExpectedVersion expectedVersion,
    Instant now
) {
    int updated = mapper.transitionStatus(
        tenantId.value(),
        quoteId.value(),
        from.name(),
        to.name(),
        expectedVersion.value(),
        now
    );

    if (updated == 1) {
        return TransitionResult.changed();
    }

    var current = mapper.findHeaderById(tenantId.value(), quoteId.value());
    if (current == null) {
        return TransitionResult.notFound();
    }
    if (current.version() != expectedVersion.value()) {
        return TransitionResult.versionConflict(current.version());
    }
    return TransitionResult.invalidState(current.status());
}

CREATE TABLE quote.idempotency_record (
    tenant_id UUID NOT NULL,
    idempotency_key TEXT NOT NULL,
    request_fingerprint TEXT NOT NULL,
    status TEXT NOT NULL,
    response_code INTEGER,
    response_body JSONB,
    created_at TIMESTAMPTZ NOT NULL,
    completed_at TIMESTAMPTZ,
    expires_at TIMESTAMPTZ NOT NULL,
    PRIMARY KEY (tenant_id, idempotency_key),
    CHECK (status IN ('STARTED', 'COMPLETED', 'FAILED'))
);

<insert id="insertIdempotencyStart">
  INSERT INTO quote.idempotency_record (
      tenant_id,
      idempotency_key,
      request_fingerprint,
      status,
      created_at,
      expires_at
  ) VALUES (
      #{tenantId},
      #{key},
      #{fingerprint},
      'STARTED',
      #{now},
      #{expiresAt}
  )
  ON CONFLICT (tenant_id, idempotency_key) DO NOTHING
</insert>

CREATE TABLE quote.outbox_event (
    tenant_id UUID NOT NULL,
    outbox_id UUID NOT NULL,
    aggregate_type TEXT NOT NULL,
    aggregate_id UUID NOT NULL,
    event_type TEXT NOT NULL,
    event_version INTEGER NOT NULL,
    event_key TEXT NOT NULL,
    payload JSONB NOT NULL,
    headers JSONB NOT NULL,
    status TEXT NOT NULL,
    attempts INTEGER NOT NULL DEFAULT 0,
    next_attempt_at TIMESTAMPTZ NOT NULL,
    created_at TIMESTAMPTZ NOT NULL,
    published_at TIMESTAMPTZ,
    PRIMARY KEY (tenant_id, outbox_id),
    CHECK (status IN ('PENDING', 'IN_PROGRESS', 'PUBLISHED', 'FAILED'))
);

<insert id="insertOutboxEvent">
  INSERT INTO quote.outbox_event (
      tenant_id,
      outbox_id,
      aggregate_type,
      aggregate_id,
      event_type,
      event_version,
      event_key,
      payload,
      headers,
      status,
      attempts,
      next_attempt_at,
      created_at
  ) VALUES (
      #{tenantId},
      #{outboxId},
      #{aggregateType},
      #{aggregateId},
      #{eventType},
      #{eventVersion},
      #{eventKey},
      #{payload,typeHandler=com.acme.cpq.quote.persistence.typehandler.JsonbTypeHandler},
      #{headers,typeHandler=com.acme.cpq.quote.persistence.typehandler.JsonbTypeHandler},
      'PENDING',
      0,
      #{createdAt},
      #{createdAt}
  )
</insert>

<select id="claimPendingEvents" resultMap="outboxResultMap">
  UPDATE quote.outbox_event
  SET status = 'IN_PROGRESS',
      attempts = attempts + 1,
      next_attempt_at = #{nextAttemptAt}
  WHERE (tenant_id, outbox_id) IN (
      SELECT tenant_id, outbox_id
      FROM quote.outbox_event
      WHERE status IN ('PENDING', 'FAILED')
        AND next_attempt_at &lt;= #{now}
      ORDER BY created_at ASC
      LIMIT #{limit}
      FOR UPDATE SKIP LOCKED
  )
  RETURNING tenant_id,
            outbox_id,
            aggregate_type,
            aggregate_id,
            event_type,
            event_version,
            event_key,
            payload,
            headers,
            attempts,
            created_at
</select>

CREATE TABLE order_mgmt.inbox_event (
    tenant_id UUID NOT NULL,
    consumer_name TEXT NOT NULL,
    message_id TEXT NOT NULL,
    event_type TEXT NOT NULL,
    event_key TEXT NOT NULL,
    processed_at TIMESTAMPTZ NOT NULL,
    PRIMARY KEY (tenant_id, consumer_name, message_id)
);

<insert id="insertInboxRecord">
  INSERT INTO order_mgmt.inbox_event (
      tenant_id,
      consumer_name,
      message_id,
      event_type,
      event_key,
      processed_at
  ) VALUES (
      #{tenantId},
      #{consumerName},
      #{messageId},
      #{eventType},
      #{eventKey},
      #{processedAt}
  )
  ON CONFLICT (tenant_id, consumer_name, message_id) DO NOTHING
</insert>

public final class SqlErrorClassifier {
    public PersistenceFailure classify(SQLException exception) {
        String sqlState = exception.getSQLState();
        return switch (sqlState) {
            case "23505" -> PersistenceFailure.uniqueViolation(exception);
            case "23503" -> PersistenceFailure.foreignKeyViolation(exception);
            case "23514" -> PersistenceFailure.checkViolation(exception);
            case "40001" -> PersistenceFailure.serializationFailure(exception);
            case "40P01" -> PersistenceFailure.deadlock(exception);
            default -> PersistenceFailure.unknown(exception);
        };
    }
}

<insert id="insertLines">
  INSERT INTO quote.quote_line (
      tenant_id,
      quote_id,
      line_id,
      line_number,
      product_id,
      product_version,
      quantity,
      status,
      created_at
  ) VALUES
  <foreach item="line" collection="lines" separator=",">
    (
      #{line.tenantId},
      #{line.quoteId},
      #{line.lineId},
      #{line.lineNumber},
      #{line.productId},
      #{line.productVersion},
      #{line.quantity},
      #{line.status},
      #{line.createdAt}
    )
  </foreach>
</insert>

CREATE UNIQUE INDEX quote_number_active_uq
ON quote.quote (tenant_id, quote_number)
WHERE deleted_at IS NULL;

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "https://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
  <settings>
    <setting name="mapUnderscoreToCamelCase" value="true" />
    <setting name="defaultStatementTimeout" value="5" />
    <setting name="jdbcTypeForNull" value="NULL" />
    <setting name="localCacheScope" value="STATEMENT" />
  </settings>

  <typeHandlers>
    <typeHandler handler="com.acme.cpq.quote.persistence.typehandler.JsonbTypeHandler" />
  </typeHandlers>

  <mappers>
    <mapper resource="mybatis/mapper/QuoteMapper.xml" />
    <mapper resource="mybatis/mapper/QuoteLineMapper.xml" />
    <mapper resource="mybatis/mapper/IdempotencyMapper.xml" />
    <mapper resource="mybatis/mapper/OutboxMapper.xml" />
  </mappers>
</configuration>

pool_size_per_instance * instance_count <= safe_database_connection_budget

PostgreSQL max useful app connections: 120
Quote service instances: 6
Reserved for migrations/admin/replication: 20
Budget for quote service: 40
Pool per instance: 6

SET LOCAL statement_timeout = '5s';
SET LOCAL lock_timeout = '500ms';

@Intercepts({
    @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
    @Signature(type = Executor.class, method = "query", args = {
        MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class
    })
})
public final class SqlObservationInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        long start = System.nanoTime();
        MappedStatement statement = (MappedStatement) invocation.getArgs()[0];
        try {
            Object result = invocation.proceed();
            long elapsedMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
            recordSuccess(statement.getId(), elapsedMs, result);
            return result;
        } catch (Throwable t) {
            long elapsedMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
            recordFailure(statement.getId(), elapsedMs, t);
            throw t;
        }
    }
}

sql.statement.duration
sql.statement.errors
sql.statement.rows
sql.connection.acquire.duration
sql.transaction.duration

{
  "level": "WARN",
  "message": "Slow SQL statement",
  "service": "quote-service",
  "statementId": "QuoteSearchMapper.searchQuotes",
  "durationMs": 842,
  "rowCount": 50,
  "tenantScoped": true,
  "traceId": "..."
}

@Test
void transitionStatus_shouldReturnChangedOnlyWhenStateAndVersionMatch() {
    var quote = fixture.insertApprovedQuote();

    var result = repository.transitionStatus(
        quote.tenantId(),
        quote.id(),
        QuoteStatus.APPROVED,
        QuoteStatus.ACCEPTED,
        ExpectedVersion.of(quote.version()),
        clock.instant()
    );

    assertThat(result).isEqualTo(TransitionResult.changed());

    var stale = repository.transitionStatus(
        quote.tenantId(),
        quote.id(),
        QuoteStatus.APPROVED,
        QuoteStatus.ACCEPTED,
        ExpectedVersion.of(quote.version()),
        clock.instant()
    );

    assertThat(stale).isInstanceOf(TransitionResult.VersionConflict.class);
}

public final class QuotePersistenceFixture {
    public PersistedQuote insertApprovedQuote() {
        var tenantId = UUID.randomUUID();
        var quoteId = UUID.randomUUID();
        jdbc.update("""
            INSERT INTO quote.quote (
                tenant_id,
                quote_id,
                quote_number,
                status,
                currency,
                total_amount_minor,
                currency_scale,
                version,
                created_at,
                updated_at,
                expires_at
            ) VALUES (?, ?, ?, 'APPROVED', 'USD', 120000, 2, 3, now(), now(), now() + interval '7 day')
            """,
            tenantId,
            quoteId,
            "Q-10001"
        );
        return new PersistedQuote(new TenantId(tenantId), new QuoteId(quoteId), 3);
    }
}

@Path("/quotes")
public class QuoteResource {
    private final QuoteMapper mapper;
}

CpqMapper.xml

for (QuoteSummary q : quotes) {
    q.setLines(lineMapper.findByQuoteId(q.id()));
}

public interface ProductCatalogMapper {
    ProductVersionRow findProductVersion(@Param("tenantId") UUID tenantId,
                                         @Param("productId") UUID productId,
                                         @Param("version") int version);

    List<ProductAttributeRow> findAttributes(@Param("tenantId") UUID tenantId,
                                             @Param("productId") UUID productId,
                                             @Param("version") int version);

    List<CompatibilityRuleRow> findCompatibilityRules(@Param("tenantId") UUID tenantId,
                                                      @Param("catalogVersion") String catalogVersion);
}

SELECT price_book_id,
       price_book_version,
       product_id,
       charge_type,
       currency,
       amount_minor,
       scale,
       effective_from,
       effective_to
FROM pricing.price_entry
WHERE tenant_id = #{tenantId}
  AND product_id = #{productId}
  AND currency = #{currency}
  AND effective_from <= #{pricingAt}
  AND (effective_to IS NULL OR effective_to > #{pricingAt})
ORDER BY effective_from DESC
LIMIT 1

CREATE INDEX price_entry_lookup_idx
ON pricing.price_entry (
    tenant_id,
    product_id,
    currency,
    effective_from DESC
);

<update id="markLineCompleted">
  UPDATE order_mgmt.order_line
  SET status = 'COMPLETED',
      completed_at = #{completedAt},
      version = version + 1,
      updated_at = #{now}
  WHERE tenant_id = #{tenantId}
    AND order_id = #{orderId}
    AND line_id = #{lineId}
    AND status IN ('IN_PROGRESS', 'PENDING_COMPLETION')
    AND version = #{expectedVersion}
</update>

public final class MyBatisQuoteRepository implements QuoteRepository {
    private final QuoteMapper quoteMapper;
    private final QuoteLineMapper lineMapper;
    private final QuoteChargeMapper chargeMapper;
    private final QuoteRowMapper rowMapper;

    public MyBatisQuoteRepository(SqlSession session, QuoteRowMapper rowMapper) {
        this.quoteMapper = session.getMapper(QuoteMapper.class);
        this.lineMapper = session.getMapper(QuoteLineMapper.class);
        this.chargeMapper = session.getMapper(QuoteChargeMapper.class);
        this.rowMapper = rowMapper;
    }

    @Override
    public Optional<Quote> findById(TenantId tenantId, QuoteId quoteId) {
        var header = quoteMapper.findHeaderById(tenantId.value(), quoteId.value());
        if (header == null) {
            return Optional.empty();
        }
        var lines = lineMapper.findByQuoteId(tenantId.value(), quoteId.value());
        var charges = chargeMapper.findByQuoteId(tenantId.value(), quoteId.value());
        return Optional.of(rowMapper.toDomain(header, lines, charges));
    }

    @Override
    public QuoteSaveResult saveDraft(Quote quote, ExpectedVersion expectedVersion) {
        var row = rowMapper.toHeaderRow(quote);
        int updated = quoteMapper.updateHeaderIfVersionMatches(row, expectedVersion.value());
        if (updated != 1) {
            return QuoteSaveResult.conflict();
        }
        lineMapper.deleteDraftLines(quote.tenantId().value(), quote.id().value());
        lineMapper.insertLines(rowMapper.toLineRows(quote));
        chargeMapper.insertCharges(rowMapper.toChargeRows(quote));
        return QuoteSaveResult.saved(quote.version());
    }
}

{
  "type": "https://errors.acme.com/concurrency-conflict",
  "title": "Quote has changed",
  "status": 409,
  "detail": "Quote version 5 is stale. Current version is 6.",
  "currentVersion": 6
}

## Query: QuoteSearchMapper.searchQuotes

Purpose:
- Search quote summaries for back-office quote list.

Expected cardinality:
- Tenant: 10k to 5M quotes.
- Result page: 20-100 rows.

Predicates:
- tenant_id mandatory
- status optional
- customer_id optional
- created_at range optional

Sort:
- created_at desc, quote_id desc

Indexes:
- quote_search_created_idx (tenant_id, created_at desc, quote_id desc)
- quote_search_status_created_idx (tenant_id, status, created_at desc)
- quote_customer_created_idx (tenant_id, customer_id, created_at desc)

Failure signal:
- p95 > 200ms under normal load
- sequential scan on quote table for tenant search