The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.
TypeScript clickhousemysqlnextjsopen-sourceplanetscaleprismatailwindcsstinybirdtypescriptupstashvercel
initial lemon squeezy importer structure
Pedro Ladeiraaeec6f77b448
diff --git a/apps/web/app/(ee)/api/cron/import/lemonsqueezy/route.ts b/apps/web/app/(ee)/api/cron/import/lemonsqueezy/route.tsnew file mode 100644index 0000000000..e392cc124d--- /dev/null+++ b/apps/web/app/(ee)/api/cron/import/lemonsqueezy/route.ts@@ -0,0 +1,26 @@+import { withCron } from "@/lib/cron/with-cron";+import { importCommissions } from "@/lib/lemonsqueezy/import-commissions";+import { importCustomers } from "@/lib/lemonsqueezy/import-customers";+import { importPartners } from "@/lib/lemonsqueezy/import-partners";+import { lemonSqueezyImportPayloadSchema } from "@/lib/lemonsqueezy/schemas";+import { logAndRespond } from "../../utils";++export const dynamic = "force-dynamic";++export const POST = withCron(async ({ rawBody }) => {+ const payload = lemonSqueezyImportPayloadSchema.parse(JSON.parse(rawBody));++ switch (payload.action) {+ case "import-partners":+ await importPartners(payload);+ break;+ case "import-customers":+ await importCustomers(payload);+ break;+ case "import-commissions":+ await importCommissions(payload);+ break;+ }++ return logAndRespond("OK");+});diff --git a/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/partners-menu-popover.tsx b/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/partners-menu-popover.tsxindex ca526a1b76..3d124ffc53 100644--- a/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/partners-menu-popover.tsx+++ b/apps/web/app/app.dub.co/(dashboard)/[slug]/(ee)/program/partners/partners-menu-popover.tsx@@ -4,6 +4,7 @@ import { PROGRAM_IMPORT_SOURCES } from "@/lib/constants/program";import useWorkspace from "@/lib/swr/use-workspace";import { useExportPartnersModal } from "@/ui/modals/export-partners-modal";import { useImportFirstPromoterModal } from "@/ui/modals/import-firstpromoter-modal";+import { useImportLemonSqueezyModal } from "@/ui/modals/import-lemonsqueezy-modal";import { useImportPartnerStackModal } from "@/ui/modals/import-partnerstack-modal";import { useImportRewardfulModal } from "@/ui/modals/import-rewardful-modal";import { useImportTapfiliateModal } from "@/ui/modals/import-tapfiliate-modal";@@ -23,6 +24,7 @@ export function PartnersMenuPopover() {const { ImportPartnerStackModal } = useImportPartnerStackModal();const { ImportFirstPromoterModal } = useImportFirstPromoterModal();const { ImportTapfiliateModal } = useImportTapfiliateModal();+ const { ImportLemonSqueezyModal } = useImportLemonSqueezyModal();const { ExportPartnersModal, setShowExportPartnersModal } =useExportPartnersModal();@@ -34,6 +36,7 @@ export function PartnersMenuPopover() {<ImportFirstPromoterModal /><ImportPartnerStackModal /><ImportTapfiliateModal />+ <ImportLemonSqueezyModal /><ExportPartnersModal /><Popovercontent={diff --git a/apps/web/lib/actions/partners/set-lemonsqueezy-token.ts b/apps/web/lib/actions/partners/set-lemonsqueezy-token.tsnew file mode 100644index 0000000000..3ba722e44f--- /dev/null+++ b/apps/web/lib/actions/partners/set-lemonsqueezy-token.ts@@ -0,0 +1,50 @@+"use server";++import { LemonSqueezyApi } from "@/lib/lemonsqueezy/api";+import { lemonSqueezyImporter } from "@/lib/lemonsqueezy/importer";+import { LemonSqueezyStore } from "@/lib/lemonsqueezy/types";+import * as z from "zod/v4";+import { authActionClient } from "../safe-action";+import { throwIfNoPermission } from "../throw-if-no-permission";++const schema = z.object({+ workspaceId: z.string(),+ apiKey: z.string().trim().min(1),+});++export const setLemonSqueezyTokenAction = authActionClient+ .inputSchema(schema)+ .action(async ({ parsedInput, ctx }) => {+ const { workspace } = ctx;+ const { apiKey } = parsedInput;++ throwIfNoPermission({+ role: workspace.role,+ requiredRoles: ["owner", "member"],+ });++ const lemonSqueezyApi = new LemonSqueezyApi({+ apiKey,+ });++ let stores: LemonSqueezyStore[];++ try {+ stores = await lemonSqueezyApi.listStores();+ } catch (error) {+ console.error(error);+ throw new Error("Invalid Lemon Squeezy API key.");+ }++ if (stores.length === 0) {+ throw new Error("No stores found in your Lemon Squeezy account.");+ }++ await lemonSqueezyImporter.setCredentials(workspace.id, {+ apiKey,+ });++ return {+ stores,+ };+ });diff --git a/apps/web/lib/actions/partners/start-lemonsqueezy-import.ts b/apps/web/lib/actions/partners/start-lemonsqueezy-import.tsnew file mode 100644index 0000000000..6c727303a2--- /dev/null+++ b/apps/web/lib/actions/partners/start-lemonsqueezy-import.ts@@ -0,0 +1,62 @@+"use server";++import { createId } from "@/lib/api/create-id";+import { getDefaultProgramIdOrThrow } from "@/lib/api/programs/get-default-program-id-or-throw";+import { LemonSqueezyApi } from "@/lib/lemonsqueezy/api";+import { lemonSqueezyImporter } from "@/lib/lemonsqueezy/importer";+import * as z from "zod/v4";+import { getProgramOrThrow } from "../../api/programs/get-program-or-throw";+import { authActionClient } from "../safe-action";+import { throwIfNoPermission } from "../throw-if-no-permission";++const schema = z.object({+ workspaceId: z.string(),+ storeId: z.string().trim().min(1),+});++export const startLemonSqueezyImportAction = authActionClient+ .inputSchema(schema)+ .action(async ({ ctx, parsedInput }) => {+ const { workspace, user } = ctx;+ const { storeId } = parsedInput;++ throwIfNoPermission({+ role: workspace.role,+ requiredRoles: ["owner", "member"],+ });++ const programId = getDefaultProgramIdOrThrow(workspace);++ const program = await getProgramOrThrow({+ workspaceId: workspace.id,+ programId,+ });++ if (!program.domain) {+ throw new Error("Program domain is not set.");+ }++ if (!program.url) {+ throw new Error("Program URL is not set.");+ }++ const credentials = await lemonSqueezyImporter.getCredentials(workspace.id);++ const lemonSqueezyApi = new LemonSqueezyApi({+ apiKey: credentials.apiKey,+ });++ const stores = await lemonSqueezyApi.listStores();++ if (!stores.some((store) => store.id === storeId)) {+ throw new Error("Invalid Lemon Squeezy store ID.");+ }++ await lemonSqueezyImporter.queue({+ importId: createId({ prefix: "import_" }),+ userId: user.id,+ programId: program.id,+ storeId,+ action: "import-partners",+ });+ });diff --git a/apps/web/lib/constants/program.ts b/apps/web/lib/constants/program.tsindex c3cb7e2132..ee463f5dbc 100644--- a/apps/web/lib/constants/program.ts+++ b/apps/web/lib/constants/program.ts@@ -37,6 +37,12 @@ export const PROGRAM_IMPORT_SOURCES = [image: "https://assets.dub.co/misc/icons/tapfiliate.svg",helpUrl: "https://dub.co/help/article/migrating-from-tapfiliate",},+ {+ id: "lemonsqueezy",+ value: "Lemon Squeezy",+ image: "https://assets.dub.co/misc/icons/lemonsqueezy.svg",+ helpUrl: "https://dub.co/help/article/migrating-from-lemonsqueezy",+ },] as const;export const PROGRAM_APPLICATION_IMAGE_MAX_FILE_SIZE_MB = 5;diff --git a/apps/web/lib/lemonsqueezy/api.ts b/apps/web/lib/lemonsqueezy/api.tsnew file mode 100644index 0000000000..7cc6d20cb8--- /dev/null+++ b/apps/web/lib/lemonsqueezy/api.ts@@ -0,0 +1,249 @@+import * as z from "zod/v4";+import {+ lemonSqueezyAffiliateSchema,+ lemonSqueezyCustomerSchema,+ lemonSqueezyJsonApiListSchema,+ lemonSqueezyOrderSchema,+ lemonSqueezyStoreSchema,+ lemonSqueezySubscriptionInvoiceSchema,+} from "./schemas";+import {+ LemonSqueezyAffiliate,+ LemonSqueezyCustomer,+ LemonSqueezyOrder,+ LemonSqueezyStore,+ LemonSqueezySubscriptionInvoice,+} from "./types";++const LEMONSQUEEZY_PAGE_SIZE = 100;++type JsonApiResource = {+ type: string;+ id: string;+ attributes: Record<string, unknown>;+ relationships?: Record<string, unknown>;+};++function flattenResource<T extends z.ZodType>(+ resource: JsonApiResource,+ schema: T,+ extra?: Record<string, unknown>,+): z.infer<T> {+ return schema.parse({+ id: resource.id,+ ...resource.attributes,+ ...extra,+ });+}++function getRelationshipIds(+ resource: JsonApiResource,+ relationshipName: string,+): string[] {+ const relationship = resource.relationships?.[relationshipName] as+ | {+ data?:+ | { type: string; id: string }+ | Array<{ type: string; id: string }>+ | null;+ }+ | undefined;++ if (!relationship?.data) {+ return [];+ }++ if (Array.isArray(relationship.data)) {+ return relationship.data.map((item) => item.id);+ }++ return [relationship.data.id];+}++export class LemonSqueezyApi {+ private readonly baseUrl = "https://api.lemonsqueezy.com/v1";+ private readonly apiKey: string;++ constructor({ apiKey }: { apiKey: string }) {+ this.apiKey = apiKey;+ }++ private async fetch<T>(+ path: string,+ searchParams?: URLSearchParams,+ ): Promise<T> {+ const url = new URL(`${this.baseUrl}${path}`);+ if (searchParams) {+ searchParams.forEach((value, key) => {+ url.searchParams.set(key, value);+ });+ }++ const controller = new AbortController();+ const timeout = setTimeout(() => controller.abort(), 15000);++ let response: Response;++ try {+ response = await fetch(url.toString(), {+ headers: {+ Accept: "application/vnd.api+json",+ "Content-Type": "application/vnd.api+json",+ Authorization: `Bearer ${this.apiKey}`,+ },+ signal: controller.signal,+ });+ } finally {+ clearTimeout(timeout);+ }++ if (!response.ok) {+ const error = await response.text();+ console.error("Lemon Squeezy API Error:", error);++ const retryAfter = response.headers.get("Retry-After");+ const rateLimitMessage =+ response.status === 429+ ? ` Rate limited.${retryAfter ? ` Retry after ${retryAfter}s.` : ""}`+ : "";++ throw new Error(+ `[Lemon Squeezy API] ${+ error ||+ `Request to ${path} failed with status ${response.status}.${rateLimitMessage}`+ }`,+ );+ }++ return (await response.json()) as T;+ }++ private async listResources({+ path,+ storeId,+ page = 1,+ include,+ }: {+ path: string;+ storeId?: string;+ page?: number;+ include?: string;+ }) {+ const searchParams = new URLSearchParams({+ "page[number]": page.toString(),+ "page[size]": LEMONSQUEEZY_PAGE_SIZE.toString(),+ });++ if (storeId) {+ searchParams.set("filter[store_id]", storeId);+ }++ if (include) {+ searchParams.set("include", include);+ }++ const payload = await this.fetch<unknown>(path, searchParams);+ return lemonSqueezyJsonApiListSchema.parse(payload);+ }++ async listStores(): Promise<LemonSqueezyStore[]> {+ const { data } = await this.listResources({ path: "/stores" });++ return data.map((resource) =>+ flattenResource(resource, lemonSqueezyStoreSchema),+ );+ }++ async listAffiliates({+ storeId,+ page = 1,+ }: {+ storeId: string;+ page?: number;+ }): Promise<LemonSqueezyAffiliate[]> {+ const { data } = await this.listResources({+ path: "/affiliates",+ storeId,+ page,+ });++ return data.map((resource) =>+ flattenResource(resource, lemonSqueezyAffiliateSchema),+ );+ }++ async listCustomers({+ storeId,+ page = 1,+ include,+ }: {+ storeId: string;+ page?: number;+ include?: string;+ }): Promise<LemonSqueezyCustomer[]> {+ const { data } = await this.listResources({+ path: "/customers",+ storeId,+ page,+ include,+ });++ return data.map((resource) =>+ flattenResource(resource, lemonSqueezyCustomerSchema, {+ // When `include=affiliates` (or relationship data is sideloaded),+ // JSON:API puts affiliate refs on relationships.affiliates.data+ affiliate_ids: getRelationshipIds(resource, "affiliates"),+ }),+ );+ }++ async listCustomerAffiliates({+ customerId,+ }: {+ customerId: string;+ }): Promise<LemonSqueezyAffiliate[]> {+ const { data } = await this.listResources({+ path: `/customers/${customerId}/affiliates`,+ });++ return data.map((resource) =>+ flattenResource(resource, lemonSqueezyAffiliateSchema),+ );+ }++ async listOrders({+ storeId,+ page = 1,+ }: {+ storeId: string;+ page?: number;+ }): Promise<LemonSqueezyOrder[]> {+ const { data } = await this.listResources({+ path: "/orders",+ storeId,+ page,+ });++ return data.map((resource) =>+ flattenResource(resource, lemonSqueezyOrderSchema),+ );+ }++ async listSubscriptionInvoices({+ storeId,+ page = 1,+ }: {+ storeId: string;+ page?: number;+ }): Promise<LemonSqueezySubscriptionInvoice[]> {+ const { data } = await this.listResources({+ path: "/subscription-invoices",+ storeId,+ page,+ });++ return data.map((resource) =>+ flattenResource(resource, lemonSqueezySubscriptionInvoiceSchema),+ );+ }+}diff --git a/apps/web/lib/lemonsqueezy/import-commissions.ts b/apps/web/lib/lemonsqueezy/import-commissions.tsnew file mode 100644index 0000000000..e37affaac8--- /dev/null+++ b/apps/web/lib/lemonsqueezy/import-commissions.ts@@ -0,0 +1,610 @@+import { prisma } from "@/lib/prisma";+import { sendEmail } from "@dub/email";+import ProgramImported from "@dub/email/templates/program-imported";+import { chunk, nanoid } from "@dub/utils";+import {+ CommissionStatus,+ Customer,+ Link,+ Program,+ Reward,+} from "@prisma/client";+import { convertCurrencyWithFxRates } from "../analytics/convert-currency";+import { isFirstConversion } from "../analytics/is-first-conversion";+import { createId } from "../api/create-id";+import { updateLinkStatsForImporter } from "../api/links/update-link-stats-for-importer";+import { syncPartnerLinksStats } from "../api/partners/sync-partner-links-stats";+import { syncTotalCommissions } from "../api/partners/sync-total-commissions";+import { calculateSaleEarnings } from "../api/sales/calculate-sale-earnings";+import { getLeadEvents } from "../tinybird/get-lead-events";+import { logImportError } from "../tinybird/log-import-error";+import { recordSaleWithTimestamp } from "../tinybird/record-sale";+import { LeadEventTB } from "../types";+import { redis } from "../upstash";+import { clickEventSchemaTB } from "../zod/schemas/clicks";+import { LemonSqueezyApi } from "./api";+import { LEMONSQUEEZY_MAX_BATCHES, lemonSqueezyImporter } from "./importer";+import {+ LemonSqueezyImportPayload,+ LemonSqueezyOrder,+ LemonSqueezySubscriptionInvoice,+} from "./types";++type SaleEvent = {+ invoiceId: string;+ affiliateId: string;+ customerExternalId: string;+ amount: number;+ currency: string;+ amountUsd: number | null | undefined;+ status: string;+ createdAt: string;+ metadata: Record<string, unknown>;+};++const toDubStatus = (status: string): CommissionStatus | null => {+ switch (status) {+ case "paid":+ return "paid";+ case "pending":+ return "pending";+ case "refunded":+ case "partial_refund":+ return "canceled";+ case "void":+ case "failed":+ case "fraudulent":+ return null; // skip+ default:+ return "pending";+ }+};++export async function importCommissions(payload: LemonSqueezyImportPayload) {+ const {+ importId,+ programId,+ storeId,+ userId,+ page = 1,+ resource = "orders",+ } = payload;++ const program = await prisma.program.findUnique({+ where: {+ id: programId,+ },+ });++ if (!program) {+ console.error(`Program ${programId} not found.`);+ return;+ }++ if (!program.domain) {+ console.error("Program domain not found", program.id);+ return;+ }++ const { apiKey } = await lemonSqueezyImporter.getCredentials(+ program.workspaceId,+ );+ const lemonSqueezyApi = new LemonSqueezyApi({ apiKey });++ const fxRates = await redis.hgetall<Record<string, string>>("fxRates:usd");++ let currentPage = page;+ let hasMore = true;+ let processedBatches = 0;++ while (hasMore && processedBatches < LEMONSQUEEZY_MAX_BATCHES) {+ const { saleEvents, pageEmpty } =+ resource === "orders"+ ? await listOrderSaleEvents({+ lemonSqueezyApi,+ storeId,+ page: currentPage,+ })+ : await listInvoiceSaleEvents({+ lemonSqueezyApi,+ storeId,+ page: currentPage,+ });++ if (pageEmpty) {+ hasMore = false;+ break;+ }++ if (saleEvents.length > 0) {+ await processSaleEvents({+ program,+ domain: program.domain,+ saleEvents,+ fxRates,+ importId,+ });+ }++ currentPage++;+ processedBatches++;+ }++ if (hasMore) {+ await lemonSqueezyImporter.queue({+ ...payload,+ action: "import-commissions",+ resource,+ page: currentPage,+ });+ return;+ }++ // Finished orders → continue with subscription invoices (skip initial to avoid double-count)+ if (resource === "orders") {+ await lemonSqueezyImporter.queue({+ ...payload,+ action: "import-commissions",+ resource: "subscription-invoices",+ page: 1,+ });+ return;+ }++ // Imports finished+ await lemonSqueezyImporter.deleteCredentials(program.workspaceId);++ const workspaceUser = await prisma.projectUsers.findUnique({+ where: {+ userId_projectId: {+ userId,+ projectId: program.workspaceId,+ },+ },+ include: {+ project: true,+ user: true,+ },+ });++ if (workspaceUser?.user.email) {+ await sendEmail({+ to: workspaceUser.user.email,+ subject: "Lemon Squeezy program imported",+ react: ProgramImported({+ email: workspaceUser.user.email,+ workspace: workspaceUser.project,+ program,+ provider: "Lemon Squeezy",+ importId,+ }),+ });+ }+}++async function listOrderSaleEvents({+ lemonSqueezyApi,+ storeId,+ page,+}: {+ lemonSqueezyApi: LemonSqueezyApi;+ storeId: string;+ page: number;+}): Promise<{ saleEvents: SaleEvent[]; pageEmpty: boolean }> {+ const orders = await lemonSqueezyApi.listOrders({ storeId, page });++ if (orders.length === 0) {+ return { saleEvents: [], pageEmpty: true };+ }++ const saleEvents = orders+ .filter((order): order is LemonSqueezyOrder & { affiliate_id: number } =>+ Boolean(order.affiliate_id),+ )+ .map((order) => ({+ invoiceId: `ls_order_${order.id}`,+ affiliateId: String(order.affiliate_id),+ customerExternalId: String(order.customer_id),+ amount: order.subtotal,+ currency: order.currency,+ amountUsd: order.subtotal_usd,+ status: order.status,+ createdAt: order.created_at || new Date().toISOString(),+ metadata: order as unknown as Record<string, unknown>,+ }));++ return { saleEvents, pageEmpty: false };+}++async function listInvoiceSaleEvents({+ lemonSqueezyApi,+ storeId,+ page,+}: {+ lemonSqueezyApi: LemonSqueezyApi;+ storeId: string;+ page: number;+}): Promise<{ saleEvents: SaleEvent[]; pageEmpty: boolean }> {+ const invoices = await lemonSqueezyApi.listSubscriptionInvoices({+ storeId,+ page,+ });++ if (invoices.length === 0) {+ return { saleEvents: [], pageEmpty: true };+ }++ const saleEvents = invoices+ .filter(+ (+ invoice,+ ): invoice is LemonSqueezySubscriptionInvoice & {+ affiliate_id: number;+ } =>+ Boolean(invoice.affiliate_id) &&+ // Initial invoices are covered by the Order import+ invoice.billing_reason !== "initial",+ )+ .map((invoice) => ({+ invoiceId: `ls_invoice_${invoice.id}`,+ affiliateId: String(invoice.affiliate_id),+ customerExternalId: String(invoice.customer_id),+ amount: invoice.subtotal,+ currency: invoice.currency,+ amountUsd: invoice.subtotal_usd,+ status: invoice.status,+ createdAt: invoice.created_at || new Date().toISOString(),+ metadata: invoice as unknown as Record<string, unknown>,+ }));++ return { saleEvents, pageEmpty: false };+}++async function processSaleEvents({+ program,+ domain,+ saleEvents,+ fxRates,+ importId,+}: {+ program: Pick<Program, "id" | "workspaceId">;+ domain: string;+ saleEvents: SaleEvent[];+ fxRates: Record<string, string> | null;+ importId: string;+}) {+ const affiliateIds = [+ ...new Set(saleEvents.map((event) => event.affiliateId)),+ ];+ const customerExternalIds = [+ ...new Set(saleEvents.map((event) => event.customerExternalId)),+ ];++ const [links, customersData] = await Promise.all([+ prisma.link.findMany({+ where: {+ domain,+ key: {+ in: affiliateIds,+ },+ },+ }),+ prisma.customer.findMany({+ where: {+ projectId: program.workspaceId,+ externalId: {+ in: customerExternalIds,+ },+ },+ include: {+ link: true,+ },+ orderBy: {+ createdAt: "asc",+ },+ }),+ ]);++ const affiliateIdToLink = new Map(links.map((link) => [link.key, link]));++ const partnerIds = [+ ...new Set(+ links+ .map((link) => link.partnerId)+ .filter((id): id is string => Boolean(id)),+ ),+ ];++ const enrollments = await prisma.programEnrollment.findMany({+ where: {+ programId: program.id,+ partnerId: {+ in: partnerIds,+ },+ },+ include: {+ saleReward: true,+ },+ });++ const partnerIdToSaleReward = new Map(+ enrollments.map((enrollment) => [+ enrollment.partnerId,+ enrollment.saleReward,+ ]),+ );++ const customerLeadEvents = await getLeadEvents({+ customerIds: customersData.map((customer) => customer.id),+ }).then((res) => res.data);++ const saleChunks = chunk(saleEvents, 10);++ for (const saleChunk of saleChunks) {+ await Promise.all(+ saleChunk.map((saleEvent) =>+ createCommission({+ program,+ saleEvent,+ partnerLink: affiliateIdToLink.get(saleEvent.affiliateId),+ saleReward: (() => {+ const partnerId = affiliateIdToLink.get(+ saleEvent.affiliateId,+ )?.partnerId;+ return partnerId+ ? partnerIdToSaleReward.get(partnerId) ?? null+ : null;+ })(),+ fxRates,+ importId,+ customersData,+ customerLeadEvents,+ }),+ ),+ );+ }+}++async function createCommission({+ program,+ saleEvent,+ partnerLink,+ saleReward,+ fxRates,+ importId,+ customersData,+ customerLeadEvents,+}: {+ program: Pick<Program, "id" | "workspaceId">;+ saleEvent: SaleEvent;+ partnerLink?: Link;+ saleReward: Reward | null;+ fxRates: Record<string, string> | null;+ importId: string;+ customersData: (Customer & { link: Link | null })[];+ customerLeadEvents: LeadEventTB[];+}) {+ const commonImportLogInputs = {+ workspace_id: program.workspaceId,+ import_id: importId,+ source: "lemonsqueezy" as const,+ entity: "commission" as const,+ entity_id: saleEvent.invoiceId,+ };++ const status = toDubStatus(saleEvent.status);+ if (!status) {+ return;+ }++ const existingCommission = await prisma.commission.findUnique({+ where: {+ invoiceId_programId: {+ invoiceId: saleEvent.invoiceId,+ programId: program.id,+ },+ },+ select: {+ id: true,+ },+ });++ if (existingCommission) {+ console.log(+ `Commission ${saleEvent.invoiceId} already exists, skipping...`,+ );+ return;+ }++ if (!partnerLink?.partnerId) {+ await logImportError({+ ...commonImportLogInputs,+ code: "PARTNER_NOT_FOUND",+ message: `No imported partner found for affiliate ${saleEvent.affiliateId} (commission ${saleEvent.invoiceId}).`,+ });+ return;+ }++ const existingCustomer = customersData.find(+ ({ externalId }) => externalId === saleEvent.customerExternalId,+ );++ if (!existingCustomer) {+ await logImportError({+ ...commonImportLogInputs,+ code: "CUSTOMER_NOT_FOUND",+ message: `No customer ${saleEvent.customerExternalId} found for commission ${saleEvent.invoiceId}.`,+ });+ return;+ }++ if (!existingCustomer.clickId) {+ await logImportError({+ ...commonImportLogInputs,+ code: "CLICK_NOT_FOUND",+ message: `No click found for customer ${existingCustomer.id}.`,+ });+ return;+ }++ const leadEvent = customerLeadEvents.find(+ (event) => event.customer_id === existingCustomer.id,+ );++ if (!leadEvent) {+ await logImportError({+ ...commonImportLogInputs,+ code: "LEAD_NOT_FOUND",+ message: `No lead event found for customer ${existingCustomer.id}.`,+ });+ return;+ }++ // Prefer LS-provided USD amounts; otherwise convert+ let saleAmount = saleEvent.amountUsd ?? saleEvent.amount;+ if (+ saleEvent.amountUsd == null &&+ saleEvent.currency.toUpperCase() !== "USD" &&+ fxRates+ ) {+ const { amount: convertedAmount } = convertCurrencyWithFxRates({+ currency: saleEvent.currency,+ amount: saleAmount,+ fxRates,+ });+ saleAmount = convertedAmount;+ }++ const createdAt = new Date(saleEvent.createdAt);+ const trackedCommission = await prisma.commission.findFirst({+ where: {+ customerId: existingCustomer.id,+ programId: program.id,+ createdAt: {+ gte: new Date(createdAt.getTime() - 60 * 60 * 1000),+ lte: new Date(createdAt.getTime() + 60 * 60 * 1000),+ },+ type: "sale",+ amount: saleAmount,+ },+ });++ if (trackedCommission) {+ console.log(+ `Commission ${saleEvent.invoiceId} with sale amount ${saleAmount} was already recorded on Dub. Skipping...`,+ );+ return;+ }++ // LS does not expose per-order commission amounts; derive from Dub sale reward+ const earnings = saleReward+ ? calculateSaleEarnings({+ reward: {+ type: saleReward.type,+ amountInCents: saleReward.amountInCents,+ amountInPercentage: saleReward.amountInPercentage+ ? Number(saleReward.amountInPercentage)+ : null,+ },+ sale: {+ amount: saleAmount,+ quantity: 1,+ },+ })+ : 0;++ const clickData = clickEventSchemaTB+ .omit({ timestamp: true })+ .parse(leadEvent);++ const eventId = nanoid(16);++ await Promise.all([+ prisma.commission.create({+ data: {+ id: createId({ prefix: "cm_" }),+ eventId,+ type: "sale",+ programId: program.id,+ partnerId: partnerLink.partnerId,+ linkId: partnerLink.id,+ customerId: existingCustomer.id,+ amount: saleAmount,+ earnings,+ currency: "usd",+ quantity: 1,+ status,+ invoiceId: saleEvent.invoiceId,+ createdAt,+ },+ }),++ saleAmount > 0 &&+ recordSaleWithTimestamp({+ ...clickData,+ event_id: eventId,+ event_name: "Invoice paid",+ amount: saleAmount,+ customer_id: existingCustomer.id,+ payment_processor: "lemonsqueezy",+ currency: "usd",+ metadata: JSON.stringify(saleEvent.metadata),+ timestamp: createdAt.toISOString(),+ }),++ prisma.link.update({+ where: {+ id: partnerLink.id,+ },+ data: {+ ...(isFirstConversion({+ customer: existingCustomer,+ linkId: partnerLink.id,+ }) && {+ conversions: {+ increment: 1,+ },+ lastConversionAt: updateLinkStatsForImporter({+ currentTimestamp: partnerLink.lastConversionAt,+ newTimestamp: createdAt,+ }),+ }),+ ...(saleAmount > 0 && {+ sales: {+ increment: 1,+ },+ saleAmount: {+ increment: saleAmount,+ },+ }),+ },+ }),++ syncPartnerLinksStats({+ partnerId: partnerLink.partnerId,+ programId: program.id,+ eventType: "sale",+ }),++ saleAmount > 0 &&+ prisma.customer.update({+ where: {+ id: existingCustomer.id,+ },+ data: {+ sales: {+ increment: 1,+ },+ saleAmount: {+ increment: saleAmount,+ },+ firstSaleAt: existingCustomer.firstSaleAt ? undefined : createdAt,+ },+ }),+ ]);++ await syncTotalCommissions({+ partnerId: partnerLink.partnerId,+ programId: program.id,+ });+}diff --git a/apps/web/lib/lemonsqueezy/import-customers.ts b/apps/web/lib/lemonsqueezy/import-customers.tsnew file mode 100644index 0000000000..7196480f5a--- /dev/null+++ b/apps/web/lib/lemonsqueezy/import-customers.ts@@ -0,0 +1,296 @@+import { prisma } from "@/lib/prisma";+import { chunk, nanoid } from "@dub/utils";+import { Customer, Link, Project } from "@prisma/client";+import { createId } from "../api/create-id";+import { updateLinkStatsForImporter } from "../api/links/update-link-stats-for-importer";+import { syncPartnerLinksStats } from "../api/partners/sync-partner-links-stats";+import { recordClick, recordLeadWithTimestamp } from "../tinybird";+import { logImportError } from "../tinybird/log-import-error";+import { clickEventSchemaTB } from "../zod/schemas/clicks";+import { LemonSqueezyApi } from "./api";+import { LEMONSQUEEZY_MAX_BATCHES, lemonSqueezyImporter } from "./importer";+import { LemonSqueezyCustomer, LemonSqueezyImportPayload } from "./types";++export async function importCustomers(payload: LemonSqueezyImportPayload) {+ const { importId, programId, storeId, page = 1 } = payload;++ const program = await prisma.program.findUnique({+ where: {+ id: programId,+ },+ include: {+ workspace: {+ select: {+ id: true,+ plan: true,+ stripeConnectId: true,+ },+ },+ },+ });++ if (!program) {+ console.error(`Program ${programId} not found.`);+ return;+ }++ if (!program.domain || !program.url) {+ console.error("Program domain or url not found", program.id);+ return;+ }++ const { workspace } = program;+ const { apiKey } = await lemonSqueezyImporter.getCredentials(workspace.id);+ const lemonSqueezyApi = new LemonSqueezyApi({ apiKey });++ let currentPage = page;+ let hasMore = true;+ let processedBatches = 0;++ while (hasMore && processedBatches < LEMONSQUEEZY_MAX_BATCHES) {+ const customers = await lemonSqueezyApi.listCustomers({+ storeId,+ page: currentPage,+ include: "affiliates",+ });++ if (customers.length === 0) {+ hasMore = false;+ break;+ }++ // Gate: only import customers with a non-empty affiliates relationship+ const referredCustomers = customers.filter(+ (customer) => customer.affiliate_ids.length > 0,+ );++ if (referredCustomers.length > 0) {+ const affiliateIds = [+ ...new Set(+ referredCustomers.flatMap((customer) => customer.affiliate_ids),+ ),+ ];++ const links = await prisma.link.findMany({+ where: {+ domain: program.domain,+ key: {+ in: affiliateIds,+ },+ },+ select: {+ id: true,+ key: true,+ domain: true,+ url: true,+ partnerId: true,+ programId: true,+ lastLeadAt: true,+ },+ });++ const affiliateIdToLink = new Map(links.map((link) => [link.key, link]));++ const customerExternalIds = referredCustomers.map(+ (customer) => customer.id,+ );++ const existingCustomers = await prisma.customer.findMany({+ where: {+ projectId: workspace.id,+ externalId: {+ in: customerExternalIds,+ },+ },+ select: {+ id: true,+ externalId: true,+ },+ });++ const existingExternalIds = new Set(+ existingCustomers.map((customer) => customer.externalId),+ );++ const newCustomers = referredCustomers.filter(+ (customer) => !existingExternalIds.has(customer.id),+ );++ if (newCustomers.length > 0) {+ const customerChunks = chunk(newCustomers, 10);++ for (const customerChunk of customerChunks) {+ await Promise.all(+ customerChunk.map((customer) => {+ // Deterministic: first affiliate_id that has an imported partner link+ const affiliateId = customer.affiliate_ids.find((id) =>+ affiliateIdToLink.has(id),+ );++ return createCustomer({+ workspace,+ customer,+ link: affiliateId+ ? affiliateIdToLink.get(affiliateId)+ : undefined,+ importId,+ });+ }),+ );+ }+ }+ }++ currentPage++;+ processedBatches++;+ }++ await lemonSqueezyImporter.queue({+ ...payload,+ action: hasMore ? "import-customers" : "import-commissions",+ page: hasMore ? currentPage : undefined,+ resource: hasMore ? undefined : "orders",+ });+}++async function createCustomer({+ workspace,+ customer,+ link,+ importId,+}: {+ workspace: Pick<Project, "id" | "stripeConnectId">;+ customer: LemonSqueezyCustomer;+ link?: Pick<+ Link,+ "id" | "key" | "domain" | "url" | "partnerId" | "programId" | "lastLeadAt"+ >;+ importId: string;+}) {+ const externalId = customer.id;++ const commonImportLogInputs = {+ workspace_id: workspace.id,+ import_id: importId,+ source: "lemonsqueezy" as const,+ entity: "customer" as const,+ entity_id: externalId,+ };++ if (!customer.email) {+ await logImportError({+ ...commonImportLogInputs,+ code: "CUSTOMER_EMAIL_NOT_FOUND",+ message: `Customer ${externalId} not imported because it has no email.`,+ });++ return;+ }++ if (!link) {+ await logImportError({+ ...commonImportLogInputs,+ code: "LINK_NOT_FOUND",+ message: `No imported partner link found for customer ${externalId} (affiliates: ${customer.affiliate_ids.join(", ")}).`,+ });++ return;+ }++ const clickedAt = new Date(customer.created_at || Date.now());++ const dummyRequest = new Request(link.url, {+ headers: new Headers({+ "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",+ "x-forwarded-for": "127.0.0.1",+ "x-vercel-ip-country": customer.country || "US",+ "x-vercel-ip-country-region": "CA",+ "x-vercel-ip-continent": "NA",+ }),+ });++ const clickData = await recordClick({+ req: dummyRequest,+ clickId: nanoid(16),+ workspaceId: workspace.id,+ linkId: link.id,+ domain: link.domain,+ key: link.key,+ url: link.url,+ skipRatelimit: true,+ timestamp: clickedAt.toISOString(),+ });++ const clickEvent = clickEventSchemaTB.parse({+ ...clickData,+ bot: 0,+ qr: 0,+ });++ let createdCustomer: Customer | null = null;++ try {+ createdCustomer = await prisma.customer.create({+ data: {+ id: createId({ prefix: "cus_" }),+ name: customer.name || customer.email,+ email: customer.email,+ externalId,+ projectId: workspace.id,+ projectConnectId: workspace.stripeConnectId,+ clickId: clickEvent.click_id,+ linkId: link.id,+ programId: link.programId,+ partnerId: link.partnerId,+ country: customer.country || clickEvent.country,+ clickedAt,+ createdAt: clickedAt,+ },+ });+ } catch (error) {+ if (error.code === "P2002") {+ console.warn(+ `Customer with external ID ${externalId} already exists. Skipping...`,+ );+ } else {+ console.error("Error creating customer", customer, error);+ }++ return;+ }++ await Promise.all([+ recordLeadWithTimestamp({+ ...clickEvent,+ event_id: nanoid(16),+ event_name: "Sign up",+ customer_id: createdCustomer.id,+ timestamp: clickedAt.toISOString(),+ }),++ prisma.link.update({+ where: {+ id: link.id,+ },+ data: {+ leads: {+ increment: 1,+ },+ lastLeadAt: updateLinkStatsForImporter({+ currentTimestamp: link.lastLeadAt,+ newTimestamp: clickedAt,+ }),+ },+ }),++ ...(link.partnerId && link.programId+ ? [+ syncPartnerLinksStats({+ partnerId: link.partnerId,+ programId: link.programId,+ eventType: "lead",+ }),+ ]+ : []),+ ]);+}diff --git a/apps/web/lib/lemonsqueezy/import-partners.ts b/apps/web/lib/lemonsqueezy/import-partners.tsnew file mode 100644index 0000000000..c3eab9d331--- /dev/null+++ b/apps/web/lib/lemonsqueezy/import-partners.ts@@ -0,0 +1,250 @@+import { prisma } from "@/lib/prisma";+import { PartnerGroup, Program } from "@prisma/client";+import { createId } from "../api/create-id";+import { createLink } from "../api/links";+import { generatePartnerLink } from "../api/partners/generate-partner-link";+import { logImportError } from "../tinybird/log-import-error";+import { WorkspaceProps } from "../types";+import { DEFAULT_PARTNER_GROUP } from "../zod/schemas/groups";+import { LemonSqueezyApi } from "./api";+import { LEMONSQUEEZY_MAX_BATCHES, lemonSqueezyImporter } from "./importer";+import { LemonSqueezyAffiliate, LemonSqueezyImportPayload } from "./types";++export async function importPartners(payload: LemonSqueezyImportPayload) {+ const { importId, programId, storeId, userId, page = 1 } = payload;++ const program = await prisma.program.findUnique({+ where: {+ id: programId,+ },+ include: {+ groups: {+ select: {+ id: true,+ slug: true,+ clickRewardId: true,+ leadRewardId: true,+ saleRewardId: true,+ referralRewardId: true,+ discountId: true,+ },+ },+ workspace: {+ select: {+ id: true,+ plan: true,+ },+ },+ },+ });++ if (!program) {+ console.error(`Program ${programId} not found.`);+ return;+ }++ if (!program.domain || !program.url) {+ console.error("Program domain or url not found", program.id);+ return;+ }++ const defaultGroup = program.groups.find(+ (group) => group.slug === DEFAULT_PARTNER_GROUP.slug,+ );++ if (!defaultGroup) {+ console.error(`Default group not found for program ${programId}.`);+ return;+ }++ const workspace = program.workspace as WorkspaceProps;++ const { apiKey } = await lemonSqueezyImporter.getCredentials(workspace.id);+ const lemonSqueezyApi = new LemonSqueezyApi({ apiKey });++ let currentPage = page;+ let hasMore = true;+ let processedBatches = 0;++ const commonImportLogInputs = {+ workspace_id: program.workspaceId,+ import_id: importId,+ source: "lemonsqueezy" as const,+ entity: "partner" as const,+ };++ while (hasMore && processedBatches < LEMONSQUEEZY_MAX_BATCHES) {+ const affiliates = await lemonSqueezyApi.listAffiliates({+ storeId,+ page: currentPage,+ });++ if (affiliates.length === 0) {+ hasMore = false;+ break;+ }++ const activeAffiliates: LemonSqueezyAffiliate[] = [];+ const notImportedAffiliates: LemonSqueezyAffiliate[] = [];++ for (const affiliate of affiliates) {+ // LS has no leads count on affiliates. Import all active partners;+ // pending/disabled are skipped. Customer/commission steps only+ // attach referred activity.+ if (affiliate.status === "active") {+ activeAffiliates.push(affiliate);+ } else {+ notImportedAffiliates.push(affiliate);+ }+ }++ if (activeAffiliates.length > 0) {+ await Promise.allSettled(+ activeAffiliates.map((affiliate) =>+ createPartnerAndLinks({+ workspace,+ program,+ affiliate,+ group: defaultGroup,+ userId,+ importId,+ }),+ ),+ );+ }++ if (notImportedAffiliates.length > 0) {+ await logImportError(+ notImportedAffiliates.map((affiliate) => ({+ ...commonImportLogInputs,+ entity_id: affiliate.id,+ code: "INACTIVE_PARTNER",+ message: `Partner ${affiliate.user_email} not imported because status is "${affiliate.status}" (only active affiliates are imported).`,+ })),+ );+ }++ currentPage++;+ processedBatches++;+ }++ await lemonSqueezyImporter.queue({+ ...payload,+ action: hasMore ? "import-partners" : "import-customers",+ page: hasMore ? currentPage : undefined,+ });+}++async function createPartnerAndLinks({+ workspace,+ program,+ affiliate,+ group,+ userId,+ importId,+}: {+ workspace: Pick<WorkspaceProps, "id" | "plan">;+ program: Pick<+ Program,+ "id" | "workspaceId" | "domain" | "url" | "defaultFolderId"+ >;+ affiliate: LemonSqueezyAffiliate;+ group: Pick<+ PartnerGroup,+ | "id"+ | "discountId"+ | "clickRewardId"+ | "leadRewardId"+ | "saleRewardId"+ | "referralRewardId"+ >;+ userId: string;+ importId: string;+}) {+ if (!affiliate.user_email) {+ await logImportError({+ workspace_id: program.workspaceId,+ import_id: importId,+ source: "lemonsqueezy",+ entity: "partner",+ entity_id: affiliate.id,+ code: "PARTNER_NOT_FOUND",+ message: `Affiliate ${affiliate.id} not imported because it has no email.`,+ });++ return;+ }++ const partner = await prisma.partner.upsert({+ where: {+ email: affiliate.user_email,+ },+ create: {+ id: createId({ prefix: "pn_" }),+ name: affiliate.user_name || affiliate.user_email,+ email: affiliate.user_email,+ },+ update: {},+ });++ const { links } = await prisma.programEnrollment.upsert({+ where: {+ partnerId_programId: {+ partnerId: partner.id,+ programId: program.id,+ },+ },+ create: {+ id: createId({ prefix: "pge_" }),+ programId: program.id,+ partnerId: partner.id,+ status: "approved",+ groupId: group.id,+ clickRewardId: group.clickRewardId,+ leadRewardId: group.leadRewardId,+ saleRewardId: group.saleRewardId,+ referralRewardId: group.referralRewardId,+ discountId: group.discountId,+ },+ update: {+ status: "approved",+ },+ select: {+ links: {+ select: {+ key: true,+ },+ },+ },+ });++ if (links.length > 0 && links.some((link) => link.key === affiliate.id)) {+ console.log(+ `Partner ${partner.email} already has a link with key ${affiliate.id}, skipping...`,+ );+ return;+ }++ try {+ const partnerLink = await generatePartnerLink({+ workspace,+ program,+ partner: {+ id: partner.id,+ name: partner.name,+ email: partner.email!,+ },+ link: {+ domain: program.domain!,+ url: program.url!,+ // Use affiliate id so commissions can map affiliate_id → partner link+ key: affiliate.id,+ },+ userId,+ });++ await createLink(partnerLink);+ } catch (error) {+ console.error("Error creating partner link", error, affiliate);+ }+}diff --git a/apps/web/lib/lemonsqueezy/importer.ts b/apps/web/lib/lemonsqueezy/importer.tsnew file mode 100644index 0000000000..fcb395b874--- /dev/null+++ b/apps/web/lib/lemonsqueezy/importer.ts@@ -0,0 +1,50 @@+import { qstash } from "@/lib/cron";+import { redis } from "@/lib/upstash";+import { APP_DOMAIN_WITH_NGROK } from "@dub/utils";+import { LemonSqueezyCredentials, LemonSqueezyImportPayload } from "./types";++// Lemon Squeezy rate limit is 300 requests per minute+export const LEMONSQUEEZY_MAX_BATCHES = 10;++export const CACHE_EXPIRY = 60 * 60 * 24;+export const CACHE_KEY_PREFIX = "lemonsqueezy:import";++class LemonSqueezyImporter {+ async setCredentials(+ workspaceId: string,+ credentials: LemonSqueezyCredentials,+ ) {+ await redis.set(`${CACHE_KEY_PREFIX}:${workspaceId}`, credentials, {+ ex: CACHE_EXPIRY,+ });+ }++ async getCredentials(workspaceId: string): Promise<LemonSqueezyCredentials> {+ const credentials = await redis.get<LemonSqueezyCredentials>(+ `${CACHE_KEY_PREFIX}:${workspaceId}`,+ );++ if (!credentials) {+ throw new Error(+ "Lemon Squeezy credentials not found. Please restart the import process.",+ );+ }++ return credentials;+ }++ async deleteCredentials(workspaceId: string) {+ return await redis.del(`${CACHE_KEY_PREFIX}:${workspaceId}`);+ }++ async queue(body: LemonSqueezyImportPayload, options?: { delay?: number }) {+ return await qstash.publishJSON({+ url: `${APP_DOMAIN_WITH_NGROK}/api/cron/import/lemonsqueezy`,+ body,+ contentBasedDeduplication: true,+ ...(options?.delay != null && { delay: options.delay }),+ });+ }+}++export const lemonSqueezyImporter = new LemonSqueezyImporter();diff --git a/apps/web/lib/lemonsqueezy/schemas.ts b/apps/web/lib/lemonsqueezy/schemas.tsnew file mode 100644index 0000000000..5aba0a5bd0--- /dev/null+++ b/apps/web/lib/lemonsqueezy/schemas.ts@@ -0,0 +1,158 @@+import * as z from "zod/v4";++export const lemonSqueezyImportSteps = z.enum([+ "import-partners",+ "import-customers",+ "import-commissions",+]);++export const lemonSqueezyImportPayloadSchema = z.object({+ importId: z.string(),+ userId: z.string(),+ programId: z.string(),+ storeId: z.string(),+ action: lemonSqueezyImportSteps,+ page: z.number().optional(),+ // Used by import-commissions to paginate orders first, then subscription invoices+ resource: z.enum(["orders", "subscription-invoices"]).optional(),+});++const jsonApiResourceSchema = z.object({+ type: z.string(),+ id: z.string(),+ attributes: z.record(z.string(), z.unknown()),+ relationships: z.record(z.string(), z.unknown()).optional(),+});++export const lemonSqueezyJsonApiListSchema = z.object({+ data: z.array(jsonApiResourceSchema),+ included: z.array(jsonApiResourceSchema).optional(),+ meta: z+ .object({+ page: z+ .object({+ currentPage: z.number(),+ from: z.number().nullable().optional(),+ lastPage: z.number(),+ perPage: z.number(),+ to: z.number().nullable().optional(),+ total: z.number(),+ })+ .optional(),+ })+ .optional(),+ links: z+ .object({+ first: z.string().optional(),+ last: z.string().optional(),+ next: z.string().nullable().optional(),+ prev: z.string().nullable().optional(),+ })+ .optional(),+});++export const lemonSqueezyStoreSchema = z.object({+ id: z.string(),+ name: z.string(),+ slug: z.string(),+ domain: z.string(),+ url: z.string(),+ currency: z.string().nullish(),+ total_sales: z.number().nullish(),+ total_revenue: z.number().nullish(),+ created_at: z.string().nullish(),+ updated_at: z.string().nullish(),+});++export const lemonSqueezyAffiliateSchema = z.object({+ id: z.string(),+ store_id: z.number(),+ user_id: z.number().nullish(),+ user_name: z.string().nullish(),+ user_email: z.string(),+ share_domain: z.string().nullish(),+ status: z.string(),+ products: z.unknown().nullish(),+ application_note: z.string().nullish(),+ total_earnings: z.number().nullish(),+ unpaid_earnings: z.number().nullish(),+ created_at: z.string().nullish(),+ updated_at: z.string().nullish(),+ // Optional if Lemon Squeezy exposes the affiliate link token+ token: z.string().nullish(),+});++export const lemonSqueezyCustomerSchema = z.object({+ id: z.string(),+ store_id: z.number(),+ name: z.string().nullish(),+ email: z.string(),+ status: z.string().nullish(),+ city: z.string().nullish(),+ region: z.string().nullish(),+ country: z.string().nullish(),+ total_revenue_currency: z.number().nullish(),+ mrr: z.number().nullish(),+ created_at: z.string().nullish(),+ updated_at: z.string().nullish(),+ test_mode: z.boolean().nullish(),+ affiliate_ids: z.array(z.string()).default([]),+});++export const lemonSqueezyOrderSchema = z.object({+ id: z.string(),+ store_id: z.number(),+ customer_id: z.number(),+ affiliate_id: z.number().nullish(),+ identifier: z.string().nullish(),+ order_number: z.number().nullish(),+ user_name: z.string().nullish(),+ user_email: z.string().nullish(),+ currency: z.string(),+ currency_rate: z.union([z.string(), z.number()]).nullish(),+ subtotal: z.number(),+ discount_total: z.number().nullish(),+ tax: z.number().nullish(),+ total: z.number().nullish(),+ subtotal_usd: z.number().nullish(),+ discount_total_usd: z.number().nullish(),+ tax_usd: z.number().nullish(),+ total_usd: z.number().nullish(),+ refunded_amount: z.number().nullish(),+ refunded_amount_usd: z.number().nullish(),+ status: z.string(),+ refunded: z.boolean().nullish(),+ refunded_at: z.string().nullish(),+ created_at: z.string().nullish(),+ updated_at: z.string().nullish(),+ test_mode: z.boolean().nullish(),+});++export const lemonSqueezySubscriptionInvoiceSchema = z.object({+ id: z.string(),+ store_id: z.number(),+ subscription_id: z.number().nullish(),+ customer_id: z.number(),+ affiliate_id: z.number().nullish(),+ user_name: z.string().nullish(),+ user_email: z.string().nullish(),+ billing_reason: z.string().nullish(),+ currency: z.string(),+ currency_rate: z.union([z.string(), z.number()]).nullish(),+ status: z.string(),+ refunded: z.boolean().nullish(),+ refunded_at: z.string().nullish(),+ subtotal: z.number(),+ discount_total: z.number().nullish(),+ tax: z.number().nullish(),+ total: z.number().nullish(),+ refunded_amount: z.number().nullish(),+ subtotal_usd: z.number().nullish(),+ discount_total_usd: z.number().nullish(),+ tax_usd: z.number().nullish(),+ total_usd: z.number().nullish(),+ refunded_amount_usd: z.number().nullish(),+ created_at: z.string().nullish(),+ updated_at: z.string().nullish(),+ test_mode: z.boolean().nullish(),+});diff --git a/apps/web/lib/lemonsqueezy/types.ts b/apps/web/lib/lemonsqueezy/types.tsnew file mode 100644index 0000000000..3706b240f2--- /dev/null+++ b/apps/web/lib/lemonsqueezy/types.ts@@ -0,0 +1,29 @@+import * as z from "zod/v4";+import {+ lemonSqueezyAffiliateSchema,+ lemonSqueezyCustomerSchema,+ lemonSqueezyImportPayloadSchema,+ lemonSqueezyOrderSchema,+ lemonSqueezyStoreSchema,+ lemonSqueezySubscriptionInvoiceSchema,+} from "./schemas";++export interface LemonSqueezyCredentials {+ apiKey: string;+}++export type LemonSqueezyImportPayload = z.infer<+ typeof lemonSqueezyImportPayloadSchema+>;++export type LemonSqueezyStore = z.infer<typeof lemonSqueezyStoreSchema>;++export type LemonSqueezyAffiliate = z.infer<typeof lemonSqueezyAffiliateSchema>;++export type LemonSqueezyCustomer = z.infer<typeof lemonSqueezyCustomerSchema>;++export type LemonSqueezyOrder = z.infer<typeof lemonSqueezyOrderSchema>;++export type LemonSqueezySubscriptionInvoice = z.infer<+ typeof lemonSqueezySubscriptionInvoiceSchema+>;diff --git a/apps/web/lib/zod/schemas/import-error-log.ts b/apps/web/lib/zod/schemas/import-error-log.tsindex bde1e972d2..f215e4107f 100644--- a/apps/web/lib/zod/schemas/import-error-log.ts+++ b/apps/web/lib/zod/schemas/import-error-log.ts@@ -9,6 +9,7 @@ export const importErrorLogSchema = z.object({"partnerstack","firstpromoter","tapfiliate",+ "lemonsqueezy",]),entity: z.enum(["partner", "link", "customer", "commission"]),entity_id: z.string(),diff --git a/apps/web/ui/modals/import-lemonsqueezy-modal.tsx b/apps/web/ui/modals/import-lemonsqueezy-modal.tsxnew file mode 100644index 0000000000..d0e0166a2f--- /dev/null+++ b/apps/web/ui/modals/import-lemonsqueezy-modal.tsx@@ -0,0 +1,328 @@+import { setLemonSqueezyTokenAction } from "@/lib/actions/partners/set-lemonsqueezy-token";+import { startLemonSqueezyImportAction } from "@/lib/actions/partners/start-lemonsqueezy-import";+import { LemonSqueezyStore } from "@/lib/lemonsqueezy/types";+import useWorkspace from "@/lib/swr/use-workspace";+import {+ Button,+ Check2,+ Logo,+ Modal,+ ScrollContainer,+ useMediaQuery,+ useRouterStuff,+} from "@dub/ui";+import { cn, nFormatter } from "@dub/utils";+import { ArrowRight } from "lucide-react";+import { AnimatePresence, motion } from "motion/react";+import { useAction } from "next-safe-action/hooks";+import { useRouter, useSearchParams } from "next/navigation";+import {+ Dispatch,+ SetStateAction,+ useCallback,+ useEffect,+ useMemo,+ useState,+} from "react";+import { toast } from "sonner";+import { MarkdownDescription } from "../shared/markdown-description";++type Step = "set-token" | "select-store";++function ImportLemonSqueezyModal({+ showImportLemonSqueezyModal,+ setShowImportLemonSqueezyModal,+}: {+ showImportLemonSqueezyModal: boolean;+ setShowImportLemonSqueezyModal: Dispatch<SetStateAction<boolean>>;+}) {+ const searchParams = useSearchParams();+ const { queryParams } = useRouterStuff();+ const [step, setStep] = useState<Step>("set-token");+ const [stores, setStores] = useState<LemonSqueezyStore[]>([]);++ useEffect(() => {+ if (searchParams?.get("import") === "lemonsqueezy") {+ setShowImportLemonSqueezyModal(true);+ } else {+ setShowImportLemonSqueezyModal(false);+ }+ }, [searchParams]);++ useEffect(() => {+ if (!showImportLemonSqueezyModal) {+ setStep("set-token");+ setStores([]);+ }+ }, [showImportLemonSqueezyModal]);++ return (+ <Modal+ showModal={showImportLemonSqueezyModal}+ setShowModal={setShowImportLemonSqueezyModal}+ onClose={() =>+ queryParams({+ del: "import",+ })+ }+ >+ <div className="flex flex-col items-center justify-center space-y-3 border-b border-neutral-200 px-4 py-8 sm:px-16">+ <div className="flex items-center space-x-3 py-4">+ <img+ src="https://assets.dub.co/misc/icons/lemonsqueezy.svg"+ alt="Lemon Squeezy logo"+ className="h-10 w-10 rounded-full"+ />+ <ArrowRight className="h-5 w-5 text-neutral-600" />+ <Logo />+ </div>+ <h3 className="text-lg font-medium">+ Import your Lemon Squeezy program+ </h3>+ <MarkdownDescription className="text-center text-sm text-neutral-500">+ [Migrate your existing Lemon Squeezy+ program](https://dub.co/help/article/migrating-from-lemonsqueezy),+ partners, and historical stats into Dub in just a few clicks.+ </MarkdownDescription>+ </div>++ <div className="flex flex-col space-y-6 bg-neutral-50 px-4 py-8 text-left sm:px-16">+ <AnimatePresence mode="wait">+ {step === "set-token" ? (+ <motion.div+ key="token-form"+ initial={{ opacity: 0, x: 20 }}+ animate={{ opacity: 1, x: 0 }}+ exit={{ opacity: 0, x: -20 }}+ transition={{ duration: 0.2, ease: "easeInOut" }}+ >+ <TokenForm setStep={setStep} setStores={setStores} />+ </motion.div>+ ) : (+ <motion.div+ key="select-store"+ initial={{ opacity: 0, x: 20 }}+ animate={{ opacity: 1, x: 0 }}+ exit={{ opacity: 0, x: -20 }}+ transition={{ duration: 0.2, ease: "easeInOut" }}+ >+ <SelectStore+ stores={stores}+ onClose={() => {+ setShowImportLemonSqueezyModal(false);+ queryParams({+ del: "import",+ });+ }}+ />+ </motion.div>+ )}+ </AnimatePresence>+ </div>+ </Modal>+ );+}++function TokenForm({+ setStep,+ setStores,+}: {+ setStep: Dispatch<SetStateAction<Step>>;+ setStores: Dispatch<SetStateAction<LemonSqueezyStore[]>>;+}) {+ const { isMobile } = useMediaQuery();+ const { id: workspaceId } = useWorkspace();++ const [apiKey, setApiKey] = useState("");++ const { executeAsync, isPending } = useAction(setLemonSqueezyTokenAction, {+ onSuccess: ({ data }) => {+ if (data?.stores) {+ setStores(data.stores);+ setStep("select-store");+ }+ },+ onError: ({ error }) => {+ toast.error(error.serverError);+ },+ });++ const onSubmit = async (e: React.FormEvent) => {+ e.preventDefault();++ if (!workspaceId || !apiKey) {+ return;+ }++ await executeAsync({+ workspaceId,+ apiKey,+ });+ };++ return (+ <form onSubmit={onSubmit} className="flex flex-col space-y-4">+ <div>+ <label+ htmlFor="apiKey"+ className="block text-sm font-medium text-neutral-700"+ >+ Lemon Squeezy API Key+ </label>+ <input+ type="password"+ id="apiKey"+ value={apiKey}+ autoFocus={!isMobile}+ onChange={(e) => setApiKey(e.target.value)}+ className="mt-1 block w-full rounded-md border border-neutral-200 px-3 py-2 placeholder-neutral-400 focus:border-neutral-500 focus:outline-none focus:ring-neutral-500 sm:text-sm"+ required+ />+ <p className="mt-1.5 text-xs text-neutral-500">+ You can create an API key in your{" "}+ <a+ href="https://app.lemonsqueezy.com/settings/api"+ target="_blank"+ rel="noopener noreferrer"+ className="text-blue-500 hover:text-blue-600"+ >+ Lemon Squeezy settings+ </a>+ . Use a live-mode key for production migrations.+ </p>+ </div>++ <Button+ text={isPending ? "Fetching stores..." : "Fetch stores"}+ loading={isPending}+ disabled={!apiKey}+ />+ </form>+ );+}++function SelectStore({+ stores,+ onClose,+}: {+ stores: LemonSqueezyStore[];+ onClose: () => void;+}) {+ const router = useRouter();+ const { id: workspaceId, slug } = useWorkspace();++ const [selectedStoreId, setSelectedStoreId] = useState<string | null>(+ stores.length === 1 ? stores[0].id : null,+ );++ const { executeAsync, isPending } = useAction(startLemonSqueezyImportAction, {+ onSuccess: () => {+ onClose();+ toast.success(+ "Successfully added program to import queue! We will send you an email when your program has been fully imported.",+ );+ router.push(`/${slug}/program/partners`);+ },+ onError: ({ error }) => {+ toast.error(error.serverError);+ },+ });++ const onSubmit = async (e: React.FormEvent) => {+ e.preventDefault();++ if (!workspaceId || !selectedStoreId) {+ return;+ }++ await executeAsync({+ workspaceId,+ storeId: selectedStoreId,+ });+ };++ return (+ <form onSubmit={onSubmit} className="flex flex-col space-y-6">+ <div className="space-y-2">+ <label className="block text-sm font-medium text-neutral-700">+ Choose a store to import+ </label>++ <ScrollContainer className="max-h-[280px] rounded-lg border border-neutral-200 bg-white">+ <div className="flex w-full flex-col gap-1 p-1">+ {stores.map((store) => {+ const checked = selectedStoreId === store.id;++ return (+ <button+ key={store.id}+ type="button"+ onClick={() => setSelectedStoreId(store.id)}+ className={cn(+ "flex cursor-pointer select-none items-center gap-3 rounded-md px-3 py-2.5 text-left text-sm text-neutral-700",+ "hover:bg-neutral-100",+ checked && "bg-neutral-100",+ )}+ >+ <div+ className={cn(+ "border-border-emphasis flex size-4 shrink-0 items-center justify-center rounded-full border bg-white transition-colors duration-75",+ checked && "border-neutral-900 bg-neutral-900",+ )}+ >+ <Check2+ className={cn(+ "size-2.5 text-white transition-[transform,opacity] duration-75",+ !checked && "scale-75 opacity-0",+ )}+ />+ </div>+ <div className="flex min-w-0 flex-1 flex-col">+ <span className="min-w-0 truncate font-medium">+ {store.name}+ </span>+ <span className="truncate text-xs text-neutral-500">+ {store.domain || store.url}+ {store.total_sales != null+ ? ` · ${nFormatter(store.total_sales, { full: true })} sales`+ : ""}+ </span>+ </div>+ </button>+ );+ })}+ </div>+ </ScrollContainer>+ </div>++ <Button+ text="Import program"+ disabled={!selectedStoreId}+ loading={isPending}+ className="w-full justify-center"+ />+ </form>+ );+}++export function useImportLemonSqueezyModal() {+ const [showImportLemonSqueezyModal, setShowImportLemonSqueezyModal] =+ useState(false);++ const ImportLemonSqueezyModalCallback = useCallback(() => {+ return (+ <ImportLemonSqueezyModal+ showImportLemonSqueezyModal={showImportLemonSqueezyModal}+ setShowImportLemonSqueezyModal={setShowImportLemonSqueezyModal}+ />+ );+ }, [showImportLemonSqueezyModal, setShowImportLemonSqueezyModal]);++ return useMemo(+ () => ({+ setShowImportLemonSqueezyModal,+ ImportLemonSqueezyModal: ImportLemonSqueezyModalCallback,+ }),+ [setShowImportLemonSqueezyModal, ImportLemonSqueezyModalCallback],+ );+}diff --git a/apps/web/ui/modals/modal-provider.tsx b/apps/web/ui/modals/modal-provider.tsxindex 169408d4d4..50abe0c8f0 100644--- a/apps/web/ui/modals/modal-provider.tsx+++ b/apps/web/ui/modals/modal-provider.tsx@@ -24,6 +24,7 @@ import {} from "react";import { toast } from "sonner";import { useAddEditTagModal } from "./add-edit-tag-modal";+import { useImportLemonSqueezyModal } from "./import-lemonsqueezy-modal";import { useImportPartnerStackModal } from "./import-partnerstack-modal";import { useImportRebrandlyModal } from "./import-rebrandly-modal";import { useImportRewardfulModal } from "./import-rewardful-modal";@@ -46,6 +47,7 @@ export const ModalContext = createContext<{setShowImportRewardfulModal: Dispatch<SetStateAction<boolean>>;setShowImportToltModal: Dispatch<SetStateAction<boolean>>;setShowImportTapfiliateModal: Dispatch<SetStateAction<boolean>>;+ setShowImportLemonSqueezyModal: Dispatch<SetStateAction<boolean>>;}>({setShowAddWorkspaceModal: () => {},setShowAddEditDomainModal: () => {},@@ -59,6 +61,7 @@ export const ModalContext = createContext<{setShowImportRewardfulModal: () => {},setShowImportToltModal: () => {},setShowImportTapfiliateModal: () => {},+ setShowImportLemonSqueezyModal: () => {},});export function ModalProvider({ children }: { children: ReactNode }) {@@ -114,6 +117,8 @@ function ModalProviderClient({ children }: { children: ReactNode }) {const { setShowImportToltModal, ImportToltModal } = useImportToltModal();const { setShowImportTapfiliateModal, ImportTapfiliateModal } =useImportTapfiliateModal();+ const { setShowImportLemonSqueezyModal, ImportLemonSqueezyModal } =+ useImportLemonSqueezyModal();useEffect(() => {setShowProgramWelcomeModal(searchParams.has("onboarded-program"));@@ -200,6 +205,7 @@ function ModalProviderClient({ children }: { children: ReactNode }) {setShowImportRewardfulModal,setShowImportToltModal,setShowImportTapfiliateModal,+ setShowImportLemonSqueezyModal,}}><AddWorkspaceModal />@@ -214,6 +220,7 @@ function ModalProviderClient({ children }: { children: ReactNode }) {<ImportRewardfulModal /><ImportToltModal /><ImportTapfiliateModal />+ <ImportLemonSqueezyModal /><UpgradedModal /><ProgramWelcomeModal />{children}diff --git a/packages/email/src/templates/program-imported.tsx b/packages/email/src/templates/program-imported.tsxindex 4cc378779f..eaba774d1d 100644--- a/packages/email/src/templates/program-imported.tsx+++ b/packages/email/src/templates/program-imported.tsx@@ -31,7 +31,8 @@ export default function ProgramImported({| "Tolt"| "PartnerStack"| "FirstPromoter"- | "Tapfiliate";+ | "Tapfiliate"+ | "Lemon Squeezy";workspace: {slug: string;};