How to Build a Ride Hailing Platform with Replit

1// Type this into Replit Agent:
2// Build a ride-hailing platform with Express and PostgreSQL using Drizzle ORM.
3// Install stripe npm package manually (DO NOT use /stripe command).
4// Tables:
5// - users: id serial pk, user_id text not null unique (Replit Auth ID),
6//   type text not null (enum rider/driver), name text not null,
7//   phone text, email text, created_at timestamp default now()
8// - drivers: id serial, user_id integer FK users not null unique,
9//   vehicle_make text, vehicle_model text, vehicle_year integer,
10//   license_plate text, is_online boolean default false,
11//   current_lat numeric, current_lng numeric,
12//   rating_avg numeric default 5.0, total_rides integer default 0,
13//   stripe_account_id text, payout_status text default 'pending'
14// - rides: id serial, rider_id integer FK users not null,
15//   driver_id integer FK users, pickup_lat numeric not null,
16//   pickup_lng numeric not null, pickup_address text,
17//   dropoff_lat numeric not null, dropoff_lng numeric not null,
18//   dropoff_address text,
19//   status text default 'requested' (enum requested/matched/driver_en_route/in_progress/completed/cancelled),
20//   fare_estimate integer not null (cents), fare_actual integer,
21//   distance_km numeric, duration_minutes integer,
22//   started_at timestamp, completed_at timestamp,
23//   created_at timestamp default now()
24// - ride_tracking: id serial, ride_id integer FK rides not null,
25//   lat numeric not null, lng numeric not null,
26//   recorded_at timestamp default now()
27// - ratings: id serial, ride_id integer FK rides not null unique,
28//   rider_rating integer, driver_rating integer,
29//   rider_comment text, driver_comment text,
30//   created_at timestamp default now()
31// Routes:
32// POST /api/rides/request — fare estimate + create ride
33// POST /api/rides/:id/accept — driver accepts ride
34// PATCH /api/rides/:id/status — advance status
35// POST /api/rides/:id/cancel — cancel
36// POST /api/rides/:id/track — driver posts GPS coordinates
37// GET /api/rides/:id/track — rider polls latest driver position
38// POST /api/rides/:id/rate — mutual post-ride rating
39// PATCH /api/drivers/online — toggle driver availability + update GPS
40// GET /api/drivers/nearby — find online drivers within radius
41// GET /api/rides/active — current active ride
42// GET /api/rides/history — past rides
43// POST /api/drivers/onboard — Stripe Connect Express onboarding
44// POST /api/webhooks/stripe — raw body, Stripe payouts webhook
45// Register webhook route BEFORE express.json(). Use Replit Auth. Bind server to 0.0.0.0.

1const fetch = require('node-fetch');
2const { rides, drivers, users } = require('../../shared/schema');
3const { eq, and, sql } = require('drizzle-orm');
4
5const BASE_FARE_CENTS = 200;  // $2.00 base
6const PER_KM_CENTS = 120;     // $1.20 per km
7const PER_MIN_CENTS = 25;     // $0.25 per minute
8
9async function estimateFare(pickupLat, pickupLng, dropoffLat, dropoffLng) {
10  const url = `https://api.openrouteservice.org/v2/directions/driving-car?api_key=${process.env.ORS_API_KEY}&start=${pickupLng},${pickupLat}&end=${dropoffLng},${dropoffLat}`;
11  const resp = await fetch(url);
12  const data = await resp.json();
13  const segment = data.features?.[0]?.properties?.segments?.[0];
14  const distanceKm = segment ? segment.distance / 1000 : 5;
15  const durationMin = segment ? segment.duration / 60 : 10;
16  const fare = BASE_FARE_CENTS + Math.round(distanceKm * PER_KM_CENTS) + Math.round(durationMin * PER_MIN_CENTS);
17  return { fare, distanceKm: Math.round(distanceKm * 10) / 10, durationMin: Math.round(durationMin) };
18}
19
20// Haversine distance in km between two lat/lng points
21function haversine(lat1, lng1, lat2, lng2) {
22  const R = 6371;
23  const dLat = (lat2 - lat1) * Math.PI / 180;
24  const dLng = (lng2 - lng1) * Math.PI / 180;
25  const a = Math.sin(dLat / 2) ** 2 +
26    Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) * Math.sin(dLng / 2) ** 2;
27  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
28}
29
30// POST /api/rides/request
31router.post('/rides/request', async (req, res) => {
32  const userId = req.user?.id;
33  if (!userId) return res.status(401).json({ error: 'Login required' });
34
35  const { pickupLat, pickupLng, pickupAddress, dropoffLat, dropoffLng, dropoffAddress } = req.body;
36
37  const { fare, distanceKm, durationMin } = await estimateFare(pickupLat, pickupLng, dropoffLat, dropoffLng);
38
39  const [rider] = await db.select().from(users).where(eq(users.userId, userId));
40  if (!rider) return res.status(404).json({ error: 'User profile not found' });
41
42  const [ride] = await db.insert(rides).values({
43    riderId: rider.id,
44    pickupLat, pickupLng, pickupAddress,
45    dropoffLat, dropoffLng, dropoffAddress,
46    fareEstimate: fare,
47    distanceKm,
48    durationMinutes: durationMin,
49    status: 'requested',
50  }).returning();
51
52  res.status(201).json({ ride, fareEstimate: fare, distanceKm, durationMin });
53});

1// PATCH /api/drivers/online — driver toggles availability and updates GPS
2router.patch('/drivers/online', async (req, res) => {
3  const userId = req.user?.id;
4  if (!userId) return res.status(401).json({ error: 'Login required' });
5
6  const { isOnline, lat, lng } = req.body;
7
8  const [user] = await db.select().from(users).where(eq(users.userId, userId));
9  const [driver] = await db.select().from(drivers).where(eq(drivers.userId, user.id));
10  if (!driver) return res.status(404).json({ error: 'Driver profile not found' });
11
12  const [updated] = await db.update(drivers)
13    .set({ isOnline, currentLat: lat, currentLng: lng })
14    .where(eq(drivers.id, driver.id))
15    .returning();
16
17  res.json(updated);
18});
19
20// POST /api/rides/:id/track — driver posts current GPS position
21router.post('/rides/:id/track', async (req, res) => {
22  const { lat, lng } = req.body;
23  await db.insert(rideTracking).values({
24    rideId: parseInt(req.params.id),
25    lat, lng,
26  });
27  // Also update driver's current_lat/lng for nearby queries
28  const userId = req.user?.id;
29  const [user] = await db.select().from(users).where(eq(users.userId, userId));
30  const [driver] = await db.select().from(drivers).where(eq(drivers.userId, user.id));
31  if (driver) {
32    await db.update(drivers).set({ currentLat: lat, currentLng: lng }).where(eq(drivers.id, driver.id));
33  }
34  res.json({ recorded: true });
35});
36
37// GET /api/rides/:id/track — rider polls latest driver GPS position
38router.get('/rides/:id/track', async (req, res) => {
39  const [latest] = await db.select().from(rideTracking)
40    .where(eq(rideTracking.rideId, parseInt(req.params.id)))
41    .orderBy(desc(rideTracking.recordedAt))
42    .limit(1);
43  res.json(latest || null);
44});
45
46// GET /api/drivers/nearby — find online drivers within 5km of pickup
47router.get('/drivers/nearby', async (req, res) => {
48  const { lat, lng, radius = 5 } = req.query;
49  const nearbyDrivers = await db.execute(sql`
50    SELECT d.*, u.name,
51      acos(
52        sin(radians(${parseFloat(lat)})) * sin(radians(d.current_lat)) +
53        cos(radians(${parseFloat(lat)})) * cos(radians(d.current_lat)) *
54        cos(radians(d.current_lng) - radians(${parseFloat(lng)}))
55      ) * 6371 AS distance_km
56    FROM drivers d
57    JOIN users u ON u.id = d.user_id
58    WHERE d.is_online = true
59      AND d.current_lat IS NOT NULL
60    HAVING acos(
61        sin(radians(${parseFloat(lat)})) * sin(radians(d.current_lat)) +
62        cos(radians(${parseFloat(lat)})) * cos(radians(d.current_lat)) *
63        cos(radians(d.current_lng) - radians(${parseFloat(lng)}))
64      ) * 6371 <= ${parseFloat(radius)}
65    ORDER BY distance_km ASC
66    LIMIT 10
67  `);
68  res.json(nearbyDrivers.rows);
69});

1const Stripe = require('stripe');
2const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);
3const express = require('express');
4const router = express.Router();
5
6// POST /api/drivers/onboard — initiate Stripe Connect Express onboarding
7router.post('/drivers/onboard', async (req, res) => {
8  const userId = req.user?.id;
9  const [user] = await db.select().from(users).where(eq(users.userId, userId));
10  const [driver] = await db.select().from(drivers).where(eq(drivers.userId, user.id));
11  if (!driver) return res.status(404).json({ error: 'Driver profile not found' });
12
13  let accountId = driver.stripeAccountId;
14  if (!accountId) {
15    const account = await stripe.accounts.create({
16      type: 'express',
17      capabilities: { transfers: { requested: true } },
18    });
19    accountId = account.id;
20    await db.update(drivers).set({ stripeAccountId: accountId }).where(eq(drivers.id, driver.id));
21  }
22
23  const link = await stripe.accountLinks.create({
24    account: accountId,
25    refresh_url: `${process.env.REPLIT_DEPLOYMENT_URL}/driver/onboard`,
26    return_url: `${process.env.REPLIT_DEPLOYMENT_URL}/driver/dashboard`,
27    type: 'account_onboarding',
28  });
29
30  res.json({ url: link.url });
31});
32
33// POST /api/webhooks/stripe — raw body required, register BEFORE express.json()
34router.post('/webhooks/stripe', express.raw({ type: 'application/json' }), async (req, res) => {
35  const sig = req.headers['stripe-signature'];
36  let event;
37  try {
38    // constructEvent is SYNC — not async
39    event = stripe.webhooks.constructEvent(req.body, sig, process.env.STRIPE_WEBHOOK_SECRET);
40  } catch (err) {
41    return res.status(400).json({ error: `Webhook verification failed: ${err.message}` });
42  }
43
44  if (event.type === 'account.updated') {
45    const account = event.data.object;
46    if (account.charges_enabled && account.payouts_enabled) {
47      await db.update(drivers)
48        .set({ payoutStatus: 'active' })
49        .where(eq(drivers.stripeAccountId, account.id));
50    }
51  }
52
53  res.json({ received: true });
54});
55
56module.exports = router;

1// server/index.js — critical middleware order
2const express = require('express');
3const path = require('path');
4
5const payoutsRouter = require('./routes/payouts'); // contains webhook route
6const ridesRouter = require('./routes/rides');
7const trackingRouter = require('./routes/tracking');
8
9const app = express();
10
11// IMPORTANT: Register webhook route BEFORE express.json()
12// Stripe needs the raw request body for signature verification
13app.use('/api', payoutsRouter);
14
15// Then add JSON parsing for all other routes
16app.use(express.json());
17app.use('/api', ridesRouter);
18app.use('/api', trackingRouter);
19
20// Serve static frontend
21app.use(express.static(path.join(__dirname, '../client/dist')));
22app.get('*', (req, res) => {
23  res.sendFile(path.join(__dirname, '../client/dist/index.html'));
24});
25
26// Bind to 0.0.0.0 — required for Replit
27app.listen(5000, '0.0.0.0', () => console.log('Ride-hailing server running on port 5000'));
28
29// After deploying to Reserved VM:
30// 1. Stripe Dashboard → Developers → Webhooks → Add endpoint
31// 2. URL: https://your-repl.replit.app/api/webhooks/stripe
32// 3. Select events: account.updated, transfer.created
33// 4. Copy Signing Secret → Replit Secrets → STRIPE_WEBHOOK_SECRET