feat: enhance API response handling and add new components for module management

apps/web/app/api/club/accept-invite/route.ts

@@ -2,6 +2,7 @@ import { NextResponse } from 'next/server';
 
 import { createClient } from '@supabase/supabase-js';
 
+import { apiError } from '@kit/next/route-helpers';
 import { getLogger } from '@kit/shared/logger';
 
 export async function POST(request: Request) {
@@ -113,6 +114,6 @@ export async function POST(request: Request) {
       { error: err, context: 'accept-invite' },
       '[accept-invite] Error',
     );
-    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 });
+    return apiError('Serverfehler', 500);
   }
 }

apps/web/app/api/club/contact/route.ts

@@ -1,27 +1,28 @@
-import { NextResponse } from 'next/server';
+import * as z from 'zod';
 
+import { apiError, apiSuccess, emailSchema } from '@kit/next/route-helpers';
 import { getLogger } from '@kit/shared/logger';
 
+const ContactSchema = z.object({
+  recipientEmail: z.string().optional(),
+  name: z.string().optional(),
+  email: emailSchema,
+  subject: z.string().optional(),
+  message: z.string().min(1, 'Nachricht ist erforderlich'),
+});
+
 export async function POST(request: Request) {
   const logger = await getLogger();
 
   try {
     const body = await request.json();
-    const { recipientEmail, name, email, subject, message } = body;
+    const parsed = ContactSchema.safeParse(body);
 
-    if (!email || !message) {
-      return NextResponse.json(
-        { error: 'E-Mail und Nachricht sind erforderlich' },
-        { status: 400 },
-      );
+    if (!parsed.success) {
+      return apiError(parsed.error.issues[0]?.message ?? 'Ungültige Eingabe');
     }
 
-    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-      return NextResponse.json(
-        { error: 'Ungültige E-Mail-Adresse' },
-        { status: 400 },
-      );
-    }
+    const { recipientEmail, name, email, subject, message } = parsed.data;
 
     // In production: use @kit/mailers to send the email
     // For now: log and return success
@@ -45,9 +46,9 @@ export async function POST(request: Request) {
     //   text: `Name: ${name}\nE-Mail: ${email}\n\n${message}`,
     // });
 
-    return NextResponse.json({ success: true, message: 'Nachricht gesendet' });
+    return apiSuccess({ message: 'Nachricht gesendet' });
   } catch (err) {
     logger.error({ error: err, context: 'contact' }, '[contact] Error');
-    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 });
+    return apiError('Serverfehler', 500);
   }
 }

apps/web/app/api/club/course-register/route.ts

@@ -1,28 +1,34 @@
-import { NextResponse } from 'next/server';
+import * as z from 'zod';
 
+import {
+  apiError,
+  apiSuccess,
+  emailSchema,
+  requiredString,
+} from '@kit/next/route-helpers';
 import { getLogger } from '@kit/shared/logger';
 import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';
 
+const CourseRegisterSchema = z.object({
+  courseId: requiredString('Kurs-ID'),
+  firstName: requiredString('Vorname'),
+  lastName: requiredString('Nachname'),
+  email: emailSchema,
+  phone: z.string().optional(),
+});
+
 export async function POST(request: Request) {
   const logger = await getLogger();
 
   try {
     const body = await request.json();
-    const { courseId, firstName, lastName, email, phone } = body;
+    const parsed = CourseRegisterSchema.safeParse(body);
 
-    if (!courseId || !firstName || !lastName || !email) {
-      return NextResponse.json(
-        { error: 'Kurs-ID, Vorname, Nachname und E-Mail sind erforderlich' },
-        { status: 400 },
-      );
+    if (!parsed.success) {
+      return apiError(parsed.error.issues[0]?.message ?? 'Ungültige Eingabe');
     }
 
-    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-      return NextResponse.json(
-        { error: 'Ungültige E-Mail-Adresse' },
-        { status: 400 },
-      );
-    }
+    const { courseId, firstName, lastName, email, phone } = parsed.data;
 
     const supabase = getSupabaseServerAdminClient();
 
@@ -41,21 +47,15 @@ export async function POST(request: Request) {
         { error, context: 'course-register-insert' },
         '[course-register] Insert error',
       );
-      return NextResponse.json(
-        { error: 'Anmeldung fehlgeschlagen' },
-        { status: 500 },
-      );
+      return apiError('Anmeldung fehlgeschlagen', 500);
     }
 
-    return NextResponse.json({
-      success: true,
-      message: 'Anmeldung erfolgreich',
-    });
+    return apiSuccess({ message: 'Anmeldung erfolgreich' });
   } catch (err) {
     logger.error(
       { error: err, context: 'course-register' },
       '[course-register] Error',
     );
-    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 });
+    return apiError('Serverfehler', 500);
   }
 }

apps/web/app/api/club/event-register/route.ts

@@ -1,13 +1,36 @@
-import { NextResponse } from 'next/server';
+import * as z from 'zod';
 
+import {
+  apiError,
+  apiSuccess,
+  emailSchema,
+  requiredString,
+} from '@kit/next/route-helpers';
 import { getLogger } from '@kit/shared/logger';
 import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';
 
+const EventRegisterSchema = z.object({
+  eventId: requiredString('Event-ID'),
+  firstName: requiredString('Vorname'),
+  lastName: requiredString('Nachname'),
+  email: emailSchema,
+  phone: z.string().optional(),
+  dateOfBirth: z.string().optional(),
+  parentName: z.string().optional(),
+  parentPhone: z.string().optional(),
+});
+
 export async function POST(request: Request) {
   const logger = await getLogger();
 
   try {
     const body = await request.json();
+    const parsed = EventRegisterSchema.safeParse(body);
+
+    if (!parsed.success) {
+      return apiError(parsed.error.issues[0]?.message ?? 'Ungültige Eingabe');
+    }
+
     const {
       eventId,
       firstName,
@@ -17,21 +40,7 @@ export async function POST(request: Request) {
       dateOfBirth,
       parentName,
       parentPhone,
-    } = body;
-
-    if (!eventId || !firstName || !lastName || !email) {
-      return NextResponse.json(
-        { error: 'Event-ID, Vorname, Nachname und E-Mail sind erforderlich' },
-        { status: 400 },
-      );
-    }
-
-    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-      return NextResponse.json(
-        { error: 'Ungültige E-Mail-Adresse' },
-        { status: 400 },
-      );
-    }
+    } = parsed.data;
 
     const supabase = getSupabaseServerAdminClient();
 
@@ -53,21 +62,15 @@ export async function POST(request: Request) {
         { error, context: 'event-register-insert' },
         '[event-register] Insert error',
       );
-      return NextResponse.json(
-        { error: 'Anmeldung fehlgeschlagen' },
-        { status: 500 },
-      );
+      return apiError('Anmeldung fehlgeschlagen', 500);
     }
 
-    return NextResponse.json({
-      success: true,
-      message: 'Anmeldung erfolgreich',
-    });
+    return apiSuccess({ message: 'Anmeldung erfolgreich' });
   } catch (err) {
     logger.error(
       { error: err, context: 'event-register' },
       '[event-register] Error',
     );
-    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 });
+    return apiError('Serverfehler', 500);
   }
 }

apps/web/app/api/club/membership-apply/route.ts

@@ -1,13 +1,38 @@
-import { NextResponse } from 'next/server';
+import * as z from 'zod';
 
+import {
+  apiError,
+  apiSuccess,
+  emailSchema,
+  requiredString,
+} from '@kit/next/route-helpers';
 import { getLogger } from '@kit/shared/logger';
 import { getSupabaseServerAdminClient } from '@kit/supabase/server-admin-client';
 
+const MembershipApplySchema = z.object({
+  accountId: requiredString('Konto-ID'),
+  firstName: requiredString('Vorname'),
+  lastName: requiredString('Nachname'),
+  email: emailSchema,
+  phone: z.string().optional(),
+  street: z.string().optional(),
+  postalCode: z.string().optional(),
+  city: z.string().optional(),
+  dateOfBirth: z.string().optional(),
+  message: z.string().optional(),
+});
+
 export async function POST(request: Request) {
   const logger = await getLogger();
 
   try {
     const body = await request.json();
+    const parsed = MembershipApplySchema.safeParse(body);
+
+    if (!parsed.success) {
+      return apiError(parsed.error.issues[0]?.message ?? 'Ungültige Eingabe');
+    }
+
     const {
       accountId,
       firstName,
@@ -19,23 +44,7 @@ export async function POST(request: Request) {
       city,
       dateOfBirth,
       message,
-    } = body;
-
-    if (!accountId || !firstName || !lastName || !email) {
-      return NextResponse.json(
-        {
-          error: 'Konto-ID, Vorname, Nachname und E-Mail sind erforderlich',
-        },
-        { status: 400 },
-      );
-    }
-
-    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-      return NextResponse.json(
-        { error: 'Ungültige E-Mail-Adresse' },
-        { status: 400 },
-      );
-    }
+    } = parsed.data;
 
     const supabase = getSupabaseServerAdminClient();
 
@@ -58,21 +67,15 @@ export async function POST(request: Request) {
         { error, context: 'membership-apply-insert' },
         '[membership-apply] Insert error',
       );
-      return NextResponse.json(
-        { error: 'Bewerbung fehlgeschlagen' },
-        { status: 500 },
-      );
+      return apiError('Bewerbung fehlgeschlagen', 500);
     }
 
-    return NextResponse.json({
-      success: true,
-      message: 'Bewerbung erfolgreich eingereicht',
-    });
+    return apiSuccess({ message: 'Bewerbung erfolgreich eingereicht' });
   } catch (err) {
     logger.error(
       { error: err, context: 'membership-apply' },
       '[membership-apply] Error',
     );
-    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 });
+    return apiError('Serverfehler', 500);
   }
 }

apps/web/app/api/club/newsletter/route.ts

@@ -1,30 +1,33 @@
-import { NextResponse } from 'next/server';
-
 import { createClient } from '@supabase/supabase-js';
 
+import * as z from 'zod';
+
+import {
+  apiError,
+  apiSuccess,
+  emailSchema,
+  requiredString,
+} from '@kit/next/route-helpers';
 import { getLogger } from '@kit/shared/logger';
 
+const NewsletterSchema = z.object({
+  accountId: requiredString('accountId'),
+  email: emailSchema,
+  name: z.string().optional(),
+});
+
 export async function POST(request: Request) {
   const logger = await getLogger();
 
   try {
     const body = await request.json();
-    const { accountId, email, name } = body;
+    const parsed = NewsletterSchema.safeParse(body);
 
-    if (!accountId || !email) {
-      return NextResponse.json(
-        { error: 'accountId und email sind erforderlich' },
-        { status: 400 },
-      );
+    if (!parsed.success) {
+      return apiError(parsed.error.issues[0]?.message ?? 'Ungültige Eingabe');
     }
 
-    // Validate email format
-    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
-      return NextResponse.json(
-        { error: 'Ungültige E-Mail-Adresse' },
-        { status: 400 },
-      );
-    }
+    const { accountId, email, name } = parsed.data;
 
     const supabase = createClient(
       process.env.NEXT_PUBLIC_SUPABASE_URL!,
@@ -49,18 +52,12 @@ export async function POST(request: Request) {
         { error, context: 'newsletter-subscription' },
         '[newsletter] Subscription error',
       );
-      return NextResponse.json(
-        { error: 'Anmeldung fehlgeschlagen' },
-        { status: 500 },
-      );
+      return apiError('Anmeldung fehlgeschlagen', 500);
     }
 
-    return NextResponse.json({
-      success: true,
-      message: 'Erfolgreich angemeldet',
-    });
+    return apiSuccess({ message: 'Erfolgreich angemeldet' });
   } catch (err) {
     logger.error({ error: err, context: 'newsletter' }, '[newsletter] Error');
-    return NextResponse.json({ error: 'Serverfehler' }, { status: 500 });
+    return apiError('Serverfehler', 500);
   }
 }