Communitygithub.com

Pranith-Jain/dfir-threat-intel-platform

Créez rapidement une liste d'attente complète : capture d'email, détection des doublons, email de confirmation via Resend, stockage Supabase, vue admin des inscriptions et suivi optionnel des parrainages.

Qu'est-ce que dfir-threat-intel-platform ?

Ce skill permet de générer une liste d'attente complète pour un produit, en s'intégrant automatiquement à la stack existante (Next.js, Supabase, Prisma, Drizzle, Resend). Il détecte d'abord l'environnement du projet, puis demande à l'utilisateur ses préférences (informations collectées, suivi des parrainages, email de confirmation). Il crée ensuite une table `waitlist` dans la base de données, un point d'API d'inscription gérant la validation, la normalisation et la détection des doublons, un email de confirmation via Resend, un formulaire d'inscription React, et une vue admin protégée par un secret. Il est idéal pour lancer un produit, constituer une audience ou gérer un accès anticipé, supportant les plateformes modernes comme Next.js, Supabase, Prisma, Drizzle et Resend.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Créez rapidement une liste d'attente complète — capture d'email, stockage, email de confirmation et vue admin. Lit d'abord le projet, puis s'intègre à la stack existante.

Phase 1 : Détection du projet

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

Vérifiez :

  • Base de données : Supabase / Prisma / Drizzle / raw Postgres ?
  • Email : Resend déjà installé ?
  • Authentification : Un fournisseur d'authentification ? (nécessaire pour la vue admin)
  • Table waitlist existante ? Cherchez waitlist dans les fichiers de schéma

Phase 2 : Demander à l'utilisateur

Je vais créer une liste d'attente pour [nom du produit].

Décisions rapides :

1. Quelles informations souhaitez-vous collecter ?
   a) Email uniquement (par défaut — meilleur taux de conversion)
   b) Email + nom
   c) Email + nom + "que construisez-vous ?" (champ optionnel)

2. Suivi des parrainages ?
   a) Non — simple liste
   b) Oui — chaque inscription reçoit un lien de parrainage unique, nombre de parrainages comptabilisé

3. Email de confirmation ?
   a) Oui — envoyer un email "vous êtes sur la liste" via Resend (par défaut)
   b) Non

4. Avez-vous Resend et un domaine d'envoi vérifié ? (oui / besoin de configurer)

Phase 3 : Schéma de base de données

Adapté à la base de données détectée. Créez une table waitlist :

Supabase / SQL brut :

create table public.waitlist (
  id uuid primary key default gen_random_uuid(),
  email text not null unique,
  name text,
  note text,                              -- champ optionnel "que construisez-vous ?"
  referral_code text unique,              -- code de partage (si parrainage activé)
  referred_by text references public.waitlist(referral_code),  -- qui les a parrainés
  referral_count integer default 0,       -- combien ils ont parrainé
  position integer,                       -- position dans la file (définie par trigger)
  confirmed_at timestamptz,               -- null = non confirmé
  created_at timestamptz default now()
);

-- Incrémentation automatique de la position à l'insertion
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();

Si aucun suivi de parrainage n'est nécessaire, supprimez 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 : Point d'API d'inscription

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

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

  // Valider l'email
  if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
    return NextResponse.json({ error: 'Email valide requis' }, { status: 400 });
  }

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

  // Vérifier les doublons
  const existing = await db.query.waitlist.findFirst({
    where: eq(waitlist.email, normalizedEmail),
  });

  if (existing) {
    // Retourner un succès — ne pas divulguer les emails enregistrés aux spammeurs
    return NextResponse.json({
      success: true,
      position: existing.position,
      alreadyRegistered: true,
    });
  }

  // Générer le code de parrainage si activé
  const referralCode = generateReferralCode(normalizedEmail); // ex : 8 premiers caractères du hash de l'email

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

  // Incrémenter le compteur du parrain
  if (referredBy) {
    await db
      .update(waitlistTable)
      .set({ referralCount: sql`referral_count + 1` })
      .where(eq(waitlistTable.referralCode, referredBy));
  }

  // Envoyer l'email de confirmation (si Resend est configuré)
  if (process.env.RESEND_API_KEY) {
    await sendWaitlistConfirmation({
      email: normalizedEmail,
      name: name || 'there',
      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 : Email de confirmation

// 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: `[Nom du produit] <[email protected]>`,
    to: email,
    subject: `vous êtes #${position} sur la liste`,
    html: `
      <div style="font-family: sans-serif; max-width: 520px; margin: 0 auto; padding: 40px 20px; color: #111;">
        <p>Salut ${name},</p>
        <p>Vous êtes <strong>#${position}</strong> sur la liste d'attente. Nous vous contacterons quand ce sera votre tour.</p>
        ${
          referralUrl
            ? `
        <p style="margin-top: 24px;">
          Montez dans la liste — partagez votre lien :<br>
          <a href="${referralUrl}" style="color: #000; font-weight: bold;">${referralUrl}</a>
        </p>
        `
            : ''
        }
        <p style="color: #666; font-size: 13px; margin-top: 40px;">— [Votre nom]</p>
      </div>
    `,
  });
}

Phase 6 : Composant de formulaire d'inscription

// 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>vous êtes #{position} sur la liste.</p>
        {userReferralCode && (
          <p>
            partagez votre lien pour monter : <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' ? 'inscription...' : "rejoindre la liste d'attente"}
      </button>
      {state === 'error' && <p>une erreur s'est produite. réessayez.</p>}
    </form>
  );
}

Lisez le code de parrainage depuis les paramètres d'URL dans la page :

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

Phase 7 : Vue admin

Route simple nécessitant un en-tête secret — pas d'authentification complète nécessaire pour une liste d'attente :

// 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: 'Non autorisé' }, { status: 401 });
  }

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

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

Récupérez avec : curl -H "x-admin-secret: $ADMIN_SECRET" https://yoursite.com/api/admin/waitlist

Vérifier

[ ] L'email en double retourne un succès avec alreadyRegistered: true (pas d'erreur, pas de fuite)
[ ] L'email est normalisé en minuscules avant stockage
[ ] La position s'incrémente correctement — la première inscription est #1
[ ] L'email de confirmation arrive dans la boîte de réception, pas dans les spams
[ ] Le code de parrainage dans l'URL (?ref=) est capturé et stocké lors de l'inscription
[ ] Le compteur du parrain s'incrémente lorsque l'inscription parrainée est terminée
[ ] La route admin nécessite l'en-tête x-admin-secret
[ ] ADMIN_SECRET et RESEND_API_KEY dans .env.example
[ ] Le formulaire désactive le champ pendant la soumission
[ ] L'état de succès affiche la position et le lien de parrainage

Skills associés