@pagecrawl/n8n-nodes-pagecrawl 0.1.0

package/dist/nodes/PageCrawl/PageCrawl.node.js

@@ -0,0 +1,467 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageCrawl = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const PageDescription_1 = require("./descriptions/PageDescription");
+const CheckDescription_1 = require("./descriptions/CheckDescription");
+const ScreenshotDescription_1 = require("./descriptions/ScreenshotDescription");
+const WebhookDescription_1 = require("./descriptions/WebhookDescription");
+class PageCrawl {
+    constructor() {
+        this.description = {
+            displayName: 'PageCrawl',
+            name: 'pageCrawl',
+            icon: 'file:pagecrawl.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Interact with PageCrawl.io API for website monitoring',
+            defaults: {
+                name: 'PageCrawl',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'pageCrawlApi',
+                    required: true,
+                },
+            ],
+            requestDefaults: {
+                baseURL: '={{$credentials.baseUrl}}/api',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+            },
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Page',
+                            value: 'page',
+                            description: 'Manage tracked pages',
+                        },
+                        {
+                            name: 'Check',
+                            value: 'check',
+                            description: 'Access check history and diffs',
+                        },
+                        {
+                            name: 'Screenshot',
+                            value: 'screenshot',
+                            description: 'Get page screenshots',
+                        },
+                        {
+                            name: 'Webhook',
+                            value: 'webhook',
+                            description: 'Manage webhooks',
+                        },
+                    ],
+                    default: 'page',
+                },
+                ...PageDescription_1.pageOperations,
+                ...PageDescription_1.pageFields,
+                ...CheckDescription_1.checkOperations,
+                ...CheckDescription_1.checkFields,
+                ...ScreenshotDescription_1.screenshotOperations,
+                ...ScreenshotDescription_1.screenshotFields,
+                ...WebhookDescription_1.webhookOperations,
+                ...WebhookDescription_1.webhookFields,
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const credentials = await this.getCredentials('pageCrawlApi');
+        const baseUrl = (credentials.baseUrl || 'https://pagecrawl.io').replace(/\/+$/, '');
+        for (let i = 0; i < items.length; i++) {
+            const resource = this.getNodeParameter('resource', i);
+            const operation = this.getNodeParameter('operation', i);
+            try {
+                let responseData;
+                // Handle different resources and operations
+                if (resource === 'page') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        const options = this.getNodeParameter('options', i);
+                        const endpoint = '/pages';
+                        const qs = {};
+                        if (options.simple) {
+                            qs.simple = 1;
+                        }
+                        if (options.take) {
+                            qs.take = options.take;
+                        }
+                        if (options.folder) {
+                            qs.folder = options.folder;
+                        }
+                        if (!returnAll) {
+                            qs.limit = this.getNodeParameter('limit', i);
+                        }
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'GET',
+                            url: `${baseUrl}/api${endpoint}`,
+                            qs,
+                            json: true,
+                        });
+                        if (!returnAll && Array.isArray(responseData)) {
+                            responseData = responseData.slice(0, qs.limit);
+                        }
+                    }
+                    else if (operation === 'get') {
+                        const pageId = this.getNodeParameter('pageId', i);
+                        const options = this.getNodeParameter('options', i);
+                        const qs = {};
+                        if (options.simple) {
+                            qs.simple = 1;
+                        }
+                        if (options.take) {
+                            qs.take = options.take;
+                        }
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'GET',
+                            url: `${baseUrl}/api/pages/${pageId}`,
+                            qs,
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'createSimple') {
+                        const url = this.getNodeParameter('url', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const body = { url };
+                        if (additionalFields.selector) {
+                            body.selector = additionalFields.selector;
+                        }
+                        if (additionalFields.frequency !== undefined) {
+                            body.frequency = additionalFields.frequency;
+                        }
+                        if (additionalFields.ignore_duplicates !== undefined) {
+                            body.ignore_duplicates = additionalFields.ignore_duplicates;
+                        }
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'POST',
+                            url: `${baseUrl}/api/track-simple`,
+                            body,
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'create') {
+                        const url = this.getNodeParameter('url', i);
+                        const name = this.getNodeParameter('name', i);
+                        const frequency = this.getNodeParameter('frequency', i);
+                        const elements = this.getNodeParameter('elements', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const body = {
+                            url,
+                            name,
+                            frequency,
+                            elements: elements.element || [],
+                        };
+                        // Add all additional fields
+                        Object.assign(body, additionalFields);
+                        // Convert tags from comma-separated string to array
+                        if (typeof body.tags === 'string' && body.tags) {
+                            body.tags = body.tags.split(',').map((tag) => tag.trim()).filter(Boolean);
+                        }
+                        // Remove ID fields if they're 0 (not set)
+                        if (body.folder_id === 0)
+                            delete body.folder_id;
+                        if (body.template_id === 0)
+                            delete body.template_id;
+                        if (body.auth_id === 0)
+                            delete body.auth_id;
+                        // Parse JSON fields if they're strings
+                        if (typeof body.actions === 'string') {
+                            try {
+                                body.actions = JSON.parse(body.actions);
+                            }
+                            catch (e) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in actions field', { itemIndex: i });
+                            }
+                        }
+                        if (typeof body.rules === 'string') {
+                            try {
+                                body.rules = JSON.parse(body.rules);
+                            }
+                            catch (e) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in rules field', { itemIndex: i });
+                            }
+                        }
+                        if (typeof body.headers === 'string') {
+                            try {
+                                body.headers = JSON.parse(body.headers);
+                            }
+                            catch (e) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in headers field', { itemIndex: i });
+                            }
+                        }
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'POST',
+                            url: `${baseUrl}/api/pages`,
+                            body,
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'update') {
+                        const pageId = this.getNodeParameter('pageId', i);
+                        const updateFields = this.getNodeParameter('updateFields', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const body = { ...updateFields, ...additionalFields };
+                        // Convert tags from comma-separated string to array
+                        if (typeof body.tags === 'string' && body.tags) {
+                            body.tags = body.tags.split(',').map((tag) => tag.trim()).filter(Boolean);
+                        }
+                        // Remove ID fields if they're 0 (not set)
+                        if (body.folder_id === 0)
+                            delete body.folder_id;
+                        if (body.template_id === 0)
+                            delete body.template_id;
+                        if (body.auth_id === 0)
+                            delete body.auth_id;
+                        // Parse JSON fields if they're strings
+                        if (typeof body.elements === 'string') {
+                            try {
+                                body.elements = JSON.parse(body.elements);
+                            }
+                            catch (e) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in elements field', { itemIndex: i });
+                            }
+                        }
+                        if (typeof body.actions === 'string') {
+                            try {
+                                body.actions = JSON.parse(body.actions);
+                            }
+                            catch (e) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in actions field', { itemIndex: i });
+                            }
+                        }
+                        if (typeof body.rules === 'string') {
+                            try {
+                                body.rules = JSON.parse(body.rules);
+                            }
+                            catch (e) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in rules field', { itemIndex: i });
+                            }
+                        }
+                        if (typeof body.headers === 'string') {
+                            try {
+                                body.headers = JSON.parse(body.headers);
+                            }
+                            catch (e) {
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in headers field', { itemIndex: i });
+                            }
+                        }
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'PUT',
+                            url: `${baseUrl}/api/pages/${pageId}`,
+                            body,
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'delete') {
+                        const pageId = this.getNodeParameter('pageId', i);
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'DELETE',
+                            url: `${baseUrl}/api/pages/${pageId}`,
+                            json: true,
+                        });
+                        responseData = { success: true, deleted: pageId };
+                    }
+                    else if (operation === 'runCheckNow') {
+                        const pageId = this.getNodeParameter('pageId', i);
+                        const options = this.getNodeParameter('runCheckOptions', i);
+                        const qs = {};
+                        if (options.skip_first_notification) {
+                            qs.skip_first_notification = 1;
+                        }
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'PUT',
+                            url: `${baseUrl}/api/pages/${pageId}/check`,
+                            qs,
+                            json: true,
+                        });
+                        responseData = { success: true, message: 'Check triggered', pageId };
+                    }
+                }
+                else if (resource === 'check') {
+                    const pageId = this.getNodeParameter('pageId', i);
+                    if (operation === 'getHistory') {
+                        const options = this.getNodeParameter('options', i);
+                        const qs = {};
+                        if (options.simple) {
+                            qs.simple = 1;
+                        }
+                        if (options.take) {
+                            qs.take = options.take;
+                        }
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'GET',
+                            url: `${baseUrl}/api/pages/${pageId}/history`,
+                            qs,
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'getDiffImage') {
+                        const checkId = this.getNodeParameter('checkId', i);
+                        const response = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'GET',
+                            url: `${baseUrl}/api/pages/${pageId}/checks/${checkId}/diff.png`,
+                            encoding: 'arraybuffer',
+                        });
+                        const binaryData = await this.helpers.prepareBinaryData(response, `diff-${pageId}-${checkId}.png`, 'image/png');
+                        const executionData = this.helpers.constructExecutionMetaData([{ json: {}, binary: { data: binaryData } }], { itemData: { item: i } });
+                        returnData.push(...executionData);
+                        continue;
+                    }
+                    else if (operation === 'getDiffHtml') {
+                        const checkId = this.getNodeParameter('checkId', i);
+                        const htmlContent = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'GET',
+                            url: `${baseUrl}/api/pages/${pageId}/checks/${checkId}/diff.html`,
+                            headers: {
+                                Accept: 'text/html',
+                            },
+                        });
+                        responseData = {
+                            html: htmlContent,
+                            pageId,
+                            checkId,
+                        };
+                    }
+                    else if (operation === 'getDiffMarkdown') {
+                        const checkId = this.getNodeParameter('checkId', i);
+                        const markdownContent = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'GET',
+                            url: `${baseUrl}/api/pages/${pageId}/checks/${checkId}/diff.markdown`,
+                            headers: {
+                                Accept: 'text/markdown',
+                            },
+                        });
+                        responseData = {
+                            markdown: markdownContent,
+                            pageId,
+                            checkId,
+                        };
+                    }
+                }
+                else if (resource === 'screenshot') {
+                    const pageId = this.getNodeParameter('pageId', i);
+                    let endpoint = '';
+                    if (operation === 'getLatest') {
+                        endpoint = `/pages/${pageId}/checks/latest/screenshot`;
+                    }
+                    else if (operation === 'getLatestDiff') {
+                        endpoint = `/pages/${pageId}/checks/latest/diff`;
+                    }
+                    else if (operation === 'getCheckScreenshot') {
+                        const checkId = this.getNodeParameter('checkId', i);
+                        endpoint = `/pages/${pageId}/checks/${checkId}/screenshot`;
+                    }
+                    else if (operation === 'getCheckDiff') {
+                        const checkId = this.getNodeParameter('checkId', i);
+                        endpoint = `/pages/${pageId}/checks/${checkId}/diff`;
+                    }
+                    const response = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                        method: 'GET',
+                        url: `${baseUrl}/api${endpoint}`,
+                        encoding: 'arraybuffer',
+                    });
+                    const binaryData = await this.helpers.prepareBinaryData(response, `screenshot-${pageId}.png`, 'image/png');
+                    const executionData = this.helpers.constructExecutionMetaData([{ json: {}, binary: { data: binaryData } }], { itemData: { item: i } });
+                    returnData.push(...executionData);
+                    continue;
+                }
+                else if (resource === 'webhook') {
+                    if (operation === 'getAll') {
+                        const returnAll = this.getNodeParameter('returnAll', i);
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'GET',
+                            url: `${baseUrl}/api/hooks`,
+                            json: true,
+                        });
+                        if (!returnAll && Array.isArray(responseData)) {
+                            const limit = this.getNodeParameter('limit', i);
+                            responseData = responseData.slice(0, limit);
+                        }
+                    }
+                    else if (operation === 'create') {
+                        const target_url = this.getNodeParameter('target_url', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const body = { target_url };
+                        if (additionalFields.change_id) {
+                            body.change_id = additionalFields.change_id;
+                        }
+                        if (additionalFields.payload_fields) {
+                            body.payload_fields = additionalFields.payload_fields;
+                        }
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'POST',
+                            url: `${baseUrl}/api/hooks`,
+                            body,
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'update') {
+                        const webhookId = this.getNodeParameter('webhookId', i);
+                        const updateFields = this.getNodeParameter('updateFields', i);
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'PUT',
+                            url: `${baseUrl}/api/hooks/${webhookId}`,
+                            body: updateFields,
+                            json: true,
+                        });
+                    }
+                    else if (operation === 'delete') {
+                        const webhookId = this.getNodeParameter('webhookId', i);
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'DELETE',
+                            url: `${baseUrl}/api/hooks/${webhookId}`,
+                            json: true,
+                        });
+                        responseData = { success: true, deleted: webhookId };
+                    }
+                    else if (operation === 'test') {
+                        const webhookId = this.getNodeParameter('webhookId', i);
+                        responseData = await this.helpers.requestWithAuthentication.call(this, 'pageCrawlApi', {
+                            method: 'PUT',
+                            url: `${baseUrl}/api/hooks/${webhookId}/test`,
+                            json: true,
+                        });
+                        responseData = { success: true, message: 'Test webhook sent' };
+                    }
+                }
+                const executionData = this.helpers.constructExecutionMetaData([{ json: responseData }], { itemData: { item: i } });
+                returnData.push(...executionData);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    // Extract detailed error message from API response if available
+                    const errorMessage = error.response?.body?.message
+                        || error.response?.body?.error
+                        || error.message
+                        || 'An error occurred';
+                    const statusCode = error.statusCode || error.response?.statusCode;
+                    const executionData = this.helpers.constructExecutionMetaData([{
+                            json: {
+                                error: errorMessage,
+                                statusCode,
+                                resource,
+                                operation,
+                            },
+                        }], { itemData: { item: i } });
+                    returnData.push(...executionData);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.PageCrawl = PageCrawl;

package/dist/nodes/PageCrawl/PageCrawl.node.json

@@ -0,0 +1,22 @@
+{
+    "node": "n8n-nodes-pagecrawl.PageCrawl",
+    "nodeVersion": "1.0",
+    "codexVersion": "1.0",
+    "categories": ["Marketing & Content"],
+    "resources": {
+        "credentialDocumentation": [
+            {
+                "url": "https://pagecrawl.io/docs/api"
+            }
+        ],
+        "primaryDocumentation": [
+            {
+                "url": "https://pagecrawl.io/docs"
+            }
+        ]
+    },
+    "alias": ["Monitor", "Track", "Website", "Change Detection", "Web Scraping"],
+    "subcategories": {
+        "Marketing & Content": ["Automation", "Analytics"]
+    }
+}

package/dist/nodes/PageCrawl/descriptions/CheckDescription.d.ts

@@ -0,0 +1,3 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const checkOperations: INodeProperties[];
+export declare const checkFields: INodeProperties[];

package/dist/nodes/PageCrawl/descriptions/CheckDescription.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFields = exports.checkOperations = void 0;
+exports.checkOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['check'],
+            },
+        },
+        options: [
+            {
+                name: 'Get History',
+                value: 'getHistory',
+                description: 'Get check history for a page',
+                action: 'Get check history',
+            },
+            {
+                name: 'Get Text Diff HTML',
+                value: 'getDiffHtml',
+                description: 'Get text difference as HTML',
+                action: 'Get text diff HTML',
+            },
+            {
+                name: 'Get Text Diff Image',
+                value: 'getDiffImage',
+                description: 'Get text difference as image',
+                action: 'Get text diff image',
+            },
+            {
+                name: 'Get Text Diff Markdown',
+                value: 'getDiffMarkdown',
+                description: 'Get text difference as Markdown',
+                action: 'Get text diff markdown',
+            },
+        ],
+        default: 'getHistory',
+    },
+];
+exports.checkFields = [
+    // ========================================
+    // check:getHistory
+    // ========================================
+    {
+        displayName: 'Page ID',
+        name: 'pageId',
+        type: 'string',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['check'],
+            },
+        },
+        default: '',
+        description: 'The ID or slug of the page',
+    },
+    {
+        displayName: 'Options',
+        name: 'options',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['check'],
+                operation: ['getHistory'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Simple',
+                name: 'simple',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to return simplified response',
+            },
+            {
+                displayName: 'Take',
+                name: 'take',
+                type: 'number',
+                default: 0,
+                description: 'Limit number of checks retrieved',
+                typeOptions: {
+                    minValue: 0,
+                },
+            },
+        ],
+    },
+    // ========================================
+    // check:getDiff*
+    // ========================================
+    {
+        displayName: 'Check ID',
+        name: 'checkId',
+        type: 'string',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['check'],
+                operation: ['getDiffHtml', 'getDiffImage', 'getDiffMarkdown'],
+            },
+        },
+        default: '',
+        description: 'The check ID (use "latest" for most recent)',
+    },
+];

package/dist/nodes/PageCrawl/descriptions/PageDescription.d.ts

@@ -0,0 +1,3 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const pageOperations: INodeProperties[];
+export declare const pageFields: INodeProperties[];