create-solostack 1.2.2 → 1.3.0

package/src/generators/pro/stripe-advanced.js

@@ -0,0 +1,521 @@
+/**
+ * Advanced Stripe Integration Generator - Pro Feature
+ * Generates subscription management, webhooks, and billing page
+ */
+
+import path from 'path';
+import { writeFile, ensureDir } from '../../utils/files.js';
+
+export async function generateAdvancedStripe(projectPath) {
+    // Ensure directories
+    await ensureDir(path.join(projectPath, 'src/app/api/stripe/webhook'));
+    await ensureDir(path.join(projectPath, 'src/app/api/stripe/create-subscription'));
+    await ensureDir(path.join(projectPath, 'src/app/api/stripe/cancel-subscription'));
+    await ensureDir(path.join(projectPath, 'src/app/api/stripe/customer-portal'));
+    await ensureDir(path.join(projectPath, 'src/app/dashboard/billing'));
+
+    // Generate Stripe utility library
+    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-11-20.acacia',
+  typescript: true,
+});
+
+/**
+ * Pricing Plans Configuration
+ */
+export const PLANS = {
+  pro: {
+    name: 'Pro',
+    priceId: process.env.STRIPE_PRO_PRICE_ID || 'price_pro',
+    price: 29,
+    features: [
+      'Unlimited projects',
+      'Priority support',
+      'API access',
+      'Advanced analytics',
+    ],
+  },
+  enterprise: {
+    name: 'Enterprise',
+    priceId: process.env.STRIPE_ENTERPRISE_PRICE_ID || 'price_enterprise',
+    price: 99,
+    features: [
+      'Everything in Pro',
+      'Custom integrations',
+      'Dedicated account manager',
+      'SLA guarantee',
+    ],
+  },
+};
+
+/**
+ * Get or create Stripe customer for user
+ */
+export async function getOrCreateCustomer(userId: string, email: string) {
+  const { db } = await import('@/lib/db');
+  
+  const user = await db.user.findUnique({
+    where: { id: userId },
+    select: { stripeCustomerId: true },
+  });
+
+  if (user?.stripeCustomerId) {
+    return user.stripeCustomerId;
+  }
+
+  const customer = await stripe.customers.create({
+    email,
+    metadata: { userId },
+  });
+
+  await db.user.update({
+    where: { id: userId },
+    data: { stripeCustomerId: customer.id },
+  });
+
+  return customer.id;
+}
+`;
+
+    await writeFile(path.join(projectPath, 'src/lib/stripe.ts'), stripeLib);
+
+    // Generate webhook handler
+    const webhookHandler = `import { NextRequest, NextResponse } from 'next/server';
+import { stripe } from '@/lib/stripe';
+import Stripe from 'stripe';
+
+const webhookSecret = process.env.STRIPE_WEBHOOK_SECRET!;
+
+export async function POST(req: NextRequest) {
+  const body = await req.text();
+  const signature = req.headers.get('stripe-signature')!;
+
+  let event: Stripe.Event;
+
+  try {
+    event = stripe.webhooks.constructEvent(body, signature, webhookSecret);
+  } catch (err: any) {
+    console.error('Webhook signature verification failed:', err.message);
+    return NextResponse.json({ error: 'Invalid signature' }, { status: 400 });
+  }
+
+  const { db } = await import('@/lib/db');
+
+  // Check for idempotency
+  const existingEvent = await db.stripeEvent.findUnique({
+    where: { id: event.id },
+  });
+
+  if (existingEvent?.processed) {
+    return NextResponse.json({ received: true, duplicate: true });
+  }
+
+  // Record the event
+  await db.stripeEvent.upsert({
+    where: { id: event.id },
+    update: {},
+    create: { id: event.id, type: event.type },
+  });
+
+  try {
+    switch (event.type) {
+      case 'customer.subscription.created':
+      case 'customer.subscription.updated': {
+        const subscription = event.data.object as Stripe.Subscription;
+        await handleSubscriptionChange(subscription, db);
+        break;
+      }
+
+      case 'customer.subscription.deleted': {
+        const subscription = event.data.object as Stripe.Subscription;
+        await handleSubscriptionDeleted(subscription, db);
+        break;
+      }
+
+      case 'invoice.payment_succeeded': {
+        const invoice = event.data.object as Stripe.Invoice;
+        await handlePaymentSucceeded(invoice, db);
+        break;
+      }
+
+      case 'invoice.payment_failed': {
+        const invoice = event.data.object as Stripe.Invoice;
+        await handlePaymentFailed(invoice, db);
+        break;
+      }
+    }
+
+    // Mark event as processed
+    await db.stripeEvent.update({
+      where: { id: event.id },
+      data: { processed: true },
+    });
+
+  } catch (error) {
+    console.error('Error processing webhook:', error);
+    return NextResponse.json({ error: 'Webhook handler failed' }, { status: 500 });
+  }
+
+  return NextResponse.json({ received: true });
+}
+
+async function handleSubscriptionChange(subscription: Stripe.Subscription, db: any) {
+  const customerId = subscription.customer as string;
+  const user = await db.user.findFirst({
+    where: { stripeCustomerId: customerId },
+  });
+
+  if (!user) return;
+
+  const status = mapSubscriptionStatus(subscription.status);
+
+  await db.subscription.upsert({
+    where: { userId: user.id },
+    update: {
+      stripeSubscriptionId: subscription.id,
+      stripePriceId: subscription.items.data[0].price.id,
+      status,
+      currentPeriodStart: new Date(subscription.current_period_start * 1000),
+      currentPeriodEnd: new Date(subscription.current_period_end * 1000),
+      cancelAtPeriodEnd: subscription.cancel_at_period_end,
+    },
+    create: {
+      userId: user.id,
+      stripeSubscriptionId: subscription.id,
+      stripePriceId: subscription.items.data[0].price.id,
+      status,
+      currentPeriodStart: new Date(subscription.current_period_start * 1000),
+      currentPeriodEnd: new Date(subscription.current_period_end * 1000),
+      cancelAtPeriodEnd: subscription.cancel_at_period_end,
+    },
+  });
+}
+
+async function handleSubscriptionDeleted(subscription: Stripe.Subscription, db: any) {
+  await db.subscription.delete({
+    where: { stripeSubscriptionId: subscription.id },
+  }).catch(() => {}); // Ignore if not found
+}
+
+async function handlePaymentSucceeded(invoice: Stripe.Invoice, db: any) {
+  if (!invoice.customer) return;
+  
+  const user = await db.user.findFirst({
+    where: { stripeCustomerId: invoice.customer as string },
+  });
+
+  if (!user) return;
+
+  await db.payment.create({
+    data: {
+      userId: user.id,
+      stripePaymentId: invoice.payment_intent as string,
+      amount: invoice.amount_paid,
+      currency: invoice.currency,
+      status: 'succeeded',
+    },
+  });
+}
+
+async function handlePaymentFailed(invoice: Stripe.Invoice, db: any) {
+  // Send email notification about failed payment
+  // await sendPaymentFailedEmail(user.email);
+  console.log('Payment failed for invoice:', invoice.id);
+}
+
+function mapSubscriptionStatus(status: string) {
+  const statusMap: Record<string, string> = {
+    active: 'ACTIVE',
+    canceled: 'CANCELED',
+    past_due: 'PAST_DUE',
+    trialing: 'TRIALING',
+    incomplete: 'INCOMPLETE',
+  };
+  return statusMap[status] || 'INCOMPLETE';
+}
+`;
+
+    await writeFile(
+        path.join(projectPath, 'src/app/api/stripe/webhook/route.ts'),
+        webhookHandler
+    );
+
+    // Generate create subscription endpoint
+    const createSubscription = `import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { stripe, getOrCreateCustomer, PLANS } from '@/lib/stripe';
+
+export async function POST(req: NextRequest) {
+  try {
+    const session = await auth();
+    
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const { priceId } = await req.json();
+
+    if (!priceId) {
+      return NextResponse.json({ error: 'Price ID required' }, { status: 400 });
+    }
+
+    const customerId = await getOrCreateCustomer(session.user.id, session.user.email!);
+
+    const checkoutSession = await stripe.checkout.sessions.create({
+      customer: customerId,
+      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: any) {
+    console.error('Create subscription error:', error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+`;
+
+    await writeFile(
+        path.join(projectPath, 'src/app/api/stripe/create-subscription/route.ts'),
+        createSubscription
+    );
+
+    // Generate customer portal endpoint
+    const customerPortal = `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?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const user = await db.user.findUnique({
+      where: { id: session.user.id },
+      select: { stripeCustomerId: true },
+    });
+
+    if (!user?.stripeCustomerId) {
+      return NextResponse.json({ error: 'No billing account 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: any) {
+    console.error('Customer portal error:', error);
+    return NextResponse.json({ error: error.message }, { status: 500 });
+  }
+}
+`;
+
+    await writeFile(
+        path.join(projectPath, 'src/app/api/stripe/customer-portal/route.ts'),
+        customerPortal
+    );
+
+    // Generate billing page
+    const billingPage = `'use client';
+
+import { useState, useEffect } from 'react';
+import { useSearchParams } from 'next/navigation';
+import { CreditCard, Check, Loader2, ExternalLink } from 'lucide-react';
+
+interface Subscription {
+  status: string;
+  stripePriceId: string;
+  currentPeriodEnd: string;
+  cancelAtPeriodEnd: boolean;
+}
+
+export default function BillingPage() {
+  const [subscription, setSubscription] = useState<Subscription | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [actionLoading, setActionLoading] = useState(false);
+  const searchParams = useSearchParams();
+  const success = searchParams.get('success');
+  const canceled = searchParams.get('canceled');
+
+  useEffect(() => {
+    fetchSubscription();
+  }, []);
+
+  async function fetchSubscription() {
+    try {
+      const res = await fetch('/api/user/subscription');
+      if (res.ok) {
+        const data = await res.json();
+        setSubscription(data.subscription);
+      }
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  async function handleSubscribe(priceId: string) {
+    setActionLoading(true);
+    try {
+      const res = await fetch('/api/stripe/create-subscription', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ priceId }),
+      });
+      const data = await res.json();
+      if (data.url) {
+        window.location.href = data.url;
+      }
+    } finally {
+      setActionLoading(false);
+    }
+  }
+
+  async function handleManageBilling() {
+    setActionLoading(true);
+    try {
+      const res = await fetch('/api/stripe/customer-portal', {
+        method: 'POST',
+      });
+      const data = await res.json();
+      if (data.url) {
+        window.location.href = data.url;
+      }
+    } finally {
+      setActionLoading(false);
+    }
+  }
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center min-h-[400px]">
+        <Loader2 className="h-8 w-8 animate-spin text-indigo-600" />
+      </div>
+    );
+  }
+
+  return (
+    <div className="max-w-4xl mx-auto p-6">
+      <h1 className="text-3xl font-bold mb-2">Billing</h1>
+      <p className="text-gray-600 mb-8">Manage your subscription and billing</p>
+
+      {success && (
+        <div className="bg-green-50 border border-green-200 rounded-lg p-4 mb-6">
+          <p className="text-green-800">🎉 Subscription activated successfully!</p>
+        </div>
+      )}
+
+      {canceled && (
+        <div className="bg-yellow-50 border border-yellow-200 rounded-lg p-4 mb-6">
+          <p className="text-yellow-800">Checkout was canceled. Your subscription was not changed.</p>
+        </div>
+      )}
+
+      {subscription ? (
+        <div className="bg-white rounded-xl border p-6 mb-8">
+          <div className="flex items-center justify-between mb-4">
+            <div>
+              <h2 className="text-xl font-semibold">Current Plan</h2>
+              <p className="text-gray-600">
+                Status: <span className="font-medium text-green-600">{subscription.status}</span>
+              </p>
+            </div>
+            <CreditCard className="h-8 w-8 text-indigo-600" />
+          </div>
+          
+          <p className="text-sm text-gray-500 mb-4">
+            Next billing date: {new Date(subscription.currentPeriodEnd).toLocaleDateString()}
+            {subscription.cancelAtPeriodEnd && (
+              <span className="ml-2 text-amber-600">(Cancels at period end)</span>
+            )}
+          </p>
+
+          <button
+            onClick={handleManageBilling}
+            disabled={actionLoading}
+            className="inline-flex items-center gap-2 px-4 py-2 bg-gray-900 text-white rounded-lg hover:bg-gray-800 disabled:opacity-50"
+          >
+            {actionLoading ? <Loader2 className="h-4 w-4 animate-spin" /> : <ExternalLink className="h-4 w-4" />}
+            Manage Billing
+          </button>
+        </div>
+      ) : (
+        <div className="grid md:grid-cols-2 gap-6">
+          {/* Pro Plan */}
+          <div className="bg-white rounded-xl border-2 border-indigo-500 p-6 relative">
+            <div className="absolute -top-3 left-4 bg-indigo-500 text-white text-xs px-2 py-1 rounded">
+              POPULAR
+            </div>
+            <h3 className="text-xl font-bold mb-2">Pro</h3>
+            <p className="text-3xl font-bold mb-4">$29<span className="text-lg text-gray-500">/mo</span></p>
+            <ul className="space-y-2 mb-6">
+              {['Unlimited projects', 'Priority support', 'API access', 'Advanced analytics'].map((feature) => (
+                <li key={feature} className="flex items-center gap-2 text-sm">
+                  <Check className="h-4 w-4 text-green-500" />
+                  {feature}
+                </li>
+              ))}
+            </ul>
+            <button
+              onClick={() => handleSubscribe(process.env.NEXT_PUBLIC_STRIPE_PRO_PRICE_ID || 'price_pro')}
+              disabled={actionLoading}
+              className="w-full py-2 bg-indigo-600 text-white rounded-lg hover:bg-indigo-500 disabled:opacity-50"
+            >
+              {actionLoading ? 'Loading...' : 'Subscribe to Pro'}
+            </button>
+          </div>
+
+          {/* Enterprise Plan */}
+          <div className="bg-white rounded-xl border p-6">
+            <h3 className="text-xl font-bold mb-2">Enterprise</h3>
+            <p className="text-3xl font-bold mb-4">$99<span className="text-lg text-gray-500">/mo</span></p>
+            <ul className="space-y-2 mb-6">
+              {['Everything in Pro', 'Custom integrations', 'Dedicated account manager', 'SLA guarantee'].map((feature) => (
+                <li key={feature} className="flex items-center gap-2 text-sm">
+                  <Check className="h-4 w-4 text-green-500" />
+                  {feature}
+                </li>
+              ))}
+            </ul>
+            <button
+              onClick={() => handleSubscribe(process.env.NEXT_PUBLIC_STRIPE_ENTERPRISE_PRICE_ID || 'price_enterprise')}
+              disabled={actionLoading}
+              className="w-full py-2 bg-gray-900 text-white rounded-lg hover:bg-gray-800 disabled:opacity-50"
+            >
+              {actionLoading ? 'Loading...' : 'Subscribe to Enterprise'}
+            </button>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+`;
+
+    await writeFile(
+        path.join(projectPath, 'src/app/dashboard/billing/page.tsx'),
+        billingPage
+    );
+}

package/src/generators/setup.js

@@ -1,15 +1,17 @@
 import path from 'path';
 import { writeFile, ensureDir } from '../utils/files.js';
 
-export async function generateSetup(projectPath) {
-    // Create setup page directory
-    await ensureDir(path.join(projectPath, 'src/app/setup'));
+export async function generateSetup(projectPath, config) {
+  const isSupabaseAuth = config?.auth === 'Supabase Auth';
+  // Create setup page directory
+  await ensureDir(path.join(projectPath, 'src/app/setup'));
 
-    // Generate setup page UI
-    const setupPage = `'use client';
+  // Generate setup page UI
+  const setupPage = `'use client';
 
 import { useState, useEffect } from 'react';
-import { CheckCircle, XCircle, Loader2, AlertCircle, RefreshCw, Mail } from 'lucide-react';
+import Link from 'next/link';
+import { CheckCircle, XCircle, Loader2, AlertCircle, RefreshCw, Mail, ArrowLeft } from 'lucide-react';
 
 export default function SetupPage() {
   const [data, setData] = useState<any>(null);
@@ -70,6 +72,15 @@ export default function SetupPage() {
   return (
     <div className="min-h-screen bg-gray-50 p-8">
       <div className="mx-auto max-w-4xl space-y-8">
+        {/* Back to Home */}
+        <Link 
+          href="/" 
+          className="inline-flex items-center gap-2 text-sm font-medium text-gray-600 hover:text-gray-900 transition-colors"
+        >
+          <ArrowLeft className="h-4 w-4" />
+          Back to Home
+        </Link>
+
         <div className="flex items-center justify-between">
           <div>
             <h1 className="text-3xl font-bold tracking-tight">Setup & Diagnostics</h1>
@@ -240,14 +251,13 @@ function StatusIcon({ status }: { status: boolean }) {
 }
 `;
 
-    await writeFile(path.join(projectPath, 'src/app/setup/page.tsx'), setupPage);
+  await writeFile(path.join(projectPath, 'src/app/setup/page.tsx'), setupPage);
 
-    // Create API routes directory
-    await ensureDir(path.join(projectPath, 'src/app/api/setup'));
+  // Create API routes directory
+  await ensureDir(path.join(projectPath, 'src/app/api/setup'));
 
-    // Generate Setup API route
-    const setupApi = `import { NextResponse } from 'next/server';
-import { db } from '@/lib/db';
+  // Generate Setup API route
+  const setupApi = `import { NextResponse } from 'next/server';
 
 export async function GET() {
   if (process.env.NODE_ENV !== 'development') {
@@ -259,12 +269,15 @@ export async function GET() {
       connected: false,
       userCount: 0,
       error: null as string | null,
-      provider: 'PostgreSQL'
+      provider: '${isSupabaseAuth ? 'Supabase' : 'PostgreSQL'}'
     },
     auth: {
       configured: false,
-      hasSecret: !!process.env.NEXTAUTH_SECRET,
-      providers: [
+      type: '${isSupabaseAuth ? 'Supabase Auth' : 'NextAuth.js'}',
+      hasSecret: ${isSupabaseAuth ? '!!(process.env.NEXT_PUBLIC_SUPABASE_URL && process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY)' : '!!process.env.NEXTAUTH_SECRET'},
+      providers: ${isSupabaseAuth ? `[
+        { name: 'Supabase', configured: !!(process.env.NEXT_PUBLIC_SUPABASE_URL && process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) }
+      ]` : `[
         { 
           name: 'Google', 
           clientId: !!process.env.GOOGLE_CLIENT_ID,
@@ -277,7 +290,7 @@ export async function GET() {
           clientSecret: !!process.env.GITHUB_CLIENT_SECRET,
           configured: !!(process.env.GITHUB_CLIENT_ID && process.env.GITHUB_CLIENT_SECRET)
         }
-      ]
+      ]`}
     },
     stripe: {
       configured: false,
@@ -293,6 +306,10 @@ export async function GET() {
 
   // Check Database
   try {
+    if (!process.env.DATABASE_URL${isSupabaseAuth ? ' && !process.env.NEXT_PUBLIC_SUPABASE_URL' : ''}) {
+      throw new Error('DATABASE_URL is not configured in .env');
+    }
+    const { db } = await import('@/lib/db');
     const userCount = await db.user.count();
     results.database.connected = true;
     results.database.userCount = userCount;
@@ -315,12 +332,12 @@ export async function GET() {
 }
 `;
 
-    await writeFile(path.join(projectPath, 'src/app/api/setup/route.ts'), setupApi);
+  await writeFile(path.join(projectPath, 'src/app/api/setup/route.ts'), setupApi);
 
-    // Generate Test Email API route
-    await ensureDir(path.join(projectPath, 'src/app/api/setup/test-email'));
+  // Generate Test Email API route
+  await ensureDir(path.join(projectPath, 'src/app/api/setup/test-email'));
 
-    const testEmailApi = `import { NextResponse, NextRequest } from 'next/server';
+  const testEmailApi = `import { NextResponse, NextRequest } from 'next/server';
 import { Resend } from 'resend';
 
 export async function POST(req: NextRequest) {
@@ -355,5 +372,5 @@ export async function POST(req: NextRequest) {
 }
 `;
 
-    await writeFile(path.join(projectPath, 'src/app/api/setup/test-email/route.ts'), testEmailApi);
+  await writeFile(path.join(projectPath, 'src/app/api/setup/test-email/route.ts'), testEmailApi);
 }