Error Handling

1
{
2
  "success": false,
3
  "detail": "Human-readable error message"
4
}

1
{
2
  "detail": [
3
    {
4
      "loc": ["body", "field_name"],
5
      "msg": "Error message describing the issue",
6
      "type": "error_type"
7
    }
8
  ]
9
}

1
// Request with invalid URL
2
POST /api/v1/psd/upload
3
{
4
  "psd_file_url": "not-a-valid-url"
5
}
6
7
// Response
8
{
9
  "success": false,
10
  "detail": "Invalid PSD file URL format"
11
}

1
// Request without API key
2
POST /api/v1/psd/upload
3
X-API-KEY: (missing or invalid)
4
5
// Response
6
{
7
  "success": false,
8
  "detail": "Invalid or missing API key"
9
}

1
// Request missing required field
2
POST /api/v1/psd/upload
3
{
4
  "psd_name": "My Mockup"
5
  // Missing: psd_file_url (required)
6
}
7
8
// Response
9
{
10
  "detail": [
11
    {
12
      "loc": ["body", "psd_file_url"],
13
      "msg": "field required",
14
      "type": "value_error.missing"
15
    }
16
  ]
17
}

1
// Request with invalid asset URL
2
POST /api/v1/renders
3
{
4
  "mockup_uuid": "valid-uuid",
5
  "smart_objects": [{
6
    "uuid": "so-uuid",
7
    "asset": { "url": "not-accessible-url" }
8
  }]
9
}
10
11
// Response
12
{
13
  "success": false,
14
  "detail": "Unable to fetch asset from provided URL"
15
}

1
// Request with invalid mockup_uuid
2
POST /api/v1/renders
3
{
4
  "mockup_uuid": "non-existent-uuid",
5
  "smart_objects": [...]
6
}
7
8
// Response
9
{
10
  "success": false,
11
  "detail": "Mockup not found"
12
}

1
// Request with invalid field type
2
POST /api/v1/renders
3
{
4
  "mockup_uuid": "valid-uuid",
5
  "smart_objects": "should-be-array"
6
}
7
8
// Response
9
{
10
  "detail": [
11
    {
12
      "loc": ["body", "smart_objects"],
13
      "msg": "value is not a valid list",
14
      "type": "type_error.list"
15
    }
16
  ]
17
}
18
19
// Request with invalid export options
20
POST /api/v1/renders
21
{
22
  "mockup_uuid": "valid-uuid",
23
  "smart_objects": [...],
24
  "export_options": {
25
    "image_size": 10000,  // Max is 8000
26
    "quality": 150        // Max is 100
27
  }
28
}
29
30
// Response
31
{
32
  "detail": [
33
    {
34
      "loc": ["body", "export_options", "image_size"],
35
      "msg": "ensure this value is less than or equal to 8000",
36
      "type": "value_error.number.not_le"
37
    },
38
    {
39
      "loc": ["body", "export_options", "quality"],
40
      "msg": "ensure this value is less than or equal to 100",
41
      "type": "value_error.number.not_le"
42
    }
43
  ]
44
}

1
// Request without Bearer token
2
POST /api/v1/api-keys
3
Authorization: (missing)
4
5
// Response
6
{
7
  "success": false,
8
  "detail": "Invalid or missing Bearer token"
9
}

1
// Request to delete non-existent key
2
DELETE /api/v1/api-keys/non-existent-id
3
4
// Response
5
{
6
  "success": false,
7
  "detail": "API key not found"
8
}

1
// Request with invalid expiration
2
POST /api/v1/api-keys
3
{
4
  "name": "My Key",
5
  "expires_in_days": 5000  // Max is 3650
6
}
7
8
// Response
9
{
10
  "detail": [
11
    {
12
      "loc": ["body", "expires_in_days"],
13
      "msg": "ensure this value is less than or equal to 3650",
14
      "type": "value_error.number.not_le"
15
    }
16
  ]
17
}

1
// Response on server error
2
{
3
  "success": false,
4
  "detail": "An unexpected error occurred. Please try again."
5
}

1
async function renderWithRetry(payload, maxRetries = 3) {
2
  for (let attempt = 0; attempt < maxRetries; attempt++) {
3
    try {
4
      const response = await fetch('https://api.sudomock.com/api/v1/renders', {
5
        method: 'POST',
6
        headers: {
7
          'X-API-KEY': process.env.SUDOMOCK_API_KEY,
8
          'Content-Type': 'application/json'
9
        },
10
        body: JSON.stringify(payload)
11
      });
12
13
      // Success
14
      if (response.ok) {
15
        return response.json();
16
      }
17
18
      // Rate limited - wait and retry
19
      if (response.status === 429) {
20
        const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
21
        console.log(`Rate limited. Retrying in ${retryAfter}s...`);
22
        await sleep(retryAfter * 1000);
23
        continue;
24
      }
25
26
      // Server error - exponential backoff
27
      if (response.status >= 500) {
28
        const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s
29
        console.log(`Server error. Retrying in ${delay}ms...`);
30
        await sleep(delay);
31
        continue;
32
      }
33
34
      // Client error - don't retry, throw immediately
35
      const error = await response.json();
36
      throw new Error(error.detail || JSON.stringify(error));
37
38
    } catch (networkError) {
39
      // Network error - retry with backoff
40
      if (attempt < maxRetries - 1) {
41
        const delay = Math.pow(2, attempt) * 1000;
42
        await sleep(delay);
43
        continue;
44
      }
45
      throw networkError;
46
    }
47
  }
48
  
49
  throw new Error('Max retries exceeded');
50
}
51
52
function sleep(ms) {
53
  return new Promise(resolve => setTimeout(resolve, ms));
54
}

1
async function handleRenderRequest(payload) {
2
  const response = await fetch('https://api.sudomock.com/api/v1/renders', {
3
    method: 'POST',
4
    headers: {
5
      'X-API-KEY': process.env.SUDOMOCK_API_KEY,
6
      'Content-Type': 'application/json'
7
    },
8
    body: JSON.stringify(payload)
9
  });
10
11
  if (response.status === 422) {
12
    const error = await response.json();
13
    
14
    // Parse validation errors
15
    for (const err of error.detail) {
16
      const fieldPath = err.loc.join('.');
17
      console.error(`Validation error at ${fieldPath}: ${err.msg}`);
18
      
19
      // Example: "body.export_options.quality: ensure this value is less than or equal to 100"
20
    }
21
    
22
    throw new Error('Validation failed: ' + error.detail.map(e => e.msg).join(', '));
23
  }
24
25
  if (!response.ok) {
26
    const error = await response.json();
27
    throw new Error(error.detail);
28
  }
29
30
  return response.json();
31
}