@lastbrain/app 0.1.39 → 0.1.42

package/dist/scripts/module-build.js

@@ -8,6 +8,8 @@ const monorepoRoot = projectRoot.includes("/apps/")
     ? path.resolve(projectRoot, "..", "..")
     : 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"));
 // Charger les modules depuis modules.json
@@ -121,7 +123,9 @@ function buildPage(moduleConfig, page) {
     const modulePrefix = moduleConfig.moduleName
         .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
     let effectivePath = page.path;
@@ -130,13 +134,17 @@ function buildPage(moduleConfig, page) {
         // É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}`);
+            if (isDebugMode) {
+                console.log(`📂 Added module prefix: ${page.path} -> ${effectivePath}`);
+            }
         }
-        else {
+        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}`);
     }
     const segments = effectivePath.replace(/^\/+/, "").split("/").filter(Boolean);
@@ -215,7 +223,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 = {
         label: `Module:${moduleConfig.moduleName} ${page.componentExport}`,
         path: effectivePath,
@@ -238,7 +248,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}`);
+    }
 }
 /**
  * Génère le fichier config/menu.ts à partir des configurations de menu des modules
@@ -247,7 +259,7 @@ function generateMenuConfig(moduleConfigs) {
     const configDir = path.join(projectRoot, "config");
     ensureDirectory(configDir);
     const menuPath = path.join(configDir, "menu.ts");
-    // Collecter les menus de tous les modules
+    // Collecter les menus de tous les modules avec leurs modules sources
     const publicMenus = [];
     const authMenus = [];
     const adminMenus = [];
@@ -255,16 +267,28 @@ function generateMenuConfig(moduleConfigs) {
     moduleConfigs.forEach((moduleConfig) => {
         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,
+                })));
             }
         }
     });
@@ -276,9 +300,45 @@ function generateMenuConfig(moduleConfigs) {
     authMenus.sort(sortByOrder);
     adminMenus.sort(sortByOrder);
     accountMenus.sort(sortByOrder);
+    // Collecter les composants à importer dynamiquement
+    const componentImports = [];
+    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.__componentRef = componentName;
+        }
+    });
+    // Fonction pour préparer les menus avec les composants
+    const prepareMenusForExport = (menus) => {
+        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;
@@ -288,6 +348,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 {
@@ -298,14 +363,16 @@ 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) {
     const supabaseMigrationsDir = path.join(projectRoot, "supabase", "migrations");
@@ -441,7 +508,9 @@ ${moduleConfigurations.join(",\n")}
 }
 `;
     fs.writeFileSync(docsPagePath, docsContent);
-    console.log(`📚 Generated docs page: ${docsPagePath}`);
+    if (isDebugMode) {
+        console.log(`📚 Generated docs page: ${docsPagePath}`);
+    }
 }
 function buildGroupedApi(apis, routePath) {
     const segments = routePath.replace(/^\/+/, "").split("/").filter(Boolean);
@@ -468,7 +537,9 @@ function buildGroupedApi(apis, routePath) {
     const contentWithMarker = `// GENERATED BY LASTBRAIN MODULE BUILD
 ${content}`;
     fs.writeFileSync(filePath, contentWithMarker);
-    console.log(`🔌 Generated API route: ${filePath}`);
+    if (isDebugMode) {
+        console.log(`🔌 Generated API route: ${filePath}`);
+    }
 }
 function getModuleDescription(moduleConfig) {
     // Essayer de déduire la description depuis les pages ou retourner une description par défaut
@@ -523,7 +594,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 {
@@ -541,14 +614,16 @@ function cleanGeneratedFiles() {
                             (content.includes("export {") &&
                                 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}`);
                 }
             }
@@ -568,16 +643,22 @@ 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() {
     const targetPath = path.join(appDirectory, "components", "AppAside.tsx");
     // 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;
     }
     const templateContent = `"use client";
@@ -606,7 +687,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}`);
@@ -633,13 +716,15 @@ 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}`);
     }
     // Générer layout admin avec sidebar
@@ -662,13 +747,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}`);
     }
 }
@@ -707,15 +794,17 @@ export default realtimeConfig;
         }
         // Écrire le fichier TypeScript
         fs.writeFileSync(outputPath, content);
-        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})`);
+        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})`);
+                });
             });
-        });
+        }
     }
     catch (error) {
         console.error("❌ Error generating realtime configuration:", error);
@@ -759,31 +848,303 @@ async function generateUserTabsConfig(moduleConfigs) {
         }
         // Écrire le fichier TypeScript
         fs.writeFileSync(outputPath, appContent);
-        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})`);
-        });
+        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})`);
+            });
+        }
         // Plus de copie vers app/config ni stub core
     }
     catch (error) {
         console.error("❌ Error generating user tabs configuration:", error);
     }
 }
+async function generateBucketsConfig(moduleConfigs) {
+    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) {
+    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 = [];
+        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();
     moduleConfigs.forEach((moduleConfig) => {
         moduleConfig.apis.forEach((api) => {
@@ -804,9 +1165,32 @@ export async function runModuleBuild() {
     generateLayouts();
     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");
+    }
 }

package/dist/scripts/module-list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"module-list.d.ts","sourceRoot":"","sources":["../../src/scripts/module-list.ts"],"names":[],"mappings":"AAQA,wBAAsB,WAAW,CAAC,SAAS,EAAE,MAAM,iBAmClD"}
+{"version":3,"file":"module-list.d.ts","sourceRoot":"","sources":["../../src/scripts/module-list.ts"],"names":[],"mappings":"AAQA,wBAAsB,WAAW,CAAC,SAAS,EAAE,MAAM,iBAwElD"}