How to Build a Membership Site with Replit

1// Step 1: Type this into Replit Agent:
2// Build a membership site with Express and PostgreSQL using Drizzle ORM.
3// Tables:
4// - membership_tiers: id serial pk, name text not null, description text,
5//   price integer not null (cents per month, 0 for free), stripe_price_id text unique,
6//   features jsonb, max_members integer, display_order integer default 0,
7//   is_active boolean default true
8// - members: id serial pk, user_id text unique not null, email text not null, name text,
9//   tier_id integer FK membership_tiers not null, stripe_customer_id text,
10//   stripe_subscription_id text, status text default 'active'
11//   (enum: active/expired/cancelled/paused), joined_at timestamp default now(),
12//   expires_at timestamp
13// - protected_content: id serial pk, title text not null, body text not null,
14//   min_tier_id integer FK membership_tiers not null,
15//   content_type text default 'article' (enum: article/video/download/course),
16//   file_url text, published_at timestamp, created_at timestamp default now()
17// - member_content_access: id serial pk, member_id integer FK members,
18//   content_id integer FK protected_content, accessed_at timestamp default now()
19// - webhook_events: id serial pk, stripe_event_id text unique, event_type text,
20//   processed_at timestamp default now()
21// Routes: GET /api/tiers, POST /api/members/join, GET /api/members/me,
22// POST /api/billing-portal, GET /api/content, GET /api/content/:id,
23// POST /api/admin/content, GET /api/admin/members, POST /api/webhooks/stripe.
24// Replit Auth. Bind server to 0.0.0.0.
25
26// Step 2: After Agent creates the project, type in Replit chat:
27// /stripe
28// This provisions Stripe test sandbox, adds STRIPE_SECRET_KEY and
29// STRIPE_PUBLISHABLE_KEY to Secrets, and creates basic checkout routes.

1// scripts/seed-tiers.js — run once to create membership tiers
2const { db } = require('../server/db');
3const { membershipTiers } = require('./shared/schema');
4
5async function seedTiers() {
6  // Create tiers in order (display_order determines access hierarchy)
7  await db.insert(membershipTiers).values([
8    {
9      name: 'Free',
10      description: 'Access to free content',
11      price: 0,
12      stripePriceId: null, // No Stripe price for free tier
13      features: JSON.stringify(['Access to free articles', 'Weekly newsletter']),
14      displayOrder: 0,
15      isActive: true,
16    },
17    {
18      name: 'Silver',
19      description: 'Access to Silver and Free content',
20      price: 900, // $9/month in cents
21      // Get this from Stripe Dashboard → Products → Create a product → Add price (recurring)
22      stripePriceId: process.env.STRIPE_SILVER_PRICE_ID,
23      features: JSON.stringify(['Everything in Free', 'Premium articles', 'Monthly webinars']),
24      displayOrder: 1,
25      isActive: true,
26    },
27    {
28      name: 'Gold',
29      description: 'Access to all content',
30      price: 2900, // $29/month in cents
31      stripePriceId: process.env.STRIPE_GOLD_PRICE_ID,
32      features: JSON.stringify(['Everything in Silver', 'Video courses', 'Direct Q&A access', '1-on-1 calls']),
33      displayOrder: 2,
34      isActive: true,
35    },
36  ]).onConflictDoNothing();
37
38  console.log('Tiers seeded. Add STRIPE_SILVER_PRICE_ID and STRIPE_GOLD_PRICE_ID to Replit Secrets.');
39  process.exit(0);
40}
41
42seedTiers().catch(console.error);

1const { db } = require('../db');
2const { members, membershipTiers } = require('../../shared/schema');
3const { eq } = require('drizzle-orm');
4
5// Middleware: checks member tier against required minimum tier
6exports.requireTier = (minTierOrder) => async (req, res, next) => {
7  const userId = req.user?.id;
8  if (!userId) {
9    return res.status(401).json({ error: 'Login required', loginUrl: '/login' });
10  }
11
12  const result = await db
13    .select({
14      memberId: members.id,
15      tierOrder: membershipTiers.displayOrder,
16      tierName: membershipTiers.name,
17      status: members.status,
18    })
19    .from(members)
20    .innerJoin(membershipTiers, eq(members.tierId, membershipTiers.id))
21    .where(eq(members.userId, userId));
22
23  if (!result[0]) {
24    return res.status(403).json({
25      error: 'No active membership',
26      upgradeUrl: '/pricing',
27    });
28  }
29
30  const member = result[0];
31
32  if (member.status !== 'active') {
33    return res.status(403).json({
34      error: 'Membership expired or cancelled',
35      upgradeUrl: '/billing',
36    });
37  }
38
39  if (member.tierOrder < minTierOrder) {
40    return res.status(403).json({
41      error: `This content requires a higher membership tier`,
42      currentTier: member.tierName,
43      upgradeUrl: '/pricing',
44    });
45  }
46
47  // Attach member info to request for use in route handlers
48  req.member = member;
49  next();
50};
51
52// GET /api/content/:id — protected content with access logging
53exports.getContent = async (req, res) => {
54  const { protectedContent, memberContentAccess } = require('../../shared/schema');
55  const [content] = await db.select().from(protectedContent)
56    .where(eq(protectedContent.id, parseInt(req.params.id)));
57
58  if (!content) return res.status(404).json({ error: 'Content not found' });
59
60  // Log access
61  await db.insert(memberContentAccess).values({
62    memberId: req.member.memberId,
63    contentId: content.id,
64  }).onConflictDoNothing();
65
66  res.json(content);
67};

1const Stripe = require('stripe');
2const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
3const { members, membershipTiers } = require('../../shared/schema');
4const { eq } = require('drizzle-orm');
5
6// POST /api/members/join — start subscription checkout
7router.post('/members/join', async (req, res) => {
8  const userId = req.user?.id;
9  if (!userId) return res.status(401).json({ error: 'Login required' });
10
11  const { tierId } = req.body;
12  const [tier] = await db.select().from(membershipTiers).where(eq(membershipTiers.id, tierId));
13  if (!tier) return res.status(404).json({ error: 'Tier not found' });
14
15  // Free tier: create member directly without Stripe
16  if (tier.price === 0) {
17    await db.insert(members).values({
18      userId,
19      email: req.user.email || '',
20      tierId: tier.id,
21      status: 'active',
22    }).onConflictDoNothing();
23    return res.json({ redirect: '/dashboard' });
24  }
25
26  // Paid tier: create Stripe Checkout Session for subscription
27  const session = await stripe.checkout.sessions.create({
28    payment_method_types: ['card'],
29    mode: 'subscription',
30    line_items: [{ price: tier.stripePriceId, quantity: 1 }],
31    success_url: `${process.env.REPLIT_DEPLOYMENT_URL}/dashboard?welcome=1`,
32    cancel_url: `${process.env.REPLIT_DEPLOYMENT_URL}/pricing`,
33    metadata: { userId, tierId: tier.id.toString() },
34  });
35
36  res.json({ checkoutUrl: session.url });
37});
38
39// POST /api/billing-portal — Stripe Customer Portal
40router.post('/billing-portal', async (req, res) => {
41  const userId = req.user?.id;
42  const [member] = await db.select().from(members).where(eq(members.userId, userId));
43  if (!member?.stripeCustomerId) {
44    return res.status(400).json({ error: 'No billing information found' });
45  }
46
47  const portalSession = await stripe.billingPortal.sessions.create({
48    customer: member.stripeCustomerId,
49    return_url: `${process.env.REPLIT_DEPLOYMENT_URL}/dashboard`,
50  });
51
52  res.json({ url: portalSession.url });
53});

1// POST /api/webhooks/stripe — handle subscription lifecycle
2// Register this route BEFORE express.json() in server/index.js
3router.post('/webhooks/stripe', express.raw({ type: 'application/json' }), async (req, res) => {
4  const sig = req.headers['stripe-signature'];
5  let event;
6
7  try {
8    event = stripe.webhooks.constructEvent(req.body, sig, process.env.STRIPE_WEBHOOK_SECRET);
9  } catch (err) {
10    return res.status(400).send(`Webhook Error: ${err.message}`);
11  }
12
13  const existing = await db.select().from(webhookEvents)
14    .where(eq(webhookEvents.stripeEventId, event.id));
15  if (existing.length > 0) return res.json({ received: true });
16  await db.insert(webhookEvents).values({ stripeEventId: event.id, eventType: event.type });
17
18  if (event.type === 'checkout.session.completed') {
19    const session = event.data.object;
20    if (session.mode !== 'subscription') return res.json({ received: true });
21
22    const { userId, tierId } = session.metadata;
23    await db.insert(members).values({
24      userId,
25      email: session.customer_details?.email || '',
26      tierId: parseInt(tierId),
27      stripeCustomerId: session.customer,
28      stripeSubscriptionId: session.subscription,
29      status: 'active',
30    }).onConflictDoUpdate({
31      target: members.userId,
32      set: { tierId: parseInt(tierId), status: 'active', stripeSubscriptionId: session.subscription },
33    });
34  }
35
36  if (event.type === 'customer.subscription.deleted') {
37    const subscription = event.data.object;
38    await db.update(members)
39      .set({ status: 'expired' })
40      .where(eq(members.stripeSubscriptionId, subscription.id));
41  }
42
43  res.json({ received: true });
44});