chromiumly 2.4.0 → 2.5.1

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,37 @@
-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";
 
+/**
+ * Utility class for handling common tasks related to PDF engine operations.
+ */
 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`);
-      }
+    /**
+     * Adds PDF files to the FormData object.
+     *
+     * @param {PathLikeOrReadStream[]} files - An array of PDF files to be added to the FormData.
+     * @param {FormData} data - The FormData object to which PDF files will be added.
+     * @throws {Error} Throws an error if the file extension is not supported.
+     */
+    public static async addFiles(files: PathLikeOrReadStream[], data: FormData) {
+        for (const [key, file] of files.entries()) {
+            const filename = `file${key}.pdf`
+            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);
+            });
+        });
     });
-  });
 });