Network ranking algorithm v2

apps/web/app/(ee)/api/cron/calculate-program-similarities/calculate-category-similarity.ts

@@ -0,0 +1,43 @@
+import { prisma } from "@dub/prisma";
+
+// Calculate category similarity using Jaccard similarity
+export 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;
+}

apps/web/app/(ee)/api/cron/calculate-program-similarities/calculate-partner-similarity.ts

@@ -0,0 +1,44 @@
+import { prisma } from "@dub/prisma";
+
+interface PartnerSimilarityResult {
+  sharedPartnersCount: bigint;
+  program1PartnersCount: bigint;
+  program2PartnersCount: bigint;
+}
+
+// Calculate partner similarity using Jaccard similarity
+export async function calculatePartnerSimilarity(
+  program1Id: string,
+  program2Id: string,
+): Promise<number> {
+  const [result] = await prisma.$queryRaw<PartnerSimilarityResult[]>`
+    SELECT 
+      COUNT(DISTINCT CASE WHEN e1.partnerId IS NOT NULL AND e2.partnerId IS NOT NULL THEN e1.partnerId END) AS sharedPartnersCount,
+      (SELECT COUNT(*) FROM ProgramEnrollment WHERE programId = ${program1Id}) AS program1PartnersCount,
+      (SELECT COUNT(*) FROM ProgramEnrollment WHERE programId = ${program2Id}) AS program2PartnersCount
+    FROM
+      ProgramEnrollment e1
+    JOIN
+      ProgramEnrollment e2 ON e1.partnerId = e2.partnerId
+    WHERE
+      e1.programId = ${program1Id} AND e2.programId = ${program2Id}
+  `;
+
+  const { sharedPartnersCount, program1PartnersCount, program2PartnersCount } =
+    result ?? {
+      sharedPartnersCount: BigInt(0),
+      program1PartnersCount: BigInt(0),
+      program2PartnersCount: BigInt(0),
+    };
+
+  const unionCount =
+    Number(program1PartnersCount) +
+    Number(program2PartnersCount) -
+    Number(sharedPartnersCount);
+
+  if (unionCount === 0) {
+    return 0;
+  }
+
+  return Number(sharedPartnersCount) / unionCount;
+}

apps/web/app/(ee)/api/cron/calculate-program-similarities/calculate-performance-similarity.ts

@@ -0,0 +1,65 @@
+import { prisma } from "@dub/prisma";
+
+const METRIC_KEYS = [
+  "totalClicks",
+  "totalLeads",
+  "totalConversions",
+  "totalSales",
+  "totalSaleAmount",
+] as const;
+
+// Calculate performance similarity using Cosine similarity
+export 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);
+}