Stream requestbody to file and convert from file

src/html-to-pdf-client.ts

@@ -1,17 +1,39 @@
-import { spawn, which } from 'bun';
+import { spawn, which, file } from 'bun';
+import { PinoLogger } from './logger.ts';
 
-export type HtmlToPdfClient = (req: Request, outputPath: string) => Promise<void>;
-export const htmlToPdfClient: HtmlToPdfClient = async (req, outputPath) => {
+export type HtmlToPdfClient = (inputPath: string, outputPath: string, logger: PinoLogger, timeout?: number) => Promise<void>;
+export const htmlToPdfClient: HtmlToPdfClient = async (inputPath, outputPath, logger, timeout = 10_000) => {
 	const bin = which('wkhtmltopdf');
 	if (bin === null) {
 		throw new Error('Missing HTML to PDF binary');
 	}
+
+	const inputFile = Bun.file(inputPath);
+	if (!await inputFile.exists()) {
+		throw new Error(`Html for conversion ${inputPath} does not exist or is not readable`)
+	}
+
+	const htmlSize = inputFile.size;
+	if (htmlSize < 1) {
+		throw new Error(`Html file-size for conversion ${inputPath} is smaller than 1 byte`)
+	}
+
+	logger.info(`Starting conversion of HTML to PDF from ${inputPath}, size: ${htmlSize}`);
+
 	const proc = spawn(
-		['wkhtmltopdf', '--quiet', '--print-media-type', '--no-outline', '-', outputPath],
-		{stdin: req, stderr: 'pipe'},
+		['wkhtmltopdf', '--log-level', 'warn', '--print-media-type', '--disable-javascript', '--no-outline', inputPath, outputPath],
+		{stderr: 'pipe'},
 	);
 
+	const timer = setTimeout(() => {
+		proc.kill(129);
+		throw new Error(`Timing out after ${timeout} ms while calling wkhtmltopdf, killing the process manually`);
+	}, timeout);
+
 	const exitCode = await proc.exited;
+
+	clearTimeout(timer);
+
 	const errors: string = await Bun.readableStreamToText(proc.stderr);
 	if (errors) {
 		throw new Error(errors);
@@ -21,4 +43,11 @@ export const htmlToPdfClient: HtmlToPdfClient = async (req, outputPath) => {
 	if (exitCode !== 0) {
 		throw new Error(`Failed to convert HTML to PDF, the process exited with code ${exitCode}`);
 	}
+
+	const outputFile = file(outputPath);
+	const pdfSize = outputFile.size;
+	if (pdfSize < 1) {
+		throw new Error(`PDF file-size for conversion ${outputPath} is smaller than 1 byte`)
+	}
+	logger.info(`created PDF output with size: ${pdfSize}`);
 };

src/index.ts

@@ -1,6 +1,6 @@
 import { createServer } from './server.ts';
 import { trapShutdown } from './shutdown.ts';
 
-const server = createServer();
+const server = await createServer();
 
 trapShutdown(async () => server.stop());

src/logger.ts

@@ -1,7 +1,8 @@
-import pino, { type Logger as PinoLogger } from 'pino';
+import pino from 'pino';
 
 export const loggerUsingPino = () => pino({
 	name: 'html-pdf-export',
 });
 
-export type Logger = () => PinoLogger;
+export type PinoLogger = typeof pino;
+export type LoggerFactory = () => PinoLogger;

src/server.ts

@@ -2,20 +2,58 @@ import { file } from 'bun';
 import { nanoid } from 'nanoid';
 import { mkdir, unlink } from 'node:fs/promises';
 import { tmpdir } from 'os';
+import { ReadableStream } from "stream/web";
 import { htmlToPdfClient, type HtmlToPdfClient } from './html-to-pdf-client.ts';
-import { type Logger, loggerUsingPino } from './logger.ts';
+import { type LoggerFactory, loggerUsingPino, PinoLogger } from './logger.ts';
 
 export interface CreateServerOptions {
 	port?: number;
-	logger?: Logger;
+	logger?: LoggerFactory;
 	htmlToPdfClient?: HtmlToPdfClient;
 }
 
-export const createServer = (options?: CreateServerOptions) => {
+const convertHtmlToPdf = async(
+	requestBody: ReadableStream,
+	requestId: string,
+	tmpDir: string,
+	client: HtmlToPdfClient,
+	logger: PinoLogger
+) => {
+	const outputPath = `${tmpDir}/${requestId}.pdf`;
+	const inputPath = `${tmpDir}/${requestId}.html`;
+
+	logger.info(`Writing request body to file: ${inputPath}`);
+	await Bun.write(inputPath, await Bun.readableStreamToBlob(requestBody));
+
+	const startTime = process.hrtime();
+
+	await client(inputPath, outputPath, logger);
+
+	const duration = process.hrtime(startTime);
+	logger.info(`Done converting HTML to PDF in ${duration}`);
+
+	const pdfOutput = file(outputPath);
+	logger.info(`created output size: ${pdfOutput.size}`);
+
+	pdfOutput.stream().getReader().closed.then(async() => {
+		await unlink(outputPath);
+		await unlink(inputPath);
+	});
+
+	return pdfOutput;
+};
+
+export const createServer = async(options?: CreateServerOptions) => {
 	const port = options?.port ?? 8000;
 	const logger = options?.logger?.() ?? loggerUsingPino();
 	const client = options?.htmlToPdfClient ?? htmlToPdfClient;
 
+	const tmpDir = process.env.HTML_PDF_EXPORT_TMPDIR ?? tmpdir();
+	if (!(await file(tmpDir).exists())) {
+		logger.info('Temporary file directory not found, creating a new directory');
+		await mkdir(tmpDir, {recursive: true});
+	}
+
 	logger.info(`Listening on port ${port}...`);
 
 	return Bun.serve({
@@ -44,23 +82,15 @@ export const createServer = (options?: CreateServerOptions) => {
 				return new Response(null, {status: 400});
 			}
 
-			const tmpDir = process.env.HTML_PDF_EXPORT_TMPDIR ?? tmpdir();
-			if (!(await file(tmpDir).exists())) {
-				logger.info('Temporary file directory not found, creating a new directory');
-				await mkdir(tmpDir, {recursive: true});
-			}
+			const pdfOutput = await convertHtmlToPdf(
+				req.body,
+				requestId,
+				tmpDir,
+				client,
+				logger,
+			);
 
-			const outputPath = `${tmpDir}/${requestId}.pdf`;
-			const contentLength = req.headers.get('content-length');
-			logger.info('Starting conversion of HTML to PDF', {contentLength});
-			const startTime = process.hrtime();
-			await client(req, outputPath);
-			const duration = process.hrtime(startTime);
-			logger.info('Done converting HTML to PDF', {contentLength, duration});
-
-			const output = file(outputPath);
-			output.stream().getReader().closed.then(() => unlink(outputPath));
-			return new Response(output, {status: 200, headers: {'content-type': 'application/pdf'}});
+			return new Response(pdfOutput, {status: 200, headers: {'content-type': 'application/pdf'}});
 		},
 		error(err) {
 			logger.error(err);

src/shutdown.ts

@@ -1,13 +1,12 @@
 import { sleep } from 'bun';
-import { type Logger as PinoLogger } from 'pino';
-import { type Logger, loggerUsingPino } from './logger.ts';
+import { type LoggerFactory, loggerUsingPino, PinoLogger } from './logger.ts';
 
 class ShutdownTimedOutError extends Error {
 }
 
 interface ShutdownOptions {
 	timeout?: number;
-	logger?: Logger;
+	logger?: LoggerFactory;
 }
 
 export function trapShutdown(callback: () => Promise<void>, options?: ShutdownOptions) {