n8n-nodes-idb2b 1.1.4 → 1.2.0

package/dist/nodes/IDB2B/IDB2B.refactored.node.js

@@ -6,6 +6,8 @@ const authentication_1 = require("./methods/authentication");
 const requests_1 = require("./methods/requests");
 const validation_1 = require("./methods/validation");
 const utils_1 = require("./methods/utils");
+const LeadService_1 = require("./services/LeadService");
+const LeadOperations_1 = require("./handlers/LeadOperations");
 const sharedProperties_1 = require("./descriptions/sharedProperties");
 const contactProperties_1 = require("./descriptions/contactProperties");
 const leadProperties_1 = require("./descriptions/leadProperties");
@@ -123,36 +125,19 @@ class IDB2B {
                 }
                 // Handle Lead operations
                 else if (resource === 'lead') {
-                    if (operation === 'getAll') {
-                        method = 'GET';
-                        endpoint = '/leads';
-                        const limit = this.getNodeParameter('limit', i, 50);
-                        const page = this.getNodeParameter('page', i, 1);
-                        qs.limit = limit;
-                        qs.page = page;
-                        const queryParameters = this.getNodeParameter('queryParameters', i, {});
-                        const additionalQs = (0, utils_1.buildQueryString)(queryParameters);
-                        qs = Object.assign(Object.assign({}, qs), additionalQs);
-                    }
-                    else if (operation === 'create') {
-                        method = 'POST';
-                        endpoint = '/leads';
-                        const name = this.getNodeParameter('name', i);
-                        const additionalFields = this.getNodeParameter('additionalFields', i, {});
-                        (0, validation_1.validateLeadData)(name);
-                        body = { name: name.trim() };
-                        // Add additional fields if provided
-                        const fieldMappings = [
-                            'owner_id', 'website', 'description', 'status_id', 'source_id',
-                            'size_id', 'industry_id', 'main_contact_id', 'contact_name',
-                            'contact_email', 'contact_phone_number'
-                        ];
-                        fieldMappings.forEach(field => {
-                            if (additionalFields[field]) {
-                                body[field] = additionalFields[field];
-                            }
-                        });
-                    }
+                    const leadService = new LeadService_1.LeadService({
+                        executeFunctions: this,
+                        credentials,
+                        accessToken,
+                        itemIndex: i,
+                    });
+                    const leadOperations = new LeadOperations_1.LeadOperations(leadService, this, i);
+                    const response = await leadOperations.execute(operation);
+                    returnData.push({
+                        json: response,
+                        pairedItem: { item: i },
+                    });
+                    continue;
                 }
                 // Handle Custom operations
                 else if (resource === 'custom') {
@@ -173,36 +158,39 @@ class IDB2B {
                     const queryParameters = this.getNodeParameter('queryParameters', i, {});
                     qs = (0, utils_1.buildQueryString)(queryParameters);
                 }
-                const response = await (0, requests_1.makeRequestWithRetry)(this, {
-                    method,
-                    url: `${credentials.baseUrl}${endpoint}`,
-                    headers: {
-                        Authorization: `Bearer ${accessToken}`,
-                    },
-                    body,
-                    qs,
-                    json: true,
-                });
-                let processedResponse = response;
-                // Apply field filtering for getAll operations
-                if (operation === 'getAll') {
-                    const fieldsToReturn = this.getNodeParameter('fields', i, []);
-                    if (fieldsToReturn.length > 0 && Array.isArray(response.data)) {
-                        processedResponse = Object.assign(Object.assign({}, response), { data: response.data.map((item) => {
-                                const filteredItem = {};
-                                fieldsToReturn.forEach(field => {
-                                    if (field in item) {
-                                        filteredItem[field] = item[field];
-                                    }
-                                });
-                                return filteredItem;
-                            }) });
+                // Only execute request for contact and custom operations
+                if (resource === 'contact' || resource === 'custom') {
+                    const response = await (0, requests_1.makeRequestWithRetry)(this, {
+                        method,
+                        url: `${credentials.baseUrl}${endpoint}`,
+                        headers: {
+                            Authorization: `Bearer ${accessToken}`,
+                        },
+                        body,
+                        qs,
+                        json: true,
+                    });
+                    let processedResponse = response;
+                    // Apply field filtering for contact getAll operations
+                    if (resource === 'contact' && operation === 'getAll') {
+                        const fieldsToReturn = this.getNodeParameter('fields', i, []);
+                        if (fieldsToReturn.length > 0 && Array.isArray(response.data)) {
+                            processedResponse = Object.assign(Object.assign({}, response), { data: response.data.map((item) => {
+                                    const filteredItem = {};
+                                    fieldsToReturn.forEach(field => {
+                                        if (field in item) {
+                                            filteredItem[field] = item[field];
+                                        }
+                                    });
+                                    return filteredItem;
+                                }) });
+                        }
                     }
+                    returnData.push({
+                        json: processedResponse,
+                        pairedItem: { item: i },
+                    });
                 }
-                returnData.push({
-                    json: processedResponse,
-                    pairedItem: { item: i },
-                });
             }
             catch (error) {
                 if (this.continueOnFail()) {

package/dist/nodes/IDB2B/descriptions/leadProperties.js

@@ -18,16 +18,125 @@ exports.leadOperations = {
             action: 'Get all leads',
             description: 'Retrieve all leads',
         },
+        {
+            name: 'Get',
+            value: 'get',
+            action: 'Get a lead',
+            description: 'Get a single lead by ID',
+        },
         {
             name: 'Create',
             value: 'create',
             action: 'Create a lead',
             description: 'Create a new lead',
         },
+        {
+            name: 'Update',
+            value: 'update',
+            action: 'Update a lead',
+            description: 'Update an existing lead',
+        },
+        {
+            name: 'Delete',
+            value: 'delete',
+            action: 'Delete a lead',
+            description: 'Delete a lead by ID',
+        },
+        {
+            name: 'Create Multiple',
+            value: 'createMultiple',
+            action: 'Create multiple leads',
+            description: 'Create multiple leads in bulk',
+        },
+        {
+            name: 'Delete Multiple',
+            value: 'deleteMultiple',
+            action: 'Delete multiple leads',
+            description: 'Delete multiple leads by IDs',
+        },
+        {
+            name: 'Get Call Logs',
+            value: 'getCallLogs',
+            action: 'Get lead call logs',
+            description: 'Get call logs for a specific lead',
+        },
+        {
+            name: 'Assign New Contact',
+            value: 'assignNewContact',
+            action: 'Assign new contact to lead',
+            description: 'Create and assign a new contact to a lead',
+        },
+        {
+            name: 'Assign Contacts',
+            value: 'assignContacts',
+            action: 'Assign contacts to lead',
+            description: 'Assign existing contacts to a lead',
+        },
+        {
+            name: 'Remove Contact',
+            value: 'removeContact',
+            action: 'Remove contact from lead',
+            description: 'Remove a contact from a lead',
+        },
+        {
+            name: 'Import',
+            value: 'import',
+            action: 'Import leads',
+            description: 'Import leads from CSV/Excel file',
+        },
+        {
+            name: 'Get Import Template',
+            value: 'getImportTemplate',
+            action: 'Get import template',
+            description: 'Download import template for leads',
+        },
+        {
+            name: 'Geocode',
+            value: 'geocode',
+            action: 'Geocode lead address',
+            description: 'Manually geocode a lead address',
+        },
+        {
+            name: 'Search Nearby',
+            value: 'searchNearby',
+            action: 'Find leads near location',
+            description: 'Find leads near a specific location',
+        },
     ],
     default: 'getAll',
 };
 exports.leadFields = [
+    // Lead ID field for operations that require it
+    {
+        displayName: 'Lead ID',
+        name: 'leadId',
+        type: 'string',
+        default: '',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['get', 'update', 'delete', 'getCallLogs', 'assignNewContact', 'assignContacts', 'removeContact', 'geocode'],
+            },
+        },
+        description: 'ID of the lead',
+    },
+    // Contact ID field for remove contact operation
+    {
+        displayName: 'Contact ID',
+        name: 'contactId',
+        type: 'string',
+        default: '',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['removeContact'],
+            },
+        },
+        description: 'ID of the contact to remove from the lead',
+    },
+    // Name field for create and update operations
     {
         displayName: 'Name',
         name: 'name',
@@ -42,6 +151,93 @@ exports.leadFields = [
         },
         description: 'Lead name',
     },
+    {
+        displayName: 'Name',
+        name: 'name',
+        type: 'string',
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['update'],
+            },
+        },
+        description: 'Lead name (leave empty to keep current value)',
+    },
+    // Lead IDs for bulk operations
+    {
+        displayName: 'Lead IDs',
+        name: 'leadIds',
+        type: 'string',
+        default: '',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['deleteMultiple'],
+            },
+        },
+        description: 'Comma-separated list of lead IDs to delete',
+    },
+    // Contact IDs for assign contacts operation
+    {
+        displayName: 'Contact IDs',
+        name: 'contactIds',
+        type: 'string',
+        default: '',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['assignContacts'],
+            },
+        },
+        description: 'Comma-separated list of contact IDs to assign to the lead',
+    },
+    // Leads data for bulk create
+    {
+        displayName: 'Leads Data',
+        name: 'leadsData',
+        type: 'json',
+        default: '[]',
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['createMultiple'],
+            },
+        },
+        description: 'Array of lead objects to create',
+    },
+    // Location fields for search nearby
+    {
+        displayName: 'Latitude',
+        name: 'latitude',
+        type: 'number',
+        default: 0,
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['searchNearby'],
+            },
+        },
+        description: 'Latitude for nearby search',
+    },
+    {
+        displayName: 'Longitude',
+        name: 'longitude',
+        type: 'number',
+        default: 0,
+        required: true,
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['searchNearby'],
+            },
+        },
+        description: 'Longitude for nearby search',
+    },
     {
         displayName: 'Additional Fields',
         name: 'additionalFields',
@@ -51,7 +247,7 @@ exports.leadFields = [
         displayOptions: {
             show: {
                 resource: ['lead'],
-                operation: ['create'],
+                operation: ['create', 'update'],
             },
         },
         options: [
@@ -134,16 +330,159 @@ exports.leadFields = [
             },
         ],
     },
+    // Additional fields for specialized operations
+    {
+        displayName: 'New Contact Data',
+        name: 'newContactData',
+        type: 'collection',
+        placeholder: 'Add Contact Field',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['assignNewContact'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Name',
+                name: 'name',
+                type: 'string',
+                default: '',
+                required: true,
+                description: 'Contact name',
+            },
+            {
+                displayName: 'Email',
+                name: 'email',
+                type: 'string',
+                default: '',
+                required: true,
+                description: 'Contact email',
+            },
+            {
+                displayName: 'Phone Number',
+                name: 'phone_number',
+                type: 'string',
+                default: '',
+                description: 'Contact phone number',
+            },
+        ],
+    },
+    {
+        displayName: 'Geocode Data',
+        name: 'geocodeData',
+        type: 'collection',
+        placeholder: 'Add Geocode Field',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['geocode'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Address',
+                name: 'address',
+                type: 'string',
+                default: '',
+                description: 'Address to geocode',
+            },
+            {
+                displayName: 'Latitude',
+                name: 'latitude',
+                type: 'number',
+                default: 0,
+                description: 'Latitude coordinate',
+            },
+            {
+                displayName: 'Longitude',
+                name: 'longitude',
+                type: 'number',
+                default: 0,
+                description: 'Longitude coordinate',
+            },
+        ],
+    },
+    {
+        displayName: 'Import Data',
+        name: 'importData',
+        type: 'collection',
+        placeholder: 'Add Import Field',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['import'],
+            },
+        },
+        options: [
+            {
+                displayName: 'File Path/URL',
+                name: 'file',
+                type: 'string',
+                default: '',
+                description: 'Path or URL to the import file (CSV/Excel)',
+            },
+            {
+                displayName: 'Field Mapping (JSON)',
+                name: 'mapping',
+                type: 'json',
+                default: '{}',
+                description: 'JSON object mapping CSV columns to lead fields',
+            },
+        ],
+    },
+    {
+        displayName: 'Search Options',
+        name: 'searchOptions',
+        type: 'collection',
+        placeholder: 'Add Search Option',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['searchNearby'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Radius',
+                name: 'radius',
+                type: 'number',
+                default: 10,
+                description: 'Search radius',
+            },
+            {
+                displayName: 'Unit',
+                name: 'unit',
+                type: 'options',
+                default: 'km',
+                options: [
+                    {
+                        name: 'Kilometers',
+                        value: 'km',
+                    },
+                    {
+                        name: 'Miles',
+                        value: 'miles',
+                    },
+                ],
+                description: 'Distance unit',
+            },
+        ],
+    },
     {
         displayName: 'Limit',
         name: 'limit',
         type: 'number',
         default: 50,
-        description: 'Maximum number of leads to return',
+        description: 'Maximum number of records to return',
         displayOptions: {
             show: {
                 resource: ['lead'],
-                operation: ['getAll'],
+                operation: ['getAll', 'getCallLogs', 'searchNearby'],
             },
         },
     },
@@ -156,7 +495,7 @@ exports.leadFields = [
         displayOptions: {
             show: {
                 resource: ['lead'],
-                operation: ['getAll'],
+                operation: ['getAll', 'getCallLogs', 'searchNearby'],
             },
         },
     },

package/dist/nodes/IDB2B/handlers/LeadOperations.d.ts

@@ -0,0 +1,24 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+import { LeadService } from '../services/LeadService';
+export declare class LeadOperations {
+    private leadService;
+    private executeFunctions;
+    private itemIndex;
+    constructor(leadService: LeadService, executeFunctions: IExecuteFunctions, itemIndex: number);
+    execute(operation: string): Promise<any>;
+    private handleGetAll;
+    private handleGet;
+    private handleCreate;
+    private handleUpdate;
+    private handleDelete;
+    private handleCreateMultiple;
+    private handleDeleteMultiple;
+    private handleGetCallLogs;
+    private handleAssignNewContact;
+    private handleAssignContacts;
+    private handleRemoveContact;
+    private handleImport;
+    private handleGetImportTemplate;
+    private handleGeocode;
+    private handleSearchNearby;
+}

package/dist/nodes/IDB2B/handlers/LeadOperations.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeadOperations = void 0;
+const utils_1 = require("../methods/utils");
+class LeadOperations {
+    constructor(leadService, executeFunctions, itemIndex) {
+        this.leadService = leadService;
+        this.executeFunctions = executeFunctions;
+        this.itemIndex = itemIndex;
+    }
+    async execute(operation) {
+        switch (operation) {
+            case 'getAll':
+                return this.handleGetAll();
+            case 'get':
+                return this.handleGet();
+            case 'create':
+                return this.handleCreate();
+            case 'update':
+                return this.handleUpdate();
+            case 'delete':
+                return this.handleDelete();
+            case 'createMultiple':
+                return this.handleCreateMultiple();
+            case 'deleteMultiple':
+                return this.handleDeleteMultiple();
+            case 'getCallLogs':
+                return this.handleGetCallLogs();
+            case 'assignNewContact':
+                return this.handleAssignNewContact();
+            case 'assignContacts':
+                return this.handleAssignContacts();
+            case 'removeContact':
+                return this.handleRemoveContact();
+            case 'import':
+                return this.handleImport();
+            case 'getImportTemplate':
+                return this.handleGetImportTemplate();
+            case 'geocode':
+                return this.handleGeocode();
+            case 'searchNearby':
+                return this.handleSearchNearby();
+            default:
+                throw new Error(`Unknown operation: ${operation}`);
+        }
+    }
+    async handleGetAll() {
+        const limit = this.executeFunctions.getNodeParameter('limit', this.itemIndex, 50);
+        const page = this.executeFunctions.getNodeParameter('page', this.itemIndex, 1);
+        const fields = this.executeFunctions.getNodeParameter('fields', this.itemIndex, []);
+        const queryParameters = this.executeFunctions.getNodeParameter('queryParameters', this.itemIndex, {});
+        // Build query parameters
+        const queryParams = {};
+        if (queryParameters === null || queryParameters === void 0 ? void 0 : queryParameters.parameter) {
+            queryParameters.parameter.forEach((param) => {
+                if (param.name && param.value !== undefined) {
+                    queryParams[param.name] = param.value;
+                }
+            });
+        }
+        return await this.leadService.getAll({
+            limit,
+            page,
+            fields,
+            queryParams,
+        });
+    }
+    async handleGet() {
+        const leadId = this.executeFunctions.getNodeParameter('leadId', this.itemIndex);
+        return await this.leadService.getById(leadId);
+    }
+    async handleCreate() {
+        const name = this.executeFunctions.getNodeParameter('name', this.itemIndex);
+        const additionalFields = this.executeFunctions.getNodeParameter('additionalFields', this.itemIndex, {});
+        const leadData = {
+            name: name.trim(),
+        };
+        // Add additional fields
+        const optionalFields = [
+            'owner_id', 'website', 'description', 'status_id', 'source_id',
+            'size_id', 'industry_id', 'main_contact_id', 'contact_name',
+            'contact_email', 'contact_phone_number'
+        ];
+        optionalFields.forEach(field => {
+            if (additionalFields[field] !== undefined) {
+                leadData[field] = additionalFields[field];
+            }
+        });
+        return await this.leadService.create(leadData);
+    }
+    async handleUpdate() {
+        const leadId = this.executeFunctions.getNodeParameter('leadId', this.itemIndex);
+        const name = this.executeFunctions.getNodeParameter('name', this.itemIndex, '');
+        const additionalFields = this.executeFunctions.getNodeParameter('additionalFields', this.itemIndex, {});
+        const updateData = {};
+        // Add name if provided
+        if (name && name.trim()) {
+            updateData.name = name.trim();
+        }
+        // Add additional fields
+        const optionalFields = [
+            'owner_id', 'website', 'description', 'status_id', 'source_id',
+            'size_id', 'industry_id', 'main_contact_id', 'contact_name',
+            'contact_email', 'contact_phone_number'
+        ];
+        optionalFields.forEach(field => {
+            if (additionalFields[field] !== undefined) {
+                updateData[field] = additionalFields[field];
+            }
+        });
+        return await this.leadService.update(leadId, updateData);
+    }
+    async handleDelete() {
+        const leadId = this.executeFunctions.getNodeParameter('leadId', this.itemIndex);
+        return await this.leadService.delete(leadId);
+    }
+    async handleCreateMultiple() {
+        const leadsDataString = this.executeFunctions.getNodeParameter('leadsData', this.itemIndex);
+        const leadsData = (0, utils_1.safeJsonParse)(leadsDataString, 'Leads Data');
+        if (!Array.isArray(leadsData)) {
+            throw new Error('Leads data must be an array');
+        }
+        return await this.leadService.bulkCreate(leadsData);
+    }
+    async handleDeleteMultiple() {
+        const leadIdsString = this.executeFunctions.getNodeParameter('leadIds', this.itemIndex);
+        const leadIds = leadIdsString.split(',').map(id => id.trim()).filter(id => id);
+        if (leadIds.length === 0) {
+            throw new Error('At least one lead ID is required');
+        }
+        return await this.leadService.bulkDelete(leadIds);
+    }
+    async handleGetCallLogs() {
+        const leadId = this.executeFunctions.getNodeParameter('leadId', this.itemIndex);
+        const limit = this.executeFunctions.getNodeParameter('limit', this.itemIndex, 50);
+        const page = this.executeFunctions.getNodeParameter('page', this.itemIndex, 1);
+        return await this.leadService.getCallLogs(leadId, { limit, page });
+    }
+    async handleAssignNewContact() {
+        const leadId = this.executeFunctions.getNodeParameter('leadId', this.itemIndex);
+        const newContactData = this.executeFunctions.getNodeParameter('newContactData', this.itemIndex, {});
+        return await this.leadService.assignNewContact(leadId, newContactData);
+    }
+    async handleAssignContacts() {
+        const leadId = this.executeFunctions.getNodeParameter('leadId', this.itemIndex);
+        const contactIdsString = this.executeFunctions.getNodeParameter('contactIds', this.itemIndex);
+        const contactIds = contactIdsString.split(',').map(id => id.trim()).filter(id => id);
+        if (contactIds.length === 0) {
+            throw new Error('At least one contact ID is required');
+        }
+        return await this.leadService.assignContacts(leadId, contactIds);
+    }
+    async handleRemoveContact() {
+        const leadId = this.executeFunctions.getNodeParameter('leadId', this.itemIndex);
+        const contactId = this.executeFunctions.getNodeParameter('contactId', this.itemIndex);
+        return await this.leadService.removeContact(leadId, contactId);
+    }
+    async handleImport() {
+        const importData = this.executeFunctions.getNodeParameter('importData', this.itemIndex, {});
+        const data = {};
+        if (importData.file) {
+            data.file = importData.file;
+        }
+        if (importData.mapping) {
+            data.mapping = (0, utils_1.safeJsonParse)(importData.mapping, 'Field Mapping');
+        }
+        return await this.leadService.import(data);
+    }
+    async handleGetImportTemplate() {
+        return await this.leadService.getImportTemplate();
+    }
+    async handleGeocode() {
+        const leadId = this.executeFunctions.getNodeParameter('leadId', this.itemIndex);
+        const geocodeData = this.executeFunctions.getNodeParameter('geocodeData', this.itemIndex, {});
+        return await this.leadService.geocode(leadId, geocodeData);
+    }
+    async handleSearchNearby() {
+        const latitude = this.executeFunctions.getNodeParameter('latitude', this.itemIndex);
+        const longitude = this.executeFunctions.getNodeParameter('longitude', this.itemIndex);
+        const limit = this.executeFunctions.getNodeParameter('limit', this.itemIndex, 50);
+        const page = this.executeFunctions.getNodeParameter('page', this.itemIndex, 1);
+        const searchOptions = this.executeFunctions.getNodeParameter('searchOptions', this.itemIndex, {});
+        const params = {
+            latitude,
+            longitude,
+            limit,
+            page,
+        };
+        if (searchOptions.radius !== undefined) {
+            params.radius = searchOptions.radius;
+        }
+        if (searchOptions.unit) {
+            params.unit = searchOptions.unit;
+        }
+        return await this.leadService.searchNearby(params);
+    }
+}
+exports.LeadOperations = LeadOperations;

package/dist/nodes/IDB2B/interfaces/IDB2BCallLog.d.ts

@@ -0,0 +1,13 @@
+export interface IDB2BCallLog {
+    id?: string;
+    lead_id?: string;
+    contact_id?: string;
+    user_id?: string;
+    type?: 'incoming' | 'outgoing' | 'missed';
+    duration?: number;
+    notes?: string;
+    recording_url?: string;
+    call_date?: string;
+    created_at?: string;
+    updated_at?: string;
+}

package/dist/nodes/IDB2B/interfaces/IDB2BCallLog.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/IDB2B/interfaces/IDB2BImport.d.ts

@@ -0,0 +1,23 @@
+export interface IDB2BImportResponse {
+    success: boolean;
+    message: string;
+    imported_count?: number;
+    failed_count?: number;
+    errors?: Array<{
+        row: number;
+        field: string;
+        error: string;
+    }>;
+    job_id?: string;
+    status?: 'pending' | 'processing' | 'completed' | 'failed';
+}
+export interface IDB2BImportTemplate {
+    fields: Array<{
+        name: string;
+        type: string;
+        required: boolean;
+        description?: string;
+    }>;
+    sample_data?: Record<string, any>[];
+    format?: 'csv' | 'excel';
+}

package/dist/nodes/IDB2B/interfaces/IDB2BImport.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/IDB2B/services/LeadService.d.ts

@@ -0,0 +1,77 @@
+import { IExecuteFunctions } from 'n8n-workflow';
+import { IDB2BLead } from '../interfaces/IDB2BLead';
+export interface LeadServiceOptions {
+    executeFunctions: IExecuteFunctions;
+    credentials: any;
+    accessToken: string;
+    itemIndex: number;
+}
+export interface PaginationParams {
+    limit?: number;
+    page?: number;
+}
+export interface QueryParams {
+    [key: string]: string | number | boolean;
+}
+export interface LeadGetOptions extends PaginationParams {
+    fields?: string[];
+    queryParams?: QueryParams;
+}
+export interface LeadCreateData {
+    name: string;
+    owner_id?: string;
+    website?: string;
+    description?: string;
+    status_id?: string;
+    source_id?: string;
+    size_id?: string;
+    industry_id?: string;
+    main_contact_id?: string;
+    contact_name?: string;
+    contact_email?: string;
+    contact_phone_number?: string;
+}
+export interface LeadUpdateData extends Partial<LeadCreateData> {
+}
+export interface LeadImportData {
+    file?: string;
+    data?: IDB2BLead[];
+    mapping?: Record<string, string>;
+}
+export interface GeocodeData {
+    address?: string;
+    latitude?: number;
+    longitude?: number;
+}
+export interface NearbySearchParams extends PaginationParams {
+    latitude: number;
+    longitude: number;
+    radius?: number;
+    unit?: 'km' | 'miles';
+}
+export declare class LeadService {
+    private executeFunctions;
+    private credentials;
+    private accessToken;
+    private itemIndex;
+    private baseUrl;
+    constructor(options: LeadServiceOptions);
+    private makeRequest;
+    private validateLeadId;
+    private buildQueryString;
+    getAll(options?: LeadGetOptions): Promise<any>;
+    getById(leadId: string): Promise<any>;
+    create(leadData: LeadCreateData): Promise<any>;
+    update(leadId: string, updateData: LeadUpdateData): Promise<any>;
+    delete(leadId: string): Promise<any>;
+    bulkCreate(leads: LeadCreateData[]): Promise<any>;
+    bulkDelete(leadIds: string[]): Promise<any>;
+    getCallLogs(leadId: string, options?: PaginationParams): Promise<any>;
+    assignNewContact(leadId: string, contactData: any): Promise<any>;
+    assignContacts(leadId: string, contactIds: string[]): Promise<any>;
+    removeContact(leadId: string, contactId: string): Promise<any>;
+    import(importData: LeadImportData): Promise<any>;
+    getImportTemplate(): Promise<any>;
+    geocode(leadId: string, geocodeData: GeocodeData): Promise<any>;
+    searchNearby(params: NearbySearchParams): Promise<any>;
+}

package/dist/nodes/IDB2B/services/LeadService.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeadService = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const requests_1 = require("../methods/requests");
+const validation_1 = require("../methods/validation");
+class LeadService {
+    constructor(options) {
+        this.executeFunctions = options.executeFunctions;
+        this.credentials = options.credentials;
+        this.accessToken = options.accessToken;
+        this.itemIndex = options.itemIndex;
+        this.baseUrl = this.credentials.baseUrl;
+    }
+    async makeRequest(options) {
+        const { method, endpoint, body, qs } = options;
+        return await (0, requests_1.makeRequestWithRetry)(this.executeFunctions, {
+            method,
+            url: `${this.baseUrl}${endpoint}`,
+            headers: {
+                Authorization: `Bearer ${this.accessToken}`,
+            },
+            body,
+            qs,
+            json: true,
+        });
+    }
+    validateLeadId(leadId) {
+        if (!leadId || typeof leadId !== 'string' || leadId.trim().length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.executeFunctions.getNode(), 'Lead ID is required and must be a non-empty string', { itemIndex: this.itemIndex });
+        }
+    }
+    buildQueryString(queryParameters) {
+        const qs = {};
+        if (queryParameters === null || queryParameters === void 0 ? void 0 : queryParameters.parameter) {
+            queryParameters.parameter.forEach((param) => {
+                if (param.name && param.value !== undefined) {
+                    qs[param.name] = param.value;
+                }
+            });
+        }
+        return qs;
+    }
+    async getAll(options = {}) {
+        const { limit = 50, page = 1, fields = [], queryParams = {} } = options;
+        const qs = { limit, page };
+        // Add additional query parameters
+        Object.assign(qs, queryParams);
+        const response = await this.makeRequest({
+            method: 'GET',
+            endpoint: '/leads',
+            qs,
+        });
+        // Apply field filtering if specified
+        if (fields.length > 0 && Array.isArray(response.data)) {
+            return Object.assign(Object.assign({}, response), { data: response.data.map((lead) => {
+                    const filteredLead = {};
+                    fields.forEach(field => {
+                        if (field in lead) {
+                            filteredLead[field] = lead[field];
+                        }
+                    });
+                    return filteredLead;
+                }) });
+        }
+        return response;
+    }
+    async getById(leadId) {
+        this.validateLeadId(leadId);
+        return await this.makeRequest({
+            method: 'GET',
+            endpoint: `/leads/${leadId.trim()}`,
+        });
+    }
+    async create(leadData) {
+        (0, validation_1.validateLeadData)(leadData.name);
+        const body = {
+            name: leadData.name.trim(),
+        };
+        // Add optional fields
+        const optionalFields = [
+            'owner_id', 'website', 'description', 'status_id', 'source_id',
+            'size_id', 'industry_id', 'main_contact_id', 'contact_name',
+            'contact_email', 'contact_phone_number'
+        ];
+        optionalFields.forEach(field => {
+            if (leadData[field]) {
+                body[field] = leadData[field];
+            }
+        });
+        return await this.makeRequest({
+            method: 'POST',
+            endpoint: '/leads',
+            body,
+        });
+    }
+    async update(leadId, updateData) {
+        this.validateLeadId(leadId);
+        if (updateData.name) {
+            (0, validation_1.validateLeadData)(updateData.name);
+        }
+        const body = {};
+        // Add fields to update
+        Object.keys(updateData).forEach(key => {
+            const value = updateData[key];
+            if (value !== undefined) {
+                if (key === 'name' && typeof value === 'string') {
+                    body[key] = value.trim();
+                }
+                else {
+                    body[key] = value;
+                }
+            }
+        });
+        return await this.makeRequest({
+            method: 'PATCH',
+            endpoint: `/leads/${leadId.trim()}`,
+            body,
+        });
+    }
+    async delete(leadId) {
+        this.validateLeadId(leadId);
+        return await this.makeRequest({
+            method: 'DELETE',
+            endpoint: `/leads/${leadId.trim()}`,
+        });
+    }
+    async bulkCreate(leads) {
+        if (!Array.isArray(leads) || leads.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.executeFunctions.getNode(), 'Leads array is required and must not be empty', { itemIndex: this.itemIndex });
+        }
+        // Validate each lead
+        leads.forEach((lead, index) => {
+            try {
+                (0, validation_1.validateLeadData)(lead.name);
+            }
+            catch (error) {
+                throw new n8n_workflow_1.NodeOperationError(this.executeFunctions.getNode(), `Lead at index ${index}: ${error instanceof Error ? error.message : 'Validation failed'}`, { itemIndex: this.itemIndex });
+            }
+        });
+        return await this.makeRequest({
+            method: 'POST',
+            endpoint: '/leads/bulk',
+            body: { leads },
+        });
+    }
+    async bulkDelete(leadIds) {
+        if (!Array.isArray(leadIds) || leadIds.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.executeFunctions.getNode(), 'Lead IDs array is required and must not be empty', { itemIndex: this.itemIndex });
+        }
+        // Validate each lead ID
+        leadIds.forEach((id, index) => {
+            if (!id || typeof id !== 'string' || id.trim().length === 0) {
+                throw new n8n_workflow_1.NodeOperationError(this.executeFunctions.getNode(), `Invalid lead ID at index ${index}`, { itemIndex: this.itemIndex });
+            }
+        });
+        return await this.makeRequest({
+            method: 'DELETE',
+            endpoint: '/leads/bulk',
+            body: { lead_ids: leadIds.map(id => id.trim()) },
+        });
+    }
+    async getCallLogs(leadId, options = {}) {
+        this.validateLeadId(leadId);
+        const { limit = 50, page = 1 } = options;
+        return await this.makeRequest({
+            method: 'GET',
+            endpoint: `/leads/${leadId.trim()}/call-logs`,
+            qs: { limit, page },
+        });
+    }
+    async assignNewContact(leadId, contactData) {
+        this.validateLeadId(leadId);
+        return await this.makeRequest({
+            method: 'POST',
+            endpoint: `/leads/${leadId.trim()}/assign-new-contact`,
+            body: contactData,
+        });
+    }
+    async assignContacts(leadId, contactIds) {
+        this.validateLeadId(leadId);
+        if (!Array.isArray(contactIds) || contactIds.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.executeFunctions.getNode(), 'Contact IDs array is required and must not be empty', { itemIndex: this.itemIndex });
+        }
+        return await this.makeRequest({
+            method: 'POST',
+            endpoint: `/leads/${leadId.trim()}/assign-contacts`,
+            body: { contact_ids: contactIds },
+        });
+    }
+    async removeContact(leadId, contactId) {
+        this.validateLeadId(leadId);
+        if (!contactId || typeof contactId !== 'string' || contactId.trim().length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(this.executeFunctions.getNode(), 'Contact ID is required and must be a non-empty string', { itemIndex: this.itemIndex });
+        }
+        return await this.makeRequest({
+            method: 'DELETE',
+            endpoint: `/leads/${leadId.trim()}/contacts/${contactId.trim()}`,
+        });
+    }
+    async import(importData) {
+        return await this.makeRequest({
+            method: 'POST',
+            endpoint: '/leads/import',
+            body: importData,
+        });
+    }
+    async getImportTemplate() {
+        return await this.makeRequest({
+            method: 'GET',
+            endpoint: '/leads/import/template',
+        });
+    }
+    async geocode(leadId, geocodeData) {
+        this.validateLeadId(leadId);
+        return await this.makeRequest({
+            method: 'POST',
+            endpoint: `/leads/${leadId.trim()}/geocode`,
+            body: geocodeData,
+        });
+    }
+    async searchNearby(params) {
+        const { latitude, longitude, radius = 10, unit = 'km', limit = 50, page = 1 } = params;
+        if (typeof latitude !== 'number' || typeof longitude !== 'number') {
+            throw new n8n_workflow_1.NodeOperationError(this.executeFunctions.getNode(), 'Latitude and longitude are required and must be numbers', { itemIndex: this.itemIndex });
+        }
+        return await this.makeRequest({
+            method: 'GET',
+            endpoint: '/leads/nearby/search',
+            qs: {
+                latitude,
+                longitude,
+                radius,
+                unit,
+                limit,
+                page,
+            },
+        });
+    }
+}
+exports.LeadService = LeadService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-idb2b",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "n8n community node for IDB2B CRM",
   "main": "index.js",
   "scripts": {
@@ -20,7 +20,7 @@
       "dist/credentials/IDB2BApi.credentials.js"
     ],
     "nodes": [
-      "dist/nodes/IDB2B/IDB2B.node.js"
+      "dist/nodes/IDB2B/IDB2B.refactored.node.js"
     ]
   },
   "keywords": [