@lastbrain/module-auth 2.0.19 → 2.0.31

package/src/lib/app-branding-data.ts

@@ -0,0 +1,90 @@
+import * as fs from "fs";
+import * as path from "path";
+
+/**
+ * Branding configuration for emails
+ * Loaded dynamically from app i18n files (app.name, app.icon, etc.)
+ */
+
+export interface AppBrandingData {
+  appName: string;
+  logo?: string;
+  description?: string;
+  tagline?: string;
+  icon?: string;
+  twitterCreator?: string;
+  twitterSite?: string;
+  supportEmail?: string;
+  primaryColor?: string;
+  secondaryColor?: string;
+}
+
+/**
+ * Charge les traductions de l'app depuis les fichiers i18n agrégés
+ */
+function loadAppTranslations(lang: string): Record<string, string> {
+  try {
+    const possiblePaths = [
+      // Production (Vercel)
+      path.join("/app", "i18n", `${lang}.json`),
+      // Development - apps/lastbrain
+      path.join(process.cwd(), "i18n", `${lang}.json`),
+      // Development - depuis packages vers apps/lastbrain
+      path.join(
+        process.cwd(),
+        "..",
+        "..",
+        "apps",
+        "lastbrain",
+        "i18n",
+        `${lang}.json`
+      ),
+      // Development - apps/recipe
+      path.join(
+        process.cwd(),
+        "..",
+        "..",
+        "apps",
+        "recipe",
+        "i18n",
+        `${lang}.json`
+      ),
+    ];
+
+    for (const filePath of possiblePaths) {
+      if (fs.existsSync(filePath)) {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+      }
+    }
+  } catch (error) {
+    console.warn(
+      `[getAppBranding] Could not load translations for ${lang}:`,
+      error
+    );
+  }
+
+  return {};
+}
+
+/**
+ * Récupère le branding depuis les clés i18n de l'app
+ * Utilise les clés : app.name, app.icon, app.description, app.tagline, etc.
+ */
+export function getAppBranding(locale: string = "en"): AppBrandingData {
+  const loc = locale === "fr" ? "fr" : "en";
+  const translations = loadAppTranslations(loc);
+
+  return {
+    appName: translations["app.name"] || "LastBrain",
+    icon: translations["app.icon"] || "Brain",
+    logo: translations["app.icon"] || "Brain",
+    description: translations["app.description"] || "",
+    tagline: translations["app.tagline"] || "",
+    twitterCreator: translations["app.twitter_creator"] || "",
+    twitterSite: translations["app.twitter_site"] || "",
+    supportEmail: translations["app.email.contact"] || "support@lastbrain.io",
+    primaryColor: translations["app.email.color.primary"] || "#3b82f6",
+    secondaryColor: translations["app.email.color.secondary"] || "#8b5cf6",
+  };
+}

package/src/lib/auth-email-service.ts

@@ -0,0 +1,508 @@
+import {
+  getSupabaseServiceClient,
+  getSupabaseServerClient,
+} from "@lastbrain/core/server";
+import {
+  sendEmail,
+  type AuthEmailKind,
+  getAuthEmailSubject,
+  renderAuthEmailHtml,
+} from "@lastbrain-labs/module-contact-pro";
+import { getAppBranding } from "./app-branding-data";
+import { logger } from "@lastbrain/core";
+import { cookies } from "next/headers";
+
+const FALLBACK_SITE_URL =
+  process.env.NEXT_PUBLIC_SITE_URL ||
+  process.env.SITE_URL ||
+  "http://localhost:3000";
+const NORMALIZED_SITE_URL = FALLBACK_SITE_URL.replace(/\/$/, "");
+const DEFAULT_LOCALE = "fr";
+
+/**
+ * Récupère la langue depuis le cookie NEXT_LOCALE
+ */
+async function getLocaleFromCookie(): Promise<string | undefined> {
+  try {
+    const cookieStore = await cookies();
+    const localeCookie = cookieStore.get("NEXT_LOCALE");
+    if (localeCookie?.value && /^[a-z]{2}$/.test(localeCookie.value)) {
+      return localeCookie.value;
+    }
+  } catch (error) {
+    logger.debug("[getLocaleFromCookie] Could not read cookie:", error);
+  }
+  return undefined;
+}
+
+interface BaseEmailParams {
+  email: string;
+  displayName?: string;
+  ownerId?: string;
+  redirectTo?: string;
+}
+
+async function generateLink(
+  type:
+    | "signup"
+    | "invite"
+    | "magiclink"
+    | "recovery"
+    | "email_change"
+    | "reauthentication",
+  params: any
+) {
+  const supabase = await getSupabaseServiceClient();
+  return supabase.auth.admin.generateLink({ type, ...params });
+}
+
+async function sendAuthEmail(
+  kind: AuthEmailKind,
+  to: string,
+  actionLink: string,
+  options: { displayName?: string; ownerId?: string; locale?: string }
+) {
+  const branding = getAppBranding(options.locale);
+  logger.debug("📧 sendAuthEmail - branding:", {
+    locale: options.locale,
+    appName: branding.appName,
+    icon: branding.icon,
+  });
+
+  const html = renderAuthEmailHtml(kind, {
+    kind,
+    actionLink,
+    displayName: options.displayName,
+    locale: options.locale,
+    appName: branding.appName,
+    appIcon: branding.icon,
+    appTagline: branding.tagline,
+    supportEmail: branding.supportEmail,
+    primaryColor: branding.primaryColor,
+    secondaryColor: branding.secondaryColor,
+  });
+
+  try {
+    const result = await sendEmail({
+      to,
+      subject: getAuthEmailSubject(kind, options.locale),
+      html,
+      emailType: "transactional",
+      ownerId: options.ownerId,
+    });
+    logger.debug("📧 sendEmail result", { ok: true, result });
+    return result;
+  } catch (err) {
+    logger.error("📧 sendEmail error", err);
+    throw err;
+  }
+}
+
+export async function sendSignupConfirmationEmail(params: {
+  email: string;
+  password: string;
+  fullName?: string;
+  signupSource?: string;
+  redirectTo?: string;
+  next?: string;
+  locale?: string;
+}) {
+  // Récupérer la langue depuis le cookie si non fournie
+  const locale =
+    params.locale || (await getLocaleFromCookie()) || DEFAULT_LOCALE;
+
+  // Use magic link for signup so client receives tokens in URL fragment
+  // Inclure la locale dans l'URL si pas déjà présente
+  let redirectTo =
+    params.redirectTo || `${NORMALIZED_SITE_URL}/${locale}/confirm`;
+
+  // Si un redirectTo personnalisé est fourni sans locale, l'ajouter
+  if (params.redirectTo && !params.redirectTo.match(/\/(fr|en|es|de)\//)) {
+    const url = new URL(params.redirectTo, NORMALIZED_SITE_URL);
+    url.pathname = `/${locale}${url.pathname}`;
+    redirectTo = url.toString();
+  }
+
+  if (params.next) {
+    const sep = redirectTo.includes("?") ? "&" : "?";
+    redirectTo = `${redirectTo}${sep}next=${encodeURIComponent(params.next)}`;
+  }
+
+  const { data, error } = await generateLink("magiclink", {
+    email: params.email,
+    options: {
+      redirectTo,
+      data: {
+        full_name: params.fullName,
+        signup_source: params.signupSource,
+      },
+    },
+  });
+
+  if (error) throw error;
+
+  const actionLink =
+    (data as any)?.properties?.action_link || (data as any)?.action_link;
+
+  await sendAuthEmail("magic_link", params.email, actionLink, {
+    displayName: params.fullName,
+    ownerId: data.user?.id,
+    locale,
+  });
+
+  return data.user;
+}
+
+export async function sendPasswordResetEmail(
+  params: BaseEmailParams & { locale?: string; next?: string }
+) {
+  // Récupérer la langue depuis le cookie si non fournie
+  const cookieLocale = await getLocaleFromCookie();
+
+  logger.debug("[sendPasswordResetEmail] locale detection", {
+    providedLocale: params.locale,
+    cookieLocale,
+  });
+
+  // Attempt to infer locale from redirectTo path or use provided locale
+  const inferredLocale = (() => {
+    // Priority: 1. provided locale, 2. cookie, 3. redirectTo path
+    if (params.locale && (params.locale === "fr" || params.locale === "en")) {
+      return params.locale;
+    }
+    if (cookieLocale) {
+      return cookieLocale;
+    }
+    // Otherwise, try to infer from redirectTo URL path
+    const url = params.redirectTo || `${FALLBACK_SITE_URL}/api/auth/callback`;
+    try {
+      const u = new URL(url);
+      const seg = u.pathname.split("/").filter(Boolean)[0];
+      return seg === "fr" || seg === "en" ? seg : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+
+  // Default to the reset-password page so the client can handle tokens directly.
+  const targetLocale = inferredLocale || DEFAULT_LOCALE;
+
+  logger.debug("[sendPasswordResetEmail] final locale", {
+    inferredLocale,
+    targetLocale,
+  });
+
+  // Construire le redirectTo avec la locale
+  let redirectTo =
+    params.redirectTo ||
+    `${NORMALIZED_SITE_URL}/${targetLocale}/reset-password`;
+
+  // Si un redirectTo personnalisé est fourni sans locale, l'ajouter
+  if (params.redirectTo && !params.redirectTo.match(/\/(fr|en|es|de)\//)) {
+    const url = new URL(params.redirectTo, NORMALIZED_SITE_URL);
+    url.pathname = `/${targetLocale}${url.pathname}`;
+    redirectTo = url.toString();
+  }
+
+  if ((params as any).next) {
+    const next = (params as any).next as string;
+    const sep = redirectTo.includes("?") ? "&" : "?";
+    redirectTo = `${redirectTo}${sep}next=${encodeURIComponent(next)}`;
+  }
+
+  logger.debug(
+    "[sendPasswordResetEmail] calling generateLink with redirectTo",
+    {
+      redirectTo,
+      email: params.email,
+    }
+  );
+
+  const { data, error } = await generateLink("recovery", {
+    email: params.email,
+    options: { redirectTo },
+  });
+
+  logger.debug("[sendPasswordResetEmail] generateLink returned", {
+    action_link:
+      (data as any)?.properties?.action_link || (data as any)?.action_link,
+    supabaseData: data,
+    error,
+  });
+
+  if (error) throw error;
+
+  const actionLink =
+    (data as any)?.properties?.action_link || (data as any)?.action_link;
+
+  await sendAuthEmail("magic_link", params.email, actionLink, {
+    displayName: params.displayName,
+    ownerId: params.ownerId,
+    locale: targetLocale,
+  });
+
+  return data.user;
+}
+
+export async function sendMagicLinkEmail(
+  params: BaseEmailParams & { locale?: string }
+) {
+  // Récupérer la langue depuis le cookie si non fournie
+  const cookieLocale = await getLocaleFromCookie();
+
+  const inferredLocale = (() => {
+    if (params.locale && (params.locale === "fr" || params.locale === "en")) {
+      return params.locale;
+    }
+    if (cookieLocale) {
+      return cookieLocale;
+    }
+    const url = params.redirectTo || `${FALLBACK_SITE_URL}/api/auth/callback`;
+    try {
+      const u = new URL(url);
+      const seg = u.pathname.split("/").filter(Boolean)[0];
+      return seg === "fr" || seg === "en" ? seg : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+
+  const redirectTo =
+    params.redirectTo || `${NORMALIZED_SITE_URL}/api/public/callback`;
+  const { data, error } = await generateLink("magiclink", {
+    email: params.email,
+    options: { redirectTo },
+  });
+  if (error) throw error;
+  const actionLink =
+    (data as any)?.properties?.action_link || (data as any)?.action_link;
+  await sendAuthEmail("magic_link", params.email, actionLink, {
+    displayName: params.displayName,
+    ownerId: params.ownerId,
+    locale: inferredLocale,
+  });
+  return data.user;
+}
+
+export async function sendInviteEmail(
+  params: BaseEmailParams & { password?: string; locale?: string }
+) {
+  const inferredLocale = (() => {
+    if (params.locale && (params.locale === "fr" || params.locale === "en")) {
+      return params.locale;
+    }
+    const url = params.redirectTo || `${FALLBACK_SITE_URL}/api/auth/callback`;
+    try {
+      const u = new URL(url);
+      const seg = u.pathname.split("/").filter(Boolean)[0];
+      return seg === "fr" || seg === "en" ? seg : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+
+  const redirectTo =
+    params.redirectTo || `${NORMALIZED_SITE_URL}/api/public/callback`;
+  const { data, error } = await generateLink("invite", {
+    email: params.email,
+    password: params.password,
+    options: { redirectTo },
+  });
+  if (error) throw error;
+  const actionLink =
+    (data as any)?.properties?.action_link || (data as any)?.action_link;
+  await sendAuthEmail("invite", params.email, actionLink, {
+    displayName: params.displayName,
+    ownerId: params.ownerId ?? data.user?.id,
+    locale: inferredLocale,
+  });
+  return data.user;
+}
+
+export async function sendEmailChangeConfirmation(params: {
+  email: string; // current email
+  newEmail: string;
+  displayName?: string;
+  ownerId?: string;
+  redirectTo?: string;
+  locale?: string;
+}) {
+  const redirectTo =
+    params.redirectTo || `${NORMALIZED_SITE_URL}/api/auth/callback`;
+  const { data, error } = await generateLink("email_change", {
+    email: params.email,
+    newEmail: params.newEmail,
+    options: { redirectTo },
+  });
+  if (error) throw error;
+  const actionLink =
+    (data as any)?.properties?.action_link || (data as any)?.action_link;
+  await sendAuthEmail("confirm_email_change", params.newEmail, actionLink, {
+    displayName: params.displayName,
+    ownerId: params.ownerId,
+    locale: params.locale,
+  });
+  return data.user;
+}
+
+export async function sendReauthenticationEmail(
+  params: BaseEmailParams & { locale?: string }
+) {
+  const inferredLocale = (() => {
+    if (params.locale && (params.locale === "fr" || params.locale === "en")) {
+      return params.locale;
+    }
+    const url = params.redirectTo || `${FALLBACK_SITE_URL}/api/auth/callback`;
+    try {
+      const u = new URL(url);
+      const seg = u.pathname.split("/").filter(Boolean)[0];
+      return seg === "fr" || seg === "en" ? seg : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+
+  const redirectTo =
+    params.redirectTo || `${NORMALIZED_SITE_URL}/api/auth/callback`;
+  const { data, error } = await generateLink("reauthentication", {
+    email: params.email,
+    options: { redirectTo },
+  });
+  if (error) throw error;
+  const actionLink =
+    (data as any)?.properties?.action_link || (data as any)?.action_link;
+  await sendAuthEmail("reauthentication", params.email, actionLink, {
+    displayName: params.displayName,
+    ownerId: params.ownerId,
+    locale: inferredLocale,
+  });
+  return data.user;
+}
+
+export async function fetchCurrentUserOwnerId(): Promise<string | null> {
+  const supabase = await getSupabaseServerClient();
+  const {
+    data: { user },
+  } = await supabase.auth.getUser();
+  return user?.id || null;
+}
+
+export async function sendWelcomeOnboardingEmail(params: {
+  email: string;
+  displayName?: string;
+  locale?: string;
+  ownerId?: string;
+  bonusAmountUsd?: number;
+}) {
+  const branding = getAppBranding(params.locale);
+
+  // Render the welcome onboarding email using the template from module-contact-pro
+  const html = renderAuthEmailHtml("welcome_onboarding", {
+    kind: "welcome_onboarding",
+    actionLink: `${FALLBACK_SITE_URL}/`,
+    displayName: params.displayName,
+    locale: params.locale,
+    appName: branding.appName,
+    appIcon: branding.icon,
+    appTagline: branding.tagline,
+    supportEmail: branding.supportEmail,
+    bonusAmountUsd: params.bonusAmountUsd,
+  });
+
+  await sendEmail({
+    to: params.email,
+    subject: getAuthEmailSubject(
+      "welcome_onboarding",
+      params.locale,
+      params.bonusAmountUsd
+    ),
+    html,
+    emailType: "transactional",
+    ownerId: params.ownerId,
+  });
+
+  return;
+}
+
+/**
+ * Send notification to admin when new user signs up
+ */
+export async function sendNewUserNotificationToAdmin(params: {
+  userEmail: string;
+  displayName?: string;
+  userId: string;
+  locale?: string;
+  bonusAmountUsd?: number;
+}) {
+  const ADMIN_EMAIL = "contact@lastbrain.io";
+  const branding = getAppBranding("fr");
+
+  const html = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; line-height: 1.6; color: #333; }
+    .container { max-width: 600px; margin: 0 auto; padding: 20px; }
+    .header { background: #4F46E5; color: white; padding: 20px; border-radius: 8px 8px 0 0; }
+    .content { background: #f9fafb; padding: 30px; border-radius: 0 0 8px 8px; }
+    .info-row { margin: 10px 0; padding: 10px; background: white; border-radius: 4px; }
+    .label { font-weight: 600; color: #6B7280; }
+    .value { color: #111827; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="header">
+      <h2>🎉 Nouvelle inscription - ${branding.appName}</h2>
+    </div>
+    <div class="content">
+      <p>Un nouvel utilisateur vient de s'inscrire sur la plateforme :</p>
+      
+      <div class="info-row">
+        <span class="label">Email :</span>
+        <span class="value">${params.userEmail}</span>
+      </div>
+      
+      ${params.displayName ? `<div class="info-row"><span class="label">Nom :</span><span class="value">${params.displayName}</span></div>` : ""}
+      
+      <div class="info-row">
+        <span class="label">User ID :</span>
+        <span class="value">${params.userId}</span>
+      </div>
+      
+      <div class="info-row">
+        <span class="label">Langue :</span>
+        <span class="value">${params.locale || "non définie"}</span>
+      </div>
+      
+      ${params.bonusAmountUsd ? `<div class="info-row"><span class="label">Bonus accordé :</span><span class="value">$${params.bonusAmountUsd}</span></div>` : ""}
+      
+      <div class="info-row">
+        <span class="label">Date :</span>
+        <span class="value">${new Date().toLocaleString("fr-FR")}</span>
+      </div>
+    </div>
+  </div>
+</body>
+</html>
+  `;
+
+  try {
+    await sendEmail({
+      to: ADMIN_EMAIL,
+      subject: `[${branding.appName}] Nouvelle inscription : ${params.userEmail}`,
+      html,
+      emailType: "transactional",
+    });
+    logger.info(
+      `[sendNewUserNotificationToAdmin] Notification sent to ${ADMIN_EMAIL} for user ${params.userId}`
+    );
+  } catch (error) {
+    logger.error(
+      "[sendNewUserNotificationToAdmin] Failed to send admin notification:",
+      error
+    );
+  }
+}

package/src/lib/auth-email-templates.ts

@@ -0,0 +1,5 @@
+export {
+  type AuthEmailKind,
+  getAuthEmailSubject,
+  renderAuthEmailHtml,
+} from "@lastbrain-labs/module-contact-pro";

package/src/lib/site-url.ts

@@ -0,0 +1,17 @@
+import { NextRequest } from "next/server";
+
+const FALLBACK_SITE_URL =
+  process.env.NEXT_PUBLIC_SITE_URL ||
+  process.env.SITE_URL ||
+  "http://localhost:3000";
+
+export function resolveSiteUrl(request: NextRequest) {
+  const origin =
+    process.env.NEXT_PUBLIC_SITE_URL ||
+    process.env.SITE_URL ||
+    request.headers.get("origin") ||
+    request.nextUrl.origin ||
+    FALLBACK_SITE_URL;
+
+  return origin.replace(/\/$/, "");
+}

package/src/sitemap/manifest.ts

@@ -0,0 +1,26 @@
+/**
+ * Manifest des sitemaps du module auth
+ * Déclare tous les sitemaps enfants à générer
+ * Auth module only has static pages (signin, signup, etc.)
+ */
+import type {
+  SitemapManifest,
+  SitemapChild,
+  SitemapChildKind,
+} from "@lastbrain/core";
+
+export type { SitemapManifest, SitemapChild, SitemapChildKind };
+export const sitemapManifest: SitemapManifest = {
+  module: "auth",
+  enabled: true,
+  includePublicPagesFromBuildConfig: true,
+  children: [
+    // Pages statiques (générées auto depuis build.config)
+    // Includes: /signin, /signup, /reset-password, /confirm, etc.
+    {
+      id: "static",
+      path: ":lang/static.xml",
+      kind: "static",
+    },
+  ],
+} as const;

package/src/web/admin/signup-stats.tsx

@@ -65,7 +65,7 @@ export function SignupStatsPage() {
 
   if (loading) {
     return (
-      <div className="flex justify-center items-center min-h-screen">
+      <div className="mt-16 flex justify-center items-center min-h-screen">
         <Spinner
           size="lg"
           label={t("signup_stats.loading") || "Chargement des statistiques..."}
@@ -76,7 +76,7 @@ export function SignupStatsPage() {
 
   if (error || !stats) {
     return (
-      <div className="p-6">
+      <div className="mt-16 p-6">
         <Card className="border border-danger-200 bg-danger-50/50">
           <CardBody>
             <p className="text-danger-600">{error || "Erreur de chargement"}</p>
@@ -96,7 +96,7 @@ export function SignupStatsPage() {
   ).toFixed(1);
 
   return (
-    <div className="space-y-6 px-2 md:p-6">
+    <div className="mt-16 space-y-6 px-2 md:p-6">
       {/* Header */}
       <div className="flex items-center gap-2 mb-8">
         <BarChart3 size={28} className="text-primary-600" />