@ironfang/n8n-nodes-ironfang 0.2.3 → 0.3.0

package/dist/nodes/Ironfang/Ironfang.node.js

@@ -1,549 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ironfang = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
-const transport_1 = require("./transport");
-const credentialTest_1 = require("./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.
- */
+const renderwolf_1 = require("./renderwolf");
+const catalog_1 = require("./catalog");
+const parameters_1 = require("./parameters");
+const execute_1 = require("./execute");
+const renderOptions_1 = require("./renderOptions");
+const templates_1 = require("./templates");
+const destinationCredentialTest_1 = require("./destinationCredentialTest");
+const legacy = renderwolf_1.renderwolf;
+const legacyOperations = (legacy.description.properties[1].options ?? []);
+const products = ['auditwolf', 'financewolf', 'renderwolf', 'tools'];
+// Resource-specific defaults are selected from the checked-in catalogue.
+// eslint-disable-next-line n8n-nodes-base/node-param-default-missing
+const operationParameters = products.map(product => ({
+    displayName: 'Operation', name: 'operation', type: 'options', noDataExpression: true,
+    default: product === 'renderwolf' ? 'screenshot' : catalog_1.operations.find(op => op.product === product).id,
+    displayOptions: { show: { resource: [product] } },
+    options: [...(product === 'renderwolf' ? legacyOperations : []), ...catalog_1.operations.filter(op => op.product === product).map(op => ({ name: op.name, value: op.id, description: op.description, action: op.description }))].sort((a, b) => a.name.localeCompare(b.name)),
+}));
 class Ironfang {
     description = {
-        displayName: 'Ironfang',
-        name: 'ironfang',
-        icon: { light: 'file:ironfang.svg', dark: 'file:ironfang.dark.svg' },
+        ...legacy.description,
         usableAsTool: true,
-        group: ['transform'],
-        version: [1, 1.1],
+        icon: { light: 'file:ironfang.svg', dark: 'file:ironfang.dark.svg' },
         subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
-        description: 'Rendering and developer APIs from Ironfang',
-        defaults: { name: 'Ironfang' },
-        inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
-        outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
-        credentials: [{ name: 'ironfangApi', required: true, testedBy: 'ironfangApiTest' }],
+        description: 'Renderwolf, Financewolf, Auditwolf and public developer tools',
+        credentials: [
+            { name: 'ironfangS3', required: true, testedBy: 'ironfangS3Test', displayOptions: { show: { operation: ['createDestination', 'createExportDestinations'] }, hide: { destinationType: ['webhook'] } } },
+            { name: 'ironfangApi', required: true, testedBy: 'ironfangApiTest', displayOptions: { show: { resource: ['renderwolf', 'auditwolf', 'financewolf'] }, hide: { authentication: ['public'] } } },
+        ],
         properties: [
-            {
-                displayName: 'Resource',
-                name: 'resource',
-                type: 'options',
-                noDataExpression: true,
-                default: 'renderwolf',
-                options: [
-                    {
-                        name: 'Renderwolf',
-                        value: 'renderwolf',
-                        description: 'Screenshots, PDFs and templated images',
-                    },
-                ],
-            },
-            {
-                displayName: 'Operation',
-                name: 'operation',
-                type: 'options',
-                noDataExpression: true,
-                default: 'screenshot',
-                displayOptions: { show: { resource: ['renderwolf'] } },
-                options: [
-                    {
-                        name: 'PDF',
-                        value: 'pdf',
-                        description: 'Print a URL or raw HTML to PDF',
-                        action: 'Render a PDF',
-                    },
-                    {
-                        name: 'Screenshot',
-                        value: 'screenshot',
-                        description: 'Capture a URL or raw HTML as an image',
-                        action: 'Take a screenshot',
-                    },
-                    {
-                        name: 'Signed URL',
-                        value: 'sign',
-                        description: 'Mint a stable render URL for <img> tags',
-                        action: 'Create a signed URL',
-                    },
-                    {
-                        name: 'Template Image',
-                        value: 'image',
-                        description: 'Render a stored template with variables (OG images)',
-                        action: 'Render a template image',
-                    },
-                    {
-                        name: 'Usage',
-                        value: 'usage',
-                        description: 'Current period usage against your plan cap',
-                        action: 'Get usage',
-                    }, {
-                        name: 'Video Clip',
-                        value: 'video',
-                        description: 'Render a short captioned MP4 from a background and caption cards',
-                        action: 'Create a video clip',
-                    },
-                ],
-            },
-            /* ------------------------- source (screenshot/pdf) ------------------ */
-            {
-                displayName: 'Source',
-                name: 'source',
-                type: 'options',
-                default: 'url',
-                displayOptions: { show: { operation: ['screenshot', 'pdf'] } },
-                options: [
-                    { name: 'URL', value: 'url' },
-                    { name: 'HTML', value: 'html' },
-                ],
-            },
-            {
-                displayName: 'URL',
-                name: 'url',
-                type: 'string',
-                default: '',
-                required: true,
-                placeholder: 'https://example.com',
-                displayOptions: { show: { operation: ['screenshot', 'pdf'], source: ['url'] } },
-            },
-            {
-                displayName: 'HTML',
-                name: 'html',
-                type: 'string',
-                typeOptions: { rows: 6 },
-                default: '',
-                required: true,
-                displayOptions: { show: { operation: ['screenshot', 'pdf'], source: ['html'] } },
-            },
-            /* ------------------------- screenshot options ----------------------- */
-            {
-                displayName: 'Options',
-                name: 'screenshotOptions',
-                type: 'collection',
-                placeholder: 'Add option',
-                default: {},
-                displayOptions: { show: { operation: ['screenshot'] } },
-                options: [
-                    { displayName: 'Dark Mode', name: 'dark_mode', type: 'boolean', default: false },
-                    {
-                        displayName: 'Delay (Ms)',
-                        name: 'delay_ms',
-                        type: 'number',
-                        default: 0,
-                        description: 'Extra settle time after load for late-painting pages',
-                    },
-                    {
-                        displayName: 'Device',
-                        name: 'device',
-                        type: 'options',
-                        default: 'desktop',
-                        description: 'Applies a viewport, pixel density, mobile flag and user agent together. Width and height still win if you set them.',
-                        options: [
-                            { name: 'Desktop', value: 'desktop' },
-                            { name: 'Mobile', value: 'mobile' },
-                            { name: 'Tablet', value: 'tablet' },
-                        ],
-                    },
-                    {
-                        displayName: 'Format',
-                        name: 'format',
-                        type: 'options',
-                        default: 'png',
-                        options: [
-                            { name: 'JPEG', value: 'jpeg' },
-                            { name: 'PNG', value: 'png' },
-                            { name: 'WebP', value: 'webp' },
-                        ],
-                    },
-                    { displayName: 'Full Page', name: 'full_page', type: 'boolean', default: false },
-                    { displayName: 'Height', name: 'height', type: 'number', default: 800 },
-                    {
-                        displayName: 'No Cache',
-                        name: 'no_cache',
-                        type: 'boolean',
-                        default: false,
-                        description: 'Whether to force a live capture instead of reusing an identical recent render. Use when the page must be captured exactly as it is right now, such as evidence or change detection. Counts against your quota.',
-                    },
-                    {
-                        displayName: 'Quality',
-                        name: 'quality',
-                        type: 'number',
-                        default: 85,
-                        description: 'For JPEG and WebP. Ignored for PNG, which is lossless.',
-                        typeOptions: { minValue: 1, maxValue: 100 },
-                    },
-                    {
-                        displayName: 'Selector',
-                        name: 'selector',
-                        type: 'string',
-                        default: '',
-                        description: 'CSS selector - capture just that element',
-                    },
-                    { displayName: 'Width', name: 'width', type: 'number', default: 1280 },
-                ],
-            },
-            /* ------------------------- pdf options ------------------------------ */
-            {
-                displayName: 'Options',
-                name: 'pdfOptions',
-                type: 'collection',
-                placeholder: 'Add option',
-                default: {},
-                displayOptions: { show: { operation: ['pdf'] } },
-                options: [
-                    { displayName: 'Footer HTML', name: 'footer_html', type: 'string', default: '' },
-                    { displayName: 'Header HTML', name: 'header_html', type: 'string', default: '' },
-                    { displayName: 'Landscape', name: 'landscape', type: 'boolean', default: false },
-                    {
-                        displayName: 'No Cache',
-                        name: 'no_cache',
-                        type: 'boolean',
-                        default: false,
-                        description: 'Whether to force a live capture instead of reusing an identical recent render. Use when the page must be captured exactly as it is right now, such as evidence or change detection. Counts against your quota.',
-                    },
-                    {
-                        displayName: 'Print Background',
-                        name: 'print_background',
-                        type: 'boolean',
-                        default: true,
-                    },
-                    {
-                        displayName: 'Scale',
-                        name: 'scale',
-                        type: 'number',
-                        default: 1,
-                        typeOptions: { minValue: 0.1, maxValue: 2, numberPrecision: 2 },
-                    },
-                ],
-            },
-            /* ------------------------- template image --------------------------- */
-            {
-                displayName: 'Template ID',
-                name: 'templateId',
-                type: 'string',
-                default: '',
-                required: true,
-                displayOptions: { show: { operation: ['image'] } },
-            },
-            {
-                displayName: 'Variables',
-                name: 'vars',
-                type: 'fixedCollection',
-                typeOptions: { multipleValues: true },
-                default: {},
-                placeholder: 'Add variable',
-                displayOptions: { show: { operation: ['image'] } },
-                options: [
-                    {
-                        name: 'values',
-                        displayName: 'Variable',
-                        values: [
-                            { displayName: 'Name', name: 'name', type: 'string', default: '' },
-                            { displayName: 'Value', name: 'value', type: 'string', default: '' },
-                        ],
-                    },
-                ],
-            },
-            {
-                displayName: 'Format',
-                name: 'imageFormat',
-                type: 'options',
-                default: 'png',
-                displayOptions: { show: { operation: ['image'] } },
-                options: [
-                    { name: 'JPEG', value: 'jpeg' },
-                    { name: 'PNG', value: 'png' },
-                    { name: 'WebP', value: 'webp' },
-                ],
-            },
-            /* ------------------------- signed url ------------------------------- */
-            {
-                displayName: 'Kind',
-                name: 'signKind',
-                type: 'options',
-                default: 'screenshot',
-                displayOptions: { show: { operation: ['sign'] } },
-                options: [
-                    { name: 'Screenshot', value: 'screenshot' },
-                    { name: 'Template Image', value: 'image' },
-                ],
-            },
-            {
-                displayName: 'URL',
-                name: 'signUrl',
-                type: 'string',
-                default: '',
-                required: true,
-                displayOptions: { show: { operation: ['sign'], signKind: ['screenshot'] } },
-            },
-            {
-                displayName: 'Full Page',
-                name: 'signFullPage',
-                type: 'boolean',
-                default: false,
-                displayOptions: { show: { operation: ['sign'], signKind: ['screenshot'] } },
-            },
-            {
-                displayName: 'Template ID',
-                name: 'signTemplateId',
-                type: 'string',
-                default: '',
-                required: true,
-                displayOptions: { show: { operation: ['sign'], signKind: ['image'] } },
-            },
-            {
-                displayName: 'Variables',
-                name: 'signVars',
-                type: 'fixedCollection',
-                typeOptions: { multipleValues: true },
-                default: {},
-                placeholder: 'Add variable',
-                displayOptions: { show: { operation: ['sign'], signKind: ['image'] } },
-                options: [
-                    {
-                        name: 'values',
-                        displayName: 'Variable',
-                        values: [
-                            { displayName: 'Name', name: 'name', type: 'string', default: '' },
-                            { displayName: 'Value', name: 'value', type: 'string', default: '' },
-                        ],
-                    },
-                ],
-            },
-            {
-                displayName: 'TTL (Hours)',
-                name: 'ttlHours',
-                type: 'number',
-                default: 0,
-                description: '0 means the URL never expires',
-                displayOptions: { show: { operation: ['sign'] } },
-            },
-            /* ------------------------- video clip ------------------------------- */
-            {
-                displayName: 'Size',
-                name: 'clipSize',
-                type: 'options',
-                default: 'vertical',
-                displayOptions: { show: { operation: ['video'] } },
-                description: 'Credits scale with pixels and seconds, so the smaller sizes cost less per second',
-                options: [
-                    { name: '720p 1280x720', value: '720p' },
-                    { name: 'Landscape 1920x1080', value: 'landscape' },
-                    { name: 'Square 1080x1080', value: 'square' },
-                    { name: 'Vertical 1080x1920', value: 'vertical' },
-                ],
-            },
-            {
-                displayName: 'Duration (Seconds)',
-                name: 'clipDuration',
-                type: 'number',
-                default: 15,
-                typeOptions: { minValue: 1, maxValue: 60 },
-                displayOptions: { show: { operation: ['video'] } },
-            },
-            {
-                displayName: 'Captions',
-                name: 'captions',
-                type: 'fixedCollection',
-                typeOptions: { multipleValues: true },
-                default: {},
-                placeholder: 'Add caption',
-                description: 'Cards that appear and disappear on a schedule',
-                displayOptions: { show: { operation: ['video'] } },
-                options: [
-                    {
-                        name: 'values',
-                        displayName: 'Caption',
-                        values: [
-                            { displayName: 'Text', name: 'text', type: 'string', default: '' },
-                            {
-                                displayName: 'From (Seconds)',
-                                name: 'from',
-                                type: 'number',
-                                default: 0,
-                            },
-                            { displayName: 'To (Seconds)', name: 'to', type: 'number', default: 3 },
-                        ],
-                    },
-                ],
-            },
-            {
-                displayName: 'Options',
-                name: 'clipOptions',
-                type: 'collection',
-                placeholder: 'Add option',
-                default: {},
-                displayOptions: { show: { operation: ['video'] } },
-                options: [
-                    {
-                        displayName: 'Audio URL',
-                        name: 'audio',
-                        type: 'string',
-                        default: '',
-                        description: 'An audio track, trimmed to the clip length',
-                    },
-                    {
-                        displayName: 'Background URL',
-                        name: 'background',
-                        type: 'string',
-                        default: '',
-                        description: 'An image or video to fill the frame. Leave blank for a solid colour.',
-                    },
-                    {
-                        displayName: 'Colour',
-                        name: 'colour',
-                        type: 'color',
-                        default: '',
-                        description: 'Used when there is no background URL',
-                    },
-                    {
-                        displayName: 'Font Size',
-                        name: 'font_size',
-                        type: 'number',
-                        default: 0,
-                        description: 'Caption size. 0 scales it with the canvas.',
-                    },
-                    {
-                        displayName: 'Watermark URL',
-                        name: 'watermark',
-                        type: 'string',
-                        default: '',
-                        description: 'A PNG of your own, placed bottom right',
-                    },
-                ],
-            },
-            /* ------------------------- binary output ---------------------------- */
-            {
-                displayName: 'Put Output in Field',
-                name: 'binaryProperty',
-                type: 'string',
-                default: 'data',
-                description: 'Name of the binary field to write the rendered file to',
-                displayOptions: { show: { operation: ['screenshot', 'pdf', 'image', 'video'] } },
-            },
+            { displayName: 'Resource', name: 'resource', type: 'options', noDataExpression: true, default: 'renderwolf', options: [{ name: 'Auditwolf', value: 'auditwolf' }, { name: 'Financewolf', value: 'financewolf' }, { name: 'Renderwolf', value: 'renderwolf' }, { name: 'Public Tool', value: 'tools' }] },
+            ...operationParameters,
+            ...legacy.description.properties.slice(2).map(field => ({ ...field, displayOptions: { ...field.displayOptions, show: { ...field.displayOptions?.show, resource: ['renderwolf'] } } })),
+            ...renderOptions_1.renderOptions,
+            ...parameters_1.productParameters,
         ],
     };
-    methods = { credentialTest: { ironfangApiTest: credentialTest_1.credentialTest } };
+    methods = { ...legacy.methods, credentialTest: { ...legacy.methods.credentialTest, ironfangS3Test: destinationCredentialTest_1.destinationCredentialTest }, listSearch: { searchTemplates: templates_1.searchTemplates } };
     async execute() {
-        const items = this.getInputData();
-        const out = [];
-        const collectVars = (raw) => {
-            const vars = {};
-            for (const v of raw.values ?? []) {
-                vars[String(v.name)] = String(v.value);
-            }
-            return vars;
-        };
-        for (let i = 0; i < items.length; i++) {
-            const operation = this.getNodeParameter('operation', i);
-            const credentials = await this.getCredentials('ironfangApi');
-            const baseUrl = (0, transport_1.apiBase)(credentials.baseUrl);
-            try {
-                if (operation === 'screenshot' || operation === 'pdf') {
-                    const source = this.getNodeParameter('source', i);
-                    const body = operation === 'screenshot'
-                        ? { ...this.getNodeParameter('screenshotOptions', i) }
-                        : { ...this.getNodeParameter('pdfOptions', i) };
-                    if (source === 'url') {
-                        body.url = this.getNodeParameter('url', i);
-                    }
-                    else {
-                        body.html = this.getNodeParameter('html', i);
-                    }
-                    const data = await transport_1.request.call(this, {
-                        method: 'POST',
-                        url: `${baseUrl}/v1/${operation}`,
-                        body,
-                        encoding: 'arraybuffer',
-                    });
-                    const binaryProperty = this.getNodeParameter('binaryProperty', i);
-                    const isPdf = operation === 'pdf';
-                    const format = isPdf ? 'pdf' : (body.format || 'png');
-                    const binary = await this.helpers.prepareBinaryData(data.body, `render.${format}`, isPdf ? 'application/pdf' : `image/${format}`);
-                    out.push((0, transport_1.binaryOutput)(this, i, binaryProperty, binary, data, { operation }));
-                }
-                else if (operation === 'image') {
-                    const templateId = (0, transport_1.identifier)(this, this.getNodeParameter('templateId', i), i);
-                    const format = this.getNodeParameter('imageFormat', i);
-                    const vars = collectVars(this.getNodeParameter('vars', i));
-                    const data = await transport_1.request.call(this, {
-                        method: 'POST',
-                        url: `${baseUrl}/v1/image/${templateId}`,
-                        body: { vars, format },
-                        encoding: 'arraybuffer',
-                    });
-                    const binaryProperty = this.getNodeParameter('binaryProperty', i);
-                    const binary = await this.helpers.prepareBinaryData(data.body, `render.${format}`, `image/${format}`);
-                    out.push((0, transport_1.binaryOutput)(this, i, binaryProperty, binary, data, { operation, template: templateId }));
-                }
-                else if (operation === 'video') {
-                    const captions = this.getNodeParameter('captions', i)
-                        .values?.map((c) => ({
-                        text: String(c.text),
-                        from: Number(c.from),
-                        to: Number(c.to),
-                    }));
-                    const body = {
-                        ...this.getNodeParameter('clipOptions', i),
-                        size: this.getNodeParameter('clipSize', i),
-                        duration: this.getNodeParameter('clipDuration', i),
-                    };
-                    if (captions?.length) {
-                        body.captions = captions;
-                    }
-                    // A blank font size means "scale it with the canvas", which
-                    // is what the API does when the field is absent - sending 0
-                    // would be a request for a zero-point font.
-                    if (!body.font_size) {
-                        delete body.font_size;
-                    }
-                    const data = await transport_1.request.call(this, {
-                        method: 'POST',
-                        url: `${baseUrl}/v1/video`,
-                        body,
-                        encoding: 'arraybuffer',
-                    });
-                    const binaryProperty = this.getNodeParameter('binaryProperty', i);
-                    const binary = await this.helpers.prepareBinaryData(data.body, 'clip.mp4', 'video/mp4');
-                    out.push((0, transport_1.binaryOutput)(this, i, binaryProperty, binary, data, { operation }));
-                }
-                else if (operation === 'sign') {
-                    const kind = this.getNodeParameter('signKind', i);
-                    const body = {
-                        kind,
-                        ttl_hours: this.getNodeParameter('ttlHours', i),
-                    };
-                    if (kind === 'screenshot') {
-                        body.url = this.getNodeParameter('signUrl', i);
-                        body.full_page = this.getNodeParameter('signFullPage', i);
-                    }
-                    else {
-                        body.template = (0, transport_1.identifier)(this, this.getNodeParameter('signTemplateId', i), i);
-                        body.vars = collectVars(this.getNodeParameter('signVars', i));
-                    }
-                    const resp = await transport_1.request.call(this, { method: 'POST', url: `${baseUrl}/v1/sign`, body, json: true });
-                    out.push({ json: { ...resp.body, _ironfang: resp.metadata }, pairedItem: { item: i } });
-                }
-                else if (operation === 'usage') {
-                    const resp = await transport_1.request.call(this, { method: 'GET', url: `${baseUrl}/v1/usage`, json: true });
-                    out.push({ json: { ...resp.body, _ironfang: resp.metadata }, pairedItem: { item: i } });
-                }
-                else {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation ${operation}`, {
-                        itemIndex: i,
-                    });
-                }
-            }
-            catch (error) {
-                if (this.continueOnFail()) {
-                    out.push((0, transport_1.errorOutput)(this, error, i));
-                    continue;
-                }
-                throw (0, transport_1.apiError)(this, error, i);
-            }
-        }
-        return [out];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        if (resource === 'renderwolf' && legacyOperations.some(op => op.value === operation))
+            return legacy.execute.call(this);
+        return execute_1.executeProducts.call(this);
     }
 }
 exports.Ironfang = Ironfang;

package/dist/nodes/Ironfang/IronfangTrigger.node.d.ts

@@ -0,0 +1,11 @@
+import type { INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData } from 'n8n-workflow';
+import { webhookCredentialTest } from './webhook';
+export declare class IronfangTrigger implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        credentialTest: {
+            ironfangWebhookTest: typeof webhookCredentialTest;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/Ironfang/IronfangTrigger.node.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IronfangTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const webhook_1 = require("./webhook");
+// Endpoints are registered explicitly and remain customer-owned; n8n owns its local route.
+// eslint-disable-next-line @n8n/community-nodes/webhook-lifecycle-complete
+class IronfangTrigger {
+    description = {
+        displayName: 'Ironfang Trigger', name: 'ironfangTrigger', group: ['trigger'], version: 1,
+        icon: { light: 'file:ironfang.svg', dark: 'file:ironfang.dark.svg' },
+        subtitle: 'Signed product events', description: 'Receive signed Auditwolf and Renderwolf events', defaults: { name: 'Ironfang Trigger' },
+        inputs: [], outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        credentials: [{ name: 'ironfangWebhookApi', required: true, testedBy: 'ironfangWebhookTest' }],
+        webhooks: [{ name: 'default', httpMethod: 'POST', responseMode: 'onReceived', path: 'events' }],
+        properties: [
+            { displayName: 'Register this node’s production webhook URL using Create Webhooks (Auditwolf) or Create Destination (Renderwolf), save the returned signing secret in its credential, then activate the workflow and test the endpoint. Signatures and timestamps are checked before execution.', name: 'setupNotice', type: 'notice', default: '' },
+        ],
+    };
+    methods = { credentialTest: { ironfangWebhookTest: webhook_1.webhookCredentialTest } };
+    async webhook() {
+        const req = this.getRequestObject();
+        const res = this.getResponseObject();
+        const credentials = await this.getCredentials('ironfangWebhookApi');
+        const now = Date.now();
+        let event;
+        try {
+            if (req.headers['content-encoding'] && req.headers['content-encoding'] !== 'identity')
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Compressed webhooks are not accepted');
+            if (!req.rawBody && req.readRawBody)
+                await req.readRawBody();
+            if (!Buffer.isBuffer(req.rawBody))
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Raw webhook body is unavailable');
+            event = (0, webhook_1.verifyEvent)(req.rawBody, req.headers, String(credentials.product), String(credentials.signingSecret), now);
+        }
+        catch {
+            res.status(401).json({ error: 'Invalid signed webhook' });
+            return { noWebhookResponse: true };
+        }
+        // Only the signed body ID is trusted. Header IDs are not part of the MAC.
+        const id = String(event.id);
+        const data = this.getWorkflowStaticData('node');
+        const seen = Object.assign(Object.create(null), data.events ?? {});
+        for (const [key, received] of Object.entries(seen))
+            if (received < now - 7 * 86_400_000)
+                delete seen[key];
+        if (Object.hasOwn(seen, id))
+            return { webhookResponse: { accepted: true, duplicate: true } };
+        while (Object.keys(seen).length >= 10_000)
+            delete seen[Object.keys(seen).sort((a, b) => seen[a] - seen[b])[0]];
+        seen[id] = now;
+        data.events = seen;
+        return { webhookResponse: { accepted: true }, workflowData: [[{ json: { ...event, _ironfang: { product: String(credentials.product), verified: true, eventId: id } } }]] };
+    }
+}
+exports.IronfangTrigger = IronfangTrigger;

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

@@ -0,0 +1,2 @@
+import type { Operation } from './types';
+export declare const operations: Operation[];