Polar integration

.gitignore

@@ -4,3 +4,30 @@
 
 # Local Netlify folder
 .netlify
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+dev-debug.log
+# Dependency directories
+node_modules/
+# Environment variables
+.env
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+# OS specific
+
+# Task files
+# tasks.json
+# tasks/ 
+.taskmaster
+template/e2e-tests

template/app/.env.server.example

@@ -17,6 +17,15 @@ LEMONSQUEEZY_STORE_ID=012345
 # define your own webhook secret when creating a new webhook on https://app.lemonsqueezy.com/settings/webhooks
 LEMONSQUEEZY_WEBHOOK_SECRET=my-webhook-secret
 
+# After creating an organization, you can find your organization id in the organization settings https://sandbox.polar.sh/dashboard/[your org slug]/settings
+POLAR_ORGANIZATION_ID=00000000-0000-0000-0000-000000000000
+# Generate a token at https://sandbox.polar.sh/dashboard/[your org slug]/settings
+POLAR_ACCESS_TOKEN=polar_oat_...
+# Define your own webhook secret when creating a new webhook at https://sandbox.polar.sh/dashboard/[your org slug]/settings/webhooks
+POLAR_WEBHOOK_SECRET=polar_whs_...
+# For production, set this to false, then generate a new organization and products from the live dashboard
+POLAR_SANDBOX_MODE=true
+
 # If using Stripe, go to https://dashboard.stripe.com/test/products and click on + Add Product
 # If using Lemon Squeezy, go to https://app.lemonsqueezy.com/products and create new products and variants
 PAYMENTS_HOBBY_SUBSCRIPTION_PLAN_ID=012345

template/app/package.json

@@ -9,6 +9,8 @@
     "@headlessui/react": "1.7.13",
     "@hookform/resolvers": "^5.1.1",
     "@lemonsqueezy/lemonsqueezy.js": "^3.2.0",
+    "@polar-sh/express": "^0.3.2",
+    "@polar-sh/sdk": "^0.34.3",
     "@radix-ui/react-accordion": "^1.2.11",
     "@radix-ui/react-avatar": "^1.1.10",
     "@radix-ui/react-checkbox": "^1.3.2",

template/app/src/analytics/stats.ts

@@ -1,12 +1,16 @@
+import { listOrders } from '@lemonsqueezy/lemonsqueezy.js';
+import Stripe from 'stripe';
 import { type DailyStats } from 'wasp/entities';
 import { type DailyStatsJob } from 'wasp/server/jobs';
-import Stripe from 'stripe';
 import { stripe } from '../payment/stripe/stripeClient';
-import { listOrders } from '@lemonsqueezy/lemonsqueezy.js';
 import { getDailyPageViews, getSources } from './providers/plausibleAnalyticsUtils';
 // import { getDailyPageViews, getSources } from './providers/googleAnalyticsUtils';
+// @ts-ignore
+import { OrderStatus } from '@polar-sh/sdk/models/components/orderstatus.js';
 import { paymentProcessor } from '../payment/paymentProcessor';
 import { SubscriptionStatus } from '../payment/plans';
+import { polarClient } from '../payment/polar/polarClient';
+import { assertUnreachable } from '../shared/utils';
 
 export type DailyStatsProps = { dailyStats?: DailyStats; weeklyStats?: DailyStats[]; isLoading?: boolean };
 
@@ -50,8 +54,11 @@ export const calculateDailyStats: DailyStatsJob<never, void> = async (_args, con
       case 'lemonsqueezy':
         totalRevenue = await fetchTotalLemonSqueezyRevenue();
         break;
+      case 'polar':
+        totalRevenue = await fetchTotalPolarRevenue();
+        break;
       default:
-        throw new Error(`Unsupported payment processor: ${paymentProcessor.id}`);
+        assertUnreachable(paymentProcessor.id);
     }
 
     const { totalViews, prevDayViewsChangePercent } = await getDailyPageViews();
@@ -198,3 +205,24 @@ async function fetchTotalLemonSqueezyRevenue() {
     throw error;
   }
 }
+
+async function fetchTotalPolarRevenue(): Promise<number> {
+  let totalRevenue = 0;
+
+  const result = await polarClient.orders.list({
+    limit: 100,
+  });
+
+  for await (const page of result) {
+    const orders = page.result.items || [];
+
+    for (const order of orders) {
+      if (order.status === OrderStatus.Paid && order.totalAmount > 0) {
+        totalRevenue += order.totalAmount;
+      }
+    }
+  }
+
+  // Revenue is in cents so we convert to dollars
+  return totalRevenue / 100;
+}

template/app/src/payment/PricingPage.tsx

@@ -109,7 +109,7 @@ const PricingPage = () => {
           </h2>
         </div>
         <p className='mx-auto mt-6 max-w-2xl text-center text-lg leading-8 text-muted-foreground'>
-          Choose between Stripe and LemonSqueezy as your payment provider. Just add your Product IDs! Try it
+          Choose between Stripe, LemonSqueezy or Polar as your payment provider. Just add your Product IDs! Try it
           out below with test credit card number <br />
           <span className='px-2 py-1 bg-muted rounded-md text-muted-foreground font-mono text-sm'>
             4242 4242 4242 4242 4242

template/app/src/payment/paymentProcessor.ts

@@ -4,6 +4,7 @@ import type { MiddlewareConfigFn } from 'wasp/server';
 import { PrismaClient } from '@prisma/client';
 import { stripePaymentProcessor } from './stripe/paymentProcessor';
 import { lemonSqueezyPaymentProcessor } from './lemonSqueezy/paymentProcessor';
+import { polarPaymentProcessor } from './polar/paymentProcessor';
 
 export interface CreateCheckoutSessionArgs {
   userId: string;
@@ -17,7 +18,7 @@ export interface FetchCustomerPortalUrlArgs {
 };
 
 export interface PaymentProcessor {
-  id: 'stripe' | 'lemonsqueezy';
+  id: 'stripe' | 'lemonsqueezy' | 'polar';
   createCheckoutSession: (args: CreateCheckoutSessionArgs) => Promise<{ session: { id: string; url: string }; }>; 
   fetchCustomerPortalUrl: (args: FetchCustomerPortalUrlArgs) => Promise<string | null>;
   webhook: PaymentsWebhook;
@@ -29,4 +30,5 @@ export interface PaymentProcessor {
  * other payment processor code that you're not using  from `/src/payment`
  */
 // export const paymentProcessor: PaymentProcessor = lemonSqueezyPaymentProcessor;
+// export const paymentProcessor: PaymentProcessor = polarPaymentProcessor;
 export const paymentProcessor: PaymentProcessor = stripePaymentProcessor;

template/app/src/payment/polar/checkoutUtils.ts

@@ -0,0 +1,81 @@
+// @ts-ignore
+import { CheckoutCreate } from '@polar-sh/sdk/models/components/checkoutcreate.js';
+// @ts-ignore
+import { Customer } from '@polar-sh/sdk/models/components/customer.js';
+import { env } from 'wasp/server';
+import type { PolarMode } from './paymentProcessor';
+import { polarClient } from './polarClient';
+
+export interface CreatePolarCheckoutSessionArgs {
+  productId: string;
+  userEmail: string;
+  userId: string;
+  mode: PolarMode;
+}
+
+export interface PolarCheckoutSession {
+  id: string;
+  url: string;
+  customerId?: string;
+}
+
+export async function createPolarCheckoutSession({
+  productId,
+  userEmail,
+  userId,
+  mode,
+}: CreatePolarCheckoutSessionArgs): Promise<PolarCheckoutSession> {
+  const baseUrl = env.WASP_WEB_CLIENT_URL.replace(/\/+$/, '');
+  const successUrl = `${baseUrl}/checkout?success=true`;
+  const existingCustomer = await ensurePolarCustomer(userId, userEmail);
+  const checkoutSessionArgs: CheckoutCreate = {
+    products: [productId],
+    externalCustomerId: userId,
+    customerEmail: userEmail,
+    successUrl: successUrl,
+    metadata: {
+      paymentMode: mode,
+      source: baseUrl,
+    },
+    ...(existingCustomer && { customerId: existingCustomer.id }),
+  };
+  const checkoutSession = await polarClient.checkouts.create(checkoutSessionArgs);
+  const customerId = checkoutSession.customerId;
+
+  return {
+    id: checkoutSession.id,
+    url: checkoutSession.url,
+    customerId: customerId || undefined,
+  };
+}
+
+async function ensurePolarCustomer(waspUserId: string, customerEmail: string): Promise<Customer> {
+  try {
+    const existingCustomer = await polarClient.customers.getExternal({
+      externalId: waspUserId,
+    });
+
+    if (existingCustomer) {
+      console.log('Using existing Polar customer');
+
+      return existingCustomer;
+    }
+  } catch (error) {
+    console.log('No existing Polar customer found by external ID, will create new one');
+  }
+
+  try {
+    console.log('Creating new Polar customer');
+
+    const newCustomer = await polarClient.customers.create({
+      externalId: waspUserId,
+      email: customerEmail,
+    });
+
+    return newCustomer;
+  } catch (error) {
+    console.error('Error creating Polar customer:', error);
+
+    throw error;
+  }
+}

template/app/src/payment/polar/paymentProcessor.ts

@@ -0,0 +1,79 @@
+import {
+  type CreateCheckoutSessionArgs,
+  type FetchCustomerPortalUrlArgs,
+  type PaymentProcessor,
+} from '../paymentProcessor';
+import type { PaymentPlanEffect } from '../plans';
+import { createPolarCheckoutSession } from './checkoutUtils';
+import { polarClient } from './polarClient';
+import { polarMiddlewareConfigFn, polarWebhook } from './webhook';
+
+export type PolarMode = 'subscription' | 'payment';
+
+export const polarPaymentProcessor: PaymentProcessor = {
+  id: 'polar',
+  createCheckoutSession: async ({
+    userId,
+    userEmail,
+    paymentPlan,
+    prismaUserDelegate,
+  }: CreateCheckoutSessionArgs) => {
+    const session = await createPolarCheckoutSession({
+      productId: paymentPlan.getPaymentProcessorPlanId(),
+      userEmail,
+      userId,
+      mode: paymentPlanEffectToPolarMode(paymentPlan.effect),
+    });
+
+    if (!session.customerId) {
+      throw new Error('Polar checkout session created without customer ID');
+    }
+
+    await prismaUserDelegate.update({
+      where: {
+        id: userId,
+      },
+      data: {
+        paymentProcessorUserId: session.customerId,
+      },
+    });
+
+    return {
+      session: {
+        id: session.id,
+        url: session.url,
+      },
+    };
+  },
+  fetchCustomerPortalUrl: async (args: FetchCustomerPortalUrlArgs) => {
+    const user = await args.prismaUserDelegate.findUnique({
+      where: {
+        id: args.userId,
+      },
+      select: {
+        paymentProcessorUserId: true,
+      },
+    });
+
+    if (user?.paymentProcessorUserId) {
+      const customerSession = await polarClient.customerSessions.create({
+        customerId: user.paymentProcessorUserId,
+      });
+
+      return customerSession.customerPortalUrl;
+    }
+
+    return null;
+  },
+  webhook: polarWebhook,
+  webhookMiddlewareConfigFn: polarMiddlewareConfigFn,
+};
+
+function paymentPlanEffectToPolarMode(planEffect: PaymentPlanEffect): PolarMode {
+  const effectToMode: Record<PaymentPlanEffect['kind'], PolarMode> = {
+    subscription: 'subscription',
+    credits: 'payment',
+  };
+
+  return effectToMode[planEffect.kind];
+}

template/app/src/payment/polar/polarClient.ts

@@ -0,0 +1,7 @@
+import { Polar } from '@polar-sh/sdk';
+import { requireNodeEnvVar } from '../../server/utils';
+
+export const polarClient = new Polar({
+  accessToken: requireNodeEnvVar('POLAR_ACCESS_TOKEN'),
+  server: requireNodeEnvVar('POLAR_SANDBOX_MODE') === 'true' ? 'sandbox' : 'production',
+});

template/app/src/payment/polar/userPaymentDetails.ts

@@ -0,0 +1,34 @@
+import type { PrismaClient } from '@prisma/client';
+import type { PaymentPlanId, SubscriptionStatus } from '../plans';
+
+export const updateUserPolarPaymentDetails = async (
+  {
+    userId,
+    polarCustomerId,
+    subscriptionPlan,
+    subscriptionStatus,
+    numOfCreditsPurchased,
+    datePaid,
+  }: {
+    userId: string;
+    polarCustomerId?: string;
+    subscriptionPlan?: PaymentPlanId;
+    subscriptionStatus?: SubscriptionStatus | string;
+    numOfCreditsPurchased?: number;
+    datePaid?: Date;
+  },
+  userDelegate: PrismaClient['user']
+) => {
+  return await userDelegate.update({
+    where: {
+      id: userId,
+    },
+    data: {
+      ...(polarCustomerId && { paymentProcessorUserId: polarCustomerId }),
+      subscriptionPlan,
+      subscriptionStatus,
+      datePaid,
+      credits: numOfCreditsPurchased !== undefined ? { increment: numOfCreditsPurchased } : undefined,
+    },
+  });
+};