chromiumly 2.6.0 → 2.8.0

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

@@ -0,0 +1,284 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import FormData from 'form-data';
+import { ScreenshotUtils } from './../screenshot.utils';
+
+describe('GotenbergUtils', () => {
+    const mockFormDataAppend = jest.spyOn(FormData.prototype, 'append');
+    const data = new FormData();
+
+    afterEach(() => {
+        jest.resetAllMocks();
+    });
+
+    describe('addImageProperties', () => {
+        describe('Image format', () => {
+            describe('when format parameter is set', () => {
+                it('should append format to data', () => {
+                    ScreenshotUtils.addImageProperties(data, {
+                        format: 'png'
+                    });
+                    expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                    expect(data.append).toHaveBeenCalledWith('format', 'png');
+                });
+            });
+        });
+
+        describe('Image background', () => {
+            describe('when omitBackground parameter is set', () => {
+                it('should append omitBackground to data', () => {
+                    ScreenshotUtils.addImageProperties(data, {
+                        format: 'png',
+                        omitBackground: true
+                    });
+                    expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                    expect(data.append).toHaveBeenCalledWith('format', 'png');
+                    expect(data.append).toHaveBeenNthCalledWith(
+                        2,
+                        'omitBackground',
+                        'true'
+                    );
+                });
+            });
+        });
+
+        describe('Image quality', () => {
+            describe('when omitBackground parameter is set', () => {
+                it('should append omitBackground to data', () => {
+                    ScreenshotUtils.addImageProperties(data, {
+                        format: 'jpeg',
+                        quality: 50
+                    });
+                    expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
+                    expect(data.append).toHaveBeenCalledWith('format', 'jpeg');
+                    expect(data.append).toHaveBeenNthCalledWith(
+                        2,
+                        'quality',
+                        50
+                    );
+                });
+            });
+        });
+    });
+
+    describe('customize', () => {
+        describe('when no option is passed', () => {
+            it('should not append anything', async () => {
+                await ScreenshotUtils.customize(data, {});
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(0);
+            });
+        });
+
+        describe('when header parameter is passed', () => {
+            it('should append header', async () => {
+                await ScreenshotUtils.customize(data, {
+                    header: Buffer.from('header')
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith(
+                    'files',
+                    Buffer.from('header'),
+                    'header.html'
+                );
+            });
+        });
+
+        describe('when footer parameter is passed', () => {
+            it('should append footer', async () => {
+                await ScreenshotUtils.customize(data, {
+                    footer: Buffer.from('footer')
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith(
+                    'files',
+                    Buffer.from('footer'),
+                    'footer.html'
+                );
+            });
+        });
+
+        describe('when emulatedMediaType parameter is passed', () => {
+            it('should append emulatedMediaType', async () => {
+                await ScreenshotUtils.customize(data, {
+                    emulatedMediaType: 'screen'
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith(
+                    'emulatedMediaType',
+                    'screen'
+                );
+            });
+        });
+
+        describe('when waitDelay parameter is passed', () => {
+            it('should append waitDelay', async () => {
+                await ScreenshotUtils.customize(data, {
+                    waitDelay: '5s'
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith('waitDelay', '5s');
+            });
+        });
+
+        describe('when waitForExpression parameter is passed', () => {
+            it('should append waitForExpression', async () => {
+                await ScreenshotUtils.customize(data, {
+                    waitForExpression: "document.readyState === 'complete'"
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith(
+                    'waitForExpression',
+                    "document.readyState === 'complete'"
+                );
+            });
+        });
+
+        describe('when extraHttpHeaders parameter is passed', () => {
+            it('should append extraHttpHeaders', async () => {
+                const extraHttpHeaders = {
+                    'X-Custom-Header': 'value'
+                };
+
+                await ScreenshotUtils.customize(data, {
+                    extraHttpHeaders
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith(
+                    'extraHttpHeaders',
+                    JSON.stringify(extraHttpHeaders)
+                );
+            });
+        });
+
+        describe('when failOnConsoleExceptions parameter is passed', () => {
+            it('should append failOnConsoleExceptions', async () => {
+                await ScreenshotUtils.customize(data, {
+                    failOnConsoleExceptions: true
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith(
+                    'failOnConsoleExceptions',
+                    'true'
+                );
+            });
+        });
+
+        describe('when failOnHttpStatusCodes parameter is passed', () => {
+            it('should append failOnHttpStatusCodes', async () => {
+                await ScreenshotUtils.customize(data, {
+                    failOnHttpStatusCodes: [499, 599]
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith(
+                    'failOnHttpStatusCodes',
+                    JSON.stringify([499, 599])
+                );
+            });
+        });
+
+        describe('when skipNetworkIdleEvent parameter is passed', () => {
+            it('should append skipNetworkIdleEvent', async () => {
+                await ScreenshotUtils.customize(data, {
+                    skipNetworkIdleEvent: true
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith(
+                    'skipNetworkIdleEvent',
+                    'true'
+                );
+            });
+        });
+
+        describe('when optimizeForSpeed parameter is passed', () => {
+            it('should append optimizeForSpeed', async () => {
+                await ScreenshotUtils.customize(data, {
+                    optimizeForSpeed: true
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith(
+                    'optimizeForSpeed',
+                    'true'
+                );
+            });
+        });
+
+        describe('when all options are passed', () => {
+            it('should append all options', async () => {
+                await ScreenshotUtils.customize(data, {
+                    header: Buffer.from('header.html'),
+                    footer: Buffer.from('footer.html'),
+                    emulatedMediaType: 'screen',
+                    failOnHttpStatusCodes: [499, 599],
+                    skipNetworkIdleEvent: true,
+                    failOnConsoleExceptions: true,
+                    properties: {
+                        format: 'jpeg',
+                        quality: 50
+                    },
+                    waitDelay: '5s',
+                    waitForExpression: "document.readyState === 'complete'",
+                    extraHttpHeaders: { 'X-Custom-Header': 'value' },
+                    optimizeForSpeed: true
+                });
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(12);
+                expect(data.append).toHaveBeenNthCalledWith(
+                    1,
+                    'files',
+                    Buffer.from('header.html'),
+                    'header.html'
+                );
+                expect(data.append).toHaveBeenNthCalledWith(
+                    2,
+                    'files',
+                    Buffer.from('footer.html'),
+                    'footer.html'
+                );
+                expect(data.append).toHaveBeenNthCalledWith(
+                    3,
+                    'emulatedMediaType',
+                    'screen'
+                );
+                expect(data.append).toHaveBeenNthCalledWith(
+                    4,
+                    'format',
+                    'jpeg'
+                );
+                expect(data.append).toHaveBeenNthCalledWith(5, 'quality', 50);
+                expect(data.append).toHaveBeenNthCalledWith(
+                    6,
+                    'waitDelay',
+                    '5s'
+                );
+                expect(data.append).toHaveBeenNthCalledWith(
+                    7,
+                    'waitForExpression',
+                    "document.readyState === 'complete'"
+                );
+                expect(data.append).toHaveBeenNthCalledWith(
+                    8,
+                    'extraHttpHeaders',
+                    JSON.stringify({ 'X-Custom-Header': 'value' })
+                );
+                expect(data.append).toHaveBeenNthCalledWith(
+                    9,
+                    'failOnHttpStatusCodes',
+                    JSON.stringify([499, 599])
+                );
+                expect(data.append).toHaveBeenNthCalledWith(
+                    10,
+                    'failOnConsoleExceptions',
+                    'true'
+                );
+                expect(data.append).toHaveBeenNthCalledWith(
+                    11,
+                    'skipNetworkIdleEvent',
+                    'true'
+                );
+                expect(data.append).toHaveBeenNthCalledWith(
+                    12,
+                    'optimizeForSpeed',
+                    'true'
+                );
+            });
+        });
+    });
+});

package/src/common/constants.ts

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

package/src/common/gotenberg.utils.ts

@@ -1,5 +1,7 @@
-import FormData from "form-data";
-import fetch from "node-fetch";
+import { constants, createReadStream, ReadStream, promises } from 'fs';
+import FormData from 'form-data';
+import fetch from 'node-fetch';
+import { PathLikeOrReadStream } from './types';
 
 /**
  * Utility class for common tasks related to the Gotenberg service.
@@ -12,7 +14,10 @@ export class GotenbergUtils {
      * @param {string} message - The error message to throw if the condition is false.
      * @throws {Error} Throws an error with the specified message if the condition is false.
      */
-    public static assert(condition: boolean, message: string): asserts condition {
+    public static assert(
+        condition: boolean,
+        message: string
+    ): asserts condition {
         if (!condition) {
             throw new Error(message);
         }
@@ -26,13 +31,16 @@ export class GotenbergUtils {
      * @returns {Promise<Buffer>} A Promise that resolves to the response body as a Buffer.
      * @throws {Error} Throws an error if the HTTP response status is not OK.
      */
-    public static async fetch(endpoint: string, data: FormData): Promise<Buffer> {
+    public static async fetch(
+        endpoint: string,
+        data: FormData
+    ): Promise<Buffer> {
         const response = await fetch(endpoint, {
-            method: "post",
+            method: 'post',
             body: data,
             headers: {
-                ...data.getHeaders(),
-            },
+                ...data.getHeaders()
+            }
         });
 
         if (!response.ok) {
@@ -41,4 +49,27 @@ export class GotenbergUtils {
 
         return response.buffer();
     }
-}
+
+    /**
+     * Adds a file to the FormData object.
+     *
+     * @param {FormData} data - The FormData object to which the file will be added.
+     * @param {PathLikeOrReadStream} file - The file to be added (either a PathLike or a ReadStream).
+     * @param {string} name - The name to be used for the file in the FormData.
+     * @returns {Promise<void>} A Promise that resolves once the file has been added.
+     */
+    public static async addFile(
+        data: FormData,
+        file: PathLikeOrReadStream,
+        name: string
+    ) {
+        if (Buffer.isBuffer(file)) {
+            data.append('files', file, name);
+        } else if (file instanceof ReadStream) {
+            data.append('files', file, name);
+        } else {
+            await promises.access(file, constants.R_OK);
+            data.append('files', createReadStream(file), name);
+        }
+    }
+}

package/src/common/index.ts

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

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

@@ -1,71 +1,124 @@
-import fetch from "node-fetch";
-import FormData from "form-data";
+import { createReadStream, promises } from 'fs';
+import path from 'path';
+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());
+jest.mock('node-fetch', () => jest.fn());
+
+describe('GotenbergUtils', () => {
+    const mockFormDataAppend = jest.spyOn(FormData.prototype, 'append');
+    const data = new FormData();
 
-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('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 condition is false', () => {
+            it('should return error message', () => {
+                expect(() =>
+                    GotenbergUtils.assert(false, errorMessage)
+                ).toThrow(errorMessage);
             });
         });
     });
 
-    describe("fetch", () => {
+    describe('fetch', () => {
         const mockFetch = fetch as jest.MockedFunction<typeof fetch>;
         const data = new FormData();
-        const endpoint = "http://localhost:3000/forms/chromium/convert/html";
+        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"));
+        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"));
+                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 () => {
+        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));
+                        '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 () => {
+            describe('when there is an unknown error', () => {
+                it('should throw an error', async () => {
                     mockFetch.mockResolvedValueOnce(
                         new Response(
                             {},
-                            {status: 500, statusText: "Internal server error"}
+                            {
+                                status: 500,
+                                statusText: 'Internal server error'
+                            }
                         )
                     );
                     await expect(() =>
                         GotenbergUtils.fetch(endpoint, data)
-                    ).rejects.toThrow("500 Internal server error");
+                    ).rejects.toThrow('500 Internal server error');
                 });
             });
         });
     });
+
+    describe('addFile', () => {
+        const mockPromisesAccess = jest.spyOn(promises, 'access');
+        const __tmp__ = path.resolve(process.cwd(), '__tmp__');
+        const filePath = path.resolve(__tmp__, 'file.html');
+
+        beforeAll(async () => {
+            mockPromisesAccess.mockResolvedValue();
+            await promises.mkdir(path.resolve(__tmp__), { recursive: true });
+            await promises.writeFile(filePath, 'data');
+        });
+
+        afterAll(async () => {
+            await promises.rm(path.resolve(__tmp__), { recursive: true });
+        });
+
+        describe('when file is passed as read stream', () => {
+            it('should append file to data', async () => {
+                const file = createReadStream(filePath);
+                await GotenbergUtils.addFile(data, file, 'file');
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith('files', file, 'file');
+            });
+        });
+
+        describe('when file is passed as path', () => {
+            it('should append file to data', async () => {
+                await GotenbergUtils.addFile(data, filePath, 'file');
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+            });
+        });
+
+        describe('when file is passed as buffer', () => {
+            it('should append file to data', async () => {
+                const file = Buffer.from('data');
+                await GotenbergUtils.addFile(data, file, 'file');
+                expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
+                expect(data.append).toHaveBeenCalledWith('files', file, 'file');
+            });
+        });
+    });
 });

package/src/common/types.ts

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

package/src/gotenberg.ts

@@ -1,18 +1,18 @@
-process.env.SUPPRESS_NO_CONFIG_WARNING = "y";
+process.env.SUPPRESS_NO_CONFIG_WARNING = 'y';
 
-import * as dotenv from "dotenv";
-import * as path from "path";
-import config from "config";
+import * as dotenv from 'dotenv';
+import * as path from 'path';
+import config from 'config';
 
 // Load endpoint from environment-specific file (e.g., .env.development)
 const envFile = `.env.${process.env.NODE_ENV}`;
-const envFileFallback = ".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) });
 }
 
 /**
@@ -25,6 +25,6 @@ export class Gotenberg {
      * @type {string}
      */
     public static endpoint: string =
-        process.env.GOTENBERG_ENDPOINT || config.get<string>("gotenberg.endpoint");
+        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';