# 🔍 SERVICE NAMING CHECKLIST - PraFrota

## ⚠️ CHECKLIST OBRIGATÓRIO ANTES DE CRIAR/EDITAR SERVICES

**SEMPRE consultar este checklist antes de implementar ou modificar services!**

### ✅ VERIFICAÇÕES OBRIGATÓRIAS:

#### 1. **Nomenclatura de Métodos**
- [ ] ✅ `create(data: any): Observable<Entity>` - NUNCA `createEntity()` ou `add()`
- [ ] ✅ `update(id: any, data: any): Observable<Entity>` - NUNCA `updateEntity()` ou `edit()`
- [ ] ✅ `delete(id: any): Observable<void>` - NUNCA `deleteEntity()` ou `remove()`
- [ ] ✅ `getById(id: string): Observable<Entity>` - NUNCA `getEntity()` ou `find()`
- [ ] ✅ `get[Domain]s(page, limit, filters)` - NUNCA `list()` ou `findAll()`

#### 2. **Interface DomainService**
- [ ] ✅ Implementa `DomainService<Entity>`
- [ ] ✅ Método `getEntities(page, pageSize, filters)` presente
- [ ] ✅ Métodos `create`, `update` da interface implementados

#### 3. **ApiClientService**
- [ ] ✅ Importa `ApiClientService` - NUNCA `HttpClient`
- [ ] ✅ Constructor: `private apiClient: ApiClientService`
- [ ] ✅ Calls: `this.apiClient.get()` - NUNCA `this.http.get()`

#### 4. **Estrutura Padrão**
- [ ] ✅ `@Injectable({ providedIn: 'root' })`
- [ ] ✅ Imports corretos: `Observable`, `map`, `catchError`
- [ ] ✅ Fallback com dados mock implementado

### ❌ ANTI-PATTERNS A EVITAR:

#### 🚫 NOMENCLATURA PROIBIDA:
```typescript
// ❌ NUNCA FAZER:
createRoute(), createVehicle(), createDriver()
updateRoute(), updateVehicle(), updateDriver()
deleteRoute(), deleteVehicle(), deleteDriver()
getRoute(), getVehicle(), getDriver()
addEntity(), editEntity(), removeEntity()
findById(), searchById(), retrieveById()
saveEntity(), persistEntity(), insertEntity()
```

#### 🚫 IMPORTS PROIBIDOS:
```typescript
// ❌ NUNCA IMPORTAR:
import { HttpClient } from '@angular/common/http';

// ✅ SEMPRE USAR:
import { ApiClientService } from '../../shared/services/api/api-client.service';
```

#### 🚫 CONSTRUTORES INCORRETOS:
```typescript
// ❌ ERRADO:
constructor(private http: HttpClient) {}
constructor(service: SomeService, private adapter: ServiceAdapter) {}

// ✅ CORRETO:
constructor(private apiClient: ApiClientService) {}
```

### 📋 TEMPLATE DE VERIFICAÇÃO:

```typescript
// ✅ TEMPLATE CORRETO PARA COPY/PASTE:
import { Injectable } from '@angular/core';
import { Observable, of, map } from 'rxjs';
import { catchError } from 'rxjs/operators';

import { Entity } from './entity.interface';
import { ApiClientService } from '../../shared/services/api/api-client.service';
import { DomainService } from '../../shared/components/base-domain/base-domain.component';
import { PaginatedResponse } from '../../shared/interfaces/paginate.interface';

@Injectable({
  providedIn: 'root'
})
export class ExampleService implements DomainService<Entity> {
  
  constructor(
    private apiClient: ApiClientService  // ✅ CORRETO
  ) {}

  // ✅ Métodos da interface DomainService
  getEntities(page: number, pageSize: number, filters: any): Observable<any> {
    return this.getExamples(page, pageSize, filters).pipe(
      map(response => ({
        data: response.data,
        totalCount: response.totalCount,
        pageCount: response.pageCount,
        currentPage: response.currentPage
      }))
    );
  }

  create(data: any): Observable<Entity> {  // ✅ CORRETO
    return this.apiClient.post<Entity>('examples', data);
  }

  update(id: any, data: any): Observable<Entity> {  // ✅ CORRETO
    return this.apiClient.patch<Entity>(`examples/${id}`, data);
  }

  // ✅ Métodos específicos padrão
  getById(id: string): Observable<Entity> {  // ✅ CORRETO
    return this.apiClient.get<Entity>(`examples/${id}`);
  }

  delete(id: string): Observable<void> {  // ✅ CORRETO
    return this.apiClient.delete<void>(`examples/${id}`);
  }

  getExamples(page = 1, limit = 10, filters?: any): Observable<PaginatedResponse<Entity>> {
    let url = `examples?page=${page}&limit=${limit}`;
    
    if (filters) {
      const params = new URLSearchParams();
      for (const [key, value] of Object.entries(filters)) {
        if (value) {
          params.append(key, value.toString());
        }
      }
      if (params.toString()) {
        url += `&${params.toString()}`;
      }
    }

    return this.apiClient.get<PaginatedResponse<Entity>>(url).pipe(
      catchError(error => {
        console.warn('⚠️ Backend indisponível, usando dados de fallback', error);
        return of(this.getFallbackData(page, limit, filters));
      })
    );
  }

  private getFallbackData(page: number, limit: number, filters?: any): PaginatedResponse<Entity> {
    return {
      data: [],
      totalCount: 0,
      pageCount: 0,
      currentPage: page
    };
  }
}
```

### 🎯 SERVICES DE REFERÊNCIA:

#### ✅ CONFORMES (Usar como exemplo):
- **VehiclesService**: `create`, `update`, `getById`, `delete`, `getVehicles`
- **DriversService**: `create`, `update`, `getById`, `delete`, `getDrivers`
- **RoutesService**: `create`, `update`, `getById`, `delete`, `getRoutes`

### 🚨 CONSEQUÊNCIAS DE NÃO SEGUIR:

1. **Build Errors**: BaseDomainComponent não encontrará métodos esperados
2. **Runtime Errors**: Interface DomainService quebrada
3. **Inconsistency**: Quebra padrões estabelecidos no projeto
4. **Team Confusion**: Outros desenvolvedores não conseguirão manter o código
5. **Architecture Violation**: Viola princípios SOLID e Clean Architecture

### 📝 PROCESSO DE REVISÃO:

1. **Antes de criar**: Consultar este checklist
2. **Durante implementação**: Verificar cada método criado
3. **Antes de commit**: Revisar nomenclatura completa
4. **Code Review**: Outro desenvolvedor deve verificar conformidade
5. **Testing**: Verificar se BaseDomainComponent funciona corretamente

---

**⚠️ IMPORTANTE: Este documento é CRÍTICO para manter a consistência do projeto. NUNCA pule estas verificações!** 