@lastbrain/app 0.1.7 → 0.1.9

package/src/scripts/module-build.ts

@@ -0,0 +1,502 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+
+import type {
+  ModuleApiConfig,
+  ModuleBuildConfig,
+  ModuleMenuConfig,
+  ModuleMenuItemConfig,
+  ModulePageConfig,
+  ModuleSection,
+} from "@lastbrain/core";
+
+// Utiliser PROJECT_ROOT si défini (pour pnpm --filter), sinon process.cwd()
+const projectRoot = process.env.PROJECT_ROOT || process.cwd();
+const appDirectory = path.join(projectRoot, "app");
+
+// Créer un require dans le contexte de l'application pour résoudre les modules installés dans l'app
+const projectRequire = createRequire(path.join(projectRoot, "package.json"));
+
+// Charger les modules depuis modules.json
+async function loadModuleConfigs(): Promise<ModuleBuildConfig[]> {
+  const moduleConfigs: ModuleBuildConfig[] = [];
+  const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+  
+  if (!fs.existsSync(modulesJsonPath)) {
+    return moduleConfigs;
+  }
+  
+  try {
+    const modulesData = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+    const modules = modulesData.modules || [];
+
+    for (const module of modules) {
+      // Ne charger que les modules actifs
+      if (module.active === false) {
+        continue;
+      }
+      
+      const packageName = module.package;
+      
+      try {
+        const moduleSuffix = packageName.replace("@lastbrain/module-", "");
+        const possibleConfigNames = [
+          `${moduleSuffix}.build.config`,
+          "build.config",
+        ];
+
+        let loaded = false;
+        for (const configName of possibleConfigNames) {
+          try {
+            // Résoudre le chemin du module depuis l'application
+            const modulePath = projectRequire.resolve(`${packageName}/${configName}`);
+            // Convertir en URL file:// pour l'import dynamique
+            const moduleUrl = `file://${modulePath}`;
+            const moduleImport = await import(moduleUrl);
+            
+            if (moduleImport.default) {
+              moduleConfigs.push(moduleImport.default);
+              loaded = true;
+              break;
+            }
+          } catch (err) {
+            // Essayer le nom suivant
+          }
+        }
+
+        if (!loaded) {
+          console.warn(`⚠️  Could not load build config for ${packageName}`);
+        }
+      } catch (error) {
+        console.warn(`⚠️  Failed to load module ${packageName}:`, error);
+      }
+    }
+  } catch (error) {
+    console.error("❌ Error loading modules.json:", error);
+  }
+  
+  return moduleConfigs;
+}
+
+const sectionDirectoryMap: Record<ModuleSection, string[]> = {
+  public: ["(public)"],
+  auth: ["auth"],
+  admin: ["admin"],
+  user: ["auth", "user"],
+};
+
+const sectionLayoutMap: Record<string, string> = {
+  auth: "AuthLayout",
+  admin: "AdminLayout",
+  "(public)": "PublicLayout",
+};
+
+const generatedSections = new Set<string>();
+
+const navigation: Record<string, MenuEntry[]> = {
+  public: [],
+  auth: [],
+  admin: [],
+};
+const userMenu: MenuEntry[] = [];
+
+interface MenuEntry {
+  label: string;
+  path: string;
+  module: string;
+  section: ModuleSection;
+}
+
+function ensureDirectory(dir: string) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function ensureSectionLayout(sectionPath: string[]) {
+  const sectionDir = path.join(appDirectory, ...sectionPath);
+  const sectionKey = sectionPath[0];
+
+  // Éviter de générer plusieurs fois le même layout
+  if (generatedSections.has(sectionKey)) {
+    return;
+  }
+
+  ensureDirectory(sectionDir);
+
+  const layoutName = sectionLayoutMap[sectionKey];
+  if (layoutName) {
+    const layoutPath = path.join(sectionDir, "layout.tsx");
+    if (!fs.existsSync(layoutPath)) {
+      const layoutContent = `import { ${layoutName} } from "@lastbrain/app";
+
+export default function SectionLayout({ children }: { children: React.ReactNode }) {
+  return <${layoutName}>{children}</${layoutName}>;
+}
+`;
+      fs.writeFileSync(layoutPath, layoutContent);
+      console.log(`📐 Generated section layout: ${layoutPath}`);
+    }
+  }
+
+  generatedSections.add(sectionKey);
+}
+
+function toPascalCase(value: string) {
+  return value
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+    .join("");
+}
+
+function buildPage(moduleConfig: ModuleBuildConfig, page: ModulePageConfig) {
+  const segments = page.path.replace(/^\/+/, "").split("/").filter(Boolean);
+  const sectionPath = sectionDirectoryMap[page.section] ?? ["(public)"];
+  
+  // Générer le layout de section si nécessaire
+  ensureSectionLayout(sectionPath);
+  
+  const routeDir = path.join(appDirectory, ...sectionPath, ...segments);
+  const filePath = path.join(routeDir, "page.tsx");
+  ensureDirectory(routeDir);
+
+  const wrapperSuffix = segments.length
+    ? toPascalCase(segments.join("-"))
+    : "Root";
+  const wrapperName = `${page.componentExport}${wrapperSuffix}Route`;
+
+  // Vérifier si la route a des paramètres dynamiques (segments avec [])
+  const hasDynamicParams = segments.some(seg => seg.startsWith('[') && seg.endsWith(']'));
+
+  // Pour les pages publiques (signin, signup, etc.), utiliser dynamic import sans SSR
+  // pour éviter les erreurs d'hydratation avec les IDs HeroUI/React Aria
+  const isPublicAuthPage = page.section === "public" && 
+    (page.path.includes("signin") || page.path.includes("signup") || page.path.includes("reset-password"));
+
+  let content: string;
+  
+  if (isPublicAuthPage) {
+    content = `"use client";
+
+import dynamic from "next/dynamic";
+
+const ${page.componentExport} = dynamic(
+  () => import("${moduleConfig.moduleName}").then((mod) => ({ default: mod.${page.componentExport} })),
+  { ssr: false }
+);
+
+export default function ${wrapperName}${hasDynamicParams ? '(props: any)' : '()'} {
+  return <${page.componentExport} ${hasDynamicParams ? '{...props}' : ''} />;
+}
+`;
+  } else {
+    content = `import { ${page.componentExport} } from "${moduleConfig.moduleName}";
+
+export default function ${wrapperName}${hasDynamicParams ? '(props: any)' : '()'} {
+  return <${page.componentExport} ${hasDynamicParams ? '{...props}' : ''} />;
+}
+`;
+  }
+
+  fs.writeFileSync(filePath, content);
+  console.log(`⭐ Generated page: ${filePath}`);  const entry: MenuEntry = {
+    label: `Module:${moduleConfig.moduleName} ${page.componentExport}`,
+    path: page.path,
+    module: moduleConfig.moduleName,
+    section: page.section,
+  };
+
+  if (page.section === "user") {
+    userMenu.push(entry);
+  } else if (page.section) {
+    navigation[page.section]?.push(entry);
+  }
+}
+
+function buildApi(moduleConfig: ModuleBuildConfig, api: ModuleApiConfig) {
+  const segments = api.path.replace(/^\/+/, "").split("/").filter(Boolean);
+  const sanitizedSegments =
+    segments[0] === "api" ? segments.slice(1) : segments;
+  const routeDir = path.join(appDirectory, "api", ...sanitizedSegments);
+  const filePath = path.join(routeDir, "route.ts");
+  ensureDirectory(routeDir);
+
+  const handler = `${moduleConfig.moduleName}/${api.entryPoint}`;
+  const content = `export { ${api.handlerExport} } from "${handler}";
+`;
+
+  fs.writeFileSync(filePath, content);
+  console.log(`🔌 Generated API route: ${filePath}`);
+}
+
+function dumpNavigation() {
+  const navPath = path.join(appDirectory, "navigation.generated.ts");
+  const content = `export type MenuEntry = { label: string; path: string; module: string; section: string };
+
+export const navigation = ${JSON.stringify(navigation, null, 2)};
+
+export const userMenu = ${JSON.stringify(userMenu, null, 2)};
+`;
+  fs.writeFileSync(navPath, content);
+  console.log(`🧭 Generated navigation metadata: ${navPath}`);
+}
+
+/**
+ * Génère le fichier config/menu.ts à partir des configurations de menu des modules
+ */
+function generateMenuConfig(moduleConfigs: ModuleBuildConfig[]) {
+  const configDir = path.join(projectRoot, "config");
+  ensureDirectory(configDir);
+  
+  const menuPath = path.join(configDir, "menu.ts");
+  
+  // Collecter les menus de tous les modules
+  const publicMenus: ModuleMenuItemConfig[] = [];
+  const authMenus: ModuleMenuItemConfig[] = [];
+  const adminMenus: ModuleMenuItemConfig[] = [];
+  const accountMenus: ModuleMenuItemConfig[] = [];
+  
+  moduleConfigs.forEach((moduleConfig: ModuleBuildConfig) => {
+    if (moduleConfig.menu) {
+      if (moduleConfig.menu.public) {
+        publicMenus.push(...moduleConfig.menu.public);
+      }
+      if (moduleConfig.menu.auth) {
+        authMenus.push(...moduleConfig.menu.auth);
+      }
+      if (moduleConfig.menu.admin) {
+        adminMenus.push(...moduleConfig.menu.admin);
+      }
+      if (moduleConfig.menu.account) {
+        accountMenus.push(...moduleConfig.menu.account);
+      }
+    }
+  });
+  
+  // Trier par ordre
+  const sortByOrder = (a: ModuleMenuItemConfig, b: ModuleMenuItemConfig) => {
+    return (a.order ?? 999) - (b.order ?? 999);
+  };
+  
+  publicMenus.sort(sortByOrder);
+  authMenus.sort(sortByOrder);
+  adminMenus.sort(sortByOrder);
+  accountMenus.sort(sortByOrder);
+  
+  // Générer le contenu du fichier
+  const content = `// Auto-generated menu configuration
+// Generated from module build configs
+
+export interface MenuItem {
+  title: string;
+  description?: string;
+  icon?: string;
+  path: string;
+  order?: number;
+}
+
+export interface MenuConfig {
+  public: MenuItem[];
+  auth: MenuItem[];
+  admin: MenuItem[];
+  account: MenuItem[];
+}
+
+export const menuConfig: MenuConfig = {
+  public: ${JSON.stringify(publicMenus, null, 2)},
+  auth: ${JSON.stringify(authMenus, null, 2)},
+  admin: ${JSON.stringify(adminMenus, null, 2)},
+  account: ${JSON.stringify(accountMenus, null, 2)},
+};
+`;
+  
+  fs.writeFileSync(menuPath, content);
+  console.log(`🍔 Generated menu configuration: ${menuPath}`);
+}
+
+function copyModuleMigrations(moduleConfigs: ModuleBuildConfig[]) {
+  const supabaseMigrationsDir = path.join(projectRoot, "supabase", "migrations");
+  
+  // S'assurer que le dossier migrations existe
+  if (!fs.existsSync(supabaseMigrationsDir)) {
+    ensureDirectory(supabaseMigrationsDir);
+  }
+
+  const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+  
+  // Charger modules.json
+  let modulesConfig: { modules: Array<{ package: string; migrations?: string[] }> } = { modules: [] };
+  if (fs.existsSync(modulesJsonPath)) {
+    modulesConfig = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+  }
+  
+  moduleConfigs.forEach((moduleConfig: ModuleBuildConfig) => {
+    try {
+      const moduleName = moduleConfig.moduleName;
+      const copiedMigrations: string[] = [];
+      
+      // Essayer plusieurs chemins possibles pour trouver le module
+      const possiblePaths = [
+        // Dans node_modules local de l'app
+        path.join(projectRoot, "node_modules", moduleName),
+        // Dans node_modules à la racine du workspace
+        path.join(projectRoot, "..", "..", "node_modules", moduleName),
+        // Directement dans packages/ (pour monorepo)
+        path.join(projectRoot, "..", "..", "packages", moduleName.replace("@lastbrain/", "")),
+      ];
+      
+      let moduleBasePath: string | null = null;
+      
+      for (const possiblePath of possiblePaths) {
+        if (fs.existsSync(possiblePath)) {
+          moduleBasePath = possiblePath;
+          break;
+        }
+      }
+      
+      if (!moduleBasePath) {
+        return;
+      }
+      
+      const moduleMigrationsDir = path.join(moduleBasePath, "supabase", "migrations");
+      
+      if (fs.existsSync(moduleMigrationsDir)) {
+        const migrationFiles = fs.readdirSync(moduleMigrationsDir);
+        
+        migrationFiles.forEach((file) => {
+          if (file.endsWith(".sql")) {
+            const sourcePath = path.join(moduleMigrationsDir, file);
+            const destPath = path.join(supabaseMigrationsDir, file);
+            
+            // Copier seulement si le fichier n'existe pas déjà
+            if (!fs.existsSync(destPath)) {
+              fs.copyFileSync(sourcePath, destPath);
+              console.log(`📦 Copied migration: ${file} from ${moduleName}`);
+            }
+            copiedMigrations.push(file);
+          }
+        });
+      }
+      
+      // Mettre à jour modules.json avec les migrations
+      if (copiedMigrations.length > 0) {
+        const moduleIndex = modulesConfig.modules.findIndex(
+          (m) => m.package === moduleName
+        );
+        
+        if (moduleIndex >= 0) {
+          modulesConfig.modules[moduleIndex].migrations = copiedMigrations;
+        } else {
+          modulesConfig.modules.push({
+            package: moduleName,
+            migrations: copiedMigrations,
+          });
+        }
+      }
+    } catch (error) {
+      console.warn(`⚠️  Could not copy migrations from ${moduleConfig.moduleName}:`, error);
+    }
+  });
+  
+  // Sauvegarder modules.json avec les migrations mises à jour
+  ensureDirectory(path.dirname(modulesJsonPath));
+  fs.writeFileSync(modulesJsonPath, JSON.stringify(modulesConfig, null, 2));
+}
+
+function generateDocsPage(moduleConfigs: ModuleBuildConfig[]) {
+  const docsDir = path.join(appDirectory, "docs");
+  ensureDirectory(docsDir);
+  
+  const docsPagePath = path.join(docsDir, "page.tsx");
+  
+  // Charger tous les modules depuis modules.json (actifs ET inactifs)
+  const modulesJsonPath = path.join(projectRoot, ".lastbrain", "modules.json");
+  let allModules: Array<{ package: string; active: boolean; migrations?: string[] }> = [];
+  
+  if (fs.existsSync(modulesJsonPath)) {
+    try {
+      const modulesData = JSON.parse(fs.readFileSync(modulesJsonPath, "utf-8"));
+      allModules = modulesData.modules || [];
+    } catch (error) {
+      console.error("❌ Error reading modules.json:", error);
+    }
+  }
+  
+  // Générer les imports des composants Doc de chaque module
+  const docImports: string[] = [];
+  const moduleConfigurations: string[] = [];
+  
+  allModules.forEach((moduleEntry) => {
+    const moduleName = moduleEntry.package;
+    const moduleId = moduleName.replace("@lastbrain/module-", "");
+    const docComponentName = `${toPascalCase(moduleId)}ModuleDoc`;
+    
+    // Trouver la config du module pour obtenir la description
+    const moduleConfig = moduleConfigs.find(mc => mc.moduleName === moduleName);
+    const description = moduleConfig ? getModuleDescription(moduleConfig) : "Module non configuré";
+    
+    // Importer le composant Doc seulement pour les modules actifs
+    if (moduleEntry.active) {
+      docImports.push(`import { ${docComponentName} } from "${moduleName}";`);
+    }
+    
+    const config = {
+      id: moduleId,
+      name: `Module ${moduleId.charAt(0).toUpperCase() + moduleId.slice(1)}`,
+      description: description,
+      component: docComponentName,
+      active: moduleEntry.active,
+    };
+    
+    moduleConfigurations.push(`  {
+    id: "${config.id}",
+    name: "${config.name}",
+    description: "${config.description}",
+    ${config.active ? `content: <${config.component} />,` : 'content: null,'}
+    available: ${config.active},
+  }`);
+  });
+  
+  const docsContent = `// Auto-generated docs page with module documentation
+import React from "react";
+import { DocPage } from "@lastbrain/app";
+${docImports.join('\n')}
+
+export default function DocsPage() {
+  const modules = [
+${moduleConfigurations.join(',\n')}
+  ];
+  
+  return <DocPage modules={modules} />;
+}
+`;
+  
+  fs.writeFileSync(docsPagePath, docsContent);
+  console.log(`📚 Generated docs page: ${docsPagePath}`);
+}
+
+function getModuleDescription(moduleConfig: ModuleBuildConfig): string {
+  // Essayer de déduire la description depuis les pages ou retourner une description par défaut
+  if (moduleConfig.pages.length > 0) {
+    return `${moduleConfig.pages.length} page(s), ${moduleConfig.apis.length} API(s)`;
+  }
+  return "Module documentation";
+}
+
+export async function runModuleBuild() {
+  ensureDirectory(appDirectory);
+
+  const moduleConfigs = await loadModuleConfigs();
+  moduleConfigs.forEach((moduleConfig) => {
+    moduleConfig.pages.forEach((page) => buildPage(moduleConfig, page));
+    moduleConfig.apis.forEach((api) => buildApi(moduleConfig, api));
+  });
+
+  dumpNavigation();
+  generateMenuConfig(moduleConfigs);
+  generateDocsPage(moduleConfigs);
+  copyModuleMigrations(moduleConfigs);
+}
+
+runModuleBuild();