vibecarbon 0.1.0

package/carbon/src/server/billing/providers/stripe.ts

@@ -0,0 +1,233 @@
+/**
+ * Stripe billing provider implementation.
+ *
+ * Wraps the existing Stripe client (src/server/lib/stripe.ts) behind
+ * the BillingProvider interface. All Stripe-specific API calls are
+ * contained here so the rest of the billing system stays provider-agnostic.
+ */
+
+import type Stripe from 'stripe';
+import { env } from '../../lib/env';
+import { getStripe, isStripeConfigured, verifyWebhookSignature } from '../../lib/stripe';
+import type { BillingProvider, CheckoutResult, PortalResult, SubscriptionInfo } from '../provider';
+
+export class StripeProvider implements BillingProvider {
+  readonly type = 'stripe' as const;
+
+  isConfigured(): boolean {
+    return isStripeConfigured();
+  }
+
+  async createCheckout(params: {
+    customerId: string;
+    priceId: string;
+    successUrl: string;
+    cancelUrl: string;
+    metadata: Record<string, string>;
+    mode?: 'subscription' | 'payment';
+  }): Promise<CheckoutResult> {
+    const stripe = getStripe();
+
+    const session = await stripe.checkout.sessions.create({
+      customer: params.customerId,
+      mode: params.mode ?? 'subscription',
+      line_items: [{ price: params.priceId, quantity: 1 }],
+      success_url: params.successUrl,
+      cancel_url: params.cancelUrl,
+      metadata: params.metadata,
+    });
+
+    return {
+      url: session.url ?? '',
+      sessionId: session.id,
+    };
+  }
+
+  async createPortalSession(params: {
+    customerId: string;
+    returnUrl: string;
+  }): Promise<PortalResult> {
+    const stripe = getStripe();
+
+    const session = await stripe.billingPortal.sessions.create({
+      customer: params.customerId,
+      return_url: params.returnUrl,
+    });
+
+    return { url: session.url };
+  }
+
+  async getSubscription(params: {
+    customerId: string;
+    subscriptionId: string;
+  }): Promise<SubscriptionInfo | null> {
+    const stripe = getStripe();
+
+    try {
+      const subscription = await stripe.subscriptions.retrieve(params.subscriptionId, {
+        expand: ['items.data.price.product'],
+      });
+
+      const item = subscription.items.data[0];
+      if (!item) return null;
+
+      const price = item.price;
+      const product = price.product as Stripe.Product;
+
+      const currentPeriodEnd = (subscription as unknown as { current_period_end?: number })
+        .current_period_end;
+
+      return {
+        id: subscription.id,
+        status: subscription.status,
+        planId: this.resolvePlanId(price.id),
+        priceId: price.id,
+        currentPeriodEnd: currentPeriodEnd ? new Date(currentPeriodEnd * 1000).toISOString() : null,
+        cancelAtPeriodEnd: subscription.cancel_at_period_end,
+        price: {
+          unitAmount: price.unit_amount ?? 0,
+          currency: price.currency,
+          interval: price.recurring?.interval ?? 'month',
+        },
+        product: {
+          id: product.id,
+          name: product.name,
+        },
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  async handleWebhook(params: {
+    body: string;
+    signature: string;
+  }): Promise<{ type: string; data: Record<string, unknown> }> {
+    const event = verifyWebhookSignature(params.body, params.signature);
+
+    // Normalize Stripe event types to a common format
+    const normalized = this.normalizeEventType(event.type);
+
+    return {
+      type: normalized,
+      data: {
+        ...this.extractEventData(event),
+        _raw: event,
+      },
+    };
+  }
+
+  async createCustomer(params: {
+    email: string;
+    name: string;
+    metadata: Record<string, string>;
+  }): Promise<string> {
+    const stripe = getStripe();
+
+    const customer = await stripe.customers.create({
+      email: params.email,
+      name: params.name,
+      metadata: params.metadata,
+    });
+
+    return customer.id;
+  }
+
+  async deleteCustomer(customerId: string): Promise<void> {
+    const stripe = getStripe();
+    await stripe.customers.del(customerId);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+
+  /** Map a Stripe price ID to a plan ID using configured env vars. */
+  private resolvePlanId(priceId: string): string {
+    if (priceId === env.STRIPE_PRICE_STARTER) return 'starter';
+    if (priceId === env.STRIPE_PRICE_PRO) return 'pro';
+    return 'free';
+  }
+
+  /**
+   * Map Stripe webhook event types to normalized billing event names.
+   *
+   * The normalized names are used by the generic webhook handler so that
+   * subscription lifecycle logic is provider-agnostic.
+   */
+  private normalizeEventType(stripeType: string): string {
+    const map: Record<string, string> = {
+      'checkout.session.completed': 'checkout.completed',
+      'customer.subscription.created': 'subscription.created',
+      'customer.subscription.updated': 'subscription.updated',
+      'customer.subscription.deleted': 'subscription.deleted',
+      'invoice.payment_failed': 'payment.failed',
+    };
+    return map[stripeType] ?? stripeType;
+  }
+
+  /** Extract relevant data from a Stripe event into a flat record. */
+  private extractEventData(event: Stripe.Event): Record<string, unknown> {
+    switch (event.type) {
+      case 'checkout.session.completed': {
+        const session = event.data.object as Stripe.Checkout.Session;
+        return {
+          provider: 'stripe',
+          mode: session.mode,
+          customerId: session.customer as string,
+          subscriptionId: session.subscription as string,
+          customerEmail: session.customer_details?.email ?? null,
+        };
+      }
+
+      case 'customer.subscription.created':
+      case 'customer.subscription.updated': {
+        const sub = event.data.object as Stripe.Subscription;
+        const priceId = sub.items.data[0]?.price.id;
+        const periodStart = (sub as unknown as { current_period_start?: number })
+          .current_period_start;
+        const periodEnd = (sub as unknown as { current_period_end?: number }).current_period_end;
+        return {
+          provider: 'stripe',
+          subscriptionId: sub.id,
+          customerId: sub.customer as string,
+          status: sub.status,
+          priceId,
+          currentPeriodStart: periodStart ? new Date(periodStart * 1000).toISOString() : null,
+          currentPeriodEnd: periodEnd ? new Date(periodEnd * 1000).toISOString() : null,
+          cancelAtPeriodEnd: sub.cancel_at_period_end,
+          canceledAt: sub.canceled_at ? new Date(sub.canceled_at * 1000).toISOString() : null,
+        };
+      }
+
+      case 'customer.subscription.deleted': {
+        const sub = event.data.object as Stripe.Subscription;
+        return {
+          provider: 'stripe',
+          subscriptionId: sub.id,
+          customerId: sub.customer as string,
+          status: 'canceled',
+        };
+      }
+
+      case 'invoice.payment_failed': {
+        const invoice = event.data.object as Stripe.Invoice;
+        const invoiceWithSub = invoice as unknown as {
+          subscription?: string | { id: string } | null;
+        };
+        const subscriptionId =
+          typeof invoiceWithSub.subscription === 'string'
+            ? invoiceWithSub.subscription
+            : invoiceWithSub.subscription?.id;
+        return {
+          provider: 'stripe',
+          subscriptionId: subscriptionId ?? null,
+          invoiceId: invoice.id,
+        };
+      }
+
+      default:
+        return { provider: 'stripe', raw: event.data.object as unknown as Record<string, unknown> };
+    }
+  }
+}

package/carbon/src/server/emails/templates.ts

@@ -0,0 +1,116 @@
+/**
+ * Transactional email templates.
+ *
+ * Uses simple HTML strings rather than React Email to avoid adding
+ * a build-time dependency. Swap for @react-email/components if you
+ * need richer templating.
+ */
+
+const PROJECT_NAME = '{{PROJECT_NAME}}';
+
+/** Escape HTML entities to prevent HTML injection in emails */
+function escapeHtml(str: string): string {
+  return str
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function layout(content: string): string {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 0; padding: 0; background: #f4f4f5; color: #18181b; }
+    .container { max-width: 560px; margin: 0 auto; padding: 40px 20px; }
+    .card { background: #fff; border-radius: 8px; padding: 32px; box-shadow: 0 1px 3px rgba(0,0,0,0.08); }
+    .btn { display: inline-block; padding: 10px 24px; background: #18181b; color: #fff; text-decoration: none; border-radius: 6px; font-weight: 500; font-size: 14px; }
+    .footer { text-align: center; padding: 24px 0; font-size: 12px; color: #71717a; }
+    h1 { font-size: 20px; margin: 0 0 16px; }
+    p { font-size: 14px; line-height: 1.6; margin: 0 0 16px; color: #3f3f46; }
+    .highlight { background: #f4f4f5; border-radius: 6px; padding: 12px 16px; font-size: 14px; margin: 16px 0; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="card">
+      ${content}
+    </div>
+    <div class="footer">
+      ${PROJECT_NAME}
+    </div>
+  </div>
+</body>
+</html>`;
+}
+
+export function orgInviteEmail(params: {
+  inviterName: string;
+  organizationName: string;
+  role: string;
+  loginUrl: string;
+}): { subject: string; html: string } {
+  const inviter = escapeHtml(params.inviterName);
+  const org = escapeHtml(params.organizationName);
+  const role = escapeHtml(params.role);
+  return {
+    subject: `You've been invited to ${params.organizationName}`,
+    html: layout(`
+      <h1>You've been invited</h1>
+      <p><strong>${inviter}</strong> has invited you to join <strong>${org}</strong> as a <strong>${role}</strong>.</p>
+      <p style="text-align: center; margin: 24px 0;">
+        <a href="${params.loginUrl}" class="btn">Accept Invitation</a>
+      </p>
+      <p style="font-size: 12px; color: #71717a;">If you don't have an account yet, you'll be able to create one after clicking the link above.</p>
+    `),
+  };
+}
+
+export function subscriptionConfirmEmail(params: {
+  userName?: string;
+  planName: string;
+  amount: string;
+  interval: string;
+}): { subject: string; html: string } {
+  const userName = params.userName ? escapeHtml(params.userName) : null;
+  const planName = escapeHtml(params.planName);
+  const amount = escapeHtml(params.amount);
+  const interval = escapeHtml(params.interval);
+  return {
+    subject: `Subscription confirmed: ${params.planName} plan`,
+    html: layout(`
+      <h1>Subscription Confirmed</h1>
+      <p>${userName ? `Hi ${userName},` : 'Hi,'}</p>
+      <p>You're now on the <strong>${planName}</strong> plan.</p>
+      <div class="highlight">
+        <strong>${amount}</strong> / ${interval}
+      </div>
+      <p>You can manage your subscription at any time from your billing settings.</p>
+    `),
+  };
+}
+
+export function paymentFailedEmail(params: {
+  userName?: string;
+  planName: string;
+  billingUrl: string;
+}): { subject: string; html: string } {
+  const userName2 = params.userName ? escapeHtml(params.userName) : null;
+  const planName2 = escapeHtml(params.planName);
+  return {
+    subject: `Payment failed for your ${PROJECT_NAME} subscription`,
+    html: layout(`
+      <h1>Payment Failed</h1>
+      <p>${userName2 ? `Hi ${userName2},` : 'Hi,'}</p>
+      <p>We were unable to process the payment for your <strong>${planName2}</strong> plan. Please update your payment method to avoid any interruption to your service.</p>
+      <p style="text-align: center; margin: 24px 0;">
+        <a href="${params.billingUrl}" class="btn">Update Payment Method</a>
+      </p>
+      <p style="font-size: 12px; color: #71717a;">If you believe this is an error, please contact support.</p>
+    `),
+  };
+}