@lastbrain/app 2.0.31 → 2.0.35

package/src/scripts/module-create.ts

@@ -50,13 +50,14 @@ function parsePagesList(input: string): string[] {
 
 /**
  * Slugifie un nom de page: minuscules, tirets, alphanum uniquement
+ * Préserve les crochets [] pour les routes dynamiques et les slashes / pour les sous-chemins
  */
 function slugifyPageName(name: string): string {
   return name
     .trim()
     .toLowerCase()
     .replace(/[\s_]+/g, "-")
-    .replace(/[^a-z0-9-]/g, "")
+    .replace(/[^a-z0-9\-/[\]]/g, "") // Préserve -, /, [, ]
     .replace(/--+/g, "-")
     .replace(/^-+|-+$/g, "");
 }
@@ -121,7 +122,7 @@ function generatePackageJson(
   isPro: boolean = false
 ): string {
   const versions = getLastBrainPackageVersions(rootDir);
-  const moduleNameOnly = slug.replace("module-", "").replace("-pro", "");
+  const moduleNameOnly = slug.replace("module-", "");
   const buildConfigExport = `./${moduleNameOnly}.build.config`;
   const packageJson: Record<string, unknown> = {
     name: moduleName,
@@ -403,7 +404,11 @@ function toPascalCase(value: string): string {
     .join("");
 }
 
-function generateIndexTs(pages: PageConfig[], moduleNameOnly: string): string {
+function generateIndexTs(
+  pages: PageConfig[],
+  moduleNameOnly: string,
+  hasPublicPages: boolean
+): string {
   // Grouper les pages par nom pour détecter les doublons
   const pagesByName = new Map<string, PageConfig[]>();
   for (const page of pages) {
@@ -430,6 +435,11 @@ function generateIndexTs(pages: PageConfig[], moduleNameOnly: string): string {
   const cleanedNameOnly = moduleNameOnly.replace(/-pro$/, "");
   const moduleAlias = toPascalCase(cleanedNameOnly);
 
+  // Export du sitemap manifest si le module a des pages publiques
+  const sitemapExport = hasPublicPages
+    ? `\n// Sitemap configuration\nexport { sitemapManifest } from "./sitemap/manifest";\n`
+    : "";
+
   return `// Client Components
 ${exports.join("\n")}
 
@@ -438,7 +448,7 @@ export { Doc } from "./components/Doc";
 export { Doc as ${moduleAlias}ModuleDoc } from "./components/Doc";
 
 // Configuration de build
-export { default as buildConfig } from "./${moduleNameOnly}.build.config";
+export { default as buildConfig } from "./${moduleNameOnly}.build.config";${sitemapExport}
 `;
 }
 
@@ -1419,6 +1429,184 @@ export function findWorkspaceRoot(): string {
   );
 }
 
+/**
+ * Génère le fichier manifest.ts pour les sitemaps
+ */
+function generateSitemapManifest(moduleName: string): string {
+  return `/**
+ * Types pour le système de sitemaps multi-modules
+ */
+export type SitemapChildKind = "static" | "reexport";
+
+export interface SitemapChild {
+  id: string;
+  path: string;
+  kind: SitemapChildKind;
+  handler?: string;
+  paging?: {
+    pageSize: number;
+  };
+}
+
+export interface SitemapManifest {
+  module: string;
+  enabled: boolean;
+  includePublicPagesFromBuildConfig: boolean;
+  children: SitemapChild[];
+}
+
+/**
+ * Manifest des sitemaps du module ${moduleName}
+ * Déclare tous les sitemaps enfants à générer
+ * 
+ * Configuration:
+ * - enabled: Active/désactive le module dans les sitemaps globaux
+ * - includePublicPagesFromBuildConfig: Inclut automatiquement les pages publiques du build.config
+ * - children: Liste des sitemaps à générer
+ * 
+ * Types de sitemaps:
+ * 1. "static": Pages statiques générées depuis build.config (sans paramètres dynamiques)
+ * 2. "reexport": Sitemaps dynamiques avec handler personnalisé (avec paramètres :lang, :type, etc.)
+ */
+export const sitemapManifest: SitemapManifest = {
+  module: "${moduleName}",
+  enabled: true,
+  includePublicPagesFromBuildConfig: true,
+  children: [
+    // Pages statiques (générées automatiquement depuis build.config)
+    {
+      id: "static",
+      path: ":lang/static.xml",
+      kind: "static",
+    },
+    
+    // EXEMPLE: Sitemap dynamique avec handler personnalisé
+    // Décommentez et adaptez selon vos besoins:
+    
+    // {
+    //   id: "dynamic-content",
+    //   path: ":lang/content.xml",
+    //   kind: "reexport",
+    //   handler: "${moduleName}/sitemap/handlers/content",
+    // },
+  ],
+} as const;
+`;
+}
+
+/**
+ * Génère un exemple de handler de sitemap dynamique
+ */
+function generateSitemapHandler(moduleName: string): string {
+  return `/**
+ * EXEMPLE: Handler dynamique pour sitemap
+ * 
+ * Ce fichier montre comment créer un sitemap dynamique qui génère
+ * des URLs à partir de données (base de données, API, liste statique, etc.)
+ * 
+ * Pour activer ce handler:
+ * 1. Décommentez l'entrée correspondante dans manifest.ts
+ * 2. Adaptez la logique ci-dessous à vos besoins
+ * 3. Rebuild le module: pnpm --filter ${moduleName} build
+ */
+
+import { LOCALE_MAP } from "@lastbrain/core";
+// Pour récupérer des données depuis Supabase:
+// import { getSupabaseServiceClient } from "@lastbrain/core/server";
+
+/**
+ * Handler GET pour générer le sitemap XML
+ * 
+ * @param _request - Requête HTTP (non utilisée ici)
+ * @param context - Contient les paramètres dynamiques de la route (:lang, :type, etc.)
+ * @returns Response avec le XML du sitemap
+ */
+export async function GET(
+  _request: Request,
+  context: { params: Promise<{ lang: string }> }
+): Promise<Response> {
+  const params = await context.params;
+  const { lang } = params;
+
+  // Validation de la langue
+  if (!LOCALE_MAP[lang]) {
+    return new Response("Invalid language", { status: 404 });
+  }
+
+  // Configuration de l'URL de base
+  const baseUrl =
+    process.env.NEXT_PUBLIC_SITE_URL ||
+    (process.env.VERCEL_URL
+      ? \`https://\${process.env.VERCEL_URL}\`
+      : "https://example.com");
+
+  try {
+    // EXEMPLE 1: Liste statique d'URLs
+    const staticItems = [
+      { slug: "item-1", updatedAt: new Date().toISOString() },
+      { slug: "item-2", updatedAt: new Date().toISOString() },
+      { slug: "item-3", updatedAt: new Date().toISOString() },
+    ];
+
+    // EXEMPLE 2: Récupération depuis Supabase (décommentez si besoin)
+    /*
+    const supabase = getSupabaseServiceClient();
+    const { data: items, error } = await supabase
+      .from("your_table")
+      .select("slug, updated_at")
+      .eq("status", "published")
+      .order("updated_at", { ascending: false })
+      .limit(1000);
+
+    if (error) {
+      console.error("Sitemap error:", error);
+      return new Response(JSON.stringify({ error: error.message }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    */
+
+    // Génération des URLs pour le sitemap
+    const urls = staticItems.map((item) => ({
+      url: \`\${baseUrl}/\${lang}/your-section/\${item.slug}\`,
+      lastmod: item.updatedAt,
+      changefreq: "weekly",
+      priority: 0.7,
+    }));
+
+    // Construction du XML
+    const urlEntries = urls
+      .map(
+        (entry) => \`  <url>
+    <loc>\${entry.url}</loc>
+    <lastmod>\${entry.lastmod}</lastmod>
+    <changefreq>\${entry.changefreq}</changefreq>
+    <priority>\${entry.priority}</priority>
+  </url>\`
+      )
+      .join("\\n");
+
+    const xml = \`<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+\${urlEntries}
+</urlset>\`;
+
+    // Retour de la réponse XML
+    return new Response(xml, {
+      headers: {
+        "Content-Type": "application/xml",
+        "Cache-Control": "public, max-age=3600",
+      },
+    });
+  } catch (err) {
+    console.error("Sitemap generation error:", err);
+    return new Response("Internal error", { status: 500 });
+  }
+}
+`;
+}
+
 /**
  * Crée la structure du module
  */
@@ -1464,11 +1652,14 @@ export async function createModuleStructure(
     generateBuildConfig(config)
   );
 
+  // Détecter si le module a des pages publiques (pour l'export sitemap)
+  const hasPublicPages = config.pages.some((p) => p.section === "public");
+
   // Créer index.ts
   console.log(chalk.yellow("  📄 src/index.ts"));
   await fs.writeFile(
     path.join(moduleDir, "src", "index.ts"),
-    generateIndexTs(config.pages, moduleNameOnly)
+    generateIndexTs(config.pages, moduleNameOnly, hasPublicPages)
   );
 
   // Note: server.ts n'est plus généré pour éviter les conflits d'exports
@@ -1494,24 +1685,48 @@ export async function createModuleStructure(
   }
 
   for (const page of config.pages) {
-    const pagePath = path.join(moduleDir, "src", "web", page.section);
+    // Extraire le chemin du répertoire et le nom de base de la page
+    const pageNameParts = page.name.split("/");
+    const pageBaseName = pageNameParts[pageNameParts.length - 1];
+
+    // Créer le chemin complet incluant les sous-répertoires avec leurs noms originaux
+    // Garder les noms tels quels (ex: "apis", "[slug]" etc.) pour les répertoires
+    const subdirParts = pageNameParts.slice(0, -1);
+    const pagePath =
+      subdirParts.length > 0
+        ? path.join(moduleDir, "src", "web", page.section, ...subdirParts)
+        : path.join(moduleDir, "src", "web", page.section);
+
     await fs.ensureDir(pagePath);
 
-    const baseName = page.name
+    // Le nom de fichier suit la convention Next.js : garder les crochets
+    // apis/[slug] → apis/[slug].tsx
+    // apis/[id]/versions → apis/[id]/versions.tsx
+    const fileName = `${pageBaseName}.tsx`;
+
+    // Pour le nom du composant React, on enlève les crochets
+    // [slug] → Slug, [id] → Id
+    const cleanedBaseName = pageBaseName.replace(/[[\]]/g, "");
+
+    const baseName = cleanedBaseName
       .split("-")
       .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
       .join("");
 
-    // Si le même nom de page existe dans plusieurs sections, ajouter la section au nom du fichier
+    // Si le même nom de page existe dans plusieurs sections, ajouter la section au nom du composant
     const duplicates = pagesByName.get(page.name) || [];
     const hasDuplicates = duplicates.length > 1;
     const componentNameWithSection = hasDuplicates
       ? `${baseName}${toPascalCase(page.section)}`
       : baseName;
 
-    const fileName = `${componentNameWithSection}Page.tsx`;
+    // Afficher le chemin complet
+    const fullDisplayPath =
+      subdirParts.length > 0
+        ? `src/web/${page.section}/${subdirParts.join("/")}/${fileName}`
+        : `src/web/${page.section}/${fileName}`;
+    console.log(chalk.yellow(`  📄 ${fullDisplayPath}`));
 
-    console.log(chalk.yellow(`  📄 src/web/${page.section}/${fileName}`));
     await fs.writeFile(
       path.join(pagePath, fileName),
       generatePageComponent(page.name, page.section, componentNameWithSection)
@@ -1567,6 +1782,41 @@ export async function createModuleStructure(
     );
   }
 
+  // Créer les fichiers sitemap si le module a des pages publiques
+  if (hasPublicPages) {
+    console.log(chalk.blue("\n🗺️  Création des fichiers sitemap..."));
+
+    const sitemapDir = path.join(moduleDir, "src", "sitemap");
+    const handlersDir = path.join(sitemapDir, "handlers");
+    await fs.ensureDir(handlersDir);
+
+    // manifest.ts
+    console.log(chalk.yellow("  📄 src/sitemap/manifest.ts"));
+    await fs.writeFile(
+      path.join(sitemapDir, "manifest.ts"),
+      generateSitemapManifest(config.slug.replace("module-", ""))
+    );
+
+    // Exemple de handler dynamique (commenté par défaut)
+    console.log(
+      chalk.yellow("  📄 src/sitemap/handlers/example.ts (commented)")
+    );
+    await fs.writeFile(
+      path.join(handlersDir, "example.ts"),
+      generateSitemapHandler(config.moduleName)
+    );
+
+    console.log(chalk.green("  ✓ Fichiers sitemap créés"));
+    console.log(
+      chalk.gray("    → Éditez manifest.ts pour personnaliser vos sitemaps")
+    );
+    console.log(
+      chalk.gray(
+        "    → Décommentez handlers/example.ts pour ajouter des sitemaps dynamiques"
+      )
+    );
+  }
+
   // Générer la documentation du module
   console.log(chalk.blue("\n📝 Génération de la documentation..."));
   await generateModuleReadme(config, moduleDir);

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

@@ -0,0 +1,313 @@
+/**
+ * Générateur de sitemap PLAT (pas d'imbrication d'index)
+ *
+ * PRINCIPE:
+ * - /sitemap.xml = unique index racine
+ * - /sitemap/{module}/{lang}/{type}.xml = sitemaps de contenu (urlset)
+ * - PAS d'index intermédiaire /sitemap/{module}/sitemap.xml
+ *
+ * Conforme aux recommandations Google Search Console :
+ * "Un sitemap index ne doit pas référencer un autre sitemap index"
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import type { ModuleBuildConfig } from "../index.js";
+
+interface SitemapEntry {
+  path: string;
+  module: string;
+  kind: string; // "static", "dynamic", etc.
+}
+
+interface MenuIgnored {
+  public: { title: string; path: string }[];
+  auth: { title: string; path: string }[];
+}
+
+/**
+ * Charge le fichier menu-ignored.ts de l'app si disponible
+ */
+function loadMenuIgnored(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 [];
+  }
+}
+
+/**
+ * Vérifie si un sitemap correspond à une URL ignorée
+ */
+function isSitemapIgnored(
+  sitemapPath: string,
+  ignoredPaths: string[]
+): boolean {
+  // Extraire le chemin de base du sitemap (sans /sitemap/{module}/{lang}/)
+  // Ex: /sitemap/recipes-pro/fr/static.xml contient les pages comme /fr/...
+
+  for (const ignoredPath of ignoredPaths) {
+    // Si le sitemap contient une page ignorée, on l'exclut
+    // Note: cette logique peut être affinée selon vos besoins
+    if (sitemapPath.includes("static.xml")) {
+      // Les sitemaps statiques peuvent contenir des pages ignorées
+      // On garde tous les sitemaps statiques pour l'instant
+      // car ils peuvent contenir d'autres pages non ignorées
+      continue;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Collecte tous les sitemaps enfants (urlset) de tous les modules
+ * Sans créer d'index intermédiaires
+ */
+export function collectAllContentSitemaps(
+  moduleManifests: Array<{
+    config: ModuleBuildConfig;
+    manifest: any;
+  }>,
+  languages: string[],
+  appDirectory?: string
+): SitemapEntry[] {
+  const entries: SitemapEntry[] = [];
+
+  for (const { manifest } of moduleManifests) {
+    if (!manifest.enabled) continue;
+
+    // Exclure le module auth (routes bloquées pour l'exploration)
+    if (manifest.module === "auth") continue;
+
+    for (const child of manifest.children || []) {
+      if (child.kind === "static") {
+        // Générer une entrée par langue
+        for (const lang of languages) {
+          const childPath = child.path.replace(":lang", lang);
+          const fullPath = childPath.startsWith("/")
+            ? childPath
+            : `/${childPath}`;
+
+          // Ajouter le préfixe du module pour éviter les conflits
+          const modulePath = `/sitemap/${manifest.module}${fullPath}`;
+
+          entries.push({
+            path: modulePath,
+            module: manifest.module,
+            kind: child.kind,
+          });
+        }
+      } else if (child.kind === "reexport") {
+        // Sitemap dynamique - gérer les patterns :lang et :type
+
+        // Vérifier si le path contient d'autres paramètres que :lang
+        // (comme :type, :id, etc.) - ces sitemaps ne doivent PAS être dans l'index
+        if (
+          child.path.includes(":") &&
+          child.path.replace(":lang", "").includes(":")
+        ) {
+          // Skip les sitemaps avec des paramètres autres que :lang
+          // Exemple: :lang/:type/categories.xml contient :type qui n'est pas géré ici
+          continue;
+        }
+
+        if (child.path.includes(":lang")) {
+          // Générer pour chaque langue
+          for (const lang of languages) {
+            const childPath = child.path.replace(":lang", lang);
+            const fullPath = childPath.startsWith("/")
+              ? childPath
+              : `/${childPath}`;
+
+            // Ajouter le préfixe du module
+            const modulePath = `/sitemap/${manifest.module}${fullPath}`;
+
+            entries.push({
+              path: modulePath,
+              module: manifest.module,
+              kind: child.kind,
+            });
+          }
+        } else {
+          // Pas de paramètre langue - path statique
+          const fullPath = child.path.startsWith("/")
+            ? child.path
+            : `/${child.path}`;
+
+          // Ajouter le préfixe du module
+          const modulePath = `/sitemap/${manifest.module}${fullPath}`;
+
+          entries.push({
+            path: modulePath,
+            module: manifest.module,
+            kind: child.kind,
+          });
+        }
+      }
+    }
+  }
+
+  // Filtrer les sitemaps selon menu-ignored.ts si appDirectory est fourni
+  if (appDirectory) {
+    const ignoredPaths = loadMenuIgnored(appDirectory);
+    if (ignoredPaths.length > 0) {
+      // Pour l'instant, on ne filtre pas au niveau du sitemap index
+      // car les sitemaps peuvent contenir un mix de pages ignorées et non ignorées
+      // Le filtrage devrait idéalement se faire au niveau des handlers de sitemap individuels
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Génère le sitemap.xml racine PLAT qui liste directement tous les sitemaps de contenu
+ * SANS passer par des index intermédiaires
+ */
+export function generateFlatGlobalSitemapIndex(
+  appDirectory: string,
+  entries: SitemapEntry[],
+  isDebugMode: boolean
+) {
+  const globalSitemapDir = path.join(appDirectory, "sitemap.xml");
+  const globalSitemapFile = path.join(globalSitemapDir, "route.ts");
+
+  if (!fs.existsSync(globalSitemapDir)) {
+    fs.mkdirSync(globalSitemapDir, { recursive: true });
+  }
+
+  // Générer les entrées XML
+  const sitemapEntries = entries
+    .map(
+      (entry) => `  <sitemap>
+    <loc>\${baseUrl}${entry.path}</loc>
+    <lastmod>\${new Date().toISOString()}</lastmod>
+  </sitemap>`
+    )
+    .join("\n");
+
+  const content = `// GENERATED BY LASTBRAIN MODULE BUILD - FLAT Global Sitemap Index
+// Lists ALL content sitemaps directly (NO nested indexes)
+// Total: ${entries.length} sitemap(s)
+// Modules: ${Array.from(new Set(entries.map((e) => e.module))).join(", ")}
+
+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 xml = \`<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${sitemapEntries}
+</sitemapindex>\`;
+
+  return new Response(xml, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": "public, max-age=3600, s-maxage=3600",
+    },
+  });
+}
+`;
+
+  fs.writeFileSync(globalSitemapFile, content);
+
+  if (isDebugMode) {
+    console.log(
+      `🌍 Generated FLAT global sitemap index with ${entries.length} content sitemaps`
+    );
+    console.log(
+      `   Modules: ${Array.from(new Set(entries.map((e) => e.module))).join(", ")}`
+    );
+  }
+
+  return globalSitemapFile;
+}
+
+/**
+ * Valide qu'aucun sitemap de contenu ne contient de référence circulaire ou imbrication
+ */
+export function validateNoNestedIndexes(
+  appDirectory: string,
+  entries: SitemapEntry[],
+  isDebugMode: boolean
+): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Vérifier qu'aucune entrée ne pointe vers un sitemap.xml (qui serait un index)
+  for (const entry of entries) {
+    if (entry.path.endsWith("/sitemap.xml")) {
+      errors.push(
+        `❌ NESTED INDEX DETECTED: ${entry.path} (module: ${entry.module})`
+      );
+    }
+
+    // Vérifier qu'aucune entrée ne pointe vers la racine /sitemap.xml
+    if (entry.path === "/sitemap.xml") {
+      errors.push(
+        `❌ CIRCULAR REFERENCE: ${entry.path} points to root sitemap (module: ${entry.module})`
+      );
+    }
+  }
+
+  // Vérifier les fichiers générés pour s'assurer qu'ils sont bien des urlset et pas des sitemapindex
+  for (const entry of entries) {
+    const segments = entry.path
+      .replace(/^\//, "")
+      .replace(/\.xml$/, ".xml")
+      .split("/");
+    const routeDir = path.join(appDirectory, ...segments);
+    const routeFile = path.join(routeDir, "route.ts");
+
+    if (fs.existsSync(routeFile)) {
+      const content = fs.readFileSync(routeFile, "utf-8");
+
+      // Vérifier si le fichier contient "sitemapindex" (mauvais)
+      if (content.includes("<sitemapindex")) {
+        errors.push(
+          `❌ FILE IS INDEX NOT URLSET: ${entry.path} contains <sitemapindex> (module: ${entry.module})`
+        );
+      }
+
+      // Vérifier s'il contient bien "urlset" (bon)
+      if (!content.includes("<urlset") && !content.includes("sitemapindex")) {
+        // Peut être un re-export, c'est OK
+        if (isDebugMode) {
+          console.log(`   ℹ️  ${entry.path} is a re-export (OK)`);
+        }
+      }
+    }
+  }
+
+  if (errors.length > 0 && isDebugMode) {
+    console.error("\n🚨 SITEMAP VALIDATION ERRORS:");
+    errors.forEach((err) => console.error(err));
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}