How to Build a Booking Platform with Replit

1// Prompt to type into Replit Agent:
2// Build a Node.js Express booking platform with Replit Auth and built-in PostgreSQL using Drizzle ORM.
3// Schema in shared/schema.ts:
4// * providers: id serial pk, user_id text not null unique, name text not null, bio text,
5//   timezone text not null default 'America/New_York', avatar_url text, created_at timestamp default now()
6// * services: id serial pk, provider_id integer references providers not null,
7//   name text not null, duration_minutes integer not null, price integer, description text,
8//   is_active boolean default true
9// * availability: id serial pk, provider_id integer references providers not null,
10//   day_of_week integer not null (0=Sunday to 6=Saturday), start_time text not null (HH:MM),
11//   end_time text not null (HH:MM), is_active boolean default true,
12//   unique on (provider_id, day_of_week, start_time)
13// * availability_overrides: id serial pk, provider_id integer references providers not null,
14//   date date not null, is_blocked boolean default true,
15//   custom_start text, custom_end text
16// * bookings: id serial pk, provider_id integer references providers not null,
17//   service_id integer references services not null, customer_name text not null,
18//   customer_email text not null, start_time timestamp not null, end_time timestamp not null,
19//   status text default 'confirmed', notes text,
20//   confirmation_code text unique not null, created_at timestamp default now()
21// Routes: GET /api/providers/:id, GET /api/providers/:id/slots,
22// POST /api/bookings, GET /api/bookings/:code, PATCH /api/bookings/:code/cancel,
23// GET /api/provider/bookings, PUT /api/provider/availability
24// React frontend with public booking page and provider dashboard

1import { db } from '../db.js';
2import { availability, availabilityOverrides, bookings, services } from '../../shared/schema.js';
3import { eq, and, gte, lt } from 'drizzle-orm';
4import { DateTime } from 'luxon';
5
6export async function getAvailableSlots(req, res) {
7  const providerId = parseInt(req.params.id);
8  const { date, serviceId } = req.query;
9  if (!date || !serviceId) return res.status(400).json({ error: 'date and serviceId are required' });
10
11  const [service] = await db.select().from(services).where(eq(services.id, parseInt(serviceId)));
12  if (!service) return res.status(404).json({ error: 'Service not found' });
13
14  const [providerRow] = await db.select().from(availability).where(eq(availability.providerId, providerId)).limit(1);
15  const timezone = 'America/New_York'; // TODO: fetch from providers table
16
17  // Parse the target date in provider's timezone
18  const targetDate = DateTime.fromISO(date, { zone: timezone });
19  const dayOfWeek = targetDate.weekday % 7; // luxon: 1=Mon...7=Sun, we want 0=Sun
20
21  // Check for override on this date
22  const [override] = await db.select().from(availabilityOverrides).where(
23    and(eq(availabilityOverrides.providerId, providerId), eq(availabilityOverrides.date, date))
24  );
25
26  if (override?.isBlocked) return res.json({ slots: [] });
27
28  // Get recurring schedule for this day
29  const schedule = await db.select().from(availability).where(
30    and(eq(availability.providerId, providerId), eq(availability.dayOfWeek, dayOfWeek), eq(availability.isActive, true))
31  );
32
33  if (schedule.length === 0) return res.json({ slots: [] });
34
35  // Use override times if present, otherwise use schedule
36  const startStr = override?.customStart || schedule[0].startTime;
37  const endStr = override?.customEnd || schedule[0].endTime;
38  const workStart = targetDate.set({ hour: parseInt(startStr), minute: parseInt(startStr.split(':')[1]) });
39  const workEnd = targetDate.set({ hour: parseInt(endStr), minute: parseInt(endStr.split(':')[1]) });
40
41  // Fetch existing bookings for this provider on this date
42  const dayStart = targetDate.startOf('day').toJSDate();
43  const dayEnd = targetDate.endOf('day').toJSDate();
44  const existingBookings = await db.select().from(bookings).where(
45    and(eq(bookings.providerId, providerId), gte(bookings.startTime, dayStart), lt(bookings.startTime, dayEnd))
46  );
47
48  // Generate slots
49  const slots = [];
50  let slotStart = workStart;
51  const durationMinutes = service.durationMinutes;
52
53  while (slotStart.plus({ minutes: durationMinutes }) <= workEnd) {
54    const slotEnd = slotStart.plus({ minutes: durationMinutes });
55
56    // Check if slot overlaps any existing booking
57    const overlaps = existingBookings.some(b => {
58      const bStart = DateTime.fromJSDate(b.startTime);
59      const bEnd = DateTime.fromJSDate(b.endTime);
60      return slotStart < bEnd && slotEnd > bStart;
61    });
62
63    if (!overlaps) {
64      slots.push({ start: slotStart.toISO(), end: slotEnd.toISO(), displayStart: slotStart.toFormat('h:mm a') });
65    }
66
67    slotStart = slotStart.plus({ minutes: durationMinutes + 15 }); // 15-min buffer between slots
68  }
69
70  res.json({ slots });
71}

1import crypto from 'crypto';
2import { db } from '../db.js';
3import { bookings } from '../../shared/schema.js';
4import { and, eq, lt, gte } from 'drizzle-orm';
5
6function generateConfirmationCode() {
7  return 'BOOK-' + crypto.randomBytes(4).toString('hex').toUpperCase();
8}
9
10export async function createBooking(req, res) {
11  const { providerId, serviceId, customerName, customerEmail, startTime, notes } = req.body;
12  const start = new Date(startTime);
13
14  const [service] = await db.select().from(services).where(eq(services.id, serviceId));
15  if (!service) return res.status(404).json({ error: 'Service not found' });
16
17  const end = new Date(start.getTime() + service.durationMinutes * 60 * 1000);
18
19  const client = await db.$client.connect();
20  try {
21    await client.query('BEGIN');
22
23    // Check for overlapping bookings with row lock
24    const { rows: conflicts } = await client.query(
25      `SELECT id FROM bookings
26       WHERE provider_id = $1 AND status != 'cancelled'
27       AND start_time < $2 AND end_time > $3
28       FOR UPDATE`,
29      [providerId, end, start]
30    );
31
32    if (conflicts.length > 0) {
33      await client.query('ROLLBACK');
34      return res.status(409).json({ error: 'This time slot is no longer available' });
35    }
36
37    const confirmationCode = generateConfirmationCode();
38    const { rows: [booking] } = await client.query(
39      `INSERT INTO bookings (provider_id, service_id, customer_name, customer_email, start_time, end_time, status, notes, confirmation_code)
40       VALUES ($1, $2, $3, $4, $5, $6, 'confirmed', $7, $8) RETURNING *`,
41      [providerId, serviceId, customerName, customerEmail, start, end, notes || null, confirmationCode]
42    );
43
44    await client.query('COMMIT');
45
46    // Send confirmation email (non-blocking)
47    sendConfirmationEmail(booking).catch(console.error);
48
49    res.status(201).json({ booking, confirmationCode });
50  } catch (err) {
51    await client.query('ROLLBACK');
52    res.status(500).json({ error: 'Booking failed' });
53  } finally {
54    client.release();
55  }
56}

1import { Resend } from 'resend'; // or: import sgMail from '@sendgrid/mail';
2
3const resend = new Resend(process.env.RESEND_API_KEY);
4
5export async function sendConfirmationEmail(booking) {
6  const dateStr = new Date(booking.start_time).toLocaleString('en-US', {
7    weekday: 'long', year: 'numeric', month: 'long', day: 'numeric',
8    hour: '2-digit', minute: '2-digit', timeZoneName: 'short',
9  });
10
11  await resend.emails.send({
12    from: 'bookings@yourdomain.com',
13    to: booking.customer_email,
14    subject: `Booking Confirmed — ${dateStr}`,
15    html: `
16      <h2>Your booking is confirmed!</h2>
17      <p><strong>Date:</strong> ${dateStr}</p>
18      <p><strong>Confirmation code:</strong> ${booking.confirmation_code}</p>
19      <p>To cancel, visit: ${process.env.APP_URL}/bookings/${booking.confirmation_code}/cancel</p>
20    `,
21  });
22}
23
24// Add to Replit Secrets (lock icon 🔒):
25// RESEND_API_KEY=re_...
26// APP_URL=https://your-deployed-url.replit.app
27//
28// Deploy on Autoscale:
29// Booking pages get shared on social media and booking links — traffic is unpredictable.
30// Autoscale handles spikes automatically. Cold starts are hidden by the booking form load time.
31// Set deployment target in .replit:
32// [deployment]
33// deploymentTarget = "autoscale"