chromiumly 1.0.4 → 2.0.2

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

@@ -0,0 +1,105 @@
+import { createReadStream, promises } from "fs";
+
+import fetch from "node-fetch";
+import FormData from "form-data";
+
+import { PdfFormat } from "../../../common";
+import { MarkdownConverter } from "../markdown.converter";
+
+const { Response } = jest.requireActual("node-fetch");
+jest.mock("node-fetch", () => jest.fn());
+
+describe("MarkdownConverter", () => {
+  const mockPromisesAccess = jest.spyOn(promises, "access");
+  const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+
+  const converter = new MarkdownConverter();
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("endpoint", () => {
+    it("should route to Chromium Markdown route", () => {
+      expect(converter.endpoint).toEqual(
+        "http://localhost:3000/forms/chromium/convert/markdown"
+      );
+    });
+  });
+
+  describe("convert", () => {
+    beforeEach(() => {
+      (createReadStream as jest.Mock) = jest.fn().mockImplementation(() => {});
+    });
+
+    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",
+          markdown: "path/to/file.md",
+        });
+        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",
+          markdown: "path/to/file.md",
+          pdfFormat: PdfFormat.A_2b,
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(3);
+        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",
+          markdown: "path/to/file.md",
+          properties: { size: { width: 8.3, height: 11.7 } },
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(4);
+        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",
+            markdown: "path/to/file.md",
+          })
+        ).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",
+            markdown: "path/to/file.md",
+          })
+        ).rejects.toThrow(errorMessage);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,82 @@
+import fetch from "node-fetch";
+import FormData from "form-data";
+
+import { PdfFormat } from "../../../common";
+import { UrlConverter } from "../url.converter";
+
+const { Response } = jest.requireActual("node-fetch");
+jest.mock("node-fetch", () => jest.fn());
+
+describe("HtmlConverter", () => {
+  const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+
+  const converter = new UrlConverter();
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("endpoint", () => {
+    it("should route to Chromium HTML route", () => {
+      expect(converter.endpoint).toEqual(
+        "http://localhost:3000/forms/chromium/convert/url"
+      );
+    });
+  });
+
+  describe("convert", () => {
+    describe("when URL is valid", () => {
+      it("should return a buffer", async () => {
+        mockFetch.mockResolvedValueOnce(new Response("content"));
+        const buffer = await converter.convert({
+          url: "http://www.example.com/",
+        });
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when pdf format parameter is passed", () => {
+      it("should return a buffer", async () => {
+        mockFetch.mockResolvedValueOnce(new Response("content"));
+        const buffer = await converter.convert({
+          url: "http://www.example.com/",
+          pdfFormat: PdfFormat.A_3b,
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(2);
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when page properties parameter is passed", () => {
+      it("should return a buffer", async () => {
+        mockFetch.mockResolvedValueOnce(new Response("content"));
+        const buffer = await converter.convert({
+          url: "http://www.example.com/",
+          properties: { size: { width: 8.3, height: 11.7 } },
+        });
+        expect(mockFormDataAppend).toBeCalledTimes(3);
+        expect(buffer).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when URL is invalid", () => {
+      it("should throw an error", async () => {
+        await expect(() =>
+          converter.convert({ url: "invalid url" })
+        ).rejects.toThrow("Invalid URL: invalid url");
+      });
+    });
+
+    describe("when fetch request fails", () => {
+      it("should throw an error", async () => {
+        const errorMessage =
+          "FetchError: request to http://localhost:3000/forms/chromium/convert/html failed";
+        mockFetch.mockRejectedValueOnce(new Error(errorMessage));
+        await expect(() =>
+          converter.convert({ url: "http://www.example.com/" })
+        ).rejects.toThrow(errorMessage);
+      });
+    });
+  });
+});

package/src/{converters → chromium/converters}/url.converter.ts

@@ -2,32 +2,38 @@ import { URL } from "url";
 
 import FormData from "form-data";
 
-import { IConverter } from "../common/converter.interface";
-import { PageProperties } from "../common/converter.types";
-import { ConverterUtils } from "../common/converter.utils";
-import { Converter } from "../common/converter";
-import { Route } from "../main.config";
+import { GotenbergUtils, PdfFormat } from "../../common";
+import { IConverter } from "../interfaces/converter.interface";
+import { PageProperties } from "../interfaces/converter.types";
+import { ConverterUtils } from "../utils/converter.utils";
+import { Converter } from "./converter";
+import { ChromiumRoute } from "../../main.config";
 
 export class UrlConverter extends Converter implements IConverter {
   constructor() {
-    super(Route.URL);
+    super(ChromiumRoute.URL);
   }
 
   async convert({
     url,
     properties,
+    pdfFormat,
   }: {
     url: string;
     properties?: PageProperties;
+    pdfFormat?: PdfFormat;
   }): Promise<Buffer> {
     try {
       const _url = new URL(url);
       const data = new FormData();
+      if (pdfFormat) {
+        data.append("pdfFormat", pdfFormat);
+      }
       data.append("url", _url.href);
       if (properties) {
         ConverterUtils.injectPageProperties(data, properties);
       }
-      return ConverterUtils.fetch(this.endpoint, data);
+      return GotenbergUtils.fetch(this.endpoint, data);
     } catch (error) {
       throw error;
     }

package/src/chromium/index.ts

@@ -0,0 +1,3 @@
+export { HtmlConverter } from "./converters/html.converter";
+export { MarkdownConverter } from "./converters/markdown.converter";
+export { UrlConverter } from "./converters/url.converter";

package/src/{common → chromium/interfaces}/converter.interface.ts

@@ -1,11 +1,12 @@
 import { PathLike } from "fs";
 
+import { PdfFormat } from "../../common";
 import { PageProperties } from "./converter.types";
 
 export interface IConverter {
   convert({
     ...args
   }: {
-    [x: string]: string | PathLike | PageProperties;
+    [x: string]: string | PathLike | PageProperties | PdfFormat;
   }): Promise<Buffer>;
 }

package/src/chromium/utils/converter.utils.ts

@@ -0,0 +1,75 @@
+import FormData from "form-data";
+
+import { GotenbergUtils } from "../../common/gotenberg.utils";
+import { PageProperties } from "../interfaces/converter.types";
+
+export class ConverterUtils {
+  public static injectPageProperties(
+    data: FormData,
+    pageProperties: PageProperties
+  ): void {
+    if (pageProperties.size) {
+      GotenbergUtils.assert(
+        pageProperties.size.width >= 1.0 && pageProperties.size.height >= 1.5,
+        "size is smaller than the minimum printing requirements (i.e. 1.0 x 1.5 in)"
+      );
+
+      data.append("paperWidth", pageProperties.size.width);
+      data.append("paperHeight", pageProperties.size.height);
+    }
+
+    if (pageProperties.margins) {
+      GotenbergUtils.assert(
+        pageProperties.margins.top >= 0 &&
+          pageProperties.margins.bottom >= 0 &&
+          pageProperties.margins.left >= 0 &&
+          pageProperties.margins.left >= 0,
+        "negative margins are not allowed"
+      );
+
+      data.append("marginTop", pageProperties.margins.top);
+      data.append("marginBottom", pageProperties.margins.bottom);
+      data.append("marginLeft", pageProperties.margins.left);
+      data.append("marginRight", pageProperties.margins.right);
+    }
+
+    if (pageProperties.preferCssPageSize) {
+      data.append(
+        "preferCssPageSize",
+        String(pageProperties.preferCssPageSize)
+      );
+    }
+
+    if (pageProperties.printBackground) {
+      data.append("printBackground", String(pageProperties.printBackground));
+    }
+
+    if (pageProperties.landscape) {
+      data.append("landscape", String(pageProperties.landscape));
+    }
+
+    if (pageProperties.scale) {
+      GotenbergUtils.assert(
+        pageProperties.scale >= 0.1 && pageProperties.scale <= 2.0,
+        "scale is outside of [0.1 - 2] range"
+      );
+
+      data.append("scale", pageProperties.scale);
+    }
+
+    if (pageProperties.nativePageRanges) {
+      GotenbergUtils.assert(
+        pageProperties.nativePageRanges.from > 0 &&
+          pageProperties.nativePageRanges.to > 0 &&
+          pageProperties.nativePageRanges.to >=
+            pageProperties.nativePageRanges.from,
+        "page ranges syntax error"
+      );
+
+      data.append(
+        "nativePageRanges",
+        `${pageProperties.nativePageRanges.from}-${pageProperties.nativePageRanges.to}`
+      );
+    }
+  }
+}

package/src/chromium/utils/tests/converter.utils.test.ts

@@ -0,0 +1,101 @@
+import FormData from "form-data";
+import { ConverterUtils } from "../converter.utils";
+
+describe("ConverterUtils", () => {
+  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+  const data = new FormData();
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("injectPageProperties", () => {
+    describe("Page size", () => {
+      describe("when page size is valid", () => {
+        it("should append page size to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            size: { width: 8.3, height: 11.7 },
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(2);
+          expect(data.append).toHaveBeenCalledWith("paperWidth", 8.3);
+          expect(data.append).toHaveBeenNthCalledWith(2, "paperHeight", 11.7);
+        });
+      });
+    });
+
+    describe("Page margins", () => {
+      describe("when page margins are valid", () => {
+        it("should append page margins to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            margins: { top: 0.5, bottom: 0.5, left: 1, right: 1 },
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(4);
+          expect(data.append).toHaveBeenCalledWith("marginTop", 0.5);
+          expect(data.append).toHaveBeenNthCalledWith(2, "marginBottom", 0.5);
+          expect(data.append).toHaveBeenNthCalledWith(3, "marginLeft", 1);
+          expect(data.append).toHaveBeenNthCalledWith(4, "marginRight", 1);
+        });
+      });
+    });
+
+    describe("Page css size", () => {
+      describe("when preferCssPageSize parameter is set", () => {
+        it("should append preferCssPageSize to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            preferCssPageSize: true,
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("preferCssPageSize", "true");
+        });
+      });
+    });
+
+    describe("Page background", () => {
+      describe("when printBackground parameter is set", () => {
+        it("should append printBackground to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            printBackground: true,
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("printBackground", "true");
+        });
+      });
+    });
+
+    describe("Page landscape", () => {
+      describe("when landscape parameter is set", () => {
+        it("should append landscape to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            landscape: true,
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("landscape", "true");
+        });
+      });
+    });
+
+    describe("Page scale", () => {
+      describe("when page scale is valid", () => {
+        it("should append scale to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            scale: 1.5,
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("scale", 1.5);
+        });
+      });
+    });
+
+    describe("Page ranges", () => {
+      describe("when nativePageRanges is valid", () => {
+        it("should append nativePageRanges to data", () => {
+          ConverterUtils.injectPageProperties(data, {
+            nativePageRanges: { from: 1, to: 6 },
+          });
+          expect(mockFormDataAppend).toBeCalledTimes(1);
+          expect(data.append).toHaveBeenCalledWith("nativePageRanges", "1-6");
+        });
+      });
+    });
+  });
+});

package/src/common/constants.ts

@@ -0,0 +1,5 @@
+export enum PdfFormat {
+  A_1a = "PDF/A-1a",
+  A_2b = "PDF/A-2b",
+  A_3b = "PDF/A-3b",
+}

package/src/common/gotenberg.utils.ts

@@ -0,0 +1,25 @@
+import FormData from "form-data";
+import fetch from "node-fetch";
+
+export class GotenbergUtils {
+  public static assert(condition: boolean, message: string): asserts condition {
+    if (!condition) {
+      throw new Error(message);
+    }
+  }
+
+  public static async fetch(endpoint: string, data: FormData): Promise<Buffer> {
+    const response = await fetch(endpoint, {
+      method: "post",
+      body: data,
+      headers: {
+        ...data.getHeaders(),
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`${response.status} ${response.statusText}`);
+    }
+    return response.buffer();
+  }
+}

package/src/common/index.ts

@@ -0,0 +1,2 @@
+export { PdfFormat } from "./constants";
+export { GotenbergUtils } from "./gotenberg.utils";

package/src/common/tests/gotenberg.utils.test.ts

@@ -0,0 +1,71 @@
+import fetch from "node-fetch";
+import FormData from "form-data";
+
+import { GotenbergUtils } from "./../gotenberg.utils";
+
+const { Response, FetchError } = jest.requireActual("node-fetch");
+
+jest.mock("node-fetch", () => jest.fn());
+
+describe("GotenbergUtils", () => {
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("assert", () => {
+    const errorMessage = "error message";
+    describe("when condition is true", () => {
+      it("should pass", () => {
+        expect(() => GotenbergUtils.assert(true, errorMessage)).not.toThrow();
+      });
+    });
+    describe("when condition is false", () => {
+      it("should return error message", () => {
+        expect(() => GotenbergUtils.assert(false, errorMessage)).toThrow(
+          errorMessage
+        );
+      });
+    });
+  });
+
+  describe("fetch", () => {
+    const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
+    const data = new FormData();
+    const endpoint = "http://localhost:3000/forms/chromium/convert/html";
+
+    describe("when fetch request succeeds", () => {
+      it("should return a buffer", async () => {
+        mockFetch.mockResolvedValueOnce(new Response("content"));
+        const response = await GotenbergUtils.fetch(endpoint, data);
+        await expect(response).toEqual(Buffer.from("content"));
+      });
+    });
+
+    describe("when fetch request fails", () => {
+      describe("when there is a known error", () => {
+        it("should throw an error", async () => {
+          const errorMessage =
+            "FetchError: request to http://localhost:3000/forms/chromium/convert/html failed";
+          mockFetch.mockRejectedValueOnce(new FetchError(errorMessage));
+          await expect(() =>
+            GotenbergUtils.fetch(endpoint, data)
+          ).rejects.toThrow(errorMessage);
+        });
+      });
+
+      describe("when there is an unknown error", () => {
+        it("should throw an error", async () => {
+          mockFetch.mockResolvedValueOnce(
+            new Response(
+              {},
+              { status: 500, statusText: "Internal server error" }
+            )
+          );
+          await expect(() =>
+            GotenbergUtils.fetch(endpoint, data)
+          ).rejects.toThrow("500 Internal server error");
+        });
+      });
+    });
+  });
+});

package/src/libre-office/index.ts

@@ -0,0 +1,2 @@
+export { PageProperties } from "./interfaces/libre-office.types";
+export { LibreOfficeUtils } from "./utils/libre-office.utils";

package/src/libre-office/interfaces/libre-office.types.ts

@@ -0,0 +1,4 @@
+export type PageProperties = {
+  landscape?: boolean; // Set the paper orientation to landscape (default false)
+  nativePageRanges?: { from: number; to: number }; // Page ranges to print
+};

package/src/libre-office/utils/constants.ts

@@ -0,0 +1,78 @@
+export const LIBRE_OFFICE_EXTENSIONS = [
+  ".bib",
+  ".doc",
+  ".xml",
+  ".docx",
+  ".fodt",
+  ".html",
+  ".ltx",
+  ".txt",
+  ".odt",
+  ".ott",
+  ".pdb",
+  ".pdf",
+  ".psw",
+  ".rtf",
+  ".sdw",
+  ".stw",
+  ".sxw",
+  ".uot",
+  ".vor",
+  ".wps",
+  ".epub",
+  ".png",
+  ".bmp",
+  ".emf",
+  ".eps",
+  ".fodg",
+  ".gif",
+  ".jpg",
+  ".met",
+  ".odd",
+  ".otg",
+  ".pbm",
+  ".pct",
+  ".pgm",
+  ".ppm",
+  ".ras",
+  ".std",
+  ".svg",
+  ".svm",
+  ".swf",
+  ".sxd",
+  ".sxw",
+  ".tiff",
+  ".xhtml",
+  ".xpm",
+  ".fodp",
+  ".potm",
+  ".pot",
+  ".pptx",
+  ".pps",
+  ".ppt",
+  ".pwp",
+  ".sda",
+  ".sdd",
+  ".sti",
+  ".sxi",
+  ".uop",
+  ".wmf",
+  ".csv",
+  ".dbf",
+  ".dif",
+  ".fods",
+  ".ods",
+  ".ots",
+  ".pxl",
+  ".sdc",
+  ".slk",
+  ".stc",
+  ".sxc",
+  ".uos",
+  ".xls",
+  ".xlt",
+  ".xlsx",
+  ".tif",
+  ".jpeg",
+  ".odp",
+];

package/src/libre-office/utils/libre-office.utils.ts

@@ -0,0 +1,51 @@
+import { constants, createReadStream, PathLike, promises } from "fs";
+import path from "path";
+
+import FormData from "form-data";
+
+import { GotenbergUtils } from "../../common";
+import { LIBRE_OFFICE_EXTENSIONS } from "./constants";
+import { PageProperties } from "../interfaces/libre-office.types";
+
+export class LibreOfficeUtils {
+  public static async injectFiles(files: PathLike[], data: FormData) {
+    for (const file of files) {
+      try {
+        await promises.access(file, constants.R_OK);
+        const filename = path.basename(file.toString());
+        const extension = path.extname(filename);
+        if (LIBRE_OFFICE_EXTENSIONS.includes(extension)) {
+          data.append(filename, createReadStream(file));
+        } else {
+          throw new Error(`${extension} is not supported`);
+        }
+      } catch (error) {
+        throw error;
+      }
+    }
+  }
+
+  public static injectPageProperties(
+    data: FormData,
+    pageProperties: PageProperties
+  ): void {
+    if (pageProperties.landscape) {
+      data.append("landscape", String(pageProperties.landscape));
+    }
+
+    if (pageProperties.nativePageRanges) {
+      GotenbergUtils.assert(
+        pageProperties.nativePageRanges.from > 0 &&
+          pageProperties.nativePageRanges.to > 0 &&
+          pageProperties.nativePageRanges.to >=
+            pageProperties.nativePageRanges.from,
+        "page ranges syntax error"
+      );
+
+      data.append(
+        "nativePageRanges",
+        `${pageProperties.nativePageRanges.from}-${pageProperties.nativePageRanges.to}`
+      );
+    }
+  }
+}