Nodejs word to pdf

I have method on Node js Return Word document , i want pass parameter called file type to convert this word document
to PDF.

the output from buf var it file like below
PK
! ߤ�l [Content_Types].xml<?xml version="1.0" encoding="UTF-8" standalone="yes"?>...

How can convert this word document to pdf ?

router.get("/hello", function(request, response, next,fileType) {

  var zip = new JSZip(
    "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",
    { base64: true }
  );
  var doc = new Docxtemplater();

  doc.loadZip(zip);
  //set the templateVariables
  doc.setData({});

  try {
    // render the document (replace all occurences of {first_name} by John, {last_name} by Doe, ...)
    doc.render();
    var buf = doc.getZip().generate({ type: "nodebuffer" });


    if(fileType=='docx'){
    response.writeHead(200, {
      "Content-Disposition": "attachment;filename=" + "template.docx",
      "Content-Type":
        "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
    });
    }else if(fileType=='pdf'){

        //here should convert 
    }

    response.end(buf);
  } catch (error) {
    var e = {
      message: error.message,
      name: error.name,
      stack: error.stack,
      properties: error.properties
    };
    console.log(JSON.stringify({ error: e }));
    // The error thrown here contains additional information when logged with JSON.stringify (it contains a property object).
    throw error;
  }
});

Express or Express.js is described as a flexible framework for building web apps and APIs, as well as the de facto standard server framework for Node.js. Leveraging Express and Node.js enables devs to add powerful back-end functionalities to their web and mobile applications, and create feature-rich user experiences. Check out the following video for more info on building a PDF app with Express and Node.js.

In this blog, we show you how to create your very own file server using Node.js, Express, and the Apryse SDK Node.js PDF Library. Our sample project not only serves static files; it will also perform advanced document processing operations like file conversion from DOCX, PPTX, or XLSX to PDF (MS Office software or licenses not required), thumbnail generation, and more.

Check out this ready-to-go project sample on our Github. And if you do not have Node.js installed yet, download and install it from here.

Set Up Your Node.js Project

To get started, create a new folder, open it inside your terminal, and type the following:

$ npm init

The above command will walk you through the creation of a new project. The entry point, the file from which execution starts, is index.js by default.

Next, let’s install some project dependencies. The first one is Express.js, a lightweight web framework for Node.js.

$ npm install express --save

The second one is the Apryse SDK. This will facilitate file conversion, splitting of documents, thumbnail generation, optimization of PDFs, OCR, and many other document processing actions.

$ npm install @pdftron/pdfnet-node --save

The third one is nodemon, which enables hot reloading of the server while we develop and make changes to our code.

$ npm install nodemon --save

Once we are done with dependencies, we will get our package.json in order. Add the following under scripts.

"scripts": {
    "start": "nodemon index.js"
  },
  

The next step is to establish our entry point. Create a new file called index.js on the same level as package.json.

Afterwards, run npm start.

Create a Simple Express.js Server

Now we will create a simple Express server inside of index.js.

const express = require('express');
const port = 9000;

const app = express();

app.listen(port, () =>
  console.log(
    `nodejs-convert-file-server listening at http://localhost:${port}`,
  ),
);

Next, navigate to http://localhost:9000 and you should see your server running. No endpoints are created just yet, so you will be met with Cannot GET/. If you run into any other errors, check the terminal, since it might require a manual restart.

Serve Static Files From Node.js

We will create a new folder directory called files within your project. Let’s add an API to our index.js to return a list of files inside of it in JSON format.

app.get('/files', (req, res) => {
  const inputPath = path.resolve(__dirname, filesPath);
  fs.readdir(inputPath, function (err, files) {
    if (err) {
      return console.log('Unable to scan directory: ' + err);
    }
    res.setHeader('Content-type', mimeType['.json']);
    res.end(JSON.stringify(files));
  });
});

Mime data types are just a way of communicating what type of content the browser should expect. Therefore, I’ve prepared a handy module you can use:

// maps file extension to MIME types
// full list can be found here: https://www.freeformatter.com/mime-types-list.html
module.exports = mimeType = {
    '.ico': 'image/x-icon',
    '.html': 'text/html',
    '.js': 'text/javascript',
    '.json': 'application/json',
    '.css': 'text/css',
    '.png': 'image/png',
    '.jpg': 'image/jpeg',
    '.wav': 'audio/wav',
    '.mp3': 'audio/mpeg',
    '.svg': 'image/svg+xml',
    '.pdf': 'application/pdf',
    '.zip': 'application/zip',
    '.doc': 'application/msword',
    '.eot': 'application/vnd.ms-fontobject',
    '.ttf': 'application/x-font-ttf',
  };

To use this module inside of index.js, make sure you import it:

const mimeType = require('./mimeType');

Now, let’s create another endpoint that returns the requested file:

app.get('/files/:filename', (req, res) => {
  const inputPath = path.resolve(__dirname, filesPath, req.params.filename);
  fs.readFile(inputPath, function (err, data) {
    if (err) {
      res.statusCode = 500;
      res.end(`Error getting the file: ${err}.`);
    } else {
      const ext = path.parse(inputPath).ext;
      res.setHeader('Content-type', mimeType[ext] || 'text/plain');
      res.end(data);
    }
  });
});

Over at http://localhost:9000, if you append a path and a filename, you should get that file back in your response. For example, http://localhost:9000/files/test.pdf will return test.pdf if that file is present in the files folder.

Create a Thumbnail by Converting PDF to Image

Let’s add another API to create a thumbnail of a PDF, a functionality that will pair nicely with the ability to list files in the directory and get a quick preview for each of them.

For this new API, we will use the Apryse library we installed earlier.

app.get('/thumbnail/:filename', (req, res) => {
  const filename = req.params.filename;
  let ext = path.parse(filename).ext;

  const inputPath = path.resolve(__dirname, filesPath, filename);
  const outputPath = path.resolve(__dirname, filesPath, `${filename}.png`);

  if (ext !== '.pdf') {
    throw `Only PDFs can return a thumbnail. Cannot return a thumb for a file with extension: ${ext}.`;
  }

  const main = async () => {
    const doc = await PDFNet.PDFDoc.createFromFilePath(inputPath);
    await doc.initSecurityHandler();
    const pdfdraw = await PDFNet.PDFDraw.create(92);
    const currPage = await doc.getPage(1);
    await pdfdraw.export(currPage, outputPath, 'PNG');
  };

  PDFNetEndpoint(main, outputPath, res);
})

The above code snippet will parse out the requested parameters, ensure the file is a PDF, and generate a PNG thumbnail for the first page, before calling a function we created called PDFNetEndpoint. PDFNetEndpoint definition is below:

const PDFNetEndpoint = (main, pathname, res) => {
    PDFNet.runWithCleanup(main)
    .then(() => {
      PDFNet.shutdown();
      fs.readFile(pathname, (err, data) => {
        if (err) {
          res.statusCode = 500;
          res.end(`Error getting the file: ${err}.`);
        } else {
          const ext = path.parse(pathname).ext;
          res.setHeader('Content-type', mimeType[ext] || 'text/plain');
          res.end(data);
        }
      });
    })
    .catch((error) => {
      res.statusCode = 500;
      res.end(error);
    });
};

This Apryse endpoint ensures that we can execute the thumbnail-generating function without any errors and return an image representation of the first page of a PDF.

To test the endpoint out, enter the following into the browser: http://localhost:9000/thumbnail/test.pdf

Convert to PDF from DOCX, PPTX, or XLSX

Here is an example for how to convert an MS Office document into a PDF without needing MS Office software or licenses.

app.get('/convert/:filename', (req, res) => {
  const filename = req.params.filename;
  let ext = path.parse(filename).ext;

  const inputPath = path.resolve(__dirname, filesPath, filename);
  const outputPath = path.resolve(__dirname, filesPath, `${filename}.pdf`);

  if (ext === '.pdf') {
    res.statusCode = 500;
    res.end(`File is already PDF.`);
  }

  const main = async () => {
    const pdfdoc = await PDFNet.PDFDoc.create();
    await pdfdoc.initSecurityHandler();
    await PDFNet.Convert.toPdf(pdfdoc, inputPath);
    pdfdoc.save(
      `${pathname}${filename}.pdf`,
      PDFNet.SDFDoc.SaveOptions.e_linearized,
    );
    ext = '.pdf';
  };

  PDFNetEndpoint(main, outputPath, res);
});

To test it out, enter the following in the browser: http://localhost:9000/convert/test.docx.

Generate PDFs From a Template

Typically, generating PDFs happens from a source format, like a Word file or HTML markup, which you then convert to PDF using a solution like the Apryse SDK. For example, we have a letter template below, called template_letter.pdf in which we will replace names, dates, and addresses programmatically.

app.get('/replaceContent/:name', (req, res) => {
  const name = req.params.name.replace('_', ' ');
  const filename = 'template_letter.pdf'

  const inputPath = path.resolve(__dirname, filesPath, filename);
  const outputPath = path.resolve(__dirname, filesPath, `${filename}_replaced.pdf`);

  const main = async () => {
    const pdfdoc = await PDFNet.PDFDoc.createFromFilePath(inputPath);
    await pdfdoc.initSecurityHandler();
    const replacer = await PDFNet.ContentReplacer.create();
    const page = await pdfdoc.getPage(1);

    await replacer.addString('NAME', name);
    await replacer.addString('Address', '123 Main St, Vancouver, BC CANADA');
    await replacer.addString('DATE', new Date(Date.now()).toLocaleString());
    await replacer.process(page);

    pdfdoc.save(
      outputPath,
      PDFNet.SDFDoc.SaveOptions.e_linearized,
    );
  };

  PDFNetEndpoint(main, outputPath, res);
});

To test it, in browser, call the endpoint http://localhost:9000/replaceContent/John_Smith. After replacing name, address, and date, our letter is ready to be sent. As you can see, we preserve fonts and styles.

Using Apryse, however, you can also generate PDFs from scratch. In the following sample, we generate a new PDF from nothing and add a blank page.

app.get('/generate/:filename', (req, res) => {
  const filename = req.params.filename;
  const outputPath = path.resolve(__dirname, filesPath, `${filename}.pdf`);
  const main = async () => {
    const pdfdoc = await PDFNet.PDFDoc.create();
    await pdfdoc.initSecurityHandler();
    const page1 = await pdfdoc.pageCreate();
    pdfdoc.pagePushBack(page1);
    pdfdoc.save(
      outputPath,
      PDFNet.SDFDoc.SaveOptions.e_linearized,
    );
  };

  PDFNetEndpoint(main, outputPath, res);
});

After generating a PDF, you can call other APIs to add text elements, images, and so on⁠—either through adding annotations and then flattening them, or element building at a low-level.

Watermark a PDF

Sometimes, we want to protect the content of a PDF and prevent screenshotting or screen capture of a document. Many organizations choose to watermark content in order to protect it, which can be achieved with the following:

app.get('/watermark/:filename-:watermark', (req, res) => {
  const filename = req.params.filename;
  const watermark = req.params.watermark;
  let ext = path.parse(filename).ext;

  if (ext !== '.pdf') {
    res.statusCode = 500;
    res.end(`File is not a PDF. Please convert it first.`);
  }

  const inputPath = path.resolve(__dirname, filesPath, filename);
  const outputPath = path.resolve(__dirname, filesPath, `${filename}_watermarked.pdf`);

  const main = async () => {
    const pdfdoc = await PDFNet.PDFDoc.createFromFilePath(inputPath);
    await pdfdoc.initSecurityHandler();

    const stamper = await PDFNet.Stamper.create(
      PDFNet.Stamper.SizeType.e_relative_scale,
      0.5,
      0.5,
    ); // Stamp size is relative to the size of the crop box of the destination page
    stamper.setAlignment(
      PDFNet.Stamper.HorizontalAlignment.e_horizontal_center,
      PDFNet.Stamper.VerticalAlignment.e_vertical_center,
    );
    const redColorPt = await PDFNet.ColorPt.init(1, 0, 0);
    stamper.setFontColor(redColorPt);
    const pgSet = await PDFNet.PageSet.createRange(1, await pdfdoc.getPageCount());
    stamper.stampText(pdfdoc, watermark, pgSet);

    pdfdoc.save(
      outputPath,
      PDFNet.SDFDoc.SaveOptions.e_linearized,
    );
  };

  PDFNetEndpoint(main, outputPath, res);
});

To test, in the browser, call http://localhost:9000/watermark/webviewer.pdf-awesome. This will watermark every page of the document with awesome.

Add More APIs and Endpoints

You can also add a number of other document manipulation APIs. In fact, we have put together several Node.js samples for you to try out, including:

• Parse & extract PDF content
• Convert HTML to PDF
• Encrypt and decrypt PDF files
• Compress & optimize PDF files
• Redact PDF content
• Much more… (see Node.js samples)

Conclusion

This article was intended to help you build a simple document processing file server using Node.js and Express using our sample project on Github.

Ultimately, however, we’re just scratching the surface of what functionalities you can add with the powerful Apryse SDK, including dozens of other unique document processing capabilities.

Stay tuned for more APIs and demos, which I’ll be adding. And feel free to reach out with any questions.

In this post, You will learn how to convert Docx files to pdf documents in JavaScript and nodejs.

Docx/doc are document file formats from Microsoft, that contains images, text, tables, and styles
PDF files are from Adobe company, which is a separate format for representing the content of images, texts, and styles

There are a lot of online tools to do the conversion from doc to pdf. Sometimes, As a programmer, you need to have a conversion of different formats in the JavaScript/NodeJS applications.

JavaScript/NodeJS offers multiple ways to convert using npm packages

• docx-to-pdf
• libreoffice-convert

You can also check other posts on npm command deprecate option is deprecated

How to Convert word document to pdf in Nodejs application

First, Create a Nodejs application from scratch.

Let’s create a nodejs application from scratch using the npm init -y command in a new folder

B:blogjsworknodeworkdoctopdf>npm init -y
Wrote to B:blogjsworknodeworkdoctopdfpackage.json:

{
  "name": "doctopdf",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo "Error: no test specified" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

This creates a package.json as follows

{
  "name": "doctopdf",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo "Error: no test specified" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

convert docx to pdf using docx-pdf library

docx-pdf is a simple library to convert Docx to a pdf document.

First, Install Docx-pdf npm library

npm install Docx-pdf --save

This will add a dependency in package.json as follows

{
 "dependencies": {
    "docx-pdf": "0.0.1"
  }
}

In javascript, import docx-pdf using the required for ES5 modules

var converter = require('docx-pdf');

convert objects accepts

• input file which is a word document
• output file is the name of a pdf document
• callback which has err for error messages for conversion failed
  and result in successful conversion
• a result is an object containing a filename attribute and the value is the pdf document name and path

var converter = require('docx-pdf');

converter('test.docx', 'output.pdf', function(err, result) {
    if (err) {
        console.log("Converting Doc to PDF  failed", err);
    }
    console.log("Converting Doc to PDF succesfull", result);
});

And same code was written with async and await keywords for the asynchronous process.

convert docx to pdf with async/await

This will be useful for bigger files of sizes

The declared function which accepts input and output filename
It returns the promise object with reject for failed conversions and resolve for successful conversions.
And, docxConverter logic calls inside the async keyword with an anonymous function for asynchronous processing.

    async function ConvertDocToPdf(inputfile, outputfile) {
            return new Promise((resolve, reject) =>{
                        const inputPath = path.join(__dirname, "test.docx");
        const outputPath = path.join(__dirname, `/test.pdf`);
        let docData = await fs.readFile(inputPath)
                docxConverter(inputfile, outputfile, (err, result) => {
                    return err ?
                        reject(err) :
                        resolve(result)
                })
            })
        }

You need to call the same function with the await keyword

    await ConvertDocToPdf("test.docx", "test.pdf")

It is a simple library, the only disadvantage is not able to convert formatting styles.

libreoffice-convert npm package

libreoffice is an open-source office package for managing office documents.

libreoffice-convert is an npm package in nodejs that provides manipulation of word documents.

First, install libreoffice-convert npm package using the npm install command

npm install libreoffice-convert --save

Example code to convert docx to pdf using the libreoffice-convert package:

const libre = require('libreoffice-convert');
const path = require('path');
const fs = require('fs');
async function ConvertDocToPdf() {
    try {
        const inputPath = path.join(__dirname, "test.docx");
        const outputPath = path.join(__dirname, `/test.pdf`);
        let docData = await fs.readFile(inputPath)
        return new Promise((resolve, reject) => {
            libre.convert(docData, '.pdf', undefined, (err, done) => {
                if (err) {
                    reject('Conversion Failed')
                }
                fs.writeFileSync(outputPath, done);
                resolve("Convertion successfull")
            });
        })
    } catch (err) {
        console.log("Error in input reading", err);
    }
}

a sequence of steps for the above code

• Defined function with async keyword for asynchronous processing
• import libreoffice-convert, fs, and path modules into code
• read the input file using readFile method of fs module in NodeJS
• libre.convert the docx to pdf file
• conversion code is wrapped in a promise object
• for conversion failed cases, the reject promise is returned
• the promise is resolved for a successful conversion,
• Finally written output pdf file using the writeFileSync method

Conclusion

To Sum up, Learned how to Convert word to pdf in nodejs in multiple ways.