route.ts

import { createManualCommissions } from "@/lib/api/commissions/create-manual-commissions";
import { getCommissions } from "@/lib/api/commissions/get-commissions";
import { transformCustomerForCommission } from "@/lib/api/customers/transform-customer";
import { DubApiError } from "@/lib/api/errors";
import { getDefaultProgramIdOrThrow } from "@/lib/api/programs/get-default-program-id-or-throw";
import { parseRequestBody } from "@/lib/api/utils";
import { withWorkspace } from "@/lib/auth";
import {
  CommissionEnrichedSchema,
  createCommissionResponseSchema,
  createManualCommissionBodySchema,
  getCommissionsQuerySchema,
} from "@/lib/zod/schemas/commissions";
import { prisma } from "@dub/prisma";
import { NextResponse } from "next/server";
import * as z from "zod/v4";

// GET /api/commissions - get all commissions for a program
export const GET = withWorkspace(async ({ workspace, searchParams }) => {
  const programId = getDefaultProgramIdOrThrow(workspace);

  const isHoldStatus = searchParams.status === "hold";
  const {
    status: _status,
    fraudEventGroupId,
    type: rawType,
    ...restSearchParams
  } = searchParams;

  let { partnerId, tenantId, ...filters } = getCommissionsQuerySchema.parse(
    isHoldStatus
      ? restSearchParams
      : { ...restSearchParams, status: searchParams.status },
  );

  if (tenantId && !partnerId) {
    const partner = await prisma.programEnrollment.findUnique({
      where: {
        tenantId_programId: {
          tenantId,
          programId,
        },
      },
      select: {
        partnerId: true,
      },
    });

    if (!partner) {
      throw new DubApiError({
        code: "not_found",
        message: `Partner with specified tenantId ${tenantId} not found.`,
      });
    }

    partnerId = partner.partnerId;
  }

  const commissions = await getCommissions({
    ...filters,
    // Pass raw type string (may be comma-separated) for multi-value handling
    ...(rawType && { type: rawType }),
    partnerId,
    programId,
    isHoldStatus,
    ...(fraudEventGroupId && { fraudEventGroupId }),
  });

  return NextResponse.json(
    z.array(CommissionEnrichedSchema).parse(
      commissions.map((c) => ({
        ...c,
        customer: transformCustomerForCommission(c.customer),
        partner: {
          ...c.partner,
          groupId: c.programEnrollment.groupId,
        },
      })),
    ),
  );
});

// POST /api/commissions - create commissions
export const POST = withWorkspace(
  async ({ workspace, session, req }) => {
    const programId = getDefaultProgramIdOrThrow(workspace);

    const body = createManualCommissionBodySchema.parse(
      await parseRequestBody(req),
    );

    console.time("createManualCommissions");

    await createManualCommissions({
      ...body,
      workspace,
      programId,
      user: session.user,
    });

    console.timeEnd("createManualCommissions");

    return NextResponse.json(
      createCommissionResponseSchema.parse({
        success: true,
        message: "Your commissions are being created and will appear shortly.",
      }),
      {
        status: 202,
      },
    );
  },
  {
    requiredPlan: [
      "business",
      "business plus",
      "business extra",
      "business max",
      "advanced",
      "enterprise",
    ],
    requiredRoles: ["owner", "member"],
  },
);