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

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

@@ -1,197 +1,155 @@
-import { callLimeApi } from './commons';
-import { IAllExecuteFunctions, IDataObject } from 'n8n-workflow';
-import { NodeResponse } from '../../nodeResponse';
-
+import { callLimeApi, removeKeys } from './commons';
+import { IAllExecuteFunctions } from 'n8n-workflow';
+import { Limeobject } from '../models';
+
+/**
+ * Endpoint path for Lime CRM Limeobject API.
+ *
+ * @internal
+ * @group Transport
+ */
 const LIMEOBJECT_URL = '/api/v1/limeobject/';
 
-interface FetchManyLimeObjectsApiResponse {
+/**
+ * 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;
+}
+
+/**
+ * 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: Array<object>;
+        limeobjects: LimeobjectCrmApiResponse[];
     };
 }
 
-export async function createLimeObject(
+/**
+ * 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,
+    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;
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            limeType: limeType,
+): Promise<Limeobject> {
+    const url = `${LIMEOBJECT_URL}${limetype}/`;
+    const response = await callLimeApi<LimeobjectCrmApiResponse>(nodeContext, {
+        method: 'POST',
+        url: url,
+        requestOptions: {
+            body: data,
         },
-    };
+        errorMetadata: {
+            limetype: limetype,
+        },
+    });
+    return removeKeys(response, ['_links']);
 }
 
-export async function deleteLimeObject(
+/**
+ * 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,
+    limetype: string,
     id: string
-): Promise<NodeResponse<void>> {
-    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,
-            limeType: limeType,
+): Promise<void> {
+    const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
+    return await callLimeApi(nodeContext, {
+        method: 'DELETE',
+        url: url,
+        errorMetadata: {
+            limetype: limetype,
             id: id,
         },
-    };
+    });
 }
 
-export async function getLimeObject(
+/**
+ * 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,
+    limetype: string,
     id: string
-): Promise<NodeResponse<unknown>> {
-    const url = `${LIMEOBJECT_URL}${limeType}/${id}/`;
-    const response = await callLimeApi(nodeContext, 'GET', url);
-
-    if (response.success) return response;
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            limeType: limeType,
+): Promise<Limeobject> {
+    const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
+    const response = await callLimeApi<LimeobjectCrmApiResponse>(nodeContext, {
+        method: 'GET',
+        url: url,
+        errorMetadata: {
+            limetype: limetype,
             id: id,
         },
-    };
+    });
+    return removeKeys(response, ['_links']);
 }
 
-export async function updateLimeObject(
+/**
+ * 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,
+    limetype: string,
     id: string,
     data: object
-): Promise<NodeResponse<unknown>> {
-    const url = `${LIMEOBJECT_URL}${limeType}/${id}/`;
-    const response = await callLimeApi(nodeContext, 'PUT', url, {
-        body: data,
-    });
-
-    if (response.success) return response;
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            limeType: limeType,
-            id: id,
+): Promise<Limeobject> {
+    const url = `${LIMEOBJECT_URL}${limetype}/${id}/`;
+    const response = await callLimeApi<LimeobjectCrmApiResponse>(nodeContext, {
+        method: 'PUT',
+        url: url,
+        requestOptions: {
+            body: data,
         },
-    };
-}
-
-async function _searchLimeObjectWithLimit(
-    nodeContext: IAllExecuteFunctions,
-    url: string,
-    limit: number,
-    offset: number,
-    qs: IDataObject
-): Promise<NodeResponse<FetchManyLimeObjectsApiResponse>> {
-    const returnData = [];
-    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<Array<object>>> {
-    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 ?? [],
-        };
-    }
-    return {
-        success: response.success,
-        error: response.error,
-        status: response.status,
-        metadata: {
-            ...response.metadata,
-            limeType: limeType,
+        errorMetadata: {
+            limetype: limetype,
+            id: id,
         },
-    };
+    });
+    return removeKeys(response, ['_links']);
 }

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

@@ -1,85 +1,197 @@
 import { callLimeApi } from '.';
 import { IAllExecuteFunctions } from 'n8n-workflow';
-import { LimeType, LimeTypeProperty } from '../commons';
-import { NodeResponse } from '../../nodeResponse';
+import { removeKeys } from './commons';
+import { Limetype, LimetypeProperty } from '../models';
 
+/**
+ * Endpoint path for Lime CRM Limetype API.
+ *
+ * @internal
+ * @group Transport
+ */
 const LIMETYPE_URL = '/api/v1/limetype/';
 
-interface LimeTypesApiResponse {
-    _links: {
-        limetypes: LimeType[];
+/**
+ * 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;
+}
+
+/**
+ * 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;
+        plural?: string;
+    };
+    _embedded: {
+        properties: LimetypePropertyApiResponse[];
     };
+    _links: object;
 }
 
-interface LimeTypePropertiesApiResponse {
+/**
+ * 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: {
-        properties: LimeTypeProperty[];
+        limetypes: LimetypeCrmApiResponse[];
+        _links: object;
     };
 }
 
-export async function getLimeTypesFromApi(
-    nodeContext: IAllExecuteFunctions
-): Promise<NodeResponse<LimeType[]>> {
-    const response = await callLimeApi<LimeTypesApiResponse>(
-        nodeContext,
-        'GET',
-        LIMETYPE_URL
-    );
-    if (response.success) {
-        return {
-            success: true,
-            data: response.data?._links.limetypes ?? [],
-        };
-    }
-    return response;
+/**
+ * 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[];
+    };
 }
 
-export async function getLimeType(
-    nodeContext: IAllExecuteFunctions,
-    limeType: string
-): Promise<NodeResponse<LimeType>> {
-    const url = `${LIMETYPE_URL}${limeType}/`;
-    const response = await callLimeApi<LimeType>(nodeContext, 'GET', url);
+/**
+ * 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']),
+        properties: limetype._embedded.properties.map((property) =>
+            removeKeys(property, ['_links'])
+        ),
+    } as Limetype;
+}
 
-    if (response.success) return response;
+/**
+ * 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<Limetype[]> {
+    const response = await callLimeApi<LimetypesCrmApiResponse>(nodeContext, {
+        method: 'GET',
+        url: LIMETYPE_URL,
+        requestOptions: {
+            qs: {
+                _embed: 'limetypes.properties',
+            },
+        },
+    });
+    return response._embedded?.limetypes.map(deserializeLimetype) || [];
+}
 
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            limetype: limeType,
+/**
+ * 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<Limetype> {
+    const url = `${LIMETYPE_URL}${limetype}/`;
+    const response = await callLimeApi<LimetypeCrmApiResponse>(nodeContext, {
+        method: 'GET',
+        url: url,
+        requestOptions: {
+            qs: {
+                _embed: 'properties',
+            },
         },
-    };
+    });
+
+    return deserializeLimetype(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[]>> {
-    const url = `${LIMETYPE_URL}${limeType}/`;
-    const response = await callLimeApi<LimeTypePropertiesApiResponse>(
+    limetype: string
+): Promise<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 ?? [],
-        };
-    }
-
-    return {
-        ...response,
-        metadata: {
-            ...response.metadata,
-            limetype: limeType,
-        },
-    };
+    return (
+        response._embedded.properties.map(
+            (property) =>
+                removeKeys(property, [
+                    '_links',
+                    '_embedded',
+                ]) as LimetypeProperty
+        ) || []
+    );
 }