@lastbrain/app 0.1.40 → 0.1.42

package/src/scripts/module-build.ts

@@ -321,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,
+          })),
+        );
       }
     }
   });
@@ -354,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;
@@ -366,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 {
@@ -376,10 +443,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    ")}],
 };
 `;
 
@@ -987,6 +1054,302 @@ 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);
 
@@ -1056,6 +1419,18 @@ export async function runModuleBuild() {
   }
   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!");