chromiumly 2.4.0 → 2.5.1

package/src/chromium/converters/markdown.converter.ts

@@ -1,80 +1,97 @@
-import { constants, createReadStream, PathLike, promises } from "fs";
-
 import FormData from "form-data";
 
-import { GotenbergUtils, PdfFormat } from "../../common";
+import {GotenbergUtils, PdfFormat, PathLikeOrReadStream} from "../../common";
 import {
-  EmulatedMediaType,
-  PageProperties,
+    EmulatedMediaType,
+    PageProperties,
 } from "../interfaces/converter.types";
-import { ConverterUtils } from "../utils/converter.utils";
-import { Converter } from "./converter";
-import { ChromiumRoute } from "../../main.config";
+import {ConverterUtils} from "../utils/converter.utils";
+import {Converter} from "./converter";
+import {ChromiumRoute} from "../../main.config";
 
+/**
+ * Class representing a Markdown converter that extends the base Converter class.
+ * This class is used to convert HTML with markdown content to PDF using Gotenberg service.
+ *
+ * @extends Converter
+ */
 export class MarkdownConverter extends Converter {
-  constructor() {
-    super(ChromiumRoute.MARKDOWN);
-  }
+    /**
+     * Creates an instance of MarkdownConverter.
+     * Initializes the converter with the Markdown conversion route.
+     */
+    constructor() {
+        super(ChromiumRoute.MARKDOWN);
+    }
 
-  async convert({
-    html,
-    markdown,
-    header,
-    footer,
-    properties,
-    pdfFormat,
-    pdfUA,
-    emulatedMediaType,
-    waitDelay,
-    waitForExpression,
-    userAgent,
-    extraHttpHeaders,
-    failOnConsoleExceptions,
-  }: {
-    html: PathLike;
-    markdown: PathLike;
-    header?: PathLike;
-    footer?: PathLike;
-    properties?: PageProperties;
-    pdfFormat?: PdfFormat;
-    pdfUA?: boolean;
-    emulatedMediaType?: EmulatedMediaType;
-    waitDelay?: string;
-    waitForExpression?: string;
-    userAgent?: string;
-    extraHttpHeaders?: Record<string, string>;
-    failOnConsoleExceptions?: boolean;
-  }): Promise<Buffer> {
-    const data = new FormData();
+    /**
+     * Converts HTML with markdown content to PDF.
+     *
+     * @param {Object} options - Conversion options.
+     * @param {PathLikeOrReadStream} options.html - PathLike or ReadStream of the HTML content to be converted.
+     * @param {PathLikeOrReadStream} options.markdown - PathLike or ReadStream of the Markdown content to be converted.
+     * @param {PathLikeOrReadStream} [options.header] - PathLike or ReadStream of the header HTML content.
+     * @param {PathLikeOrReadStream} [options.footer] - PathLike or ReadStream of the footer HTML content.
+     * @param {PageProperties} [options.properties] - Page properties for the conversion.
+     * @param {PdfFormat} [options.pdfFormat] - PDF format options.
+     * @param {boolean} [options.pdfUA] - Indicates whether to generate PDF/UA compliant output.
+     * @param {EmulatedMediaType} [options.emulatedMediaType] - Emulated media type for the conversion.
+     * @param {string} [options.waitDelay] - Delay before the conversion process starts.
+     * @param {string} [options.waitForExpression] - JavaScript expression to wait for before completing the conversion.
+     * @param {string} [options.userAgent] - User agent string to use during the conversion.
+     * @param {Record<string, string>} [options.extraHttpHeaders] - Additional HTTP headers for the conversion.
+     * @param {boolean} [options.failOnConsoleExceptions] - Whether to fail on console exceptions during conversion.
+     * @returns {Promise<Buffer>} A Promise resolving to the converted PDF content as a Buffer.
+     */
+    async convert({
+                      html,
+                      markdown,
+                      header,
+                      footer,
+                      properties,
+                      pdfFormat,
+                      pdfUA,
+                      emulatedMediaType,
+                      waitDelay,
+                      waitForExpression,
+                      userAgent,
+                      extraHttpHeaders,
+                      failOnConsoleExceptions,
+                  }: {
+        html: PathLikeOrReadStream;
+        markdown: PathLikeOrReadStream;
+        header?: PathLikeOrReadStream;
+        footer?: PathLikeOrReadStream;
+        properties?: PageProperties;
+        pdfFormat?: PdfFormat;
+        pdfUA?: boolean;
+        emulatedMediaType?: EmulatedMediaType;
+        waitDelay?: string;
+        waitForExpression?: string;
+        userAgent?: string;
+        extraHttpHeaders?: Record<string, string>;
+        failOnConsoleExceptions?: boolean;
+    }): Promise<Buffer> {
+        const data = new FormData();
 
-    if (Buffer.isBuffer(html)) {
-      data.append("files", html, "index.html");
-    } else {
-      await promises.access(html, constants.R_OK);
-      data.append("files", createReadStream(html), "index.html");
-    }
+        await ConverterUtils.addFile(data, html, "index.html");
 
-    if (Buffer.isBuffer(markdown)) {
-      data.append("files", createReadStream(markdown), "file.md");
-    } else {
-      await promises.access(markdown, constants.R_OK);
-      data.append("file.md", createReadStream(markdown));
-    }
+        await ConverterUtils.addFile(data, markdown, "file.md");
 
-    ConverterUtils.customize(data, {
-      header,
-      footer,
-      properties,
-      pdfFormat,
-      pdfUA,
-      emulatedMediaType,
-      waitDelay,
-      waitForExpression,
-      userAgent,
-      extraHttpHeaders,
-      failOnConsoleExceptions,
-    });
+        await ConverterUtils.customize(data, {
+            header,
+            footer,
+            properties,
+            pdfFormat,
+            pdfUA,
+            emulatedMediaType,
+            waitDelay,
+            waitForExpression,
+            userAgent,
+            extraHttpHeaders,
+            failOnConsoleExceptions,
+        });
 
-    return GotenbergUtils.fetch(this.endpoint, data);
-  }
-}
+        return GotenbergUtils.fetch(this.endpoint, data);
+    }
+}

package/src/chromium/converters/tests/html.converter.test.ts

@@ -1,163 +1,147 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { createReadStream, promises } from "fs";
+import {createReadStream, promises} from "fs";
 
 import fetch from "node-fetch";
 import FormData from "form-data";
 
-import { PdfFormat } from "../../../common";
-import { HtmlConverter } from "../html.converter";
+import {PdfFormat} from "../../../common";
+import {HtmlConverter} from "../html.converter";
 
-const { Response } = jest.requireActual("node-fetch");
+const {Response} = jest.requireActual("node-fetch");
 jest.mock("node-fetch", () => jest.fn());
 
 describe("HtmlConverter", () => {
-  const mockPromisesAccess = jest.spyOn(promises, "access");
-  const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
-  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
-
-  const converter = new HtmlConverter();
-  beforeEach(() => {
-    (createReadStream as jest.Mock) = jest
-      .fn()
-      .mockImplementation((file) => file);
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe("endpoint", () => {
-    it("should route to Chromium HTML route", () => {
-      expect(converter.endpoint).toEqual(
-        "http://localhost:3000/forms/chromium/convert/html"
-      );
-    });
-  });
-
-  describe("convert", () => {
-    describe("when file exists", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({ html: "path/to/index.html" });
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
+    const converter = new HtmlConverter();
 
-    describe("when buffer is passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          html: Buffer.from("html"),
+    describe("endpoint", () => {
+        it("should route to Chromium HTML route", () => {
+            expect(converter.endpoint).toEqual(
+                "http://localhost:3000/forms/chromium/convert/html"
+            );
         });
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
     });
 
-    describe("when pdf format parameter is passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          html: "path/to/index.html",
-          pdfFormat: PdfFormat.A_1a,
+    describe("convert", () => {
+        const mockPromisesAccess = jest.spyOn(promises, "access");
+        const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+        const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+        
+        beforeEach(() => {
+            (createReadStream as jest.Mock) = jest.fn()
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when page properties parameter is passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          html: "path/to/index.html",
-          properties: { size: { width: 8.3, height: 11.7 } },
+        afterEach(() => {
+            jest.resetAllMocks();
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when header parameter is passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          html: "path/to/index.html",
-          header: "path/to/header.html",
+        describe("when html parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                });
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when footer parameter is passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          html: "path/to/index.html",
-          footer: "path/to/footer.html",
+        describe("when pdf format parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    pdfFormat: PdfFormat.A_1a,
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when emulatedMediaType parameter is passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          html: "path/to/index.html",
-          emulatedMediaType: "screen",
+        describe("when page properties parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    properties: {size: {width: 8.3, height: 11.7}},
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(3);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when all parameters are passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await converter.convert({
-          html: "path/to/index.html",
-          header: "path/to/header.html",
-          footer: "path/to/footer.html",
-          pdfFormat: PdfFormat.A_1a,
-          emulatedMediaType: "screen",
-          properties: { size: { width: 8.3, height: 11.7 } },
+        describe("when header parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    header: Buffer.from("header"),
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
         });
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(7);
-        expect(buffer).toEqual(Buffer.from("content"));
-      });
-    });
 
-    describe("when file does not exist", () => {
-      it("should throw an error", async () => {
-        const errorMessage =
-          "ENOENT: no such file or directory, access 'path/to/index.html'";
-        mockPromisesAccess.mockRejectedValue(new Error(errorMessage));
-        await expect(() =>
-          converter.convert({ html: "path/to/index.html" })
-        ).rejects.toThrow(errorMessage);
-      });
-    });
+        describe("when footer parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    footer: Buffer.from("footer"),
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
+        });
+
+        describe("when emulatedMediaType parameter is passed", () => {
+            it("should return a buffer", async () => {
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    emulatedMediaType: "screen",
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
+        });
+
+        describe("when all parameters are passed", () => {
+            it("should return a buffer", async () => {
+                mockPromisesAccess.mockResolvedValue();
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await converter.convert({
+                    html: Buffer.from("data"),
+                    header: Buffer.from("header"),
+                    footer: Buffer.from("footer"),
+                    pdfFormat: PdfFormat.A_1a,
+                    emulatedMediaType: "screen",
+                    properties: {size: {width: 8.3, height: 11.7}},
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(7);
+                expect(buffer).toEqual(Buffer.from("content"));
+            });
+        });
+
+        describe("when file does not exist", () => {
+            it("should throw an error", async () => {
+                const errorMessage =
+                    "ENOENT: no such file or directory, access 'path/to/index.html'";
+                mockPromisesAccess.mockRejectedValue(new Error(errorMessage));
+                await expect(() =>
+                    converter.convert({html: "path/to/index.html"})
+                ).rejects.toThrow(errorMessage);
+            });
+        });
 
-    describe("when fetch request fails", () => {
-      it("should throw an error", async () => {
-        const errorMessage =
-          "FetchError: request to http://localhost:3000/forms/chromium/convert/html failed";
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockRejectedValue(new Error(errorMessage));
-        await expect(() =>
-          converter.convert({ html: "path/to/index.html" })
-        ).rejects.toThrow(errorMessage);
-      });
+        describe("when fetch request fails", () => {
+            it("should throw an error", async () => {
+                const errorMessage =
+                    "FetchError: request to http://localhost:3000/forms/chromium/convert/html failed";
+                mockPromisesAccess.mockResolvedValue();
+                mockFetch.mockRejectedValue(new Error(errorMessage));
+                await expect(() =>
+                    converter.convert({html: "path/to/index.html"})
+                ).rejects.toThrow(errorMessage);
+            });
+        });
     });
-  });
 });