Stripe Payments & Subscriptions for SaaS

1. User clicks "Subscribe to Pro Plan" on your site
2. Your API creates a Stripe Checkout Session
3. User is redirected to Stripe's hosted payment page
4. User enters credit card on Stripe's page (you never see the card)
5. Stripe charges the card
6. Stripe redirects user back to your success URL
7. Stripe sends a webhook to your API: "payment succeeded"
8. Your API activates the user's subscription

# Install the plugin
go get github.com/MUKE-coder/grit-plugins/grit-stripe

# Stripe Configuration (TEST MODE — safe for development)
STRIPE_SECRET_KEY=sk_test_51...your_secret_key
STRIPE_PUBLISHABLE_KEY=pk_test_51...your_publishable_key
STRIPE_WEBHOOK_SECRET=whsec_...your_webhook_secret

import gritstripe "github.com/MUKE-coder/grit-plugins/grit-stripe"

func InitStripe() {
    gritstripe.Init(gritstripe.Config{
        SecretKey:      os.Getenv("STRIPE_SECRET_KEY"),
        WebhookSecret:  os.Getenv("STRIPE_WEBHOOK_SECRET"),
    })
}

import gritstripe "github.com/MUKE-coder/grit-plugins/grit-stripe"

func (h *Handler) CreateCheckout(c *gin.Context) {
    user := middleware.GetUser(c) // From auth middleware

    var input struct {
        PriceID string // json:"price_id"
    }
    c.ShouldBindJSON(&input)

    session := gritstripe.CreateCheckoutSession(gritstripe.CheckoutParams{
        PriceID:       input.PriceID,
        SuccessURL:    "https://myapp.com/billing/success",
        CancelURL:     "https://myapp.com/billing",
        CustomerEmail: user.Email,
        Metadata: map[string]string{
            "user_id": fmt.Sprint(user.ID),
        },
    })

    // Return the Stripe-hosted payment page URL
    c.JSON(200, gin.H{"url": session.URL})
}

// 1. Call your API to create a checkout session
// POST /api/billing/checkout with { price_id: "price_xxx" }

// 2. API returns { url: "https://checkout.stripe.com/c/pay/..." }

// 3. Redirect the user to Stripe's payment page
// window.location.href = response.url

// 4. User enters card on Stripe's page
// 5. On success: Stripe redirects to your success URL
// 6. On cancel: Stripe redirects to your cancel URL

Free Plan
  - Price: $0/month (no Stripe integration needed)
  - Features: 1 project, 100 API calls/day, community support
  - Stripe Price ID: none (default for all users)

Pro Plan
  - Price: $20/month
  - Features: 10 projects, 10,000 API calls/day, email support
  - Stripe Price ID: price_pro_monthly

Team Plan
  - Price: $50/month
  - Features: Unlimited projects, 100,000 API calls/day, priority support, team members
  - Stripe Price ID: price_team_monthly

func (h *Handler) HandleStripeWebhook(c *gin.Context) {
    gritstripe.HandleWebhook(c, gritstripe.WebhookHandlers{

        // Payment successful — activate subscription
        "checkout.session.completed": func(event stripe.Event) {
            // Extract user_id from session metadata
            // Update user's plan in database
            // Set subscription_status = "active"
            // Set stripe_customer_id on user record
        },

        // Subscription renewed (monthly payment)
        "invoice.payment_succeeded": func(event stripe.Event) {
            // Update subscription period end date
            // Log the payment
        },

        // Payment failed (card declined, expired, etc.)
        "invoice.payment_failed": func(event stripe.Event) {
            // Send email: "Your payment failed"
            // Grace period: keep subscription active for 3 days
            // After grace period: downgrade to free
        },

        // User cancelled — subscription ends at period end
        "customer.subscription.deleted": func(event stripe.Event) {
            // Downgrade user to free plan
            // Set subscription_status = "cancelled"
        },

        // Subscription updated (plan change)
        "customer.subscription.updated": func(event stripe.Event) {
            // Update user's plan in database
            // If upgraded: activate new features immediately
            // If downgraded: keep current plan until period end
        },
    })
}

// Webhook endpoint — no auth middleware!
// Stripe authenticates via webhook signature, not JWT
r.POST("/api/webhooks/stripe", h.HandleStripeWebhook)

func (h *Handler) CreatePortalSession(c *gin.Context) {
    user := middleware.GetUser(c)

    // Get the user's Stripe customer ID from your database
    stripeCustomerID := user.StripeCustomerID

    portalSession := gritstripe.CreatePortalSession(
        stripeCustomerID,
        "https://myapp.com/billing", // Return URL after portal
    )

    c.JSON(200, gin.H{"url": portalSession.URL})
}

// Route: POST /api/billing/portal

// PricingPage component
//
// Layout: 3 cards in a row (responsive: stack on mobile)
//
// Free Plan Card:
//   - Title: "Free"
//   - Price: "$0/month"
//   - Features: checkmark list (1 project, 100 API calls, etc.)
//   - Button: "Get Started" → link to /register
//
// Pro Plan Card (highlighted — "Most Popular"):
//   - Title: "Pro"
//   - Price: "$20/month"
//   - Features: checkmark list (10 projects, 10K API calls, etc.)
//   - Button: "Subscribe" → POST /api/billing/checkout
//     with price_id = STRIPE_PRO_PRICE_ID
//
// Team Plan Card:
//   - Title: "Team"
//   - Price: "$50/month"
//   - Features: checkmark list (unlimited, priority support, etc.)
//   - Button: "Subscribe" → POST /api/billing/checkout
//     with price_id = STRIPE_TEAM_PRICE_ID
//
// Each Subscribe button:
//   1. Calls POST /api/billing/checkout
//   2. Gets back { url: "https://checkout.stripe.com/..." }
//   3. Redirects: window.location.href = url

type User struct {
    gorm.Model
    Name               string
    Email              string
    Password           string
    Role               string // "USER", "ADMIN"

    // Stripe fields
    StripeCustomerID   string // Stripe customer ID
    SubscriptionPlan   string // "free", "pro", "team"
    SubscriptionStatus string // "active", "cancelled", "past_due"
    PeriodEnd          time.Time // When current billing period ends
}

func RequireSubscription(plans ...string) gin.HandlerFunc {
    return func(c *gin.Context) {
        user := GetUser(c)

        // Check if user's plan is in the required plans
        allowed := false
        for _, plan := range plans {
            if user.SubscriptionPlan == plan {
                allowed = true
                break
            }
        }

        if !allowed {
            c.JSON(403, gin.H{
                "error": "This feature requires a " + plans[0] + " subscription",
            })
            c.Abort()
            return
        }

        c.Next()
    }
}

// Usage in routes:
// r.GET("/api/analytics", RequireSubscription("pro", "team"), h.GetAnalytics)
// r.GET("/api/team/members", RequireSubscription("team"), h.GetTeamMembers)

// After login, the user object includes subscription info
// user.subscription_plan = "pro"
// user.subscription_status = "active"

// Show/hide features based on plan:
// If plan is "free": show upgrade banner
// If plan is "pro": show Pro features, hide Team features
// If plan is "team": show all features

// On the dashboard:
// Free users see: "Upgrade to Pro for advanced analytics"
// Pro users see: the analytics dashboard
// Team users see: analytics + team management