Communitygithub.com

Warteliste-Grundgerüst

Erstelle eine vollständige Warteliste inklusive E-Mail-Erfassung, Duplikatserkennung, Bestätigungs-E-Mail über Resend, Supabase-Speicherung, Admin-Ansicht und optionalem Empfehlungs-Tracking. Ideal für Produktlaunches, Audience-Aufbau oder Early-Access-Gating.

Was ist Warteliste-Grundgerüst?

Dieses Skill generiert ein vollständiges Wartelisten-System für ein Next.js-Projekt (mit Supabase, Prisma oder Drizzle). Es erkennt automatisch die vorhandene Datenbank und E-Mail-Infrastruktur des Projekts, fragt dann die Konfigurationspräferenzen des Nutzers ab (gesammelte Felder, Empfehlungs-Tracking, Bestätigungs-E-Mail) und erstellt Datenbankschema, API-Route (POST /api/waitlist), Admin-API (GET /api/admin/waitlist mit Secret-Header) sowie das Frontend-Komponente (WaitlistForm). Es implementiert eine saubere Duplikatserkennung, normalisiert E-Mails auf Kleinbuchstaben, bietet einen optionalen Empfehlungslink (sha256-basiert) und sendet eine personalisierte Bestätigungs-E-Mail über Resend. Das Skill arbeitet plattformübergreifend: Es unterstützt Supabase (SQL/triggers), Prisma (Model) und Drizzle (Schema). Der Fokus liegt auf Sicherheit (kein Leaken registrierter E-Mails, Admin-Schutz durch x-admin-secret) und Benutzerfreundlichkeit (Formular deaktiviert während des Sendens, Erfolgsmeldung mit Position und Empfehlungslink).

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Pranith-Jain/dfir-threat-intel-platform/tree/HEAD/.agents/skills/waitlist

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Erstelle eine vollständige Warteliste — E-Mail-Erfassung, Speicherung, Bestätigungs-E-Mail und eine Admin-Ansicht. Liest zuerst das Projekt, integriert sich in den bestehenden Stack.

Phase 1: Projekt erkennen

cat package.json | grep -E "next|supabase|prisma|drizzle|resend"

Prüfe auf:

  • Datenbank: Supabase / Prisma / Drizzle / rohes Postgres?
  • E-Mail: Resend bereits installiert?
  • Auth: Irgendein Auth-Provider? (Admin-Ansicht benötigt ihn)
  • Bestehende Wartelisten-Tabelle? Suche nach waitlist in Schema-Dateien

Phase 2: Den Nutzer fragen

Ich erstelle eine Warteliste für [Produktname].

Kurze Entscheidungen:

1. Welche Informationen möchtest du sammeln?
   a) Nur E-Mail (Standard — höchste Konversionsrate)
   b) E-Mail + Name
   c) E-Mail + Name + „Was baust du auf?" (optionales Feld)

2. Empfehlungs-Tracking?
   a) Nein — einfache Liste
   b) Ja — jede Anmeldung erhält einen eindeutigen Empfehlungslink, Anzahl der Empfehlungen wird gezählt

3. Bestätigungs-E-Mail?
   a) Ja — sende eine „Du bist auf der Liste"-E-Mail via Resend (Standard)
   b) Nein

4. Hast du Resend und eine verifizierte Absendedomain? (ja / muss eingerichtet werden)

Phase 3: Datenbankschema

An die erkannte Datenbank anpassen. Erstelle eine waitlist-Tabelle:

Supabase / rohes SQL:

create table public.waitlist (
  id uuid primary key default gen_random_uuid(),
  email text not null unique,
  name text,
  note text,                              -- optionales "Was baust du auf?"-Feld
  referral_code text unique,              -- ihr teilbarer Code (falls Empfehlung aktiviert)
  referred_by text references public.waitlist(referral_code),  -- wer sie geschickt hat
  referral_count integer default 0,       -- wie viele sie empfohlen haben
  position integer,                       -- Position in der Warteschlange (durch Trigger gesetzt)
  confirmed_at timestamptz,               -- null = unbestätigt
  created_at timestamptz default now()
);

-- Auto-Inkrement für Position beim Einfügen
create or replace function set_waitlist_position()
returns trigger as $$
begin
  new.position = (select coalesce(max(position), 0) + 1 from public.waitlist);
  return new;
end;
$$ language plpgsql;

create trigger waitlist_position_trigger
  before insert on public.waitlist
  for each row execute function set_waitlist_position();

Falls kein Empfehlungs-Tracking benötigt wird, entferne referral_code, referred_by, referral_count.

Prisma:

model Waitlist {
  id           String    @id @default(cuid())
  email        String    @unique
  name         String?
  note         String?
  referralCode String?   @unique
  referredBy   String?
  referralCount Int      @default(0)
  position     Int
  confirmedAt  DateTime?
  createdAt    DateTime  @default(now())
}

Phase 4: Die Signup-API-Route

// app/api/waitlist/route.ts
import { NextResponse } from 'next/server';

export async function POST(req: Request) {
  const { email, name, note, referredBy } = await req.json();

  // E-Mail validieren
  if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
    return NextResponse.json({ error: 'Gültige E-Mail erforderlich' }, { status: 400 });
  }

  // Normalisieren
  const normalizedEmail = email.toLowerCase().trim();

  // Auf Duplikate prüfen
  const existing = await db.query.waitlist.findFirst({
    where: eq(waitlist.email, normalizedEmail),
  });

  if (existing) {
    // Erfolg zurückgeben — Spammern nicht verraten, welche E-Mails registriert sind
    return NextResponse.json({
      success: true,
      position: existing.position,
      alreadyRegistered: true,
    });
  }

  // Empfehlungscode generieren, falls aktiviert
  const referralCode = generateReferralCode(normalizedEmail); // z.B. erste 8 Zeichen des E-Mail-Hashs

  // Einfügen
  const entry = await db
    .insert(waitlistTable)
    .values({
      email: normalizedEmail,
      name: name?.trim() || null,
      note: note?.trim() || null,
      referralCode,
      referredBy: referredBy || null,
    })
    .returning();

  // Zähler des Empfehlers erhöhen
  if (referredBy) {
    await db
      .update(waitlistTable)
      .set({ referralCount: sql`referral_count + 1` })
      .where(eq(waitlistTable.referralCode, referredBy));
  }

  // Bestätigungs-E-Mail senden (falls Resend eingerichtet ist)
  if (process.env.RESEND_API_KEY) {
    await sendWaitlistConfirmation({
      email: normalizedEmail,
      name: name || 'dort',
      position: entry[0].position,
      referralCode,
    });
  }

  return NextResponse.json({
    success: true,
    position: entry[0].position,
    referralCode,
  });
}

function generateReferralCode(email: string): string {
  const { createHash } = require('crypto');
  return createHash('sha256').update(email).digest('hex').slice(0, 8);
}

Phase 5: Bestätigungs-E-Mail

// lib/emails/waitlist-confirmation.ts
import { Resend } from 'resend';

const resend = new Resend(process.env.RESEND_API_KEY);

export async function sendWaitlistConfirmation({
  email,
  name,
  position,
  referralCode,
}: {
  email: string;
  name: string;
  position: number;
  referralCode?: string;
}) {
  const referralUrl = referralCode ? `${process.env.NEXT_PUBLIC_APP_URL}/?ref=${referralCode}` : null;

  await resend.emails.send({
    from: `[Produktname] <[email protected]>`,
    to: email,
    subject: `du bist #${position} auf der Liste`,
    html: `
      <div style="font-family: sans-serif; max-width: 520px; margin: 0 auto; padding: 40px 20px; color: #111;">
        <p>Hallo ${name},</p>
        <p>Du bist <strong>#${position}</strong> auf der Warteliste. Wir melden uns, wenn du dran bist.</p>
        ${
          referralUrl
            ? `
        <p style="margin-top: 24px;">
          Steige in der Liste auf — teile deinen Link:<br>
          <a href="${referralUrl}" style="color: #000; font-weight: bold;">${referralUrl}</a>
        </p>
        `
            : ''
        }
        <p style="color: #666; font-size: 13px; margin-top: 40px;">— [Dein Name]</p>
      </div>
    `,
  });
}

Phase 6: Die Anmeldeformular-Komponente

// components/waitlist-form.tsx
'use client';
import { useState } from 'react';

export function WaitlistForm({ referralCode }: { referralCode?: string }) {
  const [email, setEmail] = useState('');
  const [state, setState] = useState<'idle' | 'loading' | 'success' | 'error'>('idle');
  const [position, setPosition] = useState<number | null>(null);
  const [userReferralCode, setUserReferralCode] = useState<string | null>(null);

  async function handleSubmit(e: React.FormEvent) {
    e.preventDefault();
    setState('loading');

    const res = await fetch('/api/waitlist', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ email, referredBy: referralCode }),
    });

    const data = await res.json();

    if (data.success) {
      setState('success');
      setPosition(data.position);
      setUserReferralCode(data.referralCode);
    } else {
      setState('error');
    }
  }

  if (state === 'success') {
    return (
      <div>
        <p>du bist #{position} auf der Liste.</p>
        {userReferralCode && (
          <p>
            teile deinen Link, um aufzusteigen: <code>{`${window.location.origin}/?ref=${userReferralCode}`}</code>
          </p>
        )}
      </div>
    );
  }

  return (
    <form onSubmit={handleSubmit}>
      <input
        type="email"
        value={email}
        onChange={(e) => setEmail(e.target.value)}
        placeholder="[email protected]"
        required
        disabled={state === 'loading'}
      />
      <button type="submit" disabled={state === 'loading'}>
        {state === 'loading' ? 'beitreten...' : 'Warteliste beitreten'}
      </button>
      {state === 'error' && <p>Etwas ist schiefgelaufen. Bitte versuche es erneut.</p>}
    </form>
  );
}

Lese den Empfehlungscode aus den URL-Parametern auf der Seite:

// app/page.tsx
export default function Page({ searchParams }: { searchParams: { ref?: string } }) {
  return <WaitlistForm referralCode={searchParams.ref} />;
}

Phase 7: Admin-Ansicht

Einfache Route, die einen geheimen Header benötigt — keine vollständige Authentifizierung für eine Wartelisten-Admin-Seite nötig:

// app/api/admin/waitlist/route.ts
export async function GET(req: Request) {
  if (req.headers.get('x-admin-secret') !== process.env.ADMIN_SECRET) {
    return Response.json({ error: 'Unautorisiert' }, { status: 401 });
  }

  const signups = await db.select().from(waitlistTable).orderBy(asc(waitlistTable.position));

  return Response.json({
    total: signups.length,
    signups,
  });
}

Abrufen mit: curl -H "x-admin-secret: $ADMIN_SECRET" https://deineseite.com/api/admin/waitlist

Überprüfen

[ ] Doppelte E-Mail gibt Erfolg zurück mit alreadyRegistered: true (kein Fehler, kein Leak)
[ ] E-Mail wird vor dem Speichern auf Kleinbuchstaben normalisiert
[ ] Position wird korrekt erhöht — erste Anmeldung ist #1
[ ] Bestätigungs-E-Mail kommt im Posteingang an, nicht im Spam
[ ] Empfehlungscode in der URL (?ref=) wird bei der Anmeldung erfasst und gespeichert
[ ] Zähler des Empfehlers wird erhöht, wenn die empfohlene Anmeldung abgeschlossen ist
[ ] Admin-Route benötigt den x-admin-secret-Header
[ ] ADMIN_SECRET und RESEND_API_KEY in .env.example
[ ] Formular deaktiviert die Eingabe während des Sendens
[ ] Erfolgszustand zeigt Position und Empfehlungslink an

Verwandte Skills