n8n-nodes-instantly-dev
Version:
n8n community node for Instantly API v2 - DEV TESTING VERSION
280 lines • 12.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.InstantlyApi = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const generic_functions_1 = require("../generic.functions");
const OperationRouter_1 = require("./operations/OperationRouter");
const LeadParameters_1 = require("./parameters/LeadParameters");
const CampaignParameters_1 = require("./parameters/CampaignParameters");
const AccountParameters_1 = require("./parameters/AccountParameters");
const AnalyticsParameters_1 = require("./parameters/AnalyticsParameters");
const UniboxParameters_1 = require("./parameters/UniboxParameters");
// Helper function to get campaigns for dropdown
async function getCampaigns(filter) {
try {
// Get campaigns using our existing pagination function
const responseData = await generic_functions_1.instantlyApiRequest.call(this, 'GET', '/api/v2/campaigns', {}, { limit: 100 });
// Handle response structure - campaigns are in 'items' array for paginated responses
let campaigns = [];
if (responseData.items && Array.isArray(responseData.items)) {
campaigns = responseData.items;
}
else if (Array.isArray(responseData)) {
campaigns = responseData;
}
// Filter campaigns if filter is provided
const filteredCampaigns = campaigns.filter((campaign) => {
if (!filter)
return true;
const campaignName = `${campaign.name || ''}`.toLowerCase();
return campaignName.includes(filter.toLowerCase());
});
// Map campaigns to dropdown options
const campaignOptions = filteredCampaigns.map((campaign) => ({
name: campaign.name || `Campaign ${campaign.id}`,
value: campaign.id,
}));
return {
results: campaignOptions,
};
}
catch (error) {
console.error('Error fetching campaigns for dropdown:', error);
return {
results: [],
};
}
}
// Helper function to get email accounts for dropdown
async function getEmailAccounts(filter) {
try {
// Get email accounts using the accounts API endpoint
const responseData = await generic_functions_1.instantlyApiRequest.call(this, 'GET', '/api/v2/accounts', {}, { limit: 100 });
// Handle response structure - accounts are in 'items' array for paginated responses
let accounts = [];
if (responseData.items && Array.isArray(responseData.items)) {
accounts = responseData.items;
}
else if (Array.isArray(responseData)) {
accounts = responseData;
}
// Filter accounts if filter is provided
const filteredAccounts = accounts.filter((account) => {
if (!filter)
return true;
const accountEmail = `${account.email || ''}`.toLowerCase();
const accountName = `${account.first_name || ''} ${account.last_name || ''}`.toLowerCase().trim();
return accountEmail.includes(filter.toLowerCase()) || accountName.includes(filter.toLowerCase());
});
// Map accounts to dropdown options
const accountOptions = filteredAccounts.map((account) => {
const displayName = account.first_name && account.last_name
? `${account.email} (${account.first_name} ${account.last_name})`
: account.email;
return {
name: displayName || `Account ${account.id}`,
value: account.email,
};
});
return {
results: accountOptions,
};
}
catch (error) {
console.error('Error fetching email accounts for dropdown:', error);
return {
results: [],
};
}
}
// Helper function to get leads for dropdown
async function getLeads(filter) {
try {
// Get leads using the leads list API endpoint
const body = {
limit: 100,
};
// Add search filter if provided
if (filter) {
body.search = filter;
}
const response = await generic_functions_1.instantlyApiRequest.call(this, 'POST', '/api/v2/leads/list', body);
const leadOptions = [];
if (response.items && Array.isArray(response.items)) {
for (const lead of response.items) {
const name = `${lead.first_name || ''} ${lead.last_name || ''}`.trim() || lead.email || 'Unknown Lead';
const value = lead.id;
leadOptions.push({
name: `${name} (${lead.email || 'No email'})`,
value,
});
}
}
return {
results: leadOptions,
};
}
catch (error) {
console.error('Error fetching leads for dropdown:', error);
return {
results: [],
};
}
}
class InstantlyApi {
constructor() {
this.description = {
displayName: 'Instantly',
name: 'instantly',
icon: 'file:instantly.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Interact with Instantly API',
defaults: {
name: 'Instantly',
},
inputs: ["main" /* NodeConnectionType.Main */],
outputs: ["main" /* NodeConnectionType.Main */],
credentials: [
{
name: 'instantlyApi',
required: true,
},
],
properties: [
{
displayName: 'Resource',
name: 'resource',
type: 'options',
noDataExpression: true,
options: [
{
name: 'Account',
value: 'account',
description: 'Manage SMTP email accounts for sending',
},
{
name: 'Analytics',
value: 'analytics',
description: 'Get campaign and account analytics',
},
{
name: 'Campaign',
value: 'campaign',
description: 'Manage email campaigns',
},
{
name: 'Lead',
value: 'lead',
description: 'Manage leads and contacts',
},
{
name: 'Unibox',
value: 'unibox',
description: 'Manage inbox messages and conversations',
},
],
default: 'campaign',
},
// CAMPAIGN OPERATIONS - Using modular parameters
...CampaignParameters_1.campaignParameters,
// LEAD OPERATIONS - Using modular parameters
...LeadParameters_1.leadParameters,
// ACCOUNT OPERATIONS - Using modular parameters
...AccountParameters_1.accountParameters,
// ANALYTICS OPERATIONS - Using modular parameters
...AnalyticsParameters_1.analyticsParameters,
// UNIBOX OPERATIONS - Using modular parameters
...UniboxParameters_1.uniboxParameters,
],
};
this.methods = {
listSearch: {
getCampaigns,
getEmailAccounts,
getLeads,
},
loadOptions: {
// Load email accounts for multi-select dropdown
async getEmailAccounts() {
try {
const response = await generic_functions_1.instantlyApiRequest.call(this, 'GET', '/api/v2/accounts');
const accounts = response.items || [];
return accounts.map((account) => ({
name: `${account.email} (${account.first_name} ${account.last_name})`,
value: account.email,
}));
}
catch (error) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load email accounts: ${error.message}`);
}
},
},
};
}
async execute() {
const items = this.getInputData();
const returnData = [];
// Helper function to extract campaign ID from resourceLocator
const getCampaignId = (i) => {
const campaignLocator = this.getNodeParameter('campaignId', i);
if (typeof campaignLocator === 'string') {
// Backward compatibility - if it's still a string
return campaignLocator;
}
// Extract value from resourceLocator
return campaignLocator.value || campaignLocator;
};
// Helper function to extract email from resourceLocator
const getEmailAccount = (i) => {
const emailLocator = this.getNodeParameter('emailAccount', i);
if (typeof emailLocator === 'string') {
// Backward compatibility - if it's still a string
return emailLocator;
}
// Extract value from resourceLocator
return emailLocator.value || emailLocator;
};
for (let i = 0; i < items.length; i++) {
try {
const resource = this.getNodeParameter('resource', i);
const operation = this.getNodeParameter('operation', i);
let responseData;
if (resource === 'campaign') {
// Use the modular OperationRouter for Campaign operations
responseData = await OperationRouter_1.OperationRouter.execute(this, i, resource, operation);
}
else if (resource === 'lead') {
// Use the modular OperationRouter for Lead operations
responseData = await OperationRouter_1.OperationRouter.execute(this, i, resource, operation);
}
else if (resource === 'account') {
// Use the modular OperationRouter for Account operations
responseData = await OperationRouter_1.OperationRouter.execute(this, i, resource, operation);
}
else if (resource === 'analytics') {
// Use the modular OperationRouter for Analytics operations
responseData = await OperationRouter_1.OperationRouter.execute(this, i, resource, operation);
}
else if (resource === 'unibox') {
// Use the modular OperationRouter for Unibox operations
responseData = await OperationRouter_1.OperationRouter.execute(this, i, resource, operation);
}
const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
returnData.push(...executionData);
}
catch (error) {
if (this.continueOnFail()) {
const executionData = this.helpers.constructExecutionMetaData([{ json: { error: error.message } }], { itemData: { item: i } });
returnData.push(...executionData);
continue;
}
throw error;
}
}
return [returnData];
}
}
exports.InstantlyApi = InstantlyApi;
//# sourceMappingURL=InstantlyApi.node.js.map