n8n-nodes-unopim 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,66 @@
+# Changelog
+
+All notable changes to `n8n-nodes-unopim` are recorded here.
+
+The version in `package.json` and the newest heading in this file must always
+match. `npm run release` bumps `package.json` on its own, so the entry below it
+has to be written by hand.
+
+## Versions
+
+| Version | Date | n8n | Node.js | UnoPim | UnoPim connector package |
+|---|---|---|---|---|---|
+| 1.0.0 | not yet published | 1.x and 2.x, tested on 2.36.7 | 22 or newer | 3.0 or newer | `webkul/n8n` 1.0.0 |
+
+## 1.0.0 (not yet published)
+
+First release. Two nodes and one credential, published as a community node
+package.
+
+### Added
+
+- **UnoPim Trigger node.** Starts a workflow when the catalog changes. It
+  registers the webhook with UnoPim when the workflow is switched on and removes
+  it when the workflow is switched off, so there is nothing to set up in the
+  UnoPim admin.
+- **Seventeen events.** Created, updated and deleted for products, categories,
+  attributes and families, plus five wildcards: one per record type and
+  `catalog.any` for the whole catalog. The event list is loaded from the
+  connected instance, so it always matches what that PIM publishes.
+- **Trigger options.** Restrict deliveries to one locale or one channel, flatten
+  the value scopes onto a single namespace, and verify an HMAC SHA256 signature
+  with a shared signing secret.
+- **UnoPim action node.** Eleven resources: product, configurable product,
+  category, attribute, attribute group, attribute family, category field,
+  association type, locale, channel and currency. Each supports get many, get,
+  create, update and delete, and the first eight also support update partially.
+- **Return All.** Walks every page of a listing using UnoPim keyset pagination,
+  which stays fast on a large catalog where page offsets do not.
+- **Filters and sorting** on every get many, using UnoPim own filter syntax, so
+  a scheduled workflow can ask for only what changed since its last run.
+- **Custom API Call** for any endpoint the node does not cover, with the
+  credential already attached.
+- **Loaded dropdowns.** Locales, channels, families, attributes and categories
+  are fetched from the instance the credential points at.
+- **Agent tool support.** The action node can be attached to an AI Agent node,
+  so an agent can query and update the catalog directly.
+- **UnoPim API credential.** Laravel Passport password grant, with a connection
+  test that reports the number of events the instance publishes.
+- **Item linking.** Every output item is linked back to the input item that
+  produced it, so later nodes can trace an item to its source.
+- **Continue On Fail support.** A failed item carries an `error` field instead
+  of a record, so a workflow can branch on it.
+- **53 unit tests** run with the built in Node test runner, and a GitHub Actions
+  workflow that publishes to npm with provenance.
+
+### Notes
+
+- Access tokens are cached in the node process and refreshed shortly before they
+  expire. A 401 forces one refresh and one retry.
+- The credential rejects a URL that ends in `/admin`. The field takes the
+  application root, for example `https://demo.unopim.com`.
+- A node runs once per input item. A get many feeding a single write runs that
+  write once per record returned, which is rarely what you want for a delete.
+  Aggregate the list first.
+- This release needs the UnoPim side of the connector, the `webkul/n8n` package,
+  installed on the PIM.

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2010-2026, Webkul Software
+
+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,134 @@
+# n8n-nodes-unopim
+
+n8n community nodes for [UnoPim](https://unopim.com), the open-source Product
+Information Management system.
+
+Two nodes ship in this package:
+
+| Node | What it does |
+|---|---|
+| **UnoPim** | Reads and writes the catalog — products, categories, attributes, families and settings |
+| **UnoPim Trigger** | Starts a workflow the moment the catalog changes |
+
+[Installation](#installation) · [Credentials](#credentials) · [Operations](#operations) · [Trigger events](#trigger-events) · [Compatibility](#compatibility)
+
+## Installation
+
+Follow the
+[community nodes installation guide](https://docs.n8n.io/integrations/community-nodes/installation/)
+and install `n8n-nodes-unopim`.
+
+The trigger node also needs the UnoPim side of the connector installed on your
+PIM. See [the connector package](https://github.com/unopim/unopim-n8n) for that
+half. The action node works against a stock UnoPim install with no extra
+package.
+
+## Credentials
+
+UnoPim authenticates with Passport's password grant.
+
+1. In UnoPim, open **Configuration → Integrations → API Keys** and create a key.
+2. Copy four values from that row: Client ID, Client Secret, API Username and
+   API Password.
+3. In n8n, create a **UnoPim API** credential and paste them, along with your
+   UnoPim URL.
+
+> The **Username** is the value UnoPim generated, in the form
+> `integration+<id>@api.local`. It is not your own admin login. An admin login
+> is accepted by the form but fails every request afterwards.
+
+## Operations
+
+The UnoPim node covers eleven resources. Every resource supports **Get Many**,
+**Get**, **Create**, **Update** and **Delete**; most also support
+**Update Partially**, which sends a PATCH rather than replacing the record.
+
+| Resource | Endpoint |
+|---|---|
+| Product | `/products` |
+| Configurable Product | `/configurable-products` |
+| Category | `/categories` |
+| Attribute | `/attributes` |
+| Attribute Group | `/attribute-groups` |
+| Attribute Family | `/families` |
+| Category Field | `/category-fields` |
+| Association Type | `/association-types` |
+| Locale | `/locales` |
+| Channel | `/channels` |
+| Currency | `/currencies` |
+
+**Get Many** takes a **Return All** toggle. UnoPim caps a page at 100 rows, so
+returning everything walks the pages for you — using keyset pagination, which
+stays fast on a large catalog where page offsets do not.
+
+You can narrow a listing with UnoPim's own filter syntax:
+
+```json
+{ "sku": [{ "operator": "IN", "value": ["SHIRT-01", "SHIRT-02"] }] }
+```
+
+Dropdowns for locales, channels, families, attributes and categories are loaded
+live from the connected instance, so they always match what that PIM actually
+has.
+
+### Use with an AI agent
+
+The UnoPim node is available as a tool, so an AI Agent node can query and update
+the catalog directly — "find every product missing a description in French and
+fill it in" becomes one agent step rather than a hand-built branch.
+
+## Trigger events
+
+The trigger registers a webhook with UnoPim when the workflow is activated and
+removes it when the workflow is switched off. Nothing polls.
+
+| Entity | Events |
+|---|---|
+| Product | created · updated · deleted |
+| Category | created · updated · deleted |
+| Attribute | created · updated · deleted |
+| Attribute Family | created · updated · deleted |
+
+Five wildcards cover the case where a workflow cares that *something* changed
+rather than exactly what: `product.any`, `category.any`, `attribute.any`,
+`family.any` and `catalog.any`. Every payload carries `entity` and `reference`,
+so a workflow listening on `catalog.any` can tell a product from a family.
+
+### Options
+
+- **Locale** and **Channel** narrow the delivered values to one scope.
+- **Flatten Values** collapses the attribute value scopes onto one level
+  (`price__default__en_US`). It is off by default — n8n reads nested JSON
+  natively, and the nested shape is easier to walk in an expression.
+- **Signing Secret** makes UnoPim sign each delivery. A delivery whose
+  signature does not match is rejected.
+
+### Notes
+
+- UnoPim writes a product row and then saves its values, so creating a product
+  through the API fires both `product.created` and `product.updated`. A
+  workflow with both triggers enabled runs twice for one new product.
+- The UnoPim side delivers on a dedicated queue. Without a queue worker running
+  on that queue, no trigger ever fires.
+- If your n8n instance is not reachable from UnoPim, deliveries fail and the
+  subscription is deactivated after several consecutive failures. It
+  reactivates by itself the next time the workflow is switched on.
+
+## Compatibility
+
+- n8n 1.x and 2.x, tested on 2.36.7
+- Node.js 22 or newer
+- UnoPim 3.0 or newer
+
+## Changelog
+
+Release history is in [CHANGELOG.md](CHANGELOG.md).
+
+## Resources
+
+- [n8n community nodes documentation](https://docs.n8n.io/integrations/#community-nodes)
+- [UnoPim documentation](https://docs.unopim.com/)
+
+## License
+
+[MIT](LICENSE)

package/dist/credentials/UnoPimApi.credentials.d.ts

@@ -0,0 +1,15 @@
+import type { IAuthenticateGeneric, ICredentialDataDecryptedObject, ICredentialTestRequest, ICredentialType, IHttpRequestHelper, INodeProperties } from 'n8n-workflow';
+export declare class UnoPimApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    icon: "file:unopim.svg";
+    documentationUrl: string;
+    properties: INodeProperties[];
+    preAuthentication(this: IHttpRequestHelper, credentials: ICredentialDataDecryptedObject): Promise<{
+        sessionToken: string;
+    }>;
+    authenticate: IAuthenticateGeneric;
+    supportedNodes: string[];
+    test: ICredentialTestRequest;
+}
+export declare function normaliseBaseUrl(baseUrl: string): string;

package/dist/credentials/UnoPimApi.credentials.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnoPimApi = void 0;
+exports.normaliseBaseUrl = normaliseBaseUrl;
+const REJECTED = 'Those credentials were rejected. Copy all four values from the same row under ' +
+    'Configuration > Integrations > API Keys. The Username is the generated API username ' +
+    'in the form integration+<id>@api.local — not your own admin login.';
+class UnoPimApi {
+    name = 'unoPimApi';
+    displayName = 'UnoPim API';
+    icon = 'file:unopim.svg';
+    documentationUrl = 'https://docs.unopim.com/';
+    properties = [
+        {
+            displayName: 'UnoPim URL',
+            name: 'baseUrl',
+            type: 'string',
+            default: '',
+            placeholder: 'https://demo.unopim.com',
+            required: true,
+            description: 'Root URL of your UnoPim instance, without a trailing slash',
+        },
+        {
+            displayName: 'Client ID',
+            name: 'clientId',
+            type: 'string',
+            default: '',
+            required: true,
+            description: 'From Configuration > Integrations > API Keys in UnoPim. Create a key, then copy its Client ID.',
+        },
+        {
+            displayName: 'Client Secret',
+            name: 'clientSecret',
+            type: 'string',
+            typeOptions: { password: true },
+            default: '',
+            required: true,
+            description: 'The Client Secret on the same row as the Client ID',
+        },
+        {
+            displayName: 'Username',
+            name: 'username',
+            type: 'string',
+            default: '',
+            required: true,
+            placeholder: 'integration+1@api.local',
+            description: 'The API username on the same row, generated by UnoPim in the form integration+<id>@api.local. This is not your own admin login.',
+        },
+        {
+            displayName: 'Password',
+            name: 'password',
+            type: 'string',
+            typeOptions: { password: true },
+            default: '',
+            required: true,
+            description: 'The API password on the same row, not your own admin password',
+        },
+        {
+            displayName: 'Session Token',
+            name: 'sessionToken',
+            type: 'hidden',
+            typeOptions: { password: true },
+            default: '',
+        },
+    ];
+    async preAuthentication(credentials) {
+        const baseUrl = normaliseBaseUrl(credentials.baseUrl);
+        let response;
+        try {
+            response = (await this.helpers.httpRequest({
+                method: 'POST',
+                url: `${baseUrl}/oauth/token`,
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({
+                    grant_type: 'password',
+                    client_id: String(credentials.clientId ?? ''),
+                    client_secret: String(credentials.clientSecret ?? ''),
+                    username: String(credentials.username ?? ''),
+                    password: String(credentials.password ?? ''),
+                    scope: '',
+                }).toString(),
+                json: true,
+            }));
+        }
+        catch {
+            throw new Error(REJECTED);
+        }
+        if (!response?.access_token) {
+            throw new Error('UnoPim did not return an access token. Check that the UnoPim URL points at the application root and that /oauth/token is reachable there.');
+        }
+        return { sessionToken: response.access_token };
+    }
+    authenticate = {
+        type: 'generic',
+        properties: {
+            headers: {
+                Authorization: '=Bearer {{$credentials.sessionToken}}',
+                Accept: 'application/json',
+            },
+        },
+    };
+    supportedNodes = ['unoPim', 'unoPimTrigger'];
+    test = {
+        request: {
+            baseURL: '={{$credentials.baseUrl.replace(/\\/+$/, "")}}',
+            url: '/api/v1/rest/n8n/me',
+        },
+    };
+}
+exports.UnoPimApi = UnoPimApi;
+function normaliseBaseUrl(baseUrl) {
+    const trimmed = (baseUrl ?? '').trim().replace(/\/+$/, '');
+    if (!/^https?:\/\//i.test(trimmed)) {
+        throw new Error('The UnoPim URL must start with http:// or https://.');
+    }
+    const url = new URL(trimmed);
+    if (url.username || url.password) {
+        throw new Error('Remove the username and password from the UnoPim URL. Enter them in the fields below instead.');
+    }
+    if (url.search || url.hash) {
+        throw new Error('The UnoPim URL must not contain a query string or fragment. Use just the address, for example https://demo.unopim.com.');
+    }
+    if (/\/admin$/i.test(url.pathname)) {
+        throw new Error('Remove "/admin" from the end of the UnoPim URL. This field takes the application root, ' +
+            `for example ${trimmed.replace(/\/admin$/i, '') || 'https://demo.unopim.com'}, not the admin panel address.`);
+    }
+    return trimmed;
+}

package/dist/credentials/unopim.svg

@@ -0,0 +1,21 @@
+<svg viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<style>
+.uno-fav-quad { fill: #414361; }
+@media (prefers-color-scheme: dark) {
+.uno-fav-quad { fill: #F4F2FE; }
+}
+</style>
+<g clip-path="url(#clip0_200_7482)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M5.33333 0C2.38782 0 0 2.38781 0 5.33333V12H8V8H12V0H5.33333Z" fill="#8B5CF6"/>
+<path d="M8 4C8 1.79086 9.79085 0 12 0C14.2091 0 16 1.79086 16 4C16 6.20915 14.2091 8 12 8H8V4Z" fill="#4DCCBD"/>
+<path class="uno-fav-quad" d="M8 12C8 14.2091 6.20915 16 4 16C1.79086 16 -1.93129e-07 14.2091 0 12C1.93131e-07 9.79085 1.79086 8 4 8H8V12Z" fill="#414361"/>
+<path fill-rule="evenodd" clip-rule="evenodd" d="M5.33333 0C2.38782 0 0 2.38781 0 5.33333V12H8V8H12V0H5.33333Z" fill="#8B5CF6"/>
+<path d="M8 4C8 1.79086 9.79085 0 12 0C14.2091 0 16 1.79086 16 4C16 6.20915 14.2091 8 12 8H8V4Z" fill="#4DCCBD"/>
+<path class="uno-fav-quad" d="M8 12C8 14.2091 6.20915 16 4 16C1.79086 16 -1.93129e-07 14.2091 0 12C1.93131e-07 9.79085 1.79086 8 4 8H8V12Z" fill="#414361"/>
+</g>
+<defs>
+<clipPath id="clip0_200_7482">
+<rect width="16" height="16" fill="white"/>
+</clipPath>
+</defs>
+</svg>

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

@@ -0,0 +1,9 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+import * as loadOptions from './methods/loadOptions';
+export declare class UnoPim implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: typeof loadOptions;
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/UnoPim/UnoPim.node.js

@@ -0,0 +1,258 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnoPim = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const resources_1 = require("./actions/resources");
+const loadOptions = __importStar(require("./methods/loadOptions"));
+const transport_1 = require("./transport");
+const OPERATIONS_NEEDING_IDENTIFIER = ['get', 'update', 'patch', 'delete'];
+const OPERATIONS_NEEDING_BODY = ['create', 'update', 'patch'];
+function operationProperty() {
+    return resources_1.RESOURCES.map((resource) => ({
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: { resource: [resource.value] },
+        },
+        options: resource.operations.map((operation) => ({
+            name: resources_1.OPERATION_LABELS[operation].name,
+            value: operation,
+            action: `${resources_1.OPERATION_LABELS[operation].action} in ${resource.name.toLowerCase()}`,
+        })),
+        default: resource.operations[0],
+    }));
+}
+function identifierProperty() {
+    return resources_1.RESOURCES.map((resource) => ({
+        displayName: resource.identifier,
+        name: 'identifier',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: [resource.value],
+                operation: resource.operations.filter((operation) => OPERATIONS_NEEDING_IDENTIFIER.includes(operation)),
+            },
+        },
+        description: `The ${resource.identifier.toLowerCase()} of the ${resource.name.toLowerCase()} to act on`,
+    }));
+}
+class UnoPim {
+    description = {
+        displayName: 'UnoPim',
+        name: 'unoPim',
+        icon: 'file:unopim.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+        description: 'Read and write the UnoPim catalog',
+        defaults: {
+            name: 'UnoPim',
+        },
+        usableAsTool: true,
+        inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+        credentials: [
+            {
+                name: 'unoPimApi',
+                required: true,
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Resource',
+                name: 'resource',
+                type: 'options',
+                noDataExpression: true,
+                options: resources_1.RESOURCE_OPTIONS,
+                default: 'product',
+            },
+            ...operationProperty(),
+            ...identifierProperty(),
+            {
+                displayName: 'Data',
+                name: 'data',
+                type: 'json',
+                default: '{}',
+                required: true,
+                displayOptions: {
+                    show: {
+                        operation: OPERATIONS_NEEDING_BODY,
+                    },
+                },
+                description: 'The record body, as UnoPim\'s API expects it. For a product this is the object carrying sku, family, status and values.',
+            },
+            {
+                displayName: 'Return All',
+                name: 'returnAll',
+                type: 'boolean',
+                default: false,
+                displayOptions: {
+                    show: { operation: ['getMany'] },
+                },
+                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: ['getMany'],
+                        returnAll: [false],
+                    },
+                },
+                description: 'Max number of results to return',
+            },
+            {
+                displayName: 'Options',
+                name: 'options',
+                type: 'collection',
+                placeholder: 'Add option',
+                default: {},
+                displayOptions: {
+                    show: { operation: ['getMany'] },
+                },
+                options: [
+                    {
+                        displayName: 'Filters (JSON)',
+                        name: 'filters',
+                        type: 'json',
+                        default: '{}',
+                        description: 'UnoPim filter object, for example {"sku":[{"operator":"IN","value":["A","B"]}]}',
+                    },
+                    {
+                        displayName: 'Sort',
+                        name: 'sort',
+                        type: 'string',
+                        default: '',
+                        placeholder: 'updated_at',
+                        description: 'Column to sort by',
+                    },
+                ],
+            },
+        ],
+    };
+    methods = {
+        loadOptions,
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resourceName = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        const resource = (0, resources_1.resourceByValue)(resourceName);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const rows = await runOperation.call(this, resource.endpoint, operation, i);
+                returnData.push(...rows.map((row) => ({
+                    json: row,
+                    pairedItem: { item: i },
+                })));
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.UnoPim = UnoPim;
+async function runOperation(endpoint, operation, itemIndex) {
+    if (operation === 'getMany') {
+        return listRecords.call(this, endpoint, itemIndex);
+    }
+    const identifier = OPERATIONS_NEEDING_IDENTIFIER.includes(operation)
+        ? encodeURIComponent(this.getNodeParameter('identifier', itemIndex))
+        : '';
+    const body = OPERATIONS_NEEDING_BODY.includes(operation)
+        ? parseJsonParameter.call(this, 'data', itemIndex)
+        : {};
+    const method = {
+        create: 'POST',
+        update: 'PUT',
+        patch: 'PATCH',
+        delete: 'DELETE',
+        get: 'GET',
+        getMany: 'GET',
+    }[operation];
+    const path = operation === 'create' ? endpoint : `${endpoint}/${identifier}`;
+    const response = await transport_1.unopimApiRequest.call(this, method, path, body);
+    return [response ?? {}];
+}
+async function listRecords(endpoint, itemIndex) {
+    const options = this.getNodeParameter('options', itemIndex, {});
+    const qs = {};
+    if (options.sort) {
+        qs.sort = options.sort;
+    }
+    const filters = parseJsonParameter.call(this, 'options.filters', itemIndex, options.filters);
+    if (Object.keys(filters).length > 0) {
+        qs.filters = JSON.stringify(filters);
+    }
+    if (this.getNodeParameter('returnAll', itemIndex)) {
+        return transport_1.unopimApiRequestAllItems.call(this, endpoint, qs);
+    }
+    const limit = this.getNodeParameter('limit', itemIndex);
+    return transport_1.unopimApiRequestLimited.call(this, endpoint, limit, qs);
+}
+function parseJsonParameter(name, itemIndex, raw) {
+    const value = raw ?? this.getNodeParameter(name, itemIndex, '{}');
+    if (value === undefined || value === null || value === '') {
+        return {};
+    }
+    if (typeof value === 'object') {
+        return value;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The value in "${name}" is not valid JSON. Fix the JSON, or pass an object from a previous node.`, { itemIndex });
+    }
+}

package/dist/nodes/UnoPim/UnoPim.node.json

@@ -0,0 +1,14 @@
+{
+    "node": "n8n-nodes-unopim.unoPim",
+    "nodeVersion": "1.0",
+    "codexVersion": "1.0",
+    "categories": ["Data & Storage", "Marketing"],
+    "resources": {
+        "credentialDocumentation": [
+            { "url": "https://docs.unopim.com/" }
+        ],
+        "primaryDocumentation": [
+            { "url": "https://github.com/unopim/n8n-nodes-unopim" }
+        ]
+    }
+}