Build a PDF Template Engine

// src/pdf/engine.ts — PDF generation with templates, data binding, and batch processing
import PDFDocument from "pdfkit";
import { pool } from "../db";
import { Redis } from "ioredis";
import { Readable } from "node:stream";

const redis = new Redis(process.env.REDIS_URL!);

interface PDFTemplate {
  id: string;
  name: string;
  type: "invoice" | "contract" | "report" | "receipt" | "certificate";
  layout: {
    pageSize: "A4" | "Letter" | "Legal";
    margins: { top: number; bottom: number; left: number; right: number };
    orientation: "portrait" | "landscape";
  };
  header: TemplateSection | null;
  footer: TemplateSection | null;
  sections: TemplateSection[];
  styles: {
    fontFamily: string;
    primaryColor: string;
    accentColor: string;
    fontSize: number;
    lineHeight: number;
  };
  variables: Array<{ name: string; type: string; required: boolean; default?: any }>;
}

interface TemplateSection {
  type: "text" | "table" | "image" | "spacer" | "divider" | "signature" | "pagebreak";
  content?: string;            // supports {{variable}} placeholders
  style?: {
    fontSize?: number;
    bold?: boolean;
    italic?: boolean;
    alignment?: "left" | "center" | "right";
    color?: string;
    marginTop?: number;
    marginBottom?: number;
  };
  table?: {
    headers: string[];
    widths: number[];          // column widths as percentages
    dataKey: string;           // variable name containing row data
    rowTemplate: string[];     // {{item.field}} for each column
    totalRow?: string[];       // optional totals row
    striped?: boolean;
  };
  image?: {
    urlKey: string;            // variable name containing image URL
    width?: number;
    height?: number;
    alignment?: "left" | "center" | "right";
  };
  condition?: string;          // {{#if variable}} — only render if truthy
}

// Generate PDF from template + data
export async function generatePDF(
  templateId: string,
  data: Record<string, any>
): Promise<Buffer> {
  const { rows: [tmplRow] } = await pool.query(
    "SELECT * FROM pdf_templates WHERE id = $1", [templateId]
  );
  if (!tmplRow) throw new Error("Template not found");

  const template: PDFTemplate = {
    ...tmplRow,
    layout: JSON.parse(tmplRow.layout),
    header: tmplRow.header ? JSON.parse(tmplRow.header) : null,
    footer: tmplRow.footer ? JSON.parse(tmplRow.footer) : null,
    sections: JSON.parse(tmplRow.sections),
    styles: JSON.parse(tmplRow.styles),
    variables: JSON.parse(tmplRow.variables),
  };

  // Validate required variables
  for (const v of template.variables) {
    if (v.required && data[v.name] === undefined) {
      throw new Error(`Missing required variable: ${v.name}`);
    }
    if (data[v.name] === undefined && v.default !== undefined) {
      data[v.name] = v.default;
    }
  }

  // Add built-in variables
  data._date = new Date().toLocaleDateString("en-US", { year: "numeric", month: "long", day: "numeric" });
  data._year = new Date().getFullYear();
  data._page = 1;

  return new Promise((resolve, reject) => {
    const doc = new PDFDocument({
      size: template.layout.pageSize,
      layout: template.layout.orientation,
      margins: template.layout.margins,
      bufferPages: true, // needed for headers/footers
    });

    const chunks: Buffer[] = [];
    doc.on("data", (chunk: Buffer) => chunks.push(chunk));
    doc.on("end", () => resolve(Buffer.concat(chunks)));
    doc.on("error", reject);

    // Set default font
    doc.font("Helvetica").fontSize(template.styles.fontSize);

    // Render sections
    for (const section of template.sections) {
      if (section.condition && !evaluateCondition(section.condition, data)) continue;
      renderSection(doc, section, data, template);
    }

    // Add headers/footers to all pages
    const pageCount = doc.bufferedPageRange().count;
    for (let i = 0; i < pageCount; i++) {
      doc.switchToPage(i);

      if (template.header) {
        const savedY = doc.y;
        doc.y = template.layout.margins.top / 2;
        renderHeaderFooter(doc, template.header, { ...data, _page: i + 1, _pages: pageCount }, template);
        doc.y = savedY;
      }

      if (template.footer) {
        doc.y = doc.page.height - template.layout.margins.bottom + 10;
        renderHeaderFooter(doc, template.footer, { ...data, _page: i + 1, _pages: pageCount }, template);
      }
    }

    doc.end();
  });
}

function renderSection(doc: typeof PDFDocument.prototype, section: TemplateSection, data: Record<string, any>, template: PDFTemplate): void {
  const style = section.style || {};

  if (style.marginTop) doc.moveDown(style.marginTop / template.styles.fontSize);

  switch (section.type) {
    case "text": {
      const text = interpolate(section.content || "", data);
      doc.fontSize(style.fontSize || template.styles.fontSize);
      if (style.bold) doc.font("Helvetica-Bold");
      else if (style.italic) doc.font("Helvetica-Oblique");
      else doc.font("Helvetica");
      if (style.color) doc.fillColor(style.color);
      else doc.fillColor(template.styles.primaryColor || "#000000");

      doc.text(text, { align: style.alignment || "left" });
      break;
    }

    case "table": {
      if (!section.table) break;
      const rows = data[section.table.dataKey] || [];
      renderTable(doc, section.table, rows, data, template);
      break;
    }

    case "spacer":
      doc.moveDown(2);
      break;

    case "divider":
      const x = doc.x;
      const width = doc.page.width - template.layout.margins.left - template.layout.margins.right;
      doc.moveTo(x, doc.y).lineTo(x + width, doc.y)
        .strokeColor("#CCCCCC").lineWidth(0.5).stroke();
      doc.moveDown(0.5);
      break;

    case "signature": {
      doc.moveDown(3);
      const sigX = doc.x;
      doc.moveTo(sigX, doc.y).lineTo(sigX + 200, doc.y)
        .strokeColor("#000000").lineWidth(1).stroke();
      doc.moveDown(0.3);
      doc.fontSize(10).text(interpolate(section.content || "Signature", data));
      doc.text(data._date);
      break;
    }

    case "pagebreak":
      doc.addPage();
      break;
  }

  if (style.marginBottom) doc.moveDown(style.marginBottom / template.styles.fontSize);
}

function renderTable(doc: any, table: NonNullable<TemplateSection["table"]>, rows: any[], data: Record<string, any>, template: PDFTemplate): void {
  const pageWidth = doc.page.width - template.layout.margins.left - template.layout.margins.right;
  const colWidths = table.widths.map((w) => (pageWidth * w) / 100);
  const startX = template.layout.margins.left;

  // Headers
  doc.font("Helvetica-Bold").fontSize(10);
  let x = startX;
  for (let i = 0; i < table.headers.length; i++) {
    doc.text(table.headers[i], x, doc.y, { width: colWidths[i], continued: i < table.headers.length - 1 });
    x += colWidths[i];
  }
  doc.moveDown(0.5);

  // Divider
  doc.moveTo(startX, doc.y).lineTo(startX + pageWidth, doc.y).strokeColor("#000").lineWidth(0.5).stroke();
  doc.moveDown(0.3);

  // Rows
  doc.font("Helvetica").fontSize(10);
  for (let r = 0; r < rows.length; r++) {
    const row = rows[r];

    // Striped background
    if (table.striped && r % 2 === 1) {
      doc.rect(startX, doc.y - 2, pageWidth, 16).fill("#F8F9FA");
      doc.fillColor("#000000");
    }

    x = startX;
    for (let i = 0; i < table.rowTemplate.length; i++) {
      const cellText = interpolate(table.rowTemplate[i], { ...data, item: row });
      doc.text(cellText, x, doc.y, { width: colWidths[i] });
      x += colWidths[i];
    }

    // Check if we need a new page
    if (doc.y > doc.page.height - template.layout.margins.bottom - 50) {
      doc.addPage();
    }
  }

  // Totals row
  if (table.totalRow) {
    doc.moveDown(0.3);
    doc.moveTo(startX, doc.y).lineTo(startX + pageWidth, doc.y).strokeColor("#000").stroke();
    doc.moveDown(0.3);
    doc.font("Helvetica-Bold");

    x = startX;
    for (let i = 0; i < table.totalRow.length; i++) {
      const cellText = interpolate(table.totalRow[i], data);
      doc.text(cellText, x, doc.y, { width: colWidths[i] });
      x += colWidths[i];
    }
  }

  doc.moveDown(1);
}

function renderHeaderFooter(doc: any, section: TemplateSection, data: Record<string, any>, template: PDFTemplate): void {
  const text = interpolate(section.content || "", data);
  doc.fontSize(8).fillColor("#999999").font("Helvetica");
  doc.text(text, template.layout.margins.left, doc.y, {
    align: section.style?.alignment || "center",
    width: doc.page.width - template.layout.margins.left - template.layout.margins.right,
  });
}

// Replace {{variable}} placeholders
function interpolate(template: string, data: Record<string, any>): string {
  return template.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
    const parts = key.trim().split(".");
    let value: any = data;
    for (const part of parts) {
      value = value?.[part];
    }
    if (value === undefined || value === null) return "";
    if (typeof value === "number" && key.includes("amount")) {
      return (value / 100).toFixed(2);
    }
    return String(value);
  });
}

function evaluateCondition(condition: string, data: Record<string, any>): boolean {
  const match = condition.match(/\{\{#if\s+(\w+)\}\}/);
  if (match) return !!data[match[1]];
  return true;
}

// Batch generate PDFs
export async function batchGenerate(
  templateId: string,
  dataList: Array<Record<string, any>>
): Promise<Array<{ data: Record<string, any>; buffer: Buffer }>> {
  const results = [];
  for (const data of dataList) {
    const buffer = await generatePDF(templateId, data);
    results.push({ data, buffer });
  }
  return results;
}