Update src/app/api/generate/video/route.ts

src/app/api/generate/video/route.ts

@@ -1,74 +1,125 @@
 import { NextRequest, NextResponse } from "next/server";
 import ZAI from "z-ai-web-dev-sdk";
 import { db } from "@/lib/db";
+import fs from "fs/promises";
+import path from "path";
 
-const VIDEO_CENSOR_RULES: Record<string, string> = {
-  youtube: "family friendly, no violence, no nudity",
-  tiktok: "age appropriate, no dangerous content",
-  instagram: "community guidelines compliant",
-  general: "safe for work"
-};
+const DOWNLOAD_DIR = path.join(process.cwd(), "download", "videos");
+
+async function ensureDir() {
+  try {
+    await fs.mkdir(DOWNLOAD_DIR, { recursive: true });
+  } catch {}
+}
 
 export async function POST(request: NextRequest) {
   try {
     const body = await request.json();
-    const { prompt, optimizedPrompt, platform = "general", style = "cinematic" } = body;
+    const {
+      prompt,
+      optimizedPrompt,
+      platform = "general",
+      style = "cinematic",
+      duration = "short",
+      aspectRatio = "16:9",
+      saveToDb = true,
+      projectId,
+    } = body;
 
     if (!prompt && !optimizedPrompt) {
-      return NextResponse.json({ success: false, error: "Se requiere un prompt" }, { status: 400 });
+      return NextResponse.json(
+        { success: false, error: "Se requiere un prompt" },
+        { status: 400 }
+      );
     }
 
-    let finalPrompt = optimizedPrompt || prompt;
-    const censorRule = VIDEO_CENSOR_RULES[platform] || VIDEO_CENSOR_RULES.general;
-    finalPrompt = finalPrompt + ", " + censorRule + ", short clip";
+    await ensureDir();
 
-    const contentRecord = await db.content.create({
-      data: {
-        type: "video",
-        title: prompt.substring(0, 50),
-        description: prompt,
-        prompt: prompt,
-        optimizedPrompt: finalPrompt,
-        platform: platform,
-        status: "processing"
-      }
-    });
+    const finalPrompt = optimizedPrompt || prompt;
+
+    // ✅ DB record
+    let contentRecord: any = null;
+    if (saveToDb) {
+      contentRecord = await db.content.create({
+        data: {
+          type: "video",
+          title: (prompt || "").substring(0, 50),
+          description: prompt,
+          prompt: prompt,
+          optimizedPrompt: finalPrompt,
+          platform,
+          status: "processing",
+          projectId: projectId || null,
+          metadata: JSON.stringify({ style, duration, aspectRatio }),
+        },
+      });
+    }
 
     try {
       const zai = await ZAI.create();
-      const response = await zai.videos.generations.create({ prompt: finalPrompt });
-      const videoData = response.data?.[0];
-      if (!videoData) throw new Error("No se recibio video");
 
-      await db.content.update({
-        where: { id: contentRecord.id },
-        data: { status: "completed", filePath: "generated" }
+      // ✅ SDK correcto (sin la S)
+      const response: any = await zai.video.generations.create({
+        prompt: finalPrompt,
       });
 
-      await db.agentTask.create({
-        data: { type: "generate_video", status: "completed", input: prompt, output: "Video generado", completedAt: new Date() }
-      });
+      // ✅ Extraer URL de forma tolerante
+      const videoUrl: string | null =
+        response?.video_url ||
+        response?.url ||
+        response?.data?.[0]?.url ||
+        null;
+
+      if (!videoUrl) {
+        throw new Error("No se recibió video del generador");
+      }
 
-      return NextResponse.json({ success: true, video: { id: contentRecord.id, prompt: finalPrompt, platform, style } });
+      // ✅ actualizar DB
+      if (contentRecord) {
+        await db.content.update({
+          where: { id: contentRecord.id },
+          data: {
+            status: "completed",
+            filePath: videoUrl,
+          },
+        });
+      }
+
+      return NextResponse.json({
+        success: true,
+        video: {
+          id: contentRecord?.id,
+          url: videoUrl,
+          prompt: finalPrompt,
+          platform,
+          style,
+          duration,
+          aspectRatio,
+        },
+      });
     } catch (genError) {
-      await db.content.update({ where: { id: contentRecord.id }, data: { status: "failed" } });
-      return NextResponse.json({ success: false, error: String(genError) }, { status: 500 });
+      console.error("Error generando video:", genError);
+
+      if (contentRecord) {
+        await db.content.update({
+          where: { id: contentRecord.id },
+          data: {
+            status: "failed",
+            metadata: JSON.stringify({ error: String(genError) }),
+          },
+        });
+      }
+
+      return NextResponse.json(
+        { success: false, error: "Error al generar video" },
+        { status: 500 }
+      );
     }
   } catch (error) {
-    return NextResponse.json({ success: false, error: "Error interno" }, { status: 500 });
+    console.error("Error en generate video:", error);
+    return NextResponse.json(
+      { success: false, error: "Error interno" },
+      { status: 500 }
+    );
   }
 }
-
-export async function GET(request: NextRequest) {
-  try {
-    const { searchParams } = new URL(request.url);
-    const platform = searchParams.get("platform");
-    const limit = parseInt(searchParams.get("limit") || "20");
-    const where: Record<string, unknown> = { type: "video" };
-    if (platform) where.platform = platform;
-    const videos = await db.content.findMany({ where, orderBy: { createdAt: "desc" }, take: limit });
-    return NextResponse.json({ success: true, videos, total: videos.length });
-  } catch {
-    return NextResponse.json({ success: false, error: "Error" }, { status: 500 });
-  }
-}