Program Marketplace

Copyexport const getPublicNetworkPrograms = cache(
  async (
    params: Partial<z.infer<typeof getPublicNetworkProgramsQuerySchema>> = {},
  ) => {
    const {
      category,
      rewardType,
      featured,
      search,
      sortBy = "popularity",
      sortOrder = "desc",
      page = 1,
      pageSize = PROGRAM_NETWORK_MAX_PAGE_SIZE,
    } = params;
 
    const programs = await prisma.program.findMany({
      where: {
        addedToMarketplaceAt: {
          not: null,
        },
        ...(featured && {
          featuredOnMarketplaceAt: {
            not: null,
          },
        }),
        ...(search && {
          OR: [
            { name: { contains: search } },
            { slug: { contains: search } },
            { domain: { contains: search } },
            { url: { contains: search } },
            { description: { contains: search } },
          ],
        }),
        ...(category && {
          categories: {
            some: {
              category,
            },
          },
        }),
        ...(rewardType && {
          groups: {
            some: {
              slug: DEFAULT_PARTNER_GROUP.slug,
              ...(rewardType === "sale" && {
                saleRewardId: { not: null },
              }),
              ...(rewardType === "lead" && {
                leadRewardId: { not: null },
              }),
              ...(rewardType === "click" && {
                clickRewardId: { not: null },
              }),
              ...(rewardType === "discount" && {
                discountId: { not: null },
              }),
            },
          },
        }),
      },
      include: {
        groups: {
          where: {
            slug: DEFAULT_PARTNER_GROUP.slug,
          },
          include: {
            clickReward: true,
            leadReward: true,
            saleReward: true,
            referralReward: true,
            discount: true,
          },
        },
        categories: true,
      },
      orderBy:
        sortBy === "popularity"
          ? { marketplaceRanking: "asc" }
          : {

Copyexport const getMarketplaceProgramsSummary = cache(async () => {
  const programs = await prisma.program.findMany({
    where: {
      addedToMarketplaceAt: {
        not: null,
      },
    },
    include: programInclude,
  });
 
  const programMeta = programs.map(toProgramMeta);
  const usedIds = new Set<string>();
 
  const selectRow = (
    candidates: ProgramRecord[],
    sortFn: (a: ProgramRecord, b: ProgramRecord) => number,
  ) =>
    selectPrograms(
      candidates,
      usedIds,
      MARKETPLACE_HOME_ROW_PAGE_SIZE,
      sortFn,
    ).map(formatNetworkProgram);
 
  const featuredPrograms = programs
    .filter((program) => program.featuredOnMarketplaceAt)
    .sort(() => Math.random() - 0.5)
    .map(formatNetworkProgram);
 
  const mostPopular = selectRow(programs, byMarketplaceRanking);
  const newPrograms = selectPrograms(
    programs,
    new Set(),
    MARKETPLACE_HOME_ROW_PAGE_SIZE,
    byRecency,
  ).map(formatNetworkProgram);
  const categoryRows = selectCategoryRows(programMeta, usedIds);
 
  const categories = Object.fromEntries(
    Object.values(Category).map((category) => [
      category,
      (categoryRows.get(category) ?? []).map(formatNetworkProgram),
    ]),
  );
 
  return MarketplaceProgramsSummarySchema.parse({
    featuredPrograms,
    mostPopular,
    newPrograms,
    categories,
  });
});

Copyexport async function GET(req: Request) {
  const searchParams = Object.fromEntries(new URL(req.url).searchParams);
  const params = parsePublicMarketplaceQuery(searchParams);
 
  const programs = await getPublicNetworkPrograms(params);
 
  return NextResponse.json(programs);
}

Copyconst payloadSchema = z.object({
  currentProgramId: z
    .string()
    .optional()
    .describe("Current program being compared."),
  comparisonBatchCursor: z
    .string()
    .optional()
    .describe("Cursor for programs to compare against."),
});
 
const PROGRAMS_PER_BATCH = 10;
 
// This route is used to calculate program similarities in the network
// Runs once every 12 hours (0 */12 * * *)
// POST /api/cron/network/calculate-program-similarities
export async function POST(req: Request) {

Copyconst programs = await prisma.program.findMany({
  where: {
    id: {
      gt: currentProgram.id,
    },
    deactivatedAt: null,
    OR: [
      {
        addedToMarketplaceAt: {
          not: null,
        },
      },
      {
        partnerNetworkEnabledAt: {
          not: null,
        },
      },
    ],
  },
  ...(comparisonBatchCursor && {
    cursor: {
      id: comparisonBatchCursor,
    },
  }),
  skip: comparisonBatchCursor ? 1 : 0,
  orderBy: {
    id: "asc",
  },
  take: PROGRAMS_PER_BATCH,
  select: {
    id: true,
    name: true,
  },
});

Copyconst [
  categorySimilarityScore,
  partnerSimilarityScore,
  performanceSimilarityScore,
] = await Promise.all([
  calculateCategorySimilarity(program1.id, program2.id),
  calculatePartnerSimilarity(program1.id, program2.id),
  calculatePerformanceSimilarity(program1.id, program2.id),
]);
 
const similarityScore =
  categorySimilarityScore * 0.5 +
  partnerSimilarityScore * 0.3 +
  performanceSimilarityScore * 0.2;
 

Copyconst similarityScore =
  categorySimilarityScore * 0.5 +
  partnerSimilarityScore * 0.3 +
  performanceSimilarityScore * 0.2;

Copyexport async function calculateCategorySimilarity(
  program1Id: string,
  program2Id: string,
): Promise<number> {
  const [categories1, categories2] = await Promise.all([
    prisma.programCategory.findMany({
      where: {
        programId: program1Id,
      },
      select: {
        category: true,
      },
    }),
 
    prisma.programCategory.findMany({
      where: {
        programId: program2Id,
      },
      select: {
        category: true,
      },
    }),
  ]);
 
  const categories1Set = new Set(categories1.map(({ category }) => category));
  const categories2Set = new Set(categories2.map(({ category }) => category));
 
  const sharedCount = [...categories1Set].filter((c) =>
    categories2Set.has(c),
  ).length;
 
  const totalUniqueCount =
    categories1Set.size + categories2Set.size - sharedCount;
 
  if (totalUniqueCount === 0) {
    return 0;
  }
 
  return sharedCount / totalUniqueCount;
}

Copyconst METRIC_KEYS = [
  "totalClicks",
  "totalLeads",
  "totalConversions",
  "totalSales",
  "totalSaleAmount",
] as const;

Copyexport async function calculatePerformanceSimilarity(
  program1Id: string,
  program2Id: string,
): Promise<number> {
  const [performance1, performance2] = await Promise.all([
    prisma.programEnrollment.aggregate({
      where: {
        programId: program1Id,
      },
      _avg: {
        totalClicks: true,
        totalLeads: true,
        totalSales: true,
        totalConversions: true,
        totalSaleAmount: true,
      },
    }),
 
    prisma.programEnrollment.aggregate({
      where: {
        programId: program2Id,
      },
      _avg: {
        totalClicks: true,
        totalLeads: true,
        totalSales: true,
        totalConversions: true,
        totalSaleAmount: true,
      },
    }),
  ]);
 
  const program1Vector = METRIC_KEYS.map((key) => performance1._avg[key] ?? 0);
  const program2Vector = METRIC_KEYS.map((key) => performance2._avg[key] ?? 0);
 
  const dotProduct = program1Vector.reduce(
    (sum, val, i) => sum + val * program2Vector[i],
    0,
  );
 
  const magnitude1 = Math.sqrt(
    program1Vector.reduce((sum, val) => sum + val ** 2, 0),
  );
 
  const magnitude2 = Math.sqrt(
    program2Vector.reduce((sum, val) => sum + val ** 2, 0),
  );
 
  if (magnitude1 === 0 || magnitude2 === 0) {
    return 0;
  }
 
  return dotProduct / (magnitude1 * magnitude2);
}

Copyconst conditions: Prisma.Sql[] = [
  Prisma.sql`p.networkStatus IN ("approved", "trusted")`,
  Prisma.sql`COALESCE(pe.clickToConversionRate, 0) < 1`,
  Prisma.sql`(dp.ignoredAt IS NULL OR dp.id IS NULL)`,
  Prisma.sql`enrolled.id IS NULL`,
];

Copy* Scoring Breakdown (0-65+ points):
*
* 1. Trusted Partner Bonus (200 points): Top priority boost
*    - Partners with networkStatus = "trusted" get 200 bonus points
*    - This ensures trusted partners appear at the very top
*
* 2. Similarity Score (0-50 points): Performance in similar programs
*    - Sums weighted performance across similar programs (similarityScore > 0.3)
*    - Each program's performance weighted by its similarity score
*    - Partners with more similar programs score higher (capped at 50)
*    - Includes: consistency (20%), conversion rate (10%), LTV (15%), commissions (5%)
*
* 3. Program Match Score (0-15 points): Count of similar programs
*    - Rewards partners enrolled in many similar programs
*    - 2 points per similar program (capped at 15)
*
* Final Score = Trusted Bonus + Similarity + Match (0-265+ points)
*

Copyfunction buildOrderByClause({
  starred,
  sortBy,
  platform,
}: {
  starred?: boolean | null;
  sortBy?: "relevance" | "subscribers";
  platform?: PlatformType;
}) {
  if (starred === true) {
    return Prisma.sql`dp.starredAt DESC`;
  }
 
  if (sortBy === "subscribers" && platform) {
    return Prisma.sql`(
      SELECT COALESCE(MAX(pp_sort.subscribers), 0)
      FROM PartnerPlatform pp_sort
      WHERE pp_sort.partnerId = p.id
        AND pp_sort.type = ${platform}
        AND pp_sort.verifiedAt IS NOT NULL
    ) DESC, p.id ASC`;
  }
 
  return Prisma.sql`finalScore DESC, p.id ASC`;
}

Copyconst verifiedPlatforms = partner.platforms.filter(
  (platform) => platform.verifiedAt !== null,
);
 
// a partner has at most one platform per type, so there is at most one website
const websitePlatform = verifiedPlatforms.find(
  (platform) => platform.type === "website",
);
 
const websiteDomain = websitePlatform
  ? getDomainWithoutWWW(websitePlatform.identifier) ?? null
  : null;
 
const matchConditions: Prisma.PartnerPlatformWhereInput[] = [];
 
for (const platform of verifiedPlatforms) {
  if (platform.type === "website") {
    // website identifiers are full URLs with inconsistent normalization,
    // so match on the domain instead of the exact identifier
    if (websiteDomain) {
      matchConditions.push({
        identifier: {
          contains: websiteDomain,
        },
        type: platform.type,
      });
    }

Copyexport function ProgramMarketplaceSection({ domain }: { domain: string }) {
  return (
    <NavigationMenuLink asChild>
      <Link
        href={createHref("/marketplace", domain, {
          ...NAV_UTM_PARAMS,
          utm_campaign: domain,
          utm_content: "Program Marketplace",
        })}
        className={cn(
          "group relative isolate flex items-center overflow-hidden bg-neutral-50 px-6 py-3 transition-colors duration-75",
          "hover:bg-neutral-100 dark:border-white/[0.15] dark:bg-white/[0.03] dark:hover:bg-white/[0.06]",
        )}
      >
        {/* offset so a horizontal cell edge sits just below the middle of the bar */}
        <Grid
          cellSize={60}
          patternOffset={[-12, -32]}
          className="text-neutral-200/60 [mask-image:linear-gradient(90deg,transparent_20%,black)] dark:text-white/10"
        />

Copyexport async function generateMetadata(props: {
  params: Promise<{ segments?: string[] }>;
}): Promise<Metadata> {
  const { segments = [] } = await props.params;
  const pathname = `/marketplace${segments.length > 0 ? `/${segments.join("/")}` : ""}`;
 
  const currentYear = new Date().getFullYear();
 
  let title = `Best SaaS affiliate programs in ${currentYear}`;
  let description = `Browse and apply to the best SaaS affiliate programs on Dub's Partner Network.`;
  let image = "https://assets.dub.co/og/marketplace.jpg";
 
  if (segments.length === 1 && segments[0] === "all") {
    title = `Top SaaS affiliate programs in ${currentYear}`;
  } else if (
    segments.length === 1 &&
    segments[0] !== "all" &&
    segments[0] !== "popular"
  ) {
    const program = await getNetworkProgram({ slug: segments[0] });
 
    if (program) {
      title = `${program.name} Affiliate Program`;
      description =
        program.description ||
        `Join the ${program.name} affiliate program on Dub's Program Marketplace.`;
      image =
        program.marketplaceHeaderImage ||
        `${APP_DOMAIN}/api/og/program?slug=${program.slug}`;
    }
  } else if (segments.length === 2 && segments[0] === "c") {
    const category = Object.values(Category).find(
      (value) => value.toLowerCase() === segments[1],
    );
 
    if (category) {
      // categoryMeta should always return a value, but just in case
      const categoryMeta = PROGRAM_CATEGORIES_MAP[category];
      const label = categoryMeta?.label ?? category.replaceAll("_", " ");
      title = `Best ${label} SaaS Affiliate Programs in ${currentYear}`;
      description =
        categoryMeta?.listPageDescription ??
        `Browse the best ${label} affiliate programs on Dub's Program Marketplace.`;
      image = `${APP_DOMAIN}/api/og/program/categories?categorySlug=${category.toLowerCase()}`;
    }
  }

Copyexport function MarketplaceHomePage() {
  const { data: summary } = useSWR<MarketplaceProgramsSummary>(
    "/api/network/programs/summary",
    fetcher,
    { revalidateOnFocus: false },
  );
 
  return (
    <div className="flex flex-col gap-10">
      {summary ? (
        <FeaturedPrograms programs={summary.featuredPrograms} />
      ) : (
        <FeaturedProgramsSkeleton />
      )}
      <MarketplaceCategoriesSection />
      {MARKETPLACE_HOME_ROWS.map((row) => (
        <MarketplaceProgramRow
          key={row.key}
          title={row.title}
          viewAllHref={row.viewAllHref}
          showViewAllCard={row.showViewAllCard}
          programs={
            summary
              ? summary.categories[row.key] ?? summary[row.key]
              : undefined
          }
        />
      ))}
    </div>

Copyexport function ProgramMarketplaceBanner() {
  const { partner } = usePartnerProfile();
  const { status, setStatus } = useProgramMarketplacePromo();
 
  return (
    <AnimatePresence>
      {partner && status === "banner" && (
        <motion.div
          initial={{ opacity: 0, height: 0 }}
          animate={{ opacity: 1, height: "auto" }}
          exit={{ opacity: 0, height: 0 }}
          transition={{ duration: 0.2 }}
          className="overflow-hidden"
        >

Copyexport function MarketplaceProgramsListPage() {
  const pathname = usePathname();
  const { getQueryString, searchParamsObj } = useRouterStuff();
 
  const categoryParam = getMarketplaceCategoryFromPathname(pathname);
 
  const queryString = getQueryString(
    categoryParam ? { category: categoryParam } : undefined,
  );
 
  const { data: programsCount, error: countError } = useNetworkProgramsCount({
    query: categoryParam ? { category: categoryParam } : undefined,
  });
 
  const {
    data: programs,
    error,
    isValidating,
  } = useSWR<NetworkProgramProps[]>(
    `/api/network/programs${queryString}`,
    fetcher,
    { revalidateOnFocus: false, keepPreviousData: true },
  );
 
  const { pagination, setPagination } = usePagination(
    PROGRAM_NETWORK_MAX_PAGE_SIZE,
  );
 
  const { activeFilters, onRemoveAll } = useProgramNetworkFilters();
 
  const hasActiveFilters =
    activeFilters.length > 0 || Boolean(searchParamsObj.search);
 
  return (
    <div className="flex flex-col gap-4">
      <MarketplaceListToolbar variant="internal" />
 
      {error || countError ? (
        <div className="text-content-subtle py-12 text-sm">
          Failed to load programs
        </div>
      ) : !programs || programs?.length ? (
        <div>
          <div className="min-h-[300px]">
            {programs ? (
              <MarketplaceProgramGrid
                programs={programs}
                className={cn(isValidating && "opacity-50")}
              />
            ) : (
              <MarketplaceProgramGridSkeleton />
            )}
          </div>
          <div className="sticky bottom-0 mt-4 rounded-b-[inherit] border-t border-neutral-200 bg-white px-3.5 py-2">
            <PaginationControls
              pagination={pagination}
              setPagination={setPagination}
              totalCount={programsCount || 0}
              unit={(p) => `program${p ? "s" : ""}`}
            />
          </div>

Copyexport function FeaturedProgramCard({
  program,
  externalMarketplace = false,
  colorIndex = 0,
}: {
  program: NetworkProgramProps;
  externalMarketplace?: boolean;
  colorIndex?: number;
}) {
  const router = useRouter();
  const rewards = program.rewards;
 
  // Derive the tint from the program's image
  // Fall back to the palette if extraction is blocked
  const { color: accentColor, ready: accentReady } = useImageAccentColor(
    program.marketplaceHeaderImage ?? program.logo,
  );
  const backgroundColor = accentColor ?? getFeaturedCardBackground(colorIndex);
 
  return (
    <article className="relative flex h-full flex-col-reverse gap-4 overflow-hidden rounded-2xl border border-neutral-100 p-2 sm:min-h-[340px] sm:flex-row">

Copyreturn (
  <>
    <ApplicationAnalytics />
    <MarketplaceExternalShell variant="none">
      <MarketplaceProgramDetailsLayout

Copyfunction identityProgramSlug(url: string) {
  try {
    const urlObj = new URL(url);
    const parts = urlObj.pathname.split("/").filter(Boolean);
 
    if (parts.length === 0) {
      return { programSlug: null, isMarketplace: false };
    }
 
    if (parts[0] === "register") {
      return { programSlug: NETWORK_PROGRAM_SLUG, isMarketplace: false };
    }
 
    if (parts[0] === "marketplace") {
      if (parts.length === 1) {
        return { programSlug: null, isMarketplace: true };
      }
 
      if (parts[1] === "c") {
        return { programSlug: null, isMarketplace: true };
      }
 
      if (parts.length === 2) {
        if (MARKETPLACE_RESERVED_SLUGS.has(parts[1])) {
          return { programSlug: null, isMarketplace: true };
        }
 
        return {
          programSlug: parts[1].toLowerCase(),
          isMarketplace: true,
        };
      }
 
      return { programSlug: null, isMarketplace: true };
    }
 
    if (parts[0] === "programs" && parts[1] === "marketplace") {
      if (!parts[2] || MARKETPLACE_RESERVED_SLUGS.has(parts[2])) {
        return { programSlug: null, isMarketplace: false };
      }
 
      return {
        programSlug: parts[2].toLowerCase(),
        isMarketplace: true,
      };
    }
 
    if (parts[0] === "programs") {
      if (!parts[1]) {
        return { programSlug: null, isMarketplace: false };
      }
 
      return {
        programSlug: parts[1].toLowerCase(),
        isMarketplace: false,
      };
    }
 
    return {
      programSlug: parts[0].toLowerCase(),
      isMarketplace: false,
    };

Copyconst MAX_MARKETPLACE_RANKING = 2147483647;
 
type MarketplaceProgram = {
  id: string;
  name: string;
  slug: string;
  logo: string | null;
  url: string | null;
  description: string | null;
  addedToMarketplaceAt: string | Date;
  marketplaceRanking: number;
  categories: Category[];
};
 

Copyconst filters = useMemo(
  () => [
    {
      key: "plan",
      icon: CreditCard,
      label: "Plan",
      singleSelect: true,
      options: plans.map((value) => ({
        value,
        label: capitalize(value) ?? value,
      })),
    },
  ],
  [],
);

Copyif (PARTNERS_HOSTNAMES.has(domain)) {
  const programs = await prisma.program.findMany({
    where: {
      groups: {
        some: {
          slug: "default",
          landerData: {
            not: Prisma.AnyNull,
          },
          landerPublishedAt: {
            not: null,
          },
        },
      },
    },
    orderBy: {
      slug: "asc",
    },
  });
 
  return programs.map((program) => ({
    url: `https://partners.dub.co/${program.slug}`,
    lastModified: new Date(),
  }));
}

Copyexport async function GET(req: NextRequest) {
  const categorySlug = req.nextUrl.searchParams.get("categorySlug");
 
  if (!categorySlug) {
    return new Response("Missing 'categorySlug' parameter", {
      status: 400,
    });
  }
 
  const category = PROGRAM_CATEGORIES.find(
    ({ id }) => id.toLowerCase() === categorySlug.toLowerCase(),
  );
 
  if (!category) {
    return new Response("Category not found", {
      status: 404,
    });
  }

Copyconst data = await redis.get<{ domain: string; userId: string }>(
  `onboarding-domain:${workspace.id}`,
);
 
const onboardingDomain =
  data && data.domain && data.userId === user.id ? data.domain : null;
 
const domain = onboardingDomain || workspace.domains[0]?.slug;
 
if (!domain)
  redirect(`/onboarding/domain?workspace=${slug}&product=partners`);
 

Copyconst EXAMPLE_PARTNERS = [
  {
    name: "Lauren Anderson",
    country: "US",
    revenue: 1_800,
    payouts: 550,
    index: 0,
  },
  {
    name: "Elias Weber",
    country: "DE",
    revenue: 783,
    payouts: 235,
    index: 4,
  },
  {
    name: "Hiroshi Tanaka",
    country: "JP",
    revenue: 19_200,
    payouts: 5_700,
    index: 3,
  },
  {
    name: "Mia Taylor",
    country: "US",
    revenue: 22_600,
    payouts: 6_800,
    index: 1,
  },
];