create-solostack 1.2.3 → 1.3.1

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/index.js

@@ -4,9 +4,9 @@ import chalk from 'chalk';
 import ora from 'ora';
 import path from 'path';
 import { validateProjectName } from './utils/validate.js';
-import { printSuccess, printError } from './utils/logger.js';
+import { printSuccess, printError, printProSuccess } from './utils/logger.js';
 import { ensureDir, writeFile } from './utils/files.js';
-import { installPackages } from './utils/packages.js';
+import { installPackages, installProPackages } from './utils/packages.js';
 import { initGit } from './utils/git.js';
 import { generateBase } from './generators/base.js';
 import { generateDatabase } from './generators/database.js';
@@ -15,6 +15,8 @@ import { generatePayments } from './generators/payments.js';
 import { generateEmails } from './generators/emails.js';
 import { generateSetup } from './generators/setup.js';
 import { generateUI } from './generators/ui.js';
+import { validateLicense, isLicenseKeyFormat } from './utils/license.js';
+import { generateProFromServer } from './utils/pro-api.js';
 import {
     AUTH_PROVIDERS,
     DATABASES,
@@ -112,6 +114,69 @@ export async function main() {
 
     const projectPath = path.join(process.cwd(), projectName);
 
+    // Pro upgrade prompt
+    let hasProLicense = false;
+    let licenseData = null;
+
+    const proAnswer = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'wantsPro',
+            message: chalk.cyan('💎 Upgrade to Pro? (Admin panel, OAuth, API keys, advanced features)'),
+            default: false,
+        }
+    ]);
+
+    if (proAnswer.wantsPro) {
+        let retryLicense = true;
+
+        while (retryLicense && !hasProLicense) {
+            const licenseAnswer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'licenseKey',
+                    message: 'Enter your Pro license key (get one at https://solostack.dev/pro):',
+                    validate: (input) => {
+                        if (!input) {
+                            return 'License key required. Visit https://solostack.dev/pro to purchase.';
+                        }
+                        if (!isLicenseKeyFormat(input)) {
+                            return 'Invalid license key format. Expected: sk_live_XXXXX...';
+                        }
+                        return true;
+                    }
+                }
+            ]);
+
+            let spinner = ora('Validating Pro license...').start();
+            licenseData = await validateLicense(licenseAnswer.licenseKey);
+
+            if (licenseData.valid) {
+                hasProLicense = true;
+                licenseData.licenseKey = licenseAnswer.licenseKey; // Store key for server-side generation
+                spinner.succeed(chalk.green(`Pro license validated! Welcome ${licenseData.email} 💎`));
+            } else {
+                spinner.fail(chalk.red('Invalid license key'));
+
+                const retryAnswer = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'retry',
+                        message: 'Would you like to try a different license key?',
+                        default: true,
+                    }
+                ]);
+
+                retryLicense = retryAnswer.retry;
+
+                if (!retryLicense) {
+                    console.log(chalk.yellow('\n💡 Generating free version instead.'));
+                    console.log(chalk.yellow('   Get Pro at: https://solostack.dev/pro\n'));
+                }
+            }
+        }
+    }
+
     try {
         // Start generation
         console.log(chalk.cyan('\\n⚙️  Creating your SaaS boilerplate...\\n'));
@@ -156,6 +221,29 @@ export async function main() {
         await generateSetup(projectPath, config);
         spinner.succeed('Added diagnostics page (/setup)');
 
+        // Pro Features Generation (Server-Side)
+        if (hasProLicense) {
+            console.log(chalk.cyan('\n💎 Fetching Pro features from server...\n'));
+
+            spinner = ora('Downloading Pro features (OAuth, Admin, API Keys, Billing...)').start();
+            try {
+                const fileCount = await generateProFromServer(projectPath, licenseData.licenseKey, config);
+                spinner.succeed(`Pro features downloaded (${fileCount} files)`);
+            } catch (error) {
+                spinner.fail('Failed to download Pro features');
+                console.log(chalk.yellow('\n⚠️  Error: ' + error.message));
+                console.log(chalk.yellow('   Continuing with free version...\n'));
+                hasProLicense = false;
+            }
+
+            if (hasProLicense) {
+                // Install Pro-specific packages
+                spinner = ora('Installing Pro packages...').start();
+                await installProPackages(projectPath);
+                spinner.succeed('Pro packages installed');
+            }
+        }
+
         // Install dependencies
         spinner = ora('Installing dependencies (this may take a minute...)').start();
         await installPackages(projectPath);
@@ -169,7 +257,11 @@ export async function main() {
         }
 
         // Success message
-        printSuccess(projectName, projectPath);
+        if (hasProLicense) {
+            printProSuccess(projectName, projectPath);
+        } else {
+            printSuccess(projectName, projectPath);
+        }
 
         // Optional setup wizard
         console.log(); // Empty line for spacing