from datetime import timedelta

@workflow.defn
class ReliablePublish:
    @workflow.run
    async def run(self, post_id: str) -> str:
        draft = await workflow.execute_activity(
            fetch_draft,
            post_id,
            schedule_to_close_timeout=timedelta(seconds=20),
        )
        await workflow.execute_activity(verify_seo, draft)
        return await workflow.execute_activity(publish_post, draft)

func ReliablePublish(ctx workflow.Context, postID string) (string, error) {
    opts := workflow.ActivityOptions{
        ScheduleToCloseTimeout: 20 * time.Second,
    }
    ctx = workflow.WithActivityOptions(ctx, opts)

    var draft Draft
    if err := workflow.ExecuteActivity(ctx, FetchDraft, postID).Get(ctx, &draft); err != nil {
        return "", err
    }
    if err := workflow.ExecuteActivity(ctx, VerifySEO, draft).Get(ctx, nil); err != nil {
        return "", err
    }
    return draft.URL, workflow.ExecuteActivity(ctx, PublishPost, draft).Get(ctx, nil)
}

import { proxyActivities } from '@antsand/workflow';

const { fetchDraft, verifySeo, publishPost } = proxyActivities({
  startToCloseTimeout: '20 seconds',
});

export async function reliablePublish(postId: string): Promise<string> {
  const draft = await fetchDraft(postId);
  await verifySeo(draft);
  return await publishPost(draft);
}

class ReliablePublishWorkflow < Temporalio::Workflow::Definition
  def execute(post_id)
    draft = Temporalio::Workflow.execute_activity(
      FetchDraft,
      post_id,
      start_to_close_timeout: 20
    )
    Temporalio::Workflow.execute_activity(VerifySeo, draft)
    Temporalio::Workflow.execute_activity(PublishPost, draft)
  end
end

public class ReliablePublishWorkflow
{
    [WorkflowRun]
    public async Task<string> RunAsync(string postId)
    {
        var draft = await Workflow.ExecuteActivityAsync(
            (Activities a) => a.FetchDraft(postId),
            new() { StartToCloseTimeout = TimeSpan.FromSeconds(20) });

        await Workflow.ExecuteActivityAsync((Activities a) => a.VerifySeo(draft));
        return await Workflow.ExecuteActivityAsync((Activities a) => a.PublishPost(draft));
    }
}

public class ReliablePublishWorkflowImpl implements ReliablePublishWorkflow {
    private final Activities activities = Workflow.newActivityStub(
        Activities.class,
        ActivityOptions.newBuilder()
            .setStartToCloseTimeout(Duration.ofSeconds(20))
            .build());

    public String run(String postId) {
        Draft draft = activities.fetchDraft(postId);
        activities.verifySeo(draft);
        return activities.publishPost(draft);
    }
}

$workflow = new ReliablePublishWorkflow();

return $workflow->run(function () use ($post_id) {
    $draft = Activity::execute('fetchDraft', $post_id, timeout: 20);
    Activity::execute('verifySeo', $draft);

    return Activity::execute('publishPost', $draft);
});