@beinfi/n8n-nodes-pulse 0.1.0

package/dist/Pulse/pulse.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48" fill="none">
+  <rect width="48" height="48" rx="12" fill="#6366f1"/>
+  <path d="M8 24h8l4-12 8 24 4-12h8" stroke="#fff" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/dist/credentials/PulseApi.credentials.d.ts

@@ -0,0 +1,13 @@
+import type { IAuthenticateGeneric, ICredentialType, INodeProperties } from 'n8n-workflow';
+/**
+ * Credential type for the Pulse Payment & Metering API.
+ *
+ * Uses Bearer token authentication with an API key (sk_live_...).
+ */
+export declare class PulseApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+}

package/dist/credentials/PulseApi.credentials.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PulseApi = void 0;
+/**
+ * Credential type for the Pulse Payment & Metering API.
+ *
+ * Uses Bearer token authentication with an API key (sk_live_...).
+ */
+class PulseApi {
+    name = 'pulseApi';
+    displayName = 'Pulse API';
+    documentationUrl = 'https://docs.beinfi.com';
+    properties = [
+        {
+            displayName: 'API Key',
+            name: 'apiKey',
+            type: 'string',
+            typeOptions: { password: true },
+            default: '',
+            required: true,
+            placeholder: 'sk_live_...',
+            description: 'Your Pulse API key from the dashboard',
+        },
+        {
+            displayName: 'Base URL',
+            name: 'baseUrl',
+            type: 'string',
+            default: 'https://api.beinfi.com/api/v1',
+            description: 'Base URL for the Pulse API (change only for staging/self-hosted)',
+        },
+    ];
+    authenticate = {
+        type: 'generic',
+        properties: {
+            headers: {
+                Authorization: '=Bearer {{$credentials.apiKey}}',
+            },
+        },
+    };
+}
+exports.PulseApi = PulseApi;

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

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

package/dist/nodes/Pulse/Pulse.node.js

@@ -0,0 +1,637 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pulse = void 0;
+class Pulse {
+    description = {
+        displayName: 'Pulse',
+        name: 'pulse',
+        icon: 'file:pulse.svg',
+        group: ['transform'],
+        version: 1,
+        subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+        description: 'Interact with Pulse Payment & Metering API',
+        defaults: { name: 'Pulse' },
+        inputs: ['main'],
+        outputs: ['main'],
+        credentials: [
+            {
+                name: 'pulseApi',
+                required: true,
+            },
+        ],
+        properties: [
+            // ─── Resource ────────────────────────────────────────────
+            {
+                displayName: 'Resource',
+                name: 'resource',
+                type: 'options',
+                noDataExpression: true,
+                options: [
+                    { name: 'Payment Link', value: 'paymentLink' },
+                    { name: 'Webhook', value: 'webhook' },
+                    { name: 'Metering', value: 'metering' },
+                ],
+                default: 'paymentLink',
+            },
+            // ─── Payment Link Operations ─────────────────────────────
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: { show: { resource: ['paymentLink'] } },
+                options: [
+                    {
+                        name: 'Create',
+                        value: 'create',
+                        action: 'Create a payment link',
+                        description: 'Create a new payment link',
+                    },
+                    {
+                        name: 'Get',
+                        value: 'get',
+                        action: 'Get a payment link',
+                        description: 'Retrieve a payment link by ID',
+                    },
+                    {
+                        name: 'List',
+                        value: 'list',
+                        action: 'List payment links',
+                        description: 'List all payment links',
+                    },
+                    {
+                        name: 'List Intents',
+                        value: 'listIntents',
+                        action: 'List payment intents',
+                        description: 'List payment attempts for a link',
+                    },
+                ],
+                default: 'create',
+            },
+            // Payment Link: Create fields
+            {
+                displayName: 'Title',
+                name: 'title',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: 'Order #42',
+                displayOptions: { show: { resource: ['paymentLink'], operation: ['create'] } },
+                description: 'Display title shown to the payer',
+            },
+            {
+                displayName: 'Amount',
+                name: 'amount',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: '99.90',
+                displayOptions: { show: { resource: ['paymentLink'], operation: ['create'] } },
+                description: 'Payment amount as decimal string (e.g. "99.90")',
+            },
+            {
+                displayName: 'Currency',
+                name: 'currency',
+                type: 'options',
+                options: [
+                    { name: 'USD', value: 'USD' },
+                    { name: 'BRL', value: 'BRL' },
+                ],
+                default: 'USD',
+                displayOptions: { show: { resource: ['paymentLink'], operation: ['create'] } },
+                description: 'Currency for the payment',
+            },
+            {
+                displayName: 'Description',
+                name: 'linkDescription',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['paymentLink'], operation: ['create'] } },
+                description: 'Optional description shown on the checkout page',
+            },
+            // Payment Link: Get / List Intents
+            {
+                displayName: 'Payment Link ID',
+                name: 'paymentLinkId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: { resource: ['paymentLink'], operation: ['get', 'listIntents'] },
+                },
+                description: 'The payment link UUID',
+            },
+            // Payment Link: List options
+            {
+                displayName: 'Limit',
+                name: 'limit',
+                type: 'number',
+                default: 20,
+                typeOptions: { minValue: 1, maxValue: 100 },
+                displayOptions: { show: { resource: ['paymentLink'], operation: ['list'] } },
+                description: 'Max number of results to return',
+            },
+            {
+                displayName: 'Offset',
+                name: 'offset',
+                type: 'number',
+                default: 0,
+                typeOptions: { minValue: 0 },
+                displayOptions: { show: { resource: ['paymentLink'], operation: ['list'] } },
+                description: 'Number of results to skip (pagination)',
+            },
+            // ─── Webhook Operations ──────────────────────────────────
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: { show: { resource: ['webhook'] } },
+                options: [
+                    {
+                        name: 'Create',
+                        value: 'create',
+                        action: 'Create a webhook',
+                        description: 'Subscribe to webhook events',
+                    },
+                    {
+                        name: 'List',
+                        value: 'list',
+                        action: 'List webhooks',
+                        description: 'List all webhook subscriptions',
+                    },
+                    {
+                        name: 'Delete',
+                        value: 'delete',
+                        action: 'Delete a webhook',
+                        description: 'Remove a webhook subscription',
+                    },
+                ],
+                default: 'create',
+            },
+            // Webhook: Create fields
+            {
+                displayName: 'URL',
+                name: 'webhookUrl',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: 'https://example.com/webhook',
+                displayOptions: { show: { resource: ['webhook'], operation: ['create'] } },
+                description: 'HTTPS endpoint that will receive webhook POSTs',
+            },
+            {
+                displayName: 'Events',
+                name: 'events',
+                type: 'multiOptions',
+                required: true,
+                options: [
+                    { name: 'Payment Confirmed', value: 'payment.confirmed' },
+                    { name: 'Payment Failed', value: 'payment.failed' },
+                    { name: 'Payment Expired', value: 'payment.expired' },
+                ],
+                default: ['payment.confirmed'],
+                displayOptions: { show: { resource: ['webhook'], operation: ['create'] } },
+                description: 'Event types to subscribe to',
+            },
+            // Webhook: Delete
+            {
+                displayName: 'Webhook ID',
+                name: 'webhookId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: { show: { resource: ['webhook'], operation: ['delete'] } },
+                description: 'The webhook UUID to delete',
+            },
+            // ─── Metering Operations ─────────────────────────────────
+            {
+                displayName: 'Operation',
+                name: 'operation',
+                type: 'options',
+                noDataExpression: true,
+                displayOptions: { show: { resource: ['metering'] } },
+                options: [
+                    {
+                        name: 'Track Event',
+                        value: 'trackEvent',
+                        action: 'Track a usage event',
+                        description: 'Record a single usage event',
+                    },
+                    {
+                        name: 'Track Batch',
+                        value: 'trackBatch',
+                        action: 'Track batch of usage events',
+                        description: 'Record multiple usage events at once',
+                    },
+                    {
+                        name: 'Get Usage',
+                        value: 'getUsage',
+                        action: 'Get aggregated usage',
+                        description: 'Query aggregated usage data',
+                    },
+                    {
+                        name: 'Get Customer Usage',
+                        value: 'getCustomerUsage',
+                        action: 'Get customer usage',
+                        description: 'Query usage for a specific customer',
+                    },
+                    {
+                        name: 'List Products',
+                        value: 'listProducts',
+                        action: 'List metering products',
+                        description: 'List all metering products',
+                    },
+                    {
+                        name: 'Create Product',
+                        value: 'createProduct',
+                        action: 'Create a metering product',
+                        description: 'Create a new product for metering',
+                    },
+                    {
+                        name: 'Create Meter',
+                        value: 'createMeter',
+                        action: 'Create a meter',
+                        description: 'Add a meter to a product',
+                    },
+                    {
+                        name: 'Create Customer',
+                        value: 'createCustomer',
+                        action: 'Create a customer',
+                        description: 'Register a customer on a product',
+                    },
+                ],
+                default: 'trackEvent',
+            },
+            // Metering: Track Event
+            {
+                displayName: 'Meter ID',
+                name: 'meterId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: { show: { resource: ['metering'], operation: ['trackEvent'] } },
+                description: 'Meter ID or slug to track against',
+            },
+            {
+                displayName: 'Customer ID',
+                name: 'customerId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: { show: { resource: ['metering'], operation: ['trackEvent'] } },
+                description: 'Your customer external ID',
+            },
+            {
+                displayName: 'Value',
+                name: 'value',
+                type: 'number',
+                required: true,
+                default: 1,
+                displayOptions: { show: { resource: ['metering'], operation: ['trackEvent'] } },
+                description: 'Quantity consumed (e.g. number of tokens)',
+            },
+            {
+                displayName: 'Event ID',
+                name: 'eventId',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['metering'], operation: ['trackEvent'] } },
+                description: 'Idempotency key (auto-generated if empty)',
+            },
+            // Metering: Track Batch
+            {
+                displayName: 'Events (JSON)',
+                name: 'batchEvents',
+                type: 'json',
+                required: true,
+                default: '[\n  { "meterId": "", "customerId": "", "value": 1 }\n]',
+                displayOptions: { show: { resource: ['metering'], operation: ['trackBatch'] } },
+                description: 'JSON array of events. Each: { meterId, customerId, value, eventId?, metadata? }',
+            },
+            // Metering: Get Usage
+            {
+                displayName: 'Customer ID',
+                name: 'usageCustomerId',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['metering'], operation: ['getUsage'] } },
+                description: 'Filter usage by customer (optional)',
+            },
+            {
+                displayName: 'Start Date',
+                name: 'startDate',
+                type: 'string',
+                default: '',
+                placeholder: '2024-01-01',
+                displayOptions: {
+                    show: {
+                        resource: ['metering'],
+                        operation: ['getUsage', 'getCustomerUsage'],
+                    },
+                },
+                description: 'Start date filter (ISO 8601)',
+            },
+            {
+                displayName: 'End Date',
+                name: 'endDate',
+                type: 'string',
+                default: '',
+                placeholder: '2024-12-31',
+                displayOptions: {
+                    show: {
+                        resource: ['metering'],
+                        operation: ['getUsage', 'getCustomerUsage'],
+                    },
+                },
+                description: 'End date filter (ISO 8601)',
+            },
+            // Metering: Get Customer Usage / Create Meter / Create Customer — shared Product ID
+            {
+                displayName: 'Product ID',
+                name: 'productId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: {
+                        resource: ['metering'],
+                        operation: ['getCustomerUsage', 'createMeter', 'createCustomer'],
+                    },
+                },
+                description: 'The product UUID',
+            },
+            // Metering: Get Customer Usage
+            {
+                displayName: 'Customer ID',
+                name: 'customerUsageCustomerId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: { resource: ['metering'], operation: ['getCustomerUsage'] },
+                },
+                description: 'The customer external ID',
+            },
+            // Metering: Create Product
+            {
+                displayName: 'Name',
+                name: 'productName',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: { show: { resource: ['metering'], operation: ['createProduct'] } },
+                description: 'Product name',
+            },
+            {
+                displayName: 'Description',
+                name: 'productDescription',
+                type: 'string',
+                default: '',
+                displayOptions: { show: { resource: ['metering'], operation: ['createProduct'] } },
+                description: 'Optional product description',
+            },
+            // Metering: Create Meter
+            {
+                displayName: 'Name (Slug)',
+                name: 'meterName',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: 'tokens',
+                displayOptions: { show: { resource: ['metering'], operation: ['createMeter'] } },
+                description: 'Meter slug identifier',
+            },
+            {
+                displayName: 'Display Name',
+                name: 'meterDisplayName',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: 'AI Tokens',
+                displayOptions: { show: { resource: ['metering'], operation: ['createMeter'] } },
+                description: 'Human-readable meter name',
+            },
+            {
+                displayName: 'Unit',
+                name: 'meterUnit',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: 'token',
+                displayOptions: { show: { resource: ['metering'], operation: ['createMeter'] } },
+                description: 'Unit of measurement',
+            },
+            {
+                displayName: 'Unit Price',
+                name: 'meterUnitPrice',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: '0.0001',
+                displayOptions: { show: { resource: ['metering'], operation: ['createMeter'] } },
+                description: 'Cost per unit as decimal string',
+            },
+            // Metering: Create Customer
+            {
+                displayName: 'External ID',
+                name: 'externalId',
+                type: 'string',
+                required: true,
+                default: '',
+                displayOptions: {
+                    show: { resource: ['metering'], operation: ['createCustomer'] },
+                },
+                description: 'Your unique customer identifier',
+            },
+            {
+                displayName: 'Name',
+                name: 'customerName',
+                type: 'string',
+                default: '',
+                displayOptions: {
+                    show: { resource: ['metering'], operation: ['createCustomer'] },
+                },
+                description: 'Customer display name',
+            },
+            {
+                displayName: 'Email',
+                name: 'customerEmail',
+                type: 'string',
+                default: '',
+                placeholder: 'customer@example.com',
+                displayOptions: {
+                    show: { resource: ['metering'], operation: ['createCustomer'] },
+                },
+                description: 'Customer email address',
+            },
+        ],
+    };
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        const credentials = await this.getCredentials('pulseApi');
+        const baseUrl = credentials.baseUrl || 'https://api.beinfi.com/api/v1';
+        for (let i = 0; i < items.length; i++) {
+            try {
+                let response;
+                if (resource === 'paymentLink') {
+                    response = await executePaymentLink.call(this, operation, baseUrl, i);
+                }
+                else if (resource === 'webhook') {
+                    response = await executeWebhook.call(this, operation, baseUrl, i);
+                }
+                else {
+                    response = await executeMetering.call(this, operation, baseUrl, i);
+                }
+                // Unwrap Pulse API { data } envelope
+                const result = response.data ?? response;
+                const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(result), { itemData: { item: i } });
+                returnData.push(...executionData);
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Pulse = Pulse;
+// ─── Payment Link Handlers ──────────────────────────────────────
+async function executePaymentLink(operation, baseUrl, i) {
+    if (operation === 'create') {
+        const body = {
+            title: this.getNodeParameter('title', i),
+            amount: this.getNodeParameter('amount', i),
+            currency: this.getNodeParameter('currency', i),
+        };
+        const desc = this.getNodeParameter('linkDescription', i);
+        if (desc)
+            body.description = desc;
+        return makeRequest.call(this, 'POST', `${baseUrl}/payment-links`, body);
+    }
+    if (operation === 'get') {
+        const id = this.getNodeParameter('paymentLinkId', i);
+        return makeRequest.call(this, 'GET', `${baseUrl}/payment-links/${id}`);
+    }
+    if (operation === 'listIntents') {
+        const id = this.getNodeParameter('paymentLinkId', i);
+        return makeRequest.call(this, 'GET', `${baseUrl}/payment-links/${id}/intents`);
+    }
+    // list
+    const qs = {
+        limit: this.getNodeParameter('limit', i),
+        offset: this.getNodeParameter('offset', i),
+    };
+    return makeRequest.call(this, 'GET', `${baseUrl}/payment-links`, undefined, qs);
+}
+// ─── Webhook Handlers ───────────────────────────────────────────
+async function executeWebhook(operation, baseUrl, i) {
+    if (operation === 'create') {
+        return makeRequest.call(this, 'POST', `${baseUrl}/webhooks`, {
+            url: this.getNodeParameter('webhookUrl', i),
+            events: this.getNodeParameter('events', i),
+        });
+    }
+    if (operation === 'delete') {
+        const id = this.getNodeParameter('webhookId', i);
+        return makeRequest.call(this, 'DELETE', `${baseUrl}/webhooks/${id}`);
+    }
+    // list
+    return makeRequest.call(this, 'GET', `${baseUrl}/webhooks`);
+}
+// ─── Metering Handlers ──────────────────────────────────────────
+async function executeMetering(operation, baseUrl, i) {
+    if (operation === 'trackEvent') {
+        const body = {
+            meterId: this.getNodeParameter('meterId', i),
+            customerId: this.getNodeParameter('customerId', i),
+            value: String(this.getNodeParameter('value', i)),
+        };
+        const eventId = this.getNodeParameter('eventId', i);
+        if (eventId)
+            body.eventId = eventId;
+        return makeRequest.call(this, 'POST', `${baseUrl}/metering/events`, body);
+    }
+    if (operation === 'trackBatch') {
+        const raw = this.getNodeParameter('batchEvents', i);
+        const events = typeof raw === 'string' ? JSON.parse(raw) : raw;
+        return makeRequest.call(this, 'POST', `${baseUrl}/metering/events/batch`, { events });
+    }
+    if (operation === 'getUsage') {
+        const qs = {};
+        const cid = this.getNodeParameter('usageCustomerId', i);
+        const start = this.getNodeParameter('startDate', i);
+        const end = this.getNodeParameter('endDate', i);
+        if (cid)
+            qs.customerId = cid;
+        if (start)
+            qs.startDate = start;
+        if (end)
+            qs.endDate = end;
+        return makeRequest.call(this, 'GET', `${baseUrl}/metering/usage`, undefined, qs);
+    }
+    if (operation === 'getCustomerUsage') {
+        const productId = this.getNodeParameter('productId', i);
+        const customerId = this.getNodeParameter('customerUsageCustomerId', i);
+        const qs = {};
+        const start = this.getNodeParameter('startDate', i);
+        const end = this.getNodeParameter('endDate', i);
+        if (start)
+            qs.startDate = start;
+        if (end)
+            qs.endDate = end;
+        return makeRequest.call(this, 'GET', `${baseUrl}/metering/products/${productId}/customers/${customerId}/usage`, undefined, qs);
+    }
+    if (operation === 'listProducts') {
+        return makeRequest.call(this, 'GET', `${baseUrl}/metering/products`);
+    }
+    if (operation === 'createProduct') {
+        const body = {
+            name: this.getNodeParameter('productName', i),
+        };
+        const desc = this.getNodeParameter('productDescription', i);
+        if (desc)
+            body.description = desc;
+        return makeRequest.call(this, 'POST', `${baseUrl}/metering/products`, body);
+    }
+    if (operation === 'createMeter') {
+        const productId = this.getNodeParameter('productId', i);
+        return makeRequest.call(this, 'POST', `${baseUrl}/metering/products/${productId}/meters`, {
+            name: this.getNodeParameter('meterName', i),
+            displayName: this.getNodeParameter('meterDisplayName', i),
+            unit: this.getNodeParameter('meterUnit', i),
+            unitPrice: this.getNodeParameter('meterUnitPrice', i),
+        });
+    }
+    // createCustomer
+    const productId = this.getNodeParameter('productId', i);
+    const body = {
+        externalId: this.getNodeParameter('externalId', i),
+    };
+    const name = this.getNodeParameter('customerName', i);
+    const email = this.getNodeParameter('customerEmail', i);
+    if (name)
+        body.name = name;
+    if (email)
+        body.email = email;
+    return makeRequest.call(this, 'POST', `${baseUrl}/metering/products/${productId}/customers`, body);
+}
+// ─── HTTP Helper ────────────────────────────────────────────────
+async function makeRequest(method, url, body, qs) {
+    const options = { method, url, json: true };
+    if (body)
+        options.body = body;
+    if (qs)
+        options.qs = qs;
+    return this.helpers.httpRequestWithAuthentication.call(this, 'pulseApi', options);
+}

package/dist/nodes/Pulse/PulseTrigger.node.d.ts

@@ -0,0 +1,12 @@
+import type { IHookFunctions, IWebhookFunctions, INodeType, INodeTypeDescription, IWebhookResponseData } from 'n8n-workflow';
+export declare class PulseTrigger 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/Pulse/PulseTrigger.node.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PulseTrigger = void 0;
+const crypto_1 = require("crypto");
+class PulseTrigger {
+    description = {
+        displayName: 'Pulse Trigger',
+        name: 'pulseTrigger',
+        icon: 'file:pulse.svg',
+        group: ['trigger'],
+        version: 1,
+        description: 'Starts workflow when a Pulse payment event occurs',
+        defaults: { name: 'Pulse Trigger' },
+        inputs: [],
+        outputs: ['main'],
+        credentials: [
+            {
+                name: 'pulseApi',
+                required: true,
+            },
+        ],
+        webhooks: [
+            {
+                name: 'default',
+                httpMethod: 'POST',
+                responseMode: 'onReceived',
+                path: 'pulse',
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Events',
+                name: 'events',
+                type: 'multiOptions',
+                required: true,
+                options: [
+                    { name: 'Payment Confirmed', value: 'payment.confirmed' },
+                    { name: 'Payment Failed', value: 'payment.failed' },
+                    { name: 'Payment Expired', value: 'payment.expired' },
+                ],
+                default: ['payment.confirmed'],
+                description: 'Which payment events should trigger this workflow',
+            },
+        ],
+    };
+    webhookMethods = {
+        default: {
+            async checkExists() {
+                const staticData = this.getWorkflowStaticData('node');
+                if (!staticData.webhookId)
+                    return false;
+                // Verify the webhook still exists on Pulse
+                const credentials = await this.getCredentials('pulseApi');
+                const baseUrl = credentials.baseUrl || 'https://api.beinfi.com/api/v1';
+                try {
+                    const response = (await this.helpers.httpRequestWithAuthentication.call(this, 'pulseApi', {
+                        method: 'GET',
+                        url: `${baseUrl}/webhooks`,
+                        json: true,
+                    }));
+                    const webhooks = (response.data ?? response);
+                    return Array.isArray(webhooks) &&
+                        webhooks.some((wh) => wh.id === staticData.webhookId);
+                }
+                catch {
+                    return false;
+                }
+            },
+            async create() {
+                const webhookUrl = this.getNodeWebhookUrl('default');
+                const events = this.getNodeParameter('events');
+                const credentials = await this.getCredentials('pulseApi');
+                const baseUrl = credentials.baseUrl || 'https://api.beinfi.com/api/v1';
+                const response = (await this.helpers.httpRequestWithAuthentication.call(this, 'pulseApi', {
+                    method: 'POST',
+                    url: `${baseUrl}/webhooks`,
+                    body: { url: webhookUrl, events },
+                    json: true,
+                }));
+                const data = (response.data ?? response);
+                const staticData = this.getWorkflowStaticData('node');
+                staticData.webhookId = data.id;
+                staticData.webhookSecret = data.secret;
+                return true;
+            },
+            async delete() {
+                const staticData = this.getWorkflowStaticData('node');
+                const webhookId = staticData.webhookId;
+                if (!webhookId)
+                    return true;
+                const credentials = await this.getCredentials('pulseApi');
+                const baseUrl = credentials.baseUrl || 'https://api.beinfi.com/api/v1';
+                try {
+                    await this.helpers.httpRequestWithAuthentication.call(this, 'pulseApi', {
+                        method: 'DELETE',
+                        url: `${baseUrl}/webhooks/${webhookId}`,
+                        json: true,
+                    });
+                }
+                catch {
+                    // Webhook may already be deleted — ignore cleanup errors
+                }
+                delete staticData.webhookId;
+                delete staticData.webhookSecret;
+                return true;
+            },
+        },
+    };
+    async webhook() {
+        const req = this.getRequestObject();
+        const body = req.body;
+        // Verify HMAC signature if we have the secret from auto-registration
+        const staticData = this.getWorkflowStaticData('node');
+        const secret = staticData.webhookSecret;
+        if (secret) {
+            const signature = req.headers['x-pulse-signature'];
+            if (signature) {
+                const rawBody = req.rawBody?.toString() ??
+                    JSON.stringify(body);
+                const expected = 'sha256=' +
+                    (0, crypto_1.createHmac)('sha256', secret).update(rawBody).digest('hex');
+                if (signature !== expected) {
+                    return {
+                        webhookResponse: 'Invalid signature',
+                    };
+                }
+            }
+        }
+        return {
+            workflowData: [this.helpers.returnJsonArray(body)],
+        };
+    }
+}
+exports.PulseTrigger = PulseTrigger;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@beinfi/n8n-nodes-pulse",
+  "version": "0.1.0",
+  "description": "n8n community node for Pulse Payment & Metering API",
+  "license": "MIT",
+  "author": {
+    "name": "Be Infinitum"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "pulse",
+    "payment",
+    "metering",
+    "billing"
+  ],
+  "main": "dist/nodes/Pulse/Pulse.node.js",
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/PulseApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Pulse/Pulse.node.js",
+      "dist/nodes/Pulse/PulseTrigger.node.js"
+    ]
+  },
+  "scripts": {
+    "build": "tsc && copyfiles -u 1 \"nodes/**/*.svg\" dist/",
+    "dev": "tsc --watch",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "copyfiles": "^2.4.1",
+    "n8n-workflow": "^1.0.0",
+    "typescript": "^5.6.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": ">=1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}