n8n-nodes-fingrid 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mychel Garzon
+
+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

@@ -1,5 +1,7 @@
 # n8n-nodes-fingrid
 
+[![Quality gate status](https://sonarcloud.io/api/project_badges/measure?project=MychelGarzon_n8n-nodes-fingrid&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=MychelGarzon_n8n-nodes-fingrid)
+
 n8n community node for [Fingrid Open Data](https://data.fingrid.fi/en) — real-time and historical
 Finnish power grid and electricity market data (frequency, power system state, electricity shortage
 status, production/consumption, cross-border transmission, balancing and reserve markets).
@@ -8,11 +10,18 @@ status, production/consumption, cross-border transmission, balancing and reserve
 
 ## Data license
 
-Fingrid's data is published under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).
+Fingrid's data is published under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/legalcode)
+(see also the [human-readable summary](https://creativecommons.org/licenses/by/4.0/)).
 Attribution required when displaying or republishing the data:
 
 > Source Fingrid / data.fingrid.fi, license CC 4.0 BY
 
+This data is provided "as-is" without warranties of any kind, per the license terms.
+
+This node is free and open-source. If you plan to build a commercial product on top of
+Fingrid's data, review [Fingrid's Legal Terms](https://data.fingrid.fi/en) directly, as a
+separate general terms page contains language that may not apply to non-commercial use.
+
 ## Prerequisites
 
 You need a free Fingrid Open Data API key:
@@ -20,7 +29,7 @@ You need a free Fingrid Open Data API key:
 1. Go to https://data.fingrid.fi/en and sign up (email only, no company/business account required)
 2. Approve the license and terms of use
 3. You'll receive a personal API key by email immediately
-4. Rate limits: 10 requests/minute, 10,000/day
+4. Rate limits: 1 request every 2 seconds, 10,000/day
 
 ## Resources & operations
 
@@ -32,8 +41,8 @@ You need a free Fingrid Open Data API key:
   - Get File — a single dataset file
   - Get File Data — file-based data within a time range
 - **Data (multiple datasets)**
-  - Get Multiple — time series data for several datasets in one call
-  - Get Updated — data for datasets changed within a recent period
+  - Get Many — time series data for several datasets in one call
+  - Get Recently Updated — data for datasets changed within a recent period
 - **System**
   - Get Active Notifications
   - Get Health Status

package/dist/credentials/FingridApi.credentials.d.ts

@@ -0,0 +1,9 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class FingridApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/FingridApi.credentials.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FingridApi = void 0;
+class FingridApi {
+    constructor() {
+        this.name = 'fingridApi';
+        this.displayName = 'Fingrid API';
+        this.documentationUrl = 'https://data.fingrid.fi/en/instructions';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Your personal Fingrid Open Data API key. Register for free at https://data.fingrid.fi/en to get one instantly by email.',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'x-api-key': '={{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://data.fingrid.fi/api',
+                url: '/health',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.FingridApi = FingridApi;

package/dist/nodes/Fingrid/Fingrid.node.d.ts

@@ -0,0 +1,10 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, ILoadOptionsFunctions, INodeListSearchResult } from "n8n-workflow";
+export declare class Fingrid implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        listSearch: {
+            searchDatasets(this: ILoadOptionsFunctions, filter?: string): Promise<INodeListSearchResult>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Fingrid/Fingrid.node.js

@@ -0,0 +1,432 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Fingrid = void 0;
+const GenericFunctions_1 = require("./GenericFunctions");
+class Fingrid {
+    constructor() {
+        this.description = {
+            displayName: "Fingrid",
+            name: "fingrid",
+            icon: "file:fingrid.svg",
+            group: ["transform"],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: "Read Finnish power grid and electricity market data from Fingrid Open Data",
+            defaults: {
+                name: "Fingrid",
+            },
+            inputs: ["main"],
+            outputs: ["main"],
+            credentials: [
+                {
+                    name: "fingridApi",
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Resource",
+                    name: "resource",
+                    type: "options",
+                    noDataExpression: true,
+                    options: [
+                        { name: "Dataset", value: "dataset" },
+                        { name: "Data (Multiple Datasets)", value: "data" },
+                        { name: "System", value: "system" },
+                    ],
+                    default: "dataset",
+                },
+                {
+                    displayName: "Operation",
+                    name: "operation",
+                    type: "options",
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ["dataset"] } },
+                    options: [
+                        {
+                            name: "Get",
+                            value: "get",
+                            description: "Get metadata for single dataset",
+                            action: "Get dataset",
+                        },
+                        {
+                            name: "Get Data",
+                            value: "getData",
+                            description: "Get time series data for dataset within a time range",
+                            action: "Get dataset data",
+                        },
+                        {
+                            name: "Get File",
+                            value: "getFile",
+                            description: "Get single dataset file",
+                            action: "Get dataset file",
+                        },
+                        {
+                            name: "Get File Data",
+                            value: "getFileData",
+                            description: "Get file-based data for dataset within a time range",
+                            action: "Get dataset file data",
+                        },
+                        {
+                            name: "Get Latest Data",
+                            value: "getLatestData",
+                            description: "Get the most recent data point for dataset",
+                            action: "Get latest dataset data",
+                        },
+                        {
+                            name: "Search",
+                            value: "search",
+                            description: "Search / list all public datasets",
+                            action: "Search datasets",
+                        },
+                    ],
+                    default: "get",
+                },
+                {
+                    displayName: "Operation",
+                    name: "operation",
+                    type: "options",
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ["system"] } },
+                    options: [
+                        {
+                            name: "Get Active Notifications",
+                            value: "getActiveNotifications",
+                            description: "Get currently active service notifications",
+                            action: "Get active system notifications",
+                        },
+                        {
+                            name: "Get Health Status",
+                            value: "getHealthStatus",
+                            description: "Get the health status of Fingrid Open Data services",
+                            action: "Get system health status",
+                        },
+                    ],
+                    default: "getHealthStatus",
+                },
+                {
+                    displayName: "Operation",
+                    name: "operation",
+                    type: "options",
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ["data"] } },
+                    options: [
+                        {
+                            name: "Get Many",
+                            value: "getMany",
+                            description: "Get time series data for several datasets at once",
+                            action: "Get data for many datasets",
+                        },
+                        {
+                            name: "Get Recently Updated",
+                            value: "getUpdated",
+                            description: "Get data for datasets that changed within a recent period",
+                            action: "Get recently updated data",
+                        },
+                    ],
+                    default: "getMany",
+                },
+                {
+                    displayName: "Dataset ID",
+                    name: "datasetId",
+                    type: "resourceLocator",
+                    default: { mode: "list", value: "" },
+                    required: true,
+                    modes: [
+                        {
+                            displayName: "From List",
+                            name: "list",
+                            type: "list",
+                            placeholder: "Select a Dataset...",
+                            typeOptions: {
+                                searchListMethod: "searchDatasets",
+                                searchable: true,
+                            },
+                        },
+                        {
+                            displayName: "By ID",
+                            name: "id",
+                            type: "string",
+                            placeholder: "e.g. 74",
+                        },
+                    ],
+                    displayOptions: {
+                        show: {
+                            resource: ["dataset"],
+                            operation: [
+                                "get",
+                                "getData",
+                                "getLatestData",
+                                "getFile",
+                                "getFileData",
+                            ],
+                        },
+                    },
+                    description: "The numeric ID of the Fingrid dataset (find it via the 'Search' operation, or in the dataset URL on data.fingrid.fi)",
+                },
+                {
+                    displayName: "Search Text",
+                    name: "search",
+                    type: "string",
+                    placeholder: "e.g. windPower",
+                    default: "",
+                    displayOptions: {
+                        show: { resource: ["dataset"], operation: ["search"] },
+                    },
+                    description: "Free-text search across dataset names and descriptions. Leave empty to list all datasets.",
+                },
+                {
+                    displayName: "Order By",
+                    name: "orderBy",
+                    type: "string",
+                    default: "id",
+                    placeholder: "e.g. ID",
+                    displayOptions: {
+                        show: { resource: ["dataset"], operation: ["search"] },
+                    },
+                    description: "Field to sort results by when no 'Search Text' is given",
+                },
+                {
+                    displayName: "File ID",
+                    name: "fileId",
+                    type: "string",
+                    placeholder: "e.g. 12345",
+                    default: "",
+                    required: true,
+                    displayOptions: {
+                        show: { resource: ["dataset"], operation: ["getFile"] },
+                    },
+                    description: "The unique identifier of the file to retrieve",
+                },
+                {
+                    displayName: "Start Time",
+                    name: "startTime",
+                    type: "dateTime",
+                    default: "",
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ["getData", "getFileData", "getMany"],
+                        },
+                    },
+                    description: "Start of the time range to fetch, in ISO 8601 format",
+                },
+                {
+                    displayName: "End Time",
+                    name: "endTime",
+                    type: "dateTime",
+                    default: "",
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ["getData", "getFileData", "getMany"],
+                        },
+                    },
+                    description: "End of the time range to fetch, in ISO 8601 format",
+                },
+                {
+                    displayName: "Dataset IDs",
+                    name: "datasets",
+                    type: "string",
+                    placeholder: "e.g. 74,75,192",
+                    default: "",
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ["data"],
+                            operation: ["getMany", "getUpdated"],
+                        },
+                    },
+                    description: "Comma-separated list of dataset IDs, e.g. 74,75,192",
+                },
+                {
+                    displayName: "Days",
+                    name: "days",
+                    type: "number",
+                    default: 14,
+                    displayOptions: {
+                        show: { resource: ["data"], operation: ["getUpdated"] },
+                    },
+                    description: "How many days back to check for updated data",
+                },
+                {
+                    displayName: "Return All",
+                    name: "returnAll",
+                    type: "boolean",
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                "search",
+                                "getData",
+                                "getFileData",
+                                "getMany",
+                                "getUpdated",
+                            ],
+                        },
+                    },
+                    description: "Whether to return all results or only up to a given limit",
+                },
+                {
+                    displayName: "Limit",
+                    name: "limit",
+                    type: "number",
+                    typeOptions: { minValue: 1 },
+                    default: 50,
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                "search",
+                                "getData",
+                                "getFileData",
+                                "getMany",
+                                "getUpdated",
+                            ],
+                            returnAll: [false],
+                        },
+                    },
+                    description: "Max number of results to return",
+                },
+                {
+                    displayName: "Simplify",
+                    name: "simplify",
+                    type: "boolean",
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                "search",
+                                "getData",
+                                "getFileData",
+                                "getMany",
+                                "getUpdated",
+                            ],
+                        },
+                    },
+                    description: "Whether to return a streamlined version of the data without heavy metadata",
+                },
+                {
+                    displayName: "Additional Options",
+                    name: "additionalOptions",
+                    type: "collection",
+                    placeholder: "Add Option",
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            operation: [
+                                "search",
+                                "getData",
+                                "getFileData",
+                                "getMany",
+                                "getUpdated",
+                            ],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: "Page Size",
+                            name: "pageSize",
+                            type: "number",
+                            default: 20000,
+                            description: "Rows to request per page from the API when 'Return All' is on. Fingrid's own client defaults range from 250 to 20000 depending on endpoint.",
+                        },
+                        {
+                            displayName: "Sort By",
+                            name: "sortBy",
+                            type: "string",
+                            placeholder: "e.g. startTime",
+                            default: "startTime",
+                            description: "Field to sort the returned rows by",
+                        },
+                        {
+                            displayName: "Sort Order",
+                            name: "sortOrder",
+                            type: "options",
+                            options: [
+                                { name: "Ascending", value: "asc" },
+                                { name: "Descending", value: "desc" },
+                            ],
+                            default: "asc",
+                            description: "Direction to sort the results",
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            listSearch: {
+                async searchDatasets(filter) {
+                    const qs = { pageSize: 50 };
+                    if (filter) {
+                        qs.search = filter;
+                    }
+                    const responseData = await this.helpers.httpRequestWithAuthentication.call(this, "fingridApi", {
+                        method: "GET",
+                        url: "https://data.fingrid.fi/api/datasets",
+                        qs,
+                        json: true,
+                    });
+                    const datasets = Array.isArray(responseData.data)
+                        ? responseData.data
+                        : [];
+                    return {
+                        results: datasets.map((dataset) => ({
+                            name: dataset.nameEn || dataset.nameFi || `Dataset ${dataset.id}`,
+                            value: dataset.id,
+                        })),
+                    };
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter("resource", 0);
+        const operation = this.getNodeParameter("operation", 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const { endpoint, qs } = GenericFunctions_1.buildRequestParams.call(this, resource, operation, i);
+                let results = GenericFunctions_1.PAGINATED_OPERATIONS.includes(operation)
+                    ? await GenericFunctions_1.fetchPaginated.call(this, endpoint, qs, i)
+                    : await GenericFunctions_1.fetchSingle.call(this, endpoint, qs, i);
+                const SIMPLIFIABLE_OPERATIONS = [
+                    "search",
+                    "getData",
+                    "getFileData",
+                    "getMany",
+                    "getUpdated",
+                ];
+                const simplify = SIMPLIFIABLE_OPERATIONS.includes(operation)
+                    ? this.getNodeParameter("simplify", i, true)
+                    : false;
+                if (simplify) {
+                    results = results.map((item) => {
+                        return {
+                            value: item.value,
+                            startTime: item.startTime,
+                            endTime: item.endTime,
+                            datasetId: item.datasetId,
+                        };
+                    });
+                }
+                returnData.push(...results.map((item) => ({
+                    json: item,
+                    pairedItem: { item: i },
+                })));
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Fingrid = Fingrid;

package/dist/nodes/Fingrid/GenericFunctions.d.ts

@@ -0,0 +1,11 @@
+import type { IDataObject, IExecuteFunctions } from "n8n-workflow";
+export declare const BASE_URL = "https://data.fingrid.fi/api";
+export declare const PAGINATED_OPERATIONS: string[];
+export declare function respectRateLimit(): Promise<void>;
+export interface RequestParams {
+    endpoint: string;
+    qs: IDataObject;
+}
+export declare function buildRequestParams(this: IExecuteFunctions, resource: string, operation: string, i: number): RequestParams;
+export declare function fetchPaginated(this: IExecuteFunctions, endpoint: string, qs: IDataObject, i: number): Promise<IDataObject[]>;
+export declare function fetchSingle(this: IExecuteFunctions, endpoint: string, qs: IDataObject, i: number): Promise<IDataObject[]>;

package/dist/nodes/Fingrid/GenericFunctions.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAGINATED_OPERATIONS = exports.BASE_URL = void 0;
+exports.respectRateLimit = respectRateLimit;
+exports.buildRequestParams = buildRequestParams;
+exports.fetchPaginated = fetchPaginated;
+exports.fetchSingle = fetchSingle;
+const n8n_workflow_1 = require("n8n-workflow");
+exports.BASE_URL = "https://data.fingrid.fi/api";
+exports.PAGINATED_OPERATIONS = [
+    "search",
+    "getData",
+    "getFileData",
+    "getMany",
+    "getUpdated",
+];
+const MIN_REQUEST_INTERVAL_MS = 2200;
+let lastRequestTimestamp = 0;
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function respectRateLimit() {
+    const elapsed = Date.now() - lastRequestTimestamp;
+    if (elapsed < MIN_REQUEST_INTERVAL_MS) {
+        await sleep(MIN_REQUEST_INTERVAL_MS - elapsed);
+    }
+    lastRequestTimestamp = Date.now();
+}
+async function requestWithRateLimitHandling(options, i) {
+    var _a, _b;
+    try {
+        return await this.helpers.httpRequestWithAuthentication.call(this, "fingridApi", options);
+    }
+    catch (error) {
+        const statusCode = (_a = error.statusCode) !== null && _a !== void 0 ? _a : (_b = error.response) === null || _b === void 0 ? void 0 : _b.statusCode;
+        if (statusCode === 429) {
+            throw new n8n_workflow_1.NodeApiError(this.getNode(), error, {
+                message: "Fingrid API rate limit exceeded",
+                description: "Fingrid allows 1 request every 2 seconds per API key. Wait a moment and try again, or reduce 'Page Size' if using 'Return All'.",
+                itemIndex: i,
+            });
+        }
+        throw error;
+    }
+}
+function buildDatasetRequest(operation, i) {
+    const qs = {};
+    if (operation === "get") {
+        const datasetId = this.getNodeParameter("datasetId", i);
+        return { endpoint: `/datasets/${datasetId}`, qs };
+    }
+    if (operation === "search") {
+        const search = this.getNodeParameter("search", i);
+        const orderBy = this.getNodeParameter("orderBy", i);
+        if (search)
+            qs.search = search;
+        if (orderBy)
+            qs.orderBy = orderBy;
+        Object.assign(qs, this.getNodeParameter("additionalOptions", i, {}));
+        return { endpoint: "/datasets", qs };
+    }
+    if (operation === "getData") {
+        const datasetId = this.getNodeParameter("datasetId", i);
+        qs.startTime = this.getNodeParameter("startTime", i);
+        qs.endTime = this.getNodeParameter("endTime", i);
+        Object.assign(qs, this.getNodeParameter("additionalOptions", i, {}));
+        return { endpoint: `/datasets/${datasetId}/data`, qs };
+    }
+    if (operation === "getLatestData") {
+        const datasetId = this.getNodeParameter("datasetId", i);
+        return { endpoint: `/datasets/${datasetId}/data/latest`, qs };
+    }
+    if (operation === "getFile") {
+        const datasetId = this.getNodeParameter("datasetId", i);
+        const fileId = this.getNodeParameter("fileId", i);
+        return { endpoint: `/datasets/${datasetId}/files/${fileId}`, qs };
+    }
+    if (operation === "getFileData") {
+        const datasetId = this.getNodeParameter("datasetId", i);
+        qs.startTime = this.getNodeParameter("startTime", i);
+        qs.endTime = this.getNodeParameter("endTime", i);
+        Object.assign(qs, this.getNodeParameter("additionalOptions", i, {}));
+        return { endpoint: `/datasets/${datasetId}/files`, qs };
+    }
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The dataset operation "${operation}" is not recognized.`, {
+        itemIndex: i,
+        message: `The dataset 'Operation' "${operation}" is not recognized.`,
+        description: "Select a valid 'Operation' from the dropdown menu to continue.",
+    });
+}
+function buildDataRequest(operation, i) {
+    const datasetsRaw = this.getNodeParameter("datasets", i);
+    const qs = {
+        datasets: datasetsRaw
+            .split(",")
+            .map((d) => d.trim())
+            .filter((d) => d.length > 0)
+            .join(","),
+    };
+    if (operation === "getMany") {
+        qs.startTime = this.getNodeParameter("startTime", i);
+        qs.endTime = this.getNodeParameter("endTime", i);
+        Object.assign(qs, this.getNodeParameter("additionalOptions", i, {}));
+        return { endpoint: "/data", qs };
+    }
+    if (operation === "getUpdated") {
+        qs.days = this.getNodeParameter("days", i);
+        Object.assign(qs, this.getNodeParameter("additionalOptions", i, {}));
+        return { endpoint: "/data/updates", qs };
+    }
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The data operation "${operation}" is not recognized.`, {
+        itemIndex: i,
+        message: `The data 'Operation' "${operation}" is not recognized.`,
+        description: "Select a valid 'Operation' from the dropdown menu to continue.",
+    });
+}
+function buildSystemRequest(operation, i) {
+    if (operation === "getActiveNotifications") {
+        return { endpoint: "/notifications/active", qs: {} };
+    }
+    if (operation === "getHealthStatus") {
+        return { endpoint: "/health", qs: {} };
+    }
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The system operation "${operation}" is not recognized.`, {
+        itemIndex: i,
+        message: `The system 'Operation' "${operation}" is not recognized.`,
+        description: "Select a valid 'Operation' from the dropdown menu to continue.",
+    });
+}
+function buildRequestParams(resource, operation, i) {
+    if (resource === "dataset")
+        return buildDatasetRequest.call(this, operation, i);
+    if (resource === "data")
+        return buildDataRequest.call(this, operation, i);
+    if (resource === "system")
+        return buildSystemRequest.call(this, operation, i);
+    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The 'Resource' "${resource}" is not recognized.`, {
+        itemIndex: i,
+        description: "Select a valid 'Resource' (Dataset, Data, or System) from the dropdown menu to continue.",
+    });
+}
+async function fetchPaginated(endpoint, qs, i) {
+    var _a;
+    const returnAll = this.getNodeParameter("returnAll", i, false);
+    const limit = this.getNodeParameter("limit", i, 50);
+    const pageSize = qs.pageSize || 20000;
+    const collected = [];
+    let page = 1;
+    let lastPage = 1;
+    do {
+        await respectRateLimit();
+        const pageQs = { ...qs, page, pageSize };
+        const response = await requestWithRateLimitHandling.call(this, {
+            method: "GET",
+            url: `${exports.BASE_URL}${endpoint}`,
+            qs: pageQs,
+            json: true,
+        }, i);
+        const pageData = Array.isArray(response)
+            ? response
+            : ((_a = response.data) !== null && _a !== void 0 ? _a : []);
+        collected.push(...pageData);
+        const pagination = response.pagination;
+        lastPage = pagination ? pagination.lastPage : 1;
+        if (!returnAll && collected.length >= limit)
+            break;
+        page += 1;
+    } while (returnAll && page <= lastPage);
+    return returnAll ? collected : collected.slice(0, limit);
+}
+async function fetchSingle(endpoint, qs, i) {
+    const responseData = await requestWithRateLimitHandling.call(this, {
+        method: "GET",
+        url: `${exports.BASE_URL}${endpoint}`,
+        qs,
+        json: true,
+    }, i);
+    if (Array.isArray(responseData)) {
+        return responseData;
+    }
+    if (responseData &&
+        typeof responseData === "object" &&
+        Array.isArray(responseData.data)) {
+        return responseData.data;
+    }
+    return [responseData];
+}

package/dist/nodes/Fingrid/fingrid.svg

@@ -0,0 +1,5 @@
+<svg width="60" height="60" viewBox="0 0 60 60" xmlns="http://www.w3.org/2000/svg">
+  <rect width="60" height="60" rx="8" fill="#E30613"/>
+  <path d="M15 42 L15 18 L32 18 L32 24 L21 24 L21 28 L30 28 L30 34 L21 34 L21 42 Z" fill="white"/>
+  <path d="M38 18 L44 18 L44 42 L38 42 Z" fill="white"/>
+</svg>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-fingrid",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "n8n community node for Fingrid Open Data — Finnish power grid and electricity market data",
   "keywords": [
     "n8n-community-node-package",
@@ -19,17 +19,20 @@
     "type": "git",
     "url": "git+https://github.com/MychelGarzon/n8n-nodes-fingrid.git"
   },
-  "main": "index.js",
   "scripts": {
     "build": "npx rimraf dist && tsc && npx gulp build:icons",
     "dev": "tsc --watch",
     "format": "prettier nodes credentials --write",
     "lint": "eslint nodes credentials package.json",
     "lintfix": "eslint nodes credentials package.json --fix",
-   "prepublishOnly": "echo skip"
+    "lint:n8n": "n8n-node lint",
+    "prepublishOnly": "npm run build && npm run lint -c .eslintrc.prepublish.js nodes credentials package.json",
+    "release": "n8n-node release",
+    "test": "jest "
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/test/**"
   ],
   "n8n": {
     "n8nNodesApiVersion": 1,
@@ -41,12 +44,17 @@
     ]
   },
   "devDependencies": {
+    "@n8n/node-cli": "^0.44.5",
+    "@types/jest": "^30.0.0",
     "@typescript-eslint/parser": "~8.32.0",
+    "eslint": "8.57.0",
     "eslint-plugin-n8n-nodes-base": "^1.16.3",
     "gulp": "^5.0.0",
+    "jest": "^30.4.2",
     "n8n-core": "^1.14.1",
     "n8n-workflow": "^1.82.0",
     "prettier": "^3.5.3",
+    "ts-jest": "^29.4.12",
     "typescript": "^5.8.2"
   },
   "peerDependencies": {