chromiumly 2.3.1 → 2.5.0

package/src/main.config.ts

@@ -1,36 +1,37 @@
-import { Gotenberg } from "./gotenberg";
+import {Gotenberg} from "./gotenberg";
 
 export enum ChromiumRoute {
-  URL = "url",
-  HTML = "html",
-  MARKDOWN = "markdown",
+    URL = "url",
+    HTML = "html",
+    MARKDOWN = "markdown",
 }
 
 enum PdfEngineRoute {
-  MERGE = "merge",
+    MERGE = "merge",
 }
 
 enum LibreOfficeRoute {
-  CONVERT = "convert",
+    CONVERT = "convert",
 }
+
 export class Chromiumly {
-  public static readonly GOTENBERG_ENDPOINT = Gotenberg.endpoint;
+    public static readonly GOTENBERG_ENDPOINT = Gotenberg.endpoint;
 
-  public static readonly CHROMIUM_PATH = "forms/chromium/convert";
-  public static readonly PDF_ENGINES_PATH = "forms/pdfengines";
-  public static readonly LIBRE_OFFICE_PATH = "forms/libreoffice";
+    public static readonly CHROMIUM_PATH = "forms/chromium/convert";
+    public static readonly PDF_ENGINES_PATH = "forms/pdfengines";
+    public static readonly LIBRE_OFFICE_PATH = "forms/libreoffice";
 
-  public static readonly CHROMIUM_ROUTES = {
-    url: ChromiumRoute.URL,
-    html: ChromiumRoute.HTML,
-    markdown: ChromiumRoute.MARKDOWN,
-  };
+    public static readonly CHROMIUM_ROUTES = {
+        url: ChromiumRoute.URL,
+        html: ChromiumRoute.HTML,
+        markdown: ChromiumRoute.MARKDOWN,
+    };
 
-  public static readonly PDF_ENGINE_ROUTES = {
-    merge: PdfEngineRoute.MERGE,
-  };
+    public static readonly PDF_ENGINE_ROUTES = {
+        merge: PdfEngineRoute.MERGE,
+    };
 
-  public static readonly LIBRE_OFFICE_ROUTES = {
-    convert: LibreOfficeRoute.CONVERT,
-  };
+    public static readonly LIBRE_OFFICE_ROUTES = {
+        convert: LibreOfficeRoute.CONVERT,
+    };
 }

package/src/main.ts

@@ -1,3 +1,3 @@
-export { PdfFormat } from "./common/constants";
-export { HtmlConverter, MarkdownConverter, UrlConverter } from "./chromium";
-export { PDFEngine } from "./pdf-engines";
+export {PdfFormat} from "./common/constants";
+export {HtmlConverter, MarkdownConverter, UrlConverter} from "./chromium";
+export {PDFEngine} from "./pdf-engines";

package/src/pdf-engines/index.ts

@@ -1 +1 @@
-export { PDFEngine } from "./pdf.engine";
+export {PDFEngine} from "./pdf.engine";

package/src/pdf-engines/pdf.engine.ts

@@ -1,65 +1,65 @@
-import { PathLike, promises } from "fs";
+import {PathLike, promises} from "fs";
 import path from "path";
 
 import FormData from "form-data";
 
-import { Chromiumly } from "../main.config";
-import { GotenbergUtils, PdfFormat } from "../common";
-import { LibreOfficeUtils, PageProperties } from "../libre-office";
-import { PDFEngineUtils } from "./utils/engine.utils";
+import {Chromiumly} from "../main.config";
+import {GotenbergUtils, PdfFormat} from "../common";
+import {LibreOfficeUtils, PageProperties} from "../libre-office";
+import {PDFEngineUtils} from "./utils/engine.utils";
 
 export class PDFEngine {
-  public static async merge({ files }: { files: PathLike[] }): Promise<Buffer> {
-    const data = new FormData();
-    await PDFEngineUtils.injectFiles(files, data);
-    const endpoint = `${Chromiumly.GOTENBERG_ENDPOINT}/${Chromiumly.PDF_ENGINES_PATH}/${Chromiumly.PDF_ENGINE_ROUTES.merge}`;
-    return GotenbergUtils.fetch(endpoint, data);
-  }
+    public static async merge({files}: { files: PathLike[] }): Promise<Buffer> {
+        const data = new FormData();
+        await PDFEngineUtils.addFiles(files, data);
+        const endpoint = `${Chromiumly.GOTENBERG_ENDPOINT}/${Chromiumly.PDF_ENGINES_PATH}/${Chromiumly.PDF_ENGINE_ROUTES.merge}`;
+        return GotenbergUtils.fetch(endpoint, data);
+    }
 
-  public static async convert({
-    files,
-    properties,
-    pdfFormat,
-    pdfUA,
-    merge,
-  }: {
-    files: PathLike[];
-    properties?: PageProperties;
-    pdfFormat?: PdfFormat;
-    pdfUA?: boolean;
-    merge?: boolean;
-  }): Promise<Buffer> {
-    const data = new FormData();
+    public static async convert({
+                                    files,
+                                    properties,
+                                    pdfFormat,
+                                    pdfUA,
+                                    merge,
+                                }: {
+        files: PathLike[];
+        properties?: PageProperties;
+        pdfFormat?: PdfFormat;
+        pdfUA?: boolean;
+        merge?: boolean;
+    }): Promise<Buffer> {
+        const data = new FormData();
 
-    if (pdfFormat) {
-      data.append("pdfa", pdfFormat);
-    }
+        if (pdfFormat) {
+            data.append("pdfa", pdfFormat);
+        }
 
-    if (pdfUA) {
-      data.append("pdfUA", String(pdfUA));
-    }
+        if (pdfUA) {
+            data.append("pdfUA", String(pdfUA));
+        }
 
-    if (merge) {
-      data.append("merge", String(merge));
-    }
+        if (merge) {
+            data.append("merge", String(merge));
+        }
 
-    if (properties) {
-      LibreOfficeUtils.injectPageProperties(data, properties);
-    }
+        if (properties) {
+            LibreOfficeUtils.addPageProperties(data, properties);
+        }
 
-    await LibreOfficeUtils.injectFiles(files, data);
+        await LibreOfficeUtils.addFiles(files, data);
 
-    const endpoint = `${Chromiumly.GOTENBERG_ENDPOINT}/${Chromiumly.LIBRE_OFFICE_PATH}/${Chromiumly.LIBRE_OFFICE_ROUTES.convert}`;
+        const endpoint = `${Chromiumly.GOTENBERG_ENDPOINT}/${Chromiumly.LIBRE_OFFICE_PATH}/${Chromiumly.LIBRE_OFFICE_ROUTES.convert}`;
 
-    return GotenbergUtils.fetch(endpoint, data);
-  }
+        return GotenbergUtils.fetch(endpoint, data);
+    }
 
-  public static async generate(
-    filename: string,
-    buffer: Buffer
-  ): Promise<void> {
-    const __generated__ = path.resolve(process.cwd(), "__generated__");
-    await promises.mkdir(path.resolve(__generated__), { recursive: true });
-    await promises.writeFile(path.resolve(__generated__, filename), buffer);
-  }
+    public static async generate(
+        filename: string,
+        buffer: Buffer
+    ): Promise<void> {
+        const __generated__ = path.resolve(process.cwd(), "__generated__");
+        await promises.mkdir(path.resolve(__generated__), {recursive: true});
+        await promises.writeFile(path.resolve(__generated__, filename), buffer);
+    }
 }

package/src/pdf-engines/tests/pdf.engine.test.ts

@@ -1,123 +1,123 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { createReadStream, promises } from "fs";
+import {createReadStream, promises} from "fs";
 import FormData from "form-data";
 import fs from "fs/promises";
 import fetch from "node-fetch";
 import path from "path";
 
-import { PdfFormat } from "../../common";
-import { PDFEngine } from "../pdf.engine";
+import {PdfFormat} from "../../common";
+import {PDFEngine} from "../pdf.engine";
 
-const { Response } = jest.requireActual("node-fetch");
+const {Response} = jest.requireActual("node-fetch");
 jest.mock("node-fetch", () => jest.fn());
 
 describe("PDFEngine", () => {
-  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()
-      .mockImplementation((file) => file);
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  describe("convert", () => {
-    describe("when no properties are passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await PDFEngine.convert({
-          files: ["path/to/file.docx", "path/to/file.bib"],
-        });
-        expect(buffer).toEqual(Buffer.from("content"));
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-      });
+    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()
+            .mockImplementation((file) => file);
+    });
+
+    afterEach(() => {
+        jest.resetAllMocks();
     });
 
-    describe("when properties are passed", () => {
-      it("should return a buffer", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        mockFetch.mockResolvedValue(new Response("content"));
-        const buffer = await PDFEngine.convert({
-          files: ["path/to/file.docx", "path/to/file.bib"],
-          properties: { landscape: true },
-          pdfFormat: PdfFormat.A_1a,
-          pdfUA: true,
-          merge: true,
+    describe("convert", () => {
+        describe("when no properties are passed", () => {
+            it("should return a buffer", async () => {
+                mockPromisesAccess.mockResolvedValue();
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await PDFEngine.convert({
+                    files: ["path/to/file.docx", "path/to/file.bib"],
+                });
+                expect(buffer).toEqual(Buffer.from("content"));
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+            });
+        });
+
+        describe("when properties are passed", () => {
+            it("should return a buffer", async () => {
+                mockPromisesAccess.mockResolvedValue();
+                mockFetch.mockResolvedValue(new Response("content"));
+                const buffer = await PDFEngine.convert({
+                    files: ["path/to/file.docx", "path/to/file.bib"],
+                    properties: {landscape: true},
+                    pdfFormat: PdfFormat.A_1a,
+                    pdfUA: true,
+                    merge: true,
+                });
+                expect(buffer).toEqual(Buffer.from("content"));
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(6);
+            });
         });
-        expect(buffer).toEqual(Buffer.from("content"));
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(6);
-      });
     });
-  });
-
-  describe("merge", () => {
-    it("should return a buffer", async () => {
-      mockPromisesAccess.mockResolvedValue();
-      mockFetch.mockResolvedValue(new Response("content"));
-      const buffer = await PDFEngine.merge({
-        files: ["path/to/file.pdf", "path/to/another-file.pdf"],
-      });
-      expect(buffer).toEqual(Buffer.from("content"));
-      expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+
+    describe("merge", () => {
+        it("should return a buffer", async () => {
+            mockPromisesAccess.mockResolvedValue();
+            mockFetch.mockResolvedValue(new Response("content"));
+            const buffer = await PDFEngine.merge({
+                files: ["path/to/file.pdf", "path/to/another-file.pdf"],
+            });
+            expect(buffer).toEqual(Buffer.from("content"));
+            expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+        });
     });
-  });
 
-  describe("generate", () => {
-    const mockFilename = "test.pdf";
-    const mockBuffer = Buffer.from("mock pdf content");
+    describe("generate", () => {
+        const mockFilename = "test.pdf";
+        const mockBuffer = Buffer.from("mock pdf content");
 
-    afterAll(() => {
-      jest.restoreAllMocks();
-    });
+        afterAll(() => {
+            jest.restoreAllMocks();
+        });
 
-    it("should generate a PDF file", async () => {
-      const mockGeneratedDir = path.join(process.cwd(), "__generated__");
-      const mockGeneratedFilePath = path.join(mockGeneratedDir, mockFilename);
+        it("should generate a PDF file", async () => {
+            const mockGeneratedDir = path.join(process.cwd(), "__generated__");
+            const mockGeneratedFilePath = path.join(mockGeneratedDir, mockFilename);
 
-      const mockPromisesMkDir = jest
-        .spyOn(fs, "mkdir")
-        .mockResolvedValueOnce(mockGeneratedDir);
+            const mockPromisesMkDir = jest
+                .spyOn(fs, "mkdir")
+                .mockResolvedValueOnce(mockGeneratedDir);
 
-      const mockPromisesWriteFile = jest
-        .spyOn(fs, "writeFile")
-        .mockResolvedValueOnce();
+            const mockPromisesWriteFile = jest
+                .spyOn(fs, "writeFile")
+                .mockResolvedValueOnce();
 
-      await PDFEngine.generate(mockFilename, mockBuffer);
+            await PDFEngine.generate(mockFilename, mockBuffer);
 
-      expect(mockPromisesMkDir).toHaveBeenCalledWith(mockGeneratedDir, {
-        recursive: true,
-      });
+            expect(mockPromisesMkDir).toHaveBeenCalledWith(mockGeneratedDir, {
+                recursive: true,
+            });
 
-      expect(mockPromisesWriteFile).toHaveBeenCalledWith(
-        mockGeneratedFilePath,
-        mockBuffer
-      );
-    });
+            expect(mockPromisesWriteFile).toHaveBeenCalledWith(
+                mockGeneratedFilePath,
+                mockBuffer
+            );
+        });
 
-    it("should handle errors during file generation", async () => {
-      jest
-        .spyOn(fs, "mkdir")
-        .mockRejectedValueOnce(new Error("Cannot create directory"));
+        it("should handle errors during file generation", async () => {
+            jest
+                .spyOn(fs, "mkdir")
+                .mockRejectedValueOnce(new Error("Cannot create directory"));
 
-      await expect(
-        PDFEngine.generate(mockFilename, mockBuffer)
-      ).rejects.toThrow("Cannot create directory");
-    });
+            await expect(
+                PDFEngine.generate(mockFilename, mockBuffer)
+            ).rejects.toThrow("Cannot create directory");
+        });
 
-    it("should handle errors during file writing", async () => {
-      jest
-        .spyOn(fs, "writeFile")
-        .mockRejectedValueOnce(new Error("Failed to write to file"));
+        it("should handle errors during file writing", async () => {
+            jest
+                .spyOn(fs, "writeFile")
+                .mockRejectedValueOnce(new Error("Failed to write to file"));
 
-      await expect(
-        PDFEngine.generate(mockFilename, mockBuffer)
-      ).rejects.toThrow("Failed to write to file");
+            await expect(
+                PDFEngine.generate(mockFilename, mockBuffer)
+            ).rejects.toThrow("Failed to write to file");
+        });
     });
-  });
 });

package/src/pdf-engines/utils/engine.utils.ts

@@ -1,19 +1,27 @@
-import { constants, createReadStream, PathLike, promises } from "fs";
+import {constants, createReadStream, promises, ReadStream} from "fs";
 import path from "path";
 
 import FormData from "form-data";
+import {PathLikeOrReadStream} from "../../common";
 
 export class PDFEngineUtils {
-  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 (extension === ".pdf") {
-        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 (extension === ".pdf") {
+                    data.append(filename, createReadStream(file));
+                } else {
+                    throw new Error(`${extension} is not supported`);
+                }
+            }
+        }
     }
-  }
 }

package/src/pdf-engines/utils/tests/engine.utils.test.ts

@@ -1,60 +1,72 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-import { createReadStream, promises } from "fs";
+import {createReadStream, promises} from "fs";
 import FormData from "form-data";
 
-import { PDFEngineUtils } from "./../engine.utils";
+import {PDFEngineUtils} from "../engine.utils";
 
 describe("PDFEngineUtils", () => {
-  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 PDFEngineUtils.injectFiles(
-          ["path/to/file.pdf", "path/to/another-file.pdf"],
-          data
-        );
-        expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
-      });
+    beforeEach(() => {
+        (createReadStream as jest.Mock) = jest
+            .fn()
+            .mockImplementation((file) => file);
     });
 
-    describe("when one of the files is not PDF", () => {
-      it("should throw an error", async () => {
-        mockPromisesAccess.mockResolvedValue();
-        await expect(() =>
-          PDFEngineUtils.injectFiles(
-            ["path/to/file.docx", "path/to/file.pdf"],
-            data
-          )
-        ).rejects.toThrow(".docx 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(() =>
-          PDFEngineUtils.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 PDFEngineUtils.addFiles(
+                        ["path/to/file.pdf", "path/to/another-file.pdf"],
+                        data
+                    );
+                    expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                });
+            })
+            describe("when files parameter contains a buffer", () => {
+                it("should append each file to data", async () => {
+                    mockPromisesAccess.mockResolvedValue();
+                    await PDFEngineUtils.addFiles(
+                        [Buffer.from("data"), "path/to/another-file.pdf"],
+                        data
+                    );
+                    expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                });
+            })
+        });
+
+        describe("when one of the files is not PDF", () => {
+            it("should throw an error", async () => {
+                mockPromisesAccess.mockResolvedValue();
+                await expect(() =>
+                    PDFEngineUtils.addFiles(
+                        ["path/to/file.docx", "path/to/file.pdf"],
+                        data
+                    )
+                ).rejects.toThrow(".docx 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(() =>
+                    PDFEngineUtils.addFiles(
+                        ["path/to/file.pdf", "path/to/another-file.pdf"],
+                        data
+                    )
+                ).rejects.toThrow(errorMessage);
+            });
+        });
     });
-  });
 });