create-solostack 1.0.0

package/src/generators/payments.js

@@ -0,0 +1,541 @@
+import path from 'path';
+import { writeFile, ensureDir } from '../utils/files.js';
+
+/**
+ * Generates Stripe payment integration
+ * @param {string} projectPath - Path where the project is located
+ * @param {string} paymentProvider - Payment provider type
+ */
+export async function generatePayments(projectPath, paymentProvider) {
+  // Create Stripe lib file
+  const stripeLib = `import Stripe from 'stripe';
+
+if (!process.env.STRIPE_SECRET_KEY) {
+  throw new Error('STRIPE_SECRET_KEY is not set');
+}
+
+export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, {
+  apiVersion: '2024-12-18.acacia',
+  typescript: true,
+});
+
+export const PLANS = {
+  FREE: {
+    name: 'Free',
+    price: 0,
+    priceId: null,
+    features: [
+      'Basic features',
+      'Community support',
+      'Limited usage',
+    ],
+  },
+  PRO: {
+    name: 'Pro',
+    price: 9,
+    priceId: process.env.STRIPE_PRO_PRICE_ID,
+    features: [
+      'All free features',
+      'Priority support',
+      'Unlimited usage',
+      'Advanced analytics',
+    ],
+  },
+  ENTERPRISE: {
+    name: 'Enterprise',
+    price: 29,
+    priceId: process.env.STRIPE_ENTERPRISE_PRICE_ID,
+    features: [
+      'All pro features',
+      'Dedicated support',
+      'Custom integrations',
+      'SLA guarantee',
+    ],
+  },
+};
+`;
+
+  await writeFile(path.join(projectPath, 'src/lib/stripe.ts'), stripeLib);
+
+  // Create webhook handler
+  await ensureDir(path.join(projectPath, 'src/app/api/webhooks/stripe'));
+
+  const webhookHandler = `import { headers } from 'next/headers';
+import { NextRequest, NextResponse } from 'next/server';
+import Stripe from 'stripe';
+import { stripe } from '@/lib/stripe';
+import { db } from '@/lib/db';
+
+export async function POST(req: NextRequest) {
+  const body = await req.text();
+  const signature = (await headers()).get('stripe-signature');
+
+  if (!signature) {
+    return NextResponse.json(
+      { error: 'No signature' },
+      { status: 400 }
+    );
+  }
+
+  let event: Stripe.Event;
+
+  try {
+    event = stripe.webhooks.constructEvent(
+      body,
+      signature,
+      process.env.STRIPE_WEBHOOK_SECRET!
+    );
+  } catch (error) {
+    console.error('Webhook signature verification failed:', error);
+    return NextResponse.json(
+      { error: 'Invalid signature' },
+      { status: 400 }
+    );
+  }
+
+  try {
+    // Check if we've already processed this event (idempotency)
+    const existingEvent = await db.stripeEvent.findUnique({
+      where: { eventId: event.id },
+    });
+
+    if (existingEvent?.processed) {
+      console.log(\`Event \${event.id} already processed, skipping\`);
+      return NextResponse.json({ received: true, skipped: true });
+    }
+
+    // Create or update event record
+    await db.stripeEvent.upsert({
+      where: { eventId: event.id },
+      create: {
+        eventId: event.id,
+        type: event.type,
+        processed: false,
+      },
+      update: {
+        type: event.type,
+      },
+    });
+
+  try {
+    switch (event.type) {
+      case 'checkout.session.completed': {
+        const session = event.data.object as Stripe.Checkout.Session;
+        
+        if (session.mode === 'subscription') {
+          const subscriptionId = session.subscription as string;
+          const userId = session.metadata?.userId;
+
+          if (!userId) {
+            throw new Error('No userId in metadata');
+          }
+
+          const subscription = await stripe.subscriptions.retrieve(subscriptionId);
+
+          await db.subscription.create({
+            data: {
+              userId,
+              stripeSubscriptionId: subscription.id,
+              stripePriceId: subscription.items.data[0].price.id,
+              status: subscription.status.toUpperCase() as any,
+              currentPeriodStart: new Date(subscription.current_period_start * 1000),
+              currentPeriodEnd: new Date(subscription.current_period_end * 1000),
+            },
+          });
+
+          await db.user.update({
+            where: { id: userId },
+            data: { stripeCustomerId: subscription.customer as string },
+          });
+        }
+        break;
+      }
+
+      case 'customer.subscription.updated': {
+        const subscription = event.data.object as Stripe.Subscription;
+
+        await db.subscription.update({
+          where: { stripeSubscriptionId: subscription.id },
+          data: {
+            status: subscription.status.toUpperCase() as any,
+            currentPeriodStart: new Date(subscription.current_period_start * 1000),
+            currentPeriodEnd: new Date(subscription.current_period_end * 1000),
+            cancelAtPeriodEnd: subscription.cancel_at_period_end,
+          },
+        });
+        break;
+      }
+
+      case 'customer.subscription.deleted': {
+        const subscription = event.data.object as Stripe.Subscription;
+
+        await db.subscription.update({
+          where: { stripeSubscriptionId: subscription.id },
+          data: {
+            status: 'CANCELED',
+          },
+        });
+        break;
+      }
+
+      case 'payment_intent.succeeded': {
+        const paymentIntent = event.data.object as Stripe.PaymentIntent;
+        const userId = paymentIntent.metadata?.userId;
+
+        if (userId) {
+          await db.payment.create({
+            data: {
+              userId,
+              stripePaymentId: paymentIntent.id,
+              amount: paymentIntent.amount,
+              currency: paymentIntent.currency,
+              status: paymentIntent.status,
+            },
+          });
+        }
+        break;
+      }
+
+      case 'payment_intent.payment_failed': {
+        const paymentIntent = event.data.object as Stripe.PaymentIntent;
+        console.error('Payment failed:', paymentIntent.id);
+        // TODO: Send email notification
+        break;
+      }
+    }
+
+    // Mark event as processed
+    await db.stripeEvent.update({
+      where: { eventId: event.id },
+      data: { processed: true },
+    });
+
+    return NextResponse.json({ received: true, processed: true });
+  } catch (error) {
+    console.error('Webhook handler error:', error);
+    
+    // Don't mark as processed on error, allow retry
+    try {
+      await db.stripeEvent.update({
+        where: { eventId: event.id },
+        data: { processed: false },
+      });
+    } catch (dbError) {
+      console.error('Failed to update event status:', dbError);
+    }
+    
+    return NextResponse.json(
+      { error: 'Webhook handler failed', message: error instanceof Error ? error.message : 'Unknown error' },
+      { status: 500 }
+    );
+  }
+}
+`;
+
+  await writeFile(
+    path.join(projectPath, 'src/app/api/webhooks/stripe/route.ts'),
+    webhookHandler
+  );
+
+  // Create checkout API route
+  await ensureDir(path.join(projectPath, 'src/app/api/stripe/checkout'));
+
+  const checkoutApi = `import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { stripe } from '@/lib/stripe';
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth();
+
+    if (!session?.user) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      );
+    }
+
+    const { priceId } = await req.json();
+
+    if (!priceId) {
+      return NextResponse.json(
+        { error: 'Price ID is required' },
+        { status: 400 }
+      );
+    }
+
+    const checkoutSession = await stripe.checkout.sessions.create({
+      mode: 'subscription',
+      payment_method_types: ['card'],
+      line_items: [
+        {
+          price: priceId,
+          quantity: 1,
+        },
+      ],
+      success_url: \`\${process.env.NEXTAUTH_URL}/dashboard/billing?success=true\`,
+      cancel_url: \`\${process.env.NEXTAUTH_URL}/dashboard/billing?canceled=true\`,
+      metadata: {
+        userId: session.user.id,
+      },
+    });
+
+    return NextResponse.json({ url: checkoutSession.url });
+  } catch (error) {
+    console.error('Checkout error:', error);
+    return NextResponse.json(
+      { error: 'Failed to create checkout session' },
+      { status: 500 }
+    );
+  }
+}
+`;
+
+  await writeFile(
+    path.join(projectPath, 'src/app/api/stripe/checkout/route.ts'),
+    checkoutApi
+  );
+
+  // Create customer portal API route
+  await ensureDir(path.join(projectPath, 'src/app/api/stripe/portal'));
+
+  const portalApi = `import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { stripe } from '@/lib/stripe';
+import { db } from '@/lib/db';
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth();
+
+    if (!session?.user) {
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      );
+    }
+
+    const user = await db.user.findUnique({
+      where: { id: session.user.id },
+    });
+
+    if (!user?.stripeCustomerId) {
+      return NextResponse.json(
+        { error: 'No subscription found' },
+        { status: 400 }
+      );
+    }
+
+    const portalSession = await stripe.billingPortal.sessions.create({
+      customer: user.stripeCustomerId,
+      return_url: \`\${process.env.NEXTAUTH_URL}/dashboard/billing\`,
+    });
+
+    return NextResponse.json({ url: portalSession.url });
+  } catch (error) {
+    console.error('Portal error:', error);
+    return NextResponse.json(
+      { error: 'Failed to create portal session' },
+      { status: 500 }
+    );
+  }
+}
+`;
+
+  await writeFile(
+    path.join(projectPath, 'src/app/api/stripe/portal/route.ts'),
+    portalApi
+  );
+
+  // Create billing page
+  await ensureDir(path.join(projectPath, 'src/app/dashboard/billing'));
+
+  const billingPage = `import { auth } from '@/lib/auth';
+import { db } from '@/lib/db';
+import { redirect } from 'next/navigation';
+import { PLANS } from '@/lib/stripe';
+import { SubscriptionCard } from '@/components/subscription-card';
+
+export default async function BillingPage() {
+  const session = await auth();
+
+  if (!session?.user) {
+    redirect('/login');
+  }
+
+  const user = await db.user.findUnique({
+    where: { id: session.user.id },
+    include: { subscription: true },
+  });
+
+  return (
+    <div className="container mx-auto px-4 py-8">
+      <h1 className="text-3xl font-bold mb-8">Billing & Subscription</h1>
+
+      {user?.subscription ? (
+        <div className="mb-8 rounded-lg border p-6">
+          <h2 className="text-xl font-semibold mb-4">Current Subscription</h2>
+          <div className="grid gap-4">
+            <div>
+              <p className="text-sm text-muted-foreground">Status</p>
+              <p className="font-medium capitalize">{user.subscription.status.toLowerCase()}</p>
+            </div>
+            <div>
+              <p className="text-sm text-muted-foreground">Current Period</p>
+              <p className="font-medium">
+                {new Date(user.subscription.currentPeriodStart).toLocaleDateString()} -{' '}
+                {new Date(user.subscription.currentPeriodEnd).toLocaleDateString()}
+              </p>
+            </div>
+            {user.subscription.cancelAtPeriodEnd && (
+              <div className="rounded-md bg-yellow-50 p-4">
+                <p className="text-sm text-yellow-800">
+                  Your subscription will be canceled at the end of the current billing period.
+                </p>
+              </div>
+            )}
+          </div>
+          <form action="/api/stripe/portal" method="POST" className="mt-4">
+            <button
+              type="submit"
+              className="rounded-md bg-indigo-600 px-4 py-2 text-sm font-semibold text-white hover:bg-indigo-500"
+            >
+              Manage Subscription
+            </button>
+          </form>
+        </div>
+      ) : (
+        <div className="mb-8">
+          <p className="text-muted-foreground mb-4">
+            You don't have an active subscription. Choose a plan below to get started.
+          </p>
+        </div>
+      )}
+
+      <div className="grid gap-6 md:grid-cols-3">
+        {Object.entries(PLANS).map(([key, plan]) => (
+          <SubscriptionCard
+            key={key}
+            name={plan.name}
+            price={plan.price}
+            priceId={plan.priceId}
+            features={plan.features}
+            currentPlan={user?.subscription?.stripePriceId === plan.priceId}
+          />
+        ))}
+      </div>
+    </div>
+  );
+}
+`;
+
+  await writeFile(
+    path.join(projectPath, 'src/app/dashboard/billing/page.tsx'),
+    billingPage
+  );
+
+  // Create SubscriptionCard component
+  const subscriptionCard = `'use client';
+
+import { useRouter } from 'next/navigation';
+import { useState } from 'react';
+
+interface SubscriptionCardProps {
+  name: string;
+  price: number;
+  priceId: string | null;
+  features: string[];
+  currentPlan: boolean;
+}
+
+export function SubscriptionCard({
+  name,
+  price,
+  priceId,
+  features,
+  currentPlan,
+}: SubscriptionCardProps) {
+  const router = useRouter();
+  const [loading, setLoading] = useState(false);
+
+  const handleSubscribe = async () => {
+    if (!priceId) return;
+
+    setLoading(true);
+    try {
+      const res = await fetch('/api/stripe/checkout', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ priceId }),
+      });
+
+      const { url } = await res.json();
+      if (url) {
+        window.location.href = url;
+      }
+    } catch (error) {
+      console.error('Checkout error:', error);
+      setLoading(false);
+    }
+  };
+
+  return (
+    <div className="rounded-lg border p-6 flex flex-col">
+      <h3 className="text-2xl font-bold mb-2">{name}</h3>
+      <div className="mb-4">
+        <span className="text-4xl font-bold">\${price}</span>
+        <span className="text-muted-foreground">/month</span>
+      </div>
+      <ul className="space-y-2 mb-6 flex-grow">
+        {features.map((feature, i) => (
+          <li key={i} className="flex items-start">
+            <svg
+              className="h-5 w-5 text-green-500 mr-2 flex-shrink-0"
+              fill="none"
+              stroke="currentColor"
+              viewBox="0 0 24 24"
+            >
+              <path
+                strokeLinecap="round"
+                strokeLinejoin="round"
+                strokeWidth={2}
+                d="M5 13l4 4L19 7"
+              />
+            </svg>
+            <span className="text-sm">{feature}</span>
+          </li>
+        ))}
+      </ul>
+      {currentPlan ? (
+        <button
+          disabled
+          className="w-full rounded-md bg-gray-300 px-4 py-2 text-sm font-semibold text-gray-500 cursor-not-allowed"
+        >
+          Current Plan
+        </button>
+      ) : priceId ? (
+        <button
+          onClick={handleSubscribe}
+          disabled={loading}
+          className="w-full rounded-md bg-indigo-600 px-4 py-2 text-sm font-semibold text-white hover:bg-indigo-500 disabled:opacity-50"
+        >
+          {loading ? 'Loading...' : 'Subscribe'}
+        </button>
+      ) : (
+        <button
+          disabled
+          className="w-full rounded-md bg-gray-200 px-4 py-2 text-sm font-semibold text-gray-700"
+        >
+          Free Plan
+        </button>
+      )}
+    </div>
+  );
+}
+`;
+
+  await writeFile(
+    path.join(projectPath, 'src/components/subscription-card.tsx'),
+    subscriptionCard
+  );
+}