@limetech/n8n-nodes-lime 0.3.8 → 0.5.0

package/restore_script/upload.py

@@ -0,0 +1,66 @@
+import os
+
+import requests
+import json
+
+from utils import select_option, get_api_key, create_headers
+
+
+def main():
+    print("n8n Workflow Uploader")
+    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_upload.txt")
+    options = os.listdir("./workflows")
+    selected = select_option(options)
+    print(f"Selected: {selected}")
+
+    workflows_endpoint = f"{instance_url}/api/v1/workflows"
+    folder_path = f"./workflows/{selected}"
+
+    upload_workflows(url=workflows_endpoint, api_key=api_key, folder_path=folder_path)
+
+
+def upload_workflows(url, api_key, folder_path):
+    for f in os.listdir(folder_path):
+        with open(os.path.join(folder_path, f), "r") as file:
+            workflow = json.load(file)
+            clean_workflow(workflow)
+
+            try:
+                post_workflow(
+                    url=url,
+                    headers=create_headers(api_key),
+                    body=workflow
+                )
+            except requests.exceptions.RequestException as e:
+                print(f"Error: {e}")
+                return
+            print(f"{f} - uploaded")
+
+
+def post_workflow(url, headers, body):
+    response = requests.post(url=url, headers=headers, json=body)
+    response.raise_for_status()
+
+
+def clean_workflow(workflow):
+    top_keys = {"id", "createdAt", "updatedAt", "active", "isArchived", "meta", "pinData", "versionId", "triggerCount", "tags"}
+    shared_keys = {"createdAt", "updatedAt"}
+    project_keys = {"id", "type"}
+
+    for key in top_keys:
+        workflow.pop(key, None)
+    for item in workflow.get("nodes", []):
+        item.pop("credentials", None)
+    for item in workflow.get("shared", []):
+        for key in shared_keys:
+            item.pop(key, None)
+        if "project" in item:
+            for key in project_keys:
+                item["project"].pop(key, None)
+
+    return workflow
+
+
+if __name__ == "__main__":
+    main()

package/restore_script/utils.py

@@ -0,0 +1,42 @@
+import curses
+
+
+def _menu(stdscr, options):
+    curses.curs_set(0)
+    current_row = 0
+
+    while True:
+        stdscr.clear()
+        for idx, option in enumerate(options):
+            if idx == current_row:
+                stdscr.addstr(idx, 0, option, curses.A_REVERSE)
+            else:
+                stdscr.addstr(idx, 0, option)
+        key = stdscr.getch()
+
+        if key == curses.KEY_UP and current_row > 0:
+            current_row -= 1
+        elif key == curses.KEY_DOWN and current_row < len(options) - 1:
+            current_row += 1
+        elif key == curses.KEY_ENTER or key in [10, 13]:
+            return options[current_row]
+
+def select_option(options):
+    return curses.wrapper(_menu, options)
+
+
+def create_headers(api_key):
+    return {
+        "X-N8N-API-KEY": api_key,
+        "Accept": "application/json"
+    }
+
+
+def get_api_key(file_name):
+    try:
+        with open(file_name, "r") as file:
+            api_key = file.read().strip()
+    except FileNotFoundError:
+        api_key = ""
+
+    return api_key

package/tests/transform.spec.ts

@@ -1,5 +1,5 @@
 import {
-    CustomLimeTypeNames,
+    CustomLimetypeNames,
     CustomPropertiesNames,
     SearchParameters,
     transform,
@@ -10,7 +10,7 @@ import { invoice } from './fixtures/fortnox';
 describe('Fortnox transformer tests', () => {
     it('should transform invoice for Fortnox', () => {
         const searchParameters: SearchParameters = {};
-        const customLimeTipeNames: CustomLimeTypeNames = {};
+        const customLimeTipeNames: CustomLimetypeNames = {};
         const customPropertiesNames: CustomPropertiesNames = {};
 
         const result = transform(
@@ -120,7 +120,7 @@ describe('Fortnox transformer tests', () => {
             property: 'invoice_number',
             value: '2137',
         };
-        const customLimeTipeNames: CustomLimeTypeNames = {};
+        const customLimeTipeNames: CustomLimetypeNames = {};
         const customPropertiesNames: CustomPropertiesNames = {};
 
         const result = transform(
@@ -139,9 +139,9 @@ describe('Fortnox transformer tests', () => {
         });
     });
 
-    it('should transform invoice for Fortnox with custom limeType names', () => {
+    it('should transform invoice for Fortnox with custom limetype names', () => {
         const searchParameters: SearchParameters = {};
-        const customLimeTipeNames: CustomLimeTypeNames = {
+        const customLimeTipeNames: CustomLimetypeNames = {
             invoice: 'document',
             invoicerow: 'documentrow',
         };
@@ -164,7 +164,7 @@ describe('Fortnox transformer tests', () => {
 
     it('should transform invoice for Fortnox with custom properties names', () => {
         const searchParameters: SearchParameters = {};
-        const customLimeTipeNames: CustomLimeTypeNames = {};
+        const customLimeTipeNames: CustomLimetypeNames = {};
         const customPropertiesNames: CustomPropertiesNames = {
             invoice: { paid: 'is_paid' },
             invoicerow: { row_value: 'value' },

package/nodes/lime-crm/commons/limetype.ts

@@ -1,11 +0,0 @@
-export interface LimeType {
-    name: string;
-    href?: string;
-}
-
-export interface LimeTypeProperty {
-    name: string;
-    localname: string;
-    type: string;
-    required: boolean;
-}

package/nodes/lime-crm/methods/getLimeTypeProperties.ts

@@ -1,27 +0,0 @@
-import {
-    ILoadOptionsFunctions,
-    INodePropertyOptions,
-    LoggerProxy as Logger,
-} from 'n8n-workflow';
-import { getProperties } from '../transport/';
-
-/**
- * Load properties for a selected Lime type
- */
-export async function getLimeTypeProperties(
-    this: ILoadOptionsFunctions
-): Promise<INodePropertyOptions[]> {
-    const limeType = this.getNodeParameter('limeType', '') as string;
-    Logger.info(`Fetching properties for Lime type: ${limeType}`);
-    if (!limeType) return [];
-
-    const response = await getProperties(this, limeType);
-
-    if (!response.success) return [];
-
-    return response.data.map((property) => ({
-        name: (property.localname as string) || (property.name as string),
-        value: property.name as string,
-        description: `Type: ${property.type as string}${(property.required as boolean) ? ' (Required)' : ''}`,
-    }));
-}

package/nodes/lime-crm/methods/getLimeTypes.ts

@@ -1,23 +0,0 @@
-import { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
-import { getLimeTypesFromApi } from '../transport';
-
-/**
- * Load available Lime types from the API
- */
-export async function getLimeTypes(
-    this: ILoadOptionsFunctions
-): Promise<INodePropertyOptions[]> {
-    const data: INodePropertyOptions[] = [];
-    const response = await getLimeTypesFromApi(this);
-    if (response.success && response.data) {
-        for (const limeType of response.data) {
-            if (limeType.name) {
-                data.push({
-                    name: limeType.name,
-                    value: limeType.name,
-                });
-            }
-        }
-    }
-    return data;
-}

package/nodes/lime-crm/resources/limeObject/index.ts

@@ -1,64 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    NodePropertyTypes,
-} from 'n8n-workflow';
-
-import * as create from './operations/create.operation';
-import * as get from './operations/get.operation';
-import * as update from './operations/update.operation';
-import * as delete_ from './operations/delete.operation';
-import * as fetchMany from './operations/fetchMany.operation';
-
-import { LIMEOBJECT_RESOURCE } from '../../commons';
-
-export const limeObjectFields: INodeProperties[] = [
-    {
-        displayName: 'Operation',
-        name: 'operation',
-        type: 'options' as NodePropertyTypes,
-        noDataExpression: true,
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-            },
-        },
-        options: [
-            create.description,
-            get.description,
-            update.description,
-            delete_.description,
-            fetchMany.description,
-        ],
-        default: 'fetchMany',
-    },
-
-    ...create.properties,
-    ...get.properties,
-    ...update.properties,
-    ...delete_.properties,
-    ...fetchMany.properties,
-];
-
-export async function limeObjectOperations(
-    this: IExecuteFunctions,
-    { operation, i }: { operation: string; i: number }
-) {
-    if (operation === 'create') {
-        return await create.execute.call(this, i);
-    }
-    if (operation === 'get') {
-        return await get.execute.call(this, i);
-    }
-    if (operation === 'update') {
-        return await update.execute.call(this, i);
-    }
-    if (operation === 'delete') {
-        return await delete_.execute.call(this, i);
-    }
-    if (operation === 'fetchMany') {
-        return await fetchMany.execute.call(this, i);
-    }
-
-    return null;
-}

package/nodes/lime-crm/resources/limeObject/operations/fetchMany.operation.ts

@@ -1,112 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { fetchManyLimeObjects } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Fetch many',
-    value: 'fetchMany',
-    description: 'Fetch many Lime objects',
-    action: 'Fetch many objects',
-};
-
-export const properties: INodeProperties[] = [
-    {
-        displayName: 'Lime Type',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The type of entity to search for',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-    {
-        displayName: 'Search Term',
-        name: 'searchTerm',
-        type: 'string',
-        default: '',
-        description: 'Term to search for',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-    {
-        displayName: 'Search Fields',
-        name: 'searchField',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypeProperties',
-            loadOptionsDependsOn: ['limeType'],
-        },
-        default: [],
-        description:
-            'Fields to search in. If none selected, searches across all searchable fields',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-    {
-        displayName: 'Limit',
-        name: 'limit',
-        type: 'number',
-        default: 50,
-        description: 'Max number of results to return',
-        typeOptions: {
-            minValue: 1,
-        },
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-    {
-        displayName: 'Offset',
-        name: 'offset',
-        type: 'number',
-        default: 0,
-        description: 'Offset to first object to return',
-        typeOptions: {
-            minValue: 0,
-        },
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['fetchMany'],
-            },
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-    const searchTerm = this.getNodeParameter('searchTerm', i, '') as string;
-    const searchField = this.getNodeParameter('searchField', i) as string;
-    const limit = this.getNodeParameter('limit', i, 50);
-    const offset = this.getNodeParameter('offset', i, 0) as number;
-    const options = this.getNodeParameter('options', i, {});
-
-    return await fetchManyLimeObjects(
-        this,
-        limeType,
-        searchField,
-        searchTerm,
-        limit,
-        offset,
-        (options.sortField as string) || null
-    );
-}

package/nodes/lime-crm/resources/limeObject/operations/get.operation.ts

@@ -1,54 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-
-import { getLimeObject } from '../../../transport';
-import { LIMEOBJECT_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Get Object',
-    value: 'get',
-    description: 'Get a single object by ID',
-    action: 'Get an object',
-};
-
-export const properties: INodeProperties[] = [
-    // Limetype selection
-    {
-        displayName: 'Lime Type',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The type of entity to retrieve',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['get'],
-            },
-        },
-    },
-
-    // Object ID
-    {
-        displayName: 'Object ID',
-        name: 'objectId',
-        type: 'string',
-        required: true,
-        default: '',
-        description: 'The ID of the object to retrieve',
-        displayOptions: {
-            show: {
-                resource: [LIMEOBJECT_RESOURCE],
-                operation: ['get'],
-            },
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-    const objectId = this.getNodeParameter('objectId', i) as string;
-    return getLimeObject(this, limeType, objectId);
-}

package/nodes/lime-crm/resources/limeType/index.ts

@@ -1,58 +0,0 @@
-import {
-    IExecuteFunctions,
-    INodeProperties,
-    NodePropertyTypes,
-} from 'n8n-workflow';
-
-import * as getType from './operations/getType.operation';
-import * as listTypes from './operations/listTypes.operation';
-import * as getProperties from './operations/getProperties.operation';
-import { LIMETYPE_RESOURCE } from '../../commons';
-
-export const limeTypeFields: INodeProperties[] = [
-    {
-        displayName: 'Operation',
-        name: 'operation',
-        type: 'options' as NodePropertyTypes,
-        noDataExpression: true,
-        displayOptions: {
-            show: {
-                resource: [LIMETYPE_RESOURCE],
-            },
-        },
-        options: [
-            {
-                ...listTypes.description,
-            },
-            {
-                ...getType.description,
-            },
-            {
-                ...getProperties.description,
-            },
-        ],
-        default: 'listTypes',
-    },
-
-    // Operation-specific fields
-    ...getType.properties,
-    ...getProperties.properties,
-];
-
-// Operations router
-export async function limeTypeOperations(
-    this: IExecuteFunctions,
-    { operation, i }: { operation: string; i: number }
-) {
-    if (operation === 'listTypes') {
-        return await listTypes.execute.call(this);
-    }
-    if (operation === 'getType') {
-        return await getType.execute.call(this, i);
-    }
-    if (operation === 'getProperties') {
-        return await getProperties.execute.call(this, i);
-    }
-
-    return null;
-}

package/nodes/lime-crm/resources/limeType/operations/getProperties.operation.ts

@@ -1,42 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-
-import { getProperties } from '../../../transport';
-import { LIMETYPE_RESOURCE, LimeTypeProperty } from '../../../commons';
-import { NodeResponse } from '../../../../nodeResponse';
-
-export const description = {
-    name: 'Get Properties',
-    value: 'getProperties',
-    description: 'Get all properties for a specific entity type',
-    action: 'Get entity type properties',
-};
-
-export const properties: INodeProperties[] = [
-    // Limetype selection
-    {
-        displayName: 'Type Name',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The name of the entity type to get properties for',
-        displayOptions: {
-            show: {
-                resource: [LIMETYPE_RESOURCE],
-                operation: ['getProperties'],
-            },
-        },
-    },
-];
-
-export async function execute(
-    this: IExecuteFunctions,
-    i: number
-): Promise<NodeResponse<LimeTypeProperty[]>> {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-
-    return getProperties(this, limeType);
-}

package/nodes/lime-crm/resources/limeType/operations/getType.operation.ts

@@ -1,36 +0,0 @@
-import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
-import { getLimeType } from '../../../transport/limetypes';
-import { LIMETYPE_RESOURCE } from '../../../commons';
-
-export const description = {
-    name: 'Get Type',
-    value: 'getType',
-    description: 'Get details about a specific entity type',
-    action: 'Get entity type details',
-};
-
-export const properties: INodeProperties[] = [
-    {
-        displayName: 'Type Name',
-        name: 'limeType',
-        type: 'options',
-        typeOptions: {
-            loadOptionsMethod: 'getLimeTypes',
-        },
-        required: true,
-        default: '',
-        description: 'The name of the entity type to get details for',
-        displayOptions: {
-            show: {
-                resource: [LIMETYPE_RESOURCE],
-                operation: ['getType'],
-            },
-        },
-    },
-];
-
-export async function execute(this: IExecuteFunctions, i: number) {
-    const limeType = this.getNodeParameter('limeType', i) as string;
-
-    return getLimeType(this, limeType);
-}

package/nodes/lime-crm/resources/limeType/operations/listTypes.operation.ts

@@ -1,18 +0,0 @@
-import { IExecuteFunctions } from 'n8n-workflow';
-
-import { getLimeTypesFromApi } from '../../../transport';
-import { LimeType } from '../../../commons';
-import { NodeResponse } from '../../../../nodeResponse';
-
-export const description = {
-    name: 'List Types',
-    value: 'listTypes',
-    description: 'Get a list of all available entity types',
-    action: 'List all entity types',
-};
-
-export async function execute(
-    this: IExecuteFunctions
-): Promise<NodeResponse<LimeType[]>> {
-    return await getLimeTypesFromApi(this);
-}