How to Build a Subscription System with Replit

1// After running /stripe, paste this into Replit Agent:
2// Build a SaaS subscription system with Express, PostgreSQL (Drizzle ORM), and Stripe.
3// Schema: plans (id serial PK, name text, description text, stripe_price_id text unique,
4// amount integer cents, interval text monthly/yearly, features jsonb array of {key, label, included bool},
5// display_order integer default 0, is_active bool default true),
6// subscriptions (id serial PK, user_id text unique, plan_id int references plans,
7// stripe_subscription_id text unique, stripe_customer_id text,
8// status text active/trialing/past_due/canceled/incomplete,
9// current_period_start timestamp, current_period_end timestamp,
10// cancel_at_period_end bool default false, trial_end timestamp, created_at),
11// subscription_events (id serial PK, subscription_id int references subscriptions,
12// event_type text, stripe_event_id text unique, metadata jsonb, created_at),
13// webhook_events (id serial PK, stripe_event_id text unique, event_type text, processed_at timestamp).
14// Routes: GET /api/plans, POST /api/subscribe (Stripe Checkout mode=subscription, 14-day trial),
15// POST /api/billing-portal (Stripe Customer Portal), GET /api/subscription,
16// GET /api/subscription/features, POST /api/webhooks/stripe.
17// Mount /api/webhooks/stripe BEFORE express.json() using express.raw().
18// Core middleware: requireFeature(key) — loads user subscription, checks plan features jsonb,
19// returns 403 if key not included: true.
20// React: pricing page with plan cards, feature comparison, current plan badge, upgrade button;
21// subscription status banner; billing portal link.
22// Bind server to 0.0.0.0.

1// Seed script — run once to populate plans table
2// server/seed.js
3const { db } = require('./db');
4const { plans } = require('./schema');
5
6async function seed() {
7  await db.insert(plans).values([
8    {
9      name: 'Free',
10      description: 'Get started with the basics',
11      stripePriceId: 'price_free',  // no Stripe price for free tier
12      amount: 0,
13      interval: 'monthly',
14      features: [
15        { key: 'projects', label: 'Up to 3 projects', included: true },
16        { key: 'api_access', label: 'API access', included: false },
17        { key: 'team_members', label: 'Team members', included: false },
18      ],
19      displayOrder: 0,
20      isActive: true,
21    },
22    {
23      name: 'Pro',
24      description: 'For growing teams',
25      stripePriceId: 'price_XXXX',  // replace with your Stripe price ID
26      amount: 2900,  // $29.00 in cents
27      interval: 'monthly',
28      features: [
29        { key: 'projects', label: 'Unlimited projects', included: true },
30        { key: 'api_access', label: 'API access', included: true },
31        { key: 'team_members', label: 'Up to 10 team members', included: true },
32      ],
33      displayOrder: 1,
34      isActive: true,
35    },
36  ]).onConflictDoNothing();
37
38  console.log('Plans seeded');
39  process.exit(0);
40}
41
42seed().catch(console.error);

1// server/middleware/requireFeature.js
2const { eq, and, inArray } = require('drizzle-orm');
3const { db } = require('../db');
4const { subscriptions, plans } = require('../schema');
5
6const ACTIVE_STATUSES = ['active', 'trialing'];
7
8function requireFeature(featureKey) {
9  return async (req, res, next) => {
10    if (!req.user) {
11      return res.status(401).json({ error: 'Login required' });
12    }
13
14    // Load subscription with plan data
15    const rows = await db
16      .select({
17        status: subscriptions.status,
18        features: plans.features,
19        planName: plans.name,
20      })
21      .from(subscriptions)
22      .innerJoin(plans, eq(subscriptions.planId, plans.id))
23      .where(
24        and(
25          eq(subscriptions.userId, req.user.id),
26          inArray(subscriptions.status, ACTIVE_STATUSES)
27        )
28      )
29      .limit(1);
30
31    if (rows.length === 0) {
32      return res.status(402).json({
33        error: 'Subscription required',
34        upgradeUrl: '/pricing',
35      });
36    }
37
38    const { features, planName } = rows[0];
39    const feature = features.find(f => f.key === featureKey);
40
41    if (!feature || !feature.included) {
42      return res.status(403).json({
43        error: `Feature '${featureKey}' requires a higher plan`,
44        currentPlan: planName,
45        upgradeUrl: '/pricing',
46      });
47    }
48
49    req.subscription = rows[0];
50    next();
51  };
52}
53
54module.exports = { requireFeature };
55
56// Usage example:
57// const { requireFeature } = require('../middleware/requireFeature');
58// app.get('/api/pro/data', requireFeature('api_access'), (req, res) => {
59//   res.json({ data: 'premium content' });
60// });

1// server/routes/webhook.js
2const express = require('express');
3const stripe = require('../stripe');
4const { db } = require('../db');
5const { eq } = require('drizzle-orm');
6const { subscriptions, plans, subscriptionEvents, webhookEvents } = require('../schema');
7
8const router = express.Router();
9
10router.post('/', async (req, res) => {
11  const sig = req.headers['stripe-signature'];
12  let event;
13
14  try {
15    // SYNC — do NOT use constructEventAsync on Node.js/Replit
16    event = stripe.webhooks.constructEvent(
17      req.body, sig, process.env.STRIPE_WEBHOOK_SECRET
18    );
19  } catch (err) {
20    return res.status(400).send(`Webhook Error: ${err.message}`);
21  }
22
23  // Idempotency
24  const inserted = await db.insert(webhookEvents)
25    .values({ id: event.id, eventType: event.type })
26    .onConflictDoNothing()
27    .returning({ id: webhookEvents.id });
28
29  if (inserted.length === 0) return res.json({ received: true });
30
31  try {
32    const sub = event.data.object;
33    switch (event.type) {
34      case 'customer.subscription.created': {
35        const item = sub.items.data[0];
36        const [plan] = await db.select().from(plans)
37          .where(eq(plans.stripePriceId, item.price.id)).limit(1);
38
39        await db.insert(subscriptions).values({
40          userId: sub.metadata.user_id,
41          planId: plan.id,
42          stripeSubscriptionId: sub.id,
43          stripeCustomerId: sub.customer,
44          status: sub.status,
45          currentPeriodStart: new Date(sub.current_period_start * 1000),
46          currentPeriodEnd: new Date(sub.current_period_end * 1000),
47          cancelAtPeriodEnd: sub.cancel_at_period_end,
48          trialEnd: sub.trial_end ? new Date(sub.trial_end * 1000) : null,
49        }).onConflictDoNothing();
50        break;
51      }
52      case 'customer.subscription.updated': {
53        const item = sub.items.data[0];
54        const [plan] = await db.select().from(plans)
55          .where(eq(plans.stripePriceId, item.price.id)).limit(1);
56
57        await db.update(subscriptions)
58          .set({
59            planId: plan?.id,
60            status: sub.status,
61            currentPeriodEnd: new Date(sub.current_period_end * 1000),
62            cancelAtPeriodEnd: sub.cancel_at_period_end,
63          })
64          .where(eq(subscriptions.stripeSubscriptionId, sub.id));
65        break;
66      }
67      case 'customer.subscription.deleted':
68        await db.update(subscriptions)
69          .set({ status: 'canceled' })
70          .where(eq(subscriptions.stripeSubscriptionId, sub.id));
71        break;
72      case 'invoice.payment_failed':
73        await db.update(subscriptions)
74          .set({ status: 'past_due' })
75          .where(eq(subscriptions.stripeSubscriptionId, sub.subscription));
76        break;
77    }
78    return res.json({ received: true });
79  } catch (err) {
80    console.error('[webhook] error:', err);
81    return res.status(500).send('handler error');
82  }
83});
84
85module.exports = router;

1// server/routes/portal.js
2const express = require('express');
3const stripe = require('../stripe');
4const { getBaseUrl } = require('../lib/baseUrl');
5const { db } = require('../db');
6const { eq } = require('drizzle-orm');
7const { subscriptions } = require('../schema');
8
9const router = express.Router();
10
11router.post('/api/billing-portal', express.json(), async (req, res) => {
12  const userId = req.user.id;
13  const baseUrl = getBaseUrl();
14
15  const [sub] = await db.select()
16    .from(subscriptions)
17    .where(eq(subscriptions.userId, userId))
18    .limit(1);
19
20  if (!sub) {
21    return res.status(404).json({ error: 'No subscription found' });
22  }
23
24  // NOTE: First use in test mode requires saving portal settings at
25  // https://dashboard.stripe.com/test/settings/billing/portal
26  const portalSession = await stripe.billingPortal.sessions.create({
27    customer: sub.stripeCustomerId,
28    return_url: `${baseUrl}/account`,
29  });
30
31  res.json({ url: portalSession.url });
32});
33
34module.exports = router;