All files / src/app/api/user/affiliate/payouts route.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
export const dynamic = "force-dynamic";

import { NextRequest, NextResponse } from 'next/server';
import { Session } from "next-auth";
import { prisma } from "@/lib/prisma";
import { logger } from "@/lib/logging";
import { affiliateSystem } from "@/lib/affiliate-system";
import {
  withUser,
  withErrorHandling,
  successResponse,
  createdResponse,
  ApiError,
  ApiSuccessResponse,
  ApiErrorResponse } from "@/lib/api";
import { RouteContext } from "@/lib/api/middleware";
import type { AuthenticatedUser } from '@/lib/api/middleware/types';


/**
 * GET /api/user/affiliate/payouts
 * Get current user's affiliate payouts
 */
async function handleGet(
  request: NextRequest,
  _context: RouteContext | undefined,
  _session: Session,
  user: AuthenticatedUser
): Promise<NextResponse<ApiSuccessResponse<unknown> | ApiErrorResponse>> {
  // Get user's affiliate account
  const affiliate = await prisma.affiliate.findUnique({
    where: { userId: user.id }});

  if (!affiliate) {
    throw ApiError.notFound("Affiliate account");
  }

  const { searchParams } = new URL(request.url);
  const page = parseInt(searchParams.get("page") || "1");
  const limit = parseInt(searchParams.get("limit") || "20");
  const status = searchParams.get("status") || "";

  const skip = (page - 1) * limit;

  // Build where clause
  const where: Record<string, unknown> = {
    affiliateId: affiliate.id};

  if (status) {
    where.status = status;
  }

  const [payouts, total] = await Promise.all([
    prisma.affiliatePayout.findMany({
      where,
      skip,
      take: limit,
      orderBy: { requestedAt: "desc" },
      select: {
        id: true,
        amount: true,
        method: true,
        status: true,
        transactionId: true,
        transactionFee: true,
        notes: true,
        requestedAt: true,
        processedAt: true,
        saleIds: true}}),
    prisma.affiliatePayout.count({ where }),
  ]);

  return successResponse({
    payouts,
    pagination: {
      page,
      limit,
      total,
      totalPages: Math.ceil(total / limit)}});
}

/**
 * POST /api/user/affiliate/payouts
 * Request a payout
 */
async function handlePost(
  _request: NextRequest,
  _context: RouteContext | undefined,
  _session: Session,
  user: AuthenticatedUser
): Promise<NextResponse<ApiSuccessResponse<unknown> | ApiErrorResponse>> {
  // Get user's affiliate account
  const affiliate = await prisma.affiliate.findUnique({
    where: { userId: user.id }});

  if (!affiliate) {
    throw ApiError.notFound("Affiliate account");
  }

  if (affiliate.status !== "ACTIVE") {
    throw ApiError.badRequest("Affiliate account is not active");
  }

  const result = await affiliateSystem.requestPayout(affiliate.id);

  if (!result.success) {
    throw ApiError.badRequest(result.error || "Failed to request payout");
  }

  logger.info("Payout requested", {
    category: "API",
    affiliateId: affiliate.id,
    payoutId: result.payoutId});

  return createdResponse({
    payoutId: result.payoutId,
    message: "Payout request submitted successfully"});
}

export const GET = withErrorHandling(withUser(handleGet));
export const POST = withErrorHandling(withUser(handlePost));