n8n-nodes-cakemail 1.0.2 → 1.0.3

package/nodes/Cakemail/Cakemail.node.ts

@@ -0,0 +1,1528 @@
+import {
+  IExecuteFunctions,
+  INodeExecutionData,
+  INodeType,
+  INodeTypeDescription,
+  NodeOperationError,
+} from 'n8n-workflow';
+
+import { CakemailClient, CakemailError } from 'cakemail-sdk';
+
+/**
+ * Cakemail n8n node
+ */
+export class Cakemail implements INodeType {
+  description: INodeTypeDescription = {
+    displayName: 'Cakemail',
+    name: 'cakemail',
+    icon: 'file:cakemail.svg',
+    group: ['transform'],
+    version: 1,
+    subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+    description: 'Interact with Cakemail API',
+    defaults: {
+      name: 'Cakemail',
+    },
+    inputs: ['main'],
+    outputs: ['main'],
+    credentials: [
+      {
+        name: 'cakemailApi',
+        required: true,
+      },
+    ],
+    properties: [
+      // Resource selector
+      {
+        displayName: 'Resource',
+        name: 'resource',
+        type: 'options',
+        noDataExpression: true,
+        options: [
+          {
+            name: 'Account',
+            value: 'account',
+          },
+          {
+            name: 'Contact',
+            value: 'contact',
+          },
+          {
+            name: 'List',
+            value: 'list',
+          },
+          {
+            name: 'Campaign',
+            value: 'campaign',
+          },
+        ],
+        default: 'account',
+        required: true,
+        description: 'The resource to operate on',
+      },
+
+      // Account operations
+      {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ['account'],
+          },
+        },
+        options: [
+          {
+            name: 'Get',
+            value: 'get',
+            description: 'Get current account information',
+            action: 'Get current account',
+          },
+          {
+            name: 'Get By ID',
+            value: 'getById',
+            description: 'Get account by ID',
+            action: 'Get account by ID',
+          },
+          {
+            name: 'List',
+            value: 'list',
+            description: 'List accounts',
+            action: 'List accounts',
+          },
+          {
+            name: 'Create',
+            value: 'create',
+            description: 'Create a new account',
+            action: 'Create account',
+          },
+          {
+            name: 'Update',
+            value: 'update',
+            description: 'Update an account',
+            action: 'Update account',
+          },
+          {
+            name: 'Delete',
+            value: 'delete',
+            description: 'Delete an account',
+            action: 'Delete account',
+          },
+          {
+            name: 'Get Children',
+            value: 'getChildren',
+            description: 'Get child accounts of a parent account',
+            action: 'Get child accounts',
+          },
+        ],
+        default: 'get',
+        required: true,
+      },
+
+      // Contact operations
+      {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+          },
+        },
+        options: [
+          {
+            name: 'Get',
+            value: 'get',
+            description: 'Get a contact by ID',
+            action: 'Get contact',
+          },
+          {
+            name: 'Get By Email',
+            value: 'getByEmail',
+            description: 'Get a contact by email',
+            action: 'Get contact by email',
+          },
+          {
+            name: 'List',
+            value: 'list',
+            description: 'List contacts',
+            action: 'List contacts',
+          },
+          {
+            name: 'Create',
+            value: 'create',
+            description: 'Create a new contact',
+            action: 'Create contact',
+          },
+          {
+            name: 'Update',
+            value: 'update',
+            description: 'Update a contact',
+            action: 'Update contact',
+          },
+          {
+            name: 'Delete',
+            value: 'delete',
+            description: 'Delete a contact',
+            action: 'Delete contact',
+          },
+          {
+            name: 'Subscribe',
+            value: 'subscribe',
+            description: 'Subscribe a contact to a list',
+            action: 'Subscribe contact to list',
+          },
+          {
+            name: 'Unsubscribe',
+            value: 'unsubscribe',
+            description: 'Unsubscribe a contact from a list',
+            action: 'Unsubscribe contact from list',
+          },
+          {
+            name: 'Bulk Import',
+            value: 'bulkImport',
+            description: 'Import multiple contacts at once',
+            action: 'Bulk import contacts',
+          },
+          {
+            name: 'Search',
+            value: 'search',
+            description: 'Advanced search with custom field filtering',
+            action: 'Search contacts',
+          },
+          {
+            name: 'Add Tags',
+            value: 'addTags',
+            description: 'Add tags to a contact',
+            action: 'Add tags to contact',
+          },
+          {
+            name: 'Remove Tags',
+            value: 'removeTags',
+            description: 'Remove tags from a contact',
+            action: 'Remove tags from contact',
+          },
+        ],
+        default: 'get',
+        required: true,
+      },
+
+      // List operations
+      {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ['list'],
+          },
+        },
+        options: [
+          {
+            name: 'Get',
+            value: 'get',
+            description: 'Get a list by ID',
+            action: 'Get list',
+          },
+          {
+            name: 'List',
+            value: 'list',
+            description: 'List all lists',
+            action: 'List lists',
+          },
+          {
+            name: 'Create',
+            value: 'create',
+            description: 'Create a new list',
+            action: 'Create list',
+          },
+          {
+            name: 'Update',
+            value: 'update',
+            description: 'Update a list',
+            action: 'Update list',
+          },
+          {
+            name: 'Delete',
+            value: 'delete',
+            description: 'Delete a list',
+            action: 'Delete list',
+          },
+          {
+            name: 'Get Statistics',
+            value: 'getStatistics',
+            description: 'Get list statistics',
+            action: 'Get list statistics',
+          },
+        ],
+        default: 'get',
+        required: true,
+      },
+
+      // Campaign operations
+      {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+          show: {
+            resource: ['campaign'],
+          },
+        },
+        options: [
+          {
+            name: 'Get',
+            value: 'get',
+            description: 'Get a campaign by ID',
+            action: 'Get campaign',
+          },
+          {
+            name: 'List',
+            value: 'list',
+            description: 'List campaigns',
+            action: 'List campaigns',
+          },
+          {
+            name: 'Create',
+            value: 'create',
+            description: 'Create a new campaign',
+            action: 'Create campaign',
+          },
+          {
+            name: 'Update',
+            value: 'update',
+            description: 'Update a campaign',
+            action: 'Update campaign',
+          },
+          {
+            name: 'Delete',
+            value: 'delete',
+            description: 'Delete a campaign',
+            action: 'Delete campaign',
+          },
+          {
+            name: 'Send',
+            value: 'send',
+            description: 'Send a campaign',
+            action: 'Send campaign',
+          },
+        ],
+        default: 'get',
+        required: true,
+      },
+
+      // Multi-tenant account ID (optional for all operations)
+      {
+        displayName: 'Account ID',
+        name: 'accountId',
+        type: 'number',
+        default: undefined,
+        required: false,
+        description:
+          'Optional: Specify an account ID for multi-tenant operations. If not provided, uses the authenticated account.',
+      },
+
+      // ================== Account Operation Parameters ==================
+
+      // Target Account ID (for getById, update, delete, getChildren account operations)
+      {
+        displayName: 'Target Account ID',
+        name: 'targetAccountId',
+        type: 'number',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['account'],
+            operation: ['getById', 'update', 'delete', 'getChildren'],
+          },
+        },
+        default: 0,
+        description: 'The ID of the account to operate on',
+      },
+
+      // Account name (for create/update)
+      {
+        displayName: 'Name',
+        name: 'accountName',
+        type: 'string',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['account'],
+            operation: ['create'],
+          },
+        },
+        default: '',
+        description: 'Account name',
+      },
+
+      // Account email (for create)
+      {
+        displayName: 'Email',
+        name: 'accountEmail',
+        type: 'string',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['account'],
+            operation: ['create'],
+          },
+        },
+        default: '',
+        description: 'Primary email for the account',
+      },
+
+      // Account additional fields (for create/update)
+      {
+        displayName: 'Additional Fields',
+        name: 'accountAdditionalFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ['account'],
+            operation: ['create', 'update'],
+          },
+        },
+        options: [
+          {
+            displayName: 'Name',
+            name: 'name',
+            type: 'string',
+            default: '',
+            description: 'Account name (for update)',
+          },
+          {
+            displayName: 'Primary Email',
+            name: 'primary_email',
+            type: 'string',
+            default: '',
+            description: 'Primary email (for update)',
+          },
+          {
+            displayName: 'Account Type',
+            name: 'account_type',
+            type: 'options',
+            options: [
+              { name: 'Parent', value: 'parent' },
+              { name: 'Child', value: 'child' },
+              { name: 'Standalone', value: 'standalone' },
+            ],
+            default: 'standalone',
+            description: 'Type of account',
+          },
+          {
+            displayName: 'Parent Account ID',
+            name: 'parent_account_id',
+            type: 'number',
+            default: 0,
+            description: 'Parent account ID (for child accounts)',
+          },
+          {
+            displayName: 'Status',
+            name: 'status',
+            type: 'options',
+            options: [
+              { name: 'Active', value: 'active' },
+              { name: 'Suspended', value: 'suspended' },
+              { name: 'Deleted', value: 'deleted' },
+            ],
+            default: 'active',
+            description: 'Account status (for update)',
+          },
+          {
+            displayName: 'Language',
+            name: 'language',
+            type: 'string',
+            default: 'en',
+            description: 'Account language (e.g., en, fr)',
+          },
+          {
+            displayName: 'Timezone',
+            name: 'timezone',
+            type: 'string',
+            default: 'America/New_York',
+            description: 'Account timezone',
+          },
+          {
+            displayName: 'Currency',
+            name: 'currency',
+            type: 'string',
+            default: 'USD',
+            description: 'Account currency',
+          },
+          {
+            displayName: 'Settings',
+            name: 'settings',
+            type: 'json',
+            default: '{}',
+            description: 'Account settings as JSON object',
+          },
+        ],
+      },
+
+      // Get Children pagination options
+      {
+        displayName: 'Options',
+        name: 'getChildrenOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ['account'],
+            operation: ['getChildren'],
+          },
+        },
+        options: [
+          {
+            displayName: 'Page',
+            name: 'page',
+            type: 'number',
+            default: 1,
+            description: 'Page number',
+          },
+          {
+            displayName: 'Per Page',
+            name: 'per_page',
+            type: 'number',
+            default: 20,
+            description: 'Results per page',
+          },
+        ],
+      },
+
+      // Account list filters
+      {
+        displayName: 'Filters',
+        name: 'accountFilters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ['account'],
+            operation: ['list'],
+          },
+        },
+        options: [
+          {
+            displayName: 'Status',
+            name: 'status',
+            type: 'options',
+            options: [
+              { name: 'Active', value: 'active' },
+              { name: 'Suspended', value: 'suspended' },
+              { name: 'Deleted', value: 'deleted' },
+            ],
+            default: 'active',
+            description: 'Filter by account status',
+          },
+          {
+            displayName: 'Account Type',
+            name: 'account_type',
+            type: 'options',
+            options: [
+              { name: 'Parent', value: 'parent' },
+              { name: 'Child', value: 'child' },
+              { name: 'Standalone', value: 'standalone' },
+            ],
+            default: 'standalone',
+            description: 'Filter by account type',
+          },
+          {
+            displayName: 'Parent Account ID',
+            name: 'parent_account_id',
+            type: 'number',
+            default: 0,
+            description: 'Filter by parent account ID',
+          },
+          {
+            displayName: 'Search',
+            name: 'search',
+            type: 'string',
+            default: '',
+            description: 'Search by name or email',
+          },
+          {
+            displayName: 'Page',
+            name: 'page',
+            type: 'number',
+            default: 1,
+            description: 'Page number',
+          },
+          {
+            displayName: 'Per Page',
+            name: 'per_page',
+            type: 'number',
+            default: 20,
+            description: 'Results per page',
+          },
+        ],
+      },
+
+      // ================== List Operation Parameters ==================
+
+      // List ID (for get, update, delete list operations)
+      {
+        displayName: 'List ID',
+        name: 'listIdParam',
+        type: 'number',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['list'],
+            operation: ['get', 'update', 'delete', 'getStatistics'],
+          },
+        },
+        default: 0,
+        description: 'The ID of the list',
+      },
+
+      // List name (for create/update)
+      {
+        displayName: 'Name',
+        name: 'listName',
+        type: 'string',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['list'],
+            operation: ['create'],
+          },
+        },
+        default: '',
+        description: 'The name of the list',
+      },
+
+      // List additional fields
+      {
+        displayName: 'Additional Fields',
+        name: 'listAdditionalFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ['list'],
+            operation: ['create', 'update'],
+          },
+        },
+        options: [
+          {
+            displayName: 'Description',
+            name: 'description',
+            type: 'string',
+            default: '',
+            description: 'List description',
+          },
+          {
+            displayName: 'Sender Name',
+            name: 'sender_name',
+            type: 'string',
+            default: '',
+            description: 'Default sender name for campaigns',
+          },
+          {
+            displayName: 'Sender Email',
+            name: 'sender_email',
+            type: 'string',
+            default: '',
+            description: 'Default sender email for campaigns',
+          },
+          {
+            displayName: 'Language',
+            name: 'language',
+            type: 'string',
+            default: 'en',
+            description: 'Default language',
+          },
+        ],
+      },
+
+      // List pagination
+      {
+        displayName: 'Limit',
+        name: 'listLimit',
+        type: 'number',
+        displayOptions: {
+          show: {
+            resource: ['list'],
+            operation: ['list'],
+          },
+        },
+        default: 20,
+        description: 'Number of results to return',
+      },
+
+      // ================== Contact Operation Parameters ==================
+
+      // Contact ID (for get, update, delete, subscribe, unsubscribe, addTags, removeTags operations)
+      {
+        displayName: 'Contact ID',
+        name: 'contactId',
+        type: 'number',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+            operation: ['get', 'update', 'delete', 'subscribe', 'unsubscribe', 'addTags', 'removeTags'],
+          },
+        },
+        default: 0,
+        description: 'The ID of the contact',
+      },
+
+      // Tags (for addTags, removeTags operations)
+      {
+        displayName: 'Tags',
+        name: 'tagsToManage',
+        type: 'string',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+            operation: ['addTags', 'removeTags'],
+          },
+        },
+        default: '',
+        placeholder: 'vip, newsletter, customer',
+        description: 'Comma-separated list of tags',
+      },
+
+      // Contact Email (for getByEmail operation)
+      {
+        displayName: 'Email',
+        name: 'email',
+        type: 'string',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+            operation: ['getByEmail', 'create'],
+          },
+        },
+        default: '',
+        placeholder: 'user@example.com',
+        description: 'The email address of the contact',
+      },
+
+      // Contact fields for create/update
+      {
+        displayName: 'Additional Fields',
+        name: 'additionalFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+            operation: ['create', 'update'],
+          },
+        },
+        options: [
+          {
+            displayName: 'First Name',
+            name: 'first_name',
+            type: 'string',
+            default: '',
+            description: 'First name of the contact',
+          },
+          {
+            displayName: 'Last Name',
+            name: 'last_name',
+            type: 'string',
+            default: '',
+            description: 'Last name of the contact',
+          },
+          {
+            displayName: 'Company',
+            name: 'company',
+            type: 'string',
+            default: '',
+            description: 'Company name',
+          },
+          {
+            displayName: 'Phone',
+            name: 'phone',
+            type: 'string',
+            default: '',
+            description: 'Phone number',
+          },
+          {
+            displayName: 'Mobile',
+            name: 'mobile',
+            type: 'string',
+            default: '',
+            description: 'Mobile phone number',
+          },
+          {
+            displayName: 'Language',
+            name: 'language',
+            type: 'string',
+            default: 'en',
+            description: 'Preferred language (e.g., en, fr)',
+          },
+          {
+            displayName: 'Timezone',
+            name: 'timezone',
+            type: 'string',
+            default: 'UTC',
+            description: 'Timezone (e.g., America/New_York, Europe/Paris)',
+          },
+          {
+            displayName: 'Tags',
+            name: 'tags',
+            type: 'string',
+            default: '',
+            description: 'Comma-separated list of tags',
+          },
+          {
+            displayName: 'Custom Attributes',
+            name: 'custom_attributes',
+            type: 'json',
+            default: '{}',
+            description: 'JSON object with custom attribute key-value pairs',
+          },
+          {
+            displayName: 'List ID',
+            name: 'list_id',
+            type: 'number',
+            default: 0,
+            description: 'Subscribe contact to this list immediately (create only)',
+          },
+        ],
+      },
+
+      // List ID for subscribe/unsubscribe operations
+      {
+        displayName: 'List ID',
+        name: 'listId',
+        type: 'number',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+            operation: ['subscribe', 'unsubscribe'],
+          },
+        },
+        default: 0,
+        description: 'The ID of the list',
+      },
+
+      // Bulk import contacts
+      {
+        displayName: 'Contacts',
+        name: 'contacts',
+        type: 'json',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+            operation: ['bulkImport'],
+          },
+        },
+        default: '[]',
+        description: 'Array of contact objects to import. Each contact should have at least an email field.',
+        placeholder: '[{"email": "user1@example.com", "first_name": "John"}, {"email": "user2@example.com"}]',
+      },
+
+      // Advanced search parameters
+      {
+        displayName: 'Search Query',
+        name: 'searchQuery',
+        type: 'json',
+        required: true,
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+            operation: ['search'],
+          },
+        },
+        default: '{}',
+        description: 'Advanced search query with filters and operators',
+        placeholder: '{"custom_attributes.company": "Acme", "tags": ["vip"], "status": "active"}',
+      },
+
+      {
+        displayName: 'Search Options',
+        name: 'searchOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+            operation: ['search'],
+          },
+        },
+        options: [
+          {
+            displayName: 'Page',
+            name: 'page',
+            type: 'number',
+            default: 1,
+            description: 'Page number',
+          },
+          {
+            displayName: 'Per Page',
+            name: 'per_page',
+            type: 'number',
+            default: 20,
+            description: 'Results per page',
+          },
+          {
+            displayName: 'Sort By',
+            name: 'sort',
+            type: 'string',
+            default: 'created_on',
+            description: 'Field to sort by (e.g., created_on, email, first_name)',
+          },
+          {
+            displayName: 'Sort Order',
+            name: 'sort_order',
+            type: 'options',
+            options: [
+              { name: 'Ascending', value: 'asc' },
+              { name: 'Descending', value: 'desc' },
+            ],
+            default: 'desc',
+            description: 'Sort order',
+          },
+        ],
+      },
+
+      // List contacts filters
+      {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+          show: {
+            resource: ['contact'],
+            operation: ['list'],
+          },
+        },
+        options: [
+          {
+            displayName: 'Status',
+            name: 'status',
+            type: 'options',
+            options: [
+              {
+                name: 'Active',
+                value: 'active',
+              },
+              {
+                name: 'Unsubscribed',
+                value: 'unsubscribed',
+              },
+              {
+                name: 'Bounced',
+                value: 'bounced',
+              },
+              {
+                name: 'Complained',
+                value: 'complained',
+              },
+            ],
+            default: 'active',
+            description: 'Filter by contact status',
+          },
+          {
+            displayName: 'List ID',
+            name: 'list_id',
+            type: 'number',
+            default: 0,
+            description: 'Filter by list membership',
+          },
+          {
+            displayName: 'Search',
+            name: 'search',
+            type: 'string',
+            default: '',
+            description: 'Search by email, name, etc.',
+          },
+          {
+            displayName: 'Tags',
+            name: 'tags',
+            type: 'string',
+            default: '',
+            description: 'Comma-separated list of tags to filter by',
+          },
+          {
+            displayName: 'Page',
+            name: 'page',
+            type: 'number',
+            default: 1,
+            description: 'Page number for pagination',
+          },
+          {
+            displayName: 'Per Page',
+            name: 'per_page',
+            type: 'number',
+            default: 20,
+            description: 'Number of results per page',
+          },
+        ],
+      },
+    ],
+  };
+
+  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+    const items = this.getInputData();
+    const returnData: INodeExecutionData[] = [];
+
+    // Get credentials
+    const credentials = await this.getCredentials('cakemailApi');
+
+    // Initialize Cakemail client
+    const client = new CakemailClient({
+      email: credentials.email as string,
+      password: credentials.password as string,
+      baseURL: (credentials.baseURL as string) || undefined,
+    });
+
+    // Process each item
+    for (let i = 0; i < items.length; i++) {
+      try {
+        const resource = this.getNodeParameter('resource', i) as string;
+        const operation = this.getNodeParameter('operation', i) as string;
+        const accountId = this.getNodeParameter('accountId', i, undefined) as
+          | number
+          | undefined;
+
+        const options = accountId ? { accountId } : undefined;
+
+        let responseData: any;
+
+        // Route to appropriate resource handler
+        const node = new Cakemail();
+        if (resource === 'account') {
+          responseData = await node.executeAccountOperation.call(
+            this,
+            client,
+            operation,
+            i,
+            options
+          );
+        } else if (resource === 'contact') {
+          responseData = await node.executeContactOperation.call(
+            this,
+            client,
+            operation,
+            i,
+            options
+          );
+        } else if (resource === 'list') {
+          responseData = await node.executeListOperation.call(
+            this,
+            client,
+            operation,
+            i,
+            options
+          );
+        } else if (resource === 'campaign') {
+          responseData = await node.executeCampaignOperation.call(
+            this,
+            client,
+            operation,
+            i,
+            options
+          );
+        }
+
+        returnData.push({
+          json: responseData,
+          pairedItem: { item: i },
+        });
+      } catch (error: any) {
+        if (this.continueOnFail()) {
+          returnData.push({
+            json: {
+              error: error?.message || 'Unknown error',
+            },
+            pairedItem: { item: i },
+          });
+          continue;
+        }
+
+        // Convert Cakemail errors to n8n errors
+        if (error instanceof CakemailError) {
+          throw new NodeOperationError(this.getNode(), error.message, {
+            itemIndex: i,
+            description: error.cause?.message,
+          });
+        }
+
+        throw error;
+      }
+    }
+
+    return [returnData];
+  }
+
+  /**
+   * Execute account operations
+   */
+  private async executeAccountOperation(
+    this: IExecuteFunctions,
+    client: CakemailClient,
+    operation: string,
+    itemIndex: number,
+    options?: any
+  ): Promise<any> {
+    if (operation === 'get') {
+      return await client.accounts.getSelf();
+    }
+
+    if (operation === 'getById') {
+      const targetAccountId = this.getNodeParameter(
+        'targetAccountId',
+        itemIndex
+      ) as number;
+      return await client.accounts.get(targetAccountId, options);
+    }
+
+    if (operation === 'list') {
+      const filters = this.getNodeParameter(
+        'accountFilters',
+        itemIndex,
+        {}
+      ) as any;
+      return await client.accounts.list(filters, options);
+    }
+
+    if (operation === 'create') {
+      const name = this.getNodeParameter('accountName', itemIndex) as string;
+      const email = this.getNodeParameter('accountEmail', itemIndex) as string;
+      const additionalFields = this.getNodeParameter(
+        'accountAdditionalFields',
+        itemIndex,
+        {}
+      ) as any;
+
+      // Parse settings if provided as JSON string
+      if (additionalFields.settings) {
+        try {
+          additionalFields.settings =
+            typeof additionalFields.settings === 'string'
+              ? JSON.parse(additionalFields.settings)
+              : additionalFields.settings;
+        } catch (error: any) {
+          throw new NodeOperationError(
+            this.getNode(),
+            `Invalid settings JSON: ${error.message}`,
+            { itemIndex }
+          );
+        }
+      }
+
+      const accountData = {
+        name,
+        primary_email: email,
+        ...additionalFields,
+      };
+
+      return await client.accounts.create(accountData, options);
+    }
+
+    if (operation === 'update') {
+      const targetAccountId = this.getNodeParameter(
+        'targetAccountId',
+        itemIndex
+      ) as number;
+      const additionalFields = this.getNodeParameter(
+        'accountAdditionalFields',
+        itemIndex,
+        {}
+      ) as any;
+
+      // Parse settings if provided as JSON string
+      if (additionalFields.settings) {
+        try {
+          additionalFields.settings =
+            typeof additionalFields.settings === 'string'
+              ? JSON.parse(additionalFields.settings)
+              : additionalFields.settings;
+        } catch (error: any) {
+          throw new NodeOperationError(
+            this.getNode(),
+            `Invalid settings JSON: ${error.message}`,
+            { itemIndex }
+          );
+        }
+      }
+
+      return await client.accounts.update(
+        targetAccountId,
+        additionalFields,
+        options
+      );
+    }
+
+    if (operation === 'delete') {
+      const targetAccountId = this.getNodeParameter(
+        'targetAccountId',
+        itemIndex
+      ) as number;
+      await client.accounts.delete(targetAccountId, options);
+      return { success: true, accountId: targetAccountId };
+    }
+
+    if (operation === 'getChildren') {
+      const targetAccountId = this.getNodeParameter(
+        'targetAccountId',
+        itemIndex
+      ) as number;
+      const childrenOptions = this.getNodeParameter(
+        'getChildrenOptions',
+        itemIndex,
+        {}
+      ) as any;
+      return await client.accounts.getChildren(
+        targetAccountId,
+        childrenOptions,
+        options
+      );
+    }
+
+    throw new NodeOperationError(
+      this.getNode(),
+      `The operation "${operation}" is not yet implemented for account resource`,
+      { itemIndex }
+    );
+  }
+
+  /**
+   * Execute contact operations
+   */
+  private async executeContactOperation(
+    this: IExecuteFunctions,
+    client: CakemailClient,
+    operation: string,
+    itemIndex: number,
+    options?: any
+  ): Promise<any> {
+    if (operation === 'get') {
+      const contactId = this.getNodeParameter('contactId', itemIndex) as number;
+      return await client.contacts.get(contactId, options);
+    }
+
+    if (operation === 'getByEmail') {
+      const email = this.getNodeParameter('email', itemIndex) as string;
+      return await client.contacts.getByEmail(email, options);
+    }
+
+    if (operation === 'list') {
+      const filters = this.getNodeParameter('filters', itemIndex, {}) as any;
+
+      // Convert comma-separated tags to array
+      if (filters.tags && typeof filters.tags === 'string') {
+        filters.tags = filters.tags.split(',').map((t: string) => t.trim());
+      }
+
+      return await client.contacts.list(filters, options);
+    }
+
+    if (operation === 'create') {
+      const email = this.getNodeParameter('email', itemIndex) as string;
+      const additionalFields = this.getNodeParameter(
+        'additionalFields',
+        itemIndex,
+        {}
+      ) as any;
+
+      // Build create request
+      const createData: any = {
+        email,
+        ...additionalFields,
+      };
+
+      // Convert comma-separated tags to array
+      if (createData.tags && typeof createData.tags === 'string') {
+        createData.tags = createData.tags.split(',').map((t: string) => t.trim());
+      }
+
+      // Parse custom attributes JSON
+      if (createData.custom_attributes && typeof createData.custom_attributes === 'string') {
+        try {
+          createData.custom_attributes = JSON.parse(createData.custom_attributes);
+        } catch (error) {
+          throw new NodeOperationError(
+            this.getNode(),
+            'Invalid JSON in custom_attributes field',
+            { itemIndex }
+          );
+        }
+      }
+
+      return await client.contacts.create(createData, options);
+    }
+
+    if (operation === 'update') {
+      const contactId = this.getNodeParameter('contactId', itemIndex) as number;
+      const additionalFields = this.getNodeParameter(
+        'additionalFields',
+        itemIndex,
+        {}
+      ) as any;
+
+      // Convert comma-separated tags to array
+      if (additionalFields.tags && typeof additionalFields.tags === 'string') {
+        additionalFields.tags = additionalFields.tags
+          .split(',')
+          .map((t: string) => t.trim());
+      }
+
+      // Parse custom attributes JSON
+      if (additionalFields.custom_attributes && typeof additionalFields.custom_attributes === 'string') {
+        try {
+          additionalFields.custom_attributes = JSON.parse(
+            additionalFields.custom_attributes
+          );
+        } catch (error) {
+          throw new NodeOperationError(
+            this.getNode(),
+            'Invalid JSON in custom_attributes field',
+            { itemIndex }
+          );
+        }
+      }
+
+      return await client.contacts.update(contactId, additionalFields, options);
+    }
+
+    if (operation === 'delete') {
+      const contactId = this.getNodeParameter('contactId', itemIndex) as number;
+      await client.contacts.delete(contactId, options);
+      return { success: true, contactId };
+    }
+
+    if (operation === 'subscribe') {
+      const contactId = this.getNodeParameter('contactId', itemIndex) as number;
+      const listId = this.getNodeParameter('listId', itemIndex) as number;
+      return await client.contacts.subscribe(contactId, listId, options);
+    }
+
+    if (operation === 'unsubscribe') {
+      const contactId = this.getNodeParameter('contactId', itemIndex) as number;
+      const listId = this.getNodeParameter('listId', itemIndex) as number;
+      return await client.contacts.unsubscribe(contactId, listId, options);
+    }
+
+    if (operation === 'bulkImport') {
+      const contactsParam = this.getNodeParameter('contacts', itemIndex) as string;
+
+      let contacts: any[];
+      try {
+        contacts = typeof contactsParam === 'string'
+          ? JSON.parse(contactsParam)
+          : contactsParam;
+
+        if (!Array.isArray(contacts)) {
+          throw new Error('Contacts must be an array');
+        }
+      } catch (error: any) {
+        throw new NodeOperationError(
+          this.getNode(),
+          `Invalid contacts JSON: ${error.message}`,
+          { itemIndex }
+        );
+      }
+
+      // Validate that all contacts have email
+      const invalidContacts = contacts.filter((c, i) => !c.email);
+      if (invalidContacts.length > 0) {
+        throw new NodeOperationError(
+          this.getNode(),
+          `All contacts must have an email field. Found ${invalidContacts.length} contacts without email.`,
+          { itemIndex }
+        );
+      }
+
+      // Import contacts one by one and collect results
+      const results = {
+        total: contacts.length,
+        successful: 0,
+        failed: 0,
+        errors: [] as Array<{ index: number; email: string; error: string }>,
+      };
+
+      for (let i = 0; i < contacts.length; i++) {
+        try {
+          await client.contacts.create(contacts[i], options);
+          results.successful++;
+        } catch (error: any) {
+          results.failed++;
+          results.errors.push({
+            index: i,
+            email: contacts[i].email,
+            error: error.message || 'Unknown error',
+          });
+        }
+      }
+
+      return results;
+    }
+
+    if (operation === 'search') {
+      const searchQueryParam = this.getNodeParameter('searchQuery', itemIndex) as string;
+      const searchOptions = this.getNodeParameter('searchOptions', itemIndex, {}) as any;
+
+      let searchQuery: any;
+      try {
+        searchQuery = typeof searchQueryParam === 'string'
+          ? JSON.parse(searchQueryParam)
+          : searchQueryParam;
+      } catch (error: any) {
+        throw new NodeOperationError(
+          this.getNode(),
+          `Invalid search query JSON: ${error.message}`,
+          { itemIndex }
+        );
+      }
+
+      // Build search parameters
+      const searchParams: any = {
+        ...searchOptions,
+        filter: searchQuery,
+      };
+
+      // Handle sort order
+      if (searchOptions.sort && searchOptions.sort_order) {
+        searchParams.sort = `${searchOptions.sort}:${searchOptions.sort_order}`;
+        delete searchParams.sort_order;
+      }
+
+      return await client.contacts.list(searchParams, options);
+    }
+
+    if (operation === 'addTags') {
+      const contactId = this.getNodeParameter('contactId', itemIndex) as number;
+      const tagsString = this.getNodeParameter('tagsToManage', itemIndex) as string;
+      const tags = tagsString.split(',').map((t: string) => t.trim()).filter((t: string) => t);
+
+      if (tags.length === 0) {
+        throw new NodeOperationError(
+          this.getNode(),
+          'At least one tag must be provided',
+          { itemIndex }
+        );
+      }
+
+      return await client.contacts.addTags(contactId, tags, options);
+    }
+
+    if (operation === 'removeTags') {
+      const contactId = this.getNodeParameter('contactId', itemIndex) as number;
+      const tagsString = this.getNodeParameter('tagsToManage', itemIndex) as string;
+      const tags = tagsString.split(',').map((t: string) => t.trim()).filter((t: string) => t);
+
+      if (tags.length === 0) {
+        throw new NodeOperationError(
+          this.getNode(),
+          'At least one tag must be provided',
+          { itemIndex }
+        );
+      }
+
+      return await client.contacts.removeTags(contactId, tags, options);
+    }
+
+    throw new NodeOperationError(
+      this.getNode(),
+      `The operation "${operation}" is not yet implemented for contact resource`,
+      { itemIndex }
+    );
+  }
+
+  /**
+   * Execute list operations
+   */
+  private async executeListOperation(
+    this: IExecuteFunctions,
+    client: CakemailClient,
+    operation: string,
+    itemIndex: number,
+    options?: any
+  ): Promise<any> {
+    if (operation === 'get') {
+      const listId = this.getNodeParameter('listIdParam', itemIndex) as number;
+      return await client.lists.get(listId, options);
+    }
+
+    if (operation === 'list') {
+      const limit = this.getNodeParameter('listLimit', itemIndex, 20) as number;
+      return await client.lists.list({ per_page: limit }, options);
+    }
+
+    if (operation === 'create') {
+      const name = this.getNodeParameter('listName', itemIndex) as string;
+      const additionalFields = this.getNodeParameter(
+        'listAdditionalFields',
+        itemIndex,
+        {}
+      ) as any;
+
+      const createData = {
+        name,
+        ...additionalFields,
+      };
+
+      return await client.lists.create(createData, options);
+    }
+
+    if (operation === 'update') {
+      const listId = this.getNodeParameter('listIdParam', itemIndex) as number;
+      const additionalFields = this.getNodeParameter(
+        'listAdditionalFields',
+        itemIndex,
+        {}
+      ) as any;
+
+      return await client.lists.update(listId, additionalFields, options);
+    }
+
+    if (operation === 'delete') {
+      const listId = this.getNodeParameter('listIdParam', itemIndex) as number;
+      await client.lists.delete(listId, options);
+      return { success: true, listId };
+    }
+
+    if (operation === 'getStatistics') {
+      const listId = this.getNodeParameter('listIdParam', itemIndex) as number;
+      return await client.lists.getStatistics(listId, options);
+    }
+
+    throw new NodeOperationError(
+      this.getNode(),
+      `The operation "${operation}" is not yet implemented for list resource`,
+      { itemIndex }
+    );
+  }
+
+  /**
+   * Execute campaign operations
+   */
+  private async executeCampaignOperation(
+    this: IExecuteFunctions,
+    client: CakemailClient,
+    operation: string,
+    itemIndex: number,
+    options?: any
+  ): Promise<any> {
+    throw new NodeOperationError(
+      this.getNode(),
+      `Campaign operations are not yet implemented`,
+      { itemIndex }
+    );
+  }
+}