@xenterprises/fastify-xpdf 1.0.0

package/src/services/forms.js

@@ -0,0 +1,163 @@
+// src/services/forms.js
+import { PDFDocument } from "pdf-lib";
+import { generatePdfFilename, isValidPdfBuffer } from "../utils/helpers.js";
+
+/**
+ * Save PDF to xStorage if configured
+ */
+async function saveToStorage(fastify, buffer, filename, folder) {
+  if (!fastify.xStorage) {
+    return null;
+  }
+
+  try {
+    const result = await fastify.xStorage.upload(buffer, filename, {
+      folder,
+      contentType: "application/pdf",
+    });
+    return {
+      storageKey: result.key,
+      url: result.url,
+    };
+  } catch (error) {
+    fastify.log.error("Failed to save PDF to storage:", error);
+    return null;
+  }
+}
+
+export function getFormsMethods(config) {
+  const { fastify, defaultFolder } = config;
+
+  return {
+    /**
+     * Fill PDF form fields
+     * @param {Buffer} pdfBuffer - Source PDF buffer
+     * @param {object} fieldValues - Key-value pairs of field names and values
+     * @param {object} options - Fill options
+     * @returns {Promise<{buffer: Buffer, filename: string, size: number, storageKey?: string, url?: string}>}
+     */
+    fillForm: async (pdfBuffer, fieldValues = {}, options = {}) => {
+      try {
+        if (!isValidPdfBuffer(pdfBuffer)) {
+          throw new Error("Invalid PDF buffer");
+        }
+
+        const {
+          flatten = true,
+          filename = generatePdfFilename("filled-form"),
+          saveToStorage: save = false,
+          folder = defaultFolder,
+        } = options;
+
+        // Load PDF
+        const pdfDoc = await PDFDocument.load(pdfBuffer);
+        const form = pdfDoc.getForm();
+
+        // Fill form fields
+        for (const [fieldName, value] of Object.entries(fieldValues)) {
+          try {
+            const field = form.getFieldMaybe(fieldName);
+            if (!field) {
+              fastify.log.warn(`Form field not found: ${fieldName}`);
+              continue;
+            }
+
+            // Handle different field types
+            if (field.isText?.()) {
+              field.setText(String(value || ""));
+            } else if (field.isCheckBox?.()) {
+              if (value) {
+                field.check();
+              } else {
+                field.uncheck();
+              }
+            } else if (field.isRadioGroup?.()) {
+              field.select(String(value));
+            } else if (field.isDropdown?.()) {
+              field.select(String(value));
+            } else if (field.isOption?.()) {
+              field.select(String(value));
+            }
+          } catch (error) {
+            fastify.log.warn(`Error filling field ${fieldName}:`, error.message);
+          }
+        }
+
+        // Flatten form if requested (make non-editable)
+        if (flatten) {
+          form.flatten();
+        }
+
+        // Save PDF
+        const pdfBytes = await pdfDoc.save();
+        const filledBuffer = Buffer.from(pdfBytes);
+
+        // Save to storage if requested
+        let storageResult = null;
+        if (save && fastify.xStorage) {
+          storageResult = await saveToStorage(fastify, filledBuffer, filename, folder);
+        }
+
+        fastify.log.info(`PDF form filled: ${filename}`);
+
+        return {
+          buffer: filledBuffer,
+          filename,
+          size: filledBuffer.length,
+          ...(storageResult && {
+            storageKey: storageResult.storageKey,
+            url: storageResult.url,
+          }),
+        };
+      } catch (error) {
+        fastify.log.error("Form fill failed:", error);
+        throw new Error(`Failed to fill PDF form: ${error.message}`);
+      }
+    },
+
+    /**
+     * List all form fields in a PDF
+     * @param {Buffer} pdfBuffer - Source PDF buffer
+     * @returns {Promise<Array<{name: string, type: string, value: any}>>}
+     */
+    listFormFields: async (pdfBuffer) => {
+      try {
+        if (!isValidPdfBuffer(pdfBuffer)) {
+          throw new Error("Invalid PDF buffer");
+        }
+
+        // Load PDF
+        const pdfDoc = await PDFDocument.load(pdfBuffer);
+        const form = pdfDoc.getForm();
+
+        // Get all fields
+        const fields = form.getFields();
+        const fieldList = fields.map((field) => {
+          const fieldName = field.getName();
+          const value = field.getValue?.() || null;
+
+          // Determine field type
+          let type = "unknown";
+          if (field.isText?.()) type = "text";
+          else if (field.isCheckBox?.()) type = "checkbox";
+          else if (field.isRadioGroup?.()) type = "radio";
+          else if (field.isDropdown?.()) type = "dropdown";
+          else if (field.isOption?.()) type = "option";
+
+          return {
+            name: fieldName,
+            type,
+            value,
+          };
+        });
+
+        fastify.log.info(`Listed ${fieldList.length} form fields`);
+
+        return fieldList;
+      } catch (error) {
+        fastify.log.error("List form fields failed:", error);
+        throw new Error(`Failed to list form fields: ${error.message}`);
+      }
+    },
+  };
+}

package/src/services/generator.js

@@ -0,0 +1,147 @@
+// src/services/generator.js
+import { marked } from "marked";
+import {
+  generatePdfFilename,
+  formatPdfOptions,
+  wrapHtmlTemplate,
+  parseMargin,
+  getPageFormat,
+} from "../utils/helpers.js";
+
+/**
+ * Save PDF to xStorage if configured
+ */
+async function saveToStorage(fastify, buffer, filename, folder) {
+  if (!fastify.xStorage) {
+    return null;
+  }
+
+  try {
+    const result = await fastify.xStorage.upload(buffer, filename, {
+      folder,
+      contentType: "application/pdf",
+    });
+    return {
+      storageKey: result.key,
+      url: result.url,
+    };
+  } catch (error) {
+    fastify.log.error("Failed to save PDF to storage:", error);
+    return null;
+  }
+}
+
+export function getGeneratorMethods(config) {
+  const { getBrowser, fastify, format, printBackground, margin, defaultFolder } =
+    config;
+
+  /**
+   * Generate PDF from HTML
+   * @param {string} html - HTML content
+   * @param {object} options - Generation options
+   * @returns {Promise<{buffer: Buffer, filename: string, size: number, storageKey?: string, url?: string}>}
+   */
+  const generateFromHtml = async (html, options = {}) => {
+    try {
+      if (!html || typeof html !== "string") {
+        throw new Error("HTML content must be a non-empty string");
+      }
+
+      const {
+        filename = generatePdfFilename("document"),
+        format: pageFormat = format,
+        landscape = false,
+        margin: pageMargin = margin,
+        printBackground: background = printBackground,
+        saveToStorage: save = false,
+        folder = defaultFolder,
+      } = options;
+
+      // Get browser instance
+      const browser = await getBrowser();
+      const page = await browser.newPage();
+
+      try {
+        // Set content
+        await page.setContent(html, {
+          waitUntil: "networkidle2",
+          timeout: 30000,
+        });
+
+        // Generate PDF
+        const pdfData = await page.pdf({
+          format: pageFormat,
+          landscape,
+          margin: parseMargin(pageMargin),
+          printBackground: background,
+          timeout: 30000,
+        });
+
+        // Convert to Buffer if needed
+        const pdfBuffer = Buffer.isBuffer(pdfData) ? pdfData : Buffer.from(pdfData);
+
+        // Save to storage if requested
+        let storageResult = null;
+        if (save && fastify.xStorage) {
+          storageResult = await saveToStorage(fastify, pdfBuffer, filename, folder);
+        }
+
+        fastify.log.info(`PDF generated: ${filename}`);
+
+        return {
+          buffer: pdfBuffer,
+          filename,
+          size: pdfBuffer.length,
+          ...(storageResult && {
+            storageKey: storageResult.storageKey,
+            url: storageResult.url,
+          }),
+        };
+      } finally {
+        // Clean up page
+        await page.close();
+      }
+    } catch (error) {
+      fastify.log.error("HTML to PDF generation failed:", error);
+      throw new Error(`Failed to generate PDF from HTML: ${error.message}`);
+    }
+  };
+
+  /**
+   * Generate PDF from Markdown
+   * @param {string} markdown - Markdown content
+   * @param {object} options - Generation options (same as generateFromHtml)
+   * @returns {Promise<{buffer: Buffer, filename: string, size: number, storageKey?: string, url?: string}>}
+   */
+  const generateFromMarkdown = async (markdown, options = {}) => {
+    try {
+      if (!markdown || typeof markdown !== "string") {
+        throw new Error("Markdown content must be a non-empty string");
+      }
+
+      // Convert markdown to HTML
+      const htmlContent = marked(markdown);
+
+      // Wrap in template
+      const fullHtml = wrapHtmlTemplate(htmlContent);
+
+      // Generate PDF from HTML
+      const result = await generateFromHtml(fullHtml, {
+        ...options,
+        filename: options.filename || generatePdfFilename("markdown"),
+      });
+
+      fastify.log.info(`PDF generated from Markdown: ${result.filename}`);
+
+      return result;
+    } catch (error) {
+      fastify.log.error("Markdown to PDF generation failed:", error);
+      throw new Error(`Failed to generate PDF from Markdown: ${error.message}`);
+    }
+  };
+
+  return {
+    generateFromHtml,
+    generateFromMarkdown,
+  };
+}

package/src/services/merger.js

@@ -0,0 +1,115 @@
+// src/services/merger.js
+import { PDFDocument } from "pdf-lib";
+import { generatePdfFilename, isValidPdfBuffer } from "../utils/helpers.js";
+
+/**
+ * Save PDF to xStorage if configured
+ */
+async function saveToStorage(fastify, buffer, filename, folder) {
+  if (!fastify.xStorage) {
+    return null;
+  }
+
+  try {
+    const result = await fastify.xStorage.upload(buffer, filename, {
+      folder,
+      contentType: "application/pdf",
+    });
+    return {
+      storageKey: result.key,
+      url: result.url,
+    };
+  } catch (error) {
+    fastify.log.error("Failed to save PDF to storage:", error);
+    return null;
+  }
+}
+
+export function getMergerMethods(config) {
+  const { fastify, defaultFolder } = config;
+
+  return {
+    /**
+     * Merge multiple PDF files into one
+     * @param {Array<Buffer>} pdfBuffers - Array of PDF buffers to merge
+     * @param {object} options - Merge options
+     * @returns {Promise<{buffer: Buffer, filename: string, size: number, pageCount: number, storageKey?: string, url?: string}>}
+     */
+    mergePDFs: async (pdfBuffers, options = {}) => {
+      try {
+        if (!Array.isArray(pdfBuffers) || pdfBuffers.length === 0) {
+          throw new Error("pdfBuffers must be a non-empty array of PDF buffers");
+        }
+
+        // Validate all buffers
+        for (const buffer of pdfBuffers) {
+          if (!isValidPdfBuffer(buffer)) {
+            throw new Error("One or more invalid PDF buffers provided");
+          }
+        }
+
+        const {
+          filename = generatePdfFilename("merged"),
+          saveToStorage: save = false,
+          folder = defaultFolder,
+        } = options;
+
+        // Create new PDF document
+        const mergedDoc = await PDFDocument.create();
+
+        let totalPages = 0;
+
+        // Process each PDF
+        for (const buffer of pdfBuffers) {
+          try {
+            // Load source PDF
+            const srcDoc = await PDFDocument.load(buffer);
+
+            // Get page indices
+            const pageIndices = srcDoc.getPageIndices();
+            totalPages += pageIndices.length;
+
+            // Copy pages from source to merged
+            const copiedPages = await mergedDoc.copyPages(srcDoc, pageIndices);
+
+            // Add copied pages to merged document
+            for (const copiedPage of copiedPages) {
+              mergedDoc.addPage(copiedPage);
+            }
+          } catch (error) {
+            fastify.log.warn("Error processing PDF buffer during merge:", error.message);
+            throw new Error(`Failed to process PDF during merge: ${error.message}`);
+          }
+        }
+
+        // Save merged PDF
+        const pdfBytes = await mergedDoc.save();
+        const mergedBuffer = Buffer.from(pdfBytes);
+
+        // Save to storage if requested
+        let storageResult = null;
+        if (save && fastify.xStorage) {
+          storageResult = await saveToStorage(fastify, mergedBuffer, filename, folder);
+        }
+
+        fastify.log.info(
+          `PDFs merged: ${filename} (${totalPages} pages from ${pdfBuffers.length} files)`
+        );
+
+        return {
+          buffer: mergedBuffer,
+          filename,
+          size: mergedBuffer.length,
+          pageCount: totalPages,
+          ...(storageResult && {
+            storageKey: storageResult.storageKey,
+            url: storageResult.url,
+          }),
+        };
+      } catch (error) {
+        fastify.log.error("PDF merge failed:", error);
+        throw new Error(`Failed to merge PDFs: ${error.message}`);
+      }
+    },
+  };
+}

package/src/utils/helpers.js

@@ -0,0 +1,220 @@
+// src/utils/helpers.js
+
+/**
+ * Generate unique PDF filename with timestamp
+ * @param {string} baseName - Base filename (without extension)
+ * @returns {string} - Unique filename with timestamp
+ */
+export function generatePdfFilename(baseName = "document") {
+  const timestamp = Date.now();
+  return `${baseName}-${timestamp}.pdf`;
+}
+
+/**
+ * Validate PDF buffer
+ * @param {Buffer} buffer - PDF buffer to validate
+ * @returns {boolean} - True if buffer looks like a valid PDF
+ */
+export function isValidPdfBuffer(buffer) {
+  if (!Buffer.isBuffer(buffer)) {
+    return false;
+  }
+
+  // Check for PDF header: %PDF
+  const pdfHeader = buffer.toString("utf8", 0, 4);
+  return pdfHeader === "%PDF";
+}
+
+/**
+ * Get PDF metadata (page count and file size)
+ * @param {Buffer} buffer - PDF buffer
+ * @returns {object} - Metadata object {size: number}
+ */
+export function getPdfMetadata(buffer) {
+  if (!isValidPdfBuffer(buffer)) {
+    throw new Error("Invalid PDF buffer");
+  }
+
+  return {
+    size: buffer.length,
+  };
+}
+
+/**
+ * Format PDF generation options with defaults
+ * @param {object} options - User-provided options
+ * @param {object} defaults - Default options
+ * @returns {object} - Merged options
+ */
+export function formatPdfOptions(options = {}, defaults = {}) {
+  return {
+    ...defaults,
+    ...options,
+    // Ensure margin is properly merged
+    margin: {
+      ...defaults.margin,
+      ...options.margin,
+    },
+  };
+}
+
+/**
+ * Sanitize filename for safe storage
+ * @param {string} filename - Original filename
+ * @returns {string} - Sanitized filename
+ */
+export function sanitizeFilename(filename) {
+  return filename
+    .replace(/[^a-zA-Z0-9._-]/g, "_") // Replace unsafe chars
+    .replace(/_{2,}/g, "_") // Replace multiple underscores
+    .toLowerCase();
+}
+
+/**
+ * Convert HTML template to PDF-ready HTML
+ * @param {string} content - HTML or content
+ * @returns {string} - Full HTML document
+ */
+export function wrapHtmlTemplate(content) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif;
+      line-height: 1.6;
+      color: #333;
+      background: white;
+      padding: 0;
+      margin: 0;
+    }
+    h1, h2, h3, h4, h5, h6 {
+      margin-top: 1em;
+      margin-bottom: 0.5em;
+      font-weight: 600;
+    }
+    h1 { font-size: 2em; }
+    h2 { font-size: 1.5em; }
+    h3 { font-size: 1.25em; }
+    p {
+      margin-bottom: 1em;
+    }
+    ul, ol {
+      margin-left: 2em;
+      margin-bottom: 1em;
+    }
+    li {
+      margin-bottom: 0.5em;
+    }
+    code {
+      background: #f4f4f4;
+      padding: 2px 6px;
+      border-radius: 3px;
+      font-family: 'Courier New', monospace;
+      font-size: 0.9em;
+    }
+    pre {
+      background: #f4f4f4;
+      padding: 1em;
+      border-radius: 5px;
+      overflow-x: auto;
+      margin-bottom: 1em;
+      line-height: 1.4;
+    }
+    pre code {
+      background: none;
+      padding: 0;
+      border-radius: 0;
+    }
+    a {
+      color: #0066cc;
+      text-decoration: none;
+    }
+    a:hover {
+      text-decoration: underline;
+    }
+    blockquote {
+      border-left: 4px solid #ddd;
+      padding-left: 1em;
+      margin-left: 0;
+      margin-bottom: 1em;
+      color: #666;
+    }
+    table {
+      border-collapse: collapse;
+      width: 100%;
+      margin-bottom: 1em;
+    }
+    th, td {
+      border: 1px solid #ddd;
+      padding: 8px;
+      text-align: left;
+    }
+    th {
+      background: #f4f4f4;
+      font-weight: 600;
+    }
+    img {
+      max-width: 100%;
+      height: auto;
+    }
+  </style>
+</head>
+<body>
+  ${content}
+</body>
+</html>`;
+}
+
+/**
+ * Parse margin string to Puppeteer format
+ * @param {object|string} margin - Margin value
+ * @returns {object} - Puppeteer margin format
+ */
+export function parseMargin(margin) {
+  if (typeof margin === "object") {
+    return margin;
+  }
+
+  // If string, apply to all sides
+  if (typeof margin === "string") {
+    return {
+      top: margin,
+      right: margin,
+      bottom: margin,
+      left: margin,
+    };
+  }
+
+  return {};
+}
+
+/**
+ * Get page format dimensions
+ * @param {string} format - Format name (A4, Letter, etc.)
+ * @returns {object} - Width and height
+ */
+export function getPageFormat(format = "A4") {
+  const formats = {
+    Letter: { width: 8.5, height: 11 },
+    Legal: { width: 8.5, height: 14 },
+    Tabloid: { width: 11, height: 17 },
+    Ledger: { width: 17, height: 11 },
+    A0: { width: 33.1, height: 46.8 },
+    A1: { width: 23.4, height: 33.1 },
+    A2: { width: 16.54, height: 23.4 },
+    A3: { width: 11.7, height: 16.54 },
+    A4: { width: 8.27, height: 11.7 },
+    A5: { width: 5.83, height: 8.27 },
+    A6: { width: 4.13, height: 5.83 },
+  };
+
+  return formats[format] || formats.A4;
+}