How to Build a Certificate Generator with Replit

1// Step 1: Prompt Replit Agent:
2// Build a Node.js Express certificate generator with Replit Auth and built-in PostgreSQL using Drizzle ORM.
3// Schema in shared/schema.ts:
4// * templates: id serial pk, name text not null, html_content text not null,
5//   background_image_url text, dimensions jsonb default '{"width":1056,"height":816}',
6//   created_by text not null, created_at timestamp default now()
7// * certificates: id serial pk, template_id integer references templates not null,
8//   recipient_name text not null, recipient_email text, title text not null,
9//   issuer_name text not null, issue_date date not null,
10//   verification_code text unique not null, custom_fields jsonb,
11//   pdf_url text, created_by text not null, created_at timestamp default now()
12// * verification_log: id serial pk, certificate_id integer references certificates not null,
13//   verified_at timestamp default now(), ip_address text
14// Routes: GET/POST /api/templates, GET /api/templates/:id/preview,
15// POST /api/certificates, POST /api/certificates/bulk,
16// GET /api/certificates, GET /api/certificates/:id/download,
17// GET /api/verify/:code, POST /api/certificates/:id/email
18// Use puppeteer for PDF generation (headless Chrome)
19
20// Step 2: Edit replit.nix to add Chromium:
21// In the replit.nix file, add pkgs.chromium to the deps array:
22// deps = [
23//   pkgs.nodejs-18_x
24//   pkgs.chromium        // <-- add this line
25//   pkgs.nix
26// ];
27// After saving, Replit installs Chromium automatically.

1import puppeteer from 'puppeteer';
2
3export async function generatePdf(htmlContent) {
4  const browser = await puppeteer.launch({
5    executablePath: process.env.CHROMIUM_PATH || '/usr/bin/chromium',
6    args: [
7      '--no-sandbox',          // required in Replit containers
8      '--disable-setuid-sandbox',
9      '--disable-dev-shm-usage', // prevents crashes in low-memory environments
10      '--disable-gpu',
11      '--no-first-run',
12      '--no-zygote',
13    ],
14    headless: 'new',
15  });
16
17  try {
18    const page = await browser.newPage();
19    await page.setContent(htmlContent, { waitUntil: 'networkidle0' });
20    await page.emulateMediaType('print');
21
22    const pdf = await page.pdf({
23      width: '1056px',
24      height: '816px',
25      printBackground: true, // render background colors and images
26      margin: { top: '0', right: '0', bottom: '0', left: '0' },
27    });
28
29    return pdf; // returns a Buffer
30  } finally {
31    await browser.close();
32  }
33}

1import crypto from 'crypto';
2import { db } from '../db.js';
3import { templates, certificates } from '../../shared/schema.js';
4import { eq } from 'drizzle-orm';
5import { generatePdf } from '../utils/pdf.js';
6
7function generateVerificationCode() {
8  const bytes = crypto.randomBytes(4).toString('hex').toUpperCase();
9  return `CERT-${bytes}`;
10}
11
12function renderTemplate(htmlContent, variables) {
13  let rendered = htmlContent;
14  for (const [key, value] of Object.entries(variables)) {
15    const placeholder = new RegExp(`{{${key}}}`, 'g');
16    rendered = rendered.replace(placeholder, String(value || ''));
17  }
18  return rendered;
19}
20
21export async function generateCertificate(req, res) {
22  const { templateId, recipientName, recipientEmail, title, issuerName, issueDate, customFields } = req.body;
23  const createdBy = req.get('X-Replit-User-Id');
24  if (!createdBy) return res.status(401).json({ error: 'Not authenticated' });
25
26  const [template] = await db.select().from(templates).where(eq(templates.id, parseInt(templateId)));
27  if (!template) return res.status(404).json({ error: 'Template not found' });
28
29  const verificationCode = generateVerificationCode();
30  const variables = {
31    recipient_name: recipientName,
32    title,
33    issuer_name: issuerName,
34    issue_date: new Date(issueDate).toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' }),
35    verification_code: verificationCode,
36    ...(customFields || {}),
37  };
38
39  const renderedHtml = renderTemplate(template.htmlContent, variables);
40  const pdfBuffer = await generatePdf(renderedHtml);
41
42  // Store PDF as base64 in DB (or upload to external storage and store URL)
43  const pdfBase64 = pdfBuffer.toString('base64');
44
45  const [cert] = await db.insert(certificates).values({
46    templateId: parseInt(templateId),
47    recipientName,
48    recipientEmail,
49    title,
50    issuerName,
51    issueDate: new Date(issueDate),
52    verificationCode,
53    customFields: customFields || null,
54    createdBy,
55  }).returning();
56
57  res.status(201).json({ certificate: cert, verificationCode, downloadPath: `/api/certificates/${cert.id}/download` });
58}

1import { db } from '../db.js';
2import { certificates, templates, verificationLog } from '../../shared/schema.js';
3import { eq } from 'drizzle-orm';
4
5// GET /api/verify/:code — public, no auth required
6export async function verifyCertificate(req, res) {
7  const { code } = req.params;
8
9  const [cert] = await db
10    .select({
11      recipientName: certificates.recipientName,
12      title: certificates.title,
13      issuerName: certificates.issuerName,
14      issueDate: certificates.issueDate,
15      verificationCode: certificates.verificationCode,
16      createdAt: certificates.createdAt,
17      templateName: templates.name,
18    })
19    .from(certificates)
20    .leftJoin(templates, eq(certificates.templateId, templates.id))
21    .where(eq(certificates.verificationCode, code.toUpperCase()));
22
23  if (!cert) return res.status(404).json({ error: 'Certificate not found', valid: false });
24
25  // Log the verification attempt
26  db.insert(verificationLog).values({
27    certificateId: cert.id,
28    ipAddress: req.ip,
29  }).catch(console.error);
30
31  res.json({ valid: true, certificate: cert });
32}
33
34// POST /api/certificates/bulk
35export async function generateBulk(req, res) {
36  const { templateId, recipients, title, issuerName, issueDate } = req.body;
37  // recipients = [{ name, email, customFields }, ...]
38  if (!Array.isArray(recipients) || recipients.length === 0) {
39    return res.status(400).json({ error: 'recipients must be a non-empty array' });
40  }
41  if (recipients.length > 100) {
42    return res.status(400).json({ error: 'Maximum 100 recipients per bulk request' });
43  }
44
45  const results = [];
46  for (const recipient of recipients) {
47    // Re-use generateCertificate logic per recipient
48    // (abbreviated for space — call the full function in practice)
49    results.push({ name: recipient.name, status: 'queued' });
50  }
51
52  res.json({ queued: results.length, results });
53}