@lastbrain/app 0.1.40 → 0.1.42

package/dist/hooks/useNotifications.d.ts

@@ -3,6 +3,7 @@ export interface UserNotification {
     id: string;
     owner_id: string;
     title: string;
+    message: string;
     body?: string;
     type: string;
     read: boolean;

package/dist/hooks/useNotifications.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useNotifications.d.ts","sourceRoot":"","sources":["../../src/hooks/useNotifications.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,gBAAgB,EAAE,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI;;;;;iCAwExB,MAAM;;yCAiEN,MAAM;;;;;EAwDhC"}
+{"version":3,"file":"useNotifications.d.ts","sourceRoot":"","sources":["../../src/hooks/useNotifications.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,aAAa,EAAE,gBAAgB,EAAE,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,gBAAgB,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,IAAI;;;;;iCAwExB,MAAM;;yCAiEN,MAAM;;;;;EAwDhC"}

package/dist/layouts/PublicLayout.js

@@ -1,5 +1,5 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 export function PublicLayout({ children }) {
-    return _jsx("section", { className: "pt-16  px-2 md:px-0 ", children: children });
+    return _jsx("section", { className: "pt-16  ", children: children });
 }

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

@@ -1 +1 @@
-{"version":3,"file":"module-add.d.ts","sourceRoot":"","sources":["../../src/scripts/module-add.ts"],"names":[],"mappings":"AAiCA,wBAAsB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,iBA6VpE"}
+{"version":3,"file":"module-add.d.ts","sourceRoot":"","sources":["../../src/scripts/module-add.ts"],"names":[],"mappings":"AAiCA,wBAAsB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,iBA+SpE"}

package/dist/scripts/module-add.js

@@ -145,62 +145,32 @@ export async function addModule(moduleName, targetDir) {
             }
             else if (migrationAction === "push") {
                 console.log(chalk.yellow("\n⬆️  Application des nouvelles migrations..."));
-                try {
-                    // Essayer en capturant la sortie pour diagnostiquer les erreurs fréquentes
-                    execSync("supabase migration up --local", {
-                        cwd: targetDir,
-                        stdio: "pipe",
-                    });
-                    console.log(chalk.green("✓ Migrations appliquées"));
+                // Appliquer directement avec psql au lieu de supabase migration up
+                const migrationsDir = path.join(targetDir, "supabase", "migrations");
+                const migrationFiles = fs
+                    .readdirSync(migrationsDir)
+                    .filter((f) => f.endsWith(".sql"))
+                    .filter((f) => copiedMigrationFiles.includes(f))
+                    .sort();
+                if (migrationFiles.length === 0) {
+                    console.log(chalk.yellow("⚠️  Aucune nouvelle migration à appliquer"));
                 }
-                catch (error) {
-                    const output = String(error?.stderr || error?.stdout || error?.message || "");
-                    const mismatch = output.includes("Remote migration versions not found in local migrations directory");
-                    if (mismatch) {
-                        console.warn(chalk.yellow("⚠️  Historique des migrations désynchronisé."));
-                        // Extraire TOUTES les dates de migration depuis le message d'erreur
-                        const repairMatch = output.match(/supabase migration repair --status reverted ([\s\S]+?)\n/);
-                        let migrationDates = [];
-                        if (repairMatch && repairMatch[1]) {
-                            // Extraire toutes les dates de la commande suggérée
-                            migrationDates = repairMatch[1].trim().split(/\s+/);
-                        }
-                        else {
-                            // Fallback: chercher toutes les dates dans le message
-                            const allDates = output.match(/20\d{6,14}/g);
-                            migrationDates = allDates ? [...new Set(allDates)] : [];
-                        }
-                        if (migrationDates.length === 0) {
-                            console.error(chalk.red("❌ Impossible d'extraire les dates de migration"));
-                            console.log(chalk.gray("\nFaites un reset complet:\n  supabase db reset\n"));
-                        }
-                        else {
-                            // Réparation automatique de l'historique
-                            const datesStr = migrationDates.join(" ");
-                            console.log(chalk.yellow(`\n🔧 Réparation automatique de l'historique...`));
-                            console.log(chalk.gray(`   Dates: ${datesStr}`));
-                            try {
-                                execSync(`supabase migration repair --status reverted ${datesStr} --local`, {
-                                    cwd: targetDir,
-                                    stdio: "inherit",
-                                });
-                                console.log(chalk.green("✓ Historique réparé"));
-                                console.log(chalk.yellow("\n⬆️  Application des nouvelles migrations..."));
-                                execSync("supabase migration up --local", {
-                                    cwd: targetDir,
-                                    stdio: "inherit",
-                                });
-                                console.log(chalk.green("✓ Migrations appliquées"));
-                            }
-                            catch (e) {
-                                console.error(chalk.red("❌ Échec de la réparation automatique"));
-                                console.log(chalk.gray(`\nVous pouvez essayer manuellement:\n  supabase migration repair --status reverted ${datesStr} --local\n  supabase migration up --local`));
-                                console.log(chalk.gray(`\nOu faire un reset complet:\n  supabase db reset\n`));
-                            }
+                else {
+                    try {
+                        const dbUrl = "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
+                        for (const file of migrationFiles) {
+                            const filePath = path.join(migrationsDir, file);
+                            console.log(chalk.gray(`   Exécution de ${file}...`));
+                            execSync(`psql "${dbUrl}" -f "${filePath}"`, {
+                                cwd: targetDir,
+                                stdio: "pipe",
+                            });
                         }
+                        console.log(chalk.green(`✓ ${migrationFiles.length} migration(s) appliquée(s)`));
                     }
-                    else {
+                    catch (error) {
                         console.error(chalk.red("❌ Erreur lors de l'application des migrations"));
+                        console.log(chalk.gray("\nVous pouvez essayer manuellement:\n  supabase db reset\n"));
                     }
                 }
             }

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

@@ -1 +1 @@
-{"version":3,"file":"module-build.d.ts","sourceRoot":"","sources":["../../src/scripts/module-build.ts"],"names":[],"mappings":"AA69BA,wBAAsB,cAAc,kBA6EnC"}
+{"version":3,"file":"module-build.d.ts","sourceRoot":"","sources":["../../src/scripts/module-build.ts"],"names":[],"mappings":"AAw0CA,wBAAsB,cAAc,kBAyFnC"}

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,264 @@ 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);
+    }
+}
 export async function runModuleBuild() {
     ensureDirectory(appDirectory);
     // Nettoyer les fichiers générés précédemment
@@ -863,6 +1174,16 @@ 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);
     // Message de succès final
     if (!isDebugMode) {
         console.log("\n✅ Module build completed successfully!");