@limetech/n8n-nodes-lime 0.3.8 → 0.5.0

package/nodes/lime-crm/resources/metadata/operations/getSingleFileMetadata.ts

@@ -0,0 +1,130 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    INodeExecutionData,
+    NodeOperationError,
+} from 'n8n-workflow';
+import {
+    getFileMetadata,
+    getFileMetadataByLimeobject,
+} from '../../../transport';
+import { METADATA_RESOURCE } from '../../../commons';
+
+export const description = {
+    name: 'Get Single File Metadata',
+    value: 'getSingleFileMetadata',
+    description: 'Get the metadata for a single file',
+    action: 'Get single file metadata',
+};
+
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Get by',
+        name: 'source',
+        type: 'options',
+        required: true,
+        placeholder: 'Add Source',
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+                operation: ['getSingleFileMetadata'],
+            },
+        },
+        options: [
+            {
+                name: 'File ID',
+                value: 'byFile',
+                description: 'Get file by its ID',
+            },
+            {
+                name: 'Limeobject ID',
+                value: 'byLimeobject',
+                description: "Get file by it's associated Limeobject ID",
+            },
+        ],
+        default: 'byFile',
+    },
+    {
+        displayName: 'Limetype',
+        name: 'limetype',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getLimetypes',
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity associated with the file',
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+                operation: ['getSingleFileMetadata'],
+                source: ['byLimeobject'],
+            },
+        },
+    },
+    {
+        displayName: 'Identifier',
+        name: 'identifier',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the file or Limeobject to retrieve',
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+                operation: ['getSingleFileMetadata'],
+            },
+        },
+        placeholder: 'e.g., 12345',
+    },
+    {
+        displayName: 'File type property',
+        name: 'property',
+        type: 'options',
+        typeOptions: {
+            loadOptionsMethod: 'getFileProperties',
+            loadOptionsDependsOn: ['limetype'],
+        },
+        required: true,
+        default: '',
+        description: 'The type of entity associated with the file',
+        displayOptions: {
+            show: {
+                resource: [METADATA_RESOURCE],
+                operation: ['getSingleFileMetadata'],
+                source: ['byLimeobject'],
+            },
+        },
+    },
+];
+
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<INodeExecutionData> {
+    const source = this.getNodeParameter('source', i) as string;
+    const id = this.getNodeParameter('identifier', i) as string;
+
+    if (source == 'byFile') {
+        return {
+            json: await getFileMetadata(this, id),
+        };
+    }
+    if (source == 'byLimeobject') {
+        const limetype = this.getNodeParameter('limetype', i) as string;
+        const property = this.getNodeParameter('property', i) as string;
+        return {
+            json: await getFileMetadataByLimeobject(
+                this,
+                limetype,
+                id,
+                property
+            ),
+        };
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The source "${source}" is not supported!`
+    );
+}

package/nodes/lime-crm/resources/metadata/operations/getSingleLimetype.ts

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

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

@@ -4,6 +4,17 @@ import { NodeResponse } from '../../nodeResponse';
 
 type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
 
+export function removeKeys<T extends object, K extends keyof T>(
+    data: T,
+    keys: K[]
+): Omit<T, K> {
+    const { ...obj } = data;
+    for (const key of keys) {
+        delete obj[key];
+    }
+    return obj;
+}
+
 async function getLimeUrl(context: IAllExecuteFunctions): Promise<string> {
     const credentials = await context.getCredentials(
         LIME_CRM_API_CREDENTIAL_KEY
@@ -15,7 +26,8 @@ export async function callLimeApi<T>(
     nodeContext: IAllExecuteFunctions,
     method: HTTPMethod,
     url: string,
-    options?: Record<string, unknown>
+    options?: Record<string, unknown>,
+    json = true
 ): Promise<NodeResponse<T>> {
     try {
         const response: T =
@@ -25,7 +37,7 @@ export async function callLimeApi<T>(
                 {
                     method: method,
                     url: url,
-                    json: true,
+                    json: json,
                     baseURL: await getLimeUrl(nodeContext),
                     ...options,
                 }

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,14 +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 {
+    createFile,
+    getFileContent,
+    getFileContentByLimetype,
+    getFileMetadata,
+    getFileMetadataByLimeobject,
+} from './files';
 export { callLimeApi } from './commons';

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

@@ -0,0 +1,26 @@
+import { IAllExecuteFunctions } from 'n8n-workflow';
+import { NodeResponse } from '../../nodeResponse';
+import { callLimeApi } from './commons';
+
+const LIME_QUERY_URL = '/api/v1/query/';
+
+interface IncludedProperties {
+    [key: string]: IncludedProperties | string | number | boolean | null;
+}
+
+export interface QueryResponse {
+    objects: IncludedProperties[];
+}
+
+export async function queryLimeobjects(
+    nodeContext: IAllExecuteFunctions,
+    q: string
+): Promise<NodeResponse<QueryResponse>> {
+    const queryParameters = {
+        q: q,
+    };
+
+    return await callLimeApi(nodeContext, 'GET', LIME_QUERY_URL, {
+        qs: queryParameters,
+    });
+}

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,
         },
     };
 }