@watchflow/n8n-nodes-watchflow 0.2.0

package/README.md

@@ -0,0 +1,37 @@
+# @watchflow/n8n-nodes-watchflow
+
+This is an n8n community node for [Watchflow.io](https://www.watchflow.io/). It allows you to send heartbeats from your n8n workflows to monitor their health and execution time.
+
+## Installation
+
+Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.
+
+## Credentials
+
+To use this node, you'll need a Watchflow API Key. You can get one from the [Watchflow Dashboard](https://app.watchflow.io).
+
+## Resources & Operations
+
+### Heartbeat
+
+Monitor your scheduled tasks and cron jobs.
+
+#### Operations:
+- **Ping**: Simple heartbeat successful notification. Marks the job as successful.
+- **Start**: Signal the start of a job. Use this at the beginning of a workflow to track execution duration.
+- **Error**: Signal a job failure. Marks the job as failed and allows you to provide an error message.
+
+#### Parameters:
+- **Monitor Key**: A unique identifier for your monitor (e.g., `daily-backup`).
+- **Monitor Name**: A human-readable name for your monitor.
+- **Interval**: Expected heartbeat interval (e.g., `5m`, `1h`, `24h`).
+- **Additional Data**: Custom metrics or metadata as a JSON object.
+- **Error Message**: Description of why the job failed (only for Error operation).
+
+## Local Development
+
+See [LOCAL-DEVELOPMENT.md](./LOCAL-DEVELOPMENT.md) for instructions on how to run and test this node locally using Docker.
+
+## License
+
+[MIT](LICENSE)

package/credentials/WatchflowApi.credentials.ts

@@ -0,0 +1,46 @@
+import {
+  IAuthenticateGeneric,
+  ICredentialTestRequest,
+  ICredentialType,
+  INodeProperties,
+} from "n8n-workflow";
+
+export class WatchflowApi implements ICredentialType {
+  name = "watchflowApi";
+  displayName = "Watchflow API";
+  documentationUrl = "https://www.watchflow.io/api/";
+  properties: INodeProperties[] = [
+    {
+      displayName: "API Key",
+      name: "apiKey",
+      type: "string",
+      typeOptions: { password: true },
+      default: "",
+      description: "You can get API Key for Watchflow from https://app.watchflow.io",
+      required: true,
+    },
+  ];
+
+  authenticate: IAuthenticateGeneric = {
+    type: "generic",
+    properties: {
+      headers: {
+        "x-api-key": "={{$credentials.apiKey}}",
+      },
+    },
+  };
+
+  test: ICredentialTestRequest = {
+    request: {
+      baseURL: "https://api.watchflow.io",
+      url: "/heartbeat/ping",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: {
+        key: "n8n-credential-test",
+      },
+    },
+  };
+}

package/dist/credentials/WatchflowApi.credentials.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchflowApi = void 0;
+class WatchflowApi {
+    constructor() {
+        this.name = "watchflowApi";
+        this.displayName = "Watchflow API";
+        this.documentationUrl = "https://www.watchflow.io/api/";
+        this.properties = [
+            {
+                displayName: "API Key",
+                name: "apiKey",
+                type: "string",
+                typeOptions: { password: true },
+                default: "",
+                description: "You can get API Key for Watchflow from https://app.watchflow.io",
+                required: true,
+            },
+        ];
+        this.authenticate = {
+            type: "generic",
+            properties: {
+                headers: {
+                    "x-api-key": "={{$credentials.apiKey}}",
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: "https://api.watchflow.io",
+                url: "/heartbeat/ping",
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: {
+                    key: "n8n-credential-test",
+                },
+            },
+        };
+    }
+}
+exports.WatchflowApi = WatchflowApi;

package/dist/nodes/Watchflow/Watchflow.node.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Watchflow = void 0;
+const ApiHelper_1 = require("./modules/ApiHelper");
+const Heartbeat_1 = require("./modules/Heartbeat");
+class Watchflow {
+    constructor() {
+        this.description = {
+            displayName: 'Watchflow',
+            name: 'watchflow',
+            icon: 'file:watchflow.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Heartbeat monitoring for your cron jobs and scheduled tasks.',
+            defaults: {
+                name: 'Watchflow',
+            },
+            inputs: ["main" /* NodeConnectionType.Main */],
+            outputs: ["main" /* NodeConnectionType.Main */],
+            credentials: [
+                {
+                    name: 'watchflowApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Heartbeat',
+                            value: 'heartbeat',
+                        },
+                    ],
+                    default: 'heartbeat',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['heartbeat'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Ping',
+                            value: 'ping',
+                            action: 'Mark job as successful',
+                            description: 'Simple ping to mark job as successful',
+                        },
+                        {
+                            name: 'Start',
+                            value: 'start',
+                            action: 'Start job tracking',
+                            description: 'Start job tracking for duration measurement',
+                        },
+                        {
+                            name: 'Error',
+                            value: 'fail',
+                            action: 'Mark job as failed',
+                            description: 'Mark job as failed with error message',
+                        },
+                    ],
+                    default: 'ping',
+                },
+                {
+                    displayName: 'Monitor Key',
+                    name: 'key',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['heartbeat'],
+                        },
+                    },
+                    description: 'Unique identifier for your monitor (e.g., "daily-backup")',
+                },
+                {
+                    displayName: 'Monitor Name',
+                    name: 'name',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['heartbeat'],
+                        },
+                    },
+                    description: 'Human-readable name for your monitor',
+                },
+                {
+                    displayName: 'Interval',
+                    name: 'interval',
+                    type: 'string',
+                    default: '24h',
+                    displayOptions: {
+                        show: {
+                            resource: ['heartbeat'],
+                        },
+                    },
+                    description: 'Expected heartbeat interval (e.g., "5m", "1h", "24h"). Default: 24h',
+                },
+                {
+                    displayName: 'Error Message',
+                    name: 'error',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['heartbeat'],
+                            operation: ['fail'],
+                        },
+                    },
+                    description: 'Description of why the job failed',
+                },
+                {
+                    displayName: 'Additional Data',
+                    name: 'data',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            resource: ['heartbeat'],
+                        },
+                    },
+                    description: 'Custom metrics or metadata (JSON object)',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const apiHelper = new ApiHelper_1.ApiHelper(this);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter('resource', i);
+                if (resource === 'heartbeat') {
+                    const result = await Heartbeat_1.executeHeartbeat.call(this, apiHelper, i);
+                    returnData.push(...result);
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Watchflow = Watchflow;

package/dist/nodes/Watchflow/modules/ApiHelper.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiHelper = void 0;
+class ApiHelper {
+    constructor(executeFunctions) {
+        this.executeFunctions = executeFunctions;
+    }
+    async request(method, url, body, headers = {}, option = {}) {
+        const options = {
+            url: `https://api.watchflow.io/heartbeat${url}`,
+            method,
+            body,
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers,
+            },
+            json: true,
+            ...option,
+        };
+        return this.executeFunctions.helpers.httpRequestWithAuthentication.call(this.executeFunctions, 'watchflowApi', options);
+    }
+}
+exports.ApiHelper = ApiHelper;

package/dist/nodes/Watchflow/modules/Heartbeat.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeHeartbeat = executeHeartbeat;
+async function executeHeartbeat(apiHelper, itemIndex) {
+    const operation = this.getNodeParameter('operation', itemIndex);
+    const key = this.getNodeParameter('key', itemIndex);
+    const endpoints = {
+        ping: '/ping',
+        start: '/ping/start',
+        fail: '/ping/fail',
+    };
+    const endpoint = endpoints[operation] || '/ping';
+    const body = {
+        key,
+    };
+    if (operation === 'fail') {
+        const error = this.getNodeParameter('error', itemIndex, '');
+        if (error) {
+            body.error = error;
+        }
+    }
+    const interval = this.getNodeParameter('interval', itemIndex, '');
+    if (interval) {
+        body.interval = interval;
+    }
+    const name = this.getNodeParameter('name', itemIndex, '');
+    if (name) {
+        body.name = name;
+    }
+    let data = this.getNodeParameter('data', itemIndex, {});
+    if (typeof data === 'string') {
+        try {
+            data = JSON.parse(data);
+        }
+        catch (e) {
+            // If it's not valid JSON, leave it as is or handle accordingly
+        }
+    }
+    if (data && typeof data === 'object' && Object.keys(data).length > 0) {
+        body.data = data;
+    }
+    const responseData = await apiHelper.request('POST', endpoint, body);
+    return this.helpers.returnJsonArray(responseData);
+}

package/dist/nodes/Watchflow/watchflow.svg

@@ -0,0 +1,4 @@
+<svg width="1024" height="1024" viewBox="0 0 1024 1024" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M512 128C300.25 128 128 300.25 128 512C128 723.75 300.25 896 512 896C723.75 896 896 723.75 896 512C896 300.25 723.75 128 512 128ZM512 832C335.5 832 192 688.5 192 512C192 335.5 335.5 192 512 192C688.5 192 832 335.5 832 512C832 688.5 688.5 832 512 832Z" fill="#2D3748"/>
+<path d="M512 256C370.75 256 256 370.75 256 512C256 653.25 370.75 768 512 768C653.25 768 768 653.25 768 512C768 370.75 653.25 256 512 256ZM608 512L448 608V416L608 512Z" fill="#2D3748"/>
+</svg>

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@watchflow/n8n-nodes-watchflow",
+  "version": "0.2.0",
+  "description": "n8n node for Watchflow.io",
+  "keywords": [
+    "watchflow",
+    "heartbeat",
+    "monitoring",
+    "n8n-community-node-package"
+  ],
+  "homepage": "https://www.watchflow.io/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/watchflow/n8n-nodes-watchflow.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Henrik Lippke",
+    "email": "h@customjs.io"
+  },
+  "files": [
+    "dist",
+    "credentials"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/WatchflowApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Watchflow/Watchflow.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^16.11.7",
+    "gulp": "^4.0.2",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "type": "commonjs",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier --write ."
+  }
+}