Merge pull request #828 from anonfedora/fix/clean-issues-785-771-751-769

features

Author: Emmzyemms

__mocks__/app/store/api.ts

@@ -0,0 +1,113 @@
+/**
+ * Jest mock for app/store/api.ts
+ *
+ * This mock is automatically used by Jest when tests import from ./api.
+ * It provides predictable, deterministic data for testing without making real API calls.
+ */
+
+import type {
+  DashboardStats,
+  RevenuePoint,
+  Project,
+  UserProfile,
+  EarningsBreakdownItem,
+} from "../../../app/store/types";
+
+export async function fetchDashboardFromAPI(): Promise<{
+  stats: DashboardStats;
+  revenueTrend: RevenuePoint[];
+  recentProjects: Project[];
+}> {
+  return {
+    stats: {
+      earnings: {
+        total: "$1,234.56",
+        trend: 12.5,
+        trendLabel: "up",
+      },
+      clips: {
+        total: 42,
+        trend: 8.3,
+        trendLabel: "up",
+      },
+      platforms: {
+        total: 3,
+        trend: 0,
+        trendLabel: "same",
+      },
+    },
+    revenueTrend: [
+      { date: "2024-01-01", amount: 100 },
+      { date: "2024-01-02", amount: 150 },
+      { date: "2024-01-03", amount: 200 },
+    ],
+    recentProjects: [
+      {
+        id: "mock-project-1",
+        title: "Test Project 1",
+        clipsGenerated: 10,
+        status: "completed",
+      },
+      {
+        id: "mock-project-2",
+        title: "Test Project 2",
+        clipsGenerated: 5,
+        status: "processing",
+      },
+    ],
+  };
+}
+
+export async function fetchUserFromAPI(): Promise<UserProfile> {
+  return {
+    id: "mock-user-123",
+    name: "Test User",
+    email: "test@example.com",
+    avatarUrl: null,
+    plan: "free",
+    planUsagePercent: 25,
+    transformQuotaRemaining: 10,
+  };
+}
+
+export async function fetchEarningsFromAPI(): Promise<{
+  totalEarnings: string;
+  totalTrend: number;
+  trendLabel: string;
+  totalFiat: { value: string; change: number };
+  cryptoRevenue: { value: string; change: number };
+  pendingPayouts: { value: string; change: number };
+  breakdown: EarningsBreakdownItem[];
+}> {
+  return {
+    totalEarnings: "$1,234.56",
+    totalTrend: 12.5,
+    trendLabel: "up",
+    totalFiat: { value: "$1,000.00", change: 10 },
+    cryptoRevenue: { value: "50 XLM", change: 15 },
+    pendingPayouts: { value: "$234.56", change: 5 },
+    breakdown: [
+      {
+        id: "earnings-1",
+        label: "TikTok",
+        amount: 500,
+        date: "2024-01-01",
+        platform: "tiktok",
+      },
+      {
+        id: "earnings-2",
+        label: "Instagram",
+        amount: 300,
+        date: "2024-01-02",
+        platform: "instagram",
+      },
+      {
+        id: "earnings-3",
+        label: "YouTube",
+        amount: 434.56,
+        date: "2024-01-03",
+        platform: "youtube",
+      },
+    ],
+  };
+}

app/api/clips/post/route.ts

@@ -1,12 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-
-const ALLOWED_PLATFORMS = ["youtube", "instagram", "tiktok", "twitter"] as const;
-type Platform = (typeof ALLOWED_PLATFORMS)[number];
-
-interface PostClipRequest {
-  clipIds: string[];
-  platforms: string[];
-}
+import { postClipBodySchema } from "../../schemas/index";
 
 function mockUpload(platform: string, clipId: string): { ok: boolean; postId?: string; error?: string } {
   const success = Math.random() > 0.2; // 80% success rate for mock
@@ -17,25 +10,24 @@ function mockUpload(platform: string, clipId: string): { ok: boolean; postId?: s
 }
 
 export async function POST(req: NextRequest) {
-  const body: PostClipRequest = await req.json().catch(() => ({ clipIds: [], platforms: [] }));
-
-  if (!Array.isArray(body.clipIds) || body.clipIds.length === 0) {
-    return NextResponse.json({ error: "clipIds must be a non-empty array" }, { status: 400 });
-  }
-  if (!Array.isArray(body.platforms) || body.platforms.length === 0) {
-    return NextResponse.json({ error: "platforms must be a non-empty array" }, { status: 400 });
+  const rawBody = await req.json().catch(() => ({}));
+
+  // Validate request body with Zod
+  const bodyValidation = postClipBodySchema.safeParse(rawBody);
+  if (!bodyValidation.success) {
+    return NextResponse.json(
+      { error: "Validation failed", issues: bodyValidation.error.issues },
+      { status: 400 }
+    );
   }
 
-  const invalid = body.platforms.filter((p) => !ALLOWED_PLATFORMS.includes(p as Platform));
-  if (invalid.length > 0) {
-    return NextResponse.json({ error: `Invalid platforms: ${invalid.join(", ")}` }, { status: 400 });
-  }
+  const { clipIds, platforms } = bodyValidation.data;
 
   const posted: { clipId: string; platform: string; postId: string; url: string }[] = [];
   const failed: { clipId: string; platform: string; error: string }[] = [];
 
-  for (const clipId of body.clipIds) {
-    for (const platform of body.platforms) {
+  for (const clipId of clipIds) {
+    for (const platform of platforms) {
       const result = mockUpload(platform, clipId);
       if (result.ok && result.postId) {
         posted.push({

app/api/clips/route.ts

@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { auth } from "@/app/lib/auth";
 import { clipsStore } from "./clipsStore";
 import type { ApiResponse } from "../types";
+import { getClipsQuerySchema } from "../schemas/index";
 
 export async function GET(request: NextRequest) {
   const session = await auth();
@@ -10,13 +11,24 @@ export async function GET(request: NextRequest) {
   }
 
   const { searchParams } = new URL(request.url);
-  const page = parseInt(searchParams.get("page") || "1", 10);
-  const pageSize = parseInt(searchParams.get("pageSize") || "20", 10);
-  const status = searchParams.get("status") || "";
-  const style = searchParams.get("style") || "";
-  // Optional filters
-  const viralityParams = searchParams.getAll("virality");
-  const virality = viralityParams.length > 0 ? viralityParams : ["high", "medium", "low"];
+  
+  // Validate query parameters with Zod
+  const queryValidation = getClipsQuerySchema.safeParse({
+    page: searchParams.get("page"),
+    pageSize: searchParams.get("pageSize"),
+    status: searchParams.get("status"),
+    style: searchParams.get("style"),
+    virality: searchParams.getAll("virality"),
+  });
+
+  if (!queryValidation.success) {
+    return NextResponse.json(
+      { error: "Validation failed", issues: queryValidation.error.issues },
+      { status: 400 }
+    );
+  }
+
+  const { page, pageSize, status, style, virality } = queryValidation.data;
 
   // 1. Fetch user's clips
   let userClips = clipsStore.getClipsForUser(session.user.id);

app/api/schemas/billing.schema.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+/**
+ * Request body for POST /api/billing/checkout
+ */
+export const checkoutBodySchema = z.object({
+  planId: z.enum(["pro", "enterprise"]),
+});
+
+/**
+ * Query parameters for GET /api/billing/plans
+ */
+export const getPlansQuerySchema = z.object({
+  annual: z.string().optional().transform((val) => val === "true"),
+});
+
+export type CheckoutBody = z.infer<typeof checkoutBodySchema>;
+export type GetPlansQuery = z.infer<typeof getPlansQuerySchema>;

app/api/schemas/clips.schema.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+
+/**
+ * Query parameters for GET /api/clips
+ */
+export const getClipsQuerySchema = z.object({
+  page: z.string().optional().default("1").transform((val) => parseInt(val, 10)),
+  pageSize: z.string().optional().default("20").transform((val) => parseInt(val, 10)),
+  status: z.string().optional().default(""),
+  style: z.string().optional().default(""),
+  virality: z.array(z.string()).optional().default(["high", "medium", "low"]),
+});
+
+/**
+ * Request body for POST /api/clips/post (post clips to platforms)
+ */
+export const postClipBodySchema = z.object({
+  clipIds: z.array(z.string().min(1)).min(1, "At least one clip ID is required"),
+  platforms: z.array(z.enum(["youtube", "instagram", "tiktok", "twitter"])).min(1, "At least one platform is required"),
+});
+
+/**
+ * Request body for POST /api/clips/mint (mint clip as NFT)
+ */
+export const mintClipBodySchema = z.object({
+  clipId: z.string().min(1, "Clip ID is required"),
+});
+
+/**
+ * Request body for POST /api/clips (create clip)
+ */
+export const createClipBodySchema = z.object({
+  jobId: z.string().min(1, "Job ID is required"),
+  title: z.string().min(1, "Title is required"),
+  style: z.string().optional(),
+  virality: z.enum(["high", "medium", "low"]).optional(),
+});
+
+export type GetClipsQuery = z.infer<typeof getClipsQuerySchema>;
+export type PostClipBody = z.infer<typeof postClipBodySchema>;
+export type MintClipBody = z.infer<typeof mintClipBodySchema>;
+export type CreateClipBody = z.infer<typeof createClipBodySchema>;

app/api/schemas/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Central export point for all API validation schemas
+ * 
+ * This barrel file exports all Zod schemas for use in API routes and tests.
+ * Import from here to get type-safe validation for all API endpoints.
+ */
+
+export * from "./jobs.schema";
+export * from "./clips.schema";
+export * from "./user.schema";
+export * from "./transform.schema";
+export * from "./billing.schema";

app/api/schemas/jobs.schema.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+/**
+ * Job ID validation schema
+ * Accepts UUID (with or without hyphens) or alphanumeric slugs up to 64 chars
+ */
+export const jobIdSchema = z.string().regex(/^[a-zA-Z0-9_-]{1,64}$/, {
+  message: "Invalid job id format. Must be 1-64 alphanumeric characters, underscores, or hyphens.",
+});
+
+/**
+ * Query parameters for GET /api/jobs/[id]
+ */
+export const getJobQuerySchema = z.object({
+  id: jobIdSchema,
+});
+
+/**
+ * Request body for POST /api/jobs/[id] (restart job)
+ */
+export const restartJobBodySchema = z.object({
+  // No body required for restart, just the job ID in the path
+}).optional();
+
+/**
+ * Request body for POST /api/jobs (create job)
+ */
+export const createJobBodySchema = z.object({
+  filename: z.string().min(1, "Filename is required"),
+  contentType: z.string().default("video/mp4"),
+  objectKey: z.string().min(1, "Object key is required"),
+});
+
+export type JobId = z.infer<typeof jobIdSchema>;
+export type GetJobQuery = z.infer<typeof getJobQuerySchema>;
+export type CreateJobBody = z.infer<typeof createJobBodySchema>;

app/api/schemas/transform.schema.ts

@@ -0,0 +1,64 @@
+import { z } from "zod";
+
+/**
+ * Allowed transform styles (sourced from env at runtime)
+ */
+const ALLOWED_STYLES = ["anime", "cinematic", "sketch", "watercolor"] as const;
+
+/**
+ * Anime sub-styles
+ */
+const ANIME_SUB_STYLES = ["shonen", "shojo", "chibi", "mecha", "ghibli-inspired"] as const;
+
+/**
+ * Outline thickness options
+ */
+const OUTLINE_THICKNESSES = ["thin", "medium", "bold"] as const;
+
+/**
+ * Background style options
+ */
+const BACKGROUND_STYLES = ["original", "painted", "cel-shaded"] as const;
+
+/**
+ * Anime transform options - matches the interface in app/lib/animeTransform.ts
+ */
+export const animeTransformOptionsSchema = z.object({
+  subStyle: z.enum(ANIME_SUB_STYLES),
+  colorIntensity: z.number().min(0).max(100),
+  outlineThickness: z.enum(OUTLINE_THICKNESSES),
+  backgroundStyle: z.enum(BACKGROUND_STYLES),
+});
+
+/**
+ * Request body for POST /api/transform
+ */
+export const transformBodySchema = z.object({
+  clipId: z.string().min(1, "Clip ID is required"),
+  style: z.enum(ALLOWED_STYLES),
+  userId: z.string().optional(),
+  transformOptions: animeTransformOptionsSchema.optional(),
+});
+
+/**
+ * Request body for POST /api/transform/batch
+ */
+export const transformBatchBodySchema = z.object({
+  clipIds: z.array(z.string().min(1)).min(1, "At least one clip ID is required"),
+  style: z.enum(ALLOWED_STYLES),
+  transformOptions: animeTransformOptionsSchema.optional(),
+});
+
+/**
+ * Request body for POST /api/transform/preview
+ */
+export const transformPreviewBodySchema = z.object({
+  clipId: z.string().min(1, "Clip ID is required"),
+  style: z.enum(ALLOWED_STYLES),
+  transformOptions: animeTransformOptionsSchema.optional(),
+});
+
+export type AnimeTransformOptions = z.infer<typeof animeTransformOptionsSchema>;
+export type TransformBody = z.infer<typeof transformBodySchema>;
+export type TransformBatchBody = z.infer<typeof transformBatchBodySchema>;
+export type TransformPreviewBody = z.infer<typeof transformPreviewBodySchema>;