CreatePDFService.js

import FileService from './FileService'
import PDFService from './PDFService'

const SERVICE_PDF_URL = process.env.SERVICE_PDF_URL

export const getTemplateData = async (id, headers) => {
  try {
    // Preparte data for you template
    return { }
  } catch (err) {
    console.error(err)
    throw Error('A problem happened when trying to retrieve the quote.')
  }
}


export const generateQuotePDF = async (id, idBuildType, type, headers) => {
  if (!id) throw new Error('ID param is not defined!')

  const buffer = await PDFService.generate(`${SERVICE_PDF_URL}/${id}`, {}, headers)
  return buffer
}

export const generateQuoteFile = async (id, idBuildType, type, headers) => {
  if (!id) {
    throw Error('Problem to generate quote pdf')
  }

  try {
    const buffer = await generateQuotePDF(id, idBuildType, type, headers)
    const fileUrl = await FileService.saveBufferToFile(buffer, { directory: 'quotes', filename: `File.${id}.pdf` })
    return true
  } catch (err) {
    console.error(err)
  }
}

FileService.js

import intoStream from 'into-stream'

export default class FileService {
  
  async saveBufferToFile(buffer, { directory, filename }) {
    const stream = intoStream(buffer)
    const streamLength = buffer.length
    // SAVE your stream in a file or DB or storage
    return // file URL
  }

  async fileExists({ directory, filename }) {
    return true // TODO
  }
}

PDFService.js

import puppeteer from 'puppeteer'

export default class PDFService {
  defaults = {
    displayHeaderFooter: false,
    preferCSSPageSize  : true,
    printBackground    : true,
    format             : 'A4',
    margin             : { top: 0, right: 0, bottom: 0, left: 0 },
  }

  async generate (url, options = {}, headers = {}) {
    try {
      let browser = await puppeteer.launch({
        headless      : true,
        args          : process.env.CHROME_ARGS.split(' '),
        executablePath: process.env.CHROME_BIN || null,
      })

      try {
        const page = await browser.newPage()
        await page.setDefaultNavigationTimeout(120000)
        await page.setExtraHTTPHeaders({ 'Access-Token': headers.authorization })
        await page.goto(url, { waitUntil: 'networkidle0' })
        return await page.pdf({ ...this.defaults, ...options })
      } catch (err) {
        throw err
      } finally {
        await browser.close()
      }
    } catch (err) {
      console.error(err)
      throw err
    }
  }
}

TemplateService.js

import fs from 'fs'
import util from 'util'
import path from 'path'
import handlebars from 'handlebars'

const readFile = util.promisify(fs.readFile)

export default class TemplateService {
  async load (data, template) {
    try {
      const templatePath = path.resolve(__dirname, '..', 'templates', template, 'index.html')
      const content = await readFile(templatePath, 'utf8')
      const parse = handlebars.compile(content)
      return parse(data)
    } catch (err) {
      console.error(err)
      throw new Error(`An error occured when trying to create the document!`)
    }
  }
}