@limetech/n8n-nodes-lime 0.4.0 → 0.5.0

package/nodes/lime-crm/transport/files.ts

@@ -0,0 +1,155 @@
+import { callLimeApi, getLimeobject } from '.';
+import { IExecuteFunctions, IBinaryData, BINARY_ENCODING } from 'n8n-workflow';
+import { NodeResponse } from '../../nodeResponse';
+import { removeKeys } from './commons';
+import { getFilenameFromHeader, setFilename } from '../commons';
+
+const LIME_FILE_URL = '/api/v1/file/';
+
+interface FileApiResponse {
+    headers: Record<string, string | string[] | undefined>;
+    body: Buffer;
+}
+
+interface FileMetadata {
+    filename: string;
+    id: number;
+    size: number;
+    content_type: string;
+    extension: string;
+    created_by: number;
+    locked_by: number;
+    last_modified: string;
+    _links?: { [key: string]: { href: string } };
+}
+
+export async function getFileMetadata(
+    nodeContext: IExecuteFunctions,
+    id: string | number
+): Promise<NodeResponse<FileMetadata>> {
+    const url = `${LIME_FILE_URL}${id}/`;
+    const response = await callLimeApi<FileMetadata>(nodeContext, 'GET', url);
+    if (!response.success) {
+        return response;
+    }
+
+    return {
+        success: true,
+        data: removeKeys(response.data, ['_links']),
+    };
+}
+
+export async function getFileMetadataByLimeobject(
+    nodeContext: IExecuteFunctions,
+    limetype: string,
+    id: string,
+    fileTypeProperty: string
+): Promise<NodeResponse<FileMetadata>> {
+    const objectResponse = await getLimeobject(nodeContext, limetype, id);
+    if (!objectResponse.success) {
+        return objectResponse;
+    }
+    const fileId = objectResponse.data[fileTypeProperty] as string | undefined;
+
+    if (!fileId) {
+        return {
+            success: false,
+            error: 'The specified Limeobject does not have an associated file.',
+        };
+    }
+
+    const metadataResponse = await getFileMetadata(nodeContext, fileId);
+    if (!metadataResponse.success) {
+        return metadataResponse;
+    }
+
+    return {
+        success: true,
+        data: removeKeys(metadataResponse.data, ['_links']),
+    };
+}
+
+export async function getFileContent(
+    nodeContext: IExecuteFunctions,
+    id: string | number
+): Promise<NodeResponse<IBinaryData>> {
+    const url = `${LIME_FILE_URL}${id}/contents/`;
+
+    const response = await callLimeApi<FileApiResponse>(
+        nodeContext,
+        'GET',
+        url,
+        {
+            encoding: null,
+            responseType: 'stream',
+            resolveWithFullResponse: true,
+        },
+        false
+    );
+    if (!response.success) {
+        return response;
+    }
+
+    const fileName =
+        getFilenameFromHeader(response.data.headers) || `file_${id}`;
+    const binaryData = await nodeContext.helpers.prepareBinaryData(
+        response.data.body
+    );
+    binaryData.fileName = setFilename(binaryData, fileName);
+
+    return {
+        success: true,
+        data: binaryData,
+    };
+}
+
+export async function getFileContentByLimetype(
+    nodeContext: IExecuteFunctions,
+    limetype: string,
+    id: string,
+    fileTypeProperty: string
+): Promise<NodeResponse<IBinaryData>> {
+    const objectResponse = await getLimeobject(nodeContext, limetype, id);
+    if (!objectResponse.success) {
+        return objectResponse;
+    }
+    const fileId = objectResponse.data[fileTypeProperty] as string | undefined;
+
+    if (!fileId) {
+        return {
+            success: false,
+            error: 'The specified Limeobject does not have an associated file.',
+        };
+    }
+
+    return await getFileContent(nodeContext, fileId);
+}
+
+export async function createFile(
+    nodeContext: IExecuteFunctions,
+    binary: IBinaryData,
+    fallbackFileName: string
+): Promise<NodeResponse<FileMetadata>> {
+    const response = await callLimeApi<FileMetadata>(
+        nodeContext,
+        'POST',
+        LIME_FILE_URL,
+        {
+            body: Buffer.from(binary.data, BINARY_ENCODING),
+            headers: {
+                'Content-Disposition': `;filename*="UTF-8''${encodeURIComponent(binary.fileName || fallbackFileName)}"`,
+                'Content-Type': binary.mimeType,
+            },
+        }
+    );
+
+    // Remove metadata from the response to reduce its overall size
+    if (!response.success) {
+        return { success: false, error: response.error };
+    }
+
+    return {
+        success: true,
+        data: removeKeys(response.data, ['_links']),
+    };
+}

package/nodes/lime-crm/transport/index.ts

@@ -4,15 +4,22 @@ export {
     createSubscription,
     listSubscriptionsWithExistingData,
 } from './webhooks';
-export { getLimeTypesFromApi, getProperties } from './limetypes';
+export { getLimetypesFromApi, getProperties } from './limetypes';
 
 export {
-    createLimeObject,
-    deleteLimeObject,
-    updateLimeObject,
-    getLimeObject,
-    fetchManyLimeObjects,
+    createLimeobject,
+    deleteLimeobject,
+    updateLimeobject,
+    getLimeobject,
+    fetchManyLimeobjects,
 } from './limeobjects';
 export { startCreateOrUpdateObjectsTask } from './erpConnector';
-export { queryLimeObjects } from './limeQuery';
+export { queryLimeobjects } from './limeQuery';
+export {
+    createFile,
+    getFileContent,
+    getFileContentByLimetype,
+    getFileMetadata,
+    getFileMetadataByLimeobject,
+} from './files';
 export { callLimeApi } from './commons';

package/nodes/lime-crm/transport/limeQuery.ts

@@ -12,14 +12,12 @@ export interface QueryResponse {
     objects: IncludedProperties[];
 }
 
-export async function queryLimeObjects(
+export async function queryLimeobjects(
     nodeContext: IAllExecuteFunctions,
-    q: string,
-    activeObject: string
+    q: string
 ): Promise<NodeResponse<QueryResponse>> {
     const queryParameters = {
         q: q,
-        activeObject: activeObject,
     };
 
     return await callLimeApi(nodeContext, 'GET', LIME_QUERY_URL, {

package/nodes/lime-crm/transport/limeobjects.ts

@@ -1,41 +1,56 @@
-import { callLimeApi } from './commons';
+import { callLimeApi, removeKeys } from './commons';
 import { IAllExecuteFunctions, IDataObject } from 'n8n-workflow';
 import { NodeResponse } from '../../nodeResponse';
+import { Limeobject } from '../model';
 
 const LIMEOBJECT_URL = '/api/v1/limeobject/';
 
-interface FetchManyLimeObjectsApiResponse {
+interface LimeobjectCrmApiResponse {
+    id_: number;
+    _links: object;
+}
+
+interface FetchManyLimeobjectsApiResponse {
     _embedded: {
-        limeobjects: Array<object>;
+        limeobjects: LimeobjectCrmApiResponse[];
     };
 }
 
-export async function createLimeObject(
+export async function createLimeobject(
     nodeContext: IAllExecuteFunctions,
-    limeType: string,
+    limetype: string,
     data: object
-): Promise<NodeResponse<unknown>> {
-    const url = `${LIMEOBJECT_URL}${limeType}/`;
-    const response = await callLimeApi(nodeContext, 'POST', url, {
-        body: data,
-    });
-    if (response.success) return response;
+): Promise<NodeResponse<Limeobject>> {
+    const url = `${LIMEOBJECT_URL}${limetype}/`;
+    const response = await callLimeApi<LimeobjectCrmApiResponse>(
+        nodeContext,
+        'POST',
+        url,
+        {
+            body: data,
+        }
+    );
+    if (response.success)
+        return {
+            success: true,
+            data: removeKeys(response.data, ['_links']),
+        };
 
     return {
         ...response,
         metadata: {
             ...response.metadata,
-            limeType: limeType,
+            limetype: limetype,
         },
     };
 }
 
-export async function deleteLimeObject(
+export async function deleteLimeobject(
     nodeContext: IAllExecuteFunctions,
-    limeType: string,
+    limetype: string,
     id: string
 ): Promise<NodeResponse<void>> {
-    const url = `${LIMEOBJECT_URL}${limeType}/${id}/`;
+    const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
     const response: NodeResponse<void> = await callLimeApi(
         nodeContext,
         'DELETE',
@@ -48,63 +63,80 @@ export async function deleteLimeObject(
         ...response,
         metadata: {
             ...response.metadata,
-            limeType: limeType,
+            limetype: limetype,
             id: id,
         },
     };
 }
 
-export async function getLimeObject(
+export async function getLimeobject(
     nodeContext: IAllExecuteFunctions,
-    limeType: string,
+    limetype: string,
     id: string
-): Promise<NodeResponse<unknown>> {
-    const url = `${LIMEOBJECT_URL}${limeType}/${id}/`;
-    const response = await callLimeApi(nodeContext, 'GET', url);
+): Promise<NodeResponse<Limeobject>> {
+    const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
+    const response = await callLimeApi<LimeobjectCrmApiResponse>(
+        nodeContext,
+        'GET',
+        url
+    );
 
-    if (response.success) return response;
+    if (response.success)
+        return {
+            success: true,
+            data: removeKeys(response.data, ['_links']),
+        };
 
     return {
         ...response,
         metadata: {
             ...response.metadata,
-            limeType: limeType,
+            limetype: limetype,
             id: id,
         },
     };
 }
 
-export async function updateLimeObject(
+export async function updateLimeobject(
     nodeContext: IAllExecuteFunctions,
-    limeType: string,
+    limetype: string,
     id: string,
     data: object
-): Promise<NodeResponse<unknown>> {
-    const url = `${LIMEOBJECT_URL}${limeType}/${id}/`;
-    const response = await callLimeApi(nodeContext, 'PUT', url, {
-        body: data,
-    });
+): Promise<NodeResponse<Limeobject>> {
+    const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
+    const response = await callLimeApi<LimeobjectCrmApiResponse>(
+        nodeContext,
+        'PUT',
+        url,
+        {
+            body: data,
+        }
+    );
 
-    if (response.success) return response;
+    if (response.success)
+        return {
+            success: true,
+            data: removeKeys(response.data, ['_links']),
+        };
 
     return {
         ...response,
         metadata: {
             ...response.metadata,
-            limeType: limeType,
+            limetype: limetype,
             id: id,
         },
     };
 }
 
-async function _searchLimeObjectWithLimit(
+async function _searchLimeobjectWithLimit(
     nodeContext: IAllExecuteFunctions,
     url: string,
     limit: number,
     offset: number,
     qs: IDataObject
-): Promise<NodeResponse<FetchManyLimeObjectsApiResponse>> {
-    const returnData = [];
+): Promise<NodeResponse<FetchManyLimeobjectsApiResponse>> {
+    const returnData: LimeobjectCrmApiResponse[] = [];
     let hasMoreData = true;
     let currentOffset = Math.max(0, offset);
     const pageLimit = 50;
@@ -113,7 +145,7 @@ async function _searchLimeObjectWithLimit(
         qs._limit = Math.min(limit, pageLimit);
         qs._offset = currentOffset;
 
-        const response = await callLimeApi<FetchManyLimeObjectsApiResponse>(
+        const response = await callLimeApi<FetchManyLimeobjectsApiResponse>(
             nodeContext,
             'GET',
             url,
@@ -143,16 +175,16 @@ async function _searchLimeObjectWithLimit(
     };
 }
 
-export async function fetchManyLimeObjects(
+export async function fetchManyLimeobjects(
     nodeContext: IAllExecuteFunctions,
-    limeType: string,
+    limetype: string,
     searchField: string,
     searchTerm: string,
     limit: number,
     offset: number,
     sortField: string | null
-): Promise<NodeResponse<Array<object>>> {
-    const url = `${LIMEOBJECT_URL}${limeType}/`;
+): Promise<NodeResponse<Limeobject[]>> {
+    const url = `${LIMEOBJECT_URL}${limetype}/`;
     const qs: IDataObject = {
         ...(searchField && searchTerm && { [searchField]: searchTerm }),
         ...(offset != null && offset > 0 && { _offset: offset }),
@@ -161,7 +193,7 @@ export async function fetchManyLimeObjects(
 
     let response;
     if (limit) {
-        response = await _searchLimeObjectWithLimit(
+        response = await _searchLimeobjectWithLimit(
             nodeContext,
             url,
             limit,
@@ -169,7 +201,7 @@ export async function fetchManyLimeObjects(
             qs
         );
     } else {
-        response = await callLimeApi<FetchManyLimeObjectsApiResponse>(
+        response = await callLimeApi<FetchManyLimeobjectsApiResponse>(
             nodeContext,
             'GET',
             url,
@@ -182,7 +214,10 @@ export async function fetchManyLimeObjects(
     if (response.success) {
         return {
             success: true,
-            data: response.data?._embedded.limeobjects ?? [],
+            data:
+                response.data?._embedded.limeobjects.map((limeobject) =>
+                    removeKeys(limeobject, ['_links'])
+                ) ?? [],
         };
     }
     return {
@@ -191,7 +226,7 @@ export async function fetchManyLimeObjects(
         status: response.status,
         metadata: {
             ...response.metadata,
-            limeType: limeType,
+            limetype: limetype,
         },
     };
 }

package/nodes/lime-crm/transport/limetypes.ts

@@ -1,63 +1,112 @@
 import { callLimeApi } from '.';
 import { IAllExecuteFunctions } from 'n8n-workflow';
-import { LimeType, LimeTypeProperty } from '../commons';
+import { Limetype, LimetypeProperty } from '../model';
 import { NodeResponse } from '../../nodeResponse';
+import { removeKeys } from './commons';
 
 const LIMETYPE_URL = '/api/v1/limetype/';
 
-interface LimeTypesApiResponse {
-    _links: {
-        limetypes: LimeType[];
+interface LimetypePropertyApiResponse {
+    name: string;
+    _links?: object;
+    _embedded?: object;
+}
+
+interface LimetypeCrmApiResponse {
+    name: string;
+    localname?: {
+        singular?: string;
+        plural?: string;
+    };
+    _embedded: {
+        properties: LimetypePropertyApiResponse[];
+    };
+    _links: object;
+}
+
+interface LimetypesCrmApiResponse {
+    _embedded: {
+        limetypes: LimetypeCrmApiResponse[];
+        _links: object;
     };
 }
 
-interface LimeTypePropertiesApiResponse {
+interface LimetypePropertiesApiResponse {
     _embedded: {
-        properties: LimeTypeProperty[];
+        properties: LimetypeCrmApiResponse[];
     };
 }
 
-export async function getLimeTypesFromApi(
+function deserializeLimetype(limetype: LimetypeCrmApiResponse): Limetype {
+    return {
+        ...removeKeys(limetype, ['_links', '_embedded']),
+        properties: limetype._embedded.properties.map((property) =>
+            removeKeys(property, ['_links'])
+        ),
+    } as Limetype;
+}
+
+export async function getLimetypesFromApi(
     nodeContext: IAllExecuteFunctions
-): Promise<NodeResponse<LimeType[]>> {
-    const response = await callLimeApi<LimeTypesApiResponse>(
+): Promise<NodeResponse<Limetype[]>> {
+    const response = await callLimeApi<LimetypesCrmApiResponse>(
         nodeContext,
         'GET',
-        LIMETYPE_URL
+        LIMETYPE_URL,
+        {
+            qs: {
+                _embed: 'limetypes.properties',
+            },
+        }
     );
     if (response.success) {
         return {
             success: true,
-            data: response.data?._links.limetypes ?? [],
+            data:
+                response.data._embedded?.limetypes.map(deserializeLimetype) ||
+                [],
         };
     }
     return response;
 }
 
-export async function getLimeType(
+export async function getLimetype(
     nodeContext: IAllExecuteFunctions,
-    limeType: string
-): Promise<NodeResponse<LimeType>> {
-    const url = `${LIMETYPE_URL}${limeType}/`;
-    const response = await callLimeApi<LimeType>(nodeContext, 'GET', url);
+    limetype: string
+): Promise<NodeResponse<Limetype>> {
+    const url = `${LIMETYPE_URL}${limetype}/`;
+    const response = await callLimeApi<LimetypeCrmApiResponse>(
+        nodeContext,
+        'GET',
+        url,
+        {
+            qs: {
+                _embed: 'properties',
+            },
+        }
+    );
 
-    if (response.success) return response;
+    if (response.success)
+        return {
+            success: true,
+            data: deserializeLimetype(response.data),
+        };
 
     return {
         ...response,
         metadata: {
             ...response.metadata,
-            limetype: limeType,
+            limetype: limetype,
         },
     };
 }
 
 export async function getProperties(
     nodeContext: IAllExecuteFunctions,
-    limeType: string
-): Promise<NodeResponse<LimeTypeProperty[]>> {
-    const url = `${LIMETYPE_URL}${limeType}/`;
-    const response = await callLimeApi<LimeTypePropertiesApiResponse>(
+    limetype: string
+): Promise<NodeResponse<LimetypeProperty[]>> {
+    const url = `${LIMETYPE_URL}${limetype}/`;
+    const response = await callLimeApi<LimetypePropertiesApiResponse>(
         nodeContext,
         'GET',
         url,
@@ -71,7 +120,14 @@ export async function getProperties(
     if (response.success) {
         return {
             success: true,
-            data: response.data?._embedded.properties ?? [],
+            data:
+                response.data?._embedded.properties.map(
+                    (property) =>
+                        removeKeys(property, [
+                            '_links',
+                            '_embedded',
+                        ]) as LimetypeProperty
+                ) || [],
         };
     }
 
@@ -79,7 +135,7 @@ export async function getProperties(
         ...response,
         metadata: {
             ...response.metadata,
-            limetype: limeType,
+            limetype: limetype,
         },
     };
 }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@limetech/n8n-nodes-lime",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "n8n node to connect to Lime CRM",
   "license": "MIT",
   "main": "index.js",
   "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\"",
@@ -48,6 +48,7 @@
     "@typescript-eslint/eslint-plugin": "^8.38.0",
     "@typescript-eslint/parser": "^8.38.0",
     "concurrently": "^7.0.0",
+    "copyfiles": "^2.4.1",
     "eslint": "^9.32.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-n8n-nodes-base": "^1.16.1",
@@ -70,6 +71,6 @@
     "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.