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

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);
+}

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

@@ -0,0 +1,113 @@
+import {
+    IExecuteFunctions,
+    INodeProperties,
+    NodeOperationError,
+} from 'n8n-workflow';
+
+import { User, ADMIN_RESOURCE } from '../../../models';
+import {
+    fetchSingleUserById,
+    fetchSingleUserByLimeobjectId,
+} from '../../../transport';
+
+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<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;
+
+    if (source == 'byUser') {
+        return await fetchSingleUserById(this, id, withCoworker);
+    }
+    if (source == 'byLimeobject') {
+        return await fetchSingleUserByLimeobjectId(this, id, withCoworker);
+    }
+
+    throw new NodeOperationError(
+        this.getNode(),
+        `The source "${source}" is not supported!`
+    );
+}

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';