chromiumly 2.3.1 → 2.5.0

package/src/common/gotenberg.utils.ts

@@ -2,24 +2,24 @@ 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 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(),
-      },
-    });
+    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}`);
+        if (!response.ok) {
+            throw new Error(`${response.status} ${response.statusText}`);
+        }
+        return response.buffer();
     }
-    return response.buffer();
-  }
 }

package/src/common/index.ts

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

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

@@ -1,71 +1,71 @@
 import fetch from "node-fetch";
 import FormData from "form-data";
 
-import { GotenbergUtils } from "./../gotenberg.utils";
+import {GotenbergUtils} from "./../gotenberg.utils";
 
-const { Response, FetchError } = jest.requireActual("node-fetch");
+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
-        );
-      });
+    afterEach(() => {
+        jest.resetAllMocks();
     });
-  });
 
-  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("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("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("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 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");
+        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/common/types.ts

@@ -0,0 +1,3 @@
+import {PathLike, ReadStream} from "fs";
+
+export type PathLikeOrReadStream = PathLike | ReadStream

package/src/gotenberg.ts

@@ -8,14 +8,14 @@ import config from "config";
 const envFile = `.env.${process.env.NODE_ENV}`;
 const envFileFallback = ".env";
 
-const dotenvConfig = dotenv.config({ path: path.resolve(envFile) });
+const dotenvConfig = dotenv.config({path: path.resolve(envFile)});
 
 // Fallback to loading the default environment file.
 if (dotenvConfig.error) {
-  dotenv.config({ path: path.resolve(envFileFallback) });
+    dotenv.config({path: path.resolve(envFileFallback)});
 }
 
 export class Gotenberg {
-  public static endpoint: string =
-    process.env.GOTENBERG_ENDPOINT || config.get<string>("gotenberg.endpoint");
+    public static endpoint: string =
+        process.env.GOTENBERG_ENDPOINT || config.get<string>("gotenberg.endpoint");
 }

package/src/libre-office/index.ts

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

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

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

@@ -1,78 +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",
+    ".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

@@ -1,47 +1,54 @@
-import { constants, createReadStream, PathLike, promises } from "fs";
+import {constants, createReadStream, promises, ReadStream} 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";
+import {GotenbergUtils, PathLikeOrReadStream} 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) {
-      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`);
-      }
+    public static async addFiles(files: PathLikeOrReadStream[], data: FormData) {
+        for (const [key, file] of files.entries()) {
+            const filename = `file${key}`
+            if (Buffer.isBuffer(file)) {
+                data.append("files", file, filename);
+            } else if (file instanceof ReadStream) {
+                data.append("files", file, filename);
+            } else {
+                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("files", createReadStream(file), filename);
+                } else {
+                    throw new Error(`${extension} is not supported`);
+                }
+            }
+        }
     }
-  }
 
-  public static injectPageProperties(
-    data: FormData,
-    pageProperties: PageProperties
-  ): void {
-    if (pageProperties.landscape) {
-      data.append("landscape", String(pageProperties.landscape));
-    }
+    public static addPageProperties(
+        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"
-      );
+        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}`
-      );
+            data.append(
+                "nativePageRanges",
+                `${pageProperties.nativePageRanges.from}-${pageProperties.nativePageRanges.to}`
+            );
+        }
     }
-  }
 }

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

@@ -1,86 +1,98 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { promises, createReadStream } from "fs";
-import { LibreOfficeUtils } from "../libre-office.utils";
+import {promises, createReadStream} from "fs";
+import {LibreOfficeUtils} from "../libre-office.utils";
 
 import FormData from "form-data";
 
 describe("LibreOfficeUtils", () => {
-  const mockPromisesAccess = jest.spyOn(promises, "access");
-  const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
-  const data = new FormData();
+    const mockPromisesAccess = jest.spyOn(promises, "access");
+    const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
+    const data = new FormData();
 
-  beforeEach(() => {
-    (createReadStream as jest.Mock) = jest
-      .fn()
-      .mockImplementation((file) => file);
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe("injectFiles", () => {
-    describe("when files exist", () => {
-      it("should append each file to data", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        await LibreOfficeUtils.injectFiles(
-          ["path/to/file.docx", "path/to/file.bib"],
-          data
-        );
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-      });
+    beforeEach(() => {
+        (createReadStream as jest.Mock) = jest
+            .fn()
+            .mockImplementation((file) => file);
     });
 
-    describe("when one of the files has unsupported format", () => {
-      it("should throw an error", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        await expect(() =>
-          LibreOfficeUtils.injectFiles(
-            ["path/to/file.rar", "path/to/file.pdf"],
-            data
-          )
-        ).rejects.toThrow(".rar is not supported");
-      });
+    afterEach(() => {
+        jest.resetAllMocks();
     });
 
-    describe("when one of the files 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(() =>
-          LibreOfficeUtils.injectFiles(
-            ["path/to/file.pdf", "path/to/another-file.pdf"],
-            data
-          )
-        ).rejects.toThrow(errorMessage);
-      });
-    });
-  });
+    describe("addFiles", () => {
+        describe("when files exist", () => {
+            describe("when files parameter contains paths", () => {
+                it("should append each file to data", async () => {
+                    mockPromisesAccess.mockResolvedValue();
+                    await LibreOfficeUtils.addFiles(
+                        ["path/to/file.docx", "path/to/file.bib"],
+                        data
+                    );
+                    expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                });
+            })
+            describe("when files parameter contains a buffer", () => {
+                it("should append each file to data", async () => {
+                    mockPromisesAccess.mockResolvedValue();
+                    await LibreOfficeUtils.addFiles(
+                        [Buffer.from("data"), "path/to/file.bib"],
+                        data
+                    );
+                    expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                });
+            })
+        });
 
-  describe("injectPageProperties", () => {
-    describe("Page landscape", () => {
-      describe("when landscape parameter is set", () => {
-        it("should append landscape to data", () => {
-          LibreOfficeUtils.injectPageProperties(data, {
-            landscape: true,
-          });
-          expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
-          expect(data.append).toHaveBeenCalledWith("landscape", "true");
+        describe("when one of the files has unsupported format", () => {
+            it("should throw an error", async () => {
+                mockPromisesAccess.mockResolvedValue();
+                await expect(() =>
+                    LibreOfficeUtils.addFiles(
+                        ["path/to/file.rar", "path/to/file.pdf"],
+                        data
+                    )
+                ).rejects.toThrow(".rar is not supported");
+            });
+        });
+
+        describe("when one of the files 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(() =>
+                    LibreOfficeUtils.addFiles(
+                        ["path/to/file.pdf", "path/to/another-file.pdf"],
+                        data
+                    )
+                ).rejects.toThrow(errorMessage);
+            });
         });
-      });
     });
 
-    describe("Page ranges", () => {
-      describe("when nativePageRanges is valid", () => {
-        it("should append nativePageRanges to data", () => {
-          LibreOfficeUtils.injectPageProperties(data, {
-            nativePageRanges: { from: 1, to: 6 },
-          });
-          expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
-          expect(data.append).toHaveBeenCalledWith("nativePageRanges", "1-6");
+    describe("addPageProperties", () => {
+        describe("Page landscape", () => {
+            describe("when landscape parameter is set", () => {
+                it("should append landscape to data", () => {
+                    LibreOfficeUtils.addPageProperties(data, {
+                        landscape: true,
+                    });
+                    expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                    expect(data.append).toHaveBeenCalledWith("landscape", "true");
+                });
+            });
+        });
+
+        describe("Page ranges", () => {
+            describe("when nativePageRanges is valid", () => {
+                it("should append nativePageRanges to data", () => {
+                    LibreOfficeUtils.addPageProperties(data, {
+                        nativePageRanges: {from: 1, to: 6},
+                    });
+                    expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                    expect(data.append).toHaveBeenCalledWith("nativePageRanges", "1-6");
+                });
+            });
         });
-      });
     });
-  });
 });