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

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

@@ -5,14 +5,28 @@ import {
 } from 'n8n-workflow';
 import { getProperties } from '../transport/';
 
-async function _getProperties(nodeContext: ILoadOptionsFunctions) {
+/**
+ * Fetch all properties for a specific Lime type.
+ *
+ * This is an internal helper function used by other load-options methods.
+ * It calls the Lime API to retrieve properties for the selected Limetype.
+ *
+ * @param nodeContext - The n8n load options context
+ * @returns An array of properties if successful, or an empty array otherwise.
+ *
+ * @internal
+ * @group Load Options Methods
+ */
+async function fetchAllProperties(nodeContext: ILoadOptionsFunctions) {
     const limetype = nodeContext.getNodeParameter('limetype', '') as string;
     Logger.info(`Fetching file properties for Lime type: ${limetype}`);
     if (!limetype) return [];
-
-    const response = await getProperties(nodeContext, limetype);
-
-    return response.success ? response.data : [];
+    try {
+        return await getProperties(nodeContext, limetype);
+    } catch (error) {
+        Logger.warn(`There was a problem with fetching properties: ${error}`);
+        return [];
+    }
 }
 
 /**
@@ -27,13 +41,16 @@ async function _getProperties(nodeContext: ILoadOptionsFunctions) {
  * @param [allowedTypes] - Optional set of property types to filter by
  * @param [forbiddenType] - Optional set of property types to exclude
  * @returns Array of formatted property options
+ *
+ * @public
+ * @group Load Options Methods
  */
 export async function getFilteredLimetypeProperties(
     loader: ILoadOptionsFunctions,
     allowedTypes?: Set<string>,
     forbiddenType?: Set<string>
 ): Promise<INodePropertyOptions[]> {
-    const properties = await _getProperties(loader);
+    const properties = await fetchAllProperties(loader);
 
     return properties
         .filter(
@@ -44,22 +61,48 @@ export async function getFilteredLimetypeProperties(
         .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)' : ''}`,
-        }));
+            description: `Type: ${property.type as string} | Name: ${property.name as string}${(property.required as boolean) ? ' (Required)' : ''}`,
+            type: property.type,
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name));
 }
 
+/**
+ * Get all property options for the current Limetype.
+ *
+ * @returns Array of property options for the current Limetype.
+ *
+ * @public
+ * @group Load Options Methods
+ */
 export async function getLimetypeProperties(
     this: ILoadOptionsFunctions
 ): Promise<INodePropertyOptions[]> {
     return getFilteredLimetypeProperties(this);
 }
 
+/**
+ * Get only file property options for the current Limetype.
+ *
+ * @returns Array of file property options
+ *
+ * @public
+ * @group Load Options Methods
+ */
 export async function getFileProperties(
     this: ILoadOptionsFunctions
 ): Promise<INodePropertyOptions[]> {
     return getFilteredLimetypeProperties(this, new Set(['file']));
 }
 
+/**
+ * Get property options excluding those of type 'hasmany'.
+ *
+ * @returns Array of property options excluding 'hasmany' types
+ *
+ * @public
+ * @group Load Options Methods
+ */
 export async function getNoHasManyProperties(
     this: ILoadOptionsFunctions
 ): Promise<INodePropertyOptions[]> {

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

@@ -2,20 +2,25 @@ import { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
 import { getLimetypesFromApi } from '../transport';
 
 /**
- * Load available Lime types from the API
+ * Load available Limetypes from the API
+ *
+ * @returns Array of Limetypes options
+ *
+ * @public
+ * @group Load Options Methods
  */
 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) {
-            data.push({
-                name: limetype.localname?.singular || limetype.name,
-                value: limetype.name,
-            });
-        }
+
+    for (const limetype of response) {
+        data.push({
+            name: limetype.localname?.singular || limetype.name,
+            value: limetype.name,
+            description: limetype.name,
+        });
     }
-    return data;
+    return data.sort((a, b) => a.name.localeCompare(b.name));
 }

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

@@ -1,7 +1,7 @@
-export { getEntitiesForErpSystem } from './getEntitiesForErpSystem';
 export { getLimetypes } from './getLimetypes';
 export {
     getFileProperties,
+    getFilteredLimetypeProperties,
     getLimetypeProperties,
     getNoHasManyProperties,
 } from './getLimetypeProperties';

package/nodes/lime-crm/models/constants.ts

@@ -0,0 +1,73 @@
+// Credentials
+
+/**
+ * Credential name for Lime CRM API nodes.
+ *
+ * @public
+ * @group Models
+ */
+export const LIME_CRM_API_CREDENTIAL_KEY = 'limeCrmApi';
+
+// Resources
+
+/**
+ * Resource name for administrative data operations.
+ *
+ * @public
+ * @group Models
+ */
+export const ADMIN_RESOURCE = 'admin';
+
+/**
+ * Resource name for main data operations.
+ *
+ * @public
+ * @group Models
+ */
+export const DATA_RESOURCE = 'data';
+
+/**
+ * Resource name for metadata-related operations.
+ *
+ * @public
+ * @group Models
+ */
+export const METADATA_RESOURCE = 'metadata';
+
+/**
+ * Resource name for ERP connector-related operations.
+ *
+ * @internal
+ * @group Models
+ */
+export const ERP_CONNECTOR_RESOURCE = 'erpConnector';
+
+// Types
+
+/**
+ * Helper type used when none value was provided in N8N form
+ * @public
+ * @group Models
+ */
+export type NullOptionType = '';
+
+/**
+ * Wrapper for generic return type of Lime CRM API values
+ */
+export type APIResponsePrimitiveValue = string | boolean | number | null;
+
+/**
+ * Wrapper for types of Lime CRM API values
+ */
+export type APIResponseValue =
+    | APIResponsePrimitiveValue
+    | APIResponsePrimitiveValue[]
+    | Record<string, APIResponsePrimitiveValue>;
+
+// API
+/**
+ * Default limit when working with Lime CRM API
+ * @public
+ * @group Models
+ */
+export const DEFAULT_API_OBJECT_LIMIT = 50;

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

@@ -0,0 +1,21 @@
+export {
+    LIME_CRM_API_CREDENTIAL_KEY,
+    ADMIN_RESOURCE,
+    DATA_RESOURCE,
+    METADATA_RESOURCE,
+    ERP_CONNECTOR_RESOURCE,
+    DEFAULT_API_OBJECT_LIMIT,
+    NullOptionType,
+    APIResponseValue,
+    APIResponsePrimitiveValue,
+} from './constants';
+export { Limetype, LimetypeLocalName, LimetypeProperty } from './limetype';
+export { Limeobject } from './limeobject';
+export {
+    CreateWebhook,
+    Webhook,
+    WebhookContext,
+    WebhookFunctions,
+} from './webhook';
+export { User, UserLoginType, UserType } from './users';
+export { YES_NO_PROPERTY_TYPE, PropertyTypeMap } from './propertyTypes';

package/nodes/lime-crm/models/limeobject.ts

@@ -0,0 +1,13 @@
+import { APIResponseValue } from './constants';
+
+/**
+ * Representation of a Limeobject returned by the Lime CRM API.
+ *
+ * @property id_ - The unique ID of the Limeobject
+ *
+ * @public
+ * @group Models
+ */
+export type Limeobject = {
+    id_: number;
+} & Record<string, APIResponseValue>;

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

@@ -0,0 +1,47 @@
+import { APIResponseValue } from './constants';
+
+/**
+ * Representation of a property of a Limetype.
+ *
+ * @property name - The internal name of the property
+ * @property localname - The display name of the property
+ * @property type - The type of the property (e.g., string, file, hasmany)
+ *
+ * @public
+ * @group Models
+ */
+export type LimetypeProperty = {
+    name: string;
+    localname: string;
+    type: string;
+} & Record<string, APIResponseValue>;
+
+/**
+ * Localized names for a Limetype.
+ *
+ * @property singular - Singular display name
+ * @property plural - Plural display name
+ *
+ * @public
+ * @group Models
+ */
+export type LimetypeLocalName = {
+    singular: string;
+    plural: string;
+};
+
+/**
+ * Representation of a Limetype.
+ *
+ * @property name - Internal name of the Limetype
+ * @property localname - Localized names
+ * @property properties - List of properties of this Limetype
+ *
+ * @public
+ * @group Models
+ */
+export type Limetype = {
+    name: string;
+    localname: LimetypeLocalName;
+    properties: LimetypeProperty[];
+} & Record<string, APIResponseValue>;

package/nodes/lime-crm/models/propertyTypes.ts

@@ -0,0 +1,13 @@
+/**
+ * Module for defining Lime CRM types which will need to be adapted to the
+ * proper format later on.
+ */
+
+export const YES_NO_PROPERTY_TYPE = 'yesno';
+
+/**
+ * A map of <Lime CRM Type>:<The type required in JSON format>
+ */
+export type PropertyTypeMap = {
+    YES_NO_PROPERTY_TYPE: boolean;
+};

package/nodes/lime-crm/models/users.ts

@@ -0,0 +1,46 @@
+import { APIResponseValue } from './constants';
+import { IncludedProperties } from '../transport';
+import { Limeobject } from './limeobject';
+
+/**
+ * Available user login types in Lime CRM
+ * @public
+ * @group Models
+ */
+type UserLoginType = 'DEFAULT' | 'LIME' | 'LIME_AND_WINDOWS';
+
+/**
+ * Available user types in Lime CRM
+ * @public
+ * @group Models
+ */
+type UserType =
+    | 'STANDARD'
+    | 'ADMINISTRATION'
+    | 'SERVICE'
+    | 'INTEGRATION'
+    | 'SYNCHRONIZATION'
+    | 'TEST'
+    | 'API';
+
+/**
+ * Representation of a user returned by the Lime CRM API.
+ *
+ * @property id - The unique ID of the user
+ * @property username - username, most often email address
+ * @property active - flag determining whether user is active
+ * @property loginType - user login type from Lime CRM
+ * @property userType - user type from Lime CRM
+ *
+ * @public
+ * @group Models
+ */
+type User = {
+    id: number;
+    username: string;
+    active: boolean;
+    loginType: UserLoginType;
+    userType: UserType;
+} & Record<string, APIResponseValue | IncludedProperties | Limeobject>;
+
+export { User, UserType, UserLoginType };

package/nodes/lime-crm/models/webhook.ts

@@ -0,0 +1,61 @@
+import { IDataObject, IHookFunctions, IWebhookFunctions } from 'n8n-workflow';
+
+/**
+ * Available webhook execution contexts in n8n.
+ *
+ * It can be either IHookFunctions or IWebhookFunctions,
+ * depending on the lifecycle stage of the node.
+ *
+ * @internal
+ * @group Models
+ */
+export type WebhookFunctions = IHookFunctions | IWebhookFunctions;
+
+/**
+ * Contextual information about a webhook, including its node and workflow details.
+ *
+ * @property nodeId - The unique identifier of the node
+ * @property nodeName - The name of the node (optional)
+ * @property workflowId - The unique identifier of the workflow (optional)
+ * @property workflowName - The name of the workflow (optional)
+ *
+ * @public
+ * @group Models
+ */
+export interface WebhookContext {
+    nodeId: string;
+    nodeName?: string;
+    workflowId?: string;
+    workflowName?: string;
+}
+
+/**
+ * Represent a webhook object.
+ *
+ * @property data - Arbitrary workflow data associated with this webhook
+ * @property events - List of events that this webhook is subscribed to
+ * @property url - Optional URL of the webhook
+ * @property context - Context about the node and workflow that owns the webhook
+ * @property name - Name of the webhook
+ *
+ * @public
+ * @group Models
+ */
+export interface Webhook {
+    data: IDataObject;
+    events: string[];
+    url?: string;
+    context: WebhookContext;
+    name: string;
+}
+
+/**
+ * Extend {@link Webhook} with an optional secret for secure webhooks.
+ *
+ * @property secret - Optional secret used to verify webhook requests
+ * @public
+ * @group Models
+ */
+export interface CreateWebhook extends Webhook {
+    secret?: string;
+}

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

@@ -0,0 +1,89 @@
+import {
+    INodeExecutionData,
+    IExecuteFunctions,
+    INodeProperties,
+    NodePropertyTypes,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+import * as operations from './operations';
+
+import { ADMIN_RESOURCE, User } from '../../models';
+import { N8NOperationModuleHandler } from '../../../modules';
+
+const moduleHandler = new N8NOperationModuleHandler([
+    operations.getManyUsers,
+    operations.getSingleUser,
+]);
+
+/**
+ * Fields and operations for the **Admin** resource in Lime CRM.
+ *
+ * @remarks
+ * - These fields are displayed in the n8n node UI when the resource is set to `Admin`.
+ * - Each operation corresponds to a CRUD action.
+ *
+ * @group Resources
+ * @public
+ *
+ * @see {@link getManyUsers} - Operation to retrieve many Lime CRM users' data
+ * @see {@link getSingleUser} - Operation to retrieve a single user from Lime CRM
+ */
+export const adminFields: INodeProperties[] = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options' as NodePropertyTypes,
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+            },
+        },
+        options: moduleHandler.getDescriptions(),
+        default: 'getSingleUser',
+    },
+
+    ...moduleHandler.getProperties(),
+];
+
+/**
+ * Execute a specific **Admin** operation on Lime CRM objects.
+ *
+ * @param args - Contextual parameters for the operation being executed
+ * @param args.operation - The operation to perform (e.g., `getSingleUser`, `getManyUsers`)
+ * @param args.i - The index of the input item to process
+ *
+ * @returns A promise resolving to the n8n object containing the result of the operation.
+ *
+ * @throws NodeOperationError if the operation is unsupported or fails.
+ *
+ * @public
+ * @group Resources
+ */
+export async function adminOperations(
+    this: IExecuteFunctions,
+    { operation, i }: { operation: string; i: number }
+): Promise<INodeExecutionData | INodeExecutionData[]> {
+    switch (operation) {
+        case 'getManyUsers': {
+            const result = await operations.getManyUsers.execute.call(this, i);
+
+            return result.map((item: User) => ({
+                json: item,
+            }));
+        }
+        case 'getSingleUser': {
+            return {
+                json: await operations.getSingleUser.execute.call(this, i),
+            };
+        }
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The operation "${operation}" is not supported!`
+    );
+}
+
+export * from './operations';

package/nodes/lime-crm/resources/admin/operations/getManyUsers.operation.ts

@@ -0,0 +1,166 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import {
+    User,
+    UserType,
+    ADMIN_RESOURCE,
+    NullOptionType,
+    DEFAULT_API_OBJECT_LIMIT,
+} from '../../../models';
+import { fetchManyUsers } from '../../../transport';
+
+export const description = {
+    name: 'Get many users',
+    value: 'getManyUsers',
+    description: 'Get a list of users in the system',
+    action: 'Get many users',
+};
+
+/**
+ * Node properties for the "Get Many Users" operation.
+ *
+ * @param {boolean | null} id - Filter only active or inactive users
+ * @param {UserType} userType  - Filter by User Type
+ * @param {number} limit - Set a limit for how many users should the API return
+ *
+ * @public
+ */
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Active',
+        name: 'active',
+        type: 'options',
+        description: 'Filter only active or inactive users',
+        default: '',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getManyUsers'],
+            },
+        },
+        options: [
+            {
+                name: '',
+                value: '',
+            },
+            {
+                name: 'Active',
+                value: true,
+            },
+            {
+                name: 'Inactive',
+                value: false,
+            },
+        ],
+    },
+    {
+        displayName: 'User Type',
+        name: 'userType',
+        type: 'options',
+        description: 'Get only selected user types',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getManyUsers'],
+            },
+        },
+        default: '',
+        options: [
+            {
+                name: '',
+                value: '',
+            },
+            {
+                name: 'Standard',
+                value: 'STANDARD',
+            },
+            {
+                name: 'Administration',
+                value: 'ADMINISTRATION',
+            },
+            {
+                name: 'Service',
+                value: 'SERVICE',
+            },
+            {
+                name: 'Integration',
+                value: 'INTEGRATION',
+            },
+            {
+                name: 'Synchronization',
+                value: 'SYNCHRONIZATION',
+            },
+            {
+                name: 'Test',
+                value: 'TEST',
+            },
+            {
+                name: 'API',
+                value: 'API',
+            },
+        ],
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        default: DEFAULT_API_OBJECT_LIMIT,
+        description: 'The maximum number of records to return',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getManyUsers'],
+            },
+        },
+    },
+    {
+        displayName: 'Include Coworker',
+        name: 'withCoworker',
+        type: 'boolean',
+        default: '',
+        description: 'Whether to include coworker data in the response',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getManyUsers'],
+            },
+        },
+    },
+];
+
+/**
+ * Execute the "Get Many Users" operation for Lime CRM.
+ *
+ * @remarks
+ * This method retrieves many Lime CRM users with properties, if provided.
+ *
+ * @param i - The index of the current item in the workflow execution
+ *
+ * @returns User data.
+ *
+ * @public
+ */
+
+export async function execute(
+    this: IExecuteFunctions,
+    i: number
+): Promise<User[]> {
+    const active = this.getNodeParameter('active', i) as
+        | boolean
+        | NullOptionType;
+    const userType = this.getNodeParameter('userType', i) as
+        | UserType
+        | NullOptionType;
+    const limit =
+        (this.getNodeParameter(
+            'limit',
+            i,
+            DEFAULT_API_OBJECT_LIMIT
+        ) as number) || DEFAULT_API_OBJECT_LIMIT;
+    const withCoworker = this.getNodeParameter(
+        'withCoworker',
+        i,
+        false
+    ) as boolean;
+    return await fetchManyUsers(this, active, userType, limit, withCoworker);
+}