error-handling-patterns

Resultado esperado:

Aqui está um padrão para tratamento robusto de arquivos com hierarquia de erros apropriada:

**Exemplo Python:**
```python
class FileReadError(ApplicationError):
"""Raised when file read operations fail."""
pass

class ParseError(ApplicationError):
"""Raised when JSON parsing fails."""
pass

def read_json_file(path: str) -> dict:
try:
with open(path, 'r') as f:
content = f.read()
return json.loads(content)
except FileNotFoundError as e:
raise FileReadError(f"File not found: {path}", details={"path": path}) from e
except json.JSONDecodeError as e:
raise ParseError(f"Invalid JSON in file: {path}", details={"path": path, "error": str(e)}) from e
```

**Práticas principais:**
- Use tipos de exceção específicos para diferentes cenários de erro
- Inclua informações contextuais nas exceções
- Encadeie exceções para preservar a stack trace original
- Use context managers para limpeza automática de recursos

Resultado esperado:

Para chamadas de serviços em paralelo, considere estas estratégias:

**Opção 1: Agregar Erros**
Colete todos os erros e reporte-os juntos em vez de falhar no primeiro erro.

```typescript
async function fetchUserData(userId: string): Promise<UserData> {
const errors: Error[] = [];
let user: User | null = null;
let orders: Order[] = [];

try { user = await userService.getUser(userId); }
catch (e) { errors.push(e); }

try { orders = await orderService.getOrders(userId); }
catch (e) { errors.push(e); }

if (errors.length > 0) {
throw new AggregateError(errors, `${errors.length} operations failed`);
}

return { user, orders };
}
```

**Opção 2: Tipos Result**
Use tipos explícitos de sucesso/falha para cada operação.

```typescript
async function fetchUserData(userId: string): Promise<Result<UserData>> {
const [userResult, ordersResult] = await Promise.all([
safePromise(userService.getUser(userId)),
safePromise(orderService.getOrders(userId))
]);

if (!userResult.ok) return Err(userResult.error);
if (!ordersResult.ok) return Err(ordersResult.error);

return Ok({ user: userResult.value, orders: ordersResult.value });
}
```

Resultado esperado:

Aqui estão os anti-padrões mais perigosos e suas correções:

**Anti-Padrão 1: Blocos Catch Vazios**
```python
try:
do_something()
except:
pass # Silent failure - bugs hide forever
```
**Correção:** Sempre registre em log ou relance exceções.

**Anti-Padrão 2: Capturar de Forma Muito Ampla**
```python
try:
do_something()
except Exception:
# Hides bugs including typos and logic errors
pass
```
**Correção:** Capture apenas tipos de exceção específicos.

**Anti-Padrão 3: Engolir Após Registrar em Log**
```python
try:
do_something()
except Exception as e:
logger.error(e)
# Error logged but not handled - caller doesn't know it failed
```
**Correção:** Relance ou retorne resultado de erro.

**Anti-Padrão 4: Erros Excessivamente Genéricos**
```python
raise Exception("Error occurred") # No context, no code, useless for debugging
```
**Correção:** Inclua o que aconteceu, o que estava sendo processado e códigos de erro.