Flovyn vs Java Ecosystem

// Spring Batch cannot:
// 1. Wait for external approval mid-job
// 2. Sleep for days then resume
// 3. Handle webhooks triggering next steps
// 4. Coordinate with external services with compensation

class DataReviewWorkflow : WorkflowDefinition<ReviewInput, ReviewResult>() {
    override val kind = "data-review"

    override suspend fun execute(ctx: WorkflowContext, input: ReviewInput): ReviewResult {
        val imported = ctx.run("import") { importData(input) }

        // Wait for manual review (days/weeks) - worker NOT blocked
        val approval = ctx.promise<Approval>("review-approval", timeout = Duration.ofDays(7))

        val decision = try {
            approval.await()
        } catch (e: TimeoutException) {
            null
        }

        if (decision?.approved == true) {
            ctx.run("publish") { publishData(imported) }
        } else {
            ctx.run("archive") { archiveData(imported) }
        }

        return ReviewResult(status = "completed")
    }
}

public class RetryJob implements Job {
    @Autowired
    private RetryStateRepository retryRepo;  // You manage this

    @Override
    public void execute(JobExecutionContext context) {
        String taskId = context.getJobDetail().getKey().getName();
        RetryState state = retryRepo.findById(taskId)
            .orElse(new RetryState(taskId, 0));

        try {
            callExternalApi();
            retryRepo.delete(state);
        } catch (Exception e) {
            state.incrementAttempt();
            state.setLastError(e.getMessage());
            retryRepo.save(state);

            if (state.getAttempts() < 5) {
                // Reschedule with backoff
                long delay = (long) Math.pow(2, state.getAttempts()) * 1000;
                rescheduleJob(taskId, delay);
            } else {
                alertOps("Job failed after 5 attempts");
            }
        }
    }
}
// 50+ lines just for retry logic

class ApiCallWorkflow : WorkflowDefinition<ApiInput, ApiResult>() {
    override val kind = "api-call"

    override suspend fun execute(ctx: WorkflowContext, input: ApiInput): ApiResult {
        repeat(5) { attempt ->
            try {
                val response = ctx.schedule<ApiResponse>("call-api", input)
                return ApiResult(response)
            } catch (e: Exception) {
                ctx.set("lastError", e.message)
                val delay = (1L shl attempt) * 1000  // Exponential backoff
                ctx.sleep(Duration.ofMillis(delay))
            }
        }
        throw NonRetryableException("Failed after 5 attempts")
    }
}
// State persisted, survives restarts, full history

@Service
public class OrderService {
    @Autowired private OrderRepository orderRepo;
    @Autowired private PaymentService paymentService;
    @Autowired private InventoryService inventoryService;
    @Autowired private ShippingService shippingService;

    @Transactional
    public void processOrder(String orderId) {
        Order order = orderRepo.findById(orderId).orElseThrow();

        // Resume from last state
        switch (order.getStatus()) {
            case CREATED:
                processPayment(order);
                // fall through
            case PAYMENT_COMPLETED:
                reserveInventory(order);
                // fall through
            case INVENTORY_RESERVED:
                createShipment(order);
                break;
            case FAILED:
                handleFailure(order);
                break;
        }
    }

    private void processPayment(Order order) {
        try {
            PaymentResult result = paymentService.charge(order);
            order.setPaymentId(result.getId());
            order.setStatus(PAYMENT_COMPLETED);
            orderRepo.save(order);
        } catch (Exception e) {
            order.setStatus(FAILED);
            order.setError(e.getMessage());
            orderRepo.save(order);
            throw e;
        }
    }

    private void reserveInventory(Order order) {
        try {
            InventoryResult result = inventoryService.reserve(order);
            order.setReservationId(result.getId());
            order.setStatus(INVENTORY_RESERVED);
            orderRepo.save(order);
        } catch (Exception e) {
            // Compensate: refund payment
            paymentService.refund(order.getPaymentId());
            order.setStatus(FAILED);
            orderRepo.save(order);
            throw e;
        }
    }

    // More methods, more state transitions, more edge cases...
}

@Workflow(name = "order-processing")
class OrderWorkflow : TypedWorkflowDefinition<OrderInput, OrderOutput> {
    override suspend fun execute(ctx: WorkflowContext, input: OrderInput): OrderOutput {
        ctx.set("status", "processing")

        // Step 1: Payment
        val payment = ctx.schedule<PaymentResult>("payment-task", input)
        ctx.set("paymentId", payment.id)

        // Step 2: Inventory (with compensation)
        val inventory = try {
            ctx.schedule<InventoryResult>("inventory-task", input)
        } catch (e: Exception) {
            ctx.run("refund") { paymentService.refund(payment.id) }
            throw e
        }
        ctx.set("reservationId", inventory.id)

        // Step 3: Shipping (with compensation)
        val shipment = try {
            ctx.schedule<ShipmentResult>("shipment-task", input)
        } catch (e: Exception) {
            ctx.run("release-inventory") { 
                inventoryService.release(inventory.id) 
            }
            ctx.run("refund") { paymentService.refund(payment.id) }
            throw e
        }

        ctx.set("status", "completed")
        return OrderOutput(
            orderId = input.orderId,
            trackingNumber = shipment.trackingNumber
        )
    }
}
// Automatic state persistence, clear compensation logic