Retries, Timeouts, and Cancellation

import { Step } from '@siglo/core';

export const callPaymentGateway = Step.create('callGateway', async (param: any) => {
    return await api.chargeCustomer(param);
}).onFail({
    maxRetries: 3,
    backoff: 'exponential', // 'fixed', 'linear', 'exponential', or custom fn
    delay: 200, // Base delay in ms
    maxDelay: 5000, // Cap maximum backoff delay
    jitter: true, // Add random jitter to prevent thundering herd
    retryIf: (err, attempt) => {
        // Only retry on network errors or 5xx server codes
        return err.status >= 500 || err.code === 'ECONNRESET';
    },
    onRetry: (err, attempt, delayMs) => {
        console.warn(`Retry attempt #${attempt} scheduled after ${delayMs}ms due to: ${err.message}`);
    },
});

const querySlowDatabase = Step.create('queryDb', async () => {
    return await db.heavyAnalytics();
}).timeout(2500); // Fails with StepTimeoutException if exceeds 2.5s

import { flow } from '@siglo/core';

const checkoutWorkflow = flow(step1, step2, step3).timeout(10000); // 10s end-to-end deadline

import { CancellationException } from '@siglo/core';

const controller = new AbortController();

setTimeout(() => {
    controller.abort(new Error('User clicked cancel'));
}, 3000);

try {
    await workflow.run({ orderId: '123' }, { signal: controller.signal });
} catch (err: any) {
    if (err instanceof CancellationException || err.name === 'CancellationException') {
        console.log('Workflow cancelled:', err.message);
    }
}

const downloadFile = Step.create('download', async (param: any) => {
    const signal = param.signal;
    return await fetch('https://example.com/file', { signal });
});

import { Step, flow } from '@siglo/core';

const reserveHotel = Step.create('reserveHotel', async () => {
    const booking = await hotelApi.book();
    return { hotelBookingId: booking.id };
}).compensate(async ctx => {
    // Automatic rollback if subsequent steps fail
    await hotelApi.cancel(ctx.hotelBookingId);
});

const reserveFlight = Step.create('reserveFlight', async () => {
    const flight = await flightApi.book();
    return { flightBookingId: flight.id };
}).compensate(async ctx => {
    await flightApi.cancel(ctx.flightBookingId);
});

const chargeCard = Step.create('chargeCard', async () => {
    throw new Error('Credit card declined'); // Triggers saga compensation!
});

export const travelBookingSaga = flow(reserveHotel, reserveFlight, chargeCard);

import { Step, flow } from '@siglo/core';

let attempts = 0;
const flaky = Step.create('flaky', async () => {
    attempts++;
    if (attempts < 2) throw new Error('Network timeout');
    return { recovered: true };
}).onFail({ maxRetries: 3, delay: 50 });

const wf = flow(flaky);
const res = await wf.run();
console.log(res.recovered); // true

import { Step, flow, CompensationException } from '@siglo/core';

const step1 = Step.create('step1', () => ({ ok: true })).compensate(async () => {
    throw new Error('Compensation network error');
});

const step2 = Step.create('step2', () => {
    throw new Error('Step 2 failed');
});

const sagaFlow = flow(step1, step2);

try {
    await sagaFlow.run();
} catch (err: any) {
    if (err instanceof CompensationException) {
        console.error('Original Error:', err.originalError.message);
        console.error('Failed Compensations:', err.compensationErrors);
        console.error('Successfully Compensated Steps:', err.completedCompensations);
    }
}

import { expect } from 'chai';
import { createWorkflowHarness } from '@siglo/testing';
import { Step, flow } from '@siglo/core';

let calls = 0;
const step = Step.create('apiCall', () => {
    calls++;
    if (calls < 3) throw new Error('Rate limit');
    return { status: 200 };
}).onFail({ maxRetries: 3, delay: 10 });

const testWf = flow(step);

describe('Retry Fault Tolerance Suite', () => {
    it('retries until success and verifies attempt count', async () => {
        const harness = createWorkflowHarness(testWf);
        const result = await harness.run();

        expect(result.status).to.equal(200);
        harness.assertStepRetried('apiCall', 2);
    });
});