n8n-nodes-iterationlayer 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Iteration Layer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# n8n-nodes-iterationlayer
+
+n8n community node for the [Iteration Layer](https://iterationlayer.com) API.
+
+Extract data from documents, transform images, generate images, and create documents — all from your n8n workflows.
+
+## Installation
+
+### Via n8n UI (recommended)
+
+1. Open **Settings** > **Community Nodes**
+2. Select **Install a community node**
+3. Enter `n8n-nodes-iterationlayer`
+4. Accept the risks and install
+
+### Via npm (self-hosted)
+
+```bash
+cd ~/.n8n
+npm install n8n-nodes-iterationlayer
+```
+
+Restart n8n after installation.
+
+## Credentials
+
+1. Go to **Credentials** > **New Credential**
+2. Search for **Iteration Layer API**
+3. Enter your API key (starts with `il_`)
+4. Get an API key at [platform.iterationlayer.com](https://platform.iterationlayer.com)
+
+## Resources
+
+The node provides four resources, one for each Iteration Layer API:
+
+### Document Extraction
+
+Extract structured data from PDFs, images, DOCX, and more. Define a schema with field names, types, and descriptions — the API returns typed values with confidence scores.
+
+- **File input**: Binary data from a previous node or a public URL
+- **Schema**: Build via the UI (17 field types) or provide raw JSON for advanced schemas (arrays, calculated fields)
+
+### Image Transformation
+
+Apply image operations sequentially: resize, crop, rotate, blur, sharpen, convert format, upscale, remove background, and more (24 operations total).
+
+- **File input**: Binary data or URL
+- **Operations**: Add multiple operations via the UI — each type shows its specific parameters
+
+### Image Generation
+
+Generate images from layer compositions defined as JSON. Supports solid-color, text, image, QR code, barcode, and gradient layers.
+
+- **Dimensions**: Width and height in pixels
+- **Layers**: JSON array defining the composition (see [API docs](https://iterationlayer.com/docs/image-generation))
+- **Output format**: PNG, JPEG, WebP, TIFF, GIF, or AVIF
+
+### Document Generation
+
+Generate PDF, DOCX, EPUB, or PPTX documents from structured JSON definitions including metadata, page layout, styles, and content blocks.
+
+- **Format**: PDF, DOCX, EPUB, or PPTX
+- **Document**: JSON object with the full document definition (see [API docs](https://iterationlayer.com/docs/document-generation))
+
+## Binary Data
+
+Image Transformation, Image Generation, and Document Generation return binary data. The output is available as n8n binary data that you can pass to downstream nodes (e.g., write to disk, send via email, upload to S3).
+
+Document Extraction returns JSON data with extracted field values and confidence scores.
+
+## Async Mode
+
+All resources support async mode. Enable it and provide a webhook URL — the API returns immediately and delivers results to your webhook when processing is complete.
+
+## Links
+
+- [Iteration Layer Docs](https://iterationlayer.com/docs)
+- [n8n Integration Guide](https://iterationlayer.com/docs/n8n)
+- [API Reference](https://iterationlayer.com/docs/document-extraction)
+- [Get an API Key](https://platform.iterationlayer.com)
+
+## License
+
+MIT

package/dist/credentials/IterationLayerApi.credentials.d.ts

@@ -0,0 +1,8 @@
+import type { IAuthenticateGeneric, ICredentialType, INodeProperties } from "n8n-workflow";
+export declare class IterationLayerApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+}

package/dist/credentials/IterationLayerApi.credentials.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IterationLayerApi = void 0;
+class IterationLayerApi {
+    name = "iterationLayerApi";
+    displayName = "Iteration Layer API";
+    documentationUrl = "https://iterationlayer.com/docs/n8n";
+    properties = [
+        {
+            displayName: "API Key",
+            name: "apiKey",
+            type: "string",
+            typeOptions: { password: true },
+            default: "",
+            placeholder: "il_xxxx",
+            description: "Your Iteration Layer API key. Get one at https://platform.iterationlayer.com.",
+        },
+        {
+            displayName: "Base URL",
+            name: "baseUrl",
+            type: "string",
+            default: "https://api.iterationlayer.com",
+            description: "Override the API base URL for development or self-hosted instances.",
+        },
+    ];
+    authenticate = {
+        type: "generic",
+        properties: {
+            headers: {
+                Authorization: "=Bearer {{$credentials.apiKey}}",
+            },
+        },
+    };
+}
+exports.IterationLayerApi = IterationLayerApi;

package/dist/nodes/IterationLayer/IterationLayer.node.d.ts

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from "n8n-workflow";
+export declare class IterationLayer implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/IterationLayer/IterationLayer.node.js

@@ -0,0 +1,407 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IterationLayer = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const documentExtraction_js_1 = require("./descriptions/documentExtraction.js");
+const documentGeneration_js_1 = require("./descriptions/documentGeneration.js");
+const documentToMarkdown_js_1 = require("./descriptions/documentToMarkdown.js");
+const imageGeneration_js_1 = require("./descriptions/imageGeneration.js");
+const imageTransformation_js_1 = require("./descriptions/imageTransformation.js");
+const sheetGeneration_js_1 = require("./descriptions/sheetGeneration.js");
+const binaryData_js_1 = require("./helpers/binaryData.js");
+const fileInput_js_1 = require("./helpers/fileInput.js");
+function buildTransformOperation(entry) {
+    const operationType = entry.operationType;
+    switch (operationType) {
+        case "resize":
+            return {
+                type: "resize",
+                width_in_px: entry.widthInPx,
+                height_in_px: entry.heightInPx,
+                fit: entry.fit,
+            };
+        case "crop":
+            return {
+                type: "crop",
+                left_in_px: entry.leftInPx,
+                top_in_px: entry.topInPx,
+                width_in_px: entry.widthInPx,
+                height_in_px: entry.heightInPx,
+            };
+        case "smart_crop":
+            return {
+                type: "smart_crop",
+                width_in_px: entry.widthInPx,
+                height_in_px: entry.heightInPx,
+            };
+        case "extend":
+            return {
+                type: "extend",
+                top_in_px: entry.extendTopInPx,
+                bottom_in_px: entry.extendBottomInPx,
+                left_in_px: entry.extendLeftInPx,
+                right_in_px: entry.extendRightInPx,
+                hex_color: entry.hexColor,
+            };
+        case "trim":
+            return { type: "trim", threshold: entry.thresholdValue };
+        case "rotate":
+            return {
+                type: "rotate",
+                angle_in_degrees: entry.angleInDegrees,
+                hex_color: entry.hexColor,
+            };
+        case "flip":
+            return { type: "flip" };
+        case "flop":
+            return { type: "flop" };
+        case "blur":
+            return { type: "blur", sigma: entry.sigma };
+        case "sharpen":
+            return { type: "sharpen", sigma: entry.sigma };
+        case "modulate":
+            return {
+                type: "modulate",
+                brightness: entry.brightness,
+                saturation: entry.saturation,
+                hue: entry.hue,
+            };
+        case "tint":
+            return { type: "tint", hex_color: entry.tintHexColor };
+        case "grayscale":
+            return { type: "grayscale" };
+        case "invert_colors":
+            return { type: "invert_colors" };
+        case "auto_contrast":
+            return { type: "auto_contrast" };
+        case "gamma":
+            return { type: "gamma", gamma: entry.gamma };
+        case "opacity":
+            return { type: "opacity", opacity_in_percent: entry.opacityInPercent };
+        case "remove_transparency":
+            return { type: "remove_transparency", hex_color: entry.hexColor };
+        case "threshold":
+            return {
+                type: "threshold",
+                value: entry.thresholdValue,
+                is_grayscale: entry.isGrayscale,
+            };
+        case "denoise":
+            return { type: "denoise", size: entry.denoiseSize };
+        case "convert":
+            return {
+                type: "convert",
+                format: entry.convertFormat,
+                quality: entry.quality,
+            };
+        case "upscale":
+            return { type: "upscale", factor: entry.upscaleFactor };
+        case "compress_to_size":
+            return {
+                type: "compress_to_size",
+                max_file_size_in_bytes: entry.maxFileSizeInBytes,
+            };
+        case "remove_background":
+            return {
+                type: "remove_background",
+                background_hex_color: entry.hexColor || undefined,
+            };
+        default:
+            return { type: operationType };
+    }
+}
+class IterationLayer {
+    description = {
+        displayName: "Iteration Layer",
+        name: "iterationLayer",
+        icon: "file:iterationlayer.svg",
+        group: ["transform"],
+        version: 1,
+        subtitle: '={{ $parameter["resource"] }}',
+        description: "Extract data from documents, transform images, generate images, and create documents",
+        defaults: {
+            name: "Iteration Layer",
+        },
+        inputs: ["main" /* NodeConnectionType.Main */],
+        outputs: ["main" /* NodeConnectionType.Main */],
+        credentials: [
+            {
+                name: "iterationLayerApi",
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: "Resource",
+                name: "resource",
+                type: "options",
+                noDataExpression: true,
+                options: [
+                    {
+                        name: "Document Extraction",
+                        value: "documentExtraction",
+                        description: "Extract structured data from documents and images using AI",
+                    },
+                    {
+                        name: "Image Transformation",
+                        value: "imageTransformation",
+                        description: "Resize, crop, convert, and apply effects to images",
+                    },
+                    {
+                        name: "Image Generation",
+                        value: "imageGeneration",
+                        description: "Generate images from layer compositions",
+                    },
+                    {
+                        name: "Document Generation",
+                        value: "documentGeneration",
+                        description: "Generate PDF, DOCX, EPUB, or PPTX documents",
+                    },
+                    {
+                        name: "Document to Markdown",
+                        value: "documentToMarkdown",
+                        description: "Convert documents to clean, structured Markdown",
+                    },
+                    {
+                        name: "Sheet Generation",
+                        value: "sheetGeneration",
+                        description: "Generate XLSX, CSV, or Markdown spreadsheets",
+                    },
+                ],
+                default: "documentExtraction",
+            },
+            ...documentExtraction_js_1.documentExtractionProperties,
+            ...documentToMarkdown_js_1.documentToMarkdownProperties,
+            ...imageTransformation_js_1.imageTransformationProperties,
+            ...imageGeneration_js_1.imageGenerationProperties,
+            ...documentGeneration_js_1.documentGenerationProperties,
+            ...sheetGeneration_js_1.sheetGenerationProperties,
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter("resource", 0);
+        const credentials = (await this.getCredentials("iterationLayerApi"));
+        const baseUrl = credentials.baseUrl || "https://api.iterationlayer.com";
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const isAsync = this.getNodeParameter("isAsync", itemIndex, false);
+                const maybeWebhookUrl = isAsync
+                    ? this.getNodeParameter("webhookUrl", itemIndex)
+                    : undefined;
+                if (resource === "documentExtraction") {
+                    const result = await executeDocumentExtraction(this, itemIndex, baseUrl, maybeWebhookUrl);
+                    returnData.push(result);
+                }
+                else if (resource === "imageTransformation") {
+                    const result = await executeImageTransformation(this, itemIndex, baseUrl, maybeWebhookUrl);
+                    returnData.push(result);
+                }
+                else if (resource === "imageGeneration") {
+                    const result = await executeImageGeneration(this, itemIndex, baseUrl, maybeWebhookUrl);
+                    returnData.push(result);
+                }
+                else if (resource === "documentGeneration") {
+                    const result = await executeDocumentGeneration(this, itemIndex, baseUrl, maybeWebhookUrl);
+                    returnData.push(result);
+                }
+                else if (resource === "documentToMarkdown") {
+                    const result = await executeDocumentToMarkdown(this, itemIndex, baseUrl);
+                    returnData.push(result);
+                }
+                else if (resource === "sheetGeneration") {
+                    const result = await executeSheetGeneration(this, itemIndex, baseUrl, maybeWebhookUrl);
+                    returnData.push(result);
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: itemIndex },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.IterationLayer = IterationLayer;
+async function makeApiRequest(executeFunctions, method, endpoint, baseUrl, body) {
+    return (await executeFunctions.helpers.httpRequestWithAuthentication.call(executeFunctions, "iterationLayerApi", {
+        method: method,
+        url: `${baseUrl}${endpoint}`,
+        body: body,
+        json: true,
+    }));
+}
+function handleApiResponse(executeFunctions, response, itemIndex) {
+    if (!response.success) {
+        throw new n8n_workflow_1.NodeOperationError(executeFunctions.getNode(), `API error: ${response.error}`, {
+            itemIndex,
+        });
+    }
+}
+async function executeDocumentExtraction(executeFunctions, itemIndex, baseUrl, maybeWebhookUrl) {
+    const files = await (0, fileInput_js_1.getMultipleFileInputs)(executeFunctions, itemIndex);
+    const schemaInputMode = executeFunctions.getNodeParameter("schemaInputMode", itemIndex);
+    let schema;
+    if (schemaInputMode === "rawJson") {
+        const schemaJson = executeFunctions.getNodeParameter("schemaJson", itemIndex);
+        schema = (typeof schemaJson === "string" ? JSON.parse(schemaJson) : schemaJson);
+    }
+    else {
+        const schemaFieldsCollection = executeFunctions.getNodeParameter("schemaFields", itemIndex, {});
+        const fields = (schemaFieldsCollection.fieldValues ?? []).map((field) => ({
+            name: field.name,
+            description: field.description,
+            type: field.type,
+            is_required: field.isRequired,
+        }));
+        schema = { fields };
+    }
+    const requestBody = { files, schema };
+    if (maybeWebhookUrl) {
+        requestBody.webhook_url = maybeWebhookUrl;
+    }
+    const response = await makeApiRequest(executeFunctions, "POST", "/document-extraction/v1/extract", baseUrl, requestBody);
+    handleApiResponse(executeFunctions, response, itemIndex);
+    if ("async" in response && response.async) {
+        return {
+            json: { async: true, message: response.message },
+            pairedItem: { item: itemIndex },
+        };
+    }
+    return {
+        json: response.data,
+        pairedItem: { item: itemIndex },
+    };
+}
+async function executeImageTransformation(executeFunctions, itemIndex, baseUrl, maybeWebhookUrl) {
+    const file = await (0, fileInput_js_1.getFileInput)(executeFunctions, itemIndex);
+    const operationsCollection = executeFunctions.getNodeParameter("operations", itemIndex, {});
+    const operations = (operationsCollection.operationValues ?? []).map((entry) => buildTransformOperation(entry));
+    const requestBody = { file, operations };
+    if (maybeWebhookUrl) {
+        requestBody.webhook_url = maybeWebhookUrl;
+    }
+    const response = await makeApiRequest(executeFunctions, "POST", "/image-transformation/v1/transform", baseUrl, requestBody);
+    handleApiResponse(executeFunctions, response, itemIndex);
+    if ("async" in response && response.async) {
+        return {
+            json: { async: true, message: response.message },
+            pairedItem: { item: itemIndex },
+        };
+    }
+    const responseData = response.data;
+    const binary = await (0, binaryData_js_1.toBinaryOutput)(executeFunctions, responseData.buffer, responseData.mime_type, "transformed");
+    return {
+        json: { mimeType: responseData.mime_type },
+        binary,
+        pairedItem: { item: itemIndex },
+    };
+}
+async function executeImageGeneration(executeFunctions, itemIndex, baseUrl, maybeWebhookUrl) {
+    const widthInPx = executeFunctions.getNodeParameter("widthInPx", itemIndex);
+    const heightInPx = executeFunctions.getNodeParameter("heightInPx", itemIndex);
+    const outputFormat = executeFunctions.getNodeParameter("outputFormat", itemIndex);
+    const layersJsonRaw = executeFunctions.getNodeParameter("layersJson", itemIndex);
+    const fontsJsonRaw = executeFunctions.getNodeParameter("fontsJson", itemIndex);
+    const layers = typeof layersJsonRaw === "string" ? JSON.parse(layersJsonRaw) : layersJsonRaw;
+    const fonts = typeof fontsJsonRaw === "string" ? JSON.parse(fontsJsonRaw) : fontsJsonRaw;
+    const requestBody = {
+        dimensions: { width_in_px: widthInPx, height_in_px: heightInPx },
+        layers,
+        output_format: outputFormat,
+    };
+    if (Array.isArray(fonts) && fonts.length > 0) {
+        requestBody.fonts = fonts;
+    }
+    if (maybeWebhookUrl) {
+        requestBody.webhook_url = maybeWebhookUrl;
+    }
+    const response = await makeApiRequest(executeFunctions, "POST", "/image-generation/v1/generate", baseUrl, requestBody);
+    handleApiResponse(executeFunctions, response, itemIndex);
+    if ("async" in response && response.async) {
+        return {
+            json: { async: true, message: response.message },
+            pairedItem: { item: itemIndex },
+        };
+    }
+    const responseData = response.data;
+    const binary = await (0, binaryData_js_1.toBinaryOutput)(executeFunctions, responseData.buffer, responseData.mime_type, "generated");
+    return {
+        json: { mimeType: responseData.mime_type },
+        binary,
+        pairedItem: { item: itemIndex },
+    };
+}
+async function executeDocumentGeneration(executeFunctions, itemIndex, baseUrl, maybeWebhookUrl) {
+    const format = executeFunctions.getNodeParameter("format", itemIndex);
+    const documentJsonRaw = executeFunctions.getNodeParameter("documentJson", itemIndex);
+    const document = typeof documentJsonRaw === "string" ? JSON.parse(documentJsonRaw) : documentJsonRaw;
+    const requestBody = { format, document };
+    if (maybeWebhookUrl) {
+        requestBody.webhook_url = maybeWebhookUrl;
+    }
+    const response = await makeApiRequest(executeFunctions, "POST", "/document-generation/v1/generate", baseUrl, requestBody);
+    handleApiResponse(executeFunctions, response, itemIndex);
+    if ("async" in response && response.async) {
+        return {
+            json: { async: true, message: response.message },
+            pairedItem: { item: itemIndex },
+        };
+    }
+    const responseData = response.data;
+    const binary = await (0, binaryData_js_1.toBinaryOutput)(executeFunctions, responseData.buffer, responseData.mime_type, "document");
+    return {
+        json: { mimeType: responseData.mime_type },
+        binary,
+        pairedItem: { item: itemIndex },
+    };
+}
+async function executeDocumentToMarkdown(executeFunctions, itemIndex, baseUrl) {
+    const file = await (0, fileInput_js_1.getFileInput)(executeFunctions, itemIndex);
+    const requestBody = { file };
+    const response = await makeApiRequest(executeFunctions, "POST", "/document-to-markdown/v1/convert", baseUrl, requestBody);
+    handleApiResponse(executeFunctions, response, itemIndex);
+    return {
+        json: response.data,
+        pairedItem: { item: itemIndex },
+    };
+}
+async function executeSheetGeneration(executeFunctions, itemIndex, baseUrl, maybeWebhookUrl) {
+    const sheetFormat = executeFunctions.getNodeParameter("sheetFormat", itemIndex);
+    const sheetsJsonRaw = executeFunctions.getNodeParameter("sheetsJson", itemIndex);
+    const stylesJsonRaw = executeFunctions.getNodeParameter("sheetStylesJson", itemIndex);
+    const sheets = typeof sheetsJsonRaw === "string" ? JSON.parse(sheetsJsonRaw) : sheetsJsonRaw;
+    const styles = typeof stylesJsonRaw === "string" ? JSON.parse(stylesJsonRaw) : stylesJsonRaw;
+    const requestBody = {
+        format: sheetFormat,
+        sheets,
+    };
+    if (styles && Object.keys(styles).length > 0) {
+        requestBody.styles = styles;
+    }
+    if (maybeWebhookUrl) {
+        requestBody.webhook_url = maybeWebhookUrl;
+    }
+    const response = await makeApiRequest(executeFunctions, "POST", "/sheet-generation/v1/generate", baseUrl, requestBody);
+    handleApiResponse(executeFunctions, response, itemIndex);
+    if ("async" in response && response.async) {
+        return {
+            json: { async: true, message: response.message },
+            pairedItem: { item: itemIndex },
+        };
+    }
+    const responseData = response.data;
+    const binary = await (0, binaryData_js_1.toBinaryOutput)(executeFunctions, responseData.buffer, responseData.mime_type, "spreadsheet");
+    return {
+        json: { mimeType: responseData.mime_type },
+        binary,
+        pairedItem: { item: itemIndex },
+    };
+}

package/dist/nodes/IterationLayer/descriptions/documentExtraction.d.ts

@@ -0,0 +1,2 @@
+import type { INodeProperties } from "n8n-workflow";
+export declare const documentExtractionProperties: INodeProperties[];