n8n-nodes-ocean/dist/nodes/Ocean/Ocean.node.js

n8n community node for Ocean.io API integration - lookalike company and people discovery

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Ocean = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const GenericFunctions_1 = require("./GenericFunctions");
const CompanyDescription_1 = require("./CompanyDescription");
const PersonDescription_1 = require("./PersonDescription");
const CreditsDescription_1 = require("./CreditsDescription");
class Ocean {
    description = {
        displayName: 'Ocean.io',
        name: 'ocean',
        icon: 'file:ocean-logo.png',
        group: ['transform'],
        version: 1,
        subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
        description: 'Interact with Ocean.io API for lookalike company and people discovery',
        defaults: {
            name: 'Ocean.io',
        },
        inputs: [n8n_workflow_1.NodeConnectionType.Main],
        outputs: [n8n_workflow_1.NodeConnectionType.Main],
        credentials: [
            {
                name: 'oceanApi',
                required: true,
            },
        ],
        requestDefaults: {
            baseURL: 'https://api.ocean.io',
            headers: {
                Accept: 'application/json',
                'Content-Type': 'application/json',
            },
        },
        properties: [
            {
                displayName: 'Resource',
                name: 'resource',
                type: 'options',
                noDataExpression: true,
                options: [
                    {
                        name: 'Company',
                        value: 'company',
                        description: 'Search and enrich company data with lookalike discovery',
                    },
                    {
                        name: 'Person',
                        value: 'person',
                        description: 'Search and enrich people data with lookalike discovery',
                    },
                    {
                        name: 'Credits',
                        value: 'credits',
                        description: 'Manage and monitor your Ocean.io API credits',
                    },
                ],
                default: 'company',
            },
            ...CompanyDescription_1.companyOperations,
            ...PersonDescription_1.personOperations,
            ...CreditsDescription_1.creditsOperations,
            ...CompanyDescription_1.companyFields,
            ...PersonDescription_1.personFields,
            ...CreditsDescription_1.creditsFields,
        ],
    };
    async execute() {
        const items = this.getInputData();
        const returnData = [];
        const length = items.length;
        const resource = this.getNodeParameter('resource', 0);
        const operation = this.getNodeParameter('operation', 0);
        for (let i = 0; i < length; i++) {
            try {
                let responseData;
                if (resource === 'company') {
                    responseData = await this.executeCompanyOperation(i);
                }
                else if (resource === 'person') {
                    responseData = await this.executePersonOperation(i);
                }
                else if (resource === 'credits') {
                    responseData = await this.executeCreditsOperation(i);
                }
                else {
                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The resource "${resource}" is not known!`, {
                        itemIndex: i,
                    });
                }
                const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                returnData.push(...executionData);
            }
            catch (error) {
                if (this.continueOnFail()) {
                    const executionErrorData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ error: error.message }), { itemData: { item: i } });
                    returnData.push(...executionErrorData);
                    continue;
                }
                throw error;
            }
        }
        return [returnData];
    }
    async executeCompanyOperation(itemIndex) {
        const operation = this.getNodeParameter('operation', itemIndex);
        if (operation === 'search') {
            return this.searchCompanies(itemIndex);
        }
        else if (operation === 'enrich') {
            return this.enrichCompany(itemIndex);
        }
        else {
            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, {
                itemIndex,
            });
        }
    }
    async executePersonOperation(itemIndex) {
        const operation = this.getNodeParameter('operation', itemIndex);
        if (operation === 'search') {
            return this.searchPeople(itemIndex);
        }
        else if (operation === 'enrich') {
            return this.enrichPerson(itemIndex);
        }
        else {
            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, {
                itemIndex,
            });
        }
    }
    async executeCreditsOperation(itemIndex) {
        const operation = this.getNodeParameter('operation', itemIndex);
        if (operation === 'getBalance') {
            return this.getCreditBalance(itemIndex);
        }
        else {
            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, {
                itemIndex,
            });
        }
    }
    async searchCompanies(itemIndex) {
        const returnAll = this.getNodeParameter('returnAll', itemIndex, false);
        const limit = this.getNodeParameter('limit', itemIndex, 50);
        // Build search body
        const body = {};
        // Lookalike domains
        const lookalikeDomains = this.getNodeParameter('lookalikeDomains', itemIndex, '');
        if (lookalikeDomains) {
            body.lookalike_domains = lookalikeDomains.split(',').map(d => d.trim()).filter(d => d);
        }
        // Basic filters
        const companyName = this.getNodeParameter('companyName', itemIndex, '');
        if (companyName) {
            body.company_name = companyName;
        }
        const domain = this.getNodeParameter('domain', itemIndex, '');
        if (domain) {
            body.domain = domain;
        }
        // Size filters
        const employeeCountMin = this.getNodeParameter('employeeCountMin', itemIndex, undefined);
        const employeeCountMax = this.getNodeParameter('employeeCountMax', itemIndex, undefined);
        if (employeeCountMin !== undefined || employeeCountMax !== undefined) {
            body.employee_count = {};
            if (employeeCountMin !== undefined)
                body.employee_count.min = employeeCountMin;
            if (employeeCountMax !== undefined)
                body.employee_count.max = employeeCountMax;
        }
        // Location filters
        const countries = this.getNodeParameter('countries', itemIndex, '');
        if (countries) {
            body.countries = countries.split(',').map(c => c.trim()).filter(c => c);
        }
        // Industry filters
        const industries = this.getNodeParameter('industries', itemIndex, '');
        if (industries) {
            body.industries = industries.split(',').map(i => i.trim()).filter(i => i);
        }
        // Set pagination
        if (!returnAll) {
            body.size = limit;
        }
        if (returnAll) {
            return await GenericFunctions_1.oceanApiRequestAllItems.call(this, 'POST', '/v3/search/companies', body);
        }
        else {
            const response = await GenericFunctions_1.oceanApiRequest.call(this, 'POST', '/v3/search/companies', body);
            return response.companies || [];
        }
    }
    async enrichCompany(itemIndex) {
        const body = {};
        const domain = this.getNodeParameter('domain', itemIndex);
        if (domain) {
            body.domain = domain;
        }
        const companyName = this.getNodeParameter('companyName', itemIndex, '');
        if (companyName) {
            body.company_name = companyName;
        }
        const response = await GenericFunctions_1.oceanApiRequest.call(this, 'POST', '/v2/enrich/company', body);
        return response;
    }
    async searchPeople(itemIndex) {
        const returnAll = this.getNodeParameter('returnAll', itemIndex, false);
        const limit = this.getNodeParameter('limit', itemIndex, 50);
        // Build search body
        const body = {};
        // Lookalike LinkedIn handles
        const lookalikePeople = this.getNodeParameter('lookalikePeople', itemIndex, '');
        if (lookalikePeople) {
            body.lookalike_people = lookalikePeople.split(',').map(p => p.trim()).filter(p => p);
        }
        // Basic filters
        const personName = this.getNodeParameter('personName', itemIndex, '');
        if (personName) {
            body.person_name = personName;
        }
        const jobTitles = this.getNodeParameter('jobTitles', itemIndex, '');
        if (jobTitles) {
            body.job_titles = jobTitles.split(',').map(t => t.trim()).filter(t => t);
        }
        // Company filters
        const companyDomains = this.getNodeParameter('companyDomains', itemIndex, '');
        if (companyDomains) {
            body.company_domains = companyDomains.split(',').map(d => d.trim()).filter(d => d);
        }
        // Location filters
        const countries = this.getNodeParameter('countries', itemIndex, '');
        if (countries) {
            body.countries = countries.split(',').map(c => c.trim()).filter(c => c);
        }
        // Set pagination
        if (!returnAll) {
            body.size = limit;
        }
        if (returnAll) {
            return await GenericFunctions_1.oceanApiRequestAllItems.call(this, 'POST', '/v3/search/people', body);
        }
        else {
            const response = await GenericFunctions_1.oceanApiRequest.call(this, 'POST', '/v3/search/people', body);
            return response.people || [];
        }
    }
    async enrichPerson(itemIndex) {
        const body = {};
        const email = this.getNodeParameter('email', itemIndex, '');
        if (email) {
            body.email = email;
        }
        const linkedinHandle = this.getNodeParameter('linkedinHandle', itemIndex, '');
        if (linkedinHandle) {
            body.linkedin_handle = linkedinHandle;
        }
        const personName = this.getNodeParameter('personName', itemIndex, '');
        if (personName) {
            body.person_name = personName;
        }
        const response = await GenericFunctions_1.oceanApiRequest.call(this, 'POST', '/v2/enrich/person', body);
        return response;
    }
    async getCreditBalance(itemIndex) {
        const response = await GenericFunctions_1.oceanApiRequest.call(this, 'GET', '/v2/credits/balance');
        return response;
    }
}
exports.Ocean = Ocean;