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.

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.ts
new file mode 100644
index 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.tsx
index 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 />
<Popover
content={
diff --git a/apps/web/lib/actions/partners/set-lemonsqueezy-token.ts b/apps/web/lib/actions/partners/set-lemonsqueezy-token.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
index 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.tsx
new file mode 100644
index 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.tsx
index 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.tsx
index 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;
};