@ironfang/n8n-nodes-ironfang 0.2.3 → 0.3.0

package/dist/nodes/Ironfang/credentialTest.js

@@ -5,22 +5,32 @@ const transport_1 = require("./transport");
 // n8n's credential-test context exposes request; execution uses the authenticated
 // httpRequest helper. A structured scope refusal proves authentication succeeded.
 async function credentialTest(credential) {
+    const data = credential.data ?? {};
+    const selected = String(data.testProduct || 'auto');
+    const products = selected === 'auto' ? ['renderwolf', 'financewolf', 'auditwolf'] : [selected];
+    const { request: testRequest } = this.helpers;
+    let lastStatus;
     try {
-        const data = credential.data ?? {};
-        const { request: testRequest } = this.helpers;
-        const response = await testRequest({
-            method: 'GET', uri: `${(0, transport_1.apiBase)(data.baseUrl)}/v1/usage`,
-            headers: { Authorization: `Bearer ${String(data.apiKey ?? '')}` },
-            json: true, resolveWithFullResponse: true, simple: false,
-            followRedirect: false, timeout: 15_000,
-        });
-        if (response.statusCode === 200 && (typeof response.body?.limit === 'number' || response.body?.unmetered === true)) {
-            return { status: 'OK', message: 'Connected to Renderwolf; usage permission is available' };
+        for (const product of products) {
+            const base = product === 'renderwolf' ? (0, transport_1.renderwolfBase)(data.baseUrl) : (0, transport_1.productBase)(data.baseUrl, product);
+            const endpoint = product === 'renderwolf' ? '/v1/usage' : product === 'financewolf' ? '/v1/einvoices/results' : '/v1/sites';
+            const response = await testRequest({
+                method: 'GET', uri: base + endpoint,
+                headers: { Authorization: `Bearer ${String(data.apiKey ?? '')}` },
+                json: true, resolveWithFullResponse: true, simple: false,
+                followRedirect: false, timeout: 15_000,
+            });
+            lastStatus = response.statusCode;
+            const body = response.body;
+            const valid = product === 'renderwolf' ? typeof body?.limit === 'number' || body?.unmetered === true : Array.isArray(body?.[product === 'financewolf' ? 'results' : 'sites']);
+            if (response.statusCode === 200 && valid)
+                return { status: 'OK', message: `Connected to ${product}. Each operation requires its own scope.` };
+            if (response.statusCode === 403 && (body?.error?.code ?? body?.code) === 'insufficient_scope')
+                return { status: 'OK', message: `API key authenticated by ${product}. The test read is outside its scopes; choose only the scopes your workflow needs.` };
+            if (response.statusCode !== 401 && response.statusCode !== 404)
+                break;
         }
-        if (response.statusCode === 403 && response.body?.error?.code === 'insufficient_scope') {
-            return { status: 'OK', message: 'API key authenticated. Usage needs renderwolf:usage:read; other operations use their own scopes.' };
-        }
-        return { status: 'Error', message: response.statusCode === 401 ? 'API key was not accepted. Use an if_live_ platform key or an existing rw_live_ Renderwolf key.' : `Connection check returned HTTP ${response.statusCode}. Check the base URL and service availability.` };
+        return { status: 'Error', message: lastStatus === 401 ? 'API key was not accepted. Use an if_live_ platform key or an existing rw_live_ Renderwolf key.' : `Connection check returned HTTP ${lastStatus}. Check the base URL and service availability.` };
     }
     catch {
         return { status: 'Error', message: 'Could not connect. Check the base URL, TLS and service availability.' };

package/dist/nodes/Ironfang/destinationCredentialTest.d.ts

@@ -0,0 +1,2 @@
+import type { ICredentialsDecrypted, INodeCredentialTestResult } from 'n8n-workflow';
+export declare function destinationCredentialTest(credential: ICredentialsDecrypted): Promise<INodeCredentialTestResult>;

package/dist/nodes/Ironfang/destinationCredentialTest.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destinationCredentialTest = destinationCredentialTest;
+// A signing key cannot be authenticated without the destination bucket and region.
+// Keep the connection check explicit about that limit; destination Test performs
+// the actual upload/verification through Ironfang once the destination exists.
+async function destinationCredentialTest(credential) {
+    const data = credential.data ?? {};
+    if (!data.accessKey || !data.secretKey)
+        return { status: 'Error', message: 'Access key and secret key are required' };
+    return { status: 'OK', message: 'Credential fields are present. To verify S3 access, register the destination and run Test Destination. No S3 connection has been made by this check.' };
+}

package/dist/nodes/Ironfang/execute.d.ts

@@ -0,0 +1,2 @@
+import type { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+export declare function executeProducts(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;

package/dist/nodes/Ironfang/execute.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeProducts = executeProducts;
+const crypto_1 = require("crypto");
+const n8n_workflow_1 = require("n8n-workflow");
+const catalog_1 = require("./catalog");
+const transport_1 = require("./transport");
+const files_1 = require("./files");
+function jsonObject(value) {
+    const parsed = typeof value === 'string' ? JSON.parse(value) : value;
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error('Request body must be a JSON object');
+    return parsed;
+}
+function parameter(context, name, item, fallback = '') {
+    return context.getNodeParameter(name, item, fallback);
+}
+async function outputFile(context, item, response, field, fallback, json = {}) {
+    if (!field.trim())
+        throw new Error('Output binary field must not be empty');
+    if (!Buffer.isBuffer(response.body))
+        throw new Error('Expected a binary API response');
+    const binary = await context.helpers.prepareBinaryData(response.body, (0, files_1.filename)(response.headers, fallback === 'result.bin' ? 'result.' + ({ 'image/png': 'png', 'image/jpeg': 'jpg', 'image/webp': 'webp', 'application/pdf': 'pdf', 'application/zip': 'zip', 'video/mp4': 'mp4' }[response.headers['content-type']?.split(';')[0]] || 'bin') : fallback), response.headers['content-type']?.split(';')[0] || 'application/octet-stream');
+    return { json: { ...json, bytes: response.body.length, byteLength: response.body.length, _ironfang: response.metadata }, binary: { [field]: binary }, pairedItem: { item } };
+}
+async function jsonOutput(context, item, op, response) {
+    const json = response.body && typeof response.body === 'object' && !Array.isArray(response.body) ? response.body : { result: response.body ?? null };
+    if (op.id === 'generateEInvoice' && !json.artifact)
+        throw new Error('Financewolf generation response is missing the validated XML artifact');
+    if (op.product === 'financewolf' && ['generateEInvoice', 'getValidationResult'].includes(op.id) && json.artifact) {
+        const artifact = json.artifact;
+        if (typeof artifact.data_base64 !== 'string' || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(artifact.data_base64))
+            throw new Error('Financewolf returned an invalid XML artifact');
+        const xml = Buffer.from(artifact.data_base64, 'base64');
+        if (!xml.length || xml.length > 5_242_880 || xml.length !== artifact.bytes || (0, crypto_1.createHash)('sha256').update(xml).digest('hex') !== artifact.sha256)
+            throw new Error('Financewolf XML artifact size or SHA-256 does not match its metadata');
+        return outputFile(context, item, { ...response, body: xml, headers: { 'content-type': 'application/xml' } }, String(parameter(context, 'outputBinaryField', item, 'data')), 'invoice.xml', json);
+    }
+    return { json: { ...json, _ironfang: response.metadata }, pairedItem: { item } };
+}
+async function runOperation(context, item, op) {
+    const publicMode = op.product === 'tools' || (op.product === 'financewolf' && parameter(context, 'authentication', item, 'apiKey') === 'public');
+    if (publicMode && !op.public)
+        throw new Error('This operation requires an API key; public mode cannot access saved results');
+    const base = publicMode ? parameter(context, 'publicBaseUrl', item, 'https://api.ironfang.uk') : (await context.getCredentials('ironfangApi')).baseUrl;
+    const path = op.path.replace(/\{(\w+)\}/g, (_, name) => (0, transport_1.identifier)(context, parameter(context, name, item), item));
+    const url = (0, transport_1.productBase)(base, op.product) + path;
+    const qs = { ...parameter(context, 'query', item, {}) };
+    const allowed = new Set(op.query.map(q => q.name));
+    for (const key of Object.keys(qs)) {
+        if (!allowed.has(key))
+            throw new Error(`Unknown query field: ${key}`);
+        if (qs[key] === '' || qs[key] === undefined)
+            delete qs[key];
+    }
+    for (const q of op.query) {
+        if (q.required) {
+            qs[q.name] = parameter(context, q.name, item);
+            if (qs[q.name] === '')
+                throw new Error(`${q.label} is required`);
+        }
+        if (q.type === 'array' && qs[q.name] !== undefined) {
+            if (typeof qs[q.name] === 'string')
+                qs[q.name] = JSON.parse(qs[q.name]);
+            if (!Array.isArray(qs[q.name]) || !qs[q.name].every(value => typeof value === 'string'))
+                throw new Error(`${q.label} must be a JSON array of strings`);
+        }
+    }
+    const headers = {};
+    if (op.idempotency) {
+        const key = String(parameter(context, 'idempotencyKey', item));
+        if (key && publicMode)
+            throw new Error('Public Financewolf calls cannot use an idempotency key');
+        if (['submitJob', 'submitBatch'].includes(op.id) && !key.trim())
+            throw new Error('Use a stable idempotency key for job or batch submission');
+        if (key)
+            headers['Idempotency-Key'] = key;
+    }
+    let body;
+    if (op.input === 'json') {
+        body = jsonObject(parameter(context, 'requestBody', item, op.example ?? {}));
+        headers['Content-Type'] = 'application/json';
+    }
+    if (op.id === 'createDestination' || op.id === 'createExportDestinations') {
+        const destination = body;
+        if (['access_key', 'secret_key', 'session_token'].some(key => key in destination))
+            throw new Error('Store destination secrets in the Ironfang S3 Destination credential');
+        const s3 = op.id === 'createExportDestinations' || parameter(context, 'destinationType', item, 'webhook') === 's3';
+        if (op.product === 'renderwolf')
+            destination.type = s3 ? 's3' : 'webhook';
+        if (s3) {
+            const credential = await context.getCredentials('ironfangS3');
+            destination.access_key = String(credential.accessKey || '');
+            destination.secret_key = String(credential.secretKey || '');
+            if (credential.sessionToken)
+                destination.session_token = String(credential.sessionToken);
+        }
+    }
+    if (op.input === 'xml') {
+        body = parameter(context, 'xmlSource', item, 'binary') === 'text' ? Buffer.from(String(parameter(context, 'xml', item)), 'utf8') : await context.helpers.getBinaryDataBuffer(item, String(parameter(context, 'inputBinaryField', item, 'data')));
+        if (!Buffer.isBuffer(body) || !body.length || body.length > 5_242_880)
+            throw new Error('XML input must contain between 1 byte and 5 MiB');
+        headers['Content-Type'] = 'application/xml';
+    }
+    if (op.input === 'upload') {
+        const input = await context.helpers.getBinaryDataBuffer(item, String(parameter(context, 'inputBinaryField', item, 'data')));
+        if (!input.length || input.length > 8 * 1024 * 1024 - 8192)
+            throw new Error('Image input must fit within the 8 MiB multipart request limit');
+        const multipart = (0, files_1.multipartUpload)(input, jsonObject(parameter(context, 'requestBody', item, op.example ?? {})));
+        body = multipart.body;
+        headers['Content-Type'] = multipart.contentType;
+    }
+    const options = { method: op.method, url, qs, headers, body, arrayFormat: 'repeat', ...(op.response === 'json' ? { json: true } : { encoding: 'arraybuffer' }) };
+    if (op.response === 'redirect')
+        options.ignoreHttpStatusErrors = { ignore: true, except: Array.from({ length: 300 }, (_, i) => i + 300).filter(code => code !== 302) };
+    let response;
+    if (op.pagination)
+        return paginated(context, item, op, options, !publicMode);
+    response = await transport_1.request.call(context, options, !publicMode);
+    if (op.response === 'redirect') {
+        const location = response.headers.location;
+        if (response.statusCode !== 302 || !location)
+            throw new Error('Job result did not return a signed download location');
+        const target = new URL(location, url);
+        const baseURL = new URL((0, transport_1.productBase)(base, op.product));
+        if (target.origin !== baseURL.origin || !target.pathname.startsWith(`${baseURL.pathname}/v1/results/`) || target.username || target.password || target.hash)
+            throw new Error('Job result download location is outside the expected signed-result endpoint');
+        response = await transport_1.request.call(context, { method: 'GET', url: target.toString(), encoding: 'arraybuffer' }, false);
+    }
+    const field = String(parameter(context, 'outputBinaryField', item, 'data'));
+    if (op.response === 'multipart' || (op.response === 'redirect' && response.headers['content-type']?.startsWith('multipart/'))) {
+        if (field === 'poster')
+            throw new Error('Use an output field other than poster for the preview video');
+        const parts = (0, files_1.previewParts)(response.body, response.headers['content-type']);
+        const out = await outputFile(context, item, { ...response, body: parts.video, headers: { 'content-type': 'video/mp4' } }, field, 'preview.mp4');
+        out.binary.poster = await context.helpers.prepareBinaryData(parts.poster, 'poster.jpg', 'image/jpeg');
+        out.json.posterBytes = parts.poster.length;
+        return [out];
+    }
+    if (op.response !== 'json')
+        return [await outputFile(context, item, response, field, 'result.bin')];
+    return [await jsonOutput(context, item, op, response)];
+}
+async function paginated(context, item, op, options, authenticated) {
+    const paging = op.pagination;
+    const all = parameter(context, 'returnAll', item, false) === true;
+    const limit = all ? Infinity : Number(parameter(context, 'limit', item, 50));
+    if (!all && (!Number.isSafeInteger(limit) || limit < 1))
+        throw new Error('Limit must be a positive integer');
+    let cursor = parameter(context, 'pageStart', item, paging.parameter === 'offset' ? 0 : '');
+    if (paging.parameter === 'offset' && (!Number.isSafeInteger(Number(cursor)) || Number(cursor) < 0))
+        throw new Error('Start offset must be a non-negative integer');
+    const output = [];
+    const seen = new Set();
+    for (let page = 0; page < 1000; page++) {
+        const qs = { ...options.qs };
+        if (cursor !== '')
+            qs[paging.parameter] = cursor;
+        if (paging.parameter !== 'before')
+            qs.limit = Math.min(paging.size, limit - output.length);
+        const response = await transport_1.request.call(context, { ...options, qs }, authenticated);
+        const data = jsonObject(response.body);
+        const rows = data[paging.key];
+        if (!Array.isArray(rows))
+            throw new Error(`API list response is missing ${paging.key}`);
+        for (const row of rows.slice(0, limit - output.length))
+            output.push({ json: { ...row, _ironfang: { ...response.metadata, nextCursor: data.next_cursor ?? '', ...(data.retention_days ? { retentionDays: data.retention_days } : {}) } }, pairedItem: { item } });
+        if (output.length >= limit || !rows.length)
+            return output;
+        if (paging.parameter === 'offset') {
+            if (rows.length < Number(qs.limit))
+                return output;
+            cursor = Number(cursor) + rows.length;
+        }
+        else {
+            const next = data.next_cursor;
+            if (!next)
+                return output;
+            if (typeof next !== 'string' || next === cursor || seen.has(next))
+                throw new Error('API repeated a pagination cursor');
+            seen.add(next);
+            cursor = next;
+        }
+    }
+    throw new Error('Pagination exceeded 1,000 pages; narrow the query or continue from a cursor');
+}
+async function executeProducts() {
+    const output = [];
+    for (let item = 0; item < this.getInputData().length; item++) {
+        try {
+            const product = parameter(this, 'resource', item);
+            const id = parameter(this, 'operation', item);
+            const op = catalog_1.operations.find(candidate => candidate.product === product && candidate.id === id);
+            if (!op)
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Unknown product operation', { itemIndex: item });
+            output.push(...await runOperation(this, item, op));
+        }
+        catch (error) {
+            if (!this.continueOnFail())
+                throw (0, transport_1.apiError)(this, error, item);
+            output.push((0, transport_1.errorOutput)(this, error, item));
+        }
+    }
+    return [output];
+}

package/dist/nodes/Ironfang/files.d.ts

@@ -0,0 +1,10 @@
+import type { IDataObject } from 'n8n-workflow';
+export declare function multipartUpload(data: Buffer, options: IDataObject): {
+    body: Buffer;
+    contentType: string;
+};
+export declare function previewParts(body: Buffer, contentType: string): {
+    poster: Buffer;
+    video: Buffer;
+};
+export declare function filename(headers: Record<string, string>, fallback: string): string;

package/dist/nodes/Ironfang/files.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multipartUpload = multipartUpload;
+exports.previewParts = previewParts;
+exports.filename = filename;
+const crypto_1 = require("crypto");
+function multipartUpload(data, options) {
+    const boundary = `ironfang-${(0, crypto_1.randomBytes)(24).toString('hex')}`;
+    const chunks = [];
+    for (const [key, value] of Object.entries(options)) {
+        if (!/^[a-z][a-z0-9_]*$/.test(key) || !['string', 'number', 'boolean'].includes(typeof value))
+            throw new Error('Form options must contain named string, number or boolean values');
+        chunks.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${key}"\r\n\r\n${String(value)}\r\n`));
+    }
+    chunks.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="image"; filename="image"\r\nContent-Type: application/octet-stream\r\n\r\n`), data, Buffer.from(`\r\n--${boundary}--\r\n`));
+    return { body: Buffer.concat(chunks), contentType: `multipart/form-data; boundary=${boundary}` };
+}
+function previewParts(body, contentType) {
+    const boundary = /boundary=(?:"([^"\r\n]+)"|([^;\s]+))/i.exec(contentType);
+    const value = boundary?.[1] ?? boundary?.[2];
+    if (!value || value.length > 128)
+        throw new Error('Site Preview response has no valid multipart boundary');
+    const marker = Buffer.from(`--${value}`);
+    const separator = Buffer.from(`\r\n--${value}`);
+    const parts = {};
+    let offset = body.indexOf(marker);
+    while (offset >= 0) {
+        offset += marker.length;
+        if (body.subarray(offset, offset + 2).toString() === '--')
+            break;
+        const headerEnd = body.indexOf('\r\n\r\n', offset);
+        if (headerEnd < 0 || headerEnd - offset > 8192)
+            throw new Error('Invalid Site Preview part headers');
+        const header = body.subarray(offset, headerEnd).toString('ascii');
+        const name = /(?:^|;)\s*name="(poster|video)"/m.exec(header)?.[1];
+        const end = body.indexOf(separator, headerEnd + 4);
+        if (end < 0 || !name || parts[name])
+            throw new Error('Invalid or duplicate Site Preview part');
+        parts[name] = body.subarray(headerEnd + 4, end);
+        offset = end + 2;
+    }
+    if (!parts.poster?.length || !parts.video?.length)
+        throw new Error('Site Preview must return both poster and video');
+    return { poster: parts.poster, video: parts.video };
+}
+function filename(headers, fallback) {
+    const match = /filename="?([^";\r\n]+)"?/i.exec(headers['content-disposition'] ?? '');
+    const name = match?.[1]?.split(/[\\/]/).pop();
+    return name && /^[\w. -]{1,180}$/.test(name) && !name.startsWith('.') ? name : fallback;
+}

package/dist/nodes/Ironfang/parameters.d.ts

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

package/dist/nodes/Ironfang/parameters.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.productParameters = void 0;
+const catalog_1 = require("./catalog");
+const show = (op) => ({ show: { resource: [op.product], operation: [op.id] } });
+function queryField(field) {
+    const base = { displayName: field.label, name: field.name, default: field.default ?? '', description: field.description?.slice(0, 500) || `API query parameter: ${field.name}` };
+    if (field.enum?.length)
+        return { ...base, type: 'options', default: field.default || field.enum[0], options: field.enum.map(value => ({ name: value, value })) };
+    if (field.type === 'boolean')
+        return { ...base, type: 'boolean', default: field.default === true };
+    if (['integer', 'number'].includes(field.type))
+        return { ...base, type: 'number', default: typeof field.default === 'number' ? field.default : 0 };
+    if (field.type === 'array')
+        return { ...base, type: 'json', default: '[]', description: 'JSON array; each value is sent as a repeated query parameter' };
+    return { ...base, type: 'string' };
+}
+exports.productParameters = [
+    { displayName: 'Authentication', name: 'authentication', type: 'options', noDataExpression: true, default: 'apiKey', displayOptions: { show: { resource: ['financewolf'] } }, options: [{ name: 'API Key', value: 'apiKey' }, { name: 'Public (No Saved Results)', value: 'public' }], description: 'Public validation, generation and ruleset reads only. An invalid key never falls back to public access.' },
+    { displayName: 'Public API Base URL', name: 'publicBaseUrl', type: 'string', default: 'https://api.ironfang.uk', displayOptions: { show: { resource: ['tools', 'financewolf'] } }, description: 'Used by public requests only; authenticated requests use the credential base URL' },
+    { displayName: 'Public tools share per-address limits. Screenshot is limited to 20/hour/address and a shared daily ceiling. Renderwolf Screenshot is the account-based automation service.', name: 'toolsNotice', type: 'notice', default: '', displayOptions: { show: { resource: ['tools'] } } },
+    ...catalog_1.operations.flatMap((op) => {
+        const fields = [{ displayName: `Permission: ${op.scope}. ${op.description}.`, name: 'operationNotice', type: 'notice', default: '', displayOptions: show(op) }];
+        for (const match of op.path.matchAll(/\{(\w+)\}/g)) {
+            const name = match[1];
+            fields.push({ displayName: name === 'id' ? 'ID' : name.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/Id$/, 'ID').replace(/^./, s => s.toUpperCase()), name, type: 'string', default: '', required: true, displayOptions: show(op), description: 'Identifier from an earlier operation or the Ironfang portal' });
+        }
+        if (op.id === 'createDestination')
+            fields.push({ displayName: 'Destination Type', name: 'destinationType', type: 'options', default: 'webhook', displayOptions: show(op), options: [{ name: 'S3 Storage', value: 's3' }, { name: 'Webhook', value: 'webhook' }], description: 'S3 credentials are stored in an n8n credential, separate from the request body' });
+        const required = op.query.filter(q => q.required);
+        for (const q of required)
+            fields.push({ ...queryField(q), required: true, displayOptions: show(op) });
+        const optional = op.query.filter(q => !q.required && !['cursor', 'before', 'offset', 'limit'].includes(q.name));
+        if (optional.length)
+            fields.push({ displayName: 'Query Options', name: 'query', type: 'collection', placeholder: 'Add Query Option', default: {}, displayOptions: show(op), options: optional.map(queryField).sort((a, b) => a.displayName.localeCompare(b.displayName)) });
+        if (op.input === 'json' || op.input === 'upload')
+            fields.push({ displayName: op.input === 'upload' ? 'Form Options (JSON)' : 'Request Body (JSON)', name: 'requestBody', type: 'json', default: JSON.stringify(op.example ?? {}, null, 2), required: op.input === 'json', displayOptions: show(op), description: 'API request object. Replace example values. Nested objects and decimal strings are preserved. See the operation reference for the request schema.' });
+        if (op.input === 'xml')
+            fields.push({ displayName: 'XML Source', name: 'xmlSource', type: 'options', default: 'binary', displayOptions: show(op), options: [{ name: 'Binary Field', value: 'binary' }, { name: 'XML Text', value: 'text' }] }, { displayName: 'XML', name: 'xml', type: 'string', typeOptions: { rows: 8 }, default: '', required: true, displayOptions: { show: { ...show(op).show, xmlSource: ['text'] } } });
+        if (['xml', 'upload'].includes(op.input))
+            fields.push({ displayName: 'Input Binary Field', name: 'inputBinaryField', type: 'string', default: 'data', displayOptions: op.input === 'xml' ? { show: { ...show(op).show, xmlSource: ['binary'] } } : show(op), description: 'Binary field containing the XML or image file; works with filesystem and external binary storage' });
+        if (op.response !== 'json' || ['generateEInvoice', 'getValidationResult'].includes(op.id))
+            fields.push({ displayName: 'Output Binary Field', name: 'outputBinaryField', type: 'string', default: 'data', displayOptions: show(op), description: 'Field for the returned file. Site Preview uses this field for MP4 and adds a poster field.' });
+        if (op.idempotency)
+            fields.push({ displayName: 'Idempotency Key', name: 'idempotencyKey', type: 'string', default: '', required: ['submitJob', 'submitBatch'].includes(op.id), displayOptions: show(op), description: 'Stable reference for this business operation. Reuse it only when retrying identical input. Public Financewolf calls cannot use a key.' });
+        if (op.pagination)
+            fields.push({ displayName: 'Return All', name: 'returnAll', type: 'boolean', default: false, displayOptions: show(op), description: 'Whether to return all results or only up to a given limit' }, { displayName: 'Limit', name: 'limit', type: 'number', default: 50, typeOptions: { minValue: 1 }, displayOptions: { show: { ...show(op).show, returnAll: [false] } }, description: 'Max number of results to return' }, { displayName: op.pagination.parameter === 'offset' ? 'Start Offset' : 'Start Cursor', name: 'pageStart', type: op.pagination.parameter === 'offset' ? 'number' : 'string', default: op.pagination.parameter === 'offset' ? 0 : '', displayOptions: show(op) });
+        return fields;
+    }),
+];

package/dist/nodes/Ironfang/renderOptions.d.ts

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

package/dist/nodes/Ironfang/renderOptions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderOptions = void 0;
+exports.renderOptions = [
+    { displayName: 'Advanced Render Options (JSON)', name: 'advancedRenderOptions', type: 'json', default: '{}', displayOptions: { show: { resource: ['renderwolf'], operation: ['screenshot', 'pdf', 'image'] } }, description: 'Additional API fields: wait_until, wait_for_selector, timeout_ms, block_ads, block_cookie_banners, hide_selectors, headers, cookies, authorization, user_agent, device_scale_factor; screenshot clip region; PDF paper_format and margin in inches; template QR variables. Do not include the source or template variables here.' },
+    { displayName: 'Template Selection', name: 'templateSelection', type: 'options', default: 'id', displayOptions: { show: { resource: ['renderwolf'], operation: ['image'] } }, options: [{ name: 'By ID', value: 'id' }, { name: 'From List', value: 'list' }], description: 'Listing templates also requires renderwolf:templates:read' },
+    { displayName: 'Template', name: 'selectedTemplate', type: 'resourceLocator', default: { mode: 'list', value: '' }, displayOptions: { show: { resource: ['renderwolf'], operation: ['image'], templateSelection: ['list'] } }, modes: [{ displayName: 'From List', name: 'list', type: 'list', typeOptions: { searchListMethod: 'searchTemplates', searchable: false } }] },
+];

package/dist/nodes/Ironfang/renderwolf.d.ts

@@ -0,0 +1,19 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeTypeDescription } from 'n8n-workflow';
+import { credentialTest } from './credentialTest';
+/**
+ * Ironfang node. One node per vendor: pick a product with Resource, then an
+ * operation within it. Renderwolf (https://ironfang.uk/renderwolf/docs) is the
+ * first product; later ones are added as further resources rather than as
+ * separate nodes.
+ *
+ * Render operations return binary data; sign and usage return JSON.
+ */
+export declare const renderwolf: {
+    description: INodeTypeDescription;
+    methods: {
+        credentialTest: {
+            ironfangApiTest: typeof credentialTest;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+};