getOrderHistory(@PathVariable UUID orderId) {
+ return orderEventService.getHistory(orderId);
+ }
+
+ /**
+ * SSE endpoint — streams real-time order status updates to the client.
+ *
+ * Usage (JavaScript):
+ *
+ * const es = new EventSource('/api/orders/{orderId}/status-stream');
+ * es.addEventListener('status-update', e => console.log(JSON.parse(e.data)));
+ * es.addEventListener('complete', () => es.close());
+ *
+ *
+ * Events emitted:
+ * connected — immediately on subscription
+ * status-update — on every saga step (INVENTORY_RESERVED, PAYMENT_COMPLETED, SHIPPED, etc.)
+ * complete — when the order reaches a terminal state (stream then closes)
+ *
+ * The connection is held open for up to 5 minutes. If no terminal state is
+ * reached by then, the client should reconnect and poll {@link #getOrderById}.
+ */
+ @GetMapping(value = "/{orderId}/status-stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
+ @Operation(
+ summary = "Stream real-time order status via SSE",
+ description = "Opens a Server-Sent Events stream that pushes status updates as the saga progresses"
+ )
+ public SseEmitter streamOrderStatus(
+ @Parameter(description = "Order ID to subscribe to") @PathVariable UUID orderId) {
+ return orderStatusEmitter.subscribe(orderId);
+ }
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/dto/OrderResponse.java b/order-service/src/main/java/com/hacisimsek/order/dto/OrderResponse.java
index 44208cb..264fbb2 100644
--- a/order-service/src/main/java/com/hacisimsek/order/dto/OrderResponse.java
+++ b/order-service/src/main/java/com/hacisimsek/order/dto/OrderResponse.java
@@ -5,7 +5,6 @@
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
-
import java.math.BigDecimal;
import java.time.Instant;
import java.util.List;
diff --git a/order-service/src/main/java/com/hacisimsek/order/eventsourcing/OrderEvent.java b/order-service/src/main/java/com/hacisimsek/order/eventsourcing/OrderEvent.java
new file mode 100644
index 0000000..80da1bc
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/eventsourcing/OrderEvent.java
@@ -0,0 +1,91 @@
+package com.hacisimsek.order.eventsourcing;
+
+import com.hacisimsek.order.model.Order;
+import jakarta.persistence.*;
+import lombok.*;
+
+import java.time.Instant;
+import java.util.UUID;
+
+/**
+ * Immutable event record that captures every state transition of an Order.
+ *
+ * This is the Event Sourcing append-only log. Every time an order's status
+ * changes, a new OrderEvent row is inserted — never updated, never deleted.
+ *
+ * The full history of an order is the ordered sequence of its OrderEvents.
+ * The current state can always be rebuilt by replaying them in sequence.
+ *
+ * Indexing:
+ * - orderId + occurredAt for chronological history queries
+ * - correlationId for saga-level tracing across services
+ */
+@Entity
+@Table(name = "order_events",
+ indexes = {
+ @Index(name = "idx_order_events_order_id", columnList = "orderId, occurredAt"),
+ @Index(name = "idx_order_events_correlation", columnList = "correlationId")
+ })
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class OrderEvent {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.UUID)
+ private UUID id;
+
+ /** The order this event belongs to */
+ @Column(nullable = false)
+ private UUID orderId;
+
+ /** Correlation ID that ties this event to the saga and to gateway logs */
+ private UUID correlationId;
+
+ /** The type of event — maps to OrderStatus transitions */
+ @Enumerated(EnumType.STRING)
+ @Column(nullable = false)
+ private EventType eventType;
+
+ /** The new status after this event */
+ @Enumerated(EnumType.STRING)
+ @Column(nullable = false)
+ private Order.OrderStatus newStatus;
+
+ /** The previous status before this event (null for ORDER_CREATED) */
+ @Enumerated(EnumType.STRING)
+ private Order.OrderStatus previousStatus;
+
+ /** Who or what triggered this event (e.g. "inventory-service", "payment-service") */
+ @Column(length = 100)
+ private String triggeredBy;
+
+ /** Optional reason/detail (e.g. failure reason, tracking number) */
+ @Column(length = 500)
+ private String details;
+
+ /** When this event occurred — immutable, set at insert time */
+ @Column(nullable = false, updatable = false)
+ private Instant occurredAt;
+
+ @PrePersist
+ protected void onCreate() {
+ this.occurredAt = Instant.now();
+ }
+
+ public enum EventType {
+ ORDER_CREATED,
+ INVENTORY_CHECKING,
+ INVENTORY_RESERVED,
+ INVENTORY_RESERVATION_FAILED,
+ PAYMENT_PROCESSING,
+ PAYMENT_COMPLETED,
+ PAYMENT_FAILED,
+ SHIPPING_PROCESSING,
+ ORDER_SHIPPED,
+ ORDER_COMPLETED,
+ ORDER_CANCELLED,
+ ORDER_FAILED
+ }
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/eventsourcing/OrderEventRepository.java b/order-service/src/main/java/com/hacisimsek/order/eventsourcing/OrderEventRepository.java
new file mode 100644
index 0000000..3400279
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/eventsourcing/OrderEventRepository.java
@@ -0,0 +1,21 @@
+package com.hacisimsek.order.eventsourcing;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Repository for the append-only order_events table.
+ *
+ * Events are always inserted, never updated or deleted.
+ * Queries return events in chronological order.
+ */
+public interface OrderEventRepository extends JpaRepository {
+
+ /** Full audit trail for one order — ordered oldest first */
+ List findByOrderIdOrderByOccurredAtAsc(UUID orderId);
+
+ /** All events tied to a saga correlation ID — cross-service audit */
+ List findByCorrelationIdOrderByOccurredAtAsc(UUID correlationId);
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/eventsourcing/OrderEventService.java b/order-service/src/main/java/com/hacisimsek/order/eventsourcing/OrderEventService.java
new file mode 100644
index 0000000..4817726
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/eventsourcing/OrderEventService.java
@@ -0,0 +1,78 @@
+package com.hacisimsek.order.eventsourcing;
+
+import com.hacisimsek.order.model.Order;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Service for appending and querying order events (Event Sourcing log).
+ *
+ * Every call to {@link #append} inserts one immutable row into order_events.
+ * The event log is the source of truth for what happened to an order and when.
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class OrderEventService {
+
+ private final OrderEventRepository orderEventRepository;
+
+ /**
+ * Append a new event to the order's event log.
+ * Called inside the same transaction as the Order status update.
+ */
+ @Transactional
+ public OrderEvent append(UUID orderId,
+ UUID correlationId,
+ OrderEvent.EventType eventType,
+ Order.OrderStatus previousStatus,
+ Order.OrderStatus newStatus,
+ String triggeredBy,
+ String details) {
+ OrderEvent event = OrderEvent.builder()
+ .orderId(orderId)
+ .correlationId(correlationId)
+ .eventType(eventType)
+ .previousStatus(previousStatus)
+ .newStatus(newStatus)
+ .triggeredBy(triggeredBy)
+ .details(details)
+ .build();
+
+ OrderEvent saved = orderEventRepository.save(event);
+ log.debug("[EventStore] Appended {} for order {} ({} → {})",
+ eventType, orderId, previousStatus, newStatus);
+ return saved;
+ }
+
+ /** Retrieve the full immutable event log for an order */
+ @Transactional(readOnly = true)
+ public List getHistory(UUID orderId) {
+ return orderEventRepository.findByOrderIdOrderByOccurredAtAsc(orderId);
+ }
+
+ /** Retrieve all events tied to a saga correlation ID */
+ @Transactional(readOnly = true)
+ public List getByCorrelationId(UUID correlationId) {
+ return orderEventRepository.findByCorrelationIdOrderByOccurredAtAsc(correlationId);
+ }
+
+ /**
+ * Rebuild current order status by replaying the event log.
+ * Useful for auditing or reconciling against the Order table.
+ */
+ @Transactional(readOnly = true)
+ public Order.OrderStatus rebuildCurrentStatus(UUID orderId) {
+ List events = getHistory(orderId);
+ if (events.isEmpty()) {
+ throw new RuntimeException("No events found for order: " + orderId);
+ }
+ // The last event's newStatus is the current state
+ return events.get(events.size() - 1).getNewStatus();
+ }
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/outbox/OutboxEvent.java b/order-service/src/main/java/com/hacisimsek/order/outbox/OutboxEvent.java
new file mode 100644
index 0000000..f00c55b
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/outbox/OutboxEvent.java
@@ -0,0 +1,79 @@
+package com.hacisimsek.order.outbox;
+
+import jakarta.persistence.*;
+import lombok.*;
+
+import java.time.Instant;
+import java.util.UUID;
+
+/**
+ * Outbox table entry — written in the same DB transaction as the Order.
+ *
+ * The OutboxPublisher reads unpublished rows on a fixed schedule and
+ * publishes them to Kafka. On success the row is marked PUBLISHED.
+ * On failure it stays PENDING and is retried on the next schedule tick.
+ *
+ * This guarantees at-least-once Kafka delivery even if the service
+ * crashes between saving the order and sending to Kafka.
+ */
+@Entity
+@Table(name = "outbox_events",
+ indexes = {
+ @Index(name = "idx_outbox_status_created", columnList = "status, createdAt"),
+ @Index(name = "idx_outbox_aggregate", columnList = "aggregateId")
+ })
+@Data
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class OutboxEvent {
+
+ @Id
+ @GeneratedValue(strategy = GenerationType.UUID)
+ private UUID id;
+
+ /** The Kafka topic this event should be published to */
+ @Column(nullable = false)
+ private String topic;
+
+ /** The entity this event belongs to — used as the Kafka message key */
+ @Column(nullable = false)
+ private UUID aggregateId;
+
+ /** Fully-qualified Java class name of the payload (e.g. OrderCreatedEvent) */
+ @Column(nullable = false)
+ private String eventType;
+
+ /** JSON-serialized event payload */
+ @Column(nullable = false, columnDefinition = "TEXT")
+ private String payload;
+
+ @Enumerated(EnumType.STRING)
+ @Column(nullable = false)
+ @Builder.Default
+ private Status status = Status.PENDING;
+
+ @Column(nullable = false, updatable = false)
+ private Instant createdAt;
+
+ private Instant publishedAt;
+
+ /** Number of failed publish attempts — for observability */
+ @Builder.Default
+ private int retryCount = 0;
+
+ /** Last error message from a failed publish attempt */
+ @Column(length = 1000)
+ private String lastError;
+
+ @PrePersist
+ protected void onCreate() {
+ this.createdAt = Instant.now();
+ }
+
+ public enum Status {
+ PENDING,
+ PUBLISHED,
+ FAILED // after max retries exceeded (currently 5)
+ }
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/outbox/OutboxEventRepository.java b/order-service/src/main/java/com/hacisimsek/order/outbox/OutboxEventRepository.java
new file mode 100644
index 0000000..21e6a6d
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/outbox/OutboxEventRepository.java
@@ -0,0 +1,21 @@
+package com.hacisimsek.order.outbox;
+
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.UUID;
+
+public interface OutboxEventRepository extends JpaRepository {
+
+ /** Fetch all pending events ordered oldest-first (for FIFO delivery) */
+ List findByStatusOrderByCreatedAtAsc(OutboxEvent.Status status);
+
+ /** Clean up published events older than the given cutoff to keep the table small */
+ @Modifying
+ @Query("DELETE FROM OutboxEvent e WHERE e.status = 'PUBLISHED' AND e.publishedAt < :cutoff")
+ void deletePublishedBefore(@Param("cutoff") Instant cutoff);
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/outbox/OutboxPublisher.java b/order-service/src/main/java/com/hacisimsek/order/outbox/OutboxPublisher.java
new file mode 100644
index 0000000..e4ee0b7
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/outbox/OutboxPublisher.java
@@ -0,0 +1,103 @@
+package com.hacisimsek.order.outbox;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.kafka.support.SendResult;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+import java.util.List;
+
+/**
+ * Polls the outbox table every 5 seconds and publishes pending events to Kafka.
+ *
+ * Flow:
+ * 1. Read all PENDING rows (oldest first)
+ * 2. Deserialize payload back to the original event object
+ * 3. Send to the target Kafka topic synchronously (get() with 10s timeout)
+ * 4. On success → mark PUBLISHED
+ * 5. On failure → increment retryCount; after 5 failures mark FAILED
+ *
+ * A nightly cleanup job removes PUBLISHED rows older than 7 days.
+ *
+ * Why synchronous send? Because we must know whether Kafka accepted the
+ * message before marking it published. An async callback arriving after
+ * a crash would leave the row in PENDING (safe — it will be retried).
+ */
+@Component
+@RequiredArgsConstructor
+@Slf4j
+public class OutboxPublisher {
+
+ private static final int MAX_RETRIES = 5;
+
+ private final OutboxEventRepository outboxEventRepository;
+ private final KafkaTemplate kafkaTemplate;
+ private final ObjectMapper objectMapper;
+
+ @Scheduled(fixedDelay = 5000) // runs 5s after the previous run completes
+ @Transactional
+ public void publishPendingEvents() {
+ List pending =
+ outboxEventRepository.findByStatusOrderByCreatedAtAsc(OutboxEvent.Status.PENDING);
+
+ if (pending.isEmpty()) return;
+
+ log.debug("[Outbox] Processing {} pending event(s)", pending.size());
+
+ for (OutboxEvent event : pending) {
+ try {
+ // Deserialize the stored JSON payload back to the original event class
+ Class eventClass = Class.forName(event.getEventType());
+ Object eventPayload = objectMapper.readValue(event.getPayload(), eventClass);
+
+ // Synchronous send — waits for broker ACK (or throws on timeout/error)
+ SendResult result = kafkaTemplate
+ .send(event.getTopic(), event.getAggregateId().toString(), eventPayload)
+ .get();
+
+ // Mark published
+ event.setStatus(OutboxEvent.Status.PUBLISHED);
+ event.setPublishedAt(Instant.now());
+ outboxEventRepository.save(event);
+
+ log.info("[Outbox] Published {} → topic={} partition={} offset={}",
+ event.getEventType(),
+ event.getTopic(),
+ result.getRecordMetadata().partition(),
+ result.getRecordMetadata().offset());
+
+ } catch (Exception ex) {
+ int retries = event.getRetryCount() + 1;
+ event.setRetryCount(retries);
+ event.setLastError(ex.getMessage() != null
+ ? ex.getMessage().substring(0, Math.min(ex.getMessage().length(), 1000))
+ : "unknown");
+
+ if (retries >= MAX_RETRIES) {
+ event.setStatus(OutboxEvent.Status.FAILED);
+ log.error("[Outbox] Event {} FAILED after {} retries. Manual intervention required. Error: {}",
+ event.getId(), retries, ex.getMessage());
+ } else {
+ log.warn("[Outbox] Publish attempt {}/{} failed for event {} ({}): {}",
+ retries, MAX_RETRIES, event.getId(), event.getEventType(), ex.getMessage());
+ }
+ outboxEventRepository.save(event);
+ }
+ }
+ }
+
+ /** Runs nightly to clean up old published events and keep the table small */
+ @Scheduled(cron = "0 0 2 * * *") // 02:00 every day
+ @Transactional
+ public void purgePublishedEvents() {
+ Instant cutoff = Instant.now().minus(7, ChronoUnit.DAYS);
+ outboxEventRepository.deletePublishedBefore(cutoff);
+ log.info("[Outbox] Purged published events older than 7 days");
+ }
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/saga/OrderSagaHandler.java b/order-service/src/main/java/com/hacisimsek/order/saga/OrderSagaHandler.java
index e83aedd..64e0405 100644
--- a/order-service/src/main/java/com/hacisimsek/order/saga/OrderSagaHandler.java
+++ b/order-service/src/main/java/com/hacisimsek/order/saga/OrderSagaHandler.java
@@ -1,113 +1,78 @@
package com.hacisimsek.order.saga;
-import java.util.Map;
-
-import org.springframework.kafka.annotation.KafkaListener;
-import org.springframework.stereotype.Component;
-
import com.hacisimsek.common.event.inventory.InventoryReservationFailedEvent;
import com.hacisimsek.common.event.inventory.InventoryReservedEvent;
import com.hacisimsek.common.event.payment.PaymentFailedEvent;
import com.hacisimsek.common.event.payment.PaymentProcessedEvent;
import com.hacisimsek.common.event.shipping.ShipmentFailedEvent;
import com.hacisimsek.common.event.shipping.ShipmentProcessedEvent;
-import com.hacisimsek.common.logging.LogPublisher;
-import com.hacisimsek.order.model.Order;
-import com.hacisimsek.order.service.OrderService;
-
+import com.hacisimsek.order.saga.orchestrator.OrderSagaOrchestrator;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+/**
+ * Kafka listeners for the Order Saga.
+ *
+ * This class is now a thin adapter layer — it receives Kafka events and
+ * immediately delegates to the {@link OrderSagaOrchestrator} which owns
+ * all the state machine logic and compensation decisions.
+ *
+ * All business logic that was previously inline here has moved to the orchestrator.
+ */
@Component
@RequiredArgsConstructor
@Slf4j
public class OrderSagaHandler {
- private static final String SERVICE_NAME = "order-service";
+ private final OrderSagaOrchestrator orchestrator;
- private final OrderService orderService;
- private final LogPublisher logPublisher;
+ // ── Inventory events ──────────────────────────────────────────────────────
@KafkaListener(topics = "inventory-events", groupId = "order-service-group",
containerFactory = "kafkaListenerContainerFactory")
public void handleInventoryEvents(Object event) {
- log.info("Received inventory event: {}", event.getClass().getSimpleName());
+ log.debug("Received inventory event: {}", event.getClass().getSimpleName());
- if (event instanceof InventoryReservedEvent reservedEvent) {
- orderService.updateOrderStatus(reservedEvent.getOrderId(), Order.OrderStatus.INVENTORY_RESERVED);
- log.info("Inventory reserved for order: {}", reservedEvent.getOrderId());
- logPublisher.info(SERVICE_NAME,
- reservedEvent.getCorrelationId() != null ? reservedEvent.getCorrelationId().toString() : null,
- "Inventory reserved for order: " + reservedEvent.getOrderId(),
- Map.of("orderId", reservedEvent.getOrderId().toString(), "status", "INVENTORY_RESERVED"));
+ if (event instanceof InventoryReservedEvent e) {
+ orchestrator.onInventoryReserved(e.getOrderId(), e.getCorrelationId());
- } else if (event instanceof InventoryReservationFailedEvent failedEvent) {
- orderService.updateOrderStatus(failedEvent.getOrderId(), Order.OrderStatus.CANCELLED);
- log.error("Inventory reservation failed for order: {}, reason: {}",
- failedEvent.getOrderId(), failedEvent.getReason());
- logPublisher.error(SERVICE_NAME,
- failedEvent.getCorrelationId() != null ? failedEvent.getCorrelationId().toString() : null,
- "Inventory reservation failed — order cancelled: " + failedEvent.getOrderId(),
- Map.of("orderId", failedEvent.getOrderId().toString(),
- "reason", failedEvent.getReason() != null ? failedEvent.getReason() : "unknown",
- "status", "CANCELLED"));
+ } else if (event instanceof InventoryReservationFailedEvent e) {
+ orchestrator.onInventoryFailed(e.getOrderId(), e.getCorrelationId(),
+ e.getReason() != null ? e.getReason() : "unknown");
}
}
+ // ── Payment events ────────────────────────────────────────────────────────
+
@KafkaListener(topics = "payment-events", groupId = "order-service-group",
containerFactory = "kafkaListenerContainerFactory")
public void handlePaymentEvents(Object event) {
- log.info("Received payment event: {}", event.getClass().getSimpleName());
+ log.debug("Received payment event: {}", event.getClass().getSimpleName());
- if (event instanceof PaymentProcessedEvent processedEvent) {
- orderService.updateOrderStatus(processedEvent.getOrderId(), Order.OrderStatus.PAYMENT_COMPLETED);
- log.info("Payment processed for order: {}", processedEvent.getOrderId());
- logPublisher.info(SERVICE_NAME,
- processedEvent.getCorrelationId() != null ? processedEvent.getCorrelationId().toString() : null,
- "Payment completed for order: " + processedEvent.getOrderId(),
- Map.of("orderId", processedEvent.getOrderId().toString(),
- "paymentId", processedEvent.getPaymentId() != null ? processedEvent.getPaymentId().toString() : "unknown",
- "status", "PAYMENT_COMPLETED"));
+ if (event instanceof PaymentProcessedEvent e) {
+ orchestrator.onPaymentCompleted(e.getOrderId(), e.getCorrelationId(), e.getPaymentId());
- } else if (event instanceof PaymentFailedEvent failedEvent) {
- orderService.updateOrderStatus(failedEvent.getOrderId(), Order.OrderStatus.FAILED);
- log.error("Payment failed for order: {}, reason: {}",
- failedEvent.getOrderId(), failedEvent.getReason());
- logPublisher.error(SERVICE_NAME,
- failedEvent.getCorrelationId() != null ? failedEvent.getCorrelationId().toString() : null,
- "Payment failed — order marked FAILED: " + failedEvent.getOrderId(),
- Map.of("orderId", failedEvent.getOrderId().toString(),
- "reason", failedEvent.getReason() != null ? failedEvent.getReason() : "unknown",
- "status", "FAILED"));
+ } else if (event instanceof PaymentFailedEvent e) {
+ orchestrator.onPaymentFailed(e.getOrderId(), e.getCorrelationId(),
+ e.getReason() != null ? e.getReason() : "unknown");
}
}
+ // ── Shipping events ───────────────────────────────────────────────────────
+
@KafkaListener(topics = "shipping-events", groupId = "order-service-group",
containerFactory = "kafkaListenerContainerFactory")
public void handleShippingEvents(Object event) {
- log.info("Received shipping event: {}", event.getClass().getSimpleName());
+ log.debug("Received shipping event: {}", event.getClass().getSimpleName());
- if (event instanceof ShipmentProcessedEvent processedEvent) {
- orderService.updateOrderStatus(processedEvent.getOrderId(), Order.OrderStatus.SHIPPED);
- log.info("Order shipped: {}, tracking number: {}",
- processedEvent.getOrderId(), processedEvent.getTrackingNumber());
- logPublisher.info(SERVICE_NAME,
- processedEvent.getCorrelationId() != null ? processedEvent.getCorrelationId().toString() : null,
- "Order shipped: " + processedEvent.getOrderId() + " | tracking: " + processedEvent.getTrackingNumber(),
- Map.of("orderId", processedEvent.getOrderId().toString(),
- "trackingNumber", processedEvent.getTrackingNumber() != null ? processedEvent.getTrackingNumber() : "unknown",
- "status", "SHIPPED"));
+ if (event instanceof ShipmentProcessedEvent e) {
+ orchestrator.onShipmentCreated(e.getOrderId(), e.getCorrelationId(), e.getTrackingNumber());
- } else if (event instanceof ShipmentFailedEvent failedEvent) {
- orderService.updateOrderStatus(failedEvent.getOrderId(), Order.OrderStatus.FAILED);
- log.error("Shipping failed for order: {}, reason: {}",
- failedEvent.getOrderId(), failedEvent.getReason());
- logPublisher.error(SERVICE_NAME,
- failedEvent.getCorrelationId() != null ? failedEvent.getCorrelationId().toString() : null,
- "Shipment failed — order marked FAILED: " + failedEvent.getOrderId(),
- Map.of("orderId", failedEvent.getOrderId().toString(),
- "reason", failedEvent.getReason() != null ? failedEvent.getReason() : "unknown",
- "status", "FAILED"));
+ } else if (event instanceof ShipmentFailedEvent e) {
+ orchestrator.onShipmentFailed(e.getOrderId(), e.getCorrelationId(),
+ e.getReason() != null ? e.getReason() : "unknown");
}
}
-}
\ No newline at end of file
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/saga/orchestrator/OrderSagaOrchestrator.java b/order-service/src/main/java/com/hacisimsek/order/saga/orchestrator/OrderSagaOrchestrator.java
new file mode 100644
index 0000000..52d5c5d
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/saga/orchestrator/OrderSagaOrchestrator.java
@@ -0,0 +1,160 @@
+package com.hacisimsek.order.saga.orchestrator;
+
+import com.hacisimsek.common.logging.LogPublisher;
+import com.hacisimsek.order.model.Order;
+import com.hacisimsek.order.service.OrderService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.support.MessageBuilder;
+import org.springframework.statemachine.StateMachine;
+import org.springframework.statemachine.config.StateMachineFactory;
+import org.springframework.statemachine.support.DefaultStateMachineContext;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Central Saga Orchestrator — drives the Order state machine.
+ *
+ * Instead of each service reacting to events independently (choreography),
+ * this orchestrator:
+ * 1. Maintains the authoritative state machine per order
+ * 2. Receives all saga outcomes (inventory/payment/shipment results)
+ * 3. Decides the next step and updates order status
+ * 4. Handles compensation centrally (e.g. release inventory on payment failure)
+ *
+ * The Kafka listeners in OrderSagaHandler delegate to this orchestrator.
+ * This keeps all saga logic in one place instead of scattered across handlers.
+ *
+ * State machine instances are stateless in this implementation — the current
+ * state is always loaded from the database (Order.status) before processing
+ * each event, which makes it crash-safe and idempotent.
+ */
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class OrderSagaOrchestrator {
+
+ private static final String SERVICE_NAME = "order-service";
+ private static final String ORDER_ID_KEY = "orderId";
+ private static final String CORRELATION_ID_KEY = "correlationId";
+
+ private final StateMachineFactory stateMachineFactory;
+ private final OrderService orderService;
+ private final LogPublisher logPublisher;
+
+ // ── Public API called by Kafka listeners ──────────────────────────────────
+
+ public void onInventoryReserved(UUID orderId, UUID correlationId) {
+ processEvent(orderId, correlationId, SagaEvent.INVENTORY_RESERVED,
+ Order.OrderStatus.INVENTORY_RESERVED,
+ "inventory-service", "Inventory reserved — initiating payment");
+ }
+
+ public void onInventoryFailed(UUID orderId, UUID correlationId, String reason) {
+ processEvent(orderId, correlationId, SagaEvent.INVENTORY_FAILED,
+ Order.OrderStatus.CANCELLED,
+ "inventory-service", "Inventory reservation failed: " + reason);
+ log.warn("[Orchestrator] Order {} CANCELLED — inventory failed: {}", orderId, reason);
+ }
+
+ public void onPaymentCompleted(UUID orderId, UUID correlationId, UUID paymentId) {
+ processEvent(orderId, correlationId, SagaEvent.PAYMENT_COMPLETED,
+ Order.OrderStatus.PAYMENT_COMPLETED,
+ "payment-service", "Payment completed, paymentId=" + paymentId);
+ }
+
+ public void onPaymentFailed(UUID orderId, UUID correlationId, String reason) {
+ processEvent(orderId, correlationId, SagaEvent.PAYMENT_FAILED,
+ Order.OrderStatus.FAILED,
+ "payment-service", "Payment failed: " + reason);
+ // Compensation is handled by inventory-service which listens to payment-events
+ // (already implemented in InventorySagaHandler)
+ log.warn("[Orchestrator] Order {} FAILED — payment failed: {}", orderId, reason);
+ }
+
+ public void onShipmentCreated(UUID orderId, UUID correlationId, String trackingNumber) {
+ processEvent(orderId, correlationId, SagaEvent.SHIPMENT_CREATED,
+ Order.OrderStatus.SHIPPED,
+ "shipping-service", "Shipment created, tracking=" + trackingNumber);
+ }
+
+ public void onShipmentFailed(UUID orderId, UUID correlationId, String reason) {
+ processEvent(orderId, correlationId, SagaEvent.SHIPMENT_FAILED,
+ Order.OrderStatus.FAILED,
+ "shipping-service", "Shipment failed: " + reason);
+ log.warn("[Orchestrator] Order {} FAILED — shipment failed: {}", orderId, reason);
+ }
+
+ // ── Core state machine processing ─────────────────────────────────────────
+
+ private void processEvent(UUID orderId,
+ UUID correlationId,
+ SagaEvent event,
+ Order.OrderStatus targetStatus,
+ String triggeredBy,
+ String details) {
+ try {
+ // Load current state from DB (crash-safe: state machine is rebuilt each time)
+ Order.OrderStatus currentStatus = orderService.getOrderById(orderId).getStatus();
+
+ // Build a state machine pre-loaded at the current state
+ StateMachine sm = buildStateMachine(orderId, currentStatus);
+
+ // Send the event
+ Message message = MessageBuilder.withPayload(event)
+ .setHeader(ORDER_ID_KEY, orderId.toString())
+ .setHeader(CORRELATION_ID_KEY, correlationId != null ? correlationId.toString() : "")
+ .build();
+
+ sm.sendEvent(Mono.just(message)).subscribe();
+
+ Order.OrderStatus newState = sm.getState().getId();
+
+ // Persist the new state
+ orderService.updateOrderStatus(orderId, newState);
+
+ log.info("[Orchestrator] Order {} | event={} | {} → {}",
+ orderId, event, currentStatus, newState);
+
+ logPublisher.info(SERVICE_NAME,
+ correlationId != null ? correlationId.toString() : null,
+ "[Orchestrator] " + details,
+ Map.of("orderId", orderId.toString(),
+ "event", event.name(),
+ "from", currentStatus.name(),
+ "to", newState.name(),
+ "triggeredBy", triggeredBy));
+
+ } catch (Exception e) {
+ log.error("[Orchestrator] Failed to process event {} for order {}: {}",
+ event, orderId, e.getMessage());
+ }
+ }
+
+ /**
+ * Build a StateMachine instance pre-restored to the given state.
+ * Using the factory (not a singleton) ensures each order gets isolated state.
+ */
+ private StateMachine buildStateMachine(
+ UUID orderId, Order.OrderStatus currentState) throws Exception {
+
+ StateMachine sm =
+ stateMachineFactory.getStateMachine(orderId.toString());
+
+ sm.stopReactively().block();
+
+ sm.getStateMachineAccessor()
+ .doWithAllRegions(accessor ->
+ accessor.resetStateMachineReactively(
+ new DefaultStateMachineContext<>(currentState, null, null, null)
+ ).block()
+ );
+
+ sm.startReactively().block();
+ return sm;
+ }
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/saga/orchestrator/OrderSagaStateMachineConfig.java b/order-service/src/main/java/com/hacisimsek/order/saga/orchestrator/OrderSagaStateMachineConfig.java
new file mode 100644
index 0000000..f6bcc54
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/saga/orchestrator/OrderSagaStateMachineConfig.java
@@ -0,0 +1,124 @@
+package com.hacisimsek.order.saga.orchestrator;
+
+import com.hacisimsek.order.model.Order;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.statemachine.config.EnableStateMachineFactory;
+import org.springframework.statemachine.config.StateMachineConfigurerAdapter;
+import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
+import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
+
+import java.util.EnumSet;
+
+/**
+ * Spring State Machine configuration for the Order Saga Orchestrator.
+ *
+ * This replaces the scattered choreography listeners with a single, explicit
+ * state machine that drives the entire order lifecycle from one place.
+ *
+ * States map 1:1 with Order.OrderStatus.
+ * Events (SagaEvent) represent outcomes from downstream services.
+ *
+ * Transitions:
+ *
+ * PENDING ──[ORDER_PLACED]──► INVENTORY_CHECKING
+ * INVENTORY_CHECKING ──[INVENTORY_RESERVED]──► PAYMENT_PROCESSING
+ * INVENTORY_CHECKING ──[INVENTORY_FAILED]──► CANCELLED
+ * PAYMENT_PROCESSING ──[PAYMENT_COMPLETED]──► SHIPPING_PROCESSING
+ * PAYMENT_PROCESSING ──[PAYMENT_FAILED]──► FAILED (+ compensate inventory)
+ * SHIPPING_PROCESSING ──[SHIPMENT_CREATED]──► SHIPPED
+ * SHIPPING_PROCESSING ──[SHIPMENT_FAILED]──► FAILED (+ compensate inventory)
+ * SHIPPED ──[DELIVERY_CONFIRMED]──► COMPLETED
+ *
+ * The factory produces one StateMachine per order (keyed by orderId).
+ */
+@Configuration
+@EnableStateMachineFactory
+@Slf4j
+public class OrderSagaStateMachineConfig
+ extends StateMachineConfigurerAdapter {
+
+ @Override
+ public void configure(StateMachineStateConfigurer states)
+ throws Exception {
+ states
+ .withStates()
+ .initial(Order.OrderStatus.PENDING)
+ .states(EnumSet.allOf(Order.OrderStatus.class))
+ .end(Order.OrderStatus.COMPLETED)
+ .end(Order.OrderStatus.CANCELLED)
+ .end(Order.OrderStatus.FAILED);
+ }
+
+ @Override
+ public void configure(StateMachineTransitionConfigurer transitions)
+ throws Exception {
+ transitions
+ // Order placed → start inventory check
+ .withExternal()
+ .source(Order.OrderStatus.PENDING)
+ .target(Order.OrderStatus.INVENTORY_CHECKING)
+ .event(SagaEvent.ORDER_PLACED)
+ .and()
+
+ // Inventory reserved → initiate payment
+ .withExternal()
+ .source(Order.OrderStatus.INVENTORY_CHECKING)
+ .target(Order.OrderStatus.INVENTORY_RESERVED)
+ .event(SagaEvent.INVENTORY_RESERVED)
+ .and()
+
+ .withExternal()
+ .source(Order.OrderStatus.INVENTORY_RESERVED)
+ .target(Order.OrderStatus.PAYMENT_PROCESSING)
+ .event(SagaEvent.INVENTORY_RESERVED)
+ .and()
+
+ // Inventory failed → cancel order (no compensation needed)
+ .withExternal()
+ .source(Order.OrderStatus.INVENTORY_CHECKING)
+ .target(Order.OrderStatus.CANCELLED)
+ .event(SagaEvent.INVENTORY_FAILED)
+ .and()
+
+ // Payment completed → initiate shipping
+ .withExternal()
+ .source(Order.OrderStatus.PAYMENT_PROCESSING)
+ .target(Order.OrderStatus.PAYMENT_COMPLETED)
+ .event(SagaEvent.PAYMENT_COMPLETED)
+ .and()
+
+ .withExternal()
+ .source(Order.OrderStatus.PAYMENT_COMPLETED)
+ .target(Order.OrderStatus.SHIPPING_PROCESSING)
+ .event(SagaEvent.PAYMENT_COMPLETED)
+ .and()
+
+ // Payment failed → fail order + compensate inventory
+ .withExternal()
+ .source(Order.OrderStatus.PAYMENT_PROCESSING)
+ .target(Order.OrderStatus.FAILED)
+ .event(SagaEvent.PAYMENT_FAILED)
+ .and()
+
+ // Shipment created → order shipped
+ .withExternal()
+ .source(Order.OrderStatus.SHIPPING_PROCESSING)
+ .target(Order.OrderStatus.SHIPPED)
+ .event(SagaEvent.SHIPMENT_CREATED)
+ .and()
+
+ // Shipment failed → fail order + compensate inventory
+ .withExternal()
+ .source(Order.OrderStatus.SHIPPING_PROCESSING)
+ .target(Order.OrderStatus.FAILED)
+ .event(SagaEvent.SHIPMENT_FAILED)
+ .and()
+
+ // Delivery confirmed → complete
+ .withExternal()
+ .source(Order.OrderStatus.SHIPPED)
+ .target(Order.OrderStatus.COMPLETED)
+ .event(SagaEvent.DELIVERY_CONFIRMED);
+ }
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/saga/orchestrator/SagaEvent.java b/order-service/src/main/java/com/hacisimsek/order/saga/orchestrator/SagaEvent.java
new file mode 100644
index 0000000..8d526c6
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/saga/orchestrator/SagaEvent.java
@@ -0,0 +1,16 @@
+package com.hacisimsek.order.saga.orchestrator;
+
+/**
+ * Events that drive the Order Saga state machine.
+ * Published by downstream services and received via Kafka listeners.
+ */
+public enum SagaEvent {
+ ORDER_PLACED,
+ INVENTORY_RESERVED,
+ INVENTORY_FAILED,
+ PAYMENT_COMPLETED,
+ PAYMENT_FAILED,
+ SHIPMENT_CREATED,
+ SHIPMENT_FAILED,
+ DELIVERY_CONFIRMED
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/service/impl/OrderServiceImpl.java b/order-service/src/main/java/com/hacisimsek/order/service/impl/OrderServiceImpl.java
index a57fab8..6493bb1 100644
--- a/order-service/src/main/java/com/hacisimsek/order/service/impl/OrderServiceImpl.java
+++ b/order-service/src/main/java/com/hacisimsek/order/service/impl/OrderServiceImpl.java
@@ -1,5 +1,7 @@
package com.hacisimsek.order.service.impl;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
import com.hacisimsek.common.dto.OrderItemDto;
import com.hacisimsek.common.event.order.OrderCreatedEvent;
import com.hacisimsek.order.dto.OrderItemResponse;
@@ -7,12 +9,13 @@
import com.hacisimsek.order.dto.OrderResponse;
import com.hacisimsek.order.model.Order;
import com.hacisimsek.order.model.OrderItem;
+import com.hacisimsek.order.outbox.OutboxEvent;
+import com.hacisimsek.order.outbox.OutboxEventRepository;
import com.hacisimsek.order.repository.OrderRepository;
import com.hacisimsek.order.service.OrderService;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import lombok.extern.slf4j.Slf4j;
-import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -21,19 +24,32 @@
import java.util.UUID;
import java.util.stream.Collectors;
+import com.hacisimsek.order.eventsourcing.OrderEvent;
+import com.hacisimsek.order.eventsourcing.OrderEventService;
+import com.hacisimsek.order.sse.OrderStatusEmitter;
+
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
private final OrderRepository orderRepository;
- private final KafkaTemplate kafkaTemplate;
+ private final OutboxEventRepository outboxEventRepository;
+ private final ObjectMapper objectMapper;
+ private final OrderStatusEmitter orderStatusEmitter;
+ private final OrderEventService orderEventService;
private final Counter ordersCreatedCounter;
public OrderServiceImpl(OrderRepository orderRepository,
- KafkaTemplate kafkaTemplate,
+ OutboxEventRepository outboxEventRepository,
+ ObjectMapper objectMapper,
+ OrderStatusEmitter orderStatusEmitter,
+ OrderEventService orderEventService,
MeterRegistry meterRegistry) {
this.orderRepository = orderRepository;
- this.kafkaTemplate = kafkaTemplate;
+ this.outboxEventRepository = outboxEventRepository;
+ this.objectMapper = objectMapper;
+ this.orderStatusEmitter = orderStatusEmitter;
+ this.orderEventService = orderEventService;
this.ordersCreatedCounter = Counter.builder("zexxity.orders.created")
.description("Total number of orders successfully created")
.register(meterRegistry);
@@ -42,7 +58,7 @@ public OrderServiceImpl(OrderRepository orderRepository,
@Override
@Transactional
public OrderResponse createOrder(OrderRequest orderRequest) {
- // Convert order items from request
+ // ── 1. Build and save the Order ──────────────────────────────────────
List orderItems = orderRequest.getItems().stream()
.map(item -> OrderItem.builder()
.productId(item.getProductId())
@@ -52,12 +68,10 @@ public OrderResponse createOrder(OrderRequest orderRequest) {
.build())
.collect(Collectors.toList());
- // Calculate total amount
BigDecimal totalAmount = orderItems.stream()
.map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())))
.reduce(BigDecimal.ZERO, BigDecimal::add);
- // Create and save order
Order order = Order.builder()
.customerId(orderRequest.getCustomerId())
.customerEmail(orderRequest.getCustomerEmail())
@@ -68,8 +82,9 @@ public OrderResponse createOrder(OrderRequest orderRequest) {
Order savedOrder = orderRepository.save(order);
- // Start the saga by sending OrderCreatedEvent
+ // ── 2. Build the Kafka event ──────────────────────────────────────────
UUID correlationId = UUID.randomUUID();
+
List itemDtos = savedOrder.getItems().stream()
.map(item -> new OrderItemDto(
item.getProductId(),
@@ -87,22 +102,51 @@ public OrderResponse createOrder(OrderRequest orderRequest) {
savedOrder.getTotalAmount()
);
- log.info("Sending OrderCreatedEvent for order {}", savedOrder.getId());
-
- // Increment Prometheus counter
+ // ── 3. Write to the Outbox in the SAME transaction ───────────────────
+ //
+ // By writing the OutboxEvent inside the same @Transactional method,
+ // both the Order row and the OutboxEvent row are committed atomically.
+ // If Kafka is unavailable, the OutboxPublisher scheduler will pick up
+ // and publish the pending row on the next tick (every 5 seconds).
+ // This eliminates the "dual-write" race condition in the original code.
+ try {
+ OutboxEvent outboxEntry = OutboxEvent.builder()
+ .topic("order-events")
+ .aggregateId(savedOrder.getId())
+ .eventType(OrderCreatedEvent.class.getName())
+ .payload(objectMapper.writeValueAsString(event))
+ .status(OutboxEvent.Status.PENDING)
+ .build();
+
+ outboxEventRepository.save(outboxEntry);
+ log.info("Order {} saved with outbox entry (correlationId={})",
+ savedOrder.getId(), correlationId);
+ } catch (JsonProcessingException ex) {
+ // This would be a programming error (unparseable event) — rethrow
+ throw new IllegalStateException("Failed to serialize OrderCreatedEvent for outbox", ex);
+ }
+
+ // ── 4. Update status and metrics ─────────────────────────────────────
ordersCreatedCounter.increment();
-
- // Update order status to indicate saga started
savedOrder.setStatus(Order.OrderStatus.INVENTORY_CHECKING);
orderRepository.save(savedOrder);
- // Publish event to Kafka
- log.info("BEFORE Kafka Send");
+ // Append ORDER_CREATED event to the immutable event log
+ orderEventService.append(
+ savedOrder.getId(), correlationId,
+ OrderEvent.EventType.ORDER_CREATED,
+ null, Order.OrderStatus.PENDING,
+ "order-service", "Order created with " + itemDtos.size() + " item(s)");
-// Publish event to Kafka
- kafkaTemplate.send("order-events", event);
+ // Append INVENTORY_CHECKING event
+ orderEventService.append(
+ savedOrder.getId(), correlationId,
+ OrderEvent.EventType.INVENTORY_CHECKING,
+ Order.OrderStatus.PENDING, Order.OrderStatus.INVENTORY_CHECKING,
+ "order-service", "Saga started — checking inventory");
- log.info("AFTER Kafka Send");
+ // Push initial status to any SSE subscriber
+ orderStatusEmitter.push(savedOrder.getId(), Order.OrderStatus.INVENTORY_CHECKING.name(), false);
return mapToOrderResponse(savedOrder);
}
@@ -133,9 +177,49 @@ public List getOrdersByCustomerId(UUID customerId) {
public void updateOrderStatus(UUID orderId, Order.OrderStatus status) {
Order order = orderRepository.findById(orderId)
.orElseThrow(() -> new RuntimeException("Order not found with id: " + orderId));
+
+ Order.OrderStatus previousStatus = order.getStatus();
order.setStatus(status);
orderRepository.save(order);
log.info("Updated order {} status to {}", orderId, status);
+
+ // Append transition event to the immutable event log
+ OrderEvent.EventType eventType = resolveEventType(status);
+ orderEventService.append(
+ orderId, null,
+ eventType,
+ previousStatus, status,
+ "saga", null);
+
+ // Push real-time status update via SSE
+ boolean terminal = isTerminalStatus(status);
+ orderStatusEmitter.push(orderId, status.name(), terminal);
+ }
+
+ private OrderEvent.EventType resolveEventType(Order.OrderStatus status) {
+ return switch (status) {
+ case INVENTORY_CHECKING -> OrderEvent.EventType.INVENTORY_CHECKING;
+ case INVENTORY_RESERVED -> OrderEvent.EventType.INVENTORY_RESERVED;
+ case PAYMENT_PROCESSING -> OrderEvent.EventType.PAYMENT_PROCESSING;
+ case PAYMENT_COMPLETED -> OrderEvent.EventType.PAYMENT_COMPLETED;
+ case SHIPPING_PROCESSING -> OrderEvent.EventType.SHIPPING_PROCESSING;
+ case SHIPPED -> OrderEvent.EventType.ORDER_SHIPPED;
+ case COMPLETED -> OrderEvent.EventType.ORDER_COMPLETED;
+ case CANCELLED -> OrderEvent.EventType.ORDER_CANCELLED;
+ case FAILED -> OrderEvent.EventType.ORDER_FAILED;
+ default -> OrderEvent.EventType.ORDER_CREATED;
+ };
+ }
+
+ /**
+ * Terminal statuses — the saga has reached a final state.
+ * After these, no further status changes will occur.
+ */
+ private boolean isTerminalStatus(Order.OrderStatus status) {
+ return status == Order.OrderStatus.SHIPPED
+ || status == Order.OrderStatus.COMPLETED
+ || status == Order.OrderStatus.FAILED
+ || status == Order.OrderStatus.CANCELLED;
}
private OrderResponse mapToOrderResponse(Order order) {
@@ -160,4 +244,4 @@ private OrderResponse mapToOrderResponse(Order order) {
.lastModifiedAt(order.getLastModifiedAt())
.build();
}
-}
\ No newline at end of file
+}
diff --git a/order-service/src/main/java/com/hacisimsek/order/sse/OrderStatusEmitter.java b/order-service/src/main/java/com/hacisimsek/order/sse/OrderStatusEmitter.java
new file mode 100644
index 0000000..f3f466e
--- /dev/null
+++ b/order-service/src/main/java/com/hacisimsek/order/sse/OrderStatusEmitter.java
@@ -0,0 +1,121 @@
+package com.hacisimsek.order.sse;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
+
+import java.io.IOException;
+import java.time.Instant;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Manages active SSE (Server-Sent Events) connections for order status updates.
+ *
+ * Each client subscribes to a specific orderId. When the order status changes
+ * (driven by saga events), the saga handler calls {@link #push} and the update
+ * is streamed instantly to any connected browser/client — no polling needed.
+ *
+ * Connection lifecycle:
+ * - Client opens GET /api/orders/{orderId}/status-stream
+ * - Server holds the connection open (SseEmitter with 5-min timeout)
+ * - On status change → push event to that orderId's emitter
+ * - On COMPLETED/CANCELLED/FAILED → push final event and complete the stream
+ * - On timeout or client disconnect → emitter is cleaned up automatically
+ *
+ * Thread safety: ConcurrentHashMap handles concurrent subscribe/push/cleanup.
+ */
+@Component
+@Slf4j
+public class OrderStatusEmitter {
+
+ // orderId → active SseEmitter for that order
+ private final Map emitters = new ConcurrentHashMap<>();
+
+ /** SSE connection timeout — 5 minutes. Client should reconnect if needed. */
+ private static final long TIMEOUT_MS = 5 * 60 * 1000L;
+
+ /**
+ * Register a new SSE connection for the given orderId.
+ * Returns the emitter to be written directly to the HTTP response.
+ */
+ public SseEmitter subscribe(UUID orderId) {
+ SseEmitter emitter = new SseEmitter(TIMEOUT_MS);
+
+ // Clean up on completion, timeout, or error
+ emitter.onCompletion(() -> {
+ emitters.remove(orderId);
+ log.debug("[SSE] Connection completed for order {}", orderId);
+ });
+ emitter.onTimeout(() -> {
+ emitters.remove(orderId);
+ log.debug("[SSE] Connection timed out for order {}", orderId);
+ });
+ emitter.onError(ex -> {
+ emitters.remove(orderId);
+ log.debug("[SSE] Connection error for order {}: {}", orderId, ex.getMessage());
+ });
+
+ emitters.put(orderId, emitter);
+ log.info("[SSE] Client subscribed to order {} status stream (active connections: {})",
+ orderId, emitters.size());
+
+ // Send an initial "connected" event so the client knows the stream is live
+ try {
+ emitter.send(SseEmitter.event()
+ .name("connected")
+ .data("{\"orderId\":\"" + orderId + "\",\"message\":\"Subscribed to order status stream\"}"));
+ } catch (IOException e) {
+ emitters.remove(orderId);
+ }
+
+ return emitter;
+ }
+
+ /**
+ * Push a status update to the client subscribed to this orderId.
+ * Called by {@link com.hacisimsek.order.service.impl.OrderServiceImpl}
+ * whenever the order status changes.
+ *
+ * @param orderId the order that changed
+ * @param newStatus the new status string (e.g. "PAYMENT_COMPLETED")
+ * @param terminal true if this is the final state (SHIPPED, COMPLETED, FAILED, CANCELLED)
+ */
+ public void push(UUID orderId, String newStatus, boolean terminal) {
+ SseEmitter emitter = emitters.get(orderId);
+ if (emitter == null) {
+ // No connected client — that's fine, most users poll instead of streaming
+ return;
+ }
+
+ String payload = String.format(
+ "{\"orderId\":\"%s\",\"status\":\"%s\",\"timestamp\":\"%s\"}",
+ orderId, newStatus, Instant.now());
+
+ try {
+ emitter.send(SseEmitter.event()
+ .name("status-update")
+ .data(payload));
+
+ log.info("[SSE] Pushed status {} to order {} subscriber", newStatus, orderId);
+
+ // Complete the stream on terminal states — no more updates coming
+ if (terminal) {
+ emitter.send(SseEmitter.event()
+ .name("complete")
+ .data("{\"message\":\"Order reached terminal state: " + newStatus + "\"}"));
+ emitter.complete();
+ emitters.remove(orderId);
+ }
+ } catch (IOException e) {
+ log.warn("[SSE] Failed to push to order {} subscriber — removing: {}", orderId, e.getMessage());
+ emitters.remove(orderId);
+ }
+ }
+
+ /** Returns the number of active SSE connections — useful for monitoring */
+ public int activeConnections() {
+ return emitters.size();
+ }
+}
diff --git a/order-service/src/main/resources/application.yml b/order-service/src/main/resources/application.yml
new file mode 100644
index 0000000..7e90175
--- /dev/null
+++ b/order-service/src/main/resources/application.yml
@@ -0,0 +1,75 @@
+server:
+ port: 8081
+
+spring:
+ application:
+ name: order-service
+
+ datasource:
+ url: jdbc:postgresql://${DB_HOST:localhost}:${DB_PORT:5432}/order_db
+ username: ${DB_USER:postgres}
+ password: ${DB_PASSWORD:postgres}
+ driver-class-name: org.postgresql.Driver
+ hikari:
+ maximum-pool-size: 10
+ minimum-idle: 2
+ connection-timeout: 30000
+ idle-timeout: 600000
+ max-lifetime: 1800000
+
+ jpa:
+ hibernate:
+ ddl-auto: update
+ show-sql: false
+ properties:
+ hibernate:
+ format_sql: true
+ dialect: org.hibernate.dialect.PostgreSQLDialect
+
+ kafka:
+ bootstrap-servers: ${KAFKA_BOOTSTRAP_SERVERS:localhost:9095}
+ producer:
+ key-serializer: org.apache.kafka.common.serialization.StringSerializer
+ value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
+ properties:
+ spring.json.add.type.headers: true
+ consumer:
+ group-id: order-service-group
+ auto-offset-reset: earliest
+ enable-auto-commit: false
+ properties:
+ session.timeout.ms: 30000
+ heartbeat.interval.ms: 10000
+ max.poll.interval.ms: 300000
+ listener:
+ ack-mode: record
+
+eureka:
+ client:
+ service-url:
+ defaultZone: http://${EUREKA_HOST:localhost}:8761/eureka/
+ instance:
+ prefer-ip-address: true
+
+management:
+ endpoints:
+ web:
+ exposure:
+ include: health,info,prometheus,metrics
+ endpoint:
+ health:
+ show-details: always
+ prometheus:
+ enabled: true
+ metrics:
+ tags:
+ application: ${spring.application.name}
+ distribution:
+ percentiles-histogram:
+ http.server.requests: true
+ percentiles:
+ http.server.requests: 0.5, 0.95, 0.99
+
+logging:
+ level:
+ com.hacisimsek.order: INFO
diff --git a/payment-service/Dockerfile b/payment-service/Dockerfile
new file mode 100644
index 0000000..0ead949
--- /dev/null
+++ b/payment-service/Dockerfile
@@ -0,0 +1,29 @@
+# -- Stage 1: Build ----------------------------------------------------------
+FROM eclipse-temurin:21-jdk-alpine AS builder
+WORKDIR /build
+
+COPY pom.xml .
+COPY common-library/pom.xml common-library/
+COPY common-library/src common-library/src
+COPY payment-service/pom.xml payment-service/
+COPY payment-service/src payment-service/src
+
+RUN --mount=type=cache,target=/root/.m2 `
+ ./mvnw -pl common-library,payment-service -am clean package -DskipTests --no-transfer-progress
+
+# -- Stage 2: Runtime --------------------------------------------------------
+FROM eclipse-temurin:21-jre-alpine
+WORKDIR /app
+
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+
+COPY --from=builder /build/payment-service/target/*.jar app.jar
+
+EXPOSE 8083
+
+ENTRYPOINT ["java", `
+ "-XX:+UseContainerSupport", `
+ "-XX:MaxRAMPercentage=75.0", `
+ "-Djava.security.egd=file:/dev/./urandom", `
+ "-jar", "app.jar"]
diff --git a/payment-service/pom.xml b/payment-service/pom.xml
index d2e3be4..0f51b1f 100644
--- a/payment-service/pom.xml
+++ b/payment-service/pom.xml
@@ -66,6 +66,11 @@
io.micrometer
micrometer-registry-prometheus
+
+
+ org.springdoc
+ springdoc-openapi-starter-webmvc-ui
+
diff --git a/payment-service/src/main/java/com/hacisimsek/payment/controller/PaymentController.java b/payment-service/src/main/java/com/hacisimsek/payment/controller/PaymentController.java
index 93b398e..5ac866c 100644
--- a/payment-service/src/main/java/com/hacisimsek/payment/controller/PaymentController.java
+++ b/payment-service/src/main/java/com/hacisimsek/payment/controller/PaymentController.java
@@ -1,4 +1,4 @@
-package com.hacisimsek.payment.controller;
+package com.hacisimsek.payment.controller;
import com.hacisimsek.payment.dto.GatewayOrderResponse;
import com.hacisimsek.payment.dto.InitiatePaymentRequest;
@@ -24,7 +24,7 @@
import java.util.UUID;
@RestController
-@RequestMapping("/api/payments")
+@RequestMapping("/api/v1/payments")
@RequiredArgsConstructor
@Slf4j
public class PaymentController {
@@ -32,7 +32,7 @@ public class PaymentController {
private final PaymentService paymentService;
private final RestTemplate restTemplate;
- /** Initiate a payment — returns gateway order/session for frontend checkout UI. */
+ /** Initiate a payment — returns gateway order/session for frontend checkout UI. */
@PostMapping("/initiate")
public ResponseEntity initiatePayment(
@Valid @RequestBody InitiatePaymentRequest request) {
diff --git a/payment-service/src/main/java/com/hacisimsek/payment/controller/WebhookController.java b/payment-service/src/main/java/com/hacisimsek/payment/controller/WebhookController.java
index 0aeb8a7..2917383 100644
--- a/payment-service/src/main/java/com/hacisimsek/payment/controller/WebhookController.java
+++ b/payment-service/src/main/java/com/hacisimsek/payment/controller/WebhookController.java
@@ -1,4 +1,4 @@
-package com.hacisimsek.payment.controller;
+package com.hacisimsek.payment.controller;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
@@ -23,13 +23,13 @@
/**
* Receives webhook events pushed by Razorpay to your server.
*
- * Razorpay Dashboard → Settings → Webhooks → Add new webhook:
+ * Razorpay Dashboard → Settings → Webhooks → Add new webhook:
* URL: https:///api/payments/webhook/razorpay
* Events: payment.captured, payment.failed, refund.created
* Secret: value of RAZORPAY_WEBHOOK_SECRET env var
*
* IMPORTANT: This endpoint is intentionally excluded from JWT auth in the
- * API Gateway / Security config — Razorpay calls it directly, not the user.
+ * API Gateway / Security config — Razorpay calls it directly, not the user.
* Security is provided solely by HMAC-SHA256 signature verification.
*
* Spring must receive the raw bytes (not a parsed object) so the signature
@@ -37,7 +37,7 @@
* and convert to String only after verification passes.
*/
@RestController
-@RequestMapping("/api/payments/webhook")
+@RequestMapping("/api/v1/payments/webhook")
@RequiredArgsConstructor
@Slf4j
public class WebhookController {
@@ -45,7 +45,7 @@ public class WebhookController {
private final PaymentService paymentService;
private final ObjectMapper objectMapper;
- /** All gateway adapters — used to look up the Razorpay adapter by type. */
+ /** All gateway adapters — used to look up the Razorpay adapter by type. */
private final List gatewayAdapters;
/**
@@ -56,9 +56,9 @@ public class WebhookController {
* X-Razorpay-Signature:
*
* Response contract:
- * 200 OK → event acknowledged (Razorpay will not retry)
- * 400 → signature invalid (logged, no retry by Razorpay for bad sig)
- * 500 → processing error (Razorpay WILL retry — safe to throw on transient errors)
+ * 200 OK → event acknowledged (Razorpay will not retry)
+ * 400 → signature invalid (logged, no retry by Razorpay for bad sig)
+ * 500 → processing error (Razorpay WILL retry — safe to throw on transient errors)
*/
@PostMapping(
value = "/razorpay",
@@ -73,24 +73,24 @@ public ResponseEntity> handleRazorpayWebhook(
log.info("[Webhook] Razorpay event received, bodyLength={}, signaturePresent={}",
rawBody.length, signature != null);
- // ── 1. Verify HMAC signature ──────────────────────────────────────────
+ // ── 1. Verify HMAC signature ──────────────────────────────────────────
PaymentGatewayAdapter razorpayAdapter = resolveAdapter(Payment.PaymentGateway.RAZORPAY);
boolean signatureValid = razorpayAdapter.verifyWebhookSignature(bodyString, signature);
if (!signatureValid) {
- log.error("[Webhook] Razorpay signature verification FAILED — rejecting event");
+ log.error("[Webhook] Razorpay signature verification FAILED — rejecting event");
return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.body(Map.of("status", "error", "message", "Invalid signature"));
}
- // ── 2. Parse event type ───────────────────────────────────────────────
+ // ── 2. Parse event type ───────────────────────────────────────────────
String eventType;
try {
JsonNode root = objectMapper.readTree(bodyString);
eventType = root.path("event").asText();
if (eventType.isBlank()) {
- log.warn("[Webhook] No 'event' field in payload — ignoring");
+ log.warn("[Webhook] No 'event' field in payload — ignoring");
return ResponseEntity.ok(Map.of("status", "ignored", "reason", "missing event field"));
}
} catch (Exception e) {
@@ -100,7 +100,7 @@ public ResponseEntity> handleRazorpayWebhook(
.body(Map.of("status", "error", "message", "Invalid JSON payload"));
}
- // ── 3. Delegate to service ────────────────────────────────────────────
+ // ── 3. Delegate to service ────────────────────────────────────────────
try {
paymentService.handleWebhookEvent(eventType, bodyString);
log.info("[Webhook] Event '{}' processed successfully", eventType);
@@ -110,11 +110,11 @@ public ResponseEntity> handleRazorpayWebhook(
log.error("[Webhook] Error processing event '{}': {}", eventType, e.getMessage(), e);
return ResponseEntity
.status(HttpStatus.INTERNAL_SERVER_ERROR)
- .body(Map.of("status", "error", "message", "Processing failed — will retry"));
+ .body(Map.of("status", "error", "message", "Processing failed — will retry"));
}
}
- // ── Helper ────────────────────────────────────────────────────────────────
+ // ── Helper ────────────────────────────────────────────────────────────────
private PaymentGatewayAdapter resolveAdapter(Payment.PaymentGateway gateway) {
Map index = gatewayAdapters.stream()
diff --git a/payment-service/src/main/resources/application.yml b/payment-service/src/main/resources/application.yml
index f09ee9a..886ed71 100644
--- a/payment-service/src/main/resources/application.yml
+++ b/payment-service/src/main/resources/application.yml
@@ -126,3 +126,9 @@ management:
#GET http://localhost:8080/api/orders/98c44782-f8ec-4ff0-bf22-e276ffb43a4e
+
+#
+# SELECT *
+# FROM transactions
+# WHERE created_at >= CURRENT_TIMESTAMP - INTERVAL '5 days'
+# ORDER BY created_at DESC;
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index fccda22..5fb93a6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -25,6 +25,7 @@
2023.0.2
1.18.38
1.5.5.Final
+ 2.5.0
@@ -61,6 +62,20 @@
mapstruct
${mapstruct.version}
+
+
+
+ org.springdoc
+ springdoc-openapi-starter-webmvc-ui
+ ${springdoc.version}
+
+
+
+
+ org.springdoc
+ springdoc-openapi-starter-webflux-ui
+ ${springdoc.version}
+
diff --git a/product-service/Dockerfile b/product-service/Dockerfile
new file mode 100644
index 0000000..f6e6aa1
--- /dev/null
+++ b/product-service/Dockerfile
@@ -0,0 +1,29 @@
+# -- Stage 1: Build ----------------------------------------------------------
+FROM eclipse-temurin:21-jdk-alpine AS builder
+WORKDIR /build
+
+COPY pom.xml .
+COPY common-library/pom.xml common-library/
+COPY common-library/src common-library/src
+COPY product-service/pom.xml product-service/
+COPY product-service/src product-service/src
+
+RUN --mount=type=cache,target=/root/.m2 `
+ ./mvnw -pl common-library,product-service -am clean package -DskipTests --no-transfer-progress
+
+# -- Stage 2: Runtime --------------------------------------------------------
+FROM eclipse-temurin:21-jre-alpine
+WORKDIR /app
+
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+
+COPY --from=builder /build/product-service/target/*.jar app.jar
+
+EXPOSE 8088
+
+ENTRYPOINT ["java", `
+ "-XX:+UseContainerSupport", `
+ "-XX:MaxRAMPercentage=75.0", `
+ "-Djava.security.egd=file:/dev/./urandom", `
+ "-jar", "app.jar"]
diff --git a/product-service/pom.xml b/product-service/pom.xml
index 5886223..3acc2e0 100644
--- a/product-service/pom.xml
+++ b/product-service/pom.xml
@@ -48,28 +48,9 @@
lombok
true
+
+
+ org.springdoc
+ springdoc-openapi-starter-webmvc-ui
+
-
-
-
-
- org.springframework.boot
- spring-boot-maven-plugin
-
-
- org.apache.maven.plugins
- maven-compiler-plugin
-
-
-
- org.projectlombok
- lombok
- ${lombok.version}
-
-
-
-
-
-
-
-
diff --git a/product-service/src/main/java/com/hacisimsek/product/controller/CategoryController.java b/product-service/src/main/java/com/hacisimsek/product/controller/CategoryController.java
index e9fea51..4c09b61 100644
--- a/product-service/src/main/java/com/hacisimsek/product/controller/CategoryController.java
+++ b/product-service/src/main/java/com/hacisimsek/product/controller/CategoryController.java
@@ -1,4 +1,4 @@
-package com.hacisimsek.product.controller;
+package com.hacisimsek.product.controller;
import com.hacisimsek.product.dto.CategoryRequest;
import com.hacisimsek.product.model.Category;
@@ -20,7 +20,7 @@
import java.util.UUID;
@RestController
-@RequestMapping("/api/products/categories")
+@RequestMapping("/api/v1/products/categories")
@RequiredArgsConstructor
public class CategoryController {
diff --git a/product-service/src/main/java/com/hacisimsek/product/controller/ProductController.java b/product-service/src/main/java/com/hacisimsek/product/controller/ProductController.java
index 97a9021..9f0b4e2 100644
--- a/product-service/src/main/java/com/hacisimsek/product/controller/ProductController.java
+++ b/product-service/src/main/java/com/hacisimsek/product/controller/ProductController.java
@@ -1,10 +1,12 @@
-package com.hacisimsek.product.controller;
+package com.hacisimsek.product.controller;
import com.hacisimsek.product.dto.ProductRequest;
import com.hacisimsek.product.dto.ProductResponse;
import com.hacisimsek.product.dto.ProductStatusUpdateRequest;
import com.hacisimsek.product.model.ProductStatus;
import com.hacisimsek.product.service.ProductService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
@@ -30,13 +32,13 @@
import java.util.UUID;
@RestController
-@RequestMapping("/api/products")
+@RequestMapping("/api/v1/products")
@RequiredArgsConstructor
public class ProductController {
private final ProductService productService;
- // ── CRUD ──────────────────────────────────────────────────────────────────
+ // ── CRUD ──────────────────────────────────────────────────────────────────
/**
* Create a product. Seller UUID is taken from the JWT header injected by API Gateway.
@@ -92,7 +94,7 @@ public ResponseEntity deleteProduct(@PathVariable UUID id) {
return ResponseEntity.noContent().build();
}
- // ── List / Search / Filter with Pagination ────────────────────────────────
+ // ── List / Search / Filter with Pagination ────────────────────────────────
/**
* Full-text search with optional filters and pagination.
diff --git a/product-service/src/main/java/com/hacisimsek/product/repository/ProductRepository.java b/product-service/src/main/java/com/hacisimsek/product/repository/ProductRepository.java
index 2f311f1..dbcb9b0 100644
--- a/product-service/src/main/java/com/hacisimsek/product/repository/ProductRepository.java
+++ b/product-service/src/main/java/com/hacisimsek/product/repository/ProductRepository.java
@@ -31,6 +31,8 @@ public interface ProductRepository extends JpaRepository {
LEFT JOIN FETCH p.category
WHERE p.status = :status
""")
+// The main reason we used JOIN FETCH in your ProductRepository is to prevent
+// the N+1 query problem when your code needs Product and its Category.
Page findByStatus(@Param("status") ProductStatus status, Pageable pageable);
@Query("""
diff --git a/product-service/src/main/java/com/hacisimsek/product/service/ProductService.java b/product-service/src/main/java/com/hacisimsek/product/service/ProductService.java
index 97cdeb2..52b6588 100644
--- a/product-service/src/main/java/com/hacisimsek/product/service/ProductService.java
+++ b/product-service/src/main/java/com/hacisimsek/product/service/ProductService.java
@@ -90,7 +90,8 @@ public ProductResponse updateProduct(UUID id, UUID sellerId, ProductRequest requ
product.setCategory(category);
}
- return toResponse(productRepository.save(product));
+ Product updated = productRepository.save(product);
+ return toResponse(updated);
}
@Transactional
diff --git a/product-service/src/main/resources/application.yml b/product-service/src/main/resources/application.yml
index 29a6abf..1cc5908 100644
--- a/product-service/src/main/resources/application.yml
+++ b/product-service/src/main/resources/application.yml
@@ -1,4 +1,4 @@
-server:
+server:
port: 8088
spring:
@@ -10,11 +10,14 @@ spring:
username: ${DB_USER:postgres}
password: ${DB_PASSWORD:postgres}
driver-class-name: org.postgresql.Driver
+ hikari:
+ maximum-pool-size: 10
+ minimum-idle: 2
jpa:
hibernate:
ddl-auto: update
- show-sql: true
+ show-sql: false
properties:
hibernate:
format_sql: true
@@ -27,16 +30,18 @@ eureka:
instance:
prefer-ip-address: true
-logging:
- level:
- com.hacisimsek.product: DEBUG
-
management:
endpoints:
web:
exposure:
- include: "*"
-
-
-
+ include: health,info,prometheus,metrics
+ endpoint:
+ health:
+ show-details: always
+ metrics:
+ tags:
+ application: ${spring.application.name}
+logging:
+ level:
+ com.hacisimsek.product: INFO
diff --git a/seller-service/Dockerfile b/seller-service/Dockerfile
new file mode 100644
index 0000000..06a44e9
--- /dev/null
+++ b/seller-service/Dockerfile
@@ -0,0 +1,29 @@
+# -- Stage 1: Build ----------------------------------------------------------
+FROM eclipse-temurin:21-jdk-alpine AS builder
+WORKDIR /build
+
+COPY pom.xml .
+COPY common-library/pom.xml common-library/
+COPY common-library/src common-library/src
+COPY seller-service/pom.xml seller-service/
+COPY seller-service/src seller-service/src
+
+RUN --mount=type=cache,target=/root/.m2 `
+ ./mvnw -pl common-library,seller-service -am clean package -DskipTests --no-transfer-progress
+
+# -- Stage 2: Runtime --------------------------------------------------------
+FROM eclipse-temurin:21-jre-alpine
+WORKDIR /app
+
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+
+COPY --from=builder /build/seller-service/target/*.jar app.jar
+
+EXPOSE 8091
+
+ENTRYPOINT ["java", `
+ "-XX:+UseContainerSupport", `
+ "-XX:MaxRAMPercentage=75.0", `
+ "-Djava.security.egd=file:/dev/./urandom", `
+ "-jar", "app.jar"]
diff --git a/seller-service/pom.xml b/seller-service/pom.xml
index c6b4fdd..835fad7 100644
--- a/seller-service/pom.xml
+++ b/seller-service/pom.xml
@@ -50,28 +50,9 @@
lombok
true
+
+
+ org.springdoc
+ springdoc-openapi-starter-webmvc-ui
+
-
-
-
-
- org.springframework.boot
- spring-boot-maven-plugin
-
-
- org.apache.maven.plugins
- maven-compiler-plugin
-
-
-
- org.projectlombok
- lombok
- ${lombok.version}
-
-
-
-
-
-
-
-
diff --git a/seller-service/src/main/java/com/hacisimsek/seller/controller/SellerAdminController.java b/seller-service/src/main/java/com/hacisimsek/seller/controller/SellerAdminController.java
index 1f6daa3..b9bca55 100644
--- a/seller-service/src/main/java/com/hacisimsek/seller/controller/SellerAdminController.java
+++ b/seller-service/src/main/java/com/hacisimsek/seller/controller/SellerAdminController.java
@@ -1,4 +1,4 @@
-package com.hacisimsek.seller.controller;
+package com.hacisimsek.seller.controller;
import com.hacisimsek.seller.dto.SellerProfileResponse;
import com.hacisimsek.seller.model.VerificationStatus;
@@ -21,13 +21,13 @@
* in the API Gateway or a Spring Security filter.
*/
@RestController
-@RequestMapping("/api/admin/sellers")
+@RequestMapping("/api/v1/admin/sellers")
@RequiredArgsConstructor
public class SellerAdminController {
private final SellerService sellerService;
- /** Update seller verification status — VERIFIED, REJECTED, SUSPENDED, etc. */
+ /** Update seller verification status — VERIFIED, REJECTED, SUSPENDED, etc. */
@PatchMapping("/{sellerId}/verify")
public ResponseEntity updateVerification(
@PathVariable UUID sellerId,
diff --git a/seller-service/src/main/java/com/hacisimsek/seller/controller/SellerController.java b/seller-service/src/main/java/com/hacisimsek/seller/controller/SellerController.java
index cd8e0d9..d66e929 100644
--- a/seller-service/src/main/java/com/hacisimsek/seller/controller/SellerController.java
+++ b/seller-service/src/main/java/com/hacisimsek/seller/controller/SellerController.java
@@ -1,4 +1,4 @@
-package com.hacisimsek.seller.controller;
+package com.hacisimsek.seller.controller;
import com.hacisimsek.seller.dto.OrderSummary;
import com.hacisimsek.seller.dto.ProductSummary;
@@ -23,7 +23,7 @@
import java.util.UUID;
@RestController
-@RequestMapping("/api/seller")
+@RequestMapping("/api/v1/seller")
@RequiredArgsConstructor
public class SellerController {
@@ -78,7 +78,7 @@ public ResponseEntity> getSellerOrders(
}
/**
- * Sales analytics — total orders, revenue, average order value, product count.
+ * Sales analytics — total orders, revenue, average order value, product count.
* Requires VERIFIED status.
*/
@GetMapping("/analytics")
diff --git a/service-registry/Dockerfile b/service-registry/Dockerfile
new file mode 100644
index 0000000..2d9343b
--- /dev/null
+++ b/service-registry/Dockerfile
@@ -0,0 +1,29 @@
+# -- Stage 1: Build ----------------------------------------------------------
+FROM eclipse-temurin:21-jdk-alpine AS builder
+WORKDIR /build
+
+COPY pom.xml .
+COPY common-library/pom.xml common-library/
+COPY common-library/src common-library/src
+COPY service-registry/pom.xml service-registry/
+COPY service-registry/src service-registry/src
+
+RUN --mount=type=cache,target=/root/.m2 `
+ ./mvnw -pl common-library,service-registry -am clean package -DskipTests --no-transfer-progress
+
+# -- Stage 2: Runtime --------------------------------------------------------
+FROM eclipse-temurin:21-jre-alpine
+WORKDIR /app
+
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+
+COPY --from=builder /build/service-registry/target/*.jar app.jar
+
+EXPOSE 8761
+
+ENTRYPOINT ["java", `
+ "-XX:+UseContainerSupport", `
+ "-XX:MaxRAMPercentage=75.0", `
+ "-Djava.security.egd=file:/dev/./urandom", `
+ "-jar", "app.jar"]
diff --git a/shipping-service/Dockerfile b/shipping-service/Dockerfile
new file mode 100644
index 0000000..b0c0a16
--- /dev/null
+++ b/shipping-service/Dockerfile
@@ -0,0 +1,29 @@
+# -- Stage 1: Build ----------------------------------------------------------
+FROM eclipse-temurin:21-jdk-alpine AS builder
+WORKDIR /build
+
+COPY pom.xml .
+COPY common-library/pom.xml common-library/
+COPY common-library/src common-library/src
+COPY shipping-service/pom.xml shipping-service/
+COPY shipping-service/src shipping-service/src
+
+RUN --mount=type=cache,target=/root/.m2 `
+ ./mvnw -pl common-library,shipping-service -am clean package -DskipTests --no-transfer-progress
+
+# -- Stage 2: Runtime --------------------------------------------------------
+FROM eclipse-temurin:21-jre-alpine
+WORKDIR /app
+
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+
+COPY --from=builder /build/shipping-service/target/*.jar app.jar
+
+EXPOSE 8085
+
+ENTRYPOINT ["java", `
+ "-XX:+UseContainerSupport", `
+ "-XX:MaxRAMPercentage=75.0", `
+ "-Djava.security.egd=file:/dev/./urandom", `
+ "-jar", "app.jar"]
diff --git a/shipping-service/pom.xml b/shipping-service/pom.xml
index 09b5b3b..5db14b9 100644
--- a/shipping-service/pom.xml
+++ b/shipping-service/pom.xml
@@ -47,6 +47,11 @@
io.micrometer
micrometer-registry-prometheus
+
+
+ org.springdoc
+ springdoc-openapi-starter-webmvc-ui
+
diff --git a/shipping-service/src/main/java/com/hacisimsek/shipping/controller/ShippingController.java b/shipping-service/src/main/java/com/hacisimsek/shipping/controller/ShippingController.java
index 9e6128c..ee1ae1a 100644
--- a/shipping-service/src/main/java/com/hacisimsek/shipping/controller/ShippingController.java
+++ b/shipping-service/src/main/java/com/hacisimsek/shipping/controller/ShippingController.java
@@ -1,4 +1,4 @@
-package com.hacisimsek.shipping.controller;
+package com.hacisimsek.shipping.controller;
import com.hacisimsek.shipping.model.Shipment;
import com.hacisimsek.shipping.service.ShippingService;
@@ -9,7 +9,7 @@
import java.util.UUID;
@RestController
-@RequestMapping("/api/shipping")
+@RequestMapping("/api/v1/shipping")
@RequiredArgsConstructor
public class ShippingController {
diff --git a/shipping-service/src/main/java/com/hacisimsek/shipping/service/impl/ShippingServiceImpl.java b/shipping-service/src/main/java/com/hacisimsek/shipping/service/impl/ShippingServiceImpl.java
index eed1925..f02de4d 100644
--- a/shipping-service/src/main/java/com/hacisimsek/shipping/service/impl/ShippingServiceImpl.java
+++ b/shipping-service/src/main/java/com/hacisimsek/shipping/service/impl/ShippingServiceImpl.java
@@ -71,6 +71,14 @@ public void processShipping(PaymentProcessedEvent paymentEvent) {
paymentEvent.getCustomerEmail(),
savedShipment.getTrackingNumber()
);
+// ShipmentProcessedEvent shipmentEvent = ShipmentProcessedEvent.builder()
+// .correlationId(paymentEvent.getCorrelationId())
+// .orderId(paymentEvent.getOrderId())
+// .shipmentId(savedShipment.getId())
+// .customerId(savedShipment.getCustomerId())
+// .customerEmail(paymentEvent.getCustomerEmail())
+// .trackingNumber(savedShipment.getTrackingNumber())
+// .build();
kafkaTemplate.send("shipping-events", shipmentEvent);
log.info("Order shipped successfully. Order ID: {}, Tracking: {}",
diff --git a/shipping-service/src/main/resources/application.properties b/shipping-service/src/main/resources/application.properties
index cfa1030..e0dd941 100644
--- a/shipping-service/src/main/resources/application.properties
+++ b/shipping-service/src/main/resources/application.properties
@@ -1 +1,2 @@
spring.application.name=shipping-service
+#spring.serverr-port:8085
\ No newline at end of file
diff --git a/shipping-service/src/main/resources/application.yml b/shipping-service/src/main/resources/application.yml
index ce7a2c9..4bfc289 100644
--- a/shipping-service/src/main/resources/application.yml
+++ b/shipping-service/src/main/resources/application.yml
@@ -35,8 +35,11 @@ spring:
enable-auto-commit: false
properties:
session.timeout.ms: 30000
+# How long Kafka waits without heartbeats before considering consumer dead
heartbeat.interval.ms: 10000
+# How often the consumer sends heartbeats
max.poll.interval.ms: 300000
+# Maximum time between poll() calls while processing
listener:
ack-mode: record
diff --git a/user-service/Dockerfile b/user-service/Dockerfile
new file mode 100644
index 0000000..b40332a
--- /dev/null
+++ b/user-service/Dockerfile
@@ -0,0 +1,29 @@
+# -- Stage 1: Build ----------------------------------------------------------
+FROM eclipse-temurin:21-jdk-alpine AS builder
+WORKDIR /build
+
+COPY pom.xml .
+COPY common-library/pom.xml common-library/
+COPY common-library/src common-library/src
+COPY user-service/pom.xml user-service/
+COPY user-service/src user-service/src
+
+RUN --mount=type=cache,target=/root/.m2 `
+ ./mvnw -pl common-library,user-service -am clean package -DskipTests --no-transfer-progress
+
+# -- Stage 2: Runtime --------------------------------------------------------
+FROM eclipse-temurin:21-jre-alpine
+WORKDIR /app
+
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+
+COPY --from=builder /build/user-service/target/*.jar app.jar
+
+EXPOSE 8087
+
+ENTRYPOINT ["java", `
+ "-XX:+UseContainerSupport", `
+ "-XX:MaxRAMPercentage=75.0", `
+ "-Djava.security.egd=file:/dev/./urandom", `
+ "-jar", "app.jar"]
diff --git a/user-service/pom.xml b/user-service/pom.xml
index d60ee49..8d2f6cc 100644
--- a/user-service/pom.xml
+++ b/user-service/pom.xml
@@ -44,28 +44,9 @@
lombok
true
+
+
+ org.springdoc
+ springdoc-openapi-starter-webmvc-ui
+
-
-
-
-
- org.springframework.boot
- spring-boot-maven-plugin
-
-
- org.apache.maven.plugins
- maven-compiler-plugin
-
-
-
- org.projectlombok
- lombok
- ${lombok.version}
-
-
-
-
-
-
-
-
diff --git a/user-service/src/main/java/com/hacisimsek/user/controller/UserProfileController.java b/user-service/src/main/java/com/hacisimsek/user/controller/UserProfileController.java
index 0e503a7..ee9c720 100644
--- a/user-service/src/main/java/com/hacisimsek/user/controller/UserProfileController.java
+++ b/user-service/src/main/java/com/hacisimsek/user/controller/UserProfileController.java
@@ -1,4 +1,4 @@
-package com.hacisimsek.user.controller;
+package com.hacisimsek.user.controller;
import com.hacisimsek.user.dto.AddressRequest;
import com.hacisimsek.user.dto.CreateProfileRequest;
@@ -26,16 +26,16 @@
import java.util.UUID;
@RestController
-@RequestMapping("/api/users")
+@RequestMapping("/api/v1/users")
@RequiredArgsConstructor
public class UserProfileController {
private final UserProfileService userProfileService;
- // ── Profile Endpoints ─────────────────────────────────────────────────────
+ // ── Profile Endpoints ─────────────────────────────────────────────────────
/**
- * Create profile — called after registration.
+ * Create profile — called after registration.
* The userId comes from the X-User-Id header injected by the API Gateway JWT filter.
*/
@PostMapping("/profile")
@@ -75,7 +75,7 @@ public ResponseEntity deactivateProfile(
return ResponseEntity.noContent().build();
}
- // ── Preferences Endpoints ─────────────────────────────────────────────────
+ // ── Preferences Endpoints ─────────────────────────────────────────────────
/**
* Update preferences (language, currency, notification settings).
@@ -87,7 +87,7 @@ public ResponseEntity updatePreferences(
return ResponseEntity.ok(userProfileService.updatePreferences(userId, request));
}
- // ── Address Endpoints ─────────────────────────────────────────────────────
+ // ── Address Endpoints ─────────────────────────────────────────────────────
/**
* Get all addresses for the logged-in user.
diff --git a/user-service/src/main/java/com/hacisimsek/user/service/UserProfileService.java b/user-service/src/main/java/com/hacisimsek/user/service/UserProfileService.java
deleted file mode 100644
index 77f392d..0000000
--- a/user-service/src/main/java/com/hacisimsek/user/service/UserProfileService.java
+++ /dev/null
@@ -1,166 +0,0 @@
-package com.hacisimsek.user.service;
-
-import com.hacisimsek.user.dto.AddressRequest;
-import com.hacisimsek.user.dto.CreateProfileRequest;
-import com.hacisimsek.user.dto.PreferencesRequest;
-import com.hacisimsek.user.dto.UpdateProfileRequest;
-import com.hacisimsek.user.model.Address;
-import com.hacisimsek.user.model.UserPreferences;
-import com.hacisimsek.user.model.UserProfile;
-import com.hacisimsek.user.repository.AddressRepository;
-import com.hacisimsek.user.repository.UserProfileRepository;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import java.util.List;
-import java.util.UUID;
-
-@Service
-@RequiredArgsConstructor
-@Slf4j
-public class UserProfileService {
-
- private final UserProfileRepository profileRepository;
- private final AddressRepository addressRepository;
-
- // ── Profile ───────────────────────────────────────────────────────────────
-
- /**
- * Creates a profile for a newly registered user.
- * Called with the same UUID that auth-service assigned to the user.
- */
- @Transactional
- public UserProfile createProfile(UUID userId, CreateProfileRequest request) {
- if (profileRepository.existsById(userId)) {
- throw new RuntimeException("Profile already exists for user: " + userId);
- }
- UserProfile profile = UserProfile.builder()
- .id(userId)
- .fullName(request.getFullName())
- .email(request.getEmail())
- .phoneNumber(request.getPhoneNumber())
- .preferences(new UserPreferences())
- .build();
- UserProfile saved = profileRepository.save(profile);
- log.info("Profile created for user: {}", userId);
- return saved;
- }
-
- @Transactional(readOnly = true)
- public UserProfile getProfile(UUID userId) {
- return profileRepository.findById(userId)
- .orElseThrow(() -> new RuntimeException("Profile not found for user: " + userId));
- }
-
- @Transactional
- public UserProfile updateProfile(UUID userId, UpdateProfileRequest request) {
- UserProfile profile = getProfile(userId);
- profile.setFullName(request.getFullName());
- if (request.getPhoneNumber() != null) {
- profile.setPhoneNumber(request.getPhoneNumber());
- }
- return profileRepository.save(profile);
- }
-
- @Transactional
- public void deactivateProfile(UUID userId) {
- UserProfile profile = getProfile(userId);
- profile.setAccountStatus(com.hacisimsek.user.model.AccountStatus.DEACTIVATED);
- profileRepository.save(profile);
- log.info("Profile deactivated for user: {}", userId);
- }
-
- // ── Preferences ───────────────────────────────────────────────────────────
-
- @Transactional
- public UserProfile updatePreferences(UUID userId, PreferencesRequest request) {
- UserProfile profile = getProfile(userId);
- UserPreferences prefs = profile.getPreferences();
- if (prefs == null) prefs = new UserPreferences();
-
- if (request.getLanguage() != null) prefs.setLanguage(request.getLanguage());
- if (request.getCurrency() != null) prefs.setCurrency(request.getCurrency());
- if (request.getEmailNotifications() != null) prefs.setEmailNotifications(request.getEmailNotifications());
- if (request.getSmsNotifications() != null) prefs.setSmsNotifications(request.getSmsNotifications());
- if (request.getPushNotifications() != null) prefs.setPushNotifications(request.getPushNotifications());
-
- profile.setPreferences(prefs);
- return profileRepository.save(profile);
- }
-
- // ── Addresses ─────────────────────────────────────────────────────────────
-
- @Transactional(readOnly = true)
- public List getAddresses(UUID userId) {
- // ensure profile exists
- getProfile(userId);
- return addressRepository.findByUserProfileId(userId);
- }
-
- @Transactional
- public Address addAddress(UUID userId, AddressRequest request) {
- UserProfile profile = getProfile(userId);
-
- // If this address is default, clear existing default first
- if (request.isDefaultAddress()) {
- addressRepository.clearDefaultForUser(userId);
- }
-
- Address address = Address.builder()
- .userProfile(profile)
- .label(request.getLabel())
- .recipientName(request.getRecipientName())
- .phoneNumber(request.getPhoneNumber())
- .addressLine1(request.getAddressLine1())
- .addressLine2(request.getAddressLine2())
- .city(request.getCity())
- .state(request.getState())
- .postalCode(request.getPostalCode())
- .country(request.getCountry())
- .defaultAddress(request.isDefaultAddress())
- .build();
-
- return addressRepository.save(address);
- }
-
- @Transactional
- public Address updateAddress(UUID userId, UUID addressId, AddressRequest request) {
- Address address = addressRepository.findByIdAndUserProfileId(addressId, userId)
- .orElseThrow(() -> new RuntimeException("Address not found"));
-
- if (request.isDefaultAddress()) {
- addressRepository.clearDefaultForUser(userId);
- }
-
- address.setLabel(request.getLabel());
- address.setRecipientName(request.getRecipientName());
- address.setPhoneNumber(request.getPhoneNumber());
- address.setAddressLine1(request.getAddressLine1());
- address.setAddressLine2(request.getAddressLine2());
- address.setCity(request.getCity());
- address.setState(request.getState());
- address.setPostalCode(request.getPostalCode());
- address.setCountry(request.getCountry());
- address.setDefaultAddress(request.isDefaultAddress());
-
- return addressRepository.save(address);
- }
-
- @Transactional
- public void deleteAddress(UUID userId, UUID addressId) {
- Address address = addressRepository.findByIdAndUserProfileId(addressId, userId)
- .orElseThrow(() -> new RuntimeException("Address not found"));
- addressRepository.delete(address);
- }
-
- @Transactional
- public Address setDefaultAddress(UUID userId, UUID addressId) {
- addressRepository.clearDefaultForUser(userId);
- Address address = addressRepository.findByIdAndUserProfileId(addressId, userId)
- .orElseThrow(() -> new RuntimeException("Address not found"));
- address.setDefaultAddress(true);
- return addressRepository.save(address);
- }
-}
diff --git a/wishlist-service/Dockerfile b/wishlist-service/Dockerfile
new file mode 100644
index 0000000..96dac86
--- /dev/null
+++ b/wishlist-service/Dockerfile
@@ -0,0 +1,29 @@
+# -- Stage 1: Build ----------------------------------------------------------
+FROM eclipse-temurin:21-jdk-alpine AS builder
+WORKDIR /build
+
+COPY pom.xml .
+COPY common-library/pom.xml common-library/
+COPY common-library/src common-library/src
+COPY wishlist-service/pom.xml wishlist-service/
+COPY wishlist-service/src wishlist-service/src
+
+RUN --mount=type=cache,target=/root/.m2 `
+ ./mvnw -pl common-library,wishlist-service -am clean package -DskipTests --no-transfer-progress
+
+# -- Stage 2: Runtime --------------------------------------------------------
+FROM eclipse-temurin:21-jre-alpine
+WORKDIR /app
+
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+USER appuser
+
+COPY --from=builder /build/wishlist-service/target/*.jar app.jar
+
+EXPOSE 8090
+
+ENTRYPOINT ["java", `
+ "-XX:+UseContainerSupport", `
+ "-XX:MaxRAMPercentage=75.0", `
+ "-Djava.security.egd=file:/dev/./urandom", `
+ "-jar", "app.jar"]
diff --git a/wishlist-service/pom.xml b/wishlist-service/pom.xml
index c4cc48f..a1311a4 100644
--- a/wishlist-service/pom.xml
+++ b/wishlist-service/pom.xml
@@ -50,28 +50,9 @@
lombok
true
+
+
+ org.springdoc
+ springdoc-openapi-starter-webmvc-ui
+
-
-
-
-
- org.springframework.boot
- spring-boot-maven-plugin
-
-
- org.apache.maven.plugins
- maven-compiler-plugin
-
-
-
- org.projectlombok
- lombok
- ${lombok.version}
-
-
-
-
-
-
-
-
diff --git a/wishlist-service/src/main/java/com/hacisimsek/wishlist/controller/WishlistController.java b/wishlist-service/src/main/java/com/hacisimsek/wishlist/controller/WishlistController.java
index 9599d13..d9a57ce 100644
--- a/wishlist-service/src/main/java/com/hacisimsek/wishlist/controller/WishlistController.java
+++ b/wishlist-service/src/main/java/com/hacisimsek/wishlist/controller/WishlistController.java
@@ -1,4 +1,4 @@
-package com.hacisimsek.wishlist.controller;
+package com.hacisimsek.wishlist.controller;
import com.hacisimsek.wishlist.dto.AddToWishlistRequest;
import com.hacisimsek.wishlist.dto.WishlistItemResponse;
@@ -21,7 +21,7 @@
import java.util.UUID;
@RestController
-@RequestMapping("/api/wishlist")
+@RequestMapping("/api/v1/wishlist")
@RequiredArgsConstructor
public class WishlistController {