n8n-nodes-foxreach 0.1.0

package/dist/credentials/FoxReachApi.credentials.d.ts

@@ -0,0 +1,8 @@
+import { IAuthenticateGeneric, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class FoxReachApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+}

package/dist/credentials/FoxReachApi.credentials.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoxReachApi = void 0;
+class FoxReachApi {
+    constructor() {
+        this.name = 'foxReachApi';
+        this.displayName = 'FoxReach API';
+        this.documentationUrl = 'https://docs.foxreach.io/authentication';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                placeholder: 'otr_...',
+                required: true,
+                description: 'Your FoxReach API key. Find it in Settings > API Keys.',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'X-API-Key': '={{$credentials.apiKey}}',
+                },
+            },
+        };
+    }
+}
+exports.FoxReachApi = FoxReachApi;

package/dist/nodes/FoxReach/FoxReach.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class FoxReach implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/FoxReach/FoxReach.node.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoxReach = void 0;
+const LeadDescription_1 = require("./descriptions/LeadDescription");
+const CampaignDescription_1 = require("./descriptions/CampaignDescription");
+const BASE_URL = 'https://api.foxreach.io/api/v1';
+class FoxReach {
+    constructor() {
+        this.description = {
+            displayName: 'FoxReach',
+            name: 'foxReach',
+            icon: 'file:foxreach.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Manage leads and campaigns in FoxReach cold email outreach platform',
+            defaults: {
+                name: 'FoxReach',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'foxReachApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Lead',
+                            value: 'lead',
+                        },
+                        {
+                            name: 'Campaign',
+                            value: 'campaign',
+                        },
+                    ],
+                    default: 'lead',
+                },
+                ...LeadDescription_1.leadOperations,
+                ...LeadDescription_1.leadFields,
+                ...CampaignDescription_1.campaignOperations,
+                ...CampaignDescription_1.campaignFields,
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                let responseData;
+                if (resource === 'lead') {
+                    if (operation === 'create') {
+                        const email = this.getNodeParameter('email', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const body = { email };
+                        Object.assign(body, additionalFields);
+                        responseData = await this.helpers.httpRequestWithAuthentication.call(this, 'foxReachApi', {
+                            method: 'POST',
+                            url: `${BASE_URL}/leads`,
+                            body,
+                            json: true,
+                        });
+                        responseData = responseData.data;
+                    }
+                    if (operation === 'findByEmail') {
+                        const email = this.getNodeParameter('email', i);
+                        responseData = await this.helpers.httpRequestWithAuthentication.call(this, 'foxReachApi', {
+                            method: 'GET',
+                            url: `${BASE_URL}/leads`,
+                            qs: { search: email, pageSize: 5 },
+                            json: true,
+                        });
+                        responseData = responseData.data;
+                    }
+                }
+                if (resource === 'campaign') {
+                    if (operation === 'addLead') {
+                        const campaignId = this.getNodeParameter('campaignId', i);
+                        const leadId = this.getNodeParameter('leadId', i);
+                        responseData = await this.helpers.httpRequestWithAuthentication.call(this, 'foxReachApi', {
+                            method: 'POST',
+                            url: `${BASE_URL}/campaigns/${campaignId}/leads`,
+                            body: { leadIds: [leadId] },
+                            json: true,
+                        });
+                        responseData = responseData.data;
+                    }
+                }
+                if (Array.isArray(responseData)) {
+                    returnData.push(...responseData.map((item) => ({ json: item })));
+                }
+                else if (responseData) {
+                    returnData.push({ json: responseData });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.FoxReach = FoxReach;

package/dist/nodes/FoxReach/FoxReachTrigger.node.d.ts

@@ -0,0 +1,12 @@
+import { IHookFunctions, IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+export declare class FoxReachTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/FoxReach/FoxReachTrigger.node.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoxReachTrigger = void 0;
+const BASE_URL = 'https://api.foxreach.io/api/v1';
+class FoxReachTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'FoxReach Trigger',
+            name: 'foxReachTrigger',
+            icon: 'file:foxreach.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["event"]}}',
+            description: 'Starts a workflow when a FoxReach event occurs',
+            defaults: {
+                name: 'FoxReach Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'foxReachApi',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Event',
+                    name: 'event',
+                    type: 'options',
+                    required: true,
+                    default: 'reply.received',
+                    options: [
+                        {
+                            name: 'New Reply Received',
+                            value: 'reply.received',
+                            description: 'When a prospect replies to an outreach email',
+                        },
+                        {
+                            name: 'Reply Categorized',
+                            value: 'reply.categorized',
+                            description: 'When a reply is categorized (e.g. interested, not interested)',
+                        },
+                        {
+                            name: 'Email Bounced',
+                            value: 'email.bounced',
+                            description: 'When a sent email bounces back',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const webhookData = this.getWorkflowStaticData('node');
+                    // If we have a stored webhook ID, verify it still exists
+                    if (webhookData.webhookId) {
+                        try {
+                            const response = await this.helpers.httpRequestWithAuthentication.call(this, 'foxReachApi', {
+                                method: 'GET',
+                                url: `${BASE_URL}/webhooks`,
+                                qs: { pageSize: 100 },
+                                json: true,
+                            });
+                            const webhooks = response.data || [];
+                            const exists = webhooks.some((wh) => wh.id === webhookData.webhookId && wh.url === webhookUrl);
+                            if (exists)
+                                return true;
+                        }
+                        catch {
+                            // Webhook no longer exists, will recreate
+                        }
+                    }
+                    return false;
+                },
+                async create() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const event = this.getNodeParameter('event');
+                    const webhookData = this.getWorkflowStaticData('node');
+                    const response = await this.helpers.httpRequestWithAuthentication.call(this, 'foxReachApi', {
+                        method: 'POST',
+                        url: `${BASE_URL}/webhooks`,
+                        body: {
+                            url: webhookUrl,
+                            events: [event],
+                        },
+                        json: true,
+                    });
+                    webhookData.webhookId = response.data.id;
+                    return true;
+                },
+                async delete() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (webhookData.webhookId) {
+                        try {
+                            await this.helpers.httpRequestWithAuthentication.call(this, 'foxReachApi', {
+                                method: 'DELETE',
+                                url: `${BASE_URL}/webhooks/${webhookData.webhookId}`,
+                                json: true,
+                            });
+                        }
+                        catch {
+                            // Webhook may have been deleted already
+                        }
+                        delete webhookData.webhookId;
+                    }
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const body = this.getBodyData();
+        return {
+            workflowData: [
+                this.helpers.returnJsonArray({
+                    eventId: body.id,
+                    eventType: body.type,
+                    timestamp: body.timestamp,
+                    ...body.payload,
+                }),
+            ],
+        };
+    }
+}
+exports.FoxReachTrigger = FoxReachTrigger;

package/dist/nodes/FoxReach/descriptions/CampaignDescription.d.ts

@@ -0,0 +1,3 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const campaignOperations: INodeProperties[];
+export declare const campaignFields: INodeProperties[];

package/dist/nodes/FoxReach/descriptions/CampaignDescription.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.campaignFields = exports.campaignOperations = void 0;
+exports.campaignOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['campaign'],
+            },
+        },
+        options: [
+            {
+                name: 'Add Lead',
+                value: 'addLead',
+                description: 'Add a lead to a campaign',
+                action: 'Add a lead to a campaign',
+            },
+        ],
+        default: 'addLead',
+    },
+];
+exports.campaignFields = [
+    // ----------------------------------
+    //         campaign:addLead
+    // ----------------------------------
+    {
+        displayName: 'Campaign ID',
+        name: 'campaignId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['campaign'],
+                operation: ['addLead'],
+            },
+        },
+        description: 'The ID of the campaign to add the lead to',
+    },
+    {
+        displayName: 'Lead ID',
+        name: 'leadId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['campaign'],
+                operation: ['addLead'],
+            },
+        },
+        description: 'The ID of the lead to add',
+    },
+];

package/dist/nodes/FoxReach/descriptions/LeadDescription.d.ts

@@ -0,0 +1,3 @@
+import { INodeProperties } from 'n8n-workflow';
+export declare const leadOperations: INodeProperties[];
+export declare const leadFields: INodeProperties[];

package/dist/nodes/FoxReach/descriptions/LeadDescription.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leadFields = exports.leadOperations = void 0;
+exports.leadOperations = [
+    {
+        displayName: 'Operation',
+        name: 'operation',
+        type: 'options',
+        noDataExpression: true,
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+            },
+        },
+        options: [
+            {
+                name: 'Create',
+                value: 'create',
+                description: 'Create a new lead',
+                action: 'Create a lead',
+            },
+            {
+                name: 'Find by Email',
+                value: 'findByEmail',
+                description: 'Find a lead by email address',
+                action: 'Find a lead by email',
+            },
+        ],
+        default: 'create',
+    },
+];
+exports.leadFields = [
+    // ----------------------------------
+    //         lead:create
+    // ----------------------------------
+    {
+        displayName: 'Email',
+        name: 'email',
+        type: 'string',
+        placeholder: 'name@email.com',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['create'],
+            },
+        },
+        description: 'Email address of the lead. Must be unique within the workspace.',
+    },
+    {
+        displayName: 'Additional Fields',
+        name: 'additionalFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['create'],
+            },
+        },
+        options: [
+            {
+                displayName: 'First Name',
+                name: 'firstName',
+                type: 'string',
+                default: '',
+            },
+            {
+                displayName: 'Last Name',
+                name: 'lastName',
+                type: 'string',
+                default: '',
+            },
+            {
+                displayName: 'Company',
+                name: 'company',
+                type: 'string',
+                default: '',
+            },
+            {
+                displayName: 'Job Title',
+                name: 'title',
+                type: 'string',
+                default: '',
+            },
+            {
+                displayName: 'Phone',
+                name: 'phone',
+                type: 'string',
+                default: '',
+            },
+            {
+                displayName: 'LinkedIn URL',
+                name: 'linkedinUrl',
+                type: 'string',
+                default: '',
+            },
+            {
+                displayName: 'Website',
+                name: 'website',
+                type: 'string',
+                default: '',
+            },
+            {
+                displayName: 'Notes',
+                name: 'notes',
+                type: 'string',
+                default: '',
+            },
+            {
+                displayName: 'Status',
+                name: 'status',
+                type: 'options',
+                options: [
+                    { name: 'Active', value: 'active' },
+                    { name: 'Bounced', value: 'bounced' },
+                    { name: 'Unsubscribed', value: 'unsubscribed' },
+                    { name: 'Replied', value: 'replied' },
+                ],
+                default: 'active',
+            },
+        ],
+    },
+    // ----------------------------------
+    //         lead:findByEmail
+    // ----------------------------------
+    {
+        displayName: 'Email',
+        name: 'email',
+        type: 'string',
+        placeholder: 'name@email.com',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['lead'],
+                operation: ['findByEmail'],
+            },
+        },
+        description: 'The email address to search for',
+    },
+];

package/dist/nodes/FoxReach/foxreach.svg

@@ -0,0 +1,40 @@
+<svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="fxGrad" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" stop-color="#E89A84" />
+      <stop offset="100%" stop-color="#E07A5F" />
+    </linearGradient>
+    <linearGradient id="fxEarGrad" x1="0%" y1="0%" x2="0%" y2="100%">
+      <stop offset="0%" stop-color="#E07A5F" />
+      <stop offset="100%" stop-color="#C4604A" />
+    </linearGradient>
+  </defs>
+  <!-- Left ear -->
+  <path d="M100 60 L60 220 L190 250 Z" fill="url(#fxEarGrad)" />
+  <!-- Right ear -->
+  <path d="M412 60 L452 220 L322 250 Z" fill="url(#fxEarGrad)" />
+  <!-- Inner left ear -->
+  <path d="M120 120 L95 210 L175 235 Z" fill="#F3D5CF" />
+  <!-- Inner right ear -->
+  <path d="M392 120 L417 210 L337 235 Z" fill="#F3D5CF" />
+  <!-- Head -->
+  <ellipse cx="256" cy="300" rx="190" ry="175" fill="url(#fxGrad)" />
+  <!-- White face/muzzle area -->
+  <ellipse cx="256" cy="350" rx="110" ry="100" fill="#FFF5F2" />
+  <!-- Left eye -->
+  <ellipse cx="195" cy="280" rx="22" ry="25" fill="#37322F" />
+  <ellipse cx="200" cy="275" rx="7" ry="8" fill="white" />
+  <!-- Right eye -->
+  <ellipse cx="317" cy="280" rx="22" ry="25" fill="#37322F" />
+  <ellipse cx="322" cy="275" rx="7" ry="8" fill="white" />
+  <!-- Nose -->
+  <ellipse cx="256" cy="340" rx="20" ry="14" fill="#37322F" />
+  <ellipse cx="252" cy="337" rx="6" ry="4" fill="#5A504C" />
+  <!-- Mouth -->
+  <path d="M256 354 Q240 370 230 365" fill="none" stroke="#37322F" stroke-width="4" stroke-linecap="round" />
+  <path d="M256 354 Q272 370 282 365" fill="none" stroke="#37322F" stroke-width="4" stroke-linecap="round" />
+  <!-- Cheek fluff left -->
+  <path d="M80 330 Q120 310 140 340 Q110 360 80 330Z" fill="#E07A5F" />
+  <!-- Cheek fluff right -->
+  <path d="M432 330 Q392 310 372 340 Q402 360 432 330Z" fill="#E07A5F" />
+</svg>

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "n8n-nodes-foxreach",
+  "version": "0.1.0",
+  "description": "n8n community node for FoxReach cold email outreach platform",
+  "license": "MIT",
+  "homepage": "https://foxreach.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/foxreach/n8n-nodes-foxreach"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "foxreach",
+    "cold-email",
+    "outreach"
+  ],
+  "main": "dist/nodes/FoxReach/FoxReach.node.js",
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/FoxReachApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/FoxReach/FoxReach.node.js",
+      "dist/nodes/FoxReach/FoxReachTrigger.node.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc && cp nodes/FoxReach/foxreach.svg dist/nodes/FoxReach/",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "n8n-workflow": "*"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}