chromiumly 2.5.1 → 2.7.0

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,69 +1,76 @@
-import fetch from "node-fetch";
-import FormData from "form-data";
+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", () => {
+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');
                 });
             });
         });

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';

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

@@ -1,78 +1,82 @@
 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',
+    'pages',
+    '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',
+    'odg',
+    'dotx',
+    'xltx'
 ];

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

@@ -1,13 +1,13 @@
-import {constants, createReadStream, promises, ReadStream} from "fs";
-import path from "path";
+import { constants, createReadStream, promises, ReadStream } from 'fs';
+import path from 'path';
 
-import {fromStream, fromBuffer} from "file-type";
+import { fromStream, fromBuffer } from 'file-type';
 
-import FormData from "form-data";
+import FormData from 'form-data';
 
-import {GotenbergUtils, PathLikeOrReadStream} 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';
 
 /**
  * Utility class for handling common tasks related to LibreOffice conversions.
@@ -20,7 +20,10 @@ export class LibreOfficeUtils {
      * @param {FormData} data - The FormData object to which files will be added.
      * @throws {Error} Throws an error if the file extension is not supported.
      */
-    public static async addFiles(files: PathLikeOrReadStream[], data: FormData) {
+    public static async addFiles(
+        files: PathLikeOrReadStream[],
+        data: FormData
+    ) {
         for (const [key, value] of files.entries()) {
             let file = value;
             let fileInfo;
@@ -32,18 +35,18 @@ export class LibreOfficeUtils {
             } else {
                 await promises.access(value, constants.R_OK);
                 const filename = path.basename(value.toString());
-                fileInfo = {ext: path.extname(filename).slice(1)};
-                file = createReadStream(value)
+                fileInfo = { ext: path.extname(filename).slice(1) };
+                file = createReadStream(value);
             }
 
             if (!fileInfo) {
-                throw new Error("File type could not be determined");
+                throw new Error('File type could not be determined');
             }
 
             const extension = fileInfo.ext;
 
             if (LIBRE_OFFICE_EXTENSIONS.includes(extension)) {
-                data.append("files", file, `${key}.${extension}`);
+                data.append('files', file, `${key}.${extension}`);
             } else {
                 throw new Error(`${extension} is not supported`);
             }
@@ -61,20 +64,20 @@ export class LibreOfficeUtils {
         pageProperties: PageProperties
     ): void {
         if (pageProperties.landscape) {
-            data.append("landscape", String(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"
+                    pageProperties.nativePageRanges.to > 0 &&
+                    pageProperties.nativePageRanges.to >=
+                        pageProperties.nativePageRanges.from,
+                'page ranges syntax error'
             );
 
             data.append(
-                "nativePageRanges",
+                'nativePageRanges',
                 `${pageProperties.nativePageRanges.from}-${pageProperties.nativePageRanges.to}`
             );
         }

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

@@ -1,14 +1,14 @@
 // 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";
-import FileType from "file-type";
+import FormData from 'form-data';
+import FileType from 'file-type';
 
-describe("LibreOfficeUtils", () => {
-    const mockPromisesAccess = jest.spyOn(promises, "access");
-    const mockFormDataAppend = jest.spyOn(FormData.prototype, "append");
-    const mockFromBuffer = jest.spyOn(FileType, "fromBuffer");
+describe('LibreOfficeUtils', () => {
+    const mockPromisesAccess = jest.spyOn(promises, 'access');
+    const mockFormDataAppend = jest.spyOn(FormData.prototype, 'append');
+    const mockFromBuffer = jest.spyOn(FileType, 'fromBuffer');
 
     const data = new FormData();
 
@@ -22,67 +22,70 @@ describe("LibreOfficeUtils", () => {
         jest.resetAllMocks();
     });
 
-    describe("addFiles", () => {
-        describe("when files exist", () => {
-            describe("when files parameter contains paths", () => {
-                it("should append each file to data", async () => {
+    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"],
+                        ['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 () => {
+            });
+            describe('when files parameter contains a buffer', () => {
+                it('should append each file to data', async () => {
                     mockPromisesAccess.mockResolvedValueOnce();
                     mockFromBuffer.mockResolvedValueOnce({
-                        ext: "docx",
-                        mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-                    })
+                        ext: 'docx',
+                        mime: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+                    });
                     await LibreOfficeUtils.addFiles(
-                        [Buffer.from("data"), "path/to/file.bib"],
+                        [Buffer.from('data'), 'path/to/file.bib'],
                         data
                     );
                     expect(mockFormDataAppend).toHaveBeenCalledTimes(2);
                 });
-            })
+            });
         });
 
-        describe("when one of the files has undetermined format", () => {
-            it("should throw an error", async () => {
+        describe('when one of the files has undetermined format', () => {
+            it('should throw an error', async () => {
                 mockPromisesAccess.mockResolvedValueOnce();
-                mockFromBuffer.mockResolvedValueOnce(undefined
-                )
+                mockFromBuffer.mockResolvedValueOnce(undefined);
 
-                await expect(LibreOfficeUtils.addFiles(
-                    [Buffer.from("data"), "path/to/file.bib"],
-                    data
-                )).rejects.toThrow("File type could not be determined");
+                await expect(
+                    LibreOfficeUtils.addFiles(
+                        [Buffer.from('data'), 'path/to/file.bib'],
+                        data
+                    )
+                ).rejects.toThrow('File type could not be determined');
             });
-        })
+        });
 
-        describe("when one of the files has unsupported format", () => {
-            it("should throw an error", async () => {
+        describe('when one of the files has unsupported format', () => {
+            it('should throw an error', async () => {
                 mockPromisesAccess.mockResolvedValueOnce();
                 await expect(() =>
                     LibreOfficeUtils.addFiles(
-                        ["path/to/file.rar", "path/to/file.pdf"],
+                        ['path/to/file.rar', 'path/to/file.pdf'],
                         data
                     )
-                ).rejects.toThrow("rar is not supported");
+                ).rejects.toThrow('rar is not supported');
             });
         });
 
-        describe("when one of the files does not exist", () => {
-            it("should throw an error", async () => {
+        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.mockRejectedValueOnce(new Error(errorMessage));
+                mockPromisesAccess.mockRejectedValueOnce(
+                    new Error(errorMessage)
+                );
                 await expect(() =>
                     LibreOfficeUtils.addFiles(
-                        ["path/to/file.pdf", "path/to/another-file.pdf"],
+                        ['path/to/file.pdf', 'path/to/another-file.pdf'],
                         data
                     )
                 ).rejects.toThrow(errorMessage);
@@ -90,27 +93,33 @@ describe("LibreOfficeUtils", () => {
         });
     });
 
-    describe("addPageProperties", () => {
-        describe("Page landscape", () => {
-            describe("when landscape parameter is set", () => {
-                it("should append landscape to data", () => {
+    describe('addPageProperties', () => {
+        describe('Page landscape', () => {
+            describe('when landscape parameter is set', () => {
+                it('should append landscape to data', () => {
                     LibreOfficeUtils.addPageProperties(data, {
-                        landscape: true,
+                        landscape: true
                     });
                     expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
-                    expect(data.append).toHaveBeenCalledWith("landscape", "true");
+                    expect(data.append).toHaveBeenCalledWith(
+                        'landscape',
+                        'true'
+                    );
                 });
             });
         });
 
-        describe("Page ranges", () => {
-            describe("when nativePageRanges is valid", () => {
-                it("should append nativePageRanges to data", () => {
+        describe('Page ranges', () => {
+            describe('when nativePageRanges is valid', () => {
+                it('should append nativePageRanges to data', () => {
                     LibreOfficeUtils.addPageProperties(data, {
-                        nativePageRanges: {from: 1, to: 6},
+                        nativePageRanges: { from: 1, to: 6 }
                     });
                     expect(mockFormDataAppend).toHaveBeenCalledTimes(1);
-                    expect(data.append).toHaveBeenCalledWith("nativePageRanges", "1-6");
+                    expect(data.append).toHaveBeenCalledWith(
+                        'nativePageRanges',
+                        '1-6'
+                    );
                 });
             });
         });