Interfaces & Modelle

// ✓ Ein Typ, der nur von dieser Komponente genutzt wird → in derselben Datei
interface SortOption {
  value: 'price' | 'rating' | 'name';
  label: string;
}

@Component({ selector: 'app-sort-menu', /* ... */ })
export class SortMenu {
  protected readonly options: SortOption[] = [
    { value: 'price', label: 'Preis' },
    { value: 'rating', label: 'Bewertung' },
  ];
}

// models/product-dto.ts — GENAU die Form vom Server
export interface ProductDto {
  id: number;
  product_name: string;
  price_cents: number;
  stock: number;
  created_at: string;       // ISO string
  discount: number | null;
}

// models/product.ts — was die UI braucht
export interface Product {
  id: number;
  name: string;
  price: number;            // Währungseinheiten, nicht Cent
  inStock: boolean;         // abgeleitet
  createdAt: Date;
  discount?: number;        // kein null
}

// models/product-mapper.ts — der einzige Ort, der beide kennt
export function toProduct(dto: ProductDto): Product {
  return {
    id: dto.id,
    name: dto.product_name,
    price: dto.price_cents / 100,
    inStock: dto.stock > 0,
    createdAt: new Date(dto.created_at),
    ...(dto.discount !== null && { discount: dto.discount }),
  };
}

// interface: Objektformen (erweiterbar, klare Fehlermeldungen)
export interface User {
  id: number;
  name: string;
}
export interface Admin extends User {
  permissions: string[];
}

// type: Unions, Intersections, abgeleitete Typen, Funktionen
export type Role = 'admin' | 'editor' | 'viewer';
export type Id = number | string;
export type UserPreview = Pick<User, 'id' | 'name'>;
export type UserPatch = Partial<Omit<User, 'id'>>;
export type Comparator<T> = (a: T, b: T) => number;
export type LoadState<T> = { status: 'loading' } | { status: 'ok'; data: T } | { status: 'error'; error: string };

// ✓ Eine Union aus Strings + ein `as const`-Objekt statt eines Enums
export const ORDER_STATUSES = ['pending', 'paid', 'shipped', 'cancelled'] as const;
export type OrderStatus = (typeof ORDER_STATUSES)[number]; // 'pending' | 'paid' | ...

export const ORDER_LABELS: Record<OrderStatus, string> = {
  pending: 'Ausstehend',
  paid: 'Bezahlt',
  shipped: 'Versendet',
  cancelled: 'Storniert',
}; // wenn du einen Status hinzufügst und sein Label vergisst → Compile-Fehler

// Im Template: @for (s of statuses; track s) { ... } — leicht zu iterieren, ohne Object.values(Enum)

// ✓ Klare Namen, ohne unnötige Präfixe/Suffixe
interface Product {}                 // nicht IProduct, nicht ProductModel, nicht ProductInterface
interface ProductDto {}              // die Form aus der API
interface CreateProductRequest {}    // der Body für POST
interface ProductFilters {}          // UI-Zustand
type ProductId = number;             // semantischer Alias (optional)

// ✗ Interfaces für Services „einfach so“
interface IProductService { list(): Observable<Product[]>; } // bringt nichts
// Mehrere Implementierungen / Mocks gewünscht? → eine abstrakte Klasse als Token (siehe „inject() & @Service()“)

// Leite Typen aus der Single Source of Truth ab, statt sie neu zu schreiben
type UserRow = Pick<User, 'id' | 'name' | 'email'>;
type ProductForm = Omit<Product, 'id' | 'createdAt'>;
type Store = InstanceType<typeof ProductsStore>;
type CartItem = ReturnType<CartStore['items']>[number];

// Ein Validierungsschema = Typ + Laufzeitvalidierung, eine Quelle
const UserSchema = z.object({ id: z.number(), name: z.string(), email: z.email() });
type User = z.infer<typeof UserSchema>;

// Aus OpenAPI generierte Typen (openapi-typescript, orval, ng-openapi-gen)
import type { components } from './generated/api';
type ProductDto = components['schemas']['Product'];