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

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,94 @@
+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);
+            if (Array.isArray(result)) {
+                return result.map((item: User) => ({
+                    json: item,
+                }));
+            } else {
+                return {
+                    json: result,
+                };
+            }
+        }
+        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,174 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+
+import {
+    User,
+    UserType,
+    ADMIN_RESOURCE,
+    NullOptionType,
+    DEFAULT_API_OBJECT_LIMIT,
+} from '../../../models';
+import { fetchManyUsers } from '../../../transport';
+import { WorkflowResponse } from '../../../../response';
+
+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<WorkflowResponse<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;
+    const response = await fetchManyUsers(
+        this,
+        active,
+        userType,
+        limit,
+        withCoworker
+    );
+    return response.data;
+}

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

@@ -0,0 +1,112 @@
+import { IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+import { User, ADMIN_RESOURCE } from '../../../models';
+import {
+    fetchSingleUserById,
+    fetchSingleUserByLimeobjectId,
+} from '../../../transport';
+import { WorkflowResponse, APIResponse } from '../../../../response';
+import { handleWorkflowError } from '../../../../errorHandling';
+
+export const description = {
+    name: 'Get single user',
+    value: 'getSingleUser',
+    description: 'Get a single user data',
+    action: 'Get single user',
+};
+
+/**
+ * Node properties for the "Get Single User" operation.
+ *
+ * @param {string} id - The ID of the user to retrieve
+ *
+ * @public
+ */
+export const properties: INodeProperties[] = [
+    {
+        displayName: 'Get by',
+        name: 'source',
+        type: 'options',
+        required: true,
+        placeholder: 'Add Source',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getSingleUser'],
+            },
+        },
+        options: [
+            {
+                name: 'User ID',
+                value: 'byUser',
+                description: 'Get user by its ID',
+            },
+            {
+                name: 'Limeobject ID',
+                value: 'byLimeobject',
+                description: "Get user by it's related Limeobject ID",
+            },
+        ],
+        default: 'byUser',
+    },
+    {
+        displayName: 'Identifier',
+        name: 'identifier',
+        type: 'string',
+        required: true,
+        default: '',
+        description: 'The ID of the user or Limeobject to retrieve',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getSingleUser'],
+            },
+        },
+    },
+    {
+        displayName: 'Include Coworker',
+        name: 'withCoworker',
+        type: 'boolean',
+        default: '',
+        description: 'Whether to include coworker data in the response',
+        displayOptions: {
+            show: {
+                resource: [ADMIN_RESOURCE],
+                operation: ['getSingleUser'],
+            },
+        },
+    },
+];
+/**
+ * Execute the "Get Single Object" operation for Lime CRM.
+ *
+ * @remarks
+ * This method retrieves a single Lime CRM user identified by its ID.
+ *
+ * @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<WorkflowResponse<User>> {
+    const source = this.getNodeParameter('source', i) as string;
+    const id = this.getNodeParameter('identifier', i) as string;
+    const withCoworker = this.getNodeParameter('withCoworker', i) as boolean;
+
+    let response: APIResponse<User>;
+
+    if (source == 'byUser') {
+        response = await fetchSingleUserById(this, id, withCoworker);
+    } else if (source == 'byLimeobject') {
+        response = await fetchSingleUserByLimeobjectId(this, id, withCoworker);
+    } else {
+        response = handleWorkflowError(this, {
+            message: `The source ${source} is not supported!`,
+        });
+    }
+
+    return response.data;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * @group Resources
+ */
+export * as getManyUsers from './getManyUsers.operation';
+/**
+ * @group Resources
+ */
+export * as getSingleUser from './getSingleUser.operation';

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

@@ -6,15 +6,40 @@ import {
     NodeOperationError,
 } from 'n8n-workflow';
 
-import * as createSingleObject from './operations/createSingleObject';
-import * as getSingleObject from './operations/getSingleObject';
-import * as updateSingleObject from './operations/updateSingleObject.operation';
-import * as deleteSingleObject from './operations/deleteSingleObject';
-import * as getManyObjects from './operations/getManyObjects';
-import * as getSingleFile from './operations/getSingleFile';
+import * as operations from './operations';
 
-import { DATA_RESOURCE } from '../../commons';
+import { DATA_RESOURCE } from '../../models';
+import { N8NOperationModuleHandler } from '../../../modules';
 
+/**
+ * List of modules consisting data operations
+ */
+const moduleHandler = new N8NOperationModuleHandler([
+    operations.createSingleObject,
+    operations.getSingleObject,
+    operations.updateSingleObject,
+    operations.deleteSingleObject,
+    operations.getManyObjects,
+    operations.getSingleFile,
+]);
+
+/**
+ * Fields and operations for the **Data** resource in Lime CRM.
+ *
+ * @remarks
+ * - These fields are displayed in the n8n node UI when the resource is set to `Data`.
+ * - Each operation corresponds to a CRUD action or a file retrieval for Lime objects.
+ *
+ * @group Resources
+ * @public
+ *
+ * @see {@link createSingleObject} - Operation to create a single Limeobject
+ * @see {@link getSingleObject} - Operation to retrieve a single Limeobject by ID
+ * @see {@link updateSingleObject} - Operation to update a single Limeobject by ID
+ * @see {@link deleteSingleObject} - Operation to delete a single Limeobject by ID
+ * @see {@link getManyObjects} - Operation to fetch multiple Limeobjects based on search criteria
+ * @see {@link getSingleFile} - Operation to retrieve a single from Lime CRM
+ */
 export const dataFields: INodeProperties[] = [
     {
         displayName: 'Operation',
@@ -26,50 +51,69 @@ export const dataFields: INodeProperties[] = [
                 resource: [DATA_RESOURCE],
             },
         },
-        options: [
-            createSingleObject.description,
-            getSingleObject.description,
-            updateSingleObject.description,
-            deleteSingleObject.description,
-            getManyObjects.description,
-            getSingleFile.description,
-        ],
+        options: moduleHandler.getDescriptions(),
         default: 'fetchMany',
     },
 
-    ...createSingleObject.properties,
-    ...getSingleObject.properties,
-    ...updateSingleObject.properties,
-    ...deleteSingleObject.properties,
-    ...getSingleFile.properties,
-    ...getManyObjects.properties,
+    ...moduleHandler.getProperties(),
 ];
 
+/**
+ * Execute a specific **Data** operation on Lime CRM objects.
+ *
+ * @param args - Contextual parameters for the operation being executed
+ * @param args.operation - The operation to perform (e.g., `createSingleObject`, `getManyObjects`)
+ * @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 dataOperations(
     this: IExecuteFunctions,
     { operation, i }: { operation: string; i: number }
-): Promise<INodeExecutionData> {
+): Promise<INodeExecutionData | INodeExecutionData[]> {
     switch (operation) {
         case 'createSingleObject': {
-            return { json: await createSingleObject.execute.call(this, i) };
+            return {
+                json: await operations.createSingleObject.execute.call(this, i),
+            };
         }
         case 'getSingleObject': {
-            return await getSingleObject.execute.call(this, i);
+            return await operations.getSingleObject.execute.call(this, i);
         }
         case 'updateSingleObject': {
-            return { json: await updateSingleObject.execute.call(this, i) };
+            return {
+                ...(await operations.updateSingleObject.execute.call(this, i)),
+            };
         }
         case 'deleteSingleObject': {
-            await deleteSingleObject.execute.call(this, i);
-            return { json: { success: true } };
+            const response = await operations.deleteSingleObject.execute.call(
+                this,
+                i
+            );
+            return { json: response };
         }
         case 'getManyObjects': {
-            return {
-                json: await getManyObjects.execute.call(this, i),
-            };
+            const result = await operations.getManyObjects.execute.call(
+                this,
+                i
+            );
+            if (Array.isArray(result)) {
+                return result.map((item) => ({
+                    json: item,
+                }));
+            } else {
+                return {
+                    json: result,
+                };
+            }
         }
         case 'getSingleFile': {
-            return await getSingleFile.execute.call(this, i);
+            return await operations.getSingleFile.execute.call(this, i);
         }
     }
 
@@ -78,3 +122,5 @@ export async function dataOperations(
         `The operation "${operation}" is not supported!`
     );
 }
+
+export * from './operations';