@finlight/n8n-nodes-finlight 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,91 @@
+# @finlight/n8n-nodes-finlight
+
+**Official n8n integration for [finlight](https://finlight.me)** — a real-time news and finance API for geopolitics, markets, and macro headlines.
+
+This package adds native nodes to [n8n](https://n8n.io) to let you consume and query finlight data inside your automated workflows.
+
+---
+
+## ✨ Features
+
+- ✅ `finlight Webhook Trigger` — Listen to live streaming events
+- ✅ `finlight Article Search` — Query articles via REST API with flexible filters
+- 🔐 Supports API Key and Basic Auth
+
+---
+
+## 🚀 Installation
+
+If you're using a self-hosted n8n instance:
+
+```bash
+npm install @finlight/n8n-nodes-finlight
+````
+
+Then set the custom extension path in your environment or config:
+
+```env
+N8N_CUSTOM_EXTENSIONS=/path/to/node_modules/@finlight/n8n-nodes-finlight
+```
+
+Restart n8n and you'll see the `finlight` nodes available in the editor.
+
+---
+
+## 🧪 Included Nodes
+
+### 🔔 `finlight Webhook Trigger`
+
+Listen to webhook events sent from finlight (e.g. breaking news, alerts, geopolitical headlines).
+
+**Manual webhook registration is required.**
+
+You can create webhooks in your account at:
+🔧 [app.finlight.me](https://app.finlight.me)
+
+Authentication options:
+
+* `x-finlight-key` header
+* Basic Auth
+
+---
+
+### 📡 `finlight Article Search`
+
+Fetch news articles from the finlight `/v2/articles` REST API using a flexible set of parameters:
+
+* `query`
+* `sources` (array)
+* `excludeSources` (array)
+* `tickers` (array)
+* `from`, `to`, `language`, `order`, `page`, `pageSize`
+* `includeContent`, `includeEntities`, `excludeEmptyContent`
+
+See full API reference at:
+📚 [docs.finlight.me](https://docs.finlight.me)
+
+---
+
+## 📦 Development
+
+Clone the repo and build:
+
+```bash
+npm install
+npm run build
+```
+
+To test with your local n8n instance:
+
+```bash
+export N8N_CUSTOM_EXTENSIONS=/absolute/path/to/dist
+n8n start
+```
+
+Or map `dist/` into Docker if using a container setup.
+
+---
+
+## 📘 License
+
+[MIT](./LICENSE) – by [finlight](https://finlight.me)

package/dist/nodes/finlight/actions/FinlightArticleSearch.node.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinlightArticleSearch = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class FinlightArticleSearch {
+    constructor() {
+        this.description = {
+            displayName: "finlight Article Search",
+            name: "finlightArticleSearch",
+            group: ["transform"],
+            version: 1,
+            description: "Search articles using the finlight REST API",
+            defaults: {
+                name: "finlight Article Search",
+            },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            icon: "file:../finlight.svg",
+            credentials: [
+                {
+                    name: "finlightApi",
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Query",
+                    name: "query",
+                    type: "string",
+                    required: false,
+                    default: "",
+                },
+                {
+                    displayName: "Sources",
+                    name: "sources",
+                    type: "fixedCollection",
+                    placeholder: "Add Source",
+                    default: {},
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    options: [
+                        {
+                            name: "sourceList",
+                            displayName: "Source List",
+                            values: [
+                                {
+                                    displayName: "Source",
+                                    name: "source",
+                                    type: "string",
+                                    default: "",
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: "Exclude Sources",
+                    name: "excludeSources",
+                    type: "fixedCollection",
+                    placeholder: "Exclude Source",
+                    default: {},
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    options: [
+                        {
+                            name: "sourceList",
+                            displayName: "Source List",
+                            values: [
+                                {
+                                    displayName: "Source",
+                                    name: "source",
+                                    type: "string",
+                                    default: "",
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: "From (ISO date)",
+                    name: "from",
+                    type: "string",
+                    default: "",
+                },
+                {
+                    displayName: "To (ISO date)",
+                    name: "to",
+                    type: "string",
+                    default: "",
+                },
+                {
+                    displayName: "Language",
+                    name: "language",
+                    type: "string",
+                    default: "en",
+                },
+                {
+                    displayName: "Order",
+                    name: "order",
+                    type: "options",
+                    options: [
+                        { name: "DESC", value: "DESC" },
+                        { name: "ASC", value: "ASC" },
+                    ],
+                    default: "DESC",
+                },
+                {
+                    displayName: "Page Size",
+                    name: "pageSize",
+                    type: "number",
+                    default: 20,
+                    typeOptions: { minValue: 1, maxValue: 100 },
+                },
+                {
+                    displayName: "Page",
+                    name: "page",
+                    type: "number",
+                    default: 1,
+                    typeOptions: { minValue: 1 },
+                },
+                {
+                    displayName: "Include Content",
+                    name: "includeContent",
+                    type: "boolean",
+                    default: false,
+                },
+                {
+                    displayName: "Include Entities",
+                    name: "includeEntities",
+                    type: "boolean",
+                    default: false,
+                },
+                {
+                    displayName: "Exclude Empty Content",
+                    name: "excludeEmptyContent",
+                    type: "boolean",
+                    default: false,
+                },
+                {
+                    displayName: "Tickers",
+                    name: "tickers",
+                    type: "fixedCollection",
+                    placeholder: "Add Ticker",
+                    default: {},
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    options: [
+                        {
+                            name: "tickerList",
+                            displayName: "Ticker List",
+                            values: [
+                                {
+                                    displayName: "Ticker",
+                                    name: "ticker",
+                                    type: "string",
+                                    default: "",
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const apiKey = (await this.getCredentials("finlightApi"));
+        for (let i = 0; i < items.length; i++) {
+            const body = {};
+            const query = this.getNodeParameter("query", i);
+            if (query)
+                body.query = query;
+            const from = this.getNodeParameter("from", i);
+            if (from)
+                body.from = from;
+            const to = this.getNodeParameter("to", i);
+            if (to)
+                body.to = to;
+            const sourcesRaw = this.getNodeParameter("sources.sourceList", i, []);
+            if (sourcesRaw.length) {
+                body.sources = sourcesRaw.map(s => s.source);
+            }
+            const excludeSourcesRaw = this.getNodeParameter("excludeSources.sourceList", i, []);
+            if (excludeSourcesRaw.length) {
+                body.excludeSources = excludeSourcesRaw.map(s => s.source);
+            }
+            const tickersRaw = this.getNodeParameter("tickers.tickerList", i, []);
+            if (tickersRaw.length) {
+                body.tickers = tickersRaw.map(t => t.ticker);
+            }
+            body.language = this.getNodeParameter("language", i);
+            body.order = this.getNodeParameter("order", i);
+            body.pageSize = this.getNodeParameter("pageSize", i);
+            body.page = this.getNodeParameter("page", i);
+            body.includeContent = this.getNodeParameter("includeContent", i);
+            body.includeEntities = this.getNodeParameter("includeEntities", i);
+            body.excludeEmptyContent = this.getNodeParameter("excludeEmptyContent", i);
+            const response = await this.helpers.httpRequest({
+                method: "POST",
+                url: "https://api.finlight.me/v2/articles",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": apiKey.apiKey,
+                },
+                body,
+                json: true,
+            });
+            returnData.push(...(Array.isArray(response.articles) ? response.articles : [response]));
+        }
+        return [this.helpers.returnJsonArray(returnData)];
+    }
+}
+exports.FinlightArticleSearch = FinlightArticleSearch;

package/dist/nodes/finlight/credentials/FinlightApi.credentials.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinlightApi = void 0;
+class FinlightApi {
+    constructor() {
+        this.name = "finlightApi";
+        this.displayName = "finlight API Key";
+        this.properties = [
+            {
+                displayName: "API Key",
+                name: "apiKey",
+                type: "string",
+                default: "",
+            },
+        ];
+    }
+}
+exports.FinlightApi = FinlightApi;

package/dist/nodes/finlight/helpers/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/finlight/helpers/utils.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthHeaders = getAuthHeaders;
+function getAuthHeaders(params) {
+    const headers = {};
+    if (params.authentication === "apiKey" && params.apiKey) {
+        headers["x-finlight-key"] = params.apiKey;
+    }
+    if (params.authentication === "basicAuth" && params.credentials) {
+        const token = Buffer.from(`${params.credentials.user}:${params.credentials.password}`).toString("base64");
+        headers["Authorization"] = `Basic ${token}`;
+    }
+    return headers;
+}

package/dist/nodes/finlight/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodes = void 0;
+const FinlightWebhookTrigger_node_1 = require("./triggers/FinlightWebhookTrigger.node");
+const FinlightArticleSearch_node_1 = require("./actions/FinlightArticleSearch.node");
+exports.nodes = [FinlightWebhookTrigger_node_1.FinlightWebhookTrigger, FinlightArticleSearch_node_1.FinlightArticleSearch];

package/dist/nodes/finlight/triggers/FinlightWebhookTrigger.node.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinlightWebhookTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class FinlightWebhookTrigger {
+    constructor() {
+        this.description = {
+            displayName: "finlight Webhook Trigger",
+            name: "finlightWebhookTrigger",
+            group: ["trigger"],
+            version: 1,
+            description: "Triggers on new webhook events from finlight",
+            defaults: {
+                name: "finlight Webhook Trigger",
+            },
+            inputs: [],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: "finlightApi",
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authentication: ["apiKey"],
+                        },
+                    },
+                },
+                {
+                    name: "httpBasicAuth",
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            authentication: ["basicAuth"],
+                        },
+                    },
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Authentication Method",
+                    name: "authentication",
+                    type: "options",
+                    options: [
+                        { name: "API Key Header (x-finlight-key)", value: "apiKey" },
+                        { name: "Basic Auth", value: "basicAuth" },
+                        { name: "None", value: "none" },
+                    ],
+                    default: "apiKey",
+                },
+            ],
+            webhooks: [
+                {
+                    name: "default",
+                    httpMethod: "POST",
+                    responseMode: "onReceived",
+                    path: "finlight",
+                },
+            ],
+            documentationUrl: "https://docs.finlight.me",
+            icon: "file:../finlight.svg",
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    return true;
+                },
+                async create() {
+                    return true;
+                },
+                async delete() {
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const req = this.getRequestObject();
+        const headers = req.headers;
+        const body = req.body;
+        const rawBody = this.getBodyData(); // raw JSON string, not parsed
+        const authMethod = this.getNodeParameter("authentication", "");
+        // Auth: API Key Header
+        if (authMethod === "apiKey") {
+            const expectedKey = this.getNodeParameter("apiKey", "");
+            const receivedKey = headers["x-finlight-key"];
+            if (!receivedKey || receivedKey !== expectedKey) {
+                throw new Error("Unauthorized: Invalid API key");
+            }
+        }
+        // Auth: Basic
+        if (authMethod === "basicAuth") {
+            const credentials = await this.getCredentials("httpBasicAuth");
+            const authHeader = headers["authorization"];
+            const expected = "Basic " + Buffer.from(`${credentials.user}:${credentials.password}`).toString("base64");
+            if (authHeader !== expected) {
+                throw new Error("Unauthorized: Invalid Basic Auth");
+            }
+        }
+        // Build clean output with optional fields
+        const payload = body;
+        const output = {
+            link: payload.link,
+            source: payload.source,
+            title: payload.title,
+            publishDate: payload.publishDate,
+            language: payload.language,
+        };
+        if (payload.summary)
+            output.summary = payload.summary;
+        if (payload.content)
+            output.content = payload.content;
+        if (payload.sentiment)
+            output.sentiment = payload.sentiment;
+        if (payload.confidence)
+            output.confidence = payload.confidence;
+        if (payload.images?.length)
+            output.images = payload.images;
+        if (payload.companies?.length)
+            output.companies = payload.companies;
+        return {
+            workflowData: [[{ json: output }]],
+        };
+    }
+}
+exports.FinlightWebhookTrigger = FinlightWebhookTrigger;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@finlight/n8n-nodes-finlight",
+  "version": "0.1.0",
+  "description": "Official n8n integration for finlight: real-time finance and news API",
+  "author": {
+    "name": "Ali Büyükkakac",
+    "email": "ali@finlight.me"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jubeiargh/n8n-nodes-finlight.git"
+  },
+  "engines": {
+    "node": ">=20.15"
+  },
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint . --ext .ts",
+    "test": "jest"
+  },
+  "dependencies": {
+    "n8n-core": "^1.14.1",
+    "n8n-workflow": "*"
+  },
+  "devDependencies": {
+    "@types/node": "^24.1.0",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
+    "eslint": "^9.32.0",
+    "eslint-plugin-n8n-nodes-base": "^1.16.3",
+    "jest": "^29.4.0",
+    "ts-jest": "^29.4.0",
+    "typescript": "^5.8.3"
+  },
+  "keywords": [
+    "finlight",
+    "webhook",
+    "finance",
+    "news",
+    "n8n-community-node-package"
+  ],
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/nodes/finlight/credentials/FinlightApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/finlight/triggers/FinlightWebhookTrigger.node.js",
+      "dist/nodes/finlight/actions/FinlightArticleSearch.node.js"
+    ]
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}