@limetech/n8n-nodes-lime 0.5.0 → 2.5.0-dev.1

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

@@ -1,232 +1,167 @@
-import { callLimeApi, removeKeys } from './commons';
-import { IAllExecuteFunctions, IDataObject } from 'n8n-workflow';
-import { NodeResponse } from '../../nodeResponse';
-import { Limeobject } from '../model';
-
+import { callLimeApi, prepareResponseWithoutKeys } from './commons';
+import { IAllExecuteFunctions } from 'n8n-workflow';
+import { Limeobject } from '../models';
+import { APIResponse } from '../../response';
+/**
+ * Endpoint path for Lime CRM Limeobject API.
+ *
+ * @internal
+ * @group Transport
+ */
 const LIMEOBJECT_URL = '/api/v1/limeobject/';
 
-interface LimeobjectCrmApiResponse {
+/**
+ * Single Limeobject representation returned by the CRM API.
+ *
+ * @property id_ - The unique ID of the Limeobject
+ * @property _links - Links metadata returned by the API (not used in processing)
+ * @public
+ * @group Transport
+ */
+export interface LimeobjectCrmApiResponse {
     id_: number;
     _links: object;
 }
 
-interface FetchManyLimeobjectsApiResponse {
+/**
+ * Representation of the response from the CRM API when fetching multiple Limeobjects.
+ *
+ * @property _embedded - The embedded resources
+ * @property _embedded.limeobjects - An array of Limeobjects returned by the API. {@link LimeobjectCrmApiResponse}
+ * @public
+ * @group Transport
+ */
+export interface FetchManyLimeobjectsApiResponse {
     _embedded: {
         limeobjects: LimeobjectCrmApiResponse[];
     };
 }
 
+/**
+ * Create a new Limeobject for the specified Limetype.
+ *
+ * @param nodeContext - The n8n execution context
+ * @param limetype - The Limetype of the object to create
+ * @param data - The data object to send to the API
+ * @returns The created Limeobject
+ * @public
+ * @group Transport
+ */
 export async function createLimeobject(
     nodeContext: IAllExecuteFunctions,
     limetype: string,
     data: object
-): Promise<NodeResponse<Limeobject>> {
+): Promise<APIResponse<Limeobject>> {
     const url = `${LIMEOBJECT_URL}${limetype}/`;
-    const response = await callLimeApi<LimeobjectCrmApiResponse>(
-        nodeContext,
-        'POST',
-        url,
-        {
+    const response = await callLimeApi<LimeobjectCrmApiResponse>(nodeContext, {
+        method: 'POST',
+        url: url,
+        requestOptions: {
             body: data,
-        }
-    );
-    if (response.success)
-        return {
-            success: true,
-            data: removeKeys(response.data, ['_links']),
-        };
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
+        },
+        errorMetadata: {
             limetype: limetype,
         },
-    };
+    });
+    if (response.success) {
+        return prepareResponseWithoutKeys(response, ['_links']);
+    } else {
+        return response;
+    }
 }
 
+/**
+ * Delete a Limeobject.
+ *
+ * @param nodeContext - The n8n execution context
+ * @param limetype - The Limetype of the object to delete
+ * @param id - The ID of the Limeobject
+ * @returns empty response
+ *
+ * @public
+ * @group Transport
+ */
 export async function deleteLimeobject(
     nodeContext: IAllExecuteFunctions,
     limetype: string,
     id: string
-): Promise<NodeResponse<void>> {
+): Promise<APIResponse<Record<string, never>>> {
     const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
-    const response: NodeResponse<void> = await callLimeApi(
-        nodeContext,
-        'DELETE',
-        url
-    );
-
-    if (response.success) return response;
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
+    return await callLimeApi<Record<string, never>>(nodeContext, {
+        method: 'DELETE',
+        url: url,
+        errorMetadata: {
             limetype: limetype,
             id: id,
         },
-    };
+    });
 }
 
+/**
+ * Retrieve a Limeobject.
+ *
+ * @param nodeContext - The n8n execution context
+ * @param limetype - The Limetype of the object to retrieve
+ * @param id - The ID of the Limeobject
+ * @returns The Limeobject.
+ *
+ * @public
+ * @group Transport
+ */
 export async function getLimeobject(
     nodeContext: IAllExecuteFunctions,
     limetype: string,
     id: string
-): Promise<NodeResponse<Limeobject>> {
+): Promise<APIResponse<Limeobject>> {
     const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
-    const response = await callLimeApi<LimeobjectCrmApiResponse>(
-        nodeContext,
-        'GET',
-        url
-    );
-
-    if (response.success)
-        return {
-            success: true,
-            data: removeKeys(response.data, ['_links']),
-        };
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
+    const response = await callLimeApi<LimeobjectCrmApiResponse>(nodeContext, {
+        method: 'GET',
+        url: url,
+        errorMetadata: {
             limetype: limetype,
             id: id,
         },
-    };
+    });
+    if (response.success) {
+        return prepareResponseWithoutKeys(response, ['_links']);
+    } else {
+        return response;
+    }
 }
 
+/**
+ * Update a Limeobject.
+ *
+ * @param nodeContext - The n8n execution context
+ * @param limetype - The Limetype of the object to update
+ * @param id - The ID of the Limeobject
+ * @param data - The updated data to send
+ * @returns The updated Limeobject.
+ *
+ * @public
+ * @group Transport
+ */
 export async function updateLimeobject(
     nodeContext: IAllExecuteFunctions,
     limetype: string,
     id: string,
     data: object
-): Promise<NodeResponse<Limeobject>> {
+): Promise<APIResponse<Limeobject>> {
     const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
-    const response = await callLimeApi<LimeobjectCrmApiResponse>(
-        nodeContext,
-        'PUT',
-        url,
-        {
+    const response = await callLimeApi<LimeobjectCrmApiResponse>(nodeContext, {
+        method: 'PUT',
+        url: url,
+        requestOptions: {
             body: data,
-        }
-    );
-
-    if (response.success)
-        return {
-            success: true,
-            data: removeKeys(response.data, ['_links']),
-        };
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
+        },
+        errorMetadata: {
             limetype: limetype,
             id: id,
         },
-    };
-}
-
-async function _searchLimeobjectWithLimit(
-    nodeContext: IAllExecuteFunctions,
-    url: string,
-    limit: number,
-    offset: number,
-    qs: IDataObject
-): Promise<NodeResponse<FetchManyLimeobjectsApiResponse>> {
-    const returnData: LimeobjectCrmApiResponse[] = [];
-    let hasMoreData = true;
-    let currentOffset = Math.max(0, offset);
-    const pageLimit = 50;
-
-    while (hasMoreData) {
-        qs._limit = Math.min(limit, pageLimit);
-        qs._offset = currentOffset;
-
-        const response = await callLimeApi<FetchManyLimeobjectsApiResponse>(
-            nodeContext,
-            'GET',
-            url,
-            {
-                qs: qs,
-            }
-        );
-        if (!response.success) return response;
-
-        const items = response.data._embedded?.limeobjects || [];
-
-        if (items.length === 0) {
-            hasMoreData = false;
-        } else {
-            returnData.push(...items);
-            currentOffset += items.length;
-            limit -= items.length;
-
-            if (limit <= 0) {
-                hasMoreData = false;
-            }
-        }
-    }
-    return {
-        success: true,
-        data: { _embedded: { limeobjects: returnData } },
-    };
-}
-
-export async function fetchManyLimeobjects(
-    nodeContext: IAllExecuteFunctions,
-    limetype: string,
-    searchField: string,
-    searchTerm: string,
-    limit: number,
-    offset: number,
-    sortField: string | null
-): Promise<NodeResponse<Limeobject[]>> {
-    const url = `${LIMEOBJECT_URL}${limetype}/`;
-    const qs: IDataObject = {
-        ...(searchField && searchTerm && { [searchField]: searchTerm }),
-        ...(offset != null && offset > 0 && { _offset: offset }),
-        ...(sortField != null && { _sort: sortField }),
-    };
-
-    let response;
-    if (limit) {
-        response = await _searchLimeobjectWithLimit(
-            nodeContext,
-            url,
-            limit,
-            offset,
-            qs
-        );
-    } else {
-        response = await callLimeApi<FetchManyLimeobjectsApiResponse>(
-            nodeContext,
-            'GET',
-            url,
-            {
-                qs: qs,
-            }
-        );
-    }
-
+    });
     if (response.success) {
-        return {
-            success: true,
-            data:
-                response.data?._embedded.limeobjects.map((limeobject) =>
-                    removeKeys(limeobject, ['_links'])
-                ) ?? [],
-        };
+        return prepareResponseWithoutKeys(response, ['_links']);
+    } else {
+        return response;
     }
-    return {
-        success: response.success,
-        error: response.error,
-        status: response.status,
-        metadata: {
-            ...response.metadata,
-            limetype: limetype,
-        },
-    };
 }

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

@@ -1,18 +1,45 @@
 import { callLimeApi } from '.';
 import { IAllExecuteFunctions } from 'n8n-workflow';
-import { Limetype, LimetypeProperty } from '../model';
-import { NodeResponse } from '../../nodeResponse';
 import { removeKeys } from './commons';
+import { Limetype, LimetypeProperty } from '../models';
+import { APIResponse } from '../../response';
 
+/**
+ * Endpoint path for Lime CRM Limetype API.
+ *
+ * @internal
+ * @group Transport
+ */
 const LIMETYPE_URL = '/api/v1/limetype/';
 
-interface LimetypePropertyApiResponse {
+/**
+ * Lime CRM Limetype API response structure.
+ *
+ * @property name - The internal name of the property
+ * @property _links - Optional API link metadata
+ * @property _embedded - Optional embedded resources
+ *
+ * @public
+ * @group Transport
+ */
+export interface LimetypePropertyApiResponse {
     name: string;
     _links?: object;
     _embedded?: object;
 }
 
-interface LimetypeCrmApiResponse {
+/**
+ * Representation of a single Limetype object returned by the Lime CRM API.
+ *
+ * @property name - The internal name of the Limetype
+ * @property localname - Optional local name for singular and plural forms
+ * @property _embedded - Contains the Limetype's properties
+ * @property _links - API link metadata.
+ *
+ * @public
+ * @group Transport
+ */
+export interface LimetypeCrmApiResponse {
     name: string;
     localname?: {
         singular?: string;
@@ -24,19 +51,49 @@ interface LimetypeCrmApiResponse {
     _links: object;
 }
 
-interface LimetypesCrmApiResponse {
+/**
+ * Response structure for the `/limetype/` endpoint.
+ *
+ * @property _embedded - The embedded resources
+ * @property _embedded.limetypes - The list of Limetype definitions
+ * @property _embedded._links - API link metadata
+ *
+ * @public
+ * @group Transport
+ */
+export interface LimetypesCrmApiResponse {
     _embedded: {
         limetypes: LimetypeCrmApiResponse[];
         _links: object;
     };
 }
 
-interface LimetypePropertiesApiResponse {
+/**
+ * Response structure for the Limetype properties API.
+ *
+ * @property _embedded - The embedded resources
+ * @property _embedded.properties - The list of Limetype properties
+ *
+ * @public
+ * @group Transport
+ */
+export interface LimetypePropertiesApiResponse {
     _embedded: {
         properties: LimetypeCrmApiResponse[];
     };
 }
 
+/**
+ * Transform a Lime CRM API Limetype response into an internal {@link Limetype} model.
+ *
+ * Removes `_links` and `_embedded` metadata while preserving property data.
+ *
+ * @param limetype - The raw Limetype API response.
+ * @returns A deserialized {@link Limetype} object.
+ *
+ * @internal
+ * @group Transport
+ */
 function deserializeLimetype(limetype: LimetypeCrmApiResponse): Limetype {
     return {
         ...removeKeys(limetype, ['_links', '_embedded']),
@@ -46,19 +103,27 @@ function deserializeLimetype(limetype: LimetypeCrmApiResponse): Limetype {
     } as Limetype;
 }
 
+/**
+ * Fetch all available Limetypes from the Lime CRM API, including their properties.
+ *
+ * @param nodeContext - The n8n execution context
+ * @returns A list of {@link Limetype} objects
+ *
+ * @public
+ * @group Transport
+ */
 export async function getLimetypesFromApi(
     nodeContext: IAllExecuteFunctions
-): Promise<NodeResponse<Limetype[]>> {
-    const response = await callLimeApi<LimetypesCrmApiResponse>(
-        nodeContext,
-        'GET',
-        LIMETYPE_URL,
-        {
+): Promise<APIResponse<Limetype[]>> {
+    const response = await callLimeApi<LimetypesCrmApiResponse>(nodeContext, {
+        method: 'GET',
+        url: LIMETYPE_URL,
+        requestOptions: {
             qs: {
                 _embed: 'limetypes.properties',
             },
-        }
-    );
+        },
+    });
     if (response.success) {
         return {
             success: true,
@@ -66,62 +131,80 @@ export async function getLimetypesFromApi(
                 response.data._embedded?.limetypes.map(deserializeLimetype) ||
                 [],
         };
+    } else {
+        return response;
     }
-    return response;
 }
 
+/**
+ * Fetch a specific Limetype definition from the Lime CRM API.
+ *
+ * @param nodeContext - The n8n execution context
+ * @param limetype - The internal name of the Limetype to fetch
+ * @returns A {@link Limetype} object
+ *
+ * @public
+ * @group Transport
+ */
 export async function getLimetype(
     nodeContext: IAllExecuteFunctions,
     limetype: string
-): Promise<NodeResponse<Limetype>> {
+): Promise<APIResponse<Limetype>> {
     const url = `${LIMETYPE_URL}${limetype}/`;
-    const response = await callLimeApi<LimetypeCrmApiResponse>(
-        nodeContext,
-        'GET',
-        url,
-        {
+    const response = await callLimeApi<LimetypeCrmApiResponse>(nodeContext, {
+        method: 'GET',
+        url: url,
+        requestOptions: {
             qs: {
                 _embed: 'properties',
             },
-        }
-    );
-
-    if (response.success)
+        },
+    });
+    if (response.success) {
         return {
             success: true,
             data: deserializeLimetype(response.data),
         };
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            limetype: limetype,
-        },
-    };
+    } else {
+        return response;
+    }
 }
 
+/**
+ * Fetch the property definitions of a specific Limetype.
+ *
+ * @param nodeContext - The n8n execution context
+ * @param limetype - The internal name of the Limetype to fetch properties for
+ * @returns An array of {@link LimetypeProperty} objects.
+ *
+ * @public
+ * @group Transport
+ */
 export async function getProperties(
     nodeContext: IAllExecuteFunctions,
     limetype: string
-): Promise<NodeResponse<LimetypeProperty[]>> {
+): Promise<APIResponse<LimetypeProperty[]>> {
     const url = `${LIMETYPE_URL}${limetype}/`;
     const response = await callLimeApi<LimetypePropertiesApiResponse>(
         nodeContext,
-        'GET',
-        url,
         {
-            qs: {
-                _embed: 'properties',
+            method: 'GET',
+            url: url,
+            requestOptions: {
+                qs: {
+                    _embed: 'properties',
+                },
+            },
+            errorMetadata: {
+                limetype: limetype,
             },
         }
     );
-
     if (response.success) {
         return {
             success: true,
             data:
-                response.data?._embedded.properties.map(
+                response.data._embedded.properties.map(
                     (property) =>
                         removeKeys(property, [
                             '_links',
@@ -129,13 +212,7 @@ export async function getProperties(
                         ]) as LimetypeProperty
                 ) || [],
         };
+    } else {
+        return response;
     }
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            limetype: limetype,
-        },
-    };
 }