name = "job-processor"
main = "src/index.ts"
compatibility_date = "2026-09-01"

[[queues.producers]]
binding = "ORDER_QUEUE"
queue = "order-processing-queue"

[[queues.consumers]]
queue = "order-processing-queue"
max_batch_size = 10
max_batch_timeout = 5
max_retries = 3
dead_letter_queue = "order-dlq"

export interface Env {
  ORDER_QUEUE: Queue<OrderMessage>;
}

export interface OrderMessage {
  orderId: string;
  customerEmail: string;
  amount: number;
}

export default {
  // HTTP Producer Endpoint
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== 'POST') {
      return new Response('Method Not Allowed', { status: 405 });
    }

    const payload: OrderMessage = await request.json();

    // Push message to queue non-blockingly
    await env.ORDER_QUEUE.send(payload);

    return new Response(JSON.stringify({ status: 'queued', orderId: payload.orderId }), {
      status: 202,
      headers: { 'Content-Type': 'application/json' },
    });
  },

  // Batch Consumer Worker
  async queue(batch: MessageBatch<OrderMessage>, env: Env): Promise<void> {
    console.log(`Processing batch of ${batch.messages.length} messages`);

    for (const msg of batch.messages) {
      try {
        const order = msg.body;
        console.log(`Executing order processing for ${order.orderId}`);

        await executeJob(order);

        // Acknowledge successful execution
        msg.ack();
      } catch (err) {
        console.error(`Failed to process message ${msg.id}:`, err);
        // Retry message based on backoff policy
        msg.retry();
      }
    }
  },
};

async function executeJob(order: OrderMessage): Promise<void> {
  // Job logic here
}

import { WorkflowEntrypoint, WorkflowStep, WorkflowEvent } from 'cloudflare:workers';

type OnboardingPayload = {
  userId: string;
  email: string;
};

export class OnboardingWorkflow extends WorkflowEntrypoint<Env, OnboardingPayload> {
  async run(event: WorkflowEvent<OnboardingPayload>, step: WorkflowStep) {
    // Step 1: Provision account
    await step.do('create-user-db', async () => {
      return { id: event.payload.userId, status: 'PROVISIONED' };
    });

    // Step 2: Send welcome email
    await step.do('send-welcome-email', async () => {
      // Trigger transactional email
    });

    // Step 3: Sleep 48 hours without paying for idle compute!
    await step.sleep('wait-for-checkin', '48 hours');

    // Step 4: Send follow-up survey
    await step.do('send-survey-email', async () => {
      // Send engagement email
    });
  }
}