Polar integration

template/app/.env.server.example

@@ -3,6 +3,9 @@
 # If you use `wasp start db` then you DO NOT need to add a DATABASE_URL env variable here.
 # DATABASE_URL=
 
+# Supports Stripe, LemonSqueezy, Polar
+PAYMENT_PROCESSOR_ID=Stripe
+
 # For testing, go to https://dashboard.stripe.com/test/apikeys and get a test stripe key that starts with "sk_test_..."
 STRIPE_API_KEY=sk_test_...
 # After downloading starting the stripe cli (https://stripe.com/docs/stripe-cli) with `stripe listen --forward-to localhost:3001/payments-webhook` it will output your signing secret
@@ -17,6 +20,17 @@ 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_...
+# The unauthenticated URL is at https://sandbox.polar.sh/[your org slug]/portal
+POLAR_CUSTOMER_PORTAL_URL=https://sandbox.polar.sh/.../portal
+# 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/main.wasp

@@ -79,6 +79,10 @@ app OpenSaaS {
     ]
   },
 
+  server: {
+    envValidationSchema: import { envValidationSchema } from "@src/server/validation",
+  },
+
   client: {
     rootComponent: import App from "@src/client/App",
   },

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,8 +1,5 @@
 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';
 import { paymentProcessor } from '../payment/paymentProcessor';
@@ -42,18 +39,7 @@ export const calculateDailyStats: DailyStatsJob<never, void> = async (_args, con
       paidUserDelta -= yesterdaysStats.paidUserCount;
     }
 
-    let totalRevenue;
-    switch (paymentProcessor.id) {
-      case 'stripe':
-        totalRevenue = await fetchTotalStripeRevenue();
-        break;
-      case 'lemonsqueezy':
-        totalRevenue = await fetchTotalLemonSqueezyRevenue();
-        break;
-      default:
-        throw new Error(`Unsupported payment processor: ${paymentProcessor.id}`);
-    }
-
+    const totalRevenue = await paymentProcessor.getTotalRevenue();
     const { totalViews, prevDayViewsChangePercent } = await getDailyPageViews();
 
     let dailyStats = await context.entities.DailyStats.findUnique({
@@ -130,71 +116,3 @@ export const calculateDailyStats: DailyStatsJob<never, void> = async (_args, con
     });
   }
 };
-
-async function fetchTotalStripeRevenue() {
-  let totalRevenue = 0;
-  let params: Stripe.BalanceTransactionListParams = {
-    limit: 100,
-    // created: {
-    //   gte: startTimestamp,
-    //   lt: endTimestamp
-    // },
-    type: 'charge',
-  };
-
-  let hasMore = true;
-  while (hasMore) {
-    const balanceTransactions = await stripe.balanceTransactions.list(params);
-
-    for (const transaction of balanceTransactions.data) {
-      if (transaction.type === 'charge') {
-        totalRevenue += transaction.amount;
-      }
-    }
-
-    if (balanceTransactions.has_more) {
-      // Set the starting point for the next iteration to the last object fetched
-      params.starting_after = balanceTransactions.data[balanceTransactions.data.length - 1].id;
-    } else {
-      hasMore = false;
-    }
-  }
-
-  // Revenue is in cents so we convert to dollars (or your main currency unit)
-  return totalRevenue / 100;
-}
-
-async function fetchTotalLemonSqueezyRevenue() {
-  try {
-    let totalRevenue = 0;
-    let hasNextPage = true;
-    let currentPage = 1;
-
-    while (hasNextPage) {
-      const { data: response } = await listOrders({
-        filter: {
-          storeId: process.env.LEMONSQUEEZY_STORE_ID,
-        },
-        page: {
-          number: currentPage,
-          size: 100,
-        },
-      });
-
-      if (response?.data) {
-        for (const order of response.data) {
-          totalRevenue += order.attributes.total;
-        }
-      }
-
-      hasNextPage = !response?.meta?.page.lastPage;
-      currentPage++;
-    }
-
-    // Revenue is in cents so we convert to dollars (or your main currency unit)
-    return totalRevenue / 100;
-  } catch (error) {
-    console.error('Error fetching Lemon Squeezy revenue:', error);
-    throw error;
-  }
-}

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

@@ -2,14 +2,54 @@ import type { CreateCheckoutSessionArgs, FetchCustomerPortalUrlArgs, PaymentProc
 import { requireNodeEnvVar } from '../../server/utils';
 import { createLemonSqueezyCheckoutSession } from './checkoutUtils';
 import { lemonSqueezyWebhook, lemonSqueezyMiddlewareConfigFn } from './webhook';
-import { lemonSqueezySetup } from '@lemonsqueezy/lemonsqueezy.js';
+import { lemonSqueezySetup, listOrders } from '@lemonsqueezy/lemonsqueezy.js';
+import { PaymentProcessors } from '../types';
 
 lemonSqueezySetup({
   apiKey: requireNodeEnvVar('LEMONSQUEEZY_API_KEY'),
 });
 
+/**
+ * Calculates total revenue from LemonSqueezy orders
+ * @returns Promise resolving to total revenue in dollars
+ */
+async function fetchTotalLemonSqueezyRevenue(): Promise<number> {
+  try {
+    let totalRevenue = 0;
+    let hasNextPage = true;
+    let currentPage = 1;
+
+    while (hasNextPage) {
+      const { data: response } = await listOrders({
+        filter: {
+          storeId: process.env.LEMONSQUEEZY_STORE_ID,
+        },
+        page: {
+          number: currentPage,
+          size: 100,
+        },
+      });
+
+      if (response?.data) {
+        for (const order of response.data) {
+          totalRevenue += order.attributes.total;
+        }
+      }
+
+      hasNextPage = !response?.meta?.page.lastPage;
+      currentPage++;
+    }
+
+    // Revenue is in cents so we convert to dollars (or your main currency unit)
+    return totalRevenue / 100;
+  } catch (error) {
+    console.error('Error fetching Lemon Squeezy revenue:', error);
+    throw error;
+  }
+}
+
 export const lemonSqueezyPaymentProcessor: PaymentProcessor = {
-  id: 'lemonsqueezy',
+  id: PaymentProcessors.LemonSqueezy,
   createCheckoutSession: async ({ userId, userEmail, paymentPlan }: CreateCheckoutSessionArgs) => {
     if (!userId) throw new Error('User ID needed to create Lemon Squeezy Checkout Session');
     const session = await createLemonSqueezyCheckoutSession({
@@ -33,6 +73,7 @@ export const lemonSqueezyPaymentProcessor: PaymentProcessor = {
     // This is handled in the Lemon Squeezy webhook.
     return user.lemonSqueezyCustomerPortalUrl;
   },
+  getTotalRevenue: fetchTotalLemonSqueezyRevenue,
   webhook: lemonSqueezyWebhook,
   webhookMiddlewareConfigFn: lemonSqueezyMiddlewareConfigFn,
 };

template/app/src/payment/paymentProcessor.ts

@@ -4,6 +4,9 @@ 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';
+import { PaymentProcessorId, PaymentProcessors } from './types';
+import { getActivePaymentProcessor } from './validation';
 
 export interface CreateCheckoutSessionArgs {
   userId: string;
@@ -16,17 +19,91 @@ export interface FetchCustomerPortalUrlArgs {
   prismaUserDelegate: PrismaClient['user']; 
 };
 
+/**
+ * Standard interface for all payment processors
+ * Provides a consistent API for payment operations across different providers
+ */
 export interface PaymentProcessor {
-  id: 'stripe' | 'lemonsqueezy';
+  id: PaymentProcessorId;
+  /**
+   * Creates a checkout session for payment processing
+   * Handles both subscription and one-time payment flows based on the payment plan configuration
+   * @param args Checkout session creation arguments
+   * @param args.userId Internal user ID for tracking and database updates
+   * @param args.userEmail Customer email address for payment processor customer creation/lookup
+   * @param args.paymentPlan Payment plan configuration containing pricing and payment type information
+   * @param args.prismaUserDelegate Prisma user delegate for database operations
+   * @returns Promise resolving to checkout session with session ID and redirect URL
+   * @throws {Error} When payment processor API calls fail or required configuration is missing
+   * @example
+   * ```typescript
+   * const { session } = await paymentProcessor.createCheckoutSession({
+   *   userId: 'user_123',
+   *   userEmail: '[email protected]',
+   *   paymentPlan: hobbyPlan,
+   *   prismaUserDelegate: context.entities.User
+   * });
+   * // Redirect user to session.url for payment
+   * ```
+   */
   createCheckoutSession: (args: CreateCheckoutSessionArgs) => Promise<{ session: { id: string; url: string }; }>; 
+  /**
+   * Retrieves the customer portal URL for subscription and billing management
+   * Allows customers to view billing history, update payment methods, and manage subscriptions
+   * @param args Customer portal URL retrieval arguments
+   * @param args.userId Internal user ID to lookup customer information
+   * @param args.prismaUserDelegate Prisma user delegate for database operations
+   * @returns Promise resolving to customer portal URL or null if not available
+   * @throws {Error} When user lookup fails or payment processor API calls fail
+   * @example
+   * ```typescript
+   * const portalUrl = await paymentProcessor.fetchCustomerPortalUrl({
+   *   userId: 'user_123',
+   *   prismaUserDelegate: context.entities.User
+   * });
+   * if (portalUrl) {
+   *   // Redirect user to portal for billing management
+   *   return { redirectUrl: portalUrl };
+   * }
+   * ```
+   */
   fetchCustomerPortalUrl: (args: FetchCustomerPortalUrlArgs) => Promise<string | null>;
+  /**
+   * Calculates the total revenue from this payment processor
+   * @returns Promise resolving to total revenue in dollars
+   */
+  getTotalRevenue: () => Promise<number>;
   webhook: PaymentsWebhook;
   webhookMiddlewareConfigFn: MiddlewareConfigFn;
 }
 
 /**
- * Choose which payment processor you'd like to use, then delete the 
- * other payment processor code that you're not using  from `/src/payment`
+ * All available payment processors
+ */
+const paymentProcessorMap: Record<PaymentProcessors, PaymentProcessor> = {
+  [PaymentProcessors.Stripe]: stripePaymentProcessor,
+  [PaymentProcessors.LemonSqueezy]: lemonSqueezyPaymentProcessor,
+  [PaymentProcessors.Polar]: polarPaymentProcessor,
+};
+
+/**
+ * Get the payment processor instance based on environment configuration or override
+ * @param override Optional processor override for testing scenarios
+ * @returns The configured payment processor instance
+ * @throws {Error} When the specified processor is not found in the processor map
+ */
+export function getPaymentProcessor(override?: PaymentProcessorId): PaymentProcessor {
+  const processorId = getActivePaymentProcessor(override);
+  const processor = paymentProcessorMap[processorId];
+
+  if (!processor) {
+    throw new Error(`Payment processor '${processorId}' not found. Available processors: ${Object.keys(paymentProcessorMap).join(', ')}`);
+  }
+
+  return processor;
+}
+
+/**
+ * The currently configured payment processor.
  */
-// export const paymentProcessor: PaymentProcessor = lemonSqueezyPaymentProcessor;
-export const paymentProcessor: PaymentProcessor = stripePaymentProcessor;
+export const paymentProcessor: PaymentProcessor = getPaymentProcessor();