1# Cron Triggers Patterns
2 
3## API Data Sync
4 
5```typescript
6export default {
7  async scheduled(controller, env, ctx) {
8    const response = await fetch("https://api.example.com/data", {headers: { "Authorization": `Bearer ${env.API_KEY}` }});
9    if (!response.ok) throw new Error(`API error: ${response.status}`);
10    ctx.waitUntil(env.MY_KV.put("cached_data", JSON.stringify(await response.json()), {expirationTtl: 3600}));
11  },
12};
13```
14 
15## Database Cleanup
16 
17```typescript
18export default {
19  async scheduled(controller, env, ctx) {
20    const result = await env.DB.prepare(`DELETE FROM sessions WHERE expires_at < datetime('now')`).run();
21    console.log(`Deleted ${result.meta.changes} expired sessions`);
22    ctx.waitUntil(env.DB.prepare("VACUUM").run());
23  },
24};
25```
26 
27## Report Generation
28 
29```typescript
30export default {
31  async scheduled(controller, env, ctx) {
32    const startOfWeek = new Date(); startOfWeek.setDate(startOfWeek.getDate() - 7);
33    const { results } = await env.DB.prepare(`SELECT date, revenue, orders FROM daily_stats WHERE date >= ? ORDER BY date`).bind(startOfWeek.toISOString()).all();
34    const report = {period: "weekly", totalRevenue: results.reduce((sum, d) => sum + d.revenue, 0), totalOrders: results.reduce((sum, d) => sum + d.orders, 0), dailyBreakdown: results};
35    const reportKey = `reports/weekly-${Date.now()}.json`;
36    await env.REPORTS_BUCKET.put(reportKey, JSON.stringify(report));
37    ctx.waitUntil(env.SEND_EMAIL.fetch("https://example.com/send", {method: "POST", body: JSON.stringify({to: "[email protected]", subject: "Weekly Report", reportUrl: `https://reports.example.com/${reportKey}`})}));
38  },
39};
40```
41 
42## Health Checks
43 
44```typescript
45export default {
46  async scheduled(controller, env, ctx) {
47    const services = [{name: "API", url: "https://api.example.com/health"}, {name: "CDN", url: "https://cdn.example.com/health"}];
48    const checks = await Promise.all(services.map(async (service) => {
49      const start = Date.now();
50      try {
51        const response = await fetch(service.url, { signal: AbortSignal.timeout(5000) });
52        return {name: service.name, status: response.ok ? "up" : "down", responseTime: Date.now() - start};
53      } catch (error) {
54        return {name: service.name, status: "down", responseTime: Date.now() - start, error: error.message};
55      }
56    }));
57    ctx.waitUntil(env.STATUS_KV.put("health_status", JSON.stringify(checks)));
58    const failures = checks.filter(c => c.status === "down");
59    if (failures.length > 0) ctx.waitUntil(fetch(env.ALERT_WEBHOOK, {method: "POST", body: JSON.stringify({text: `${failures.length} service(s) down: ${failures.map(f => f.name).join(", ")}`})}));
60  },
61};
62```
63 
64## Batch Processing (Rate-Limited)
65 
66```typescript
67export default {
68  async scheduled(controller, env, ctx) {
69    const queueData = await env.QUEUE_KV.get("pending_items", "json");
70    if (!queueData || queueData.length === 0) return;
71    const batch = queueData.slice(0, 100);
72    const results = await Promise.allSettled(batch.map(item => fetch("https://api.example.com/process", {method: "POST", headers: {"Authorization": `Bearer ${env.API_KEY}`, "Content-Type": "application/json"}, body: JSON.stringify(item)})));
73    console.log(`Processed ${results.filter(r => r.status === "fulfilled").length}/${batch.length} items`);
74    ctx.waitUntil(env.QUEUE_KV.put("pending_items", JSON.stringify(queueData.slice(100))));
75  },
76};
77```
78 
79## Queue Integration
80 
81```typescript
82export default {
83  async scheduled(controller, env, ctx) {
84    const batch = await env.MY_QUEUE.receive({ batchSize: 100 });
85    const results = await Promise.allSettled(batch.messages.map(async (msg) => {
86      await processMessage(msg.body, env);
87      await msg.ack();
88    }));
89    console.log(`Processed ${results.filter(r => r.status === "fulfilled").length}/${batch.messages.length}`);
90  },
91};
92```
93 
94## Monitoring & Observability
95 
96```typescript
97export default {
98  async scheduled(controller, env, ctx) {
99    const startTime = Date.now();
100    const meta = { cron: controller.cron, scheduledTime: controller.scheduledTime };
101    console.log("[START]", meta);
102    try {
103      const result = await performTask(env);
104      console.log("[SUCCESS]", { ...meta, duration: Date.now() - startTime, count: result.count });
105      ctx.waitUntil(env.METRICS.put(`cron:${controller.scheduledTime}`, JSON.stringify({ ...meta, status: "success" }), { expirationTtl: 2592000 }));
106    } catch (error) {
107      console.error("[ERROR]", { ...meta, duration: Date.now() - startTime, error: error.message });
108      ctx.waitUntil(fetch(env.ALERT_WEBHOOK, { method: "POST", body: JSON.stringify({ text: `Cron failed: ${controller.cron}`, error: error.message }) }));
109      throw error;
110    }
111  },
112};
113```
114 
115**View logs:** `npx wrangler tail` or Dashboard → Workers & Pages → Worker → Logs
116 
117## Durable Objects Coordination
118 
119```typescript
120export default {
121  async scheduled(controller, env, ctx) {
122    const stub = env.COORDINATOR.get(env.COORDINATOR.idFromName("cron-lock"));
123    const acquired = await stub.tryAcquireLock(controller.scheduledTime);
124    if (!acquired) {
125      controller.noRetry();
126      return;
127    }
128    try {
129      await performTask(env);
130    } finally {
131      await stub.releaseLock();
132    }
133  },
134};
135```
136 
137## Python Handler
138 
139```python
140from workers import WorkerEntrypoint
141 
142class Default(WorkerEntrypoint):
143    async def scheduled(self, controller, env, ctx):
144        data = await env.MY_KV.get("key")
145        ctx.waitUntil(env.DB.execute("DELETE FROM logs WHERE created_at < datetime('now', '-7 days')"))
146```
147 
148## Testing Patterns
149 
150**Local testing with /__scheduled:**
151```bash
152# Start dev server
153npx wrangler dev
154 
155# Test specific cron
156curl "http://localhost:8787/__scheduled?cron=*/5+*+*+*+*"
157 
158# Test with specific time
159curl "http://localhost:8787/__scheduled?cron=0+2+*+*+*&scheduledTime=1704067200000"
160```
161 
162**Unit tests:**
163```typescript
164// test/scheduled.test.ts
165import { describe, it, expect, vi } from "vitest";
166import { env } from "cloudflare:test";
167import worker from "../src/index";
168 
169describe("Scheduled Handler", () => {
170  it("executes cron", async () => {
171    const controller = { scheduledTime: Date.now(), cron: "*/5 * * * *", type: "scheduled" as const, noRetry: vi.fn() };
172    const ctx = { waitUntil: vi.fn(), passThroughOnException: vi.fn() };
173    await worker.scheduled(controller, env, ctx);
174    expect(await env.MY_KV.get("last_run")).toBeDefined();
175  });
176  
177  it("calls noRetry on duplicate", async () => {
178    const controller = { scheduledTime: 1704067200000, cron: "0 2 * * *", type: "scheduled" as const, noRetry: vi.fn() };
179    await env.EXECUTIONS.put("0 2 * * *-1704067200000", "1");
180    await worker.scheduled(controller, env, { waitUntil: vi.fn(), passThroughOnException: vi.fn() });
181    expect(controller.noRetry).toHaveBeenCalled();
182  });
183});
184```
185 
186## See Also
187 
188- [README.md](./README.md) - Overview
189- [api.md](./api.md) - Handler implementation
190- [gotchas.md](./gotchas.md) - Troubleshooting
191