1# Common Patterns
2 
3## List All with Auto-Pagination
4 
5**Problem:** API returns paginated results. Default page size is 20.
6 
7**Solution:** Use SDK auto-pagination to iterate all results.
8 
9```typescript
10// TypeScript
11for await (const zone of client.zones.list()) {
12  console.log(zone.name);
13}
14```
15 
16```python
17# Python
18for zone in client.zones.list():
19    print(zone.name)
20```
21 
22```go
23// Go
24iter := client.Zones.ListAutoPaging(ctx, cloudflare.ZoneListParams{})
25for iter.Next() {
26    fmt.Println(iter.Current().Name)
27}
28```
29 
30## Error Handling with Retry
31 
32**Problem:** Rate limits (429) and transient errors need retry.
33 
34**Solution:** SDKs auto-retry with exponential backoff. Customize as needed.
35 
36```typescript
37// Increase retries for rate-limit-heavy operations
38const client = new Cloudflare({ maxRetries: 5 });
39 
40try {
41  const zone = await client.zones.create({ /* ... */ });
42} catch (err) {
43  if (err instanceof Cloudflare.RateLimitError) {
44    // Already retried 5 times with backoff
45    const retryAfter = err.headers['retry-after'];
46    console.log(`Rate limited. Retry after ${retryAfter}s`);
47  }
48}
49```
50 
51## Batch Parallel Operations
52 
53**Problem:** Need to create multiple resources quickly.
54 
55**Solution:** Use `Promise.all()` for parallel requests (respect rate limits).
56 
57```typescript
58// Create multiple DNS records in parallel
59const records = ['www', 'api', 'cdn'].map(subdomain =>
60  client.dns.records.create({
61    zone_id: 'zone-id',
62    type: 'A',
63    name: `${subdomain}.example.com`,
64    content: '192.0.2.1',
65  })
66);
67await Promise.all(records);
68```
69 
70**Controlled concurrency** (avoid rate limits):
71 
72```typescript
73import pLimit from 'p-limit';
74const limit = pLimit(10); // Max 10 concurrent
75 
76const subdomains = ['www', 'api', 'cdn', /* many more */];
77const records = subdomains.map(subdomain =>
78  limit(() => client.dns.records.create({
79    zone_id: 'zone-id',
80    type: 'A',
81    name: `${subdomain}.example.com`,
82    content: '192.0.2.1',
83  }))
84);
85await Promise.all(records);
86```
87 
88## Zone CRUD Workflow
89 
90```typescript
91// Create
92const zone = await client.zones.create({
93  account: { id: 'account-id' },
94  name: 'example.com',
95  type: 'full',
96});
97 
98// Read
99const fetched = await client.zones.get({ zone_id: zone.id });
100 
101// Update
102await client.zones.edit(zone.id, { paused: false });
103 
104// Delete
105await client.zones.delete(zone.id);
106```
107 
108## DNS Bulk Update
109 
110```typescript
111// Fetch all A records
112const records = [];
113for await (const record of client.dns.records.list({
114  zone_id: 'zone-id',
115  type: 'A',
116})) {
117  records.push(record);
118}
119 
120// Update all to new IP
121await Promise.all(records.map(record =>
122  client.dns.records.update({
123    zone_id: 'zone-id',
124    dns_record_id: record.id,
125    type: 'A',
126    name: record.name,
127    content: '203.0.113.1', // New IP
128    proxied: record.proxied,
129    ttl: record.ttl,
130  })
131));
132```
133 
134## Filter and Collect Results
135 
136```typescript
137// Find all proxied A records
138const proxiedRecords = [];
139for await (const record of client.dns.records.list({
140  zone_id: 'zone-id',
141  type: 'A',
142})) {
143  if (record.proxied) {
144    proxiedRecords.push(record);
145  }
146}
147```
148 
149## Error Recovery Pattern
150 
151```typescript
152async function createZoneWithRetry(name: string, maxAttempts = 3) {
153  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
154    try {
155      return await client.zones.create({
156        account: { id: 'account-id' },
157        name,
158        type: 'full',
159      });
160    } catch (err) {
161      if (err instanceof Cloudflare.RateLimitError && attempt < maxAttempts) {
162        const retryAfter = parseInt(err.headers['retry-after'] || '5');
163        console.log(`Rate limited, waiting ${retryAfter}s (retry ${attempt}/${maxAttempts})`);
164        await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
165      } else {
166        throw err;
167      }
168    }
169  }
170}
171```
172 
173## Conditional Update Pattern
174 
175```typescript
176// Only update if zone is active
177const zone = await client.zones.get({ zone_id: 'zone-id' });
178if (zone.status === 'active') {
179  await client.zones.edit(zone.id, { paused: false });
180}
181```
182 
183## Batch with Error Handling
184 
185```typescript
186// Process multiple zones, continue on errors
187const results = await Promise.allSettled(
188  zoneIds.map(id => client.zones.get({ zone_id: id }))
189);
190 
191results.forEach((result, i) => {
192  if (result.status === 'fulfilled') {
193    console.log(`Zone ${i}: ${result.value.name}`);
194  } else {
195    console.error(`Zone ${i} failed:`, result.reason.message);
196  }
197});
198```
199 
200## See Also
201 
202- [api.md](./api.md) - SDK client initialization, basic operations
203- [gotchas.md](./gotchas.md) - Rate limits, common errors
204- [configuration.md](./configuration.md) - SDK configuration options
205