It turns out that report still matter, sometimes they land on paper, other times just as PDF files easily passed around without access to the original application. Here are our thoughts on how to effectively generate reports from a Node application. There are many options, but these are what we most commonly see and use.
1: Print the relevant application page
By far the simplest way to get a “report” from a web application is to use the browser’s built-in print capability. To “print a report”, the user navigates to where they see the data they wish to print, then they choose print in the browser. That’s it.
Many pages yield a somewhat poor report from that output by default, but a CSS media-query print stylesheet can rearrange things enough to produce passable results for simple cases. We recommend setting up such print stylesheets, and trying to print pages that have a report like nature, even if another reporting technique is also used – the ability to print a web page has been in browsers since nearly the beginning, and offers a low-cost way to get more value from the same application.
2: Headless-browser-based reporting
Printing an application page in the browser means being limited to whatever HTML is relevant to display in the browser, and further being subject to the vagaries of different browsers. Instead, it’s possible to reuse the same tools (HTML, templating, CSS) on the server to generate specific content for report printing.
To do this, choose any of the highly numerous node HTML templating systems, perform data access however you do so for application features, gather up the data for report, and emit the HTML/CSS. Then use a headless browser (on the server) to transform that HTML and CSS to a PDF, then make it available for the user to download.
This has some compelling advantages:
- Familiar programming model – as a developer you use approximately the same tools for report output that you use for screen output
- As a result, it’s easy to get started with relatively little to learn
- Well suited to reports that generally feel like “documents”, such as dunning letter reports.
- HTML, and therefore this approach, have little in the way of traditional reporting software features
- Layout tooling for HTML is screen oriented, not report oriented
3: Reporting library / API
There are Node libraries which offer an API generally suitable to create reports. Unlike the HTML approach, a reporting centric API will have features directly suited for report output, such as creating tabular data output aligned by decimal point, looping over data to put rows in such a table, and so on. This typically will be considerably more concise than HTML approach, because the API will be closer to the problem domain (the domain of “make a report”).
A notable disadvantage here is that the vocabulary of report such an API can produce tends to be much more limited. This is inherent in abstraction, the higher level an API, the easier it is to produce results, but the more constrained the results.
4: Low-level PDF drawing API
Rather than a high-level API, and there are also low-level APIs available to programmatically create PDF files. A low-level API will have operations like “place text on the page with the following formatting” and “draw a line from coordinate to coordinate”. This low-level, full control means that any report or other output can be produced, but the coding effort to do so can be significant.
This approach typically makes sense only for cases with very specific reporting needs. It is too labor-intensive to create numerous reports this way.
5: Call a traditional report tool
Lastly, reporting can be thought of as a separate subsystem, whose implementation need not be bound into the same platform as the rest of a system. With this approach, reporting functionality is generally omitted from the application backend, and instead implemented using an off-the-shelf report tool. There is a busy “enterprise” reporting tool market, with multiple very mature products. Costs vary widely, but these tools provide the kind of reporting experience developers may remember from years past: a visual report design surface, a way of interactively running and tweaking and drilling into a report, and so on.
- Extensive layout possibilities
- Visual layout tools, rather than code only
- Report design can often be done by non-developers
- The reporting solution may offer tools for managing and customizing a large library of reports, out-of-the-box
- Separate subsystem, different tool for staff to learn
- Deployment complexity, of deploying an additional product rather than only adding a library
- Cost: some of these are very “enterprise” products, with prices to match
- https://community.hds.com/docs/DOC-1009856 (Pentaho)
- https://www.microsoft.com/en-US/sql-server/sql-server-2017 (Reporting services)
Choosing an approach
The general trade-off among these approaches is that both cost and capability increase in roughly the order presented above. An acceptable CSS print-specific-stylesheet might yield acceptable results in a few minutes; a separate reporting subsystem, with a new tool stack to learn, could involve a team laboring for months. Oasis Digital has used each approach above (except the headless broader approach, as headless browsers just recently became popular) with excellent results.