Conversion Tracking

Copyconst {
  clickId,
  eventName,
  eventQuantity,
  customerExternalId: newExternalId,
  externalId: oldExternalId, // deprecated (but we'll support it for backwards compatibility)
  customerId: oldCustomerId, // deprecated (but we'll support it for backwards compatibility)
  customerName,
  customerEmail,
  customerAvatar,
  mode,
  metadata,
} = trackLeadRequestSchema
  .extend({
    // we if clickId is undefined/nullish, we'll coerce into an empty string
    clickId: z.string().trim().nullish(),
    // add backwards compatibility
    customerExternalId: z.string().trim().nullish(),
    externalId: z.string().trim().nullish(),
    customerId: z.string().trim().nullish(),
  })
  .parse(body);

Copyif (!isDuplicateEvent) {
  // First, we need to find the click event
  const clickData = await getClickEvent({ clickId });
 
  // if there is no click data, throw an error
  if (!clickData) {
    throw new DubApiError({
      code: "not_found",
      message: `Click event not found for clickId: ${clickId}`,
    });
  }
 

Copyexport const trackDubLead = async (user: User) => {
  const cookieStore = await cookies();
  const clickId = cookieStore.get("dub_id")?.value;
 
  if (!clickId) {
    console.log("No dub_id cookie found, skipping lead tracking...");
    return;
  }
 
  // send the lead event to Dub
  await dub.track.lead({
    clickId,
    eventName: "Sign Up",
    customerExternalId: user.id,
    customerName: user.name,
    customerEmail: user.email,
    customerAvatar: user.image,
  });
 

Copyif (!customer) {
  const { customer: existingOrNewCustomer } = await getOrCreateCustomer({
    where: {
      projectId_externalId: {
        projectId: workspace.id,
        externalId: customerExternalId,
      },
    },
    create: {
      id: finalCustomerId,
      name: finalCustomerName,
      email: customerEmail,
      avatar: finalCustomerAvatar,
      externalId: customerExternalId,
      projectId: workspace.id,
      projectConnectId: workspace.stripeConnectId,
      clickId: clickData.click_id,
      linkId: link.id,
      programId: link.programId,
      partnerId: link.partnerId,
      country: clickData.country,
      clickedAt: new Date(clickData.timestamp + "Z"),
    },
  });
 
  customer = existingOrNewCustomer;
}

Copyif (objectTypeId === "0-1" && subscriptionType === "object.creation") {
  const contactInfo = await hubSpotApi.getContact(objectId);
 
  if (!contactInfo) {
    return `No contact info found for contact ${objectId}.`;
  }
 
  const { properties } = contactInfo;
 
  if (!properties.dub_id) {
    return `No dub_id found for contact ${objectId}.`;
  }
 
  const customerName =
    [properties.firstname, properties.lastname].filter(Boolean).join(" ") ||
    null;
 
  const trackLeadResult = await trackLead({
    clickId: properties.dub_id,
    eventName: "Sign up",
    customerEmail: properties.email,
    customerExternalId: properties.email,
    customerName,
    mode: "deferred",
    workspace,
    source: "hubspot",
    commissionSource: CommissionSource.hubspot,
  });
 
  if (trackLeadResult) {
    await updateHubSpotContact({
      contact: contactInfo,
      trackLeadResult,
      hubSpotApi,
    });
  }
 
  return `Deferred lead tracked for contact ${objectId}.`;
}

Copyexport const updateHubSpotContact = async ({
  hubSpotApi,
  contact,
  trackLeadResult,
}: {
  hubSpotApi: HubSpotApi;
  contact: HubSpotContact;
  trackLeadResult: TrackLeadResponse;
}) => {
  if (contact.properties.dub_link && contact.properties.dub_partner_email) {
    console.log(
      `[HubSpot] Contact ${contact.id} already has dub_link and dub_partner_email. Skipping update.`,
    );
    return;
  }
 
  const properties: Record<string, string> = {};
 
  if (trackLeadResult.link?.partnerId) {
    const partner = await prisma.partner.findUniqueOrThrow({
      where: {
        id: trackLeadResult.link.partnerId,
      },
      select: {
        email: true,
      },
    });
 
    if (partner.email) {
      properties["dub_partner_email"] = partner.email;
    }
  }
 
  if (trackLeadResult.link?.shortLink) {
    properties["dub_link"] = trackLeadResult.link.shortLink;
  }
 

Copyexport const POST = withWorkspace(
  async ({ req, workspace }) => {
    const body = await parseRequestBody(req);
 
    let {
      customerExternalId: newExternalId,
      externalId: oldExternalId, // deprecated
      customerId: oldCustomerId, // deprecated
      customerName,
      customerEmail,
      customerAvatar,
      clickId,
      amount,
      currency,
      eventName,
      paymentProcessor,
      invoiceId,
      leadEventName,
      metadata,
    } = trackSaleRequestSchema
      .extend({
        // add backwards compatibility
        customerExternalId: z.string().nullish(),
        externalId: z.string().nullish(),
        customerId: z.string().nullish(),
      })
      .parse(body);
 
    const customerExternalId = newExternalId || oldExternalId || oldCustomerId;
 
    if (!customerExternalId) {
      throw new DubApiError({
        code: "bad_request",
        message: "customerExternalId is required",
      });
    }

Copyexport const POST = withPublishableKey(
  async ({ req, workspace }) => {
    const body = await parseRequestBody(req);
 
    const allowRequest = verifyAnalyticsAllowedHostnames({
      allowedHostnames: (workspace?.allowedHostnames ?? []) as string[],
      req,
    });
 
    if (!allowRequest) {
      throw new DubApiError({
        code: "forbidden",
        message: `Request origin '${getHostnameFromRequest(req)}' is not included in the allowed hostnames for this workspace. Update your allowed hostnames here: https://app.dub.co/settings/tracking`,
      });
    }
 
    const {
      customerExternalId,
      customerName,
      customerEmail,
      customerAvatar,
      clickId,
      amount,
      currency,
      eventName,
      paymentProcessor,
      invoiceId,
      leadEventName,
      metadata,
    } = trackSaleRequestSchema.parse(body);
 
    if (!customerExternalId) {
      throw new DubApiError({
        code: "bad_request",
        message: "customerExternalId is required",
      });
    }

Copy// Skip if amount is 0 or less
if (amount <= 0) {
  return {
    eventName,
    customer: null,
    sale: null,
  };
}
 
// if currency is not USD, convert it to USD based on the current FX rate
// TODO: allow custom "defaultCurrency" on workspace table in the future
if (currency !== "usd") {
  const { currency: convertedCurrency, amount: convertedAmount } =
    await convertCurrency({
      currency,
      amount,
    });
 
  currency = convertedCurrency;
  amount = convertedAmount;
}
 

Copyexport const isFirstConversion = ({
  customer,
  linkId,
}: {
  customer: Pick<Customer, "sales" | "linkId">;
  linkId?: string;
}) => {
  // if this is the first sale for the customer, it's a first conversion
  if (customer.sales === 0) {
    return true;
  }
 
  // if customer has sales, but the original referral link is not the same as the current link
  // it is most likely a first conversion
  if (customer.linkId !== linkId) {
    // TODO: fix edge case where customer was brought in by a different link, but then had recurring sales on the current link
    return true;
  }
 
  return false;
};

Copylet firstConversionFlag = isFirstConversion({
  customer,
  linkId: saleData.link_id,
});
 
// Deduplicate concurrent first sales for the same customer + link so only one
// request is counted as the first conversion.
if (firstConversionFlag) {
  const claim = await redis.set(
    `firstConversion:${customer.id}:${saleData.link_id}`,
    1,
    {
      ex: 30,
      nx: true,
    },
  );
 
  firstConversionFlag = claim !== null;
}
 

CopywaitUntil(
  (async () => {
    // Update link conversions, sales, and saleAmount
    const link = await prisma.link.update({
      where: {
        id: saleData.link_id,
      },
      data: {
        ...(firstConversionFlag && {
          conversions: {
            increment: 1,
          },
          lastConversionAt: new Date(),
        }),
        sales: {
          increment: 1,
        },
        saleAmount: {
          increment: amount,
        },
      },
      include: includeTags,
    });

Copyif (link.programId && link.partnerId) {
  result = await queuePartnerCommissionCreation({
    event: "sale",
    programId: link.programId,
    partnerId: link.partnerId,
    linkId: link.id,
    customerId: customer.id,
    eventId: saleData.event_id,
    amount: saleData.amount,
    quantity: 1,
    invoiceId,
    currency,
    source: commissionSource,
    userId,
    ...(metadata != null && { metadata }),
    context: {
      customer: {
        country: customer.country,
        signupDate: customer.createdAt,
        source,
      },
      sale: {
        productId: metadata?.productId,
        amount: saleData.amount,
        ...(metadata != null && { metadata }),
      },
    },
    clickEvent: {
      url: saleData.url,
      referer: saleData.referer,
    },
    isFirstConversion: firstConversionFlag,
  });

Copyexport async function attributeViaPromotionCodeId({
  promotionCodeId,
  workspace,
  mode,
  customerDetails,
}: {
  promotionCodeId: string; // must be Stripe's promotion code ID `promo_xxx`, not the actual promo code
  workspace: Pick<
    Project,
    "id" | "defaultProgramId" | "stripeConnectId" | "webhookEnabled"
  >;
  mode: StripeMode;
  customerDetails: PromoCodeCustomerDetails;
}) {
  console.log(
    `Attributing via promotion code ID ${promotionCodeId} for customer ${customerDetails.stripeCustomerId} in workspace ${workspace.id}`,
  );
 
  const stripeAccountId = workspace.stripeConnectId!;
  const stripeCustomerId = customerDetails.stripeCustomerId;
 
  if (!workspace.defaultProgramId) {
    console.log(
      `Workspace with stripeConnectId ${stripeAccountId} has no default program, skipping...`,
    );
    return null;
  }
 
  // Find the promotion code for the promotion code id
  const promotionCode = await getPromotionCode({
    promotionCodeId,
    stripeAccountId,
    mode,
  });
 
  if (!promotionCode) {
    console.log(
      `Promotion code ${promotionCodeId} not found in connected account ${stripeAccountId}, skipping...`,
    );
    return null;
  }
 
  console.log(`Promotion code found: ${promotionCode.code}`);
 
  const discountCode = await prisma.discountCode.findUnique({
    where: {
      programId_code: {
        programId: workspace.defaultProgramId,
        code: promotionCode.code,
      },
    },
    include: {
      link: true,
    },
  });
 
  if (!discountCode) {
    console.log(
      `Couldn't find discount code "${promotionCode.code}" in program "${workspace.defaultProgramId}", skipping...`,
    );
    return null;

Copyconst link = discountCode.link;
const linkId = link.id;
const customerAddress = customerDetails.address;
const customerCountry = customerAddress?.country?.toUpperCase();
 
// Record a fake click for this event
const clickEvent = await recordFakeClick({
  link,
  customer: {
    continent: customerCountry
      ? COUNTRIES_TO_CONTINENTS[customerCountry] ?? "Unknown"
      : "Unknown",
    country: customerCountry ?? "Unknown",
    region: customerAddress?.state ?? "Unknown",
  },
});
 
const { customer, created } = await getOrCreateCustomer({
  findMode: "first",
  where: {
    OR: [
      {
        stripeCustomerId,
      },
      {
        projectId: workspace.id,
        externalId: clickEvent.click_id,
      },
    ],
  },
  create: {
    id: createId({ prefix: "cus_" }),
    name:
      customerDetails.name || customerDetails.email || generateRandomName(),
    email: customerDetails.email,
    externalId: clickEvent.click_id,
    stripeCustomerId,
    linkId: clickEvent.link_id,
    clickId: clickEvent.click_id,
    clickedAt: new Date(clickEvent.timestamp + "Z"),
    country: customerAddress?.country,
    projectId: workspace.id,
    projectConnectId: workspace.stripeConnectId,
    programId: link.programId,
    partnerId: link.partnerId,
  },
});
 
// Concurrent webhook already created this customer — continue sale without re-recording lead
if (!created) {
  let existingLead = await redis.get<LeadEventTB>(`leadCache:${customer.id}`);
 
  if (!existingLead) {
    existingLead = await getLeadEvent({
      customerId: customer.id,
    });
  }
 
  if (!existingLead) {
    console.log(
      `Customer with stripeCustomerId ${stripeCustomerId} already exists but no lead event found, skipping promo code attribution...`,
    );
    return null;
  }
 
  return {
    linkId,
    customer,
    clickEvent,
    leadEvent: {
      ...existingLead,
      workspace_id: workspace.id,
    },
  };
}
 
// Prepare the payload for the lead event
const { timestamp, ...rest } = clickEvent;
 
const leadEvent = {

Copyexport async function attributeViaDiscountCode({
  order,
  workspace,
  link,
}: {
  order: ShopifyOrder;
  workspace: Pick<WorkspaceProps, "id" | "defaultProgramId" | "webhookEnabled">;
  link: Link;
}) {
  const { customer: orderCustomer, billing_address: billingAddress } = order;
 
  const billingAddressCountry = billingAddress?.country_code?.toUpperCase();
 
  // Record a fake click for this event
  const clickEvent = await recordFakeClick({
    link,
    customer: {
      continent: billingAddressCountry
        ? COUNTRIES_TO_CONTINENTS[billingAddressCountry] ?? "Unknown"
        : "Unknown",
      country: billingAddressCountry ?? "Unknown",
      region: billingAddress?.province ?? "Unknown",
    },
  });
 
  const customerId = createId({ prefix: "cus_" });
  const clickId = clickEvent.click_id;
 
  // Create the customer before recording the fake click so a P2002 on
  // projectId_externalId never leaves an orphaned Tinybird click behind.
  const customer = await prisma.customer.create({
    data: {
      id: customerId,
      name: orderCustomer
        ? `${orderCustomer.first_name} ${orderCustomer.last_name}`.trim()
        : generateRandomName(),
      email: orderCustomer?.email,
      externalId: orderCustomer?.id?.toString() || customerId,
      linkId: link.id,
      clickId,
      clickedAt: new Date(),
      country: billingAddress?.country_code,
      projectId: workspace.id,
      programId: link.programId,
      partnerId: link.partnerId,
    },
  });

Copy// Prepare the payload for the lead event
const { timestamp, ...rest } = clickEvent;
 
const leadEvent = {
  ...rest,
  workspace_id: clickEvent.workspace_id || customer.projectId, // in case for some reason the click event doesn't have workspace_id
  event_id: nanoid(16),
  event_name: "Checkout with discount code",
  customer_id: customer.id,
  metadata: "",
};
 
await recordLead(leadEvent);
 
const linkUpdated = await prisma.link.update({
  where: {
    id: link.id,
  },
  data: {
    leads: {
      increment: 1,
    },
    lastLeadAt: new Date(),
  },
  include: includeTags,
});
 
let result:
  | Awaited<ReturnType<typeof queuePartnerCommissionCreation>>
  | undefined = undefined;
 
if (link.programId && link.partnerId) {
  result = await queuePartnerCommissionCreation({
    event: "lead",
    programId: link.programId,
    partnerId: link.partnerId,
    linkId: link.id,
    eventId: leadEvent.event_id,
    customerId: customer.id,
    quantity: 1,
    source: CommissionSource.shopify,
    context: {
      customer: {
        country: customer.country,
      },
    },
  });
 
  await Promise.allSettled([
    executeWorkflows({
      event: "leadRecorded",
      identity: {
        workspaceId: workspace.id,
        programId: link.programId,
        partnerId: link.partnerId,
      },
      metrics: {
        current: {
          leads: 1,
        },
      },
    }),
 
    syncPartnerLinksStats({
      partnerId: link.partnerId,
      programId: link.programId,
      eventType: "lead",
    }),
  ]);
}
 
await Promise.allSettled([
  sendWorkspaceWebhook({
    trigger: "lead.created",
    workspace,
    data: transformLeadEventData({
      ...clickEvent,
      eventName: "Checkout with discount code",
      link: linkUpdated,
      customer,

Copyexport async function recreateCustomerForReattribution({
  customer,
  link,
  newCustomerId,
  newClickId,
}: {
  customer: Customer;
  link: Pick<Link, "id" | "programId" | "partnerId">;
  newCustomerId: string;
  newClickId: string;
}) {
  return await prisma.$transaction(async (tx) => {
    await tx.customer.update({
      where: {
        id: customer.id,
      },
      data: {
        name: customer.name ? `${customer.name} (old)` : undefined,
        externalId: `reattributed_${nanoid(32)}`,
        stripeCustomerId: null,
        linkId: null,
        clickId: null,
        clickedAt: null,
        programId: null,
        partnerId: null,
        sales: 0,
        saleAmount: 0,
        firstSaleAt: null,
        subscriptionCanceledAt: null,
      },
    });
 
    return await tx.customer.create({
      data: {
        id: newCustomerId,
        name: customer.name,
        email: customer.email,
        avatar: customer.avatar,
        externalId: customer.externalId,
        stripeCustomerId: customer.stripeCustomerId,
        clickedAt: customer.clickedAt,
        country: customer.country,
        sales: customer.sales,
        saleAmount: customer.saleAmount,
        firstSaleAt: customer.firstSaleAt,
        subscriptionCanceledAt: customer.subscriptionCanceledAt,
        projectId: customer.projectId,
        projectConnectId: customer.projectConnectId,
        createdAt: customer.createdAt,
        linkId: link.id,
        programId: link.programId,
        partnerId: link.partnerId,
        clickId: newClickId,
      },
    });
  });
}

Copyexport const CUSTOMER_REATTRIBUTION_EVENTS_LIMIT = 500;
const UNPAID_COMMISSION_STATUSES = ["pending", "hold", "processed"] as const;
const STATS_LOCK_TTL_SECONDS = 60 * 60 * 24;

Copyexport const CUSTOMER_REATTRIBUTION_EVENTS_LIMIT = 500;
const UNPAID_COMMISSION_STATUSES = ["pending", "hold", "processed"] as const;
const STATS_LOCK_TTL_SECONDS = 60 * 60 * 24;

Copyawait Promise.all([
  // Record clicks
  fetch(
    `${process.env.TINYBIRD_API_URL}/v0/events?name=dub_click_events&wait=true`,
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.TINYBIRD_API_KEY}`,
        "Content-Type": "application/x-ndjson",
      },
      body: dataArray.map((d) => JSON.stringify(d.clickData)).join("\n"),
    },
  ),
 
  // Record leads
  recordLeadWithTimestamp(dataArray.map((d) => d.leadEventData)),
 
  // Record commissions
  prisma.commission.createMany({
    data: dataArray.map((d) => d.commissionData),
    skipDuplicates: true,
  }),
 
  // Record sales
  recordSaleWithTimestamp(dataArray.map((d) => d.saleEventData)),
 
  // Cache the externalId:eventName pairs
  redis.sadd(
    CACHE_KEY,
    ...(dataArray.map(
      ({ payload: { externalId, eventName } }) =>
        `${externalId}:${eventName}`,
    ) as [string]),
  ),
]);
…
await Promise.all(
  Object.entries(groupedLinks).map(([count, linkKeys]) =>
    prisma.link.updateMany({
      where: {
        shortLink: {
          in: linkKeys.map((key) =>
            linkConstructorSimple({
              domain: DOMAIN,
              key,
            }),
          ),
        },
      },
      data: {
        clicks: {
          increment: parseInt(count),
        },
        leads: {
          increment: parseInt(count),
        },
        sales: {
          increment: parseInt(count),
        },
      },
    }),
  ),

Copyconst cookieStore = await cookies();
const cookieName = getApplicationEventCookieName(NETWORK_PROGRAM_ID);
const applicationEventId = cookieStore.get(cookieName)?.value;
 
if (!applicationEventId) {
  console.log(
    `No application event ID found for network program + new partner ${partner.id}, skipping...`,
  );
  return;
}
 
const applicationEvent = await prisma.programApplicationEvent.findUnique({
  where: {
    id: applicationEventId,
    programId: NETWORK_PROGRAM_ID,
  },
});
 
if (!applicationEvent) {
  console.log(
    `No application event found for new partner ${partner.id}, skipping...`,
  );
  return;
}
 
if (applicationEvent.submittedAt) {
  console.log(
    `Application event already submitted for new partner ${partner.id}, skipping...`,
  );
  return;
}
 
await prisma.$transaction(async (tx) => {
  await tx.programApplicationEvent.update({
    where: {
      id: applicationEventId,
    },
    data: {
      // assuming application starts after 15-45 seconds of visiting the page
      startedAt: addSeconds(applicationEvent.visitedAt, randomInt(15, 45)),
      submittedAt: new Date(),
      partnerId: partner.id,
    },
  });
 
  if (applicationEvent.referredByPartnerId) {
    await tx.partner.update({
      where: {
        id: partner.id,
      },
      data: {
        referredByPartnerId: applicationEvent.referredByPartnerId,
      },
    });
  }
});
…
await prisma.link.update({
  where: {
    id: networkPartnerLink.id,
  },
  data: {
    clicks: {
      increment: 1,
    },
    lastClicked: applicationEvent.visitedAt,
    leads: {
      increment: 1,
    },
    lastLeadAt: new Date(),
  },
});
console.log(`Updated stats for link ${networkPartnerLink.id}`);
 
await syncPartnerLinksStats({
  partnerId: networkPartnerLink.partnerId!,
  programId: networkPartnerLink.programId!,
  eventType: "lead",
});