@lastbrain/app 2.0.31 → 2.0.35

package/src/scripts/sitemap-manifest-generator.ts

@@ -0,0 +1,476 @@
+/**
+ * Nouveau système de sitemaps basé sur les manifests
+ * Architecture PLATE (pas d'imbrication) : index global -> sitemaps enfants (urlset)
+ * Conforme Google Search Console : pas d'index imbriqués
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import type { ModuleBuildConfig } from "../index.js";
+import {
+  collectAllContentSitemaps,
+  generateFlatGlobalSitemapIndex,
+  validateNoNestedIndexes,
+} from "./sitemap-flat-generator.js";
+
+/**
+ * Charge les paths ignorés depuis menu-ignored.ts de l'app
+ */
+function loadMenuIgnoredPaths(appDirectory: string): string[] {
+  try {
+    const menuIgnoredPath = path.join(
+      appDirectory,
+      "..",
+      "config",
+      "menu-ignored.ts"
+    );
+    if (!fs.existsSync(menuIgnoredPath)) {
+      return [];
+    }
+
+    const content = fs.readFileSync(menuIgnoredPath, "utf-8");
+    const ignoredPaths: string[] = [];
+
+    // Parser simple pour extraire les paths du fichier
+    const pathMatches = content.matchAll(/path:\s*["']([^"']+)["']/g);
+    for (const match of pathMatches) {
+      ignoredPaths.push(match[1]);
+    }
+
+    return ignoredPaths;
+  } catch (error) {
+    return [];
+  }
+}
+
+// Types dupliqués depuis les modules (pour éviter dépendances circulaires)
+type SitemapChildKind = "static" | "reexport";
+
+interface SitemapChild {
+  id: string;
+  path: string;
+  kind: SitemapChildKind;
+  handler?: string;
+  paging?: {
+    pageSize: number;
+  };
+}
+
+interface SitemapManifest {
+  module: string;
+  enabled: boolean;
+  includePublicPagesFromBuildConfig: boolean;
+  children: SitemapChild[];
+}
+
+/**
+ * Charge le manifest sitemap d'un module (si existe)
+ */
+export async function loadModuleManifest(
+  moduleConfig: ModuleBuildConfig,
+  projectRequire: NodeRequire,
+  isDebugMode: boolean
+): Promise<SitemapManifest | null> {
+  try {
+    const manifestPath = `${moduleConfig.moduleName}/sitemap/manifest`;
+
+    if (isDebugMode) {
+      console.log(`  Trying to load manifest from: ${manifestPath}`);
+    }
+
+    // Utiliser require synchrone plutôt que import dynamique
+    const manifestModule = projectRequire(manifestPath);
+    const manifest = manifestModule.sitemapManifest;
+
+    if (manifest && isDebugMode) {
+      console.log(`  ✅ Loaded manifest for module: ${manifest.module}`);
+    }
+
+    return manifest || null;
+  } catch (error) {
+    if (isDebugMode) {
+      console.log(
+        `  ⏭️  No manifest found for ${moduleConfig.moduleName}:`,
+        error
+      );
+    }
+    return null;
+  }
+}
+
+/**
+ * Génère le sitemap.xml racine PLAT - liste directement tous les sitemaps de contenu
+ * SUPPRIME les index intermédiaires de modules (pas d'imbrication)
+ */
+export function generateGlobalSitemapIndex(
+  appDirectory: string,
+  moduleManifests: Array<{
+    config: ModuleBuildConfig;
+    manifest: SitemapManifest;
+  }>,
+  languages: string[],
+  isDebugMode: boolean
+) {
+  // Collecter tous les sitemaps de contenu (urlset) directement
+  const entries = collectAllContentSitemaps(
+    moduleManifests,
+    languages,
+    appDirectory
+  );
+
+  if (isDebugMode) {
+    console.log(`\n📋 Collected ${entries.length} sitemap entries:`);
+    entries
+      .slice(0, 5)
+      .forEach((e) =>
+        console.log(`  - ${e.path} (module: ${e.module}, kind: ${e.kind})`)
+      );
+    if (entries.length > 5) {
+      console.log(`  ... and ${entries.length - 5} more`);
+    }
+  }
+
+  // Générer le sitemap.xml racine plat
+  generateFlatGlobalSitemapIndex(appDirectory, entries, isDebugMode);
+
+  // Valider qu'il n'y a pas d'imbrication
+  const validation = validateNoNestedIndexes(
+    appDirectory,
+    entries,
+    isDebugMode
+  );
+
+  if (!validation.valid) {
+    console.error("\n❌ SITEMAP VALIDATION FAILED:");
+    validation.errors.forEach((err) => console.error(err));
+    throw new Error("Sitemap validation failed: nested indexes detected");
+  }
+
+  if (isDebugMode) {
+    console.log(`✅ Sitemap validation passed: no nested indexes`);
+  }
+}
+
+/**
+ * SUPPRIMÉE - Les index de modules créent une imbrication non conforme
+ * Les sitemaps de contenu sont maintenant listés directement dans /sitemap.xml
+ *
+ * Ancienne fonction : generateModuleSitemapIndex()
+ * Raison suppression : Google Search Console refuse les index imbriqués
+ */
+// export function generateModuleSitemapIndex() { ... } // DEPRECATED
+
+/**
+ * Génère un sitemap enfant statique (pages build.config)
+ */
+export function generateStaticSitemap(
+  appDirectory: string,
+  moduleConfig: ModuleBuildConfig,
+  manifest: SitemapManifest,
+  child: any,
+  lang: string,
+  isDebugMode: boolean
+) {
+  const childPath = child.path.replace(":lang", lang);
+
+  // Retirer l'extension .xml du path pour créer un dossier
+  const pathWithoutExt = childPath.replace(/\.xml$/, ".xml");
+  const pathSegments = pathWithoutExt.split("/").filter(Boolean);
+
+  const targetDir = path.join(
+    appDirectory,
+    "sitemap",
+    manifest.module,
+    ...pathSegments
+  );
+  const targetFile = path.join(targetDir, "route.ts");
+
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  // Collecter UNIQUEMENT les pages statiques (sans patterns dynamiques [])
+  // Si le manifest spécifie includePublicPagesFromBuildConfig = false, ne pas inclure les pages
+  let publicPages: any[] = [];
+
+  if (manifest.includePublicPagesFromBuildConfig !== false) {
+    publicPages = (moduleConfig.pages || [])
+      .filter((p) => p.section === "public")
+      .filter((p) => !p.path.includes("[") && !p.path.includes("]"));
+  }
+
+  // Charger et exclure les pages dans menu-ignored.ts
+  const ignoredPaths = loadMenuIgnoredPaths(appDirectory);
+  if (ignoredPaths.length > 0) {
+    publicPages = publicPages.filter((p) => {
+      // p.path peut être "/blog" ou "/shop"
+      // ignoredPaths contient ["/shop", "/prompts", ...]
+      // On doit vérifier si p.path match exactement
+      return !ignoredPaths.some((ignoredPath) => {
+        // Normaliser les chemins (retirer les slashes finaux, etc.)
+        const normalizedPagePath = p.path.replace(/\/$/, "");
+        const normalizedIgnoredPath = ignoredPath.replace(/\/$/, "");
+        return normalizedPagePath === normalizedIgnoredPath;
+      });
+    });
+  }
+
+  const content = `// GENERATED BY LASTBRAIN MODULE BUILD - Static Pages Sitemap
+// Module: ${manifest.module}
+// Lang: ${lang}
+
+export async function GET(): Promise<Response> {
+  const baseUrl =
+    process.env.NEXT_PUBLIC_SITE_URL ||
+    (process.env.VERCEL_URL ? \`https://\${process.env.VERCEL_URL}\` : "https://example.com");
+
+  const pages: string[] = ${JSON.stringify(publicPages.map((p) => `/${lang}${p.path}`))};
+
+  const xml = \`<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+\${pages.map((page: string) => \`  <url>
+    <loc>\${baseUrl}\${page}</loc>
+    <lastmod>\${new Date().toISOString()}</lastmod>
+    <changefreq>weekly</changefreq>
+    <priority>0.8</priority>
+  </url>\`).join("\\n")}
+</urlset>\`;
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": "public, max-age=3600, s-maxage=3600",
+    },
+  });
+}
+`;
+
+  fs.writeFileSync(targetFile, content);
+
+  if (isDebugMode) {
+    console.log(
+      `📄 Generated static sitemap: ${targetFile} (${publicPages.length} pages)`
+    );
+  }
+}
+
+/**
+ * Génère un sitemap enfant dynamique (reexport handler)
+ */
+export function generateReexportSitemap(
+  appDirectory: string,
+  manifest: SitemapManifest,
+  child: any,
+  lang: string,
+  type?: string,
+  isDebugMode?: boolean
+) {
+  let childPath = child.path.replace(":lang", lang);
+  if (type) {
+    childPath = childPath.replace(":type", type);
+  }
+
+  const segments = childPath.split("/").filter(Boolean);
+  const targetDir = path.join(
+    appDirectory,
+    "sitemap",
+    manifest.module,
+    ...segments.slice(0, -1)
+  );
+  const fileName = segments[segments.length - 1];
+  const targetFile = path.join(targetDir, fileName, "route.ts");
+
+  if (!fs.existsSync(path.dirname(targetFile))) {
+    fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+  }
+
+  // Créer un wrapper qui passe les params au handler
+  const paramsObject: Record<string, string> = { lang };
+  if (type) {
+    paramsObject.type = type;
+  }
+
+  const content = `// GENERATED BY LASTBRAIN MODULE BUILD - Reexport Sitemap
+// Module: ${manifest.module}
+// Handler: ${child.handler}
+// Params: ${JSON.stringify(paramsObject)}
+
+import { GET as handler } from "${child.handler}";
+
+export async function GET(request: Request): Promise<Response> {
+  // Wrapper pour passer les params au handler
+  const context = {
+    params: Promise.resolve(${JSON.stringify(paramsObject)})
+  };
+  return handler(request, context);
+}
+`;
+
+  fs.writeFileSync(targetFile, content);
+
+  if (isDebugMode) {
+    console.log(`🔗 Generated reexport sitemap: ${targetFile}`);
+  }
+}
+
+/**
+ * Génère tous les sitemaps pour un module
+ */
+export async function generateModuleSitemaps(
+  appDirectory: string,
+  moduleConfig: ModuleBuildConfig,
+  manifest: SitemapManifest,
+  languages: string[],
+  isDebugMode: boolean
+) {
+  // NE PLUS GÉNÉRER D'INDEX INTERMÉDIAIRE
+  // Ancien code : generateModuleSitemapIndex() - SUPPRIMÉ pour éviter l'imbrication
+  // Le sitemap global /sitemap.xml liste maintenant directement tous les sitemaps enfants
+
+  // Générer chaque sitemap enfant (sitemaps de contenu = urlset)
+  for (const child of manifest.children) {
+    if (child.kind === "static") {
+      // Générer static.xml pour chaque langue
+      for (const lang of languages) {
+        generateStaticSitemap(
+          appDirectory,
+          moduleConfig,
+          manifest,
+          child,
+          lang,
+          isDebugMode
+        );
+      }
+    } else if (child.kind === "reexport") {
+      // Générer les reexports selon le pattern du path
+      if (child.path.includes(":lang") && child.path.includes(":type")) {
+        // Ancien système avec :type (déprécié) - Blog: par type et langue
+        const contentTypes = ["blog", "tutorial", "faq", "help", "docs"];
+        for (const lang of languages) {
+          for (const type of contentTypes) {
+            generateReexportSitemap(
+              appDirectory,
+              manifest,
+              child,
+              lang,
+              type,
+              isDebugMode
+            );
+          }
+        }
+      } else if (child.path.includes(":lang")) {
+        // Path avec :lang uniquement
+        // Peut contenir un type fixe dans le path comme :lang/blog/categories.xml
+        for (const lang of languages) {
+          // Extraire le type du path si présent
+          const pathSegments = child.path.split("/").filter(Boolean);
+          let extractedType: string | undefined;
+
+          // Si le path est comme :lang/blog/categories.xml, extraire "blog"
+          if (pathSegments.length >= 2 && pathSegments[0] === ":lang") {
+            const potentialType = pathSegments[1];
+            // Vérifier si c'est un type de contenu connu
+            const contentTypes = ["blog", "tutorial", "faq", "help", "docs"];
+            if (contentTypes.includes(potentialType)) {
+              extractedType = potentialType;
+            }
+          }
+
+          generateReexportSitemap(
+            appDirectory,
+            manifest,
+            child,
+            lang,
+            extractedType,
+            isDebugMode
+          );
+        }
+      } else {
+        // Path statique sans params
+        generateReexportSitemap(
+          appDirectory,
+          manifest,
+          child,
+          "",
+          undefined,
+          isDebugMode
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Point d'entrée principal du nouveau système de sitemaps
+ */
+export async function generateManifestBasedSitemaps(
+  appDirectory: string,
+  moduleConfigs: ModuleBuildConfig[],
+  languages: string[],
+  projectRequire: NodeRequire,
+  isDebugMode: boolean
+) {
+  const moduleManifests: Array<{
+    config: ModuleBuildConfig;
+    manifest: SitemapManifest;
+  }> = [];
+
+  if (isDebugMode) {
+    console.log(
+      `🔍 Checking ${moduleConfigs.length} module(s) for sitemap manifests...`
+    );
+  }
+
+  // Charger les manifests de tous les modules
+  for (const config of moduleConfigs) {
+    const manifest = await loadModuleManifest(
+      config,
+      projectRequire,
+      isDebugMode
+    );
+    if (manifest && manifest.enabled) {
+      moduleManifests.push({ config, manifest });
+    }
+  }
+
+  if (moduleManifests.length === 0) {
+    if (isDebugMode) {
+      console.log(
+        "⏭️  No sitemap manifests found, skipping manifest-based generation"
+      );
+    }
+    return;
+  }
+
+  if (isDebugMode) {
+    console.log(
+      `🗺️  Found ${moduleManifests.length} module(s) with sitemap manifests`
+    );
+  }
+
+  // Générer l'index global PLAT (liste directement tous les sitemaps de contenu)
+  generateGlobalSitemapIndex(
+    appDirectory,
+    moduleManifests,
+    languages,
+    isDebugMode
+  );
+
+  // Générer les sitemaps de chaque module
+  for (const { config, manifest } of moduleManifests) {
+    if (isDebugMode) {
+      console.log(`📦 Generating sitemaps for module: ${manifest.module}`);
+    }
+    await generateModuleSitemaps(
+      appDirectory,
+      config,
+      manifest,
+      languages,
+      isDebugMode
+    );
+  }
+
+  if (isDebugMode) {
+    console.log("✅ Manifest-based sitemaps generated successfully");
+  }
+}

package/src/sitemap/manifest.ts

@@ -0,0 +1,17 @@
+/**
+ * Manifest des sitemaps du package app
+ * Package désactivé (pas un module avec pages publiques)
+ */
+import type {
+  SitemapManifest,
+  SitemapChild,
+  SitemapChildKind,
+} from "@lastbrain/core";
+
+export type { SitemapManifest, SitemapChild, SitemapChildKind };
+export const sitemapManifest: SitemapManifest = {
+  module: "app",
+  enabled: false,
+  includePublicPagesFromBuildConfig: false,
+  children: [],
+} as const;

package/src/templates/AuthGuidePage.tsx

@@ -1,5 +1,5 @@
+"use client";
 // GENERATED BY LASTBRAIN TEMPLATE (Auth Guide)
-import React from "react";
 import { Card, Code, Divider, Chip } from "@lastbrain/ui";
 
 export function AuthGuidePage() {