@lastbrain/module-auth 0.1.22 → 0.1.23

package/dist/web/public/SignUpPage.js

@@ -4,7 +4,6 @@ import { Button, Card, CardBody, Input, Link, Chip, addToast, } from "@lastbrain
 import { useRouter, useSearchParams } from "next/navigation";
 import { Suspense, useState } from "react";
 import { Mail, Lock, User, ArrowRight, Sparkles, CheckCircle2, } from "lucide-react";
-import { supabaseBrowserClient } from "@lastbrain/core";
 function SignUpForm() {
     const router = useRouter();
     const searchParams = useSearchParams();
@@ -16,7 +15,7 @@ function SignUpForm() {
     const [error, setError] = useState(null);
     const [success, setSuccess] = useState(null);
     // Récupérer le paramètre redirect
-    const redirectUrl = searchParams.get("redirect");
+    const redirectUrl = searchParams?.get("redirect") || "";
     const handleSubmit = async (event) => {
         event.preventDefault();
         setError(null);
@@ -31,35 +30,28 @@ function SignUpForm() {
         }
         setLoading(true);
         try {
-            const { data, error: signUpError } = await supabaseBrowserClient.auth.signUp({
-                email,
-                password,
-                options: {
-                    emailRedirectTo: `${window.location.origin}/api/auth/callback${redirectUrl ? `?next=${encodeURIComponent(redirectUrl)}` : ""}`,
-                    data: {
-                        full_name: fullName,
-                    },
+            // Appeler la nouvelle route API signup (signupSource sera déterminé côté serveur via VERCEL_URL)
+            const response = await fetch("/api/auth/signup", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
                 },
+                body: JSON.stringify({
+                    email,
+                    password,
+                    fullName,
+                }),
             });
-            if (signUpError) {
-                setError(signUpError.message);
+            const result = await response.json();
+            if (!response.ok) {
+                setError(result.error || "Erreur lors de l'inscription");
                 return;
             }
             // Si la confirmation par email est requise
-            if (data.user && !data.session) {
+            if (result.data.user && !result.data.session) {
                 setSuccess("Compte créé avec succès ! Veuillez vérifier votre email pour confirmer votre compte.");
                 return;
             }
-            // Si l'utilisateur est directement connecté (confirmation email désactivée)
-            if (data.session) {
-                if (redirectUrl) {
-                    window.location.href = redirectUrl;
-                }
-                else {
-                    window.location.href = "/auth/dashboard";
-                }
-                return;
-            }
             setSuccess("Compte créé. Vous pouvez désormais vous connecter.");
             setTimeout(() => {
                 if (redirectUrl) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lastbrain/module-auth",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "description": "Module d'authentification complet pour LastBrain avec Supabase",
   "private": false,
   "type": "module",
@@ -37,14 +37,14 @@
     "@lastbrain/module-ai": "^0.1.0",
     "@supabase/supabase-js": "^2.86.0",
     "lucide-react": "^0.554.0",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0"
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1"
   },
   "peerDependencies": {
     "next": ">=15.0.0"
   },
   "devDependencies": {
-    "next": "^16.0.4",
+    "next": "^16.0.7",
     "typescript": "^5.4.0"
   },
   "exports": {

package/src/api/admin/signup-stats.ts

@@ -0,0 +1,109 @@
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { NextRequest, NextResponse } from "next/server";
+
+interface SignupStats {
+  total: number;
+  bySource: {
+    lastbrain: number;
+    recipe: number;
+  };
+  byDate: Array<{
+    date: string;
+    lastbrain: number;
+    recipe: number;
+    total: number;
+  }>;
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const supabase = await getSupabaseServiceClient();
+
+    // Get total signups by source
+    const { data: signupData, error: signupError } = await supabase
+      .from("user_profil")
+      .select("signup_source", { count: "exact" })
+      .order("created_at", { ascending: false });
+
+    if (signupError) {
+      return NextResponse.json({ error: signupError.message }, { status: 400 });
+    }
+
+    // Get signups by date and source (last 30 days)
+    const thirtyDaysAgo = new Date();
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+    const { data: dateData, error: dateError } = await supabase
+      .from("user_profil")
+      .select("created_at, signup_source")
+      .gte("created_at", thirtyDaysAgo.toISOString())
+      .order("created_at", { ascending: false });
+
+    if (dateError) {
+      return NextResponse.json({ error: dateError.message }, { status: 400 });
+    }
+
+    // Process stats
+    const stats = processSignupStats(signupData, dateData);
+
+    return NextResponse.json({ data: stats }, { status: 200 });
+  } catch (error) {
+    console.error("Error fetching signup stats:", error);
+    return NextResponse.json(
+      { error: "Erreur interne du serveur" },
+      { status: 500 }
+    );
+  }
+}
+
+function processSignupStats(
+  allData: Array<{ signup_source: string | null }>,
+  dateData: Array<{ created_at: string; signup_source: string | null }>
+): SignupStats {
+  // Count by source
+  const bySource = {
+    lastbrain: 0,
+    recipe: 0,
+  };
+
+  for (const record of allData) {
+    const source = (record.signup_source || "lastbrain").toLowerCase();
+    if (source === "lastbrain") bySource.lastbrain++;
+    else if (source === "recipe") bySource.recipe++;
+  }
+
+  // Count by date
+  const byDate: Record<
+    string,
+    { lastbrain: number; recipe: number; total: number }
+  > = {};
+
+  for (const record of dateData) {
+    const date = new Date(record.created_at).toISOString().split("T")[0];
+    if (!byDate[date]) {
+      byDate[date] = { lastbrain: 0, recipe: 0, total: 0 };
+    }
+
+    const source = (record.signup_source || "lastbrain").toLowerCase();
+    if (source === "lastbrain") {
+      byDate[date].lastbrain++;
+    } else if (source === "recipe") {
+      byDate[date].recipe++;
+    }
+    byDate[date].total++;
+  }
+
+  // Sort dates
+  const sortedByDate = Object.entries(byDate)
+    .sort(([dateA], [dateB]) => dateB.localeCompare(dateA))
+    .map(([date, stats]) => ({
+      date,
+      ...stats,
+    }));
+
+  return {
+    total: allData.length,
+    bySource,
+    byDate: sortedByDate,
+  };
+}

package/src/api/admin/users-by-source.ts

@@ -0,0 +1,87 @@
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { NextRequest, NextResponse } from "next/server";
+
+interface UserSignupData {
+  id: string;
+  email: string;
+  created_at: string;
+  signup_source: string | null;
+  first_name: string | null;
+  last_name: string | null;
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const supabase = await getSupabaseServiceClient();
+
+    // Get query params for filtering
+    const url = new URL(request.url);
+    const source = url.searchParams.get("source"); // 'lastbrain' or 'recipe'
+    const page = parseInt(url.searchParams.get("page") || "1");
+    const limit = parseInt(url.searchParams.get("limit") || "50");
+
+    const offset = (page - 1) * limit;
+
+    let query = supabase.from("user_profil").select(
+      `
+        id,
+        owner_id,
+        first_name,
+        last_name,
+        signup_source,
+        created_at
+      `,
+      { count: "exact" }
+    );
+
+    // Filter by source if specified
+    if (source) {
+      query = query.eq("signup_source", source);
+    }
+
+    const { data, count, error } = await query
+      .order("created_at", { ascending: false })
+      .range(offset, offset + limit - 1);
+
+    if (error) {
+      return NextResponse.json({ error: error.message }, { status: 400 });
+    }
+
+    // Fetch email from auth.users for each profile
+    const usersWithEmails: UserSignupData[] = await Promise.all(
+      (data || []).map(async (profile: any) => {
+        const { data: authUser } = await supabase.auth.admin.getUserById(
+          profile.owner_id
+        );
+
+        return {
+          id: profile.id,
+          email: authUser?.user?.email || "Unknown",
+          created_at: profile.created_at,
+          signup_source: profile.signup_source || "lastbrain",
+          first_name: profile.first_name,
+          last_name: profile.last_name,
+        };
+      })
+    );
+
+    return NextResponse.json(
+      {
+        data: usersWithEmails,
+        pagination: {
+          page,
+          limit,
+          total: count || 0,
+          totalPages: Math.ceil((count || 0) / limit),
+        },
+      },
+      { status: 200 }
+    );
+  } catch (error) {
+    console.error("Error fetching users by signup source:", error);
+    return NextResponse.json(
+      { error: "Erreur interne du serveur" },
+      { status: 500 }
+    );
+  }
+}

package/src/api/public/signup.ts

@@ -0,0 +1,106 @@
+import {
+  getSupabaseServerClient,
+  getSupabaseServiceClient,
+} from "@lastbrain/core/server";
+import { NextRequest, NextResponse } from "next/server";
+
+interface SignUpRequest {
+  email: string;
+  password: string;
+  fullName: string;
+  signupSource?: string; // 'lastbrain' or 'recipe'
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body: SignUpRequest = await request.json();
+    const defaultSource = process.env.APP_NAME || "undefined";
+    console.log("🚀 ~ POST ~ defaultSource:", defaultSource);
+    const { email, password, fullName, signupSource = defaultSource } = body;
+
+    // Validate required fields
+    if (!email || !password) {
+      return NextResponse.json(
+        { error: "Email et mot de passe requis." },
+        { status: 400 }
+      );
+    }
+
+    // Get Supabase client for authentication
+    const supabase = await getSupabaseServerClient();
+
+    // Sign up the user
+    const { data: authData, error: signUpError } = await supabase.auth.signUp({
+      email,
+      password,
+      options: {
+        emailRedirectTo: `${request.nextUrl.origin}/api/auth/callback`,
+        data: {
+          full_name: fullName,
+          signup_source: signupSource,
+        },
+      },
+    });
+
+    if (signUpError) {
+      return NextResponse.json({ error: signUpError.message }, { status: 400 });
+    }
+
+    if (!authData.user) {
+      return NextResponse.json(
+        { error: "Erreur lors de la création du compte" },
+        { status: 500 }
+      );
+    }
+
+    // Create user profile with signup_source
+    const serviceClient = await getSupabaseServiceClient();
+
+    // Check if profile already exists
+    const { data: existingProfile } = await serviceClient
+      .from("user_profil")
+      .select("owner_id")
+      .eq("owner_id", authData.user.id)
+      .single();
+
+    // Only create profile if it doesn't exist
+    if (!existingProfile) {
+      const { error: profileError } = await serviceClient
+        .from("user_profil")
+        .insert({
+          owner_id: authData.user.id,
+          first_name: fullName?.split(" ")[0] || "",
+          last_name: fullName?.split(" ").slice(1).join(" ") || "",
+          signup_source: signupSource,
+          preferences: {},
+        });
+
+      if (profileError) {
+        console.error("Error creating user profile:", profileError);
+        return NextResponse.json(
+          {
+            error: "Compte créé mais profil non configuré",
+            message: profileError.message,
+          },
+          { status: 500 }
+        );
+      }
+    }
+
+    return NextResponse.json(
+      {
+        data: {
+          user: authData.user,
+          message: "Compte créé avec succès",
+        },
+      },
+      { status: 201 }
+    );
+  } catch (error) {
+    console.error("Signup error:", error);
+    return NextResponse.json(
+      { error: "Erreur interne du serveur" },
+      { status: 500 }
+    );
+  }
+}

package/src/auth.build.config.ts

@@ -48,6 +48,11 @@ const authBuildConfig: ModuleBuildConfig = {
       path: "/users/[id]",
       componentExport: "UserPage",
     },
+    {
+      section: "admin",
+      path: "/signup-stats",
+      componentExport: "SignupStatsPage",
+    },
   ],
   apis: [
     {
@@ -57,6 +62,13 @@ const authBuildConfig: ModuleBuildConfig = {
       entryPoint: "api/public/signin",
       authRequired: false,
     },
+    {
+      method: "POST",
+      path: "/api/auth/signup",
+      handlerExport: "POST",
+      entryPoint: "api/public/signup",
+      authRequired: false,
+    },
     {
       method: "GET",
       path: "/api/auth/profile",
@@ -106,6 +118,13 @@ const authBuildConfig: ModuleBuildConfig = {
       entryPoint: "api/admin/users/[id]/notifications",
       authRequired: true,
     },
+    {
+      method: "GET",
+      path: "/api/admin/signup-stats",
+      handlerExport: "GET",
+      entryPoint: "api/admin/signup-stats",
+      authRequired: true,
+    },
   ],
   migrations: {
     enabled: true,
@@ -162,6 +181,14 @@ const authBuildConfig: ModuleBuildConfig = {
         shortcut: "cmd+shift+u",
         shortcutDisplay: "⌘⇧U",
       },
+      {
+        title: "Statistiques d'inscriptions",
+        description: "Suivez les inscriptions par source",
+        icon: "BarChart3",
+        path: "/admin/auth/signup-stats",
+        order: 2,
+      },
+
       {
         title: "Notifications",
         description: "Vos notifications",

package/src/index.ts

@@ -9,6 +9,7 @@ export { ReglagePage } from "./web/auth/reglage.js";
 export { AdminUsersPage } from "./web/admin/users.js";
 export { default as UserPage } from "./web/admin/users/[id].js";
 export { UserDetailPage } from "./web/admin/user-detail.js";
+export { SignupStatsPage } from "./web/admin/signup-stats.js";
 
 // Header Components
 export { AccountButton } from "./components/AccountButton.js";

package/src/server.ts

@@ -1,2 +1,3 @@
 // Server-only exports (Route Handlers, Server Actions, etc.)
 export { POST as signInApi } from "./api/public/signin.js";
+export { POST as signUpApi } from "./api/public/signup.js";