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.

Merge branch 'main' into auto-approve-check

Pedro Ladeira3dd3c0e4bd5b
diff --cc apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/applications/applications-menu-popover.tsx
index b29ebf5c7e,706195cf64..1d9d84cde9
--- a/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/applications/applications-menu-popover.tsx
+++ b/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/applications/applications-menu-popover.tsx
@@@ -4,8 -4,9 +4,9 @@@ import useProgram from "@/lib/swr/use-p
import { useExportApplicationsModal } from "@/ui/modals/export-applications-modal";
import { ThreeDots } from "@/ui/shared/icons";
import { Button, Download, IconMenu, Popover, useMediaQuery } from "@dub/ui";
+ import { ProgramApplicationStatus } from "@prisma/client";
import { useState } from "react";
+import { useApplicationSettingsSheet } from "./application-settings-sheet";
export function ApplicationSettingsButton() {
const { isMobile } = useMediaQuery();
diff --cc apps/web/lib/actions/partners/create-program-application.ts
index 150efd3ff7,c055649d42..4aa110e479
--- a/apps/web/lib/actions/partners/create-program-application.ts
+++ b/apps/web/lib/actions/partners/create-program-application.ts
@@@ -9,10 -9,11 +9,11 @@@ import { getIP } from "@/lib/api/utils/
import { markApplicationEventSubmitted } from "@/lib/application-events/update-application-event";
import { getApplicationEventCookieName } from "@/lib/application-events/utils";
import { getSession } from "@/lib/auth";
- import { autoRejectPartnerJob } from "@/lib/jobs/handlers/auto-reject-partner-job";
-import { autoApproveProgramApplicationJob } from "@/lib/jobs/handlers/auto-approve-program-application-job";
+ import { autoRejectProgramApplicationJob } from "@/lib/jobs/handlers/auto-reject-program-application-job";
import { programApplicationReminderJob } from "@/lib/jobs/handlers/program-application-reminder-job";
import { getNetworkProfileChecklistProgress } from "@/lib/network/get-network-profile-checklist-progress";
+ import { backfillPartnerPlatforms } from "@/lib/partners/backfill-partner-platforms";
+import { dispatchPartnerApplicationReview } from "@/lib/partners/dispatch-partner-application-review";
import { evaluateApplicationRequirements } from "@/lib/partners/evaluate-application-requirements";
import {
formatApplicationFormData,
@@@ -336,23 -445,18 +445,24 @@@ async function createApplicationAndEnro
partner,
program,
group,
- application,
+ application: programApplication,
}),
- // Auto-approve the partner if the group has auto-approval enabled
- group.autoApprovePartnersEnabledAt
- ? autoApproveProgramApplicationJob.dispatch(
- { applicationId: programApplication.id },
- { label: partner.id },
- )
- : Promise.resolve(null),
+ ...(result.reason === "requirementsNotMet"
+ ? []
+ : [
+ dispatchPartnerApplicationReview({
++ applicationId: programApplication.id,
+ programId: program.id,
+ partnerId: partner.id,
+ autoApprovePartnersEnabledAt:
+ group.autoApprovePartnersEnabledAt,
+ applicationScreeningCriteria:
+ program.applicationScreeningCriteria,
+ }),
+ ]),
- // Send "partner.application_submitted" webhook
+ // Send "partner.application_submitted" webhook (deprecated)
sendWorkspaceWebhook({
workspace,
trigger: "partner.application_submitted",
diff --cc apps/web/lib/ai/evaluate-partner-application.ts
index a184cfd36b,0000000000..c8a3647451
mode 100644,000000..100644
--- a/apps/web/lib/ai/evaluate-partner-application.ts
+++ b/apps/web/lib/ai/evaluate-partner-application.ts
@@@ -1,258 -1,0 +1,269 @@@
+import {
+ formatApplicationFormData,
+ formatWebsiteAndSocialsFields,
+} from "@/lib/partners/format-application-form-data";
+import { programLanderSchema } from "@/lib/zod/schemas/program-lander";
+import { ProgramApplication } from "@prisma/client";
+import { experimental_evaluate as evaluate, type JSONValue } from "ai";
+
++type ApplicationEvaluationFields = Pick<
++ ProgramApplication,
++ | "formData"
++ | "website"
++ | "youtube"
++ | "twitter"
++ | "linkedin"
++ | "instagram"
++ | "tiktok"
++>;
++
+export const JEV_MATCH_THRESHOLD = 0.85;
+
+const MAX_TEXT_LENGTH = 500;
+const JEV_EVALUATE_TIMEOUT_MS = 2_000;
+const JEV_MODEL_ID = "typesafe-ai/jev";
+
+export type EvaluatePartnerApplicationInput = {
+ program: {
+ name: string;
+ description: string | null;
+ };
+ partner: {
+ name: string;
+ country: string | null;
+ description: string | null;
+ platforms: {
+ type: string;
+ identifier: string;
+ subscribers: bigint | number;
+ verifiedAt: Date | null;
+ }[];
+ };
- application: ProgramApplication | null;
++ application: ApplicationEvaluationFields | null;
+ landerData: unknown;
+};
+
+/**
+ * `skipped` (nothing to evaluate) and `failed` (Jev errored) both fail open –
+ * only `matched` is a high-confidence yes.
+ */
+export type JevEvaluation = {
+ status: "matched" | "unmatched" | "skipped" | "failed";
+ probability?: number;
+ error?: string;
+ usage?: {
+ inputTokens?: number;
+ outputTokens?: number;
+ };
+};
+
+export function isConfidentMatch(probability: number | null | undefined) {
+ return (
+ probability != null &&
+ Number.isFinite(probability) &&
+ probability >= JEV_MATCH_THRESHOLD
+ );
+}
+
+export async function evaluatePartnerApplication(
+ input: EvaluatePartnerApplicationInput,
+): Promise<JevEvaluation> {
+ const state = buildPartnerApplicationState(input);
+
+ if (!state) {
+ return { status: "skipped" };
+ }
+
+ return await evaluateBooleanQuestion({
+ state,
+ questionKey: "poorFit",
+ instructions:
+ "Is this application spam or clearly irrelevant to this program?",
+ criteria: {
+ true: "Spam or clearly irrelevant to the program",
+ false: "Plausible fit, or not enough signal to reject",
+ },
+ tag: "jev-partner-auto-approve",
+ });
+}
+
+export async function evaluateApplicationScreening({
+ screeningCriteria,
+ ...input
+}: EvaluatePartnerApplicationInput & {
+ screeningCriteria: string;
+}): Promise<JevEvaluation> {
+ const state = buildPartnerApplicationState(input);
+
+ if (!state) {
+ return { status: "skipped" };
+ }
+
+ return await evaluateBooleanQuestion({
+ state: {
+ ...state,
+ screeningCriteria: truncate(screeningCriteria, 2000),
+ },
+ questionKey: "matchesScreeningCriteria",
+ instructions:
+ "Does this application match the program's rejection criteria in screeningCriteria?",
+ criteria: {
+ true: "The application clearly matches the program's rejection criteria",
+ false:
+ "The application does not match, or there is not enough signal to reject",
+ },
+ tag: "jev-partner-application-screening",
+ });
+}
+
+// Returns null when the application has no text worth evaluating
+function buildPartnerApplicationState({
+ program,
+ partner,
+ application,
+ landerData,
+}: EvaluatePartnerApplicationInput) {
+ const applicationAnswers = (
+ application ? formatApplicationFormData(application) : []
+ )
+ .filter((field) => field.value.trim().length > 0)
+ .map((field) => ({
+ title: field.title,
+ value: truncate(field.value),
+ }));
+
+ const formSocials = application
+ ? formatWebsiteAndSocialsFields(application)
+ : {};
+
+ const socials = application
+ ? compactRecord({
+ website: formSocials.website ?? application.website,
+ youtube: formSocials.youtube ?? application.youtube,
+ twitter: formSocials.twitter ?? application.twitter,
+ linkedin: formSocials.linkedin ?? application.linkedin,
+ instagram: formSocials.instagram ?? application.instagram,
+ tiktok: formSocials.tiktok ?? application.tiktok,
+ })
+ : {};
+
+ const platforms = partner.platforms
+ .filter((platform) => platform.identifier.trim().length > 0)
+ .map((platform) => ({
+ type: platform.type,
+ identifier: platform.identifier,
+ subscribers: Number(platform.subscribers),
+ verified: Boolean(platform.verifiedAt),
+ }));
+
+ const hasEvaluableText =
+ applicationAnswers.length > 0 ||
+ Boolean(truncate(partner.description)) ||
+ Object.keys(socials).length > 0 ||
+ platforms.length > 0;
+
+ if (!hasEvaluableText) {
+ return null;
+ }
+
+ const parsedLander = programLanderSchema.safeParse(landerData);
+ const lander = parsedLander.success
+ ? compactRecord({
+ title: truncate(parsedLander.data.title),
+ description: truncate(parsedLander.data.description),
+ })
+ : undefined;
+
+ return {
+ program: compactRecord({
+ name: program.name,
+ description: truncate(program.description),
+ }),
+ ...(lander && Object.keys(lander).length > 0 ? { lander } : {}),
+ partner: compactRecord({
+ name: partner.name,
+ country: partner.country ?? undefined,
+ description: truncate(partner.description),
+ ...socials,
+ ...(platforms.length > 0 ? { platforms } : {}),
+ }),
+ ...(applicationAnswers.length > 0 ? { applicationAnswers } : {}),
+ };
+}
+
+async function evaluateBooleanQuestion({
+ state,
+ questionKey,
+ instructions,
+ criteria,
+ tag,
+}: {
+ state: Record<string, unknown>;
+ questionKey: string;
+ instructions: string;
+ criteria: {
+ true: string;
+ false: string;
+ };
+ tag: string;
+}): Promise<JevEvaluation> {
+ if (!process.env.AI_GATEWAY_API_KEY) {
+ return { status: "skipped" };
+ }
+
+ try {
+ const result = await evaluate({
+ model: JEV_MODEL_ID,
+ state: state as { [key: string]: JSONValue | undefined },
+ questions: {
+ [questionKey]: {
+ type: "boolean",
+ instructions,
+ criteria,
+ },
+ },
+ maxRetries: 0,
+ abortSignal: AbortSignal.timeout(JEV_EVALUATE_TIMEOUT_MS),
+ providerOptions: {
+ gateway: {
+ zeroDataRetention: true,
+ disallowPromptTraining: true,
+ tags: [tag],
+ },
+ },
+ });
+
+ const answer = result.answers[questionKey];
+
+ if (!answer || answer.type !== "boolean") {
+ throw new Error("Jev evaluate returned an invalid response.");
+ }
+
+ return {
+ status: isConfidentMatch(answer.probability) ? "matched" : "unmatched",
+ probability: answer.probability,
+ usage: result.usage,
+ };
+ } catch (error) {
+ return {
+ status: "failed",
+ error: error instanceof Error ? error.message : String(error),
+ };
+ }
+}
+
+function truncate(value: string | null | undefined, max = MAX_TEXT_LENGTH) {
+ if (!value?.trim()) {
+ return undefined;
+ }
+
+ const trimmed = value.trim();
+
+ return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+
+function compactRecord<T extends Record<string, unknown>>(record: T) {
+ return Object.fromEntries(
+ Object.entries(record).filter(([, value]) => value != null && value !== ""),
+ ) as Partial<T>;
+}
diff --cc apps/web/lib/jobs/handlers/auto-approve-program-application-job.ts
index 0000000000,6eeeb5074f..53c653a9e9
mode 000000,100644..100644
--- a/apps/web/lib/jobs/handlers/auto-approve-program-application-job.ts
+++ b/apps/web/lib/jobs/handlers/auto-approve-program-application-job.ts
@@@ -1,0 -1,210 +1,278 @@@
++import { evaluatePartnerApplication } from "@/lib/ai/evaluate-partner-application";
+ import { DubApiError } from "@/lib/api/errors";
+ import { getProgramApplicationRisks } from "@/lib/api/fraud/get-program-application-risks";
++import { logger } from "@/lib/axiom/server";
+ import { evaluateApplicationRequirements } from "@/lib/partners/evaluate-application-requirements";
+ import { getPlanCapabilities } from "@/lib/plan-capabilities";
+ import { prisma } from "@/lib/prisma";
+ import { approveProgramApplication } from "@/lib/program-applications/approve-program-application";
++import { screenPartnerApplication } from "@/lib/program-applications/screen-partner-application";
+ import {
+ ProgramApplicationStatus,
+ ProgramEnrollmentStatus,
+ } from "@prisma/client";
+ import * as z from "zod/v4";
+ import { defineJob } from "../index";
+
+ const inputSchema = z.object({
+ applicationId: z.string(),
+ });
+
+ const AUTO_APPROVABLE_ENROLLMENT_STATUSES: ProgramEnrollmentStatus[] = [
+ ProgramEnrollmentStatus.pending,
+ ProgramEnrollmentStatus.approved,
+ ];
+
+ // This job is used to auto-approve a program application whose group has auto-approval enabled
+ export const autoApproveProgramApplicationJob = defineJob({
+ name: "auto-approve-program-application-job",
+ schema: inputSchema,
+ async handle(input) {
+ const { applicationId } = input;
+
+ const programApplication = await prisma.programApplication.findUnique({
+ where: {
+ id: applicationId,
+ },
+ select: {
+ programId: true,
+ partnerId: true,
+ status: true,
++ formData: true,
++ website: true,
++ youtube: true,
++ twitter: true,
++ linkedin: true,
++ instagram: true,
++ tiktok: true,
+ partnerGroup: {
+ select: {
+ id: true,
+ autoApprovePartnersEnabledAt: true,
++ landerData: true,
+ },
+ },
+ partner: {
+ select: {
+ id: true,
++ name: true,
+ email: true,
+ country: true,
++ description: true,
+ platforms: true,
+ },
+ },
+ program: {
+ select: {
+ id: true,
++ name: true,
++ description: true,
+ applicationRequirements: true,
++ applicationScreeningCriteria: true,
++ aiAutoApproveEnabledAt: true,
+ workspace: {
+ select: {
+ plan: true,
+ users: {
+ where: {
+ role: "owner",
+ },
+ take: 1,
+ select: {
+ userId: true,
+ },
+ },
+ },
+ },
+ },
+ },
+ },
+ });
+
+ if (!programApplication) {
+ console.warn(`Program application ${applicationId} not found.`);
+ return;
+ }
+
+ const { programId, partnerId, partner, partnerGroup, program } =
+ programApplication;
+
+ if (programApplication.status !== ProgramApplicationStatus.pending) {
+ console.warn(
+ `Application ${applicationId} is in ${programApplication.status} status.`,
+ );
+ return;
+ }
+
+ if (!partnerId || !partner) {
+ console.warn(
+ `Application ${applicationId} is not linked to a partner yet.`,
+ );
+ return;
+ }
+
+ if (!partnerGroup) {
+ console.warn(`Group not found for application ${applicationId}.`);
+ return;
+ }
+
+ if (!partnerGroup.autoApprovePartnersEnabledAt) {
+ console.warn(
+ `Group ${partnerGroup.id} does not have auto-approval enabled.`,
+ );
+ return;
+ }
+
+ const programEnrollment = await prisma.programEnrollment.findUnique({
+ where: {
+ partnerId_programId: {
+ partnerId,
+ programId,
+ },
+ },
+ select: {
+ status: true,
+ },
+ });
+
+ if (!programEnrollment) {
+ console.warn(`Partner ${partnerId} not found in program ${programId}.`);
+ return;
+ }
+
+ if (
+ !AUTO_APPROVABLE_ENROLLMENT_STATUSES.includes(programEnrollment.status)
+ ) {
+ console.warn(
+ `Application ${applicationId} was not auto-approved because partner ${partnerId} is in ${programEnrollment.status} status.`,
+ );
+ return;
+ }
+
+ // Check if the workspace plan has fraud event management capabilities
+ // If enabled, we'll evaluate risk signals before auto-approving
+ const { canManageFraudEvents } = getPlanCapabilities(
+ program.workspace.plan,
+ );
+
+ if (canManageFraudEvents) {
+ const { riskSeverity } = await getProgramApplicationRisks({
+ program,
+ partner,
+ });
+
+ if (riskSeverity === "high") {
+ console.warn(`Partner ${partnerId} has high risk.`);
+ return;
+ }
+ }
+
+ const result = evaluateApplicationRequirements({
+ applicationRequirements: program.applicationRequirements,
+ context: {
+ country: partner.country,
+ email: partner.email,
+ },
+ });
+
+ if (!result.valid) {
+ switch (result.reason) {
+ case "invalidRequirements":
+ console.warn(
+ `Invalid applicationRequirements for program ${programId}.`,
+ );
+ return;
+
+ case "requirementsNotMet":
+ console.warn(
+ `Partner ${partnerId} does not meet eligibility requirements.`,
+ );
+ return;
+ }
+ }
+
+ const owner = program.workspace.users[0];
+
+ if (!owner) {
+ console.warn(`Owner not found for program ${programId}.`);
+ return;
+ }
+
++ const screeningCriteria = program.applicationScreeningCriteria?.trim();
++
++ if (screeningCriteria) {
++ const matchedScreeningCriteria = await screenPartnerApplication({
++ programId,
++ partnerId,
++ applicationId,
++ program: {
++ name: program.name,
++ description: program.description,
++ },
++ partner,
++ application: programApplication,
++ landerData: partnerGroup.landerData,
++ screeningCriteria,
++ });
++
++ if (matchedScreeningCriteria) {
++ return;
++ }
++ }
++
++ if (program.aiAutoApproveEnabledAt) {
++ const evaluation = await evaluatePartnerApplication({
++ program: {
++ name: program.name,
++ description: program.description,
++ },
++ partner,
++ application: programApplication,
++ landerData: partnerGroup.landerData,
++ });
++
++ logger.info("jev.partner.auto-approve", {
++ programId,
++ partnerId,
++ status: evaluation.status,
++ probability: evaluation.probability,
++ error: evaluation.error,
++ usage: evaluation.usage,
++ });
++ await logger.flush();
++
++ if (evaluation.status === "matched") {
++ console.warn(
++ `Partner ${partnerId} held from auto-approve (Jev poorFit=${evaluation.probability}).`,
++ );
++ return;
++ }
++ }
++
+ try {
+ // The group is resolved from the application itself, falling back to the
+ // program's default group
+ await approveProgramApplication({
+ programId,
+ partnerId,
+ applicationId,
+ userId: owner.userId,
+ });
+ } catch (error) {
+ // Approval preconditions (missing group, partner limit reached) cannot
+ // resolve themselves, so there is nothing to retry
+ if (error instanceof DubApiError) {
+ console.warn(
+ `Could not auto-approve application ${applicationId}: ${error.message}`,
+ );
+ return;
+ }
+
+ throw error;
+ }
+
+ console.info(
+ `Successfully auto-approved partner ${partnerId} in program ${programId}.`,
+ );
+ },
+ });
diff --cc apps/web/lib/jobs/handlers/screen-partner-application-job.ts
index 6e28cc7cec,0000000000..68449da8ab
mode 100644,000000..100644
--- a/apps/web/lib/jobs/handlers/screen-partner-application-job.ts
+++ b/apps/web/lib/jobs/handlers/screen-partner-application-job.ts
@@@ -1,78 -1,0 +1,77 @@@
+import { screenPartnerApplication } from "@/lib/program-applications/screen-partner-application";
+import { prisma } from "@/lib/prisma";
- import { ProgramEnrollmentStatus } from "@prisma/client";
++import { ProgramApplicationStatus } from "@prisma/client";
+import * as z from "zod/v4";
+import { defineJob } from "../index";
+
+const inputSchema = z.object({
+ programId: z.string(),
+ partnerId: z.string(),
+});
+
+// This job screens a pending application against the program's written criteria.
- // Groups with auto-approval enabled are screened inside auto-approve-partner-job instead.
++// Groups with auto-approval enabled are screened inside auto-approve-program-application-job instead.
+export const screenPartnerApplicationJob = defineJob({
+ name: "screen-partner-application-job",
+ schema: inputSchema,
+ async handle(input) {
+ const { programId, partnerId } = input;
+
- const programEnrollment = await prisma.programEnrollment.findUnique({
++ const programApplication = await prisma.programApplication.findFirst({
+ where: {
- partnerId_programId: {
- partnerId,
- programId,
- },
++ programId,
++ partnerId,
++ status: ProgramApplicationStatus.pending,
++ },
++ orderBy: {
++ createdAt: "desc",
+ },
+ include: {
+ partnerGroup: true,
- application: true,
+ partner: {
+ include: {
+ platforms: true,
+ },
+ },
+ program: {
+ select: {
+ name: true,
+ description: true,
+ applicationScreeningCriteria: true,
+ },
+ },
+ },
+ });
+
- if (!programEnrollment) {
- console.warn(`Partner ${partnerId} not found in program ${programId}.`);
- return;
- }
-
- if (programEnrollment.status !== ProgramEnrollmentStatus.pending) {
- console.warn(`${partnerId} is in ${programEnrollment.status} status.`);
++ if (!programApplication?.partner) {
++ console.warn(
++ `No pending application found for partner ${partnerId} in program ${programId}.`,
++ );
+ return;
+ }
+
- const { program } = programEnrollment;
++ const { program } = programApplication;
+ const screeningCriteria = program.applicationScreeningCriteria?.trim();
+
+ if (!screeningCriteria) {
+ console.warn(
+ `Program ${programId} does not have application screening criteria.`,
+ );
+ return;
+ }
+
+ await screenPartnerApplication({
+ programId,
+ partnerId,
++ applicationId: programApplication.id,
+ program: {
+ name: program.name,
+ description: program.description,
+ },
- partner: programEnrollment.partner,
- application: programEnrollment.application,
- landerData: programEnrollment.partnerGroup?.landerData,
++ partner: programApplication.partner,
++ application: programApplication,
++ landerData: programApplication.partnerGroup?.landerData,
+ screeningCriteria,
+ });
+ },
+});
diff --cc apps/web/lib/jobs/registry.ts
index 962a54ce1d,d73d1ccbfc..e4a7bdec6e
--- a/apps/web/lib/jobs/registry.ts
+++ b/apps/web/lib/jobs/registry.ts
@@@ -56,11 -58,16 +58,21 @@@ const jobLoaders =
(m) => m.autoRejectPartnerJob,
),
+ "screen-partner-application-job": () =>
+ import("./handlers/screen-partner-application-job").then(
+ (m) => m.screenPartnerApplicationJob,
+ ),
+
+ "auto-approve-program-application-job": () =>
+ import("./handlers/auto-approve-program-application-job").then(
+ (m) => m.autoApproveProgramApplicationJob,
+ ),
+
+ "auto-reject-program-application-job": () =>
+ import("./handlers/auto-reject-program-application-job").then(
+ (m) => m.autoRejectProgramApplicationJob,
+ ),
+
"queue-partner-program-summary-job": () =>
import("./handlers/queue-partner-program-summary-job").then(
(m) => m.queuePartnerProgramSummaryJob,
diff --cc apps/web/lib/partners/complete-program-applications.ts
index e5b9e081f5,578591adb2..4e1a4699a3
--- a/apps/web/lib/partners/complete-program-applications.ts
+++ b/apps/web/lib/partners/complete-program-applications.ts
@@@ -6,11 -6,17 +6,17 @@@ import { detectAndRecordFraudApplicatio
import { notifyProgramApplication } from "../api/partners/notify-program-application";
import { queuePartnerSearchSync } from "../api/partners/queue-partner-search-sync";
import { markApplicationEventSubmitted } from "../application-events/update-application-event";
- import { autoRejectPartnerJob } from "../jobs/handlers/auto-reject-partner-job";
- import { buildSocialPlatformLookup } from "../social-utils";
-import { autoApproveProgramApplicationJob } from "../jobs/handlers/auto-approve-program-application-job";
+ import { autoRejectProgramApplicationJob } from "../jobs/handlers/auto-reject-program-application-job";
import { sendWorkspaceWebhook } from "../webhook/publish";
- import { partnerApplicationWebhookSchema } from "../zod/schemas/program-application";
+ import {
+ partnerApplicationWebhookSchema,
+ programApplicationWebhookSchema,
+ } from "../zod/schemas/program-application";
+ import {
+ backfillPartnerPlatforms,
+ mergeApplicationSocialPlatforms,
+ } from "./backfill-partner-platforms";
+import { dispatchPartnerApplicationReview } from "./dispatch-partner-application-review";
import { evaluateApplicationRequirements } from "./evaluate-application-requirements";
import {
formatApplicationFormData,
@@@ -158,136 -164,122 +164,124 @@@ export async function completeProgramAp
workspaces.map((ws) => [ws.defaultProgramId, ws]),
);
- for (const programApplication of filteredProgramApplications) {
- const application = programApplication;
- const program = programApplication.program;
- const group = programApplication.partnerGroup;
- const programEnrollment = enrollmentsByApplicationId.get(
- programApplication.id,
- );
-
- const socialPlatforms = buildSocialPlatformLookup(partner.platforms);
-
- const missingSocialFields = {
- website:
- application.website && !socialPlatforms.website?.identifier
- ? application.website
- : undefined,
- youtube:
- application.youtube && !socialPlatforms.youtube?.identifier
- ? application.youtube
- : undefined,
- twitter:
- application.twitter && !socialPlatforms.twitter?.identifier
- ? application.twitter
- : undefined,
- linkedin:
- application.linkedin && !socialPlatforms.linkedin?.identifier
- ? application.linkedin
- : undefined,
- instagram:
- application.instagram && !socialPlatforms.instagram?.identifier
- ? application.instagram
- : undefined,
- tiktok:
- application.tiktok && !socialPlatforms.tiktok?.identifier
- ? application.tiktok
- : undefined,
- };
+ const { platforms: backfilledPlatforms } = await backfillPartnerPlatforms({
+ partnerId: partner.id,
+ platforms: partner.platforms,
+ applications: filteredProgramApplications,
+ });
- const hasMissingSocialFields = Object.values(missingSocialFields).some(
- (field) => field !== undefined,
- );
+ await Promise.allSettled(
+ filteredProgramApplications.map(async (programApplication) => {
+ const application = programApplication;
+ const program = programApplication.program;
+ const group = programApplication.partnerGroup;
+ const programEnrollment = enrollmentsByApplicationId.get(
+ programApplication.id,
+ );
- const applicationFormData = formatApplicationFormData(application).map(
- ({ title, value }) => ({
- label: title,
- value: value !== "" ? value : null,
- }),
- );
+ const applicationFormData = formatApplicationFormData(application).map(
+ ({ title, value }) => ({
+ label: title,
+ value: value !== "" ? value : null,
+ }),
+ );
- const { valid: validApplication } = evaluateApplicationRequirements({
- applicationRequirements: program.applicationRequirements,
- context: {
- country: partner.country,
- email: partner.email,
- },
- });
+ const { valid: validApplication } = evaluateApplicationRequirements({
+ applicationRequirements: program.applicationRequirements,
+ context: {
+ country: partner.country,
+ email: partner.email,
+ },
+ });
- await Promise.allSettled([
- ...(validApplication
- ? [
- notifyProgramApplication({
- partner,
- program,
- group,
- application,
- }),
+ const { platforms, socialFields } = mergeApplicationSocialPlatforms({
+ platforms: backfilledPlatforms,
+ application,
+ });
- dispatchPartnerApplicationReview({
- programId: program.id,
- partnerId: partner.id,
- autoApprovePartnersEnabledAt:
- group?.autoApprovePartnersEnabledAt,
- applicationScreeningCriteria:
- program.applicationScreeningCriteria,
- }),
+ const webhookData = {
+ id: application.id,
+ createdAt: application.createdAt,
+ applicationFormData,
+ partner: {
+ ...partner,
+ ...programEnrollment,
+ id: partner.id,
+ status: "pending",
+ },
+ };
- // Send "partner.application_submitted" webhook
- workspacesByProgramId.has(program.id) &&
- sendWorkspaceWebhook({
- workspace: workspacesByProgramId.get(program.id)!,
- trigger: "partner.application_submitted",
- data: partnerApplicationWebhookSchema.parse({
- id: application.id,
- createdAt: application.createdAt,
- partner: {
- ...partner,
- ...programEnrollment,
- id: partner.id,
- status: "pending",
- ...formatWebsiteAndSocialsFields(application),
- },
- applicationFormData,
- }),
+ await Promise.allSettled([
+ ...(validApplication
+ ? [
+ notifyProgramApplication({
+ partner,
+ program,
+ group,
+ application,
}),
- ]
- : [
- autoRejectPartnerJob.dispatch(
- {
+
- // Auto-approve the partner if the group has auto-approval enabled
- group?.autoApprovePartnersEnabledAt
- ? autoApproveProgramApplicationJob.dispatch(
- { applicationId: application.id },
- { label: partner.id },
- )
- : Promise.resolve(null),
++ dispatchPartnerApplicationReview({
++ applicationId: application.id,
+ programId: program.id,
+ partnerId: partner.id,
- },
- {
- delay: 5 * 60, // 5 minutes
- label: partner.id,
- },
- ),
- ]),
++ autoApprovePartnersEnabledAt:
++ group?.autoApprovePartnersEnabledAt,
++ applicationScreeningCriteria:
++ program.applicationScreeningCriteria,
++ }),
- // if the application has any website or social fields but the partner doesn't have the corresponding one (maybe they forgot to add during onboarding)
- // update the partner to use the website they applied with
- hasMissingSocialFields &&
- prisma.partnerPlatform.createMany({
- data: Object.entries(missingSocialFields)
- .filter(([, identifier]) => identifier !== undefined)
- .map(([platform, identifier]) => ({
- partnerId: partner.id,
- type: platform as PlatformType,
- identifier: identifier as string,
- })),
- skipDuplicates: true,
- }),
+ // Send "partner.application_submitted" webhook (deprecated)
+ workspacesByProgramId.has(program.id) &&
+ sendWorkspaceWebhook({
+ workspace: workspacesByProgramId.get(program.id)!,
+ trigger: "partner.application_submitted",
+ data: partnerApplicationWebhookSchema.parse({
+ ...webhookData,
+ partner: {
+ ...webhookData.partner,
+ ...formatWebsiteAndSocialsFields(application),
+ },
+ }),
+ }),
- // Detect and record fraud events for the partner when they apply to a program
- detectAndRecordFraudApplication({
- context: {
- program,
- partner,
- },
- }),
- ]);
- }
+ // Send "program_application.created" webhook
+ workspacesByProgramId.has(program.id) &&
+ sendWorkspaceWebhook({
+ workspace: workspacesByProgramId.get(program.id)!,
+ trigger: "program_application.created",
+ data: programApplicationWebhookSchema.parse({
+ ...webhookData,
+ partner: {
+ ...webhookData.partner,
+ platforms,
+ ...socialFields,
+ },
+ }),
+ }),
+ ]
+ : [
+ autoRejectProgramApplicationJob.dispatch(
+ {
+ applicationId: application.id,
+ },
+ {
+ delay: 5 * 60, // 5 minutes
+ label: partner.id,
+ },
+ ),
+ ]),
+
+ // Detect and record fraud events for the partner when they apply to a program
+ detectAndRecordFraudApplication({
+ context: {
+ program,
+ partner,
+ },
+ }),
+ ]);
+ }),
+ );
await Promise.allSettled(
programEnrollments.map((programEnrollment) =>
diff --cc apps/web/lib/partners/dispatch-partner-application-review.ts
index 5b6bdc4fc0,0000000000..26809713cb
mode 100644,000000..100644
--- a/apps/web/lib/partners/dispatch-partner-application-review.ts
+++ b/apps/web/lib/partners/dispatch-partner-application-review.ts
@@@ -1,42 -1,0 +1,43 @@@
- import { autoApprovePartnerJob } from "@/lib/jobs/handlers/auto-approve-partner-job";
++import { autoApproveProgramApplicationJob } from "@/lib/jobs/handlers/auto-approve-program-application-job";
+import { screenPartnerApplicationJob } from "@/lib/jobs/handlers/screen-partner-application-job";
+
- // Auto-approving groups are screened inside autoApprovePartnerJob, so the two
- // jobs never review the same enrollment concurrently.
++// Auto-approving groups are screened inside autoApproveProgramApplicationJob, so
++// the two jobs never review the same application concurrently.
+export function dispatchPartnerApplicationReview({
++ applicationId,
+ programId,
+ partnerId,
+ autoApprovePartnersEnabledAt,
+ applicationScreeningCriteria,
+}: {
++ applicationId: string;
+ programId: string;
+ partnerId: string;
+ autoApprovePartnersEnabledAt: Date | null | undefined;
+ applicationScreeningCriteria: string | null | undefined;
+}) {
+ if (autoApprovePartnersEnabledAt) {
- return autoApprovePartnerJob.dispatch(
++ return autoApproveProgramApplicationJob.dispatch(
+ {
- programId,
- partnerId,
++ applicationId,
+ },
+ {
+ label: partnerId,
+ },
+ );
+ }
+
+ if (applicationScreeningCriteria?.trim()) {
+ return screenPartnerApplicationJob.dispatch(
+ {
+ programId,
+ partnerId,
+ },
+ {
+ label: partnerId,
+ },
+ );
+ }
+
+ return Promise.resolve(null);
+}
diff --cc apps/web/lib/partners/format-application-form-data.ts
index 6bafc5d54c,6bafc5d54c..a271447fe8
--- a/apps/web/lib/partners/format-application-form-data.ts
+++ b/apps/web/lib/partners/format-application-form-data.ts
@@@ -8,7 -8,7 +8,7 @@@ export interface FormDataKeyValue
}
export const formatApplicationFormData = (
-- application: ProgramApplication,
++ application: Pick<ProgramApplication, "formData">,
): FormDataKeyValue[] => {
const formData =
application?.formData as ProgramApplicationFormDataWithValues;
@@@ -60,7 -60,7 +60,7 @@@
};
export const formatWebsiteAndSocialsFields = (
-- application: ProgramApplication,
++ application: Pick<ProgramApplication, "formData">,
) => {
const formData =
application?.formData as ProgramApplicationFormDataWithValues;
diff --cc apps/web/lib/program-applications/screen-partner-application.ts
index 4003e25a6c,0000000000..1744045b29
mode 100644,000000..100644
--- a/apps/web/lib/program-applications/screen-partner-application.ts
+++ b/apps/web/lib/program-applications/screen-partner-application.ts
@@@ -1,52 -1,0 +1,71 @@@
+import {
+ EvaluatePartnerApplicationInput,
+ evaluateApplicationScreening,
+} from "@/lib/ai/evaluate-partner-application";
++import { DubApiError } from "@/lib/api/errors";
+import { logger } from "@/lib/axiom/server";
+import { ProgramApplicationRejectionReason } from "@prisma/client";
- import { rejectPendingEnrollment } from "./reject-pending-enrollment";
++import { rejectProgramApplication } from "./reject-program-application";
+
+/**
+ * Rejects a pending application when Jev is confident it matches the program's
+ * written screening criteria. Fails open, so an unavailable Jev never rejects.
+ * Returns true when the criteria matched, i.e. the application must not be approved.
+ */
+export async function screenPartnerApplication({
+ programId,
+ partnerId,
++ applicationId,
+ ...input
+}: EvaluatePartnerApplicationInput & {
+ programId: string;
+ partnerId: string;
++ applicationId: string;
+ screeningCriteria: string;
+}) {
+ const evaluation = await evaluateApplicationScreening(input);
+
+ logger.info("jev.partner.application-screening", {
+ programId,
+ partnerId,
++ applicationId,
+ status: evaluation.status,
+ probability: evaluation.probability,
+ error: evaluation.error,
+ usage: evaluation.usage,
+ });
+ await logger.flush();
+
+ if (evaluation.status !== "matched") {
+ return false;
+ }
+
- const rejected = await rejectPendingEnrollment({
- programId,
- partnerId,
- rejectionReason: ProgramApplicationRejectionReason.notTheRightFit,
- });
++ try {
++ await rejectProgramApplication({
++ programId,
++ partnerId,
++ applicationId,
++ rejectionReason: ProgramApplicationRejectionReason.notTheRightFit,
++ rejectionNote: undefined,
++ reapplicationTimeframe: "standard",
++ flagForFraudReason: undefined,
++ });
++ } catch (error) {
++ // Already reviewed, or the enrollment can no longer be rejected. The match
++ // still stands, so the caller must not approve.
++ if (error instanceof DubApiError) {
++ console.warn(
++ `Could not reject application ${applicationId} after screening: ${error.message}`,
++ );
++ return true;
++ }
++
++ throw error;
++ }
+
+ console.info(
- rejected
- ? `Successfully rejected partner ${partnerId} in program ${programId} (application screening).`
- : `Partner ${partnerId} is no longer pending in program ${programId}.`,
++ `Successfully rejected application ${applicationId} in program ${programId} (application screening).`,
+ );
+
+ return true;
+}