Skip to content

armgit / dub

Public Imported from GitHub
0

The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.

Add more filters to Partner Network (#3366)

Steven Tey0916ee406cb0
diff --git a/apps/web/app/(ee)/api/network/partners/count/route.ts b/apps/web/app/(ee)/api/network/partners/count/route.ts
index a08098cf1e..1adcf05614 100644
--- a/apps/web/app/(ee)/api/network/partners/count/route.ts
+++ b/apps/web/app/(ee)/api/network/partners/count/route.ts
@@ -3,7 +3,7 @@ import { getDefaultProgramIdOrThrow } from "@/lib/api/programs/get-default-progr
import { withWorkspace } from "@/lib/auth";
import { getNetworkPartnersCountQuerySchema } from "@/lib/zod/schemas/partner-network";
import { prisma } from "@dub/prisma";
-import { Prisma } from "@dub/prisma/client";
+import { PlatformType, Prisma } from "@dub/prisma/client";
import { NextResponse } from "next/server";
// GET /api/network/partners/count - get the number of available partners in the network
@@ -27,8 +27,36 @@ export const GET = withWorkspace(
});
}
- const { partnerIds, status, groupBy, country, starred } =
- getNetworkPartnersCountQuerySchema.parse(searchParams);
+ const {
+ partnerIds,
+ status,
+ groupBy,
+ country,
+ starred,
+ platform,
+ subscribers,
+ } = getNetworkPartnersCountQuerySchema.parse(searchParams);
+
+ // Build platform filter - combine platform type and subscribers if both are set
+ const platformFilter: Prisma.PartnerPlatformWhereInput | undefined =
+ platform || subscribers
+ ? {
+ verifiedAt: { not: null },
+ ...(platform && { type: platform }),
+ ...(subscribers === "<5000" && {
+ subscribers: { lt: 5000 },
+ }),
+ ...(subscribers === "5000-25000" && {
+ subscribers: { gte: 5000, lt: 25000 },
+ }),
+ ...(subscribers === "25000-100000" && {
+ subscribers: { gte: 25000, lt: 100000 },
+ }),
+ ...(subscribers === "100000+" && {
+ subscribers: { gte: 100000 },
+ }),
+ }
+ : undefined;
const commonWhere: Prisma.PartnerWhereInput = {
discoverableAt: { not: null },
@@ -38,6 +66,11 @@ export const GET = withWorkspace(
...(country && {
country,
}),
+ ...(platformFilter && {
+ platforms: {
+ some: platformFilter,
+ },
+ }),
};
const statusWheres = {
@@ -131,6 +164,106 @@ export const GET = withWorkspace(
});
return NextResponse.json(countries);
+ } else if (groupBy === "platform") {
+ // Build platform filter for PartnerPlatform
+ const platformPlatformFilter: Prisma.PartnerPlatformWhereInput = {
+ verifiedAt: { not: null },
+ ...(subscribers === "<5000" && {
+ subscribers: { lt: 5000 },
+ }),
+ ...(subscribers === "5000-25000" && {
+ subscribers: { gte: 5000, lt: 25000 },
+ }),
+ ...(subscribers === "25000-100000" && {
+ subscribers: { gte: 25000, lt: 100000 },
+ }),
+ ...(subscribers === "100000+" && {
+ subscribers: { gte: 100000 },
+ }),
+ };
+
+ // Build partner where clause combining all filters
+ const partnerWhere: Prisma.PartnerWhereInput = {
+ ...commonWhere,
+ ...statusWheres[status || "discover"],
+ platforms: {
+ some: platformPlatformFilter,
+ },
+ };
+
+ // Get all partners matching the criteria with their platforms
+ const partners = await prisma.partner.findMany({
+ where: partnerWhere,
+ select: {
+ id: true,
+ platforms: {
+ where: platformPlatformFilter,
+ select: {
+ type: true,
+ },
+ },
+ },
+ });
+
+ // Group by platform type and count distinct partners
+ const platformCountsMap = new Map<PlatformType, Set<string>>();
+
+ for (const partner of partners) {
+ for (const platform of partner.platforms) {
+ if (!platformCountsMap.has(platform.type)) {
+ platformCountsMap.set(platform.type, new Set());
+ }
+ platformCountsMap.get(platform.type)!.add(partner.id);
+ }
+ }
+
+ const platformCounts = Array.from(platformCountsMap.entries())
+ .map(([type, partnerIds]) => ({
+ platform: type,
+ _count: partnerIds.size,
+ }))
+ .sort((a, b) => b._count - a._count);
+
+ return NextResponse.json(platformCounts);
+ } else if (groupBy === "subscribers") {
+ // Get counts by subscriber ranges (only verified platforms)
+ const subscriberRanges = [
+ { label: "<5000", min: 0, max: 4999 },
+ { label: "5000-25000", min: 5000, max: 24999 },
+ { label: "25000-100000", min: 25000, max: 99999 },
+ { label: "100000+", min: 100000, max: null },
+ ];
+
+ const subscriberCounts = await Promise.all(
+ subscriberRanges.map(async (range) => {
+ const where: Prisma.PartnerWhereInput = {
+ ...commonWhere,
+ ...statusWheres[status || "discover"],
+ platforms: {
+ some: {
+ verifiedAt: { not: null },
+ ...(range.max !== null
+ ? {
+ subscribers: { gte: range.min, lt: range.max + 1 },
+ }
+ : {
+ subscribers: { gte: range.min },
+ }),
+ ...(platform && { type: platform }),
+ },
+ },
+ };
+
+ const count = await prisma.partner.count({ where });
+
+ return {
+ subscribers: range.label,
+ _count: count,
+ };
+ }),
+ );
+
+ return NextResponse.json(subscriberCounts);
}
throw new Error("Invalid groupBy");
diff --git a/apps/web/app/(ee)/api/network/partners/route.ts b/apps/web/app/(ee)/api/network/partners/route.ts
index 56b0632af1..d4c52893b7 100644
--- a/apps/web/app/(ee)/api/network/partners/route.ts
+++ b/apps/web/app/(ee)/api/network/partners/route.ts
@@ -44,8 +44,16 @@ export const GET = withWorkspace(
});
}
- const { partnerIds, status, page, pageSize, country, starred } =
- getNetworkPartnersQuerySchema.parse(searchParams);
+ const {
+ partnerIds,
+ status,
+ page,
+ pageSize,
+ country,
+ starred,
+ platform,
+ subscribers,
+ } = getNetworkPartnersQuerySchema.parse(searchParams);
const similarPrograms = program.similarPrograms.map((sp) => ({
programId: sp.similarProgramId,
@@ -61,6 +69,8 @@ export const GET = withWorkspace(
page,
pageSize,
starred: starred ?? undefined,
+ platform: platform ?? undefined,
+ subscribers: subscribers ?? undefined,
similarPrograms,
});
console.timeEnd("calculatePartnerRanking");
diff --git a/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/network/use-partner-network-filters.tsx b/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/network/use-partner-network-filters.tsx
index 89a8e9a89b..4e5c5531ba 100644
--- a/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/network/use-partner-network-filters.tsx
+++ b/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/network/use-partner-network-filters.tsx
@@ -1,6 +1,15 @@
import useNetworkPartnersCount from "@/lib/swr/use-network-partners-count";
+import { PlatformType } from "@dub/prisma/client";
import { useRouterStuff } from "@dub/ui";
-import { FlagWavy } from "@dub/ui/icons";
+import {
+ FlagWavy,
+ Instagram,
+ Megaphone,
+ ShieldCheck,
+ TikTok,
+ Twitter,
+ YouTube,
+} from "@dub/ui/icons";
import { COUNTRIES, nFormatter } from "@dub/utils";
import { useCallback, useMemo } from "react";
@@ -25,12 +34,58 @@ export function usePartnerNetworkFilters({
excludeParams: ["country"],
});
+ const { data: platformsCount } = useNetworkPartnersCount<
+ | {
+ platform: PlatformType;
+ _count: number;
+ }[]
+ | undefined
+ >({
+ query: {
+ status,
+ groupBy: "platform",
+ },
+ excludeParams: ["platform"],
+ });
+
+ const { data: subscribersCount } = useNetworkPartnersCount<
+ | {
+ subscribers: string;
+ _count: number;
+ }[]
+ | undefined
+ >({
+ query: {
+ status,
+ groupBy: "subscribers",
+ },
+ excludeParams: ["subscribers"],
+ });
+
+ const platformIcons: Record<PlatformType, typeof YouTube> = {
+ youtube: YouTube,
+ twitter: Twitter,
+ instagram: Instagram,
+ tiktok: TikTok,
+ linkedin: Twitter, // fallback
+ website: FlagWavy, // fallback
+ };
+
+ const platformLabels: Record<PlatformType, string> = {
+ youtube: "YouTube",
+ twitter: "X",
+ instagram: "Instagram",
+ tiktok: "TikTok",
+ linkedin: "LinkedIn",
+ website: "Website",
+ };
+
const filters = useMemo(
() => [
{
key: "country",
icon: FlagWavy,
- label: "Location",
+ label: "Partner country",
getOptionIcon: (value) => (
<img
alt={value}
@@ -48,14 +103,62 @@ export function usePartnerNetworkFilters({
right: nFormatter(_count, { full: true }),
})) ?? [],
},
+ {
+ key: "platform",
+ icon: ShieldCheck,
+ label: "Verified social platform",
+ getOptionIcon: (value: PlatformType) => {
+ const Icon = platformIcons[value] || YouTube;
+ return <Icon className="size-4" />;
+ },
+ getOptionLabel: (value: PlatformType) => platformLabels[value] || value,
+ options:
+ platformsCount
+ ?.filter(({ platform }) =>
+ ["youtube", "twitter", "instagram", "tiktok"].includes(platform),
+ )
+ .map(({ platform, _count }) => ({
+ value: platform,
+ label: platformLabels[platform] || platform,
+ right: nFormatter(_count, { full: true }),
+ })) ?? [],
+ },
+ {
+ key: "subscribers",
+ icon: Megaphone,
+ label: "Verified subscriber count",
+ getOptionIcon: () => <Megaphone className="size-4" />,
+ getOptionLabel: (value: string) => {
+ const labels: Record<string, string> = {
+ "<5000": "< 5,000",
+ "5000-25000": "5,000 - 25,000",
+ "25000-100000": "25,000 - 100,000",
+ "100000+": "100,000+",
+ };
+ return labels[value] || value;
+ },
+ options:
+ subscribersCount?.map(({ subscribers, _count }) => ({
+ value: subscribers,
+ label:
+ subscribers === "<5000"
+ ? "< 5,000"
+ : subscribers === "5000-25000"
+ ? "5,000 - 25,000"
+ : subscribers === "25000-100000"
+ ? "25,000 - 100,000"
+ : "100,000+",
+ right: nFormatter(_count, { full: true }),
+ })) ?? [],
+ },
],
- [countriesCount],
+ [countriesCount, platformsCount, subscribersCount],
);
const multiFilters = useMemo(() => ({}), []) as Record<string, string[]>;
const activeFilters = useMemo(() => {
- const { country } = searchParamsObj;
+ const { country, platform, subscribers } = searchParamsObj;
return [
...Object.entries(multiFilters)
@@ -63,6 +166,8 @@ export function usePartnerNetworkFilters({
.filter(({ value }) => value.length > 0),
...(country ? [{ key: "country", value: country }] : []),
+ ...(platform ? [{ key: "platform", value: platform }] : []),
+ ...(subscribers ? [{ key: "subscribers", value: subscribers }] : []),
];
}, [searchParamsObj, multiFilters]);
@@ -105,7 +210,7 @@ export function usePartnerNetworkFilters({
const onRemoveAll = useCallback(
() =>
queryParams({
- del: ["country", "starred"],
+ del: ["country", "starred", "platform", "subscribers"],
}),
[queryParams],
);
diff --git a/apps/web/lib/api/network/calculate-partner-ranking.ts b/apps/web/lib/api/network/calculate-partner-ranking.ts
index 5bbff2bbf8..d7d2a07f42 100644
--- a/apps/web/lib/api/network/calculate-partner-ranking.ts
+++ b/apps/web/lib/api/network/calculate-partner-ranking.ts
@@ -1,18 +1,13 @@
+import { getNetworkPartnersQuerySchema } from "@/lib/zod/schemas/partner-network";
import { prisma } from "@dub/prisma";
import { Prisma } from "@dub/prisma/client";
import { ACME_PROGRAM_ID } from "@dub/utils";
+import * as z from "zod/v4";
-export interface PartnerRankingFilters {
- partnerIds?: string[];
- status?: "discover" | "invited" | "recruited";
- country?: string;
- starred?: boolean;
-}
+type PartnerRankingFilters = z.infer<typeof getNetworkPartnersQuerySchema>;
export interface PartnerRankingParams extends PartnerRankingFilters {
programId: string;
- page: number;
- pageSize: number;
similarPrograms?: Array<{ programId: string; similarityScore: number }>;
}
@@ -50,6 +45,8 @@ export async function calculatePartnerRanking({
partnerIds,
country,
starred,
+ platform,
+ subscribers,
page,
pageSize,
status = "discover",
@@ -69,6 +66,48 @@ export async function calculatePartnerRanking({
conditions.push(Prisma.sql`p.country = ${country}`);
}
+ // Filter by platform type and/or subscriber count (must have verified platform)
+ // Combine both filters into a single EXISTS clause so they apply to the same platform
+ if (platform || subscribers) {
+ const platformConditions: Prisma.Sql[] = [
+ Prisma.sql`pp_filter.partnerId = p.id`,
+ Prisma.sql`pp_filter.verifiedAt IS NOT NULL`,
+ ];
+
+ if (platform) {
+ platformConditions.push(Prisma.sql`pp_filter.type = ${platform}`);
+ }
+
+ if (subscribers) {
+ switch (subscribers) {
+ case "<5000":
+ platformConditions.push(Prisma.sql`pp_filter.subscribers < 5000`);
+ break;
+ case "5000-25000":
+ platformConditions.push(
+ Prisma.sql`pp_filter.subscribers >= 5000 AND pp_filter.subscribers < 25000`,
+ );
+ break;
+ case "25000-100000":
+ platformConditions.push(
+ Prisma.sql`pp_filter.subscribers >= 25000 AND pp_filter.subscribers < 100000`,
+ );
+ break;
+ case "100000+":
+ platformConditions.push(Prisma.sql`pp_filter.subscribers >= 100000`);
+ break;
+ }
+ }
+
+ conditions.push(
+ Prisma.sql`EXISTS (
+ SELECT 1
+ FROM PartnerPlatform pp_filter
+ WHERE ${Prisma.join(platformConditions, " AND ")}
+ )`,
+ );
+ }
+
if (status === "discover") {
conditions.push(Prisma.sql`enrolled.id IS NULL`);
} else if (status === "invited") {
diff --git a/apps/web/lib/zod/schemas/partner-network.ts b/apps/web/lib/zod/schemas/partner-network.ts
index d39ab158d1..c3b1f82370 100644
--- a/apps/web/lib/zod/schemas/partner-network.ts
+++ b/apps/web/lib/zod/schemas/partner-network.ts
@@ -1,3 +1,4 @@
+import { PlatformType } from "@dub/prisma/client";
import * as z from "zod/v4";
import { booleanQuerySchema, getPaginationQuerySchema } from "./misc";
import { PartnerSchema, partnerPlatformSchema } from "./partners";
@@ -38,6 +39,10 @@ export const getNetworkPartnersQuerySchema = z
status: NetworkPartnersStatusSchema.default("discover"),
country: z.string().optional(),
starred: booleanQuerySchema.nullish(),
+ platform: z.enum(PlatformType).optional(),
+ subscribers: z
+ .enum(["<5000", "5000-25000", "25000-100000", "100000+"])
+ .optional(),
partnerIds: z
.union([z.string(), z.array(z.string())])
.transform((v) => (Array.isArray(v) ? v : v.split(",")))
@@ -55,7 +60,9 @@ export const getNetworkPartnersCountQuerySchema = getNetworkPartnersQuerySchema
})
.extend({
status: NetworkPartnersStatusSchema.nullish(),
- groupBy: z.enum(["status", "country"]).default("status"),
+ groupBy: z
+ .enum(["status", "country", "platform", "subscribers"])
+ .default("status"),
});
export const NetworkPartnerSchema = PartnerSchema.pick({