@lastbrain/app 0.1.39 → 0.1.42

package/src/scripts/module-build.ts

@@ -19,6 +19,9 @@ const monorepoRoot = projectRoot.includes("/apps/")
   : projectRoot;
 const appDirectory = path.join(projectRoot, "app");
 
+// Mode debug activé via --debug
+const isDebugMode = process.argv.includes("--debug");
+
 // 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"));
 
@@ -161,7 +164,9 @@ function buildPage(moduleConfig: ModuleBuildConfig, page: ModulePageConfig) {
     .replace(/^@lastbrain\/module-/, "")
     .toLowerCase();
 
-  console.log(`🔄 Building page for module ${modulePrefix}: ${page.path}`);
+  if (isDebugMode) {
+    console.log(`🔄 Building page for module ${modulePrefix}: ${page.path}`);
+  }
 
   // Ajouter le préfixe du module au path pour les sections admin et auth,
   // MAIS seulement quand la section ne correspond PAS au module lui-même
@@ -173,11 +178,17 @@ function buildPage(moduleConfig: ModuleBuildConfig, page: ModulePageConfig) {
     // Éviter les doublons si le préfixe est déjà présent
     if (!page.path.startsWith(`/${modulePrefix}/`)) {
       effectivePath = `/${modulePrefix}${page.path}`;
-      console.log(`📂 Added module prefix: ${page.path} -> ${effectivePath}`);
-    } else {
+      if (isDebugMode) {
+        console.log(`📂 Added module prefix: ${page.path} -> ${effectivePath}`);
+      }
+    } else if (isDebugMode) {
       console.log(`✅ Module prefix already present: ${page.path}`);
     }
-  } else if (page.section === "auth" && modulePrefix === "auth") {
+  } else if (
+    page.section === "auth" &&
+    modulePrefix === "auth" &&
+    isDebugMode
+  ) {
     console.log(
       `🏠 Auth module in auth section, no prefix needed: ${page.path}`,
     );
@@ -270,7 +281,9 @@ export default function ${wrapperName}${hasDynamicParams ? "(props: any)" : "()"
   }
 
   fs.writeFileSync(filePath, content);
-  console.log(`⭐ Generated page: ${filePath}`);
+  if (isDebugMode) {
+    console.log(`⭐ Generated page: ${filePath}`);
+  }
   const entry: MenuEntry = {
     label: `Module:${moduleConfig.moduleName} ${page.componentExport}`,
     path: effectivePath,
@@ -294,7 +307,9 @@ 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}`);
+  if (isDebugMode) {
+    console.log(`🧭 Generated navigation metadata: ${navPath}`);
+  }
 }
 
 /**
@@ -306,25 +321,45 @@ function generateMenuConfig(moduleConfigs: ModuleBuildConfig[]) {
 
   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[] = [];
+  // Collecter les menus de tous les modules avec leurs modules sources
+  const publicMenus: (ModuleMenuItemConfig & { moduleName?: string })[] = [];
+  const authMenus: (ModuleMenuItemConfig & { moduleName?: string })[] = [];
+  const adminMenus: (ModuleMenuItemConfig & { moduleName?: string })[] = [];
+  const accountMenus: (ModuleMenuItemConfig & { moduleName?: string })[] = [];
 
   moduleConfigs.forEach((moduleConfig: ModuleBuildConfig) => {
     if (moduleConfig.menu) {
       if (moduleConfig.menu.public) {
-        publicMenus.push(...moduleConfig.menu.public);
+        publicMenus.push(
+          ...moduleConfig.menu.public.map((item) => ({
+            ...item,
+            moduleName: moduleConfig.moduleName,
+          })),
+        );
       }
       if (moduleConfig.menu.auth) {
-        authMenus.push(...moduleConfig.menu.auth);
+        authMenus.push(
+          ...moduleConfig.menu.auth.map((item) => ({
+            ...item,
+            moduleName: moduleConfig.moduleName,
+          })),
+        );
       }
       if (moduleConfig.menu.admin) {
-        adminMenus.push(...moduleConfig.menu.admin);
+        adminMenus.push(
+          ...moduleConfig.menu.admin.map((item) => ({
+            ...item,
+            moduleName: moduleConfig.moduleName,
+          })),
+        );
       }
       if (moduleConfig.menu.account) {
-        accountMenus.push(...moduleConfig.menu.account);
+        accountMenus.push(
+          ...moduleConfig.menu.account.map((item) => ({
+            ...item,
+            moduleName: moduleConfig.moduleName,
+          })),
+        );
       }
     }
   });
@@ -339,9 +374,51 @@ function generateMenuConfig(moduleConfigs: ModuleBuildConfig[]) {
   adminMenus.sort(sortByOrder);
   accountMenus.sort(sortByOrder);
 
+  // Collecter les composants à importer dynamiquement
+  const componentImports: string[] = [];
+  const allMenus = [
+    ...publicMenus,
+    ...authMenus,
+    ...adminMenus,
+    ...accountMenus,
+  ];
+
+  allMenus.forEach((menu, index) => {
+    if (menu.componentExport && menu.moduleName) {
+      const componentName = `MenuComponent${index}`;
+      componentImports.push(
+        `const ${componentName} = dynamic(() => import("${menu.moduleName}").then(mod => ({ default: mod.${menu.componentExport} })), { ssr: false });`,
+      );
+      // Ajouter une référence au composant
+      (menu as any).__componentRef = componentName;
+    }
+  });
+
+  // Fonction pour préparer les menus avec les composants
+  const prepareMenusForExport = (menus: any[]) => {
+    return menus.map((menu) => {
+      const { moduleName, __componentRef, ...cleanMenu } = menu;
+      if (__componentRef) {
+        // Retourner une référence au composant au lieu de la sérialiser
+        return `{ ...${JSON.stringify(cleanMenu)}, component: ${__componentRef} }`;
+      }
+      return JSON.stringify(cleanMenu);
+    });
+  };
+
+  const publicMenusExport = prepareMenusForExport(publicMenus);
+  const authMenusExport = prepareMenusForExport(authMenus);
+  const adminMenusExport = prepareMenusForExport(adminMenus);
+  const accountMenusExport = prepareMenusForExport(accountMenus);
+
   // Générer le contenu du fichier
   const content = `// Auto-generated menu configuration
 // Generated from module build configs
+"use client";
+
+import dynamic from "next/dynamic";
+
+${componentImports.join("\n")}
 
 export interface MenuItem {
   title: string;
@@ -351,6 +428,11 @@ export interface MenuItem {
   order?: number;
   shortcut?: string;
   shortcutDisplay?: string;
+  type?: 'text' | 'icon' | 'textIcon';
+  position?: 'center' | 'end';
+  component?: React.ComponentType<any>;
+  componentExport?: string;
+  entryPoint?: string;
 }
 
 export interface MenuConfig {
@@ -361,15 +443,17 @@ export interface MenuConfig {
 }
 
 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)},
+  public: [${publicMenusExport.join(",\n    ")}],
+  auth: [${authMenusExport.join(",\n    ")}],
+  admin: [${adminMenusExport.join(",\n    ")}],
+  account: [${accountMenusExport.join(",\n    ")}],
 };
 `;
 
   fs.writeFileSync(menuPath, content);
-  console.log(`🍔 Generated menu configuration: ${menuPath}`);
+  if (isDebugMode) {
+    console.log(`🍔 Generated menu configuration: ${menuPath}`);
+  }
 }
 
 function copyModuleMigrations(moduleConfigs: ModuleBuildConfig[]) {
@@ -557,7 +641,9 @@ ${moduleConfigurations.join(",\n")}
 `;
 
   fs.writeFileSync(docsPagePath, docsContent);
-  console.log(`📚 Generated docs page: ${docsPagePath}`);
+  if (isDebugMode) {
+    console.log(`📚 Generated docs page: ${docsPagePath}`);
+  }
 }
 
 function buildGroupedApi(
@@ -595,7 +681,9 @@ function buildGroupedApi(
 ${content}`;
 
   fs.writeFileSync(filePath, contentWithMarker);
-  console.log(`🔌 Generated API route: ${filePath}`);
+  if (isDebugMode) {
+    console.log(`🔌 Generated API route: ${filePath}`);
+  }
 }
 
 function getModuleDescription(moduleConfig: ModuleBuildConfig): string {
@@ -663,7 +751,9 @@ function cleanGeneratedFiles() {
         try {
           if (!isProtected(itemPath) && fs.readdirSync(itemPath).length === 0) {
             fs.rmdirSync(itemPath);
-            console.log(`🗑️ Removed empty directory: ${itemPath}`);
+            if (isDebugMode) {
+              console.log(`📁 Removed empty directory: ${itemPath}`);
+            }
           }
         } catch {
           // Ignorer les erreurs de suppression de fichiers
@@ -681,12 +771,14 @@ function cleanGeneratedFiles() {
                 content.includes('} from "@lastbrain/module-'))
             ) {
               fs.unlinkSync(itemPath);
-              console.log(`🗑️ Cleaned generated file: ${itemPath}`);
+              if (isDebugMode) {
+                console.log(`🗑️  Removed: ${itemPath}`);
+              }
             }
           } catch {
             // Ignorer les erreurs de lecture/suppression
           }
-        } else {
+        } else if (isDebugMode) {
           console.log(`🔒 Protected file skipped: ${itemPath}`);
         }
       }
@@ -708,11 +800,15 @@ function cleanGeneratedFiles() {
     const filePath = path.join(appDirectory, file);
     if (fs.existsSync(filePath)) {
       fs.unlinkSync(filePath);
-      console.log(`🗑️ Cleaned root file: ${filePath}`);
+      if (isDebugMode) {
+        console.log(`🗑️  Removed: ${filePath}`);
+      }
     }
   });
 
-  console.log("🧹 Cleanup completed");
+  if (isDebugMode) {
+    console.log("🧹 Cleanup completed");
+  }
 }
 
 function generateAppAside() {
@@ -720,7 +816,9 @@ function generateAppAside() {
 
   // Ne pas écraser si le fichier existe déjà
   if (fs.existsSync(targetPath)) {
-    console.log(`⏭️ AppAside already exists, skipping: ${targetPath}`);
+    if (isDebugMode) {
+      console.log(`⏭️ AppAside already exists, skipping: ${targetPath}`);
+    }
     return;
   }
 
@@ -751,7 +849,9 @@ export function AppAside({ className = "", isVisible = true }: AppAsideProps) {
   try {
     ensureDirectory(path.dirname(targetPath));
     fs.writeFileSync(targetPath, templateContent, "utf-8");
-    console.log(`✅ Generated AppAside component: ${targetPath}`);
+    if (isDebugMode) {
+      console.log(`✅ Generated AppAside component: ${targetPath}`);
+    }
   } catch (error) {
     console.error(`❌ Error generating AppAside component: ${error}`);
   }
@@ -779,11 +879,13 @@ export default function SectionLayout({
     try {
       ensureDirectory(path.dirname(authLayoutPath));
       fs.writeFileSync(authLayoutPath, authLayoutContent, "utf-8");
-      console.log(`✅ Generated auth layout with sidebar: ${authLayoutPath}`);
+      if (isDebugMode) {
+        console.log(`✅ Generated auth layout with sidebar: ${authLayoutPath}`);
+      }
     } catch (error) {
       console.error(`❌ Error generating auth layout: ${error}`);
     }
-  } else {
+  } else if (isDebugMode) {
     console.log(`⏭️ Auth layout already exists, skipping: ${authLayoutPath}`);
   }
 
@@ -808,11 +910,15 @@ export default function AdminLayout({
     try {
       ensureDirectory(path.dirname(adminLayoutPath));
       fs.writeFileSync(adminLayoutPath, adminLayoutContent, "utf-8");
-      console.log(`✅ Generated admin layout with sidebar: ${adminLayoutPath}`);
+      if (isDebugMode) {
+        console.log(
+          `✅ Generated admin layout with sidebar: ${adminLayoutPath}`,
+        );
+      }
     } catch (error) {
       console.error(`❌ Error generating admin layout: ${error}`);
     }
-  } else {
+  } else if (isDebugMode) {
     console.log(`⏭️ Admin layout already exists, skipping: ${adminLayoutPath}`);
   }
 }
@@ -860,16 +966,20 @@ export default realtimeConfig;
     // Écrire le fichier TypeScript
     fs.writeFileSync(outputPath, content);
 
-    console.log(`✅ Generated realtime configuration: ${outputPath}`);
-    console.log(`📊 Modules with realtime: ${realtimeConfigs.length}`);
+    if (isDebugMode) {
+      console.log(`✅ Generated realtime configuration: ${outputPath}`);
+      console.log(`📊 Modules with realtime: ${realtimeConfigs.length}`);
 
-    // Afficher un résumé
-    realtimeConfigs.forEach((module) => {
-      console.log(`   - ${module.moduleId}: ${module.tables.length} table(s)`);
-      module.tables.forEach((table) => {
-        console.log(`     • ${table.schema}.${table.table} (${table.event})`);
+      // Afficher un résumé
+      realtimeConfigs.forEach((module) => {
+        console.log(
+          `   - ${module.moduleId}: ${module.tables.length} table(s)`,
+        );
+        module.tables.forEach((table) => {
+          console.log(`     • ${table.schema}.${table.table} (${table.event})`);
+        });
       });
-    });
+    }
   } catch (error) {
     console.error("❌ Error generating realtime configuration:", error);
   }
@@ -928,13 +1038,15 @@ async function generateUserTabsConfig(moduleConfigs: ModuleBuildConfig[]) {
     // Écrire le fichier TypeScript
     fs.writeFileSync(outputPath, appContent);
 
-    console.log(`✅ Generated user tabs configuration: ${outputPath}`);
-    console.log(`📊 User tabs count: ${userTabsConfigs.length}`);
+    if (isDebugMode) {
+      console.log(`✅ Generated user tabs configuration: ${outputPath}`);
+      console.log(`📊 User tabs count: ${userTabsConfigs.length}`);
 
-    // Afficher un résumé
-    userTabsConfigs.forEach((tab) => {
-      console.log(`   - ${tab.title} (${tab.moduleName})`);
-    });
+      // Afficher un résumé
+      userTabsConfigs.forEach((tab) => {
+        console.log(`   - ${tab.title} (${tab.moduleName})`);
+      });
+    }
 
     // Plus de copie vers app/config ni stub core
   } catch (error) {
@@ -942,25 +1054,333 @@ async function generateUserTabsConfig(moduleConfigs: ModuleBuildConfig[]) {
   }
 }
 
+async function generateBucketsConfig(moduleConfigs: ModuleBuildConfig[]) {
+  try {
+    // Extraire les configurations storage des modules
+    const allBuckets = moduleConfigs
+      .filter(
+        (config) =>
+          config.storage?.buckets && config.storage.buckets.length > 0,
+      )
+      .flatMap((config) => config.storage!.buckets);
+
+    if (allBuckets.length === 0) {
+      console.log("⏭️ No storage buckets configuration found in modules");
+      return;
+    }
+
+    // Générer le contenu du fichier
+    const timestamp = new Date().toISOString();
+    const bucketsEntries = allBuckets
+      .map((bucket) => {
+        // Sérialiser customAccessControl si elle existe
+        const customAccessControl = bucket.customAccessControl
+          ? `\n    customAccessControl: ${bucket.customAccessControl.toString()},`
+          : "";
+
+        return `  ${bucket.name}: {
+    name: "${bucket.name}",
+    isPublic: ${bucket.public},
+    description: "${bucket.description || `Storage bucket for ${bucket.name}`}",${bucket.allowedMimeTypes ? `\n    allowedFileTypes: ${JSON.stringify(bucket.allowedMimeTypes)},` : ""}${bucket.maxFileSize ? `\n    maxFileSize: ${bucket.maxFileSize}, // ${bucket.fileSizeLimit || `${Math.round(bucket.maxFileSize / 1024 / 1024)}MB`}` : ""}${customAccessControl}
+  }`;
+      })
+      .join(",\n");
+
+    const content = `/**
+ * Storage configuration for buckets and access control
+ * 
+ * GENERATED FILE - DO NOT EDIT MANUALLY
+ * Generated at: ${timestamp}
+ * Generated from module build configs
+ */ 
+
+export interface BucketConfig {
+  name: string;
+  isPublic: boolean;
+  description: string;
+  allowedFileTypes?: string[];
+  maxFileSize?: number; // in bytes
+  customAccessControl?: (userId: string, filePath: string) => boolean;
+}
+
+export const BUCKET_CONFIGS: Record<string, BucketConfig> = {
+${bucketsEntries}
+};
+
+/**
+ * Get bucket configuration
+ */
+export function getBucketConfig(bucketName: string): BucketConfig | null {
+  return BUCKET_CONFIGS[bucketName] || null;
+}
+
+/**
+ * Check if bucket is public
+ */
+export function isPublicBucket(bucketName: string): boolean {
+  const config = getBucketConfig(bucketName);
+  return config?.isPublic ?? false;
+}
+
+/**
+ * Check if user has access to a specific file
+ */
+export function hasFileAccess(bucketName: string, userId: string, filePath: string): boolean {
+  const config = getBucketConfig(bucketName);
+  if (!config) return false;
+
+  // Public buckets are accessible to everyone
+  if (config.isPublic) return true;
+
+  // Private buckets require authentication
+  if (!userId) return false;
+
+  // Apply custom access control if defined
+  if (config.customAccessControl) {
+    return config.customAccessControl(userId, filePath);
+  }
+
+  return true;
+}
+
+/**
+ * Validate file type for bucket
+ */
+export function isValidFileType(bucketName: string, contentType: string): boolean {
+  const config = getBucketConfig(bucketName);
+  if (!config || !config.allowedFileTypes) return true;
+
+  return config.allowedFileTypes.includes(contentType);
+}
+
+/**
+ * Check if file size is within bucket limits
+ */
+export function isValidFileSize(bucketName: string, fileSize: number): boolean {
+  const config = getBucketConfig(bucketName);
+  if (!config || !config.maxFileSize) return true;
+
+  return fileSize <= config.maxFileSize;
+}
+`;
+
+    // Créer le fichier dans lib/
+    const outputPath = path.join(projectRoot, "lib", "bucket-config.ts");
+    const libDir = path.dirname(outputPath);
+
+    // Créer le dossier lib s'il n'existe pas
+    if (!fs.existsSync(libDir)) {
+      fs.mkdirSync(libDir, { recursive: true });
+    }
+
+    // Écrire le fichier TypeScript
+    fs.writeFileSync(outputPath, content);
+
+    if (isDebugMode) {
+      console.log(`✅ Generated storage buckets configuration: ${outputPath}`);
+      console.log(`📊 Storage buckets count: ${allBuckets.length}`);
+
+      // Afficher un résumé
+      allBuckets.forEach((bucket) => {
+        const access = bucket.public ? "public" : "private";
+        console.log(`   - ${bucket.name} (${access})`);
+      });
+    }
+  } catch (error) {
+    console.error("❌ Error generating buckets configuration:", error);
+  }
+}
+
+async function generateStorageProxyApi(moduleConfigs: ModuleBuildConfig[]) {
+  try {
+    // Extraire les configurations storage des modules
+    const allBuckets = moduleConfigs
+      .filter(
+        (config) =>
+          config.storage?.buckets && config.storage.buckets.length > 0,
+      )
+      .flatMap((config) => config.storage!.buckets);
+
+    if (allBuckets.length === 0) {
+      console.log("⏭️ No storage buckets found, skipping proxy API generation");
+      return;
+    }
+
+    // Identifier les buckets publics et privés
+    const publicBuckets = allBuckets.filter((b) => b.public);
+    const privateBuckets = allBuckets.filter((b) => !b.public);
+
+    // Générer les conditions pour les buckets publics
+    const publicBucketConditions = publicBuckets
+      .map((bucket) => `bucket === "${bucket.name}"`)
+      .filter(Boolean);
+
+    // Ajouter les conditions pour les chemins publics dans les buckets privés
+    const publicPathConditions: string[] = [];
+    if (publicBuckets.some((b) => b.name === "recipes")) {
+      publicPathConditions.push('storagePath.startsWith("recipes/")');
+    }
+
+    const allPublicConditions = [
+      ...publicBucketConditions,
+      ...publicPathConditions,
+    ];
+    const publicCondition =
+      allPublicConditions.length > 0
+        ? allPublicConditions.join(" || ")
+        : "false";
+
+    const timestamp = new Date().toISOString();
+    const content = `import { getSupabaseServerClient } from "@lastbrain/core/server";
+import { NextRequest, NextResponse } from "next/server";
+
+/**
+ * GET /api/storage/[bucket]/[...path]
+ * Proxy pour servir les images avec authentication
+ * 
+ * GENERATED FILE - DO NOT EDIT MANUALLY
+ * Generated at: ${timestamp}
+ * Generated from module storage configurations
+ * 
+ * Buckets configurés:
+${allBuckets.map((b) => ` * - ${b.name} (${b.public ? "public" : "private"})`).join("\n")}
+ */
+export async function GET(
+  request: NextRequest,
+  context: { params: Promise<{ bucket: string; path: string[] }> },
+) {
+  try {
+    const { bucket, path } = await context.params;
+    const storagePath = path.join("/");
+
+    // Les images publiques sont accessibles sans auth
+    if (${publicCondition}) {
+      const supabase = await getSupabaseServerClient();
+      const { data, error } = await supabase.storage
+        .from(bucket)
+        .createSignedUrl(storagePath, 3600); // 1 heure
+
+      if (error) {
+        console.error(\`[storage] Error creating signed URL for public image:\`, error);
+        return new NextResponse("Not found", { status: 404 });
+      }
+
+      // Rediriger vers l'URL signée
+      return NextResponse.redirect(data.signedUrl);
+    }
+
+    // Les images privées nécessitent une authentification
+    const supabase = await getSupabaseServerClient();
+    const {
+      data: { user },
+      error: authError, 
+    } = await supabase.auth.getUser();
+
+    if (authError || !user) {
+      return new NextResponse("Unauthorized", { status: 401 });
+    }
+
+    // Cas spécial: si le chemin commence par /product/ ou /recipe/, 
+    // c'est une image avec format court qui nécessite le préfixe userId
+    let actualStoragePath = storagePath;
+    
+    if (storagePath.startsWith("product/") || storagePath.startsWith("recipe/")) {
+      actualStoragePath = \`\${user.id}/\${storagePath}\`;
+    }
+
+    // Vérifier que l'utilisateur a accès à cette image
+    // Format: {userId}/recipe/{recipeId}/{filename} ou {userId}/product/{productId}/{filename}
+    const pathParts = actualStoragePath.split("/");
+    const pathUserId = pathParts[0];
+
+    if (pathUserId !== user.id) {
+      return new NextResponse("Forbidden", { status: 403 });
+    }
+
+    // Créer une URL signée pour l'image privée
+    const { data, error } = await supabase.storage
+      .from(bucket)
+      .createSignedUrl(actualStoragePath, 3600); // 1 heure
+
+    if (error) {
+      console.error(\`[storage] Error creating signed URL:\`, error);
+      return new NextResponse("Not found", { status: 404 });
+    }
+
+    // Rediriger vers l'URL signée
+    return NextResponse.redirect(data.signedUrl);
+  } catch (error) {
+    console.error("[storage] Error:", error);
+    return new NextResponse("Internal server error", { status: 500 });
+  }
+}
+`;
+
+    // Créer le fichier dans app/api/storage/[bucket]/[...path]/
+    const outputPath = path.join(
+      projectRoot,
+      "app",
+      "api",
+      "storage",
+      "[bucket]",
+      "[...path]",
+      "route.ts",
+    );
+    const outputDir = path.dirname(outputPath);
+
+    // Créer le dossier s'il n'existe pas
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    // Écrire le fichier TypeScript
+    fs.writeFileSync(outputPath, content);
+
+    if (isDebugMode) {
+      console.log(`✅ Generated storage proxy API: ${outputPath}`);
+      console.log(
+        `📊 Public buckets: ${publicBuckets.map((b) => b.name).join(", ") || "none"}`,
+      );
+      console.log(
+        `📊 Private buckets: ${privateBuckets.map((b) => b.name).join(", ") || "none"}`,
+      );
+    }
+  } catch (error) {
+    console.error("❌ Error generating storage proxy API:", error);
+  }
+}
+
 export async function runModuleBuild() {
   ensureDirectory(appDirectory);
 
   // Nettoyer les fichiers générés précédemment
-  console.log("🧹 Cleaning previously generated files...");
+  if (isDebugMode) {
+    console.log("🧹 Cleaning previously generated files...");
+  }
   cleanGeneratedFiles();
 
   const moduleConfigs = await loadModuleConfigs();
-  console.log(`🔍 Loaded ${moduleConfigs.length} module configurations`);
+  if (isDebugMode) {
+    console.log(`🔍 Loaded ${moduleConfigs.length} module configurations`);
+  }
 
   // Générer les pages
+  if (isDebugMode) {
+    console.log("\n📝 Generating pages...");
+  }
   moduleConfigs.forEach((moduleConfig) => {
-    console.log(
-      `📦 Processing module: ${moduleConfig.moduleName} with ${moduleConfig.pages.length} pages`,
-    );
+    if (isDebugMode) {
+      console.log(
+        `📦 Processing module: ${moduleConfig.moduleName} with ${moduleConfig.pages.length} pages`,
+      );
+    }
     moduleConfig.pages.forEach((page) => buildPage(moduleConfig, page));
   });
 
   // Grouper les APIs par chemin pour éviter les écrasements de fichier
+  if (isDebugMode) {
+    console.log("\n🔌 Generating API routes...");
+  }
   const apisByPath = new Map<
     string,
     Array<{ moduleConfig: ModuleBuildConfig; api: ModuleApiConfig }>
@@ -988,10 +1408,35 @@ export async function runModuleBuild() {
   copyModuleMigrations(moduleConfigs);
 
   // Générer la configuration realtime
-  console.log("🔄 Generating realtime configuration...");
+  if (isDebugMode) {
+    console.log("🔄 Generating realtime configuration...");
+  }
   await generateRealtimeConfig(moduleConfigs);
 
   // Générer la configuration des user tabs
-  console.log("📑 Generating user tabs configuration...");
+  if (isDebugMode) {
+    console.log("📑 Generating user tabs configuration...");
+  }
   await generateUserTabsConfig(moduleConfigs);
+
+  // Générer la configuration des buckets storage
+  if (isDebugMode) {
+    console.log("🗄️  Generating storage buckets configuration...");
+  }
+  await generateBucketsConfig(moduleConfigs);
+
+  // Générer le proxy storage API
+  if (isDebugMode) {
+    console.log("🔌 Generating storage proxy API...");
+  }
+  await generateStorageProxyApi(moduleConfigs);
+
+  // Message de succès final
+  if (!isDebugMode) {
+    console.log("\n✅ Module build completed successfully!");
+    console.log(`📦 ${moduleConfigs.length} module(s) processed`);
+    console.log("💡 Use --debug flag for detailed logs\n");
+  } else {
+    console.log("\n✅ Module build completed (debug mode)\n");
+  }
 }