Arhitectură hexagonală (ports & adapters)

                 ┌──────────────────────── exterior: adaptoare ────────────────────────┐
                 │  presentation (driving)                 infrastructure (driven)     │
  utilizator ──▶ │  TasksPage, TaskItem                    HttpTaskRepository, TaskDto │ ──▶ server
                 │        │   ┌──────────── application ─────────────┐   ▲             │
                 │        └──▶│ TaskBoard / AddTask ──▶ TaskRepository│───┘ implementează│
                 │            │        │      ┌──── domain ────┐     │                  │
                 │            │        └─────▶│ Task, createTask│    │                  │
                 │            │               └─────────────────┘     │                  │
                 │            └───────────────────────────────────────┘                  │
                 └──────────────────────────────────────────────────────────────────────┘
  Regula: săgețile de import arată DOAR spre interior. Domeniul nu importă nimic din afară.
  app.config.ts (composition root) e singurul loc care leagă TaskRepository de un adaptor.

// tasks/domain/task.ts — TypeScript pur: niciun import din Angular, RxJS sau browser
export type TaskId = string & { readonly __brand: 'TaskId' };

export interface Task {
  readonly id: TaskId;
  readonly title: string;
  readonly done: boolean;
  readonly createdAt: Date;
}

export class DomainError extends Error {
  override readonly name = 'DomainError';
}

export function normalizeTitle(raw: string): string {
  return raw.trim().replace(/\s+/g, ' ');
}

// `now` și `id` vin ca parametri: domeniul nu citește ceasul și nu generează id-uri singur
export function createTask(raw: string, existing: readonly Task[], now: Date, id: TaskId): Task {
  const title = normalizeTitle(raw);
  if (title.length < 3) throw new DomainError('Titlul are nevoie de cel puțin 3 caractere.');
  if (existing.some((t) => !t.done && t.title.toLowerCase() === title.toLowerCase())) {
    throw new DomainError('Există deja o sarcină deschisă cu acest titlu.');
  }
  return { id, title, done: false, createdAt: now };
}

export function toggleTask(task: Task): Task {
  return { ...task, done: !task.done };
}

// tasks/application/task-repository.ts — PORTUL
import { Task, TaskId } from '../domain/task';

// Clasă abstractă, nu interfață: există la runtime, deci e direct token de DI.
// Nu are @Injectable și nu știe de nicio implementare.
export abstract class TaskRepository {
  abstract list(): Promise<readonly Task[]>;
  abstract save(task: Task): Promise<void>; // upsert
  abstract remove(id: TaskId): Promise<void>;
}

// Parte din contract: adaptoarele își traduc erorile tehnice în asta.
export class RepositoryUnavailableError extends Error {
  override readonly name = 'RepositoryUnavailableError';
}

// tasks/application/add-task.ts — un caz de utilizare = o clasă cu o singură metodă publică
import { Injectable, inject } from '@angular/core';
import { Task, TaskId, createTask } from '../domain/task';
import { TaskRepository } from './task-repository';

@Injectable({ providedIn: 'root' })
export class AddTask {
  private readonly repo = inject(TaskRepository); // portul — nu știe ce adaptor răspunde

  async execute(title: string): Promise<Task> {
    const existing = await this.repo.list();
    const task = createTask(title, existing, new Date(), crypto.randomUUID() as TaskId); // regula: în domeniu
    await this.repo.save(task); // I/O: prin port
    return task;
  }
}

// tasks/infrastructure/http-task-repository.ts — ADAPTORUL HTTP
import { HttpClient, HttpErrorResponse } from '@angular/common/http';
import { Injectable, inject } from '@angular/core';
import { Observable, firstValueFrom } from 'rxjs';
import { Task, TaskId } from '../domain/task';
import { RepositoryUnavailableError, TaskRepository } from '../application/task-repository';
import { TaskDto, taskFromDto, taskToDto } from './task-dto';

@Injectable()
export class HttpTaskRepository extends TaskRepository {
  private readonly http = inject(HttpClient);
  private readonly url = '/api/tasks';

  async list(): Promise<readonly Task[]> {
    const dtos = await this.call(this.http.get<TaskDto[]>(this.url));
    return dtos.map(taskFromDto); // DTO → domeniu, aici și nicăieri altundeva
  }

  async save(task: Task): Promise<void> {
    await this.call(this.http.put<TaskDto>(`${this.url}/${task.id}`, taskToDto(task)));
  }

  async remove(id: TaskId): Promise<void> {
    await this.call(this.http.delete<void>(`${this.url}/${id}`));
  }

  // HttpErrorResponse nu iese din adaptor: nucleul primește eroarea portului
  private async call<T>(request: Observable<T>): Promise<T> {
    try {
      return await firstValueFrom(request);
    } catch (e) {
      if (e instanceof HttpErrorResponse) throw new RepositoryUnavailableError(`HTTP ${e.status}`);
      throw e;
    }
  }
}

// app.config.ts — COMPOSITION ROOT: singurul fișier care știe ce adaptor folosim
export const appConfig: ApplicationConfig = {
  providers: [
    provideHttpClient(withInterceptors([authInterceptor])),
    { provide: TaskRepository, useClass: HttpTaskRepository },
  ],
};

// Testul cazului de utilizare: adaptorul in-memory în locul HTTP-ului
import { TestBed } from '@angular/core/testing';

describe('AddTask', () => {
  let addTask: AddTask;
  let repo: InMemoryTaskRepository;

  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [{ provide: TaskRepository, useClass: InMemoryTaskRepository }],
    });
    addTask = TestBed.inject(AddTask);
    repo = TestBed.inject(TaskRepository) as InMemoryTaskRepository;
  });

  it('salvează prin port', async () => {
    await addTask.execute('Scrie teste');
    expect((await repo.list()).map((t) => t.title)).toEqual(['Scrie teste']);
  });

  it('nu salvează nimic dacă regula de domeniu e încălcată', async () => {
    await expect(addTask.execute('ab')).rejects.toThrow(DomainError);
    expect(await repo.list()).toEqual([]);
  });
});

// Regula dependenței, verificată la fiecare commit (ESLint no-restricted-imports cu regex)
export default [
  {
    files: ['src/app/features/*/domain/**/*.ts'],
    rules: {
      'no-restricted-imports': ['error', { patterns: [
        { regex: '^(@angular/|rxjs)', message: 'Domeniul e TypeScript pur: fără Angular, fără RxJS.' },
        { regex: '/(application|infrastructure|ui)/', message: 'Domeniul nu depinde de straturile exterioare.' },
      ] }],
    },
  },
  {
    files: ['src/app/features/*/application/**/*.ts'],
    rules: {
      'no-restricted-imports': ['error', { patterns: [
        { regex: '/(infrastructure|ui)/', message: 'Application depinde de porturi, nu de adaptoare sau de UI.' },
        { regex: '^@angular/common/http', message: 'HTTP doar în infrastructure.' },
      ] }],
    },
  },
  {
    files: ['src/app/features/*/ui/**/*.ts'],
    rules: {
      'no-restricted-imports': ['error', { patterns: [
        { regex: '/infrastructure/', message: 'UI-ul injectează portul sau cazul de utilizare, nu adaptorul.' },
      ] }],
    },
  },
];
// Într-un monorepo Nx: domain/application/infrastructure ca librării separate, cu tag-uri
// și @nx/enforce-module-boundaries (vezi pagina Monorepo).

// ✗ „Implementarea implicită” pusă pe port
@Injectable({ providedIn: 'root', useClass: HttpTaskRepository }) // portul importă adaptorul!
export abstract class TaskRepository { /* ... */ }
// Application → infrastructure: regula dependenței e încălcată, iar HttpClient
// ajunge în bundle chiar și pentru aplicația care folosește doar localStorage.

// ✓ Portul rămâne gol; alegerea stă în composition root
export abstract class TaskRepository { /* ... */ }
providers: [{ provide: TaskRepository, useClass: HttpTaskRepository }]

STRATURI (importurile arată doar spre interior)
  domain          Task, createTask()         TypeScript pur — fără Angular, RxJS, browser
  application     TaskRepository (port)      clasă abstractă = tip + token de DI
                  AddTask / TaskBoard        inject(TaskRepository), semnale pentru UI
  infrastructure  HttpTaskRepository         extends TaskRepository, DTO ↔ domeniu, erori traduse
  presentation    TasksPage, TaskItem        injectează application, niciodată infrastructure
  composition     app.config / route.providers  { provide: TaskRepository, useClass: Http… }

REȚETE
  schimbi adaptorul        alt useClass în composition root (sau provideTasks('local'))
  test pentru use case     providers: [{ provide: TaskRepository, useClass: InMemoryTaskRepository }]
  test pentru adaptor      contract comun + HttpTestingController pentru maparea HTTP
  DTO                      doar în infrastructure; portul vorbește în entități
  erori                    adaptorul aruncă RepositoryUnavailableError, nu HttpErrorResponse

CÂND NU
  CRUD fără reguli, app mică, prototip → httpResource în componentă + mapare în parse