n8n-nodes-cribops 0.1.18 → 0.1.24

package/dist/nodes/CribopsTrigger/CribopsTrigger.node.js

@@ -41,7 +41,7 @@ class CribopsTrigger {
                     loadOptionsMethod: 'getWebhooks',
                 },
                 default: '',
-                description: 'The Cribops webhook to use. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+                description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
             },
             {
                 displayName: 'Event Types',
@@ -109,18 +109,40 @@ class CribopsTrigger {
                     apiToken: credentials.apiToken,
                 });
                 try {
-                    // Call the API to get available webhooks
-                    // The API endpoint would be something like GET /api/v1/webhooks
-                    const response = await cribopsHttp.request('GET', '/api/v1/webhooks');
-                    const webhooks = response.data || [];
-                    return webhooks.map((webhook) => ({
-                        name: webhook.name || webhook.id,
+                    // Organization is automatically determined from API key
+                    const webhooks = await cribopsHttp.getWebhooks();
+                    // Filter for N8N type webhooks that are active and not linked
+                    const availableWebhooks = webhooks.filter((webhook) => webhook.type === 'N8N' &&
+                        webhook.status === 'active' &&
+                        !webhook.linked_workflow_id);
+                    return availableWebhooks.map((webhook) => ({
+                        name: webhook.name,
                         value: webhook.id,
-                        description: webhook.description || `Webhook ID: ${webhook.id}`,
+                        description: webhook.description || `Type: ${webhook.type}`,
                     }));
                 }
                 catch (error) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load webhooks: ${error instanceof Error ? error.message : String(error)}`);
+                    let errorMessage = 'Failed to load webhooks';
+                    if (error instanceof Error) {
+                        errorMessage += `: ${error.message}`;
+                        // Check for common issues
+                        if (error.message.includes('HTTP 401') || error.message.includes('Unauthorized')) {
+                            errorMessage = 'Authentication failed. Please check your API token in the credentials.';
+                        }
+                        else if (error.message.includes('HTTP 404')) {
+                            errorMessage = 'Webhook endpoint not found. Please check the API base URL in credentials.';
+                        }
+                        else if (error.message.includes('HTTP 403')) {
+                            errorMessage = 'Access forbidden. Your API token may not have permission to access webhooks.';
+                        }
+                        else if (error.message.includes('Failed to fetch') || error.message.includes('network')) {
+                            errorMessage = 'Network error. Please check the API base URL and ensure the Cribops API is accessible.';
+                        }
+                        else if (error.message.includes('HTTP 400')) {
+                            errorMessage = 'Bad request. Please check that the API endpoint is correct and your API token has the necessary permissions.';
+                        }
+                    }
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage);
                 }
             },
         },
@@ -135,37 +157,37 @@ class CribopsTrigger {
             async create() {
                 const webhookUrl = this.getNodeWebhookUrl('default');
                 const webhookId = this.getNodeParameter('webhookId');
-                const eventTypes = this.getNodeParameter('eventTypes', []);
-                const additionalFields = this.getNodeParameter('additionalFields', {});
                 const credentials = await this.getCredentials('cribopsApi');
+                const workflowId = this.getWorkflow().id;
+                const workflowName = this.getWorkflow().name;
                 const cribopsHttp = new CribopsHttp_1.CribopsHttp({
                     baseUrl: credentials.baseUrl,
                     apiToken: credentials.apiToken,
                 });
                 try {
-                    // Register this n8n webhook URL with the Cribops webhook
+                    // Link this workflow to the webhook entity
                     const body = {
-                        webhook_id: webhookId,
-                        target_url: webhookUrl,
-                        event_types: eventTypes,
-                        secret: additionalFields.secretToken || undefined,
+                        workflow_id: workflowId,
+                        webhook_url: webhookUrl,
+                        test_webhook_url: webhookUrl.replace('/webhook/', '/webhook-test/'),
+                        workflow_name: workflowName || 'Unnamed Workflow',
                     };
-                    // Register the n8n webhook URL with Cribops
-                    await cribopsHttp.request('POST', `/api/v1/webhooks/${webhookId}/targets`, body);
+                    // Link the n8n workflow to the webhook entity
+                    await cribopsHttp.request('POST', `/api/v1/webhooks/${webhookId}/link`, body);
                     // Store webhook data for later use
                     const webhookData = this.getWorkflowStaticData('node');
                     webhookData.webhookId = webhookId;
-                    webhookData.targetUrl = webhookUrl;
+                    webhookData.webhookUrl = webhookUrl;
                     return true;
                 }
                 catch (error) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to register webhook target: ${error instanceof Error ? error.message : String(error)}`);
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to link webhook: ${error instanceof Error ? error.message : String(error)}`);
                 }
             },
             async delete() {
                 const webhookData = this.getWorkflowStaticData('node');
                 const credentials = await this.getCredentials('cribopsApi');
-                if (!webhookData.webhookId || !webhookData.targetUrl) {
+                if (!webhookData.webhookId) {
                     return true;
                 }
                 const cribopsHttp = new CribopsHttp_1.CribopsHttp({
@@ -173,17 +195,15 @@ class CribopsTrigger {
                     apiToken: credentials.apiToken,
                 });
                 try {
-                    // Unregister the n8n webhook URL from Cribops
-                    await cribopsHttp.request('DELETE', `/api/v1/webhooks/${webhookData.webhookId}/targets`, {
-                        target_url: webhookData.targetUrl,
-                    });
+                    // Unlink the workflow from the webhook entity
+                    await cribopsHttp.request('DELETE', `/api/v1/webhooks/${webhookData.webhookId}/link`);
                     delete webhookData.webhookId;
-                    delete webhookData.targetUrl;
+                    delete webhookData.webhookUrl;
                     return true;
                 }
                 catch (error) {
                     // Log error but don't fail
-                    console.error('Failed to unregister webhook target:', error);
+                    console.error('Failed to unlink webhook:', error);
                     return true;
                 }
             },

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-cribops",
-  "version": "0.1.18",
+  "version": "0.1.24",
   "description": "n8n community node for Cribops AI platform integration",
   "keywords": [
     "n8n-community-node-package"

package/dist/utils/CribopsHttp.d.ts

@@ -37,6 +37,18 @@ export interface CribopsQueueMessage {
     };
     inserted_at: string;
 }
+export interface CribopsWebhookEntity {
+    id: string;
+    name: string;
+    description?: string;
+    type: 'N8N' | 'GHL_API' | 'GENERIC';
+    status: 'active' | 'inactive';
+    linked_workflow_id?: string;
+    linked_workflow_name?: string;
+    organization_id: string;
+    created_at: string;
+    updated_at: string;
+}
 export declare class CribopsHttp {
     private config;
     constructor(config: CribopsHttpConfig);
@@ -57,5 +69,13 @@ export declare class CribopsHttp {
         status: string;
         updated_count: number;
     }>;
+    getWebhooks(): Promise<CribopsWebhookEntity[]>;
+    linkWebhook(webhookId: string, linkData: {
+        workflow_id: string;
+        webhook_url: string;
+        test_webhook_url: string;
+        workflow_name: string;
+    }): Promise<any>;
+    unlinkWebhook(webhookId: string): Promise<any>;
     request<T = any>(method: IHttpRequestMethods, endpoint: string, data?: IDataObject, options?: Partial<IHttpRequestOptions>): Promise<T>;
 }

package/dist/utils/CribopsHttp.js

@@ -10,7 +10,22 @@ class CribopsHttp {
         };
     }
     async makeRequest(method, endpoint, data, options) {
-        const url = `${this.config.baseUrl}${endpoint}`;
+        let url = `${this.config.baseUrl}${endpoint}`;
+        // Handle query parameters for GET requests
+        if (method === 'GET' && data && Object.keys(data).length > 0) {
+            const params = new URLSearchParams();
+            Object.entries(data).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    params.append(key, String(value));
+                }
+            });
+            const queryString = params.toString();
+            if (queryString) {
+                url += `?${queryString}`;
+            }
+            // Clear data for GET requests as params are in URL
+            data = undefined;
+        }
         const requestHeaders = {
             'Authorization': `Bearer ${this.config.apiToken}`,
             'Content-Type': 'application/json',
@@ -25,11 +40,20 @@ class CribopsHttp {
             const response = await fetch(url, {
                 method,
                 headers: requestHeaders,
-                body: data ? JSON.stringify(data) : undefined,
+                body: (method !== 'GET' && data) ? JSON.stringify(data) : undefined,
             });
             if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`HTTP ${response.status}: ${errorText}`);
+                let errorText = await response.text();
+                let errorDetail = '';
+                // Try to parse error response as JSON
+                try {
+                    const errorJson = JSON.parse(errorText);
+                    errorDetail = errorJson.message || errorJson.error || errorText;
+                }
+                catch {
+                    errorDetail = errorText;
+                }
+                throw new Error(`HTTP ${response.status}: ${errorDetail}`);
             }
             const result = await response.json();
             return result;
@@ -73,8 +97,17 @@ class CribopsHttp {
                 },
             });
             if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`HTTP ${response.status}: ${errorText}`);
+                let errorText = await response.text();
+                let errorDetail = '';
+                // Try to parse error response as JSON
+                try {
+                    const errorJson = JSON.parse(errorText);
+                    errorDetail = errorJson.message || errorJson.error || errorText;
+                }
+                catch {
+                    errorDetail = errorText;
+                }
+                throw new Error(`HTTP ${response.status}: ${errorDetail}`);
             }
             const arrayBuffer = await response.arrayBuffer();
             return Buffer.from(arrayBuffer);
@@ -144,6 +177,47 @@ class CribopsHttp {
             throw new Error(`Failed to mark messages as failed for tenant ${tenantId}: ${error}`);
         }
     }
+    // Webhook-specific methods
+    async getWebhooks() {
+        try {
+            // Organization is automatically determined from API key
+            const response = await this.makeRequest('GET', '/api/v1/webhooks');
+            // Handle different response structures
+            // The API might return webhooks directly as array or wrapped in data property
+            if (Array.isArray(response)) {
+                return response;
+            }
+            else if (response.data && Array.isArray(response.data)) {
+                return response.data;
+            }
+            else if (response.webhooks && Array.isArray(response.webhooks)) {
+                return response.webhooks;
+            }
+            else {
+                // If we can't find webhooks, return empty array
+                return [];
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch webhooks: ${error}`);
+        }
+    }
+    async linkWebhook(webhookId, linkData) {
+        try {
+            return await this.makeRequest('POST', `/api/v1/webhooks/${webhookId}/link`, linkData);
+        }
+        catch (error) {
+            throw new Error(`Failed to link webhook: ${error}`);
+        }
+    }
+    async unlinkWebhook(webhookId) {
+        try {
+            return await this.makeRequest('DELETE', `/api/v1/webhooks/${webhookId}/link`);
+        }
+        catch (error) {
+            throw new Error(`Failed to unlink webhook: ${error}`);
+        }
+    }
     // Generic request method for custom API calls
     async request(method, endpoint, data, options) {
         return this.makeRequest(method, endpoint, data, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-cribops",
-  "version": "0.1.18",
+  "version": "0.1.24",
   "description": "n8n community node for Cribops AI platform integration",
   "keywords": [
     "n8n-community-node-package"