Musterlösung Aufgabe Product API

Author: lukaspanni

package-lock.json

@@ -1,8 +1,48 @@
 import express from "express";
+import buildProductRouter from "./router/product";
+import { InMemoryProductRepository } from "./repository/in-memory-product-repository";
+import type { Product } from "./types/product";
+
+const sampleData = [
+  {
+    id: crypto.randomUUID(),
+    name: "Laptop Pro X",
+    description: "Leistungsstarker Laptop für professionelle Anwendungen.",
+    price: 1200.0,
+    currency: "EUR",
+  },
+  {
+    id: crypto.randomUUID(),
+    name: "Gaming Maus XYZ",
+    description: "Ergonomische Maus für Gamer mit anpassbaren Tasten.",
+    price: 65.99,
+    currency: "EUR",
+  },
+  {
+    id: crypto.randomUUID(),
+    name: "UHD Monitor 27 Zoll",
+    description: "4K-Monitor mit hoher Farbtreue.",
+    price: 350.0,
+    currency: "USD",
+  },
+  {
+    id: crypto.randomUUID(),
+    name: "Smartphone Z10",
+    description: "Neuestes Smartphone mit fortschrittlicher Kamera.",
+    price: 899.99,
+    currency: "GBP",
+  },
+] satisfies Product[];
 
 const app = express();
 
-app.get("/", (_, res) => { 
+app.use(express.json()); // Middleware zum Parsen von JSON-Daten
+
+const productRepository = new InMemoryProductRepository(sampleData);
+const productRouter = buildProductRouter(productRepository);
+app.use("/products", productRouter);
+
+app.get("/", (_, res) => {
   res.send("Hello express");
 });
 

src/index.ts

@@ -0,0 +1,69 @@
+import { Product, CreateProductDto, UpdateProductDto } from "../types/product";
+import { ProductRepository } from "./product-repository";
+
+export class InMemoryProductRepository implements ProductRepository {
+  constructor(private products: Product[] = []) {}
+
+  findAll(): Product[] {
+    return this.products;
+  }
+
+  findAllFiltered(filters: {
+    name?: string;
+    price?: number;
+    currency?: string;
+  }): Product[] {
+    let filteredProducts = this.products;
+
+    if (filters.name) {
+      const searchName = filters.name.toLowerCase();
+      filteredProducts = filteredProducts.filter((product) =>
+        product.name.toLowerCase().includes(searchName)
+      );
+    }
+
+    if (filters.price) {
+      filteredProducts = filteredProducts.filter(
+        (product) => product.price === filters.price
+      );
+    }
+
+    if (filters.currency) {
+      filteredProducts = filteredProducts.filter(
+        (product) => product.currency === filters.currency
+      );
+    }
+
+    return filteredProducts;
+  }
+
+  findById(id: string): Product | undefined {
+    return this.products.find((p) => p.id === id);
+  }
+
+  create(productDto: CreateProductDto): Product {
+    const newProduct: Product = {
+      id: crypto.randomUUID(),
+      ...productDto,
+    };
+    this.products.push(newProduct);
+    return newProduct;
+  }
+
+  update(id: string, updateData: UpdateProductDto): Product | undefined {
+    const productIndex = this.products.findIndex((p) => p.id === id);
+    if (productIndex === -1) return undefined;
+
+    this.products[productIndex] = {
+      ...this.products[productIndex],
+      ...updateData,
+    };
+    return this.products[productIndex];
+  }
+
+  delete(id: string): boolean {
+    const initialLength = this.products.length;
+    this.products = this.products.filter((p) => p.id !== id);
+    return this.products.length !== initialLength;
+  }
+}

src/repository/in-memory-product-repository.ts

@@ -0,0 +1,14 @@
+import { Product, CreateProductDto, UpdateProductDto } from "../types/product";
+
+export interface ProductRepository {
+  findAll(): Product[];
+  findAllFiltered(filters: {
+    name?: string;
+    price?: number;
+    currency?: string;
+  }): Product[];
+  findById(id: string): Product | undefined;
+  create(product: CreateProductDto): Product;
+  update(id: string, product: UpdateProductDto): Product | undefined;
+  delete(id: string): boolean;
+}

src/repository/product-repository.ts

@@ -0,0 +1,118 @@
+import express, { Request, Response } from "express";
+import { CreateProductDto, UpdateProductDto } from "../types/product";
+import { ProductRepository } from "../repository/product-repository";
+
+const buildProductRouter = (productRepository: ProductRepository) => {
+  const router = express.Router();
+
+  /**
+   * GET /
+   * Gibt eine Liste aller Produkte zurück.
+   * Optional können Filter nach Name, Preis und Währung angewendet werden.
+   */
+  router.get("/", (req: Request, res: Response) => {
+    const { name, price, currency } = req.query;
+
+    const parsedPrice =
+      typeof price === "string" ? parseFloat(price) : undefined;
+    const filters = {
+      name: typeof name === "string" ? name : undefined,
+      price:
+        parsedPrice !== undefined && !isNaN(parsedPrice)
+          ? parsedPrice
+          : undefined,
+      currency: typeof currency === "string" ? currency : undefined,
+    };
+
+    const products = productRepository.findAllFiltered(filters);
+    res.status(200).json(products);
+  });
+
+  /**
+   * GET /:id
+   * Gibt ein bestimmtes Produkt anhand seiner ID zurück.
+   */
+  router.get("/:id", (req: Request, res: Response) => {
+    const { id } = req.params;
+    const product = productRepository.findById(id);
+
+    if (!product) {
+      res.status(404).json({ message: "Product not found" });
+      return;
+    }
+
+    res.status(200).json(product);
+  });
+
+  /**
+   * POST /
+   * Erstellt ein neues Produkt.
+   * Erfordert name, description, price und currency im Request Body.
+   */
+  router.post("/", (req: Request, res: Response) => {
+    const productDto = req.body as CreateProductDto;
+
+    if (
+      !productDto.name ||
+      !productDto.description ||
+      !productDto.price ||
+      !productDto.currency
+    ) {
+      res.status(400).json({
+        message: "Missing required fields: name, description, price, currency",
+      });
+      return;
+    }
+
+    if (typeof productDto.price !== "number" || productDto.price <= 0) {
+      res.status(400).json({ message: "Price must be a positive number" });
+      return;
+    }
+
+    const newProduct = productRepository.create(productDto);
+    res.status(201).json(newProduct);
+  });
+
+  /**
+   * PUT /:id
+   * Aktualisiert ein bestehendes Produkt anhand seiner ID.
+   * Erlaubt die Aktualisierung von name, description, price, currency.
+   */
+  router.put("/:id", ({ params: { id }, body }: Request, res: Response) => {
+    const updateData = body as UpdateProductDto;
+
+    if (
+      updateData.price !== undefined &&
+      (typeof updateData.price !== "number" || updateData.price <= 0)
+    ) {
+      res.status(400).json({ message: "Price must be a positive number" });
+      return;
+    }
+
+    const updatedProduct = productRepository.update(id, updateData);
+    if (!updatedProduct) {
+      res.status(404).json({ message: "Product not found" });
+    } else {
+      res.status(200).json(updatedProduct);
+    }
+  });
+
+  /**
+   * DELETE /:id
+   * Löscht ein Produkt anhand seiner ID.
+   */
+  router.delete("/:id", (req: Request, res: Response) => {
+    const { id } = req.params;
+    const deleted = productRepository.delete(id);
+
+    if (!deleted) {
+      res.status(404).json({ message: "Product not found" });
+    } else {
+      res.status(204).send(); // 204 No Content für erfolgreiches Löschen
+    }
+  });
+
+  return router;
+};
+
+export default buildProductRouter;

src/router/product.ts

@@ -0,0 +1,14 @@
+export type Currency = "EUR" | "USD" | "GBP"; // Unterstützte Währungen als Union Type
+
+export type Product = {
+  id: string; // Eindeutige ID des Produkts
+  name: string; // Name des Produkts
+  description: string; // Beschreibung des Produkts
+  price: number; // Preis des Produkts
+  currency: Currency; // Währung des Preises
+};
+
+// Produkt-Typ ohne ID (wird bei Erstellung vergeben)
+export type CreateProductDto = Omit<Product, "id">;
+// Produkt-Typ für Aktualisierungen (alle Felder bis auf id optional)
+export type UpdateProductDto = Partial<CreateProductDto> & { id: string };