How to Build a Polls and Surveys with Replit

1// Type this into Replit Agent:
2// Build a polls and surveys platform with Express and PostgreSQL using Drizzle ORM.
3// Tables:
4// - surveys: id serial pk, creator_id text not null, title text not null, description text,
5//   status text default 'draft' (enum: draft/active/closed),
6//   share_code text unique not null, allow_anonymous boolean default true,
7//   created_at timestamp default now()
8// - questions: id serial pk, survey_id integer FK surveys not null,
9//   type text not null (enum: text/textarea/radio/checkbox/rating/number/dropdown),
10//   text text not null, options jsonb (array of strings for radio/checkbox/dropdown),
11//   is_required boolean default true, position integer not null
12// - responses: id serial pk, survey_id integer FK surveys not null,
13//   respondent_id text (null if anonymous), submitted_at timestamp default now()
14// - answers: id serial pk, response_id integer FK responses not null,
15//   question_id integer FK questions not null, value text not null
16// Routes: POST /api/surveys (create — auto-generate share_code),
17// GET /api/surveys (list user's surveys with response counts),
18// PUT /api/surveys/:id (update title/description/status),
19// POST /api/surveys/:id/questions (add question),
20// PUT /api/surveys/:id/questions/:qid (update question),
21// DELETE /api/surveys/:id/questions/:qid (remove),
22// PATCH /api/surveys/:id/questions/reorder (update positions),
23// GET /api/s/:shareCode (public — survey with questions),
24// POST /api/s/:shareCode/submit (submit response, no auth required),
25// GET /api/surveys/:id/responses (list responses),
26// GET /api/surveys/:id/results (aggregated results).
27// Use Replit Auth for survey creators only.
28// React frontend: survey builder, public survey form (one question at a time),
29// results dashboard. Bind server to 0.0.0.0.

1const express = require('express');
2const { db } = require('../db');
3const { surveys } = require('../../shared/schema');
4const { eq } = require('drizzle-orm');
5
6const router = express.Router();
7
8// Generate a short, unique 8-character share code
9function generateShareCode() {
10  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
11  return Array.from({ length: 8 }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
12}
13
14// POST /api/surveys — create new survey
15router.post('/', async (req, res) => {
16  const creatorId = req.user?.id;
17  if (!creatorId) return res.status(401).json({ error: 'Login required to create surveys' });
18
19  const { title, description, allowAnonymous = true } = req.body;
20
21  // Generate unique share code (retry on collision)
22  let shareCode;
23  let attempts = 0;
24  while (attempts < 5) {
25    shareCode = generateShareCode();
26    const existing = await db.select().from(surveys)
27      .where(eq(surveys.shareCode, shareCode));
28    if (existing.length === 0) break;
29    attempts++;
30  }
31
32  const [survey] = await db.insert(surveys).values({
33    creatorId,
34    title,
35    description: description || null,
36    shareCode,
37    allowAnonymous,
38    status: 'draft',
39  }).returning();
40
41  res.status(201).json({
42    ...survey,
43    shareUrl: `${process.env.REPLIT_DEPLOYMENT_URL || ''}/s/${shareCode}`,
44  });
45});
46
47// GET /api/surveys — list creator's surveys with response counts
48router.get('/', async (req, res) => {
49  const creatorId = req.user?.id;
50  if (!creatorId) return res.status(401).json({ error: 'Login required' });
51
52  const result = await db.execute(sql`
53    SELECT s.*, COUNT(r.id) AS response_count
54    FROM surveys s
55    LEFT JOIN responses r ON r.survey_id = s.id
56    WHERE s.creator_id = ${creatorId}
57    GROUP BY s.id
58    ORDER BY s.created_at DESC
59  `);
60
61  res.json(result.rows);
62});
63
64module.exports = router;

1const { surveys, questions, responses, answers } = require('../../shared/schema');
2const { eq, and } = require('drizzle-orm');
3
4// GET /api/s/:shareCode — get survey with questions for respondent
5router.get('/s/:shareCode', async (req, res) => {
6  const [survey] = await db.select().from(surveys)
7    .where(and(eq(surveys.shareCode, req.params.shareCode), eq(surveys.status, 'active')));
8
9  if (!survey) return res.status(404).json({ error: 'Survey not found or not active' });
10
11  const questionList = await db.select().from(questions)
12    .where(eq(questions.surveyId, survey.id))
13    .orderBy(questions.position);
14
15  res.json({ ...survey, questions: questionList });
16});
17
18// POST /api/s/:shareCode/submit — submit response (no auth required)
19router.post('/s/:shareCode/submit', async (req, res) => {
20  const [survey] = await db.select().from(surveys)
21    .where(and(eq(surveys.shareCode, req.params.shareCode), eq(surveys.status, 'active')));
22
23  if (!survey) return res.status(404).json({ error: 'Survey not found' });
24
25  const { answersMap, respondentId } = req.body;
26  // answersMap: { questionId: 'answer value' or ['option1', 'option2'] for checkboxes }
27
28  // Validate required questions
29  const questionList = await db.select().from(questions)
30    .where(eq(questions.surveyId, survey.id));
31
32  const missingRequired = questionList.filter(q =>
33    q.isRequired && !answersMap[q.id] &&
34    (Array.isArray(answersMap[q.id]) ? answersMap[q.id].length === 0 : !answersMap[q.id])
35  );
36
37  if (missingRequired.length > 0) {
38    return res.status(400).json({
39      error: 'Required questions not answered',
40      missingQuestions: missingRequired.map(q => q.id),
41    });
42  }
43
44  // Create response record
45  const [response] = await db.insert(responses).values({
46    surveyId: survey.id,
47    respondentId: survey.allowAnonymous ? null : (respondentId || req.user?.id || null),
48  }).returning();
49
50  // Bulk insert answers
51  const answerRows = questionList
52    .filter(q => answersMap[q.id] !== undefined)
53    .map(q => ({
54      responseId: response.id,
55      questionId: q.id,
56      value: Array.isArray(answersMap[q.id])
57        ? JSON.stringify(answersMap[q.id])
58        : String(answersMap[q.id]),
59    }));
60
61  if (answerRows.length > 0) {
62    await db.insert(answers).values(answerRows);
63  }
64
65  res.status(201).json({ responseId: response.id, message: 'Response submitted successfully' });
66});

1// GET /api/surveys/:id/results — aggregated results per question
2router.get('/:id/results', async (req, res) => {
3  const creatorId = req.user?.id;
4  const surveyId = parseInt(req.params.id);
5
6  // Verify ownership
7  const [survey] = await db.select().from(surveys)
8    .where(and(eq(surveys.id, surveyId), eq(surveys.creatorId, creatorId)));
9  if (!survey) return res.status(403).json({ error: 'Not authorized' });
10
11  const questionList = await db.select().from(questions)
12    .where(eq(questions.surveyId, surveyId))
13    .orderBy(questions.position);
14
15  const totalResponses = await db.execute(sql`
16    SELECT COUNT(*) as count FROM responses WHERE survey_id = ${surveyId}
17  `);
18
19  const results = await Promise.all(questionList.map(async (q) => {
20    const allAnswers = await db.select().from(answers)
21      .where(eq(answers.questionId, q.id));
22
23    let aggregated = {};
24
25    if (q.type === 'radio' || q.type === 'dropdown') {
26      const counts = {};
27      allAnswers.forEach(a => { counts[a.value] = (counts[a.value] || 0) + 1; });
28      aggregated = { type: 'counts', data: counts };
29    } else if (q.type === 'checkbox') {
30      const counts = {};
31      allAnswers.forEach(a => {
32        const selected = JSON.parse(a.value || '[]');
33        selected.forEach(opt => { counts[opt] = (counts[opt] || 0) + 1; });
34      });
35      aggregated = { type: 'counts', data: counts };
36    } else if (q.type === 'rating' || q.type === 'number') {
37      const values = allAnswers.map(a => parseFloat(a.value)).filter(v => !isNaN(v));
38      const avg = values.length > 0 ? (values.reduce((s, v) => s + v, 0) / values.length).toFixed(2) : null;
39      aggregated = { type: 'average', average: avg, count: values.length };
40    } else {
41      // text / textarea — return recent samples
42      aggregated = {
43        type: 'text',
44        samples: allAnswers.slice(-10).map(a => a.value),
45      };
46    }
47
48    return { question: q, ...aggregated, totalAnswers: allAnswers.length };
49  }));
50
51  res.json({
52    survey,
53    totalResponses: parseInt(totalResponses.rows[0].count),
54    results,
55  });
56});

1// server/index.js — final server setup
2const express = require('express');
3const path = require('path');
4const { requireAuth } = require('@replit/repl-auth');
5
6const surveysRouter = require('./routes/surveys');
7const publicRouter = require('./routes/public');
8const resultsRouter = require('./routes/results');
9
10const app = express();
11app.use(express.json());
12app.use(requireAuth); // Replit Auth — unauthenticated users have req.user = null
13
14// Public routes (no auth required — share code acts as access token)
15app.use('/api', publicRouter); // GET/POST /api/s/:shareCode
16
17// Authenticated creator routes
18app.use('/api/surveys', surveysRouter);
19app.use('/api/surveys', resultsRouter);
20
21// Serve React frontend
22app.use(express.static(path.join(__dirname, '../client/dist')));
23app.get('*', (req, res) => {
24  res.sendFile(path.join(__dirname, '../client/dist/index.html'));
25});
26
27// IMPORTANT: bind to 0.0.0.0 for Replit (not localhost)
28app.listen(5000, '0.0.0.0', () => console.log('Surveys app running on port 5000'));