@lastbrain/module-auth 2.0.27 → 2.0.31

package/src/api/auth/me.ts

@@ -1,11 +1,12 @@
-import { NextResponse } from "next/server";
+import { NextResponse, type NextRequest } from "next/server";
 import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
 
 /**
  * GET /api/auth/me
  * Returns the current authenticated user and their profile
  */
-export async function GET() {
+export async function GET(request: NextRequest) {
   try {
     const supabase = await getSupabaseServerClient();
 
@@ -19,20 +20,41 @@ export async function GET() {
     const { data: profile } = await supabase
       .from("user_profil")
       .select("*")
-      .eq("owner_id", user!.id)
+      .eq("owner_id", user?.id)
       .single();
 
     // Profile might not exist yet, that's OK
     const userData = {
-      id: user!.id,
-      email: user!.email,
-      created_at: user!.created_at,
+      id: user?.id,
+      email: user?.email,
+      created_at: user?.created_at,
       profile: profile || null,
     };
 
+    // Si le client a envoyé un cookie NEXT_LOCALE, synchroniser sa valeur
+    // avec la langue du profil (si présente). Ne rien créer si le cookie
+    // est absent. Si la langue diffère, renvoyer une réponse JSON indiquant
+    // le changement de langue et définir le cookie côté serveur. Le client
+    // effectuera ensuite la redirection côté client pour éviter que fetch
+    // suive automatiquement un redirect 302.
+    try {
+      // Return localeUpdated to let the client/realtime decide what to do.
+      const cookieLang = request.cookies.get("NEXT_LOCALE")?.value;
+      const profileLang = profile?.language;
+      if (cookieLang && profileLang && profileLang !== cookieLang) {
+        return NextResponse.json({
+          data: userData,
+          localeUpdated: true,
+          profileLang,
+        });
+      }
+    } catch (e) {
+      logger.debug("me: locale sync error", e);
+    }
+
     return NextResponse.json({ data: userData });
   } catch (error) {
-    console.error("Error fetching user:", error);
+    logger.error("Error fetching user:", error);
     return NextResponse.json(
       { error: "Internal Server Error", message: "Failed to fetch user data" },
       { status: 500 }

package/src/api/auth/profile.ts

@@ -1,5 +1,6 @@
 import { NextRequest, NextResponse } from "next/server";
 import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
 
 /**
  * GET /api/auth/profile
@@ -30,7 +31,7 @@ export async function GET() {
 
     return NextResponse.json({ data: profile || null });
   } catch (error) {
-    console.error("Error fetching profile:", error);
+    logger.error("Error fetching profile:", error);
     return NextResponse.json(
       { error: "Internal Server Error", message: "Failed to fetch profile" },
       { status: 500 }
@@ -63,6 +64,7 @@ export async function PUT(request: NextRequest) {
       location,
       language,
       timezone,
+      username,
       preferences,
     } = body;
 
@@ -90,6 +92,7 @@ export async function PUT(request: NextRequest) {
           language,
           timezone,
           preferences,
+          username,
         })
         .eq("owner_id", user!.id)
         .select()
@@ -123,9 +126,10 @@ export async function PUT(request: NextRequest) {
       );
     }
 
+    // Indiquer au client si la langue a été modifiée (sans toucher aux cookies)
     return NextResponse.json({ data: result.data });
   } catch (error) {
-    console.error("Error updating profile:", error);
+    logger.error("Error updating profile:", error);
     return NextResponse.json(
       { error: "Internal Server Error", message: "Failed to update profile" },
       { status: 500 }

package/src/api/auth/storage/recalculate.ts

@@ -0,0 +1,108 @@
+/**
+ * POST /api/auth/storage/recalculate
+ * Force recalculation of user storage quota from addons
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(request: NextRequest) {
+  try {
+    const supabase = await getSupabaseServerClient();
+
+    // Get authenticated user
+    const {
+      data: { user },
+      error: authError,
+    } = await supabase.auth.getUser();
+
+    if (authError || !user) {
+      return NextResponse.json({ error: "Non authentifié" }, { status: 401 });
+    }
+
+    logger.debug(`[Storage Recalculate] Recalculating for user ${user.id}`);
+
+    // Call get_user_limits RPC
+    const { data: limitsData, error: limitsError } = await supabase.rpc(
+      "get_user_limits",
+      {
+        owner_id_param: user.id,
+      }
+    );
+
+    if (limitsError) {
+      logger.error(
+        "[Storage Recalculate] Error calling get_user_limits:",
+        limitsError
+      );
+      return NextResponse.json(
+        { error: "Erreur lors du calcul des limites" },
+        { status: 500 }
+      );
+    }
+
+    logger.debug(`[Storage Recalculate] get_user_limits result:`, limitsData);
+
+    // Parse result (could be string or object)
+    let parsedLimits = limitsData;
+    if (typeof limitsData === "string") {
+      try {
+        parsedLimits = JSON.parse(limitsData);
+      } catch (e) {
+        logger.error("[Storage Recalculate] Failed to parse limits data:", e);
+      }
+    }
+
+    const totalStorageGb = parsedLimits?.storage_quota_gb;
+
+    if (totalStorageGb !== null && totalStorageGb !== undefined) {
+      // Update user_profil
+      const { error: updateError } = await supabase.from("user_profil").upsert(
+        {
+          owner_id: user.id,
+          stockage: totalStorageGb,
+          updated_at: new Date().toISOString(),
+        },
+        {
+          onConflict: "owner_id",
+        }
+      );
+
+      if (updateError) {
+        logger.error(
+          "[Storage Recalculate] Error updating user_profil:",
+          updateError
+        );
+        return NextResponse.json(
+          { error: "Erreur lors de la mise à jour" },
+          { status: 500 }
+        );
+      }
+
+      logger.info(
+        `[Storage Recalculate] Updated user_profil.stockage to ${totalStorageGb} GB for user ${user.id}`
+      );
+
+      return NextResponse.json({
+        success: true,
+        storage_quota_gb: totalStorageGb,
+        breakdown: parsedLimits?.storage_breakdown,
+      });
+    } else {
+      logger.error(
+        "[Storage Recalculate] get_user_limits returned null for storage_quota_gb"
+      );
+      return NextResponse.json({ error: "Calcul invalide" }, { status: 500 });
+    }
+  } catch (error) {
+    logger.error("[Storage Recalculate] Error:", error);
+    return NextResponse.json(
+      { error: "Erreur lors du recalcul" },
+      { status: 500 }
+    );
+  }
+}

package/src/api/auth/storage/usage.ts

@@ -0,0 +1,113 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { getStorageUsage, StorageUsageData } from "@lastbrain/core";
+
+// Cache pour éviter les calculs répétés
+interface CacheEntry {
+  data: StorageUsageData;
+  timestamp: number;
+}
+
+const storageCache = new Map<string, CacheEntry>();
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes en millisecondes
+
+// Nettoyer le cache périodiquement
+function cleanExpiredCache() {
+  const now = Date.now();
+  for (const [key, entry] of storageCache.entries()) {
+    if (now - entry.timestamp > CACHE_TTL) {
+      storageCache.delete(key);
+    }
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const supabase = await getSupabaseServerClient();
+
+    // Vérifier l'authentification
+    const {
+      data: { user },
+      error: authError,
+    } = await supabase.auth.getUser();
+    if (authError || !user) {
+      return NextResponse.json(
+        { success: false, error: "Non authentifié" },
+        { status: 401 }
+      );
+    }
+
+    // Route auth: uniquement les données de l'utilisateur connecté
+    const ownerId = user.id;
+    const { searchParams } = new URL(request.url);
+    const forceRefresh = searchParams.get("forceRefresh") === "true";
+
+    // Nettoyer le cache avant utilisation
+    cleanExpiredCache();
+
+    // Vérifier si on a des données en cache (sauf si forceRefresh)
+    const cacheKey = `storage-${ownerId}`;
+    let shouldUseCache = false;
+
+    if (!forceRefresh) {
+      const cachedEntry = storageCache.get(cacheKey);
+      const now = Date.now();
+
+      if (cachedEntry && now - cachedEntry.timestamp < CACHE_TTL) {
+        // Vérifier d'abord si l'allocation de stockage a changé
+        // Récupérer juste l'allocation depuis la base (requête légère)
+        const { data: userProfile } = await supabase
+          .from("user_profil")
+          .select("stockage")
+          .eq("owner_id", ownerId)
+          .single();
+
+        const currentAllocatedGb = userProfile?.stockage || 2.0;
+        const cachedAllocatedGb = cachedEntry.data.allocatedGb;
+
+        // Si l'allocation n'a pas changé, utiliser le cache
+        if (currentAllocatedGb === cachedAllocatedGb) {
+          shouldUseCache = true;
+        } else {
+          // L'allocation a changé, invalider le cache
+          storageCache.delete(cacheKey);
+        }
+      }
+
+      if (shouldUseCache && cachedEntry) {
+        // Retourner les données depuis le cache
+        return NextResponse.json({
+          success: true,
+          data: cachedEntry.data,
+          cached: true,
+        });
+      }
+    } else {
+      // Forcer la suppression du cache pour cet utilisateur
+      storageCache.delete(cacheKey);
+    }
+
+    // Récupérer les données d'usage de stockage
+    const storageData = await getStorageUsage(supabase, ownerId);
+
+    // Mettre en cache
+    storageCache.set(cacheKey, {
+      data: storageData,
+      timestamp: Date.now(),
+    });
+
+    return NextResponse.json({
+      success: true,
+      data: storageData,
+    });
+  } catch (error) {
+    console.error("Erreur API storage usage:", error);
+    return NextResponse.json(
+      {
+        success: false,
+        error: error instanceof Error ? error.message : "Erreur serveur",
+      },
+      { status: 500 }
+    );
+  }
+}

package/src/api/public/add-welcome-bonus.ts

@@ -0,0 +1,229 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  getSupabaseServerClient,
+  getSupabaseServiceClient,
+} from "@lastbrain/core/server";
+import { sendWelcomeOnboardingEmail } from "../../lib/auth-email-service";
+import { logger } from "@lastbrain/core";
+
+/**
+ * POST /api/public/add-welcome-bonus
+ * Adds welcome bonus tokens and notifications after email confirmation
+ * Called from the confirm page after successful session establishment
+ */
+export async function POST(request: NextRequest) {
+  try {
+    // Get authenticated user from cookies
+    const supabase = await getSupabaseServerClient();
+    const {
+      data: { user },
+      error: authError,
+    } = await supabase.auth.getUser();
+
+    if (authError || !user?.id) {
+      return NextResponse.json({ error: "Not authenticated" }, { status: 401 });
+    }
+
+    // Use service client to bypass RLS for system operations
+    const serviceClient = await getSupabaseServiceClient();
+
+    logger.debug(
+      `[add-welcome-bonus] Starting for user ${user.id} (${user.email})`
+    );
+
+    // Check if signup bonus is enabled
+    const ENABLE_SIGNUP_BONUS =
+      process.env.NEXT_PUBLIC_ENABLE_SIGNUP_BONUS === "true";
+    const SIGNUP_BONUS_AMOUNT_USD = parseFloat(
+      process.env.NEXT_PUBLIC_SIGNUP_BONUS_AMOUNT_USD || "1.0"
+    );
+
+    if (!ENABLE_SIGNUP_BONUS) {
+      logger.debug(
+        `[add-welcome-bonus] Signup bonus disabled for user ${user.id}`
+      );
+      return NextResponse.json({
+        message: "Signup bonus disabled",
+        alreadyExists: false,
+      });
+    }
+
+    // Check if we already added bonus for this user
+    const { data: existingBonus } = await serviceClient
+      .from("user_token_ledger")
+      .select("id")
+      .eq("owner_id", user.id)
+      .eq("type", "signup_bonus")
+      .single();
+
+    // If bonus already exists, skip
+    if (existingBonus) {
+      logger.debug(`⏭️  Bonus already exists for user ${user.id}, skipping...`);
+      return NextResponse.json({
+        message: "Bonus already added",
+        alreadyExists: true,
+      });
+    }
+
+    // Add welcome bonus using wallet system
+    const MARGIN_TARGET = 0.6;
+    const providerBudgetUsd = SIGNUP_BONUS_AMOUNT_USD * (1 - MARGIN_TARGET); // 40%
+
+    // Insert into ledger with USD values
+    const { error: ledgerError } = await serviceClient
+      .from("user_token_ledger")
+      .insert({
+        owner_id: user.id,
+        type: "signup_bonus",
+        amount: 0, // Tokens deprecated
+        sell_value_added_usd: SIGNUP_BONUS_AMOUNT_USD,
+        provider_budget_added_usd: providerBudgetUsd,
+        meta: {
+          reason: "signup_welcome_bonus",
+          provider: "system",
+        },
+        created_by: null,
+      });
+
+    if (ledgerError) {
+      logger.error("Error adding welcome bonus to ledger:", ledgerError);
+      return NextResponse.json(
+        { error: "Failed to add bonus" },
+        { status: 500 }
+      );
+    }
+
+    // Update wallet table
+    const { data: currentWallet } = await serviceClient
+      .from("user_token_wallet")
+      .select("wallet_provider_budget_usd, wallet_sell_value_usd")
+      .eq("user_id", user.id)
+      .single();
+
+    const newProviderBudget =
+      (currentWallet?.wallet_provider_budget_usd || 0) + providerBudgetUsd;
+    const newSellValue =
+      (currentWallet?.wallet_sell_value_usd || 0) + SIGNUP_BONUS_AMOUNT_USD;
+
+    const { error: walletError } = await serviceClient
+      .from("user_token_wallet")
+      .upsert(
+        {
+          user_id: user.id,
+          wallet_provider_budget_usd: newProviderBudget,
+          wallet_sell_value_usd: newSellValue,
+          updated_at: new Date().toISOString(),
+        },
+        {
+          onConflict: "user_id",
+        }
+      );
+
+    if (walletError) {
+      logger.error("Error updating wallet for welcome bonus:", walletError);
+      return NextResponse.json(
+        { error: "Failed to update wallet" },
+        { status: 500 }
+      );
+    }
+
+    logger.debug(
+      `✅ Added $${SIGNUP_BONUS_AMOUNT_USD} welcome bonus to user ${user.id}`
+    );
+
+    // Determine locale: prefer cookie set by the client (NEXT_LOCALE),
+    // then user metadata, then Accept-Language header, fallback to 'en'.
+    let locale = "en";
+    try {
+      const cookieLocale = request.cookies.get("NEXT_LOCALE")?.value;
+      if (cookieLocale) {
+        locale = cookieLocale;
+      } else if (user.user_metadata?.locale) {
+        locale = user.user_metadata.locale as string;
+      } else {
+        const accept = request.headers.get("accept-language");
+        if (accept) {
+          // take first language tag, e.g. 'fr-FR,fr;q=0.9' -> 'fr'
+          const first = accept.split(",")[0].split("-")[0];
+          if (first) locale = first;
+        }
+      }
+    } catch (e) {
+      // if anything goes wrong, keep default 'en'
+      logger.warn(
+        "Could not determine locale from request, using default 'en'",
+        e
+      );
+    }
+
+    // Add welcome notifications only if bonus enabled
+    if (ENABLE_SIGNUP_BONUS && SIGNUP_BONUS_AMOUNT_USD > 0) {
+      const notifications = [
+        {
+          title: locale === "fr" ? "Bienvenue ! 👋" : "Welcome! 👋",
+          body:
+            locale === "fr"
+              ? "Merci de vous être inscrit ! Explorez toutes les fonctionnalités disponibles."
+              : "Thank you for signing up! Explore all available features.",
+          type: "primary",
+        },
+        {
+          title:
+            locale === "fr"
+              ? `🎁 Cadeau de bienvenue : $${SIGNUP_BONUS_AMOUNT_USD}`
+              : `🎁 Welcome gift: $${SIGNUP_BONUS_AMOUNT_USD}`,
+          body:
+            locale === "fr"
+              ? `Nous vous offrons $${SIGNUP_BONUS_AMOUNT_USD} de crédit IA pour démarrer. Utilisez-les pour accéder à nos services premium.`
+              : `We're giving you $${SIGNUP_BONUS_AMOUNT_USD} AI credits to get started. Use them to access our premium services.`,
+          type: "success",
+        },
+      ];
+
+      for (const notification of notifications) {
+        const { error: notifError } = await serviceClient
+          .from("user_notifications")
+          .insert({
+            owner_id: user.id,
+            title: notification.title,
+            body: notification.body,
+            type: notification.type,
+          });
+
+        if (notifError) {
+          logger.error("Error creating notification:", notifError);
+        }
+      }
+
+      logger.debug(`✅ Created welcome notifications for user ${user.id}`);
+    }
+
+    // Send welcome onboarding email with bonus amount if enabled
+    try {
+      await sendWelcomeOnboardingEmail({
+        email: user.email || "",
+        displayName: (user.user_metadata?.full_name as string) || "user",
+        locale,
+        ownerId: user.id,
+        bonusAmountUsd: ENABLE_SIGNUP_BONUS
+          ? SIGNUP_BONUS_AMOUNT_USD
+          : undefined,
+      });
+      logger.debug(`📧 Sent welcome onboarding email to ${user.email}`);
+    } catch (emailError) {
+      logger.warn("Failed to send welcome email (non-blocking):", emailError);
+      // Don't fail the response if email fails
+    }
+
+    return NextResponse.json({
+      success: true,
+      message: "Welcome bonus added successfully",
+    });
+  } catch (error) {
+    logger.error("Error in add-welcome-bonus:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}