developer_samples

This document provides practical examples using skail.

Each example illustrates key patterns such as human approvals, automatic workflows, retry policies, compensating sagas, fan-out/fan-in orchestration, and event-driven logic.

---

1. Parallel Human Approval (Function + Command)

[SkailFunction]
public async SkailTask AwaitAllHumanApprovals(Guid approvalTaskId)
{
    await SendApprovalRequestEmail("Finance", approvalTaskId);
    await SendApprovalRequestEmail("Legal", approvalTaskId);
    await SendApprovalRequestEmail("Executive", approvalTaskId);
    var approvals = new[]
    {
        SkailEvent.WaitForEvent<ApprovalResponse>("EVT_APPROVAL_FINANCE", approvalTaskId),
        SkailEvent.WaitForEvent<ApprovalResponse>("EVT_APPROVAL_LEGAL", approvalTaskId),
        SkailEvent.WaitForEvent<ApprovalResponse>("EVT_APPROVAL_EXECUTIVE", approvalTaskId)
    };
    var results = await SkailTask.WhenAll(approvals);
    if (results.All(r => r.Approved))
        await NotifyApproved(approvalTaskId);
    else
        await NotifyDenied(approvalTaskId, results.First(r => !r.Approved).Reason);
}

[SkailCommand]
public async SkailTask SendApprovalRequestEmail(string department, Guid taskId)
{
    var link = $"https://portal.company.com/approvals/{department.ToLower()}/{taskId}";
    await EmailService.SendAsync($"{department} - Pending Approval",
        $"Please review the request at: {link}");
}

---

2. Human Approval with Timeout

[SkailFunction]
public async SkailTask WaitForApprovalWithTimeout(Guid approvalId)
{
    await SendApprovalEmail(approvalId);
    var approvalTask = SkailEvent.WaitForEvent<ApprovalResponse>("EVT_APPROVAL", approvalId);
    var timeoutTask = SkailTask.DelayHours(72);
    var result = await SkailTask.WhenAny(approvalTask, timeoutTask);
    if (result == approvalTask)
        await NotifyApproved(approvalId);
    else
        await NotifyExpired(approvalId);
}

[SkailCommand]
public async SkailTask SendApprovalEmail(Guid approvalId)
{
    var link = $"https://portal.company.com/approve/{approvalId}";
    await EmailService.SendAsync("Approval Required", $"Click here to approve: {link}");
}

---

3. CT-e Issuance Pipeline (Function + Commands)

[SkailFunction]
public async SkailTask IssueCTe(Guid cteId)
{
    var cte = await BuildCTeModel(cteId);
    await ValidateCTe(cte);
    await SendToSefaz(cte);
    await SaveCTe(cte);
}

[SkailCommand]
public async SkailTask<CTeModel> BuildCTeModel(Guid cteId)
{
    var data = await CTeRepository.LoadDataAsync(cteId);
    return new CTeModelBuilder().FromData(data).Build();
}

[SkailCommand]
public async SkailTask ValidateCTe(CTeModel cte)
{
    await XmlSchemaValidator.ValidateAsync(cte.Xml);
}

[SkailCommand]
public async SkailTask SendToSefaz(CTeModel cte)
{
    var response = await SefazApi.SubmitAsync(cte.Xml);
    cte.AuthorizationProtocol = response.Protocol;
}

[SkailCommand]
public async SkailTask SaveCTe(CTeModel cte)
{
    await CTeRepository.SaveAsync(cte);
}

---

4. Compensating Workflow (Saga Pattern)

[SkailFunction]
public async SkailTask ProcessOrderSaga(Guid orderId)
{
    try
    {
        await ReserveStock(orderId);
        await ChargePayment(orderId);
        await EmitInvoice(orderId);
        await NotifyOrderCompleted(orderId);
    }
    catch (Exception ex)
    {
        await RefundPayment(orderId);
        await ReleaseStock(orderId);
        await NotifyOrderFailed(orderId, ex.Message);
    }
}

[SkailCommand]
public async SkailTask ReserveStock(Guid orderId)
{
    await InventoryApi.ReserveAsync(orderId);
}

[SkailCommand]
public async SkailTask ChargePayment(Guid orderId)
{
    await PaymentGateway.ChargeAsync(orderId);
}

[SkailCommand]
public async SkailTask EmitInvoice(Guid orderId)
{
    await InvoiceService.EmitAsync(orderId);
}

[SkailCommand]
public async SkailTask RefundPayment(Guid orderId)
{
    await PaymentGateway.RefundAsync(orderId);
}

[SkailCommand]
public async SkailTask ReleaseStock(Guid orderId)
{
    await InventoryApi.ReleaseAsync(orderId);
}

---

5. Durable Retry with Backoff

[SkailFunction]
public async SkailTask SendEmailWithRetries(Guid emailId)
{
    for (int attempt = 1; attempt <= 3; attempt++)
    {
        var success = await TrySendEmail(emailId);
        if (success)
        {
            await LogSuccess(emailId);
            return;
        }
        await SkailTask.DelayHours(2);
    }
    await LogFailure(emailId);
}

[SkailCommand]
public async SkailTask<bool> TrySendEmail(Guid emailId)
{
    return await EmailService.TrySendAsync(emailId);
}

[SkailCommand]
public async SkailTask LogSuccess(Guid emailId)
{
    await AuditLog.WriteAsync($"Email {emailId} successfully delivered.");
}

[SkailCommand]
public async SkailTask LogFailure(Guid emailId)
{
    await AuditLog.WriteAsync($"Permanent failure sending email {emailId} after 3 attempts.");
}

---

6. Race Between Providers (WhenAny)

[SkailFunction]
public async SkailTask ChooseBestQuote(Guid requestId)
{
    var quotes = new[]
    {
        RequestQuote("Amazon", requestId),
        RequestQuote("Walmart", requestId),
        RequestQuote("BestBuy", requestId)
    };
    var first = await SkailTask.WhenAny(quotes);
    var best = await first;
    await PersistSelectedQuote(requestId, best);
}

[SkailCommand]
public async SkailTask<QuoteResponse> RequestQuote(string provider, Guid requestId)
{
    var quote = await MarketplaceApi.GetQuoteAsync(provider, requestId);
    return new QuoteResponse(provider, quote.Price);
}

[SkailCommand]
public async SkailTask PersistSelectedQuote(Guid requestId, QuoteResponse response)
{
    await QuotesRepository.SaveAsync(requestId, response);
}

---

7. Fan-out / Fan-in Data Aggregation

[SkailFunction]
public async SkailTask AggregateDailyAnalytics(DateOnly date)
{
    var tasks = new[]
    {
        FetchSales(date),
        FetchRefunds(date),
        FetchErrors(date)
    };
    var results = await SkailTask.WhenAll(tasks);
    await SaveDailySummary(date, results);
}

[SkailCommand]
public async SkailTask<decimal> FetchSales(DateOnly date)
{
    return await AnalyticsApi.GetTotalSalesAsync(date);
}

[SkailCommand]
public async SkailTask<int> FetchRefunds(DateOnly date)
{
    return await AnalyticsApi.GetRefundCountAsync(date);
}

[SkailCommand]
public async SkailTask<int> FetchErrors(DateOnly date)
{
    return await MonitoringApi.GetErrorCountAsync(date);
}

[SkailCommand]
public async SkailTask SaveDailySummary(DateOnly date, object[] results)
{
    await ReportsRepository.SaveAsync(date, results);
}

---

8. Human Approval Followed by Automation (Hybrid)

[SkailFunction]
public async SkailTask ApproveAndDeploy(Guid requestId)
{
    await NotifyAwaitingApproval(requestId);
    var approval = await SkailEvent.WaitForEvent<ApprovalResponse>("EVT_APPROVAL", requestId);
    if (!approval.Approved)
    {
        await RecordRejection(requestId, approval.Reason);
        return;
    }
    await DeployNewVersion(requestId);
    await RecordSuccess(requestId);
}

[SkailCommand]
public async SkailTask NotifyAwaitingApproval(Guid requestId)
{
    await SlackNotifier.SendMessage($"Deployment request {requestId} awaiting approval.");
}

[SkailCommand]
public async SkailTask DeployNewVersion(Guid requestId)
{
    await DeploymentPipeline.TriggerAsync(requestId);
}

[SkailCommand]
public async SkailTask RecordRejection(Guid requestId, string reason)
{
    await AuditLog.WriteAsync($"Deployment {requestId} was rejected: {reason}");
}

[SkailCommand]
public async SkailTask RecordSuccess(Guid requestId)
{
    await AuditLog.WriteAsync($"Deployment {requestId} successfully completed.");
}

---

Note: Adapt these examples to your environment’s orchestration model, domain constraints, and versioning strategy.