How to get Paid in Your JavaScript Applications with LemonSqueezy

npm install @lemonsqueezy/lemonsqueezy.js

const configureLemonSqueezy = lemonSqueezySetup({
  apiKey: process.env.LEMON_SQUEEZY_API_KEY,
  onError(error) {
    console.log(error);
  },
});

import {
  lemonSqueezySetup,
  type Variant,
} from "@lemonsqueezy/lemonsqueezy.js";

export async function getCheckoutURL(variantId: number, embed = true) {

  if (!Number.isInteger(variantId) || variantId <= 0) {
    throw new Error("Invalid variantId. Must be a positive integer.");
  }
  if (typeof embed !== "boolean") {
    throw new Error("Invalid embed value. Must be a boolean.");
  }
  const { userId } = auth();
  const user = await currentUser();

  // get emailj
  const userEmail = user?.emailAddresses[0].emailAddress ?? "";

  const checkout = await createCheckout(
    process.env.LEMONSQUEEZY_STORE_ID as string,
    variantId,
    {
      checkoutOptions: {
        embed,
        media: true,
        logo: true,
        dark: true,
      },
      checkoutData: {
        email: userEmail,
        custom: {
          user_id: userId,
        },
      },

      productOptions: {
        enabledVariants: [variantId],
        redirectUrl: `${process.env.NEXT_PUBLIC_APP_URL}/dashboard/billing/`,
        receiptButtonText: "Go to Dashboard",
        receiptThankYouNote: "Thank you for signing up to Lemon Stand!",
      },
    }
  );


  return checkout.data?.data.attributes.url;
}

export async function POST(request: Request) {
  try {
    if (!process.env.LEMONSQUEEZY_WEBHOOK_SECRET) {
      return new Response("Lemon Squeezy Webhook Secret not set in .env", {
        status: 400,
      });
    }
  } catch (error) {
    console.log(error);
  }
}

const rawBody = await request.text();
  const secret = process.env.LEMONSQUEEZY_WEBHOOK_SECRET;

  const hmac = crypto.createHmac("sha256", secret);
  const digest = Buffer.from(hmac.update(rawBody).digest("hex"), "utf8");
  const signature = Buffer.from(
    request.headers.get("X-Signature") || "",
    "utf8"
  );

  if (!crypto.timingSafeEqual(digest, signature)) {
    throw new Error("Invalid signature.");
  }
  console.log("Signature verified");

  const data = JSON.parse(rawBody) as unknown;

export async function storeWebhookEvent(eventName: string, body: any) {
  const { data, error } = await supabase
    .from("webhook_events")
    .upsert(
      [
        {
          user_id: body.meta.custom_data.user_id,
          event_name: eventName,
          body,
        },
      ],
      { onConflict: "id" }
    )
    .select();

  if (error) {
    throw error;
  }
  return data;
}

export async function processWebhookEvent(webhookEvent: any) {
  try {
    const { data: dbWebhookEvent, error } = await supabase
      .from("webhook_events")
      .select("*")
      .eq("id", webhookEvent[0].id)
      .single();

    if (error || !dbWebhookEvent) {
      throw new Error(
        `Webhook event #${webhookEvent.id} not found in the database.`
      );
    }
  } catch (error) {
    console.error(error);
  }

  const eventBody = webhookEvent[0].body;


  if (
    webhookEvent[0].event_name.startsWith("subscription_updated") ||
    webhookEvent[0].event_name.startsWith("subscription_created")
  ) {
    const attributes = eventBody.data.attributes;
    const variantId = attributes.variant_id;

    const { data: plan, error: planError } = await supabase
      .from("plans")
      .select("*")
      .eq("variant_id", variantId)
      .single();

    if (planError || !plan) {
      throw new Error(`Plan with variantId ${variantId} not found.`);
    }
    let priceId = eventBody.data.attributes.first_subscription_item.price_id;
    let lPrice = await getPrice(priceId);

    const updateData = {
      lemon_squeezy_id: eventBody.data.id,
      order_id: attributes.order_id,
      status: attributes.status,
      renews_at: attributes.renews_at,
      ends_at: attributes.ends_at,
      trial_ends_at: attributes.trial_ends_at,
      price: lPrice.data?.data.attributes.unit_price,
      is_paused: attributes.status == "paused" ? true : false,
      subscription_item_id: attributes.first_subscription_item.id,
      is_usage_based: attributes.first_subscription_item.is_usage_based,
      user_id: eventBody.meta.custom_data.user_id,
      plan_id: plan.id,
    };

    const { error: upsertError } = await supabase
      .from("subscriptions")
      .upsert([updateData], { onConflict: "lemon_squeezy_id" });
    if (upsertError) {
      throw new Error(`Failed to upsert subscription: ${upsertError.message}`);
    }

    /** 
     * Mark the webhook event as processed
     * You can remove the webhook from the db if it is processed successfully
     * Implement this in your DB
    */



}

export async function cancelSub(id: string) {
  // Get user subscriptions
  const userSubscriptions = await getUserSubscription();

  // Check if the subscription exists
  const subscription = userSubscriptions?.find(
    (sub) => sub.lemon_squeezy_id === id
  );

  if (!subscription) {
    throw new Error(`Subscription #${id} not found.`);
  }

  const cancelledSub = await cancelSubscription(id);

  console.log(cancelledSub, "cancelledSub");

  if (cancelledSub.error) {
    throw new Error(cancelledSub.error.message);
  }

  // Update the db
  try {
   //DB logic
  } catch (error) {
    throw new Error(`Failed to cancel Subscription #${id} in the database.`);
  }

  revalidatePath("/");

  return cancelledSub;
}