@lastbrain/app 0.1.40 → 0.1.43

package/dist/scripts/module-build.js

@@ -259,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 = [];
@@ -267,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,
+                })));
             }
         }
     });
@@ -288,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;
@@ -300,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 {
@@ -310,10 +363,10 @@ 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);
@@ -809,6 +862,310 @@ async function generateUserTabsConfig(moduleConfigs) {
         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);
+    }
+}
+async function generateFooterConfig(moduleConfigs) {
+    try {
+        // Extraire tous les liens footer des modules
+        const allFooterLinks = moduleConfigs
+            .filter((config) => config.footer && config.footer.length > 0)
+            .flatMap((config) => config.footer);
+        if (allFooterLinks.length === 0) {
+            console.log("⏭️ No footer links found, skipping footer config generation");
+            return;
+        }
+        // Trier les liens par position et order
+        allFooterLinks.sort((a, b) => {
+            const posOrder = { left: 0, center: 1, right: 2 };
+            const posA = posOrder[a.position || "left"] || 0;
+            const posB = posOrder[b.position || "left"] || 0;
+            if (posA !== posB)
+                return posA - posB;
+            return (a.order || 0) - (b.order || 0);
+        });
+        const timestamp = new Date().toISOString();
+        const content = `// Auto-generated footer configuration
+// Generated from module build configs
+// Generated at: ${timestamp}
+"use client";
+
+import type { FooterConfig } from "@lastbrain/ui";
+
+export const footerConfig: FooterConfig = {
+  companyName: "LastBrain",
+  companyDescription: "Plateforme de développement rapide d'applications",
+  links: ${JSON.stringify(allFooterLinks, null, 2)},
+  social: [],
+};
+`;
+        const configDir = path.join(projectRoot, "config");
+        ensureDirectory(configDir);
+        const footerPath = path.join(configDir, "footer.ts");
+        fs.writeFileSync(footerPath, content);
+        if (isDebugMode) {
+            console.log(`✅ Generated footer config: ${footerPath}`);
+            console.log(`   - ${allFooterLinks.length} footer link(s)`);
+        }
+    }
+    catch (error) {
+        console.error("❌ Error generating footer config:", error);
+    }
+}
 export async function runModuleBuild() {
     ensureDirectory(appDirectory);
     // Nettoyer les fichiers générés précédemment
@@ -863,6 +1220,21 @@ export async function runModuleBuild() {
         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);
+    // Générer la configuration footer
+    if (isDebugMode) {
+        console.log("🦶 Generating footer configuration...");
+    }
+    await generateFooterConfig(moduleConfigs);
     // Message de succès final
     if (!isDebugMode) {
         console.log("\n✅ Module build completed successfully!");