1
@Table("invoices")
2
class InvoiceEntity : AuditableEntity(), Persistable<UUID> {
3

4
    @Id
5
    @Column("id")
6
    private var id: UUID? = null
7

8
    @Column("organization_id")
9
    var organizationId: UUID? = null
10

11
    @Column("amount")
12
    var amount: BigDecimal = BigDecimal.ZERO
13

14
    @Column("currency")
15
    var currency: String = ""
16

17
    @Column("status")
18
    var status: String = ""
19

20
    @Column("issued_at")
21
    var issuedAt: Instant? = null
22

23
    @Column("due_date")
24
    var dueDate: LocalDate? = null
25

26
    @Version
27
    @Column("version")
28
    var version: Long = 0
29

30
    @Transient
31
    private var isNew: Boolean = true
32

33
    override fun getId(): UUID? = id
34

35
    override fun isNew(): Boolean = isNew
36

37
    fun setId(id: UUID) {
38
        this.id = id
39
    }
40

41
    fun markNotNew() {
42
        this.isNew = false
43
    }
44
}

1
@Table("invoices")
2
public class InvoiceEntity extends AuditableEntity implements Persistable<UUID> {
3

4
    @Id
5
    @Column("id")
6
    private UUID id;
7

8
    @Column("organization_id")
9
    private UUID organizationId;
10

11
    @Column("amount")
12
    private BigDecimal amount = BigDecimal.ZERO;
13

14
    @Column("currency")
15
    private String currency = "";
16

17
    @Column("status")
18
    private String status = "";
19

20
    @Column("issued_at")
21
    private Instant issuedAt;
22

23
    @Column("due_date")
24
    private LocalDate dueDate;
25

26
    @Version
27
    @Column("version")
28
    private long version = 0;
29

30
    @Transient
31
    private boolean isNew = true;
32

33
    @Override
34
    public UUID getId() { return id; }
35

36
    @Override
37
    public boolean isNew() { return isNew; }
38

39
    public void setId(UUID id) { this.id = id; }
40
    public void markNotNew() { this.isNew = false; }
41

42
    // Getters and setters
43
    public UUID getOrganizationId() { return organizationId; }
44
    public void setOrganizationId(UUID organizationId) { this.organizationId = organizationId; }
45
    public BigDecimal getAmount() { return amount; }
46
    public void setAmount(BigDecimal amount) { this.amount = amount; }
47
    public String getCurrency() { return currency; }
48
    public void setCurrency(String currency) { this.currency = currency; }
49
    public String getStatus() { return status; }
50
    public void setStatus(String status) { this.status = status; }
51
    public Instant getIssuedAt() { return issuedAt; }
52
    public void setIssuedAt(Instant issuedAt) { this.issuedAt = issuedAt; }
53
    public LocalDate getDueDate() { return dueDate; }
54
    public void setDueDate(LocalDate dueDate) { this.dueDate = dueDate; }
55
    public long getVersion() { return version; }
56
    public void setVersion(long version) { this.version = version; }
57
}

1
@Repository
2
interface InvoiceJdbcRepository : CrudRepository<InvoiceEntity, UUID> {
3

4
    @Query("SELECT * FROM invoices WHERE organization_id = :organizationId")
5
    fun findByOrganizationId(@Param("organizationId") organizationId: UUID): List<InvoiceEntity>
6
}

1
@Repository
2
public interface InvoiceJdbcRepository extends CrudRepository<InvoiceEntity, UUID> {
3

4
    @Query("SELECT * FROM invoices WHERE organization_id = :organizationId")
5
    List<InvoiceEntity> findByOrganizationId(@Param("organizationId") UUID organizationId);
6
}

1
@Component
2
@Order(100)  // Lowest priority in chain
3
class InvoiceRepositoryAdapter(
4
    private val jdbcRepository: InvoiceJdbcRepository,
5
    private val mapper: EntityJdbcMapper
6
) : InvoiceRepositoryPort {
7

8
    override fun save(invoice: Invoice): Invoice {
9
        val entity = mapper.toEntityForInsert(invoice)
10
        val saved = jdbcRepository.save(entity)
11
        return mapper.toDomain(saved)
12
    }
13

14
    override fun findById(id: UUID): Invoice? {
15
        return jdbcRepository.findById(id)
16
            .map { mapper.toDomain(it) }
17
            .orElse(null)
18
    }
19

20
    override fun findByOrganizationId(organizationId: UUID): List<Invoice> {
21
        return jdbcRepository.findByOrganizationId(organizationId)
22
            .map { mapper.toDomain(it) }
23
    }
24

25
    companion object {
26
        private val log = LoggerFactory.getLogger(InvoiceRepositoryAdapter::class.java)
27
    }
28
}

1
@Component
2
@Order(100)  // Lowest priority in chain
3
public class InvoiceRepositoryAdapter implements InvoiceRepositoryPort {
4

5
    private static final Logger log = LoggerFactory.getLogger(InvoiceRepositoryAdapter.class);
6

7
    private final InvoiceJdbcRepository jdbcRepository;
8
    private final EntityJdbcMapper mapper;
9

10
    public InvoiceRepositoryAdapter(InvoiceJdbcRepository jdbcRepository, EntityJdbcMapper mapper) {
11
        this.jdbcRepository = jdbcRepository;
12
        this.mapper = mapper;
13
    }
14

15
    @Override
16
    public Invoice save(Invoice invoice) {
17
        InvoiceEntity entity = mapper.toEntityForInsert(invoice);
18
        InvoiceEntity saved = jdbcRepository.save(entity);
19
        return mapper.toDomain(saved);
20
    }
21

22
    @Override
23
    public Optional<Invoice> findById(UUID id) {
24
        return jdbcRepository.findById(id)
25
            .map(mapper::toDomain);
26
    }
27

28
    @Override
29
    public List<Invoice> findByOrganizationId(UUID organizationId) {
30
        return jdbcRepository.findByOrganizationId(organizationId)
31
            .stream()
32
            .map(mapper::toDomain)
33
            .collect(Collectors.toList());
34
    }
35
}

1
// Domain → Entity
2
fun Invoice.toEntityForInsert(): InvoiceEntity = InvoiceEntity().apply {
3
    setId(this@toEntityForInsert.id)
4
    organizationId = this@toEntityForInsert.organizationId
5
    amount = this@toEntityForInsert.amount.value
6
    currency = this@toEntityForInsert.amount.currency.currencyCode
7
    status = this@toEntityForInsert.status.name
8
    issuedAt = this@toEntityForInsert.issuedAt
9
    dueDate = this@toEntityForInsert.dueDate
10
    version = this@toEntityForInsert.version
11
    markNotNew()  // It's new for insert
12
}
13

14
// Entity → Domain
15
fun InvoiceEntity.toDomain(): Invoice = Invoice.rehydrate(
16
    id = this.id!!,
17
    organizationId = this.organizationId!!,
18
    amount = Money(this.amount, Currency.getInstance(this.currency)),
19
    status = InvoiceStatus.valueOf(this.status),
20
    issuedAt = this.issuedAt!!,
21
    dueDate = this.dueDate!!,
22
    version = this.version
23
)

1
public final class EntityJdbcMapper {
2

3
    private EntityJdbcMapper() {}
4

5
    // Domain → Entity
6
    public static InvoiceEntity toEntityForInsert(Invoice invoice) {
7
        InvoiceEntity entity = new InvoiceEntity();
8
        entity.setId(invoice.getId());
9
        entity.setOrganizationId(invoice.getOrganizationId());
10
        entity.setAmount(invoice.getAmount().getValue());
11
        entity.setCurrency(invoice.getAmount().getCurrency().getCurrencyCode());
12
        entity.setStatus(invoice.getStatus().name());
13
        entity.setIssuedAt(invoice.getIssuedAt());
14
        entity.setDueDate(invoice.getDueDate());
15
        entity.setVersion(invoice.getVersion());
16
        entity.markNotNew();
17
        return entity;
18
    }
19

20
    // Entity → Domain
21
    public static Invoice toDomain(InvoiceEntity entity) {
22
        return Invoice.rehydrate(
23
            entity.getId(),
24
            entity.getOrganizationId(),
25
            new Money(entity.getAmount(), Currency.getInstance(entity.getCurrency())),
26
            InvoiceStatus.valueOf(entity.getStatus()),
27
            entity.getIssuedAt(),
28
            entity.getDueDate(),
29
            entity.getVersion()
30
        );
31
    }
32
}

1
databaseChangeLog:
2
  - include:
3
      file: changelog/changes/V20251103120000__create_invoices_table.sql

1
class KafkaMessagePublisherAdapter(
2
    private val kafkaTemplate: KafkaTemplate<String, String>,
3
) : MessagePublisherPort {
4

5
    override fun publish(topic: String, routingKey: String, payload: String) {
6
        // routingKey doubles as Kafka key (partition selector)
7
        kafkaTemplate.send(topic, routingKey, payload).get(5, TimeUnit.SECONDS)
8
    }
9

10
    override fun publish(topic: String, payload: String) {
11
        kafkaTemplate.send(topic, payload).get(5, TimeUnit.SECONDS)
12
    }
13
}
14

15
// bootstrap/config/MessagingConfig.kt
16
@Configuration
17
class MessagingConfig {
18
    @Bean
19
    fun messagePublisherPort(kafkaTemplate: KafkaTemplate<String, String>): MessagePublisherPort =
20
        KafkaMessagePublisherAdapter(kafkaTemplate)
21
}

1
public class KafkaMessagePublisherAdapter implements MessagePublisherPort {
2

3
    private final KafkaTemplate<String, String> kafkaTemplate;
4

5
    public KafkaMessagePublisherAdapter(KafkaTemplate<String, String> kafkaTemplate) {
6
        this.kafkaTemplate = kafkaTemplate;
7
    }
8

9
    @Override
10
    public void publish(String topic, String routingKey, String payload) {
11
        try {
12
            kafkaTemplate.send(topic, routingKey, payload).get(5, TimeUnit.SECONDS);
13
        } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException(e); }
14
          catch (ExecutionException | TimeoutException e) { throw new RuntimeException(e); }
15
    }
16

17
    @Override
18
    public void publish(String topic, String payload) {
19
        try {
20
            kafkaTemplate.send(topic, payload).get(5, TimeUnit.SECONDS);
21
        } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException(e); }
22
          catch (ExecutionException | TimeoutException e) { throw new RuntimeException(e); }
23
    }
24
}

1
data class CreateInvoiceRequest(
2
    @field:NotNull(message = "Organization ID is required")
3
    val organizationId: UUID?,
4

5
    @field:NotNull(message = "Amount is required")
6
    @field:DecimalMin(value = "0.01", message = "Amount must be positive")
7
    val amount: BigDecimal?,
8

9
    @field:NotBlank(message = "Currency is required")
10
    @field:Pattern(regexp = "[A-Z]{3}", message = "Currency must be 3-letter ISO code")
11
    val currency: String?,
12

13
    @field:NotNull(message = "Due date is required")
14
    @field:Future(message = "Due date must be in the future")
15
    val dueDate: LocalDate?
16
)
17

18
// infrastructure/entry-points/rest-controller/.../model/response/InvoiceResponse.kt
19
data class InvoiceResponse(
20
    val id: UUID,
21
    val organizationId: UUID,
22
    val amount: BigDecimal,
23
    val currency: String,
24
    val status: String,
25
    val issuedAt: Instant,
26
    val dueDate: LocalDate
27
)

1
public record CreateInvoiceRequest(
2
    @NotNull(message = "Organization ID is required")
3
    UUID organizationId,
4

5
    @NotNull(message = "Amount is required")
6
    @DecimalMin(value = "0.01", message = "Amount must be positive")
7
    BigDecimal amount,
8

9
    @NotBlank(message = "Currency is required")
10
    @Pattern(regexp = "[A-Z]{3}", message = "Currency must be 3-letter ISO code")
11
    String currency,
12

13
    @NotNull(message = "Due date is required")
14
    @Future(message = "Due date must be in the future")
15
    LocalDate dueDate
16
) {}
17

18
// infrastructure/entry-points/rest-controller/.../dto/response/InvoiceResponse.java
19
public record InvoiceResponse(
20
    UUID id,
21
    UUID organizationId,
22
    BigDecimal amount,
23
    String currency,
24
    String status,
25
    Instant issuedAt,
26
    LocalDate dueDate
27
) {}

1
fun CreateInvoiceRequest.toCommand(traceId: String): CreateInvoiceCommand = CreateInvoiceCommand(
2
    organizationId = this.organizationId!!,
3
    amount = this.amount!!,
4
    currency = this.currency!!,
5
    dueDate = this.dueDate!!,
6
    traceId = traceId
7
)
8

9
fun Invoice.toResponse(): InvoiceResponse = InvoiceResponse(
10
    id = this.id,
11
    organizationId = this.organizationId,
12
    amount = this.amount.value,
13
    currency = this.amount.currency.currencyCode,
14
    status = this.status.name,
15
    issuedAt = this.issuedAt,
16
    dueDate = this.dueDate
17
)

1
@RestController
2
@RequestMapping("/api/v1/invoices")
3
class InvoiceController(
4
    private val createInvoiceUseCase: CreateInvoicePort,
5
    private val getInvoiceByIdUseCase: GetInvoiceByIdPort,
6
    private val mapper: InvoiceRestMapper
7
) {
8

9
    @PostMapping
10
    @ResponseStatus(HttpStatus.CREATED)
11
    fun createInvoice(
12
        @Valid @RequestBody request: CreateInvoiceRequest
13
    ): InvoiceResponse {
14
        log.info("Creating invoice: organizationId={}", request.organizationId)
15
        val command = request.toCommand(MDC.get("traceId") ?: UUID.randomUUID().toString())
16
        val invoice = createInvoiceUseCase.execute(command)
17
        return invoice.toResponse()
18
    }
19

20
    @GetMapping("/{id}")
21
    fun getInvoice(@PathVariable id: UUID): InvoiceResponse {
22
        log.debug("Fetching invoice: id={}", id)
23
        val invoice = getInvoiceByIdUseCase.execute(id)
24
        return invoice.toResponse()
25
    }
26

27
    companion object {
28
        private val log = LoggerFactory.getLogger(InvoiceController::class.java)
29
    }
30
}

1
@RestController
2
@RequestMapping("/api/v1/invoices")
3
public class InvoiceController {
4

5
    private static final Logger log = LoggerFactory.getLogger(InvoiceController.class);
6

7
    private final CreateInvoicePort createInvoiceUseCase;
8
    private final GetInvoiceByIdPort getInvoiceByIdUseCase;
9

10
    public InvoiceController(CreateInvoicePort createInvoiceUseCase,
11
                             GetInvoiceByIdPort getInvoiceByIdUseCase) {
12
        this.createInvoiceUseCase = createInvoiceUseCase;
13
        this.getInvoiceByIdUseCase = getInvoiceByIdUseCase;
14
    }
15

16
    @PostMapping
17
    @ResponseStatus(HttpStatus.CREATED)
18
    public InvoiceResponse createInvoice(@Valid @RequestBody CreateInvoiceRequest request) {
19
        log.info("Creating invoice: organizationId={}", request.organizationId());
20
        String traceId = Optional.ofNullable(MDC.get("traceId")).orElseGet(() -> UUID.randomUUID().toString());
21
        CreateInvoiceCommand command = InvoiceRestMapper.toCommand(request, traceId);
22
        Invoice invoice = createInvoiceUseCase.execute(command);
23
        return InvoiceRestMapper.toResponse(invoice);
24
    }
25

26
    @GetMapping("/{id}")
27
    public InvoiceResponse getInvoice(@PathVariable UUID id) {
28
        log.debug("Fetching invoice: id={}", id);
29
        Invoice invoice = getInvoiceByIdUseCase.execute(id);
30
        return InvoiceRestMapper.toResponse(invoice);
31
    }
32
}

1
@Configuration
2
class UseCaseConfig {
3

4
    @Bean
5
    fun createInvoiceUseCase(
6
        transaction: TransactionPort<Invoice>,
7
        invoiceRepository: InvoiceRepositoryPort,
8
        outboxRepository: OutboxRepositoryPort,          // SDK bean
9
        outboxEventFactory: OutboxEventFactory,          // SDK bean
10
        clock: Clock,
11
    ): CreateInvoicePort {
12
        return CreateInvoiceUseCase(transaction, invoiceRepository, outboxRepository, outboxEventFactory, clock)
13
    }
14

15
    @Bean
16
    @Primary
17
    fun invoiceRepository(): InvoiceRepositoryPort {
18
        return buildChain(InvoiceRepositoryPort::class.java)
19
    }
20

21
    // buildChain method already exists in UseCaseConfig
22
}