n8n-nodes-h2i 1.0.0

package/dist/nodes/DavixH2I/DavixH2I.node.js

@@ -0,0 +1,572 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DavixH2I = void 0;
+const GenericFunctions_1 = require("./GenericFunctions");
+function toBoolString(v) {
+    if (typeof v === 'boolean')
+        return v ? 'true' : 'false';
+    if (typeof v === 'number')
+        return v === 1 ? 'true' : 'false';
+    if (typeof v === 'string')
+        return v;
+    return 'false';
+}
+class DavixH2I {
+    description = {
+        displayName: 'Davix H2I',
+        name: 'davixH2I',
+        icon: 'file:davixH2I.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["resource"]}}',
+        description: 'Use Davix PixLab public API endpoints (H2I, Image, PDF, Tools).',
+        defaults: {
+            name: 'Davix H2I',
+        },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [{ name: 'davixH2IApi', required: true }],
+        properties: [
+            {
+                displayName: 'Resource',
+                name: 'resource',
+                type: 'options',
+                default: 'h2i',
+                options: [
+                    { name: 'H2I (HTML → Image)', value: 'h2i' },
+                    { name: 'Image (Transform / Export PDF)', value: 'image' },
+                    { name: 'PDF (Merge/Split/Compress/Convert)', value: 'pdf' },
+                    { name: 'Tools (Analyze Images)', value: 'tools' },
+                ],
+            },
+            // -------------------------
+            // H2I
+            // -------------------------
+            {
+                displayName: 'HTML',
+                name: 'html',
+                type: 'string',
+                default: '',
+                required: true,
+                typeOptions: { rows: 6 },
+                displayOptions: { show: { resource: ['h2i'] } },
+            },
+            {
+                displayName: 'CSS',
+                name: 'css',
+                type: 'string',
+                default: '',
+                typeOptions: { rows: 4 },
+                displayOptions: { show: { resource: ['h2i'] } },
+            },
+            {
+                displayName: 'Width',
+                name: 'width',
+                type: 'number',
+                default: 1000,
+                displayOptions: { show: { resource: ['h2i'] } },
+            },
+            {
+                displayName: 'Height',
+                name: 'height',
+                type: 'number',
+                default: 1500,
+                displayOptions: { show: { resource: ['h2i'] } },
+            },
+            {
+                displayName: 'Format',
+                name: 'format',
+                type: 'options',
+                default: 'png',
+                options: [
+                    { name: 'PNG', value: 'png' },
+                    { name: 'JPEG', value: 'jpeg' },
+                ],
+                displayOptions: { show: { resource: ['h2i'] } },
+            },
+            {
+                displayName: 'Download Result as Binary',
+                name: 'downloadBinary',
+                type: 'boolean',
+                default: false,
+                displayOptions: { show: { resource: ['h2i'] } },
+            },
+            {
+                displayName: 'Output Binary Property',
+                name: 'outputBinaryProperty',
+                type: 'string',
+                default: 'data',
+                displayOptions: { show: { resource: ['h2i'], downloadBinary: [true] } },
+            },
+            // -------------------------
+            // Image
+            // -------------------------
+            {
+                displayName: 'Input Binary Properties',
+                name: 'imageBinaryProps',
+                type: 'string',
+                default: 'data',
+                placeholder: 'data OR image1,image2',
+                description: 'Comma-separated binary property names from previous nodes (each will be sent as an `images` file).',
+                displayOptions: { show: { resource: ['image'] } },
+            },
+            {
+                displayName: 'Format',
+                name: 'imageFormat',
+                type: 'options',
+                default: 'webp',
+                options: [
+                    { name: 'JPEG', value: 'jpeg' },
+                    { name: 'PNG', value: 'png' },
+                    { name: 'WebP', value: 'webp' },
+                    { name: 'AVIF', value: 'avif' },
+                    { name: 'GIF', value: 'gif' },
+                    { name: 'SVG', value: 'svg' },
+                    { name: 'PDF', value: 'pdf' },
+                ],
+                displayOptions: { show: { resource: ['image'] } },
+            },
+            { displayName: 'Width', name: 'imageWidth', type: 'number', default: 0, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Height', name: 'imageHeight', type: 'number', default: 0, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Enlarge', name: 'enlarge', type: 'boolean', default: false, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Crop X', name: 'cropX', type: 'number', default: 0, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Crop Y', name: 'cropY', type: 'number', default: 0, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Crop Width', name: 'cropWidth', type: 'number', default: 0, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Crop Height', name: 'cropHeight', type: 'number', default: 0, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Rotate (degrees)', name: 'rotate', type: 'number', default: 0, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Flip Horizontal', name: 'flipH', type: 'boolean', default: false, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Flip Vertical', name: 'flipV', type: 'boolean', default: false, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Target Size (KB)', name: 'targetSizeKB', type: 'number', default: 0, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Quality', name: 'quality', type: 'number', default: 82, displayOptions: { show: { resource: ['image'] } } },
+            { displayName: 'Keep Metadata', name: 'keepMetadata', type: 'boolean', default: false, displayOptions: { show: { resource: ['image'] } } },
+            // PDF-only options
+            {
+                displayName: 'PDF Mode',
+                name: 'pdfMode',
+                type: 'options',
+                default: 'single',
+                options: [
+                    { name: 'Single', value: 'single' },
+                    { name: 'Multi', value: 'multi' },
+                ],
+                displayOptions: { show: { resource: ['image'], imageFormat: ['pdf'] } },
+            },
+            {
+                displayName: 'PDF Page Size',
+                name: 'pdfPageSize',
+                type: 'options',
+                default: 'auto',
+                options: [
+                    { name: 'Auto', value: 'auto' },
+                    { name: 'A4', value: 'a4' },
+                    { name: 'Letter', value: 'letter' },
+                ],
+                displayOptions: { show: { resource: ['image'], imageFormat: ['pdf'] } },
+            },
+            {
+                displayName: 'PDF Orientation',
+                name: 'pdfOrientation',
+                type: 'options',
+                default: 'portrait',
+                options: [
+                    { name: 'Portrait', value: 'portrait' },
+                    { name: 'Landscape', value: 'landscape' },
+                ],
+                displayOptions: { show: { resource: ['image'], imageFormat: ['pdf'] } },
+            },
+            {
+                displayName: 'PDF Margin',
+                name: 'pdfMargin',
+                type: 'number',
+                default: 0,
+                displayOptions: { show: { resource: ['image'], imageFormat: ['pdf'] } },
+            },
+            {
+                displayName: 'PDF Embed Format',
+                name: 'pdfEmbedFormat',
+                type: 'options',
+                default: 'png',
+                options: [
+                    { name: 'PNG', value: 'png' },
+                    { name: 'JPEG', value: 'jpeg' },
+                ],
+                displayOptions: { show: { resource: ['image'], imageFormat: ['pdf'] } },
+            },
+            {
+                displayName: 'PDF JPEG Quality',
+                name: 'pdfJpegQuality',
+                type: 'number',
+                default: 85,
+                displayOptions: { show: { resource: ['image'], imageFormat: ['pdf'] } },
+            },
+            {
+                displayName: 'Download Result(s) as Binary',
+                name: 'imageDownloadBinary',
+                type: 'boolean',
+                default: false,
+                displayOptions: { show: { resource: ['image'] } },
+            },
+            {
+                displayName: 'Output Binary Property',
+                name: 'imageOutputBinaryProperty',
+                type: 'string',
+                default: 'data',
+                displayOptions: { show: { resource: ['image'], imageDownloadBinary: [true] } },
+            },
+            // -------------------------
+            // PDF
+            // -------------------------
+            {
+                displayName: 'Action',
+                name: 'pdfAction',
+                type: 'options',
+                default: 'merge',
+                options: [
+                    { name: 'Merge', value: 'merge' },
+                    { name: 'Split', value: 'split' },
+                    { name: 'Compress', value: 'compress' },
+                    { name: 'To Images', value: 'to-images' },
+                    { name: 'Extract Images', value: 'extract-images' },
+                ],
+                displayOptions: { show: { resource: ['pdf'] } },
+            },
+            {
+                displayName: 'Input Binary Properties',
+                name: 'pdfBinaryProps',
+                type: 'string',
+                default: 'data',
+                placeholder: 'data OR pdf1,pdf2',
+                description: 'Comma-separated binary property names (each will be sent as a `files` PDF). For merge, provide multiple.',
+                displayOptions: { show: { resource: ['pdf'] } },
+            },
+            {
+                displayName: 'Sort By Name',
+                name: 'sortByName',
+                type: 'boolean',
+                default: false,
+                displayOptions: { show: { resource: ['pdf'], pdfAction: ['merge'] } },
+            },
+            {
+                displayName: 'Ranges',
+                name: 'ranges',
+                type: 'string',
+                default: '',
+                placeholder: '1-3,4-5',
+                displayOptions: { show: { resource: ['pdf'], pdfAction: ['split'] } },
+            },
+            {
+                displayName: 'Prefix',
+                name: 'prefix',
+                type: 'string',
+                default: 'split_',
+                displayOptions: { show: { resource: ['pdf'], pdfAction: ['split'] } },
+            },
+            {
+                displayName: 'Pages',
+                name: 'pages',
+                type: 'string',
+                default: 'all',
+                placeholder: 'all OR 1-3,5,7',
+                displayOptions: { show: { resource: ['pdf'], pdfAction: ['to-images', 'extract-images'] } },
+            },
+            {
+                displayName: 'To Format',
+                name: 'toFormat',
+                type: 'options',
+                default: 'png',
+                options: [
+                    { name: 'PNG', value: 'png' },
+                    { name: 'JPEG', value: 'jpeg' },
+                    { name: 'WebP', value: 'webp' },
+                ],
+                displayOptions: { show: { resource: ['pdf'], pdfAction: ['to-images'] } },
+            },
+            { displayName: 'Width', name: 'pdfWidth', type: 'number', default: 0, displayOptions: { show: { resource: ['pdf'], pdfAction: ['to-images'] } } },
+            { displayName: 'Height', name: 'pdfHeight', type: 'number', default: 0, displayOptions: { show: { resource: ['pdf'], pdfAction: ['to-images'] } } },
+            { displayName: 'DPI', name: 'dpi', type: 'number', default: 150, displayOptions: { show: { resource: ['pdf'], pdfAction: ['to-images'] } } },
+            {
+                displayName: 'Extract Image Format',
+                name: 'imageFormat',
+                type: 'options',
+                default: 'png',
+                options: [
+                    { name: 'PNG', value: 'png' },
+                    { name: 'JPEG', value: 'jpeg' },
+                    { name: 'WebP', value: 'webp' },
+                ],
+                displayOptions: { show: { resource: ['pdf'], pdfAction: ['extract-images'] } },
+            },
+            {
+                displayName: 'Download Result(s) as Binary',
+                name: 'pdfDownloadBinary',
+                type: 'boolean',
+                default: false,
+                displayOptions: { show: { resource: ['pdf'] } },
+            },
+            {
+                displayName: 'Output Binary Property',
+                name: 'pdfOutputBinaryProperty',
+                type: 'string',
+                default: 'data',
+                displayOptions: { show: { resource: ['pdf'], pdfDownloadBinary: [true] } },
+            },
+            // -------------------------
+            // Tools
+            // -------------------------
+            {
+                displayName: 'Input Binary Properties',
+                name: 'toolsBinaryProps',
+                type: 'string',
+                default: 'data',
+                placeholder: 'data OR img1,img2',
+                description: 'Comma-separated binary property names (each will be sent as an `images` file).',
+                displayOptions: { show: { resource: ['tools'] } },
+            },
+            {
+                displayName: 'Tools',
+                name: 'tools',
+                type: 'multiOptions',
+                default: ['metadata'],
+                options: [
+                    { name: 'Metadata', value: 'metadata' },
+                    { name: 'Colors', value: 'colors' },
+                    { name: 'Detect Format', value: 'detect-format' },
+                    { name: 'Orientation', value: 'orientation' },
+                    { name: 'Hash', value: 'hash' },
+                ],
+                displayOptions: { show: { resource: ['tools'] } },
+            },
+            { displayName: 'Include Raw EXIF', name: 'includeRawExif', type: 'boolean', default: false, displayOptions: { show: { resource: ['tools'] } } },
+            { displayName: 'Palette Size', name: 'paletteSize', type: 'number', default: 5, displayOptions: { show: { resource: ['tools'] } } },
+            {
+                displayName: 'Hash Type',
+                name: 'hashType',
+                type: 'options',
+                default: 'phash',
+                options: [
+                    { name: 'pHash', value: 'phash' },
+                    { name: 'MD5', value: 'md5' },
+                    { name: 'SHA1', value: 'sha1' },
+                ],
+                displayOptions: { show: { resource: ['tools'] } },
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const out = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            const resource = this.getNodeParameter('resource', itemIndex);
+            // ---- H2I (JSON)
+            if (resource === 'h2i') {
+                const body = {
+                    html: this.getNodeParameter('html', itemIndex),
+                    css: this.getNodeParameter('css', itemIndex),
+                    width: this.getNodeParameter('width', itemIndex),
+                    height: this.getNodeParameter('height', itemIndex),
+                    format: this.getNodeParameter('format', itemIndex),
+                };
+                const response = await GenericFunctions_1.davixRequest.call(this, {
+                    method: 'POST',
+                    url: '/v1/h2i',
+                    json: true,
+                    body,
+                });
+                const downloadBinary = this.getNodeParameter('downloadBinary', itemIndex);
+                if (downloadBinary && typeof response.url === 'string') {
+                    const binName = this.getNodeParameter('outputBinaryProperty', itemIndex);
+                    const dl = await GenericFunctions_1.downloadToBinary.call(this, response.url, `h2i.${body.format === 'jpeg' ? 'jpg' : 'png'}`);
+                    const binary = await this.helpers.prepareBinaryData(dl.data, dl.fileName, dl.mimeType);
+                    out.push({ json: response, binary: { [binName]: binary } });
+                }
+                else {
+                    out.push({ json: response });
+                }
+                continue;
+            }
+            // Helper to attach multiple binaries as files
+            const attachFiles = async (fieldName, propList, formData) => {
+                const names = propList.split(',').map((s) => s.trim()).filter(Boolean);
+                if (names.length === 0)
+                    throw new Error('No binary property names provided.');
+                for (const name of names) {
+                    const buffer = await this.helpers.getBinaryDataBuffer(itemIndex, name);
+                    const meta = items[itemIndex].binary?.[name];
+                    const fileName = meta?.fileName ?? `${fieldName}-${name}`;
+                    const mimeType = meta?.mimeType;
+                    // n8n request helper supports this shape for multipart file upload
+                    formData[fieldName] = formData[fieldName] || [];
+                    formData[fieldName].push({
+                        value: buffer,
+                        options: {
+                            filename: fileName,
+                            contentType: mimeType,
+                        },
+                    });
+                }
+            };
+            // ---- IMAGE (multipart)
+            if (resource === 'image') {
+                const imageBinaryProps = this.getNodeParameter('imageBinaryProps', itemIndex);
+                const format = this.getNodeParameter('imageFormat', itemIndex);
+                const formData = {};
+                await attachFiles('images', imageBinaryProps, formData);
+                // core params
+                formData.format = format;
+                const w = this.getNodeParameter('imageWidth', itemIndex);
+                const h = this.getNodeParameter('imageHeight', itemIndex);
+                if (w)
+                    formData.width = String(w);
+                if (h)
+                    formData.height = String(h);
+                formData.enlarge = toBoolString(this.getNodeParameter('enlarge', itemIndex));
+                formData.rotate = String(this.getNodeParameter('rotate', itemIndex));
+                formData.flipH = toBoolString(this.getNodeParameter('flipH', itemIndex));
+                formData.flipV = toBoolString(this.getNodeParameter('flipV', itemIndex));
+                const cropX = this.getNodeParameter('cropX', itemIndex);
+                const cropY = this.getNodeParameter('cropY', itemIndex);
+                const cropWidth = this.getNodeParameter('cropWidth', itemIndex);
+                const cropHeight = this.getNodeParameter('cropHeight', itemIndex);
+                if (cropWidth && cropHeight) {
+                    formData.cropX = String(cropX);
+                    formData.cropY = String(cropY);
+                    formData.cropWidth = String(cropWidth);
+                    formData.cropHeight = String(cropHeight);
+                }
+                const targetSizeKB = this.getNodeParameter('targetSizeKB', itemIndex);
+                if (targetSizeKB)
+                    formData.targetSizeKB = String(targetSizeKB);
+                formData.quality = String(this.getNodeParameter('quality', itemIndex));
+                formData.keepMetadata = toBoolString(this.getNodeParameter('keepMetadata', itemIndex));
+                // pdf-only params
+                if (format === 'pdf') {
+                    formData.pdfMode = this.getNodeParameter('pdfMode', itemIndex);
+                    formData.pdfPageSize = this.getNodeParameter('pdfPageSize', itemIndex);
+                    formData.pdfOrientation = this.getNodeParameter('pdfOrientation', itemIndex);
+                    formData.pdfMargin = String(this.getNodeParameter('pdfMargin', itemIndex));
+                    formData.pdfEmbedFormat = this.getNodeParameter('pdfEmbedFormat', itemIndex);
+                    formData.pdfJpegQuality = String(this.getNodeParameter('pdfJpegQuality', itemIndex));
+                }
+                const response = await GenericFunctions_1.davixRequest.call(this, {
+                    method: 'POST',
+                    url: '/v1/image',
+                    formData,
+                    json: true,
+                });
+                // optional download
+                const downloadBinary = this.getNodeParameter('imageDownloadBinary', itemIndex);
+                if (downloadBinary) {
+                    const binName = this.getNodeParameter('imageOutputBinaryProperty', itemIndex);
+                    // PixLab returns either url or results[] with urls (depending on implementation),
+                    // so we support both.
+                    const urls = [];
+                    if (typeof response.url === 'string')
+                        urls.push(response.url);
+                    if (Array.isArray(response.results)) {
+                        for (const r of response.results) {
+                            if (r?.url)
+                                urls.push(String(r.url));
+                        }
+                    }
+                    if (urls.length) {
+                        const firstUrl = urls[0];
+                        const ext = format === 'jpeg' ? 'jpg' : format;
+                        const dl = await GenericFunctions_1.downloadToBinary.call(this, firstUrl, `pixlab-image.${ext}`);
+                        const binary = await this.helpers.prepareBinaryData(dl.data, dl.fileName, dl.mimeType);
+                        out.push({ json: response, binary: { [binName]: binary } });
+                    }
+                    else {
+                        out.push({ json: response });
+                    }
+                }
+                else {
+                    out.push({ json: response });
+                }
+                continue;
+            }
+            // ---- PDF (multipart)
+            if (resource === 'pdf') {
+                const action = this.getNodeParameter('pdfAction', itemIndex);
+                const pdfBinaryProps = this.getNodeParameter('pdfBinaryProps', itemIndex);
+                const formData = {};
+                await attachFiles('files', pdfBinaryProps, formData);
+                formData.action = action;
+                if (action === 'merge') {
+                    formData.sortByName = toBoolString(this.getNodeParameter('sortByName', itemIndex));
+                }
+                if (action === 'split') {
+                    formData.ranges = this.getNodeParameter('ranges', itemIndex);
+                    formData.prefix = this.getNodeParameter('prefix', itemIndex);
+                }
+                if (action === 'to-images') {
+                    formData.pages = this.getNodeParameter('pages', itemIndex);
+                    formData.toFormat = this.getNodeParameter('toFormat', itemIndex);
+                    const w = this.getNodeParameter('pdfWidth', itemIndex);
+                    const h = this.getNodeParameter('pdfHeight', itemIndex);
+                    if (w)
+                        formData.width = String(w);
+                    if (h)
+                        formData.height = String(h);
+                    formData.dpi = String(this.getNodeParameter('dpi', itemIndex));
+                }
+                if (action === 'extract-images') {
+                    formData.pages = this.getNodeParameter('pages', itemIndex);
+                    formData.imageFormat = this.getNodeParameter('imageFormat', itemIndex);
+                }
+                const response = await GenericFunctions_1.davixRequest.call(this, {
+                    method: 'POST',
+                    url: '/v1/pdf',
+                    formData,
+                    json: true,
+                });
+                const downloadBinary = this.getNodeParameter('pdfDownloadBinary', itemIndex);
+                if (downloadBinary) {
+                    const binName = this.getNodeParameter('pdfOutputBinaryProperty', itemIndex);
+                    const urls = [];
+                    if (typeof response.url === 'string')
+                        urls.push(response.url);
+                    if (Array.isArray(response.results)) {
+                        for (const r of response.results) {
+                            if (r?.url)
+                                urls.push(String(r.url));
+                        }
+                    }
+                    if (urls.length) {
+                        const firstUrl = urls[0];
+                        const dl = await GenericFunctions_1.downloadToBinary.call(this, firstUrl, `pixlab-pdf-result.bin`);
+                        const binary = await this.helpers.prepareBinaryData(dl.data, dl.fileName, dl.mimeType);
+                        out.push({ json: response, binary: { [binName]: binary } });
+                    }
+                    else {
+                        out.push({ json: response });
+                    }
+                }
+                else {
+                    out.push({ json: response });
+                }
+                continue;
+            }
+            // ---- TOOLS (multipart)
+            if (resource === 'tools') {
+                const toolsBinaryProps = this.getNodeParameter('toolsBinaryProps', itemIndex);
+                const formData = {};
+                await attachFiles('images', toolsBinaryProps, formData);
+                const tools = this.getNodeParameter('tools', itemIndex);
+                formData.tools = tools.join(',');
+                formData.includeRawExif = toBoolString(this.getNodeParameter('includeRawExif', itemIndex));
+                formData.paletteSize = String(this.getNodeParameter('paletteSize', itemIndex));
+                formData.hashType = this.getNodeParameter('hashType', itemIndex);
+                const response = await GenericFunctions_1.davixRequest.call(this, {
+                    method: 'POST',
+                    url: '/v1/tools',
+                    formData,
+                    json: true,
+                });
+                out.push({ json: response });
+                continue;
+            }
+        }
+        return [out];
+    }
+}
+exports.DavixH2I = DavixH2I;

package/dist/nodes/DavixH2I/GenericFunctions.d.ts

@@ -0,0 +1,7 @@
+import type { IDataObject, IExecuteFunctions, IHttpRequestOptions } from 'n8n-workflow';
+export declare function davixRequest(this: IExecuteFunctions, options: IHttpRequestOptions): Promise<IDataObject>;
+export declare function downloadToBinary(this: IExecuteFunctions, url: string, fileName: string): Promise<{
+    data: Buffer;
+    fileName: string;
+    mimeType?: string;
+}>;

package/dist/nodes/DavixH2I/GenericFunctions.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.davixRequest = davixRequest;
+exports.downloadToBinary = downloadToBinary;
+function stripTrailingSlash(url) {
+    return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+async function davixRequest(options) {
+    const creds = await this.getCredentials('davixH2IApi');
+    const baseUrl = stripTrailingSlash(String(creds.baseUrl || ''));
+    const apiKey = String(creds.apiKey || '');
+    if (!baseUrl)
+        throw new Error('Missing Base URL in credentials.');
+    if (!apiKey)
+        throw new Error('Missing API Key in credentials.');
+    const requestOptions = {
+        ...options,
+        url: `${baseUrl}${options.url}`,
+        headers: {
+            ...(options.headers || {}),
+            // PixLab accepts x-api-key
+            'x-api-key': apiKey,
+        },
+    };
+    return await this.helpers.request(requestOptions);
+}
+async function downloadToBinary(url, fileName) {
+    const res = await this.helpers.request({
+        method: 'GET',
+        url,
+        encoding: null, // IMPORTANT: Buffer
+        resolveWithFullResponse: true,
+    });
+    const body = res.body;
+    const mimeType = res.headers?.['content-type'] || undefined;
+    return { data: body, fileName, mimeType };
+}