@limetech/n8n-nodes-lime 0.4.0 → 2.3.1-dev.1

package/nodes/lime-crm/utils/propertyAdapters.ts

@@ -0,0 +1,75 @@
+/**
+ * Set of helper functions, classes and types used for adapting the data from
+ * N8N's simple fields to Lime CRM format
+ */
+
+import { LimetypeProperty } from '../models';
+import { YES_NO_PROPERTY_TYPE, PropertyTypeMap } from '../models';
+
+/**
+ * Base inteface for Property Adapter class
+ */
+interface PropertyAdapter<T> {
+    adapt(value: string): T | string;
+}
+
+/**
+ * Adapter which takes a string from user input and parses it into boolean to
+ * conform to Lime CRM's YesNo type
+ */
+class YesNoPropertyAdapter implements PropertyAdapter<boolean> {
+    adapt(value: string): boolean | string {
+        if (value == 'true') {
+            return true;
+        } else if (value == 'false') {
+            return false;
+        }
+        return value;
+    }
+}
+
+/**
+ * Factory class which returns the proper adapter based on data type
+ * @param propertyType
+ */
+function getPropertyAdapter(
+    propertyType: string
+): PropertyAdapter<PropertyTypeMap[keyof PropertyTypeMap]> | null {
+    if (propertyType == YES_NO_PROPERTY_TYPE) {
+        return new YesNoPropertyAdapter();
+    }
+    return null;
+}
+
+/**
+ * Main function which takes the value from simple fields mode and the type of
+ * property and parses it accordingly to what Lime CRM expects
+ * @param propertyValue - user input, always string
+ * @param propertyType - type of property from Lime CRM
+ *
+ * @public
+ * @group Utils
+ */
+export function adaptProperty(propertyValue: string, propertyType: string) {
+    const adapter = getPropertyAdapter(propertyType);
+    return adapter === null ? propertyValue : adapter.adapt(propertyValue);
+}
+
+/**
+ * Given the name of the property and the set of Limetype properties, return the
+ * property type
+ * @param propertyName - name of the property we want to get the type of
+ * @param properties - list of {@link LimetypeProperty} entries
+ *
+ * @public
+ * @group Utils
+ */
+export function getPropertyType(
+    propertyName: string,
+    properties: LimetypeProperty[]
+): string {
+    return (
+        properties.find((property) => property.name === propertyName)?.type ||
+        'string'
+    );
+}

package/nodes/lime-crm/utils/webhook.ts

@@ -0,0 +1,81 @@
+import { Webhook, WebhookContext, WebhookFunctions } from '../models';
+
+/**
+ * Extract and format event identifiers from the node parameters.
+ *
+ * Builds an array of event strings in the format `<limetype>.<eventType>`
+ * based on the selected events.
+ *
+ * @param hookData - The n8n hook context
+ * @returns An array of formatted event strings.
+ *
+ * @internal
+ * @group Utils
+ */
+function getEvents(hookData: WebhookFunctions): string[] {
+    const eventData = hookData.getNodeParameter('events', []) as {
+        event: Array<{
+            limetype: string;
+            eventType: string;
+        }>;
+    };
+    const eventItems = eventData.event;
+    const events: string[] = [];
+    for (const eventItem of eventItems) {
+        events.push(`${eventItem.limetype}.${eventItem.eventType}`);
+    }
+    return events;
+}
+
+/**
+ * Generate a unique webhook name based on the selected Lime type and event.
+ *
+ * The name is constructed using the format:
+ * `<limetype>-<eventType>-<timestamp>`, ensuring uniqueness for each webhook.
+ *
+ * @param hookData - The n8n hook context used to access node parameters
+ * @returns A unique webhook name string.
+ *
+ * @internal
+ * @group Utils
+ */
+function createWebhookName(hookData: WebhookFunctions): string {
+    interface Events {
+        event: Array<{
+            limetype: string;
+            eventType: string;
+        }>;
+    }
+
+    const events = hookData.getNodeParameter('events') as Events;
+    return `${events.event[0].limetype}-${events.event[0].eventType}-${Date.now()}`;
+}
+
+/**
+ * Retrieve a fully constructed webhook object from the given node context.
+ *
+ * @param hookData - The n8n node context
+ *
+ * @returns A {@link Webhook} object with a generated name
+ *
+ * @public
+ * @group Utils
+ */
+export function getWebhook(hookData: WebhookFunctions): Webhook {
+    const node = hookData.getNode();
+    const workflow = hookData.getWorkflow();
+    const context: WebhookContext = {
+        nodeId: node.id,
+        nodeName: node.name,
+        workflowId: workflow.id,
+        workflowName: workflow.name,
+    };
+
+    return {
+        data: hookData.getWorkflowStaticData('node'),
+        events: getEvents(hookData),
+        url: hookData.getNodeWebhookUrl('default'),
+        context: context,
+        name: createWebhookName(hookData),
+    };
+}

package/nodes/modules.ts

@@ -0,0 +1,44 @@
+import { INodeProperties, INodePropertyOptions } from 'n8n-workflow';
+
+/**
+ * Helper class describing a typical module for .operation.ts files
+ */
+interface N8NOperationModule {
+    description: INodePropertyOptions;
+    properties?: INodeProperties[];
+}
+
+/**
+ * Utility class used to simplify handling modules in N8N classes and
+ * show them in a standardized way
+ */
+export class N8NOperationModuleHandler {
+    modules: N8NOperationModule[];
+
+    /**
+     * Constructor class
+     * @param modules - list of modules for a given resource
+     */
+    constructor(modules: N8NOperationModule[]) {
+        this.modules = modules.sort((operation1, operation2) =>
+            operation1.description.name.localeCompare(
+                operation2.description.name,
+                'en'
+            )
+        );
+    }
+
+    /**
+     * Return descriptions for all the modules for a given resource
+     */
+    getDescriptions(): INodePropertyOptions[] {
+        return this.modules.map((operation) => operation.description);
+    }
+
+    /**
+     * Returns flatten properties for all modules for a given resource
+     */
+    getProperties(): INodeProperties[] {
+        return this.modules.flatMap((operation) => operation.properties || []);
+    }
+}

package/nodes/response.ts

@@ -0,0 +1,16 @@
+import { IBinaryData } from 'n8n-workflow';
+
+/**
+ * Response object that includes both JSON data and optional binary file content.
+ *
+ * @typeParam T - The shape of the JSON data returned in the response
+ * @property json -  The n8n node response, containing structured JSON data.
+ * @property binary - An optional record of binary file data
+ *
+ * @public
+ * @group Response
+ */
+export type FileResponse<T> = {
+    json: T;
+    binary?: Record<string, IBinaryData>;
+};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "0.4.0",
+  "version": "2.3.1-dev.1",
   "description": "n8n node to connect to Lime CRM",
   "license": "MIT",
-  "main": "index.js",
+  "main": "nodes/index.ts",
   "scripts": {
-    "build": "tsc && mkdir -p dist/nodes/lime-crm/assets && find nodes -name '*.svg' -exec cp {} dist/{} \\;",
+    "build": "tsc && copyfiles \"nodes/**/*.svg\" dist",
     "dev": "tsc --watch",
     "dev:reload": "nodemon --watch dist --exec 'cp -R dist/* ~/.n8n/custom/dist/'",
     "watch": "concurrently \"npm run dev\" \"npm run dev:reload\"",
@@ -13,7 +13,9 @@
     "lint:fix": "eslint --max-warnings=0 . --fix",
     "format": "prettier -c .",
     "format:fix": "prettier --write .",
-    "test": "jest"
+    "test": "jest",
+    "docs": "npx typedoc",
+    "knip": "knip"
   },
   "keywords": [
     "n8n",
@@ -36,40 +38,30 @@
     ]
   },
   "devDependencies": {
+    "@limetech/eslint-config": "^4.0.0",
     "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/exec": "^7.1.0",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^11.0.4",
-    "@semantic-release/release-notes-generator": "^14.0.3",
     "@types/jest": "^30.0.0",
-    "@types/node": "^16.11.10",
-    "@types/request-promise-native": "^1.0.18",
+    "@types/node": "^24.10.1",
     "@types/ws": "^8.18.1",
-    "@typescript-eslint/eslint-plugin": "^8.38.0",
-    "@typescript-eslint/parser": "^8.38.0",
-    "concurrently": "^7.0.0",
-    "eslint": "^9.32.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-n8n-nodes-base": "^1.16.1",
-    "eslint-plugin-prettier": "^5.5.3",
-    "install": "^0.13.0",
-    "jest": "^30.0.5",
-    "nodemon": "^2.0.15",
-    "npm": "^11.5.2",
+    "concurrently": "^9.2.1",
+    "copyfiles": "^2.4.1",
+    "eslint": "^9.39.1",
+    "jest": "^30.2.0",
+    "knip": "^5.69.0",
+    "nodemon": "^3.1.11",
     "prettier": "^3.6.2",
-    "semantic-release": "^24.2.7",
-    "ts-jest": "^29.4.1",
-    "typescript": "^5.9.2"
+    "semantic-release": "^25.0.2",
+    "ts-jest": "^29.4.5",
+    "typedoc": "^0.28.14",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@limetech/eslint-config": "^3.0.2",
-    "@semantic-release/exec": "^7.1.0",
     "currency-codes": "^2.2.0",
-    "request": "^2.88.2",
-    "request-promise-native": "^1.0.9",
     "ws": "^8.18.3"
   },
   "peerDependencies": {
-    "n8n-workflow": "*"
+    "n8n-workflow": "^1.109.0"
   }
-}
+}

package/restore_script/README

@@ -0,0 +1,42 @@
+### n8n Scripts
+
+Utility scripts to batch upload, download and transfer workflows as JSON data to and from an n8n instance via
+its REST API.
+
+=========================================================================================
+### Features
+- download: Fetch items workflows from n8n and store locally.
+- upload: Push local workflows to n8n.
+- transfer: Combine download then upload for migrating between two instances without local storage
+- cli: Unified command line entrypoint wrapping the download and upload operations.
+
+=========================================================================================
+### Installation
+```bash
+poetry install
+```
+
+=========================================================================================
+### Usage
+
+#### Interactive Mode
+```bash
+poetry run python ./main.py
+```
+
+The api_key can also be provided in files [root directory]:
+- `api_key_download.txt` for download operations
+- `api_key_upload.txt` for upload operations
+
+#### CLI Mode
+Download
+```bash
+poetry run python ./cli.py download --instance_url <INSTANCE_URL> --api_key <API_KEY> --folder_path <FOLDER_PATH>
+```
+
+Upload
+```bash
+poetry run python ./cli.py upload --instance_url <INSTANCE_URL> --api_key <API_KEY> --folder_path <FOLDER_PATH>
+```
+
+The api_key can also be provided via the N8N_API_KEY environment variable.

package/restore_script/cli.py

@@ -0,0 +1,73 @@
+import argparse
+import os
+import sys
+
+
+from download import create_workflows_endpoint, fetch_workflows, save_workflows
+from upload import upload_workflows
+
+
+def _get_api_key(parser_args):
+    api_key = parser_args.api_key or os.getenv("N8N_API_KEY")
+    if not api_key:
+        print("Error: No api_key provided. Use --api_key argument or set N8N_API_KEY environment variable.",
+              file=sys.stderr)
+        sys.exit(1)
+
+    return api_key
+
+
+def download(instance_url, folder_path, parser_args):
+    api_key = _get_api_key(parser_args)
+    url = create_workflows_endpoint(instance_url, active=False, pinned_data=True)
+
+    if workflows:= fetch_workflows(url, api_key):
+        os.makedirs(os.path.normpath(folder_path), exist_ok=True)
+        save_workflows(folder_path, workflows)
+
+
+def upload(instance_url, folder_path, parser_args):
+    api_key = _get_api_key(parser_args)
+    url = f"{instance_url}/api/v1/workflows"
+
+    upload_workflows(
+        url=url, api_key=api_key, folder_path=os.path.normpath(folder_path))
+
+
+def download_cmd(subparsers):
+    download_parser = subparsers.add_parser("download", help="Download workflows from an n8n instance")
+    download_parser.add_argument("--instance_url", required=True,
+                                 help="n8n instance URL (e.g., https://n8n.example.com)")
+    download_parser.add_argument("--folder_path", required=True,
+                                 help="Path to save downloaded workflows")
+    download_parser.add_argument("--api_key",
+                                 help="Your n8n API key the default is read from N8N_API_KEY env variable")
+
+
+def upload_cmd(subparsers):
+    upload_parser = subparsers.add_parser("upload", help="Upload workflows to an n8n instance")
+    upload_parser.add_argument("--instance_url", required=True,
+                               help="n8n instance URL (e.g., https://n8n.example.com)")
+    upload_parser.add_argument("--folder_path", required=True,
+                               help="Path to the folder containing workflows to upload")
+    upload_parser.add_argument("--api_key",
+                               help="Your n8n API key the default is read from N8N_API_KEY env variable")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="A simple CLI tool for n8n workflows restore.")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    download_cmd(subparsers)
+    upload_cmd(subparsers)
+
+    args = parser.parse_args()
+
+    if args.command == "download":
+        download(parser_args=args, instance_url=args.instance_url, folder_path=args.folder_path)
+    elif args.command == "upload":
+        upload(parser_args=args, instance_url=args.instance_url, folder_path=args.folder_path)
+
+
+if __name__ == "__main__":
+    main()

package/restore_script/download.py

@@ -0,0 +1,73 @@
+import datetime
+import os
+
+import requests
+import json
+
+from utils import get_api_key, create_headers
+
+
+def main():
+    print("n8n Workflow Downloader")
+    instance_url = input("Enter n8n instance URL (e.g., https://n8n.example.com): ").strip().rstrip("/")
+    api_key = input("Enter your n8n API key: ").strip() or get_api_key("api_key_download.txt")
+    active = input("Do you want to download only active workflows? (y/n, default n): ").strip().lower() == 'y'
+    pinned_data = input("Do you want to download pinned data also? (y/n, default n): ").strip().lower() == 'y'
+
+    url = create_workflows_endpoint(instance_url, active, pinned_data)
+    if workflows:= fetch_workflows(url, api_key):
+        folder_path = create_folder(folder_path="./workflows/", instance_url=instance_url)
+        save_workflows(folder_path, workflows)
+
+
+def create_workflows_endpoint(instance_url: str, active: bool, pinned_data: bool):
+    base_url = f"{instance_url}/api/v1/workflows"
+    active = "true" if active else "false"
+    pinned_data = "true" if not pinned_data else "false"
+
+    return f"{base_url}?active={active}&excludePinnedData={pinned_data}"
+
+
+def fetch_workflows(url, api_key):
+    headers = create_headers(api_key)
+    workflows = []
+    next_cursor = None
+    while True:
+        full_url = f"{url}&limit=100" + (f"&cursor={next_cursor}" if next_cursor else "")
+        try:
+            resp = requests.get(full_url, headers=headers)
+            resp.raise_for_status()
+        except requests.RequestException as e:
+            print(f"Error: {e}")
+            return []
+
+        data = resp.json()
+        workflows.extend(data.get("data", []))
+        next_cursor = data.get("nextCursor")
+        if not next_cursor:
+            break
+
+    return workflows
+
+
+def create_folder(folder_path, instance_url):
+    name = (f"{datetime.datetime.now().strftime('%Y_%m_%d-%H_%M')}-"
+            f"{instance_url.replace('https://', '').replace('http://', '').replace('/', '_')}"
+            )
+    path = os.path.join(folder_path, name)
+    os.makedirs(path, exist_ok=True)
+
+    return path
+
+
+def save_workflows(folder_path, workflows):
+    for workflow in workflows:
+        filename = f"{workflow['name']}.json"
+        with open(f"{folder_path}/{filename}", "w") as f:
+            json.dump(workflow, f, indent=2)
+        print(f"{filename} - saved")
+    print(f"All workflows has been saved to {folder_path}")
+
+
+if __name__ == "__main__":
+    main()

package/restore_script/main.py

@@ -0,0 +1,19 @@
+from utils import select_option
+
+
+def main():
+    options = ["Download", "Upload", "Transfer"]
+    selected = select_option(options)
+    match selected:
+        case "Download":
+            from download import main
+        case "Upload":
+            from upload import main
+        case "Transfer":
+            from transfer import main
+
+    main()
+
+
+if __name__ == "__main__":
+    main()