Network and Marketplace | blade47/dub Wiki | doc0

Public

Network and Marketplace | blade47/dub Wiki | doc0

Dimension	Weight	Calculation Method	Source File
Category Similarity	0.5	Jaccard similarity coefficient on `ProgramCategory` records (`sharedCount / totalUniqueCount`)	apps/web/app/ee/api/cron/network/calculate-program-similarities/calculate-category-similarity.ts:4-43
Partner Similarity	0.3	Jaccard similarity coefficient on overlapping `ProgramEnrollment` partner IDs (`sharedPartnersCount / unionCount`)	apps/web/app/ee/api/cron/network/calculate-program-similarities/calculate-partner-similarity.ts:10-44
Performance Similarity	0.2	Comparative performance metrics evaluated concurrently via promise resolution	apps/web/app/ee/api/cron/network/calculate-program-similarities/route.ts:122-130

model ProgramSimilarity {
  id                         String @id @default(cuid())
  programId                  String
  similarProgramId           String
  similarityScore            Float
  categorySimilarityScore    Float
  partnerSimilarityScore     Float
  performanceSimilarityScore Float
 
  program        Program @relation(fields: [programId], references: [id], onDelete: Cascade)
  similarProgram Program @relation("SimilarProgram", fields: [similarProgramId], references: [id], onDelete: Cascade)
 
  @@unique([programId, similarProgramId])
  @@index([programId, similarityScore])
  @@index(similarProgramId)
}

Design Choice	Benefit	Cost
Bidirectional pairing insertion	O(1) read performance when querying similar programs for any given program ID	Doubles storage volume in `ProgramSimilarity` for every qualified pair
QStash batch queueing (`PROGRAMS_PER_BATCH = 10`)	Prevents cron timeouts by distributing heavy calculations across iterative asynchronous tasks	Extends total pipeline completion time across multiple scheduled dispatches
Raw SQL for partner Jaccard aggregation	Executes partner overlap counts efficiently directly within database memory	Ties query logic directly to SQL syntax and database schema foreign keys

Component	Point Range	Heuristic Details
Trusted Partner Bonus	200 points	Awarded to partners with `networkStatus = "trusted"` to ensure top placement
Similarity Score	0–50 points	Sums weighted performance across similar programs where `similarityScore > 0.3` (consistency 20%, conversion rate 10%, LTV 15%, commissions 5%)
Program Match Score	0–15 points	Awards 2 points per similar program the partner is enrolled in, capped at 15 points

function 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`;
}

Tab ID	Label	Description
`discover`	Discover	Displays prospective network partners available for recruitment
`invited`	Invited	Lists partners who have received an invitation to the program
`recruited`	Recruited	Displays partners who have successfully joined the program

Component File	Primary Role	Key Props & Dependencies
`marketplace-program-hero.tsx`	Renders top banner image, avatar, title, description, categories, website links, and application slots	`program`, `applySlot`, `className`
`featured-program-card.tsx`	Displays featured program cards with dynamic background tinting and reward summaries	`program`, `externalMarketplace`, `colorIndex`
`marketplace-programs-list-page.tsx`	Manages list fetching, SWR caching, pagination controls, and empty-state filtering	None (Client Component)

export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const headersList = await headers();
  let domain = headersList.get("host") as string;
 
  if (domain === "dub.localhost:8888") {
    domain = SHORT_DOMAIN;
  }
 
  if (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(),
    }));
  }
 
  const entries: MetadataRoute.Sitemap = [{ url: `https://${domain}`, lastModified: new Date() }];
 
  if (isAppHostname(domain)) {
    const marketplacePrograms = await prisma.program.findMany({
      where: { addedToMarketplaceAt: { not: null } },
      select: { slug: true, updatedAt: true },
      orderBy: { slug: "asc" },
    });
 
    entries.push(
      { url: "https://dub.co/marketplace", lastModified: new Date() },
      { url: `https://dub.co${getMarketplaceAllHref()}`, lastModified: new Date() },
      ...Object.values(Category).map((category) => ({
        url: `https://dub.co${getMarketplaceCategoryHref(category)}`,
        lastModified: new Date(),
      })),
      ...marketplacePrograms.map((program) => ({
        url: `https://dub.co/marketplace/${program.slug}`,
        lastModified: program.updatedAt,
      })),
    );
  }
 
  return entries;
}

export async function getNetworkInvitesUsage(
  workspace: Pick<Project, "id" | "billingCycleStart">,
) {
  const invites = await prisma.discoveredPartner.aggregate({
    _count: true,
    where: {
      program: {
        workspaceId: workspace.id,
      },
      OR: [
        {
          invitedAt: {
            gt: getBillingStartDate(workspace.billingCycleStart),
          },
        },
        {
          messagedAt: {
            gt: getBillingStartDate(workspace.billingCycleStart),
          },
        },
      ],
    },
  });
 
  return invites._count;
}

Utility Function	Input Parameter	Return Type	Behavior / Sanitization Rule
`getUsableNetworkPartnerName`	`name?: string \| null`	`string \| null`	Trims input; returns `null` if empty or if string contains `@`.
`getNetworkPartnerDisplayName`	`name?: string \| null`	`string`	Delegates to `getUsableNetworkPartnerName`; falls back to `"there"`.
`getProgramNetworkInviteEmailDefaults`	`{ programName: string, partnerName?: string \| null }`	`{ subject, title, body }`	Constructs template strings using the sanitized partner display name.

export async function POST(req: NextRequest) {
  const token = req.headers.get("X-Plain-Webhook-Secret");
  if (token !== process.env.PLAIN_WEBHOOK_SECRET) {
    return new Response("Unauthorized", { status: 401 });
  }
 
  let { customer } = plainCallbackSchema.parse(await req.json());
 
  if (!customer.externalId) {
    const user = await prisma.user.findUnique({
      where: { email: customer.email },
    });
    if (!user || !user.email) {
      return NextResponse.json({
        cards: [{ key: "partner", components: [plainEmptyContainer("No user found.")] }],
      });
    }
    customer.externalId = user.id;
    await upsertPlainCustomer({ id: user.id, name: user.name, email: user.email });
  }
  // ...fetches partner profile and renders customer view cards
}