n8n-nodes-lemonsqueezy 0.5.0 → 0.6.0

package/README.md

@@ -311,6 +311,29 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## Changelog
 
+### v0.6.0
+
+**Reliability & Error Handling:**
+- Improved webhook management error handling with proper 404 vs other error distinction
+- Added detailed logging for webhook lifecycle (create, check, delete operations)
+- Added logging for filtered/unsubscribed webhook events to aid debugging
+- Added rate limit visibility logging with wait time information
+- Added retry attempt logging with exponential backoff details
+
+**Input Validation:**
+- Added pre-API validation for email fields (customer create/update, checkout)
+- Added pre-API validation for URL fields (webhook URL, redirect URLs, receipt link URLs)
+- Added webhook secret minimum length validation (16 characters) for security
+- Validation errors now fail fast before making API requests
+
+**Performance:**
+- Added configurable request timeout (default: 30 seconds) for all API requests
+- Timeout prevents hanging requests and improves workflow reliability
+
+**Code Quality:**
+- Added common filter field generators to reduce code duplication
+- Added createFiltersField, createStatusFilter factory functions
+
 ### v0.5.0
 
 **Security & Stability Improvements:**

package/dist/nodes/LemonSqueezy/LemonSqueezy.node.js

@@ -10,6 +10,8 @@ async function handleCreate(ctx, resource, itemIndex) {
         const name = ctx.getNodeParameter('customerName', itemIndex);
         const email = ctx.getNodeParameter('customerEmail', itemIndex);
         const additionalFields = ctx.getNodeParameter('additionalFields', itemIndex);
+        // Validate required fields before API call
+        (0, helpers_1.validateField)('email', email, 'email');
         const body = (0, helpers_1.buildJsonApiBody)('customers', { name, email, ...additionalFields }, { store: { type: 'stores', id: storeId } });
         return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'POST', '/customers', body);
     }
@@ -63,6 +65,8 @@ async function handleCreate(ctx, resource, itemIndex) {
             attributes.custom_price = additionalOptions.customPrice;
         }
         if (additionalOptions.email) {
+            // Validate email before API call
+            (0, helpers_1.validateField)('email', additionalOptions.email, 'email');
             checkoutData.email = additionalOptions.email;
         }
         if (additionalOptions.name) {
@@ -72,12 +76,16 @@ async function handleCreate(ctx, resource, itemIndex) {
             checkoutData.discount_code = additionalOptions.discountCode;
         }
         if (additionalOptions.redirectUrl) {
+            // Validate URL before API call
+            (0, helpers_1.validateField)('redirectUrl', additionalOptions.redirectUrl, 'url');
             productOptions.redirect_url = additionalOptions.redirectUrl;
         }
         if (additionalOptions.receiptButtonText) {
             productOptions.receipt_button_text = additionalOptions.receiptButtonText;
         }
         if (additionalOptions.receiptLinkUrl) {
+            // Validate URL before API call
+            (0, helpers_1.validateField)('receiptLinkUrl', additionalOptions.receiptLinkUrl, 'url');
             productOptions.receipt_link_url = additionalOptions.receiptLinkUrl;
         }
         if (additionalOptions.receiptThankYouNote) {
@@ -154,6 +162,12 @@ async function handleCreate(ctx, resource, itemIndex) {
         const events = ctx.getNodeParameter('webhookEvents', itemIndex);
         const secret = ctx.getNodeParameter('webhookSecret', itemIndex);
         const additionalOptions = ctx.getNodeParameter('additionalOptions', itemIndex, {});
+        // Validate URL before API call
+        (0, helpers_1.validateField)('url', url, 'url');
+        // Validate webhook secret minimum length for security
+        if (secret.length < 16) {
+            throw new Error('Webhook secret must be at least 16 characters for security');
+        }
         const attributes = { url, events, secret };
         if (additionalOptions.testMode !== undefined) {
             attributes.test_mode = additionalOptions.testMode;
@@ -202,6 +216,8 @@ async function handleUpdate(ctx, resource, itemIndex) {
             attributes.name = updateFields.name;
         }
         if (updateFields.email) {
+            // Validate email before API call
+            (0, helpers_1.validateField)('email', updateFields.email, 'email');
             attributes.email = updateFields.email;
         }
         if (updateFields.city) {
@@ -240,12 +256,18 @@ async function handleUpdate(ctx, resource, itemIndex) {
         const updateFields = ctx.getNodeParameter('updateFields', itemIndex);
         const attributes = {};
         if (updateFields.url) {
+            // Validate URL before API call
+            (0, helpers_1.validateField)('url', updateFields.url, 'url');
             attributes.url = updateFields.url;
         }
         if (updateFields.events) {
             attributes.events = updateFields.events;
         }
         if (updateFields.secret) {
+            // Validate webhook secret minimum length for security
+            if (updateFields.secret.length < 16) {
+                throw new Error('Webhook secret must be at least 16 characters for security');
+            }
             attributes.secret = updateFields.secret;
         }
         const body = (0, helpers_1.buildJsonApiBody)('webhooks', attributes, undefined, webhookId);

package/dist/nodes/LemonSqueezy/LemonSqueezyTrigger.node.js

@@ -90,6 +90,14 @@ class LemonSqueezyTrigger {
                     const webhookUrl = this.getNodeWebhookUrl('default');
                     const storeId = this.getNodeParameter('storeId');
                     const webhookData = this.getWorkflowStaticData('node');
+                    // Helper to check if error is a 404 (webhook not found)
+                    const isNotFoundError = (error) => {
+                        if (error && typeof error === 'object') {
+                            const err = error;
+                            return err.statusCode === 404 || err.httpCode === 404 || err.code === 404;
+                        }
+                        return false;
+                    };
                     // Check if we have stored webhook data
                     if (webhookData.webhookId) {
                         try {
@@ -98,10 +106,17 @@ class LemonSqueezyTrigger {
                             return true;
                         }
                         catch (error) {
-                            // Webhook doesn't exist anymore or API error occurred
-                            // Log for debugging but don't fail - we'll recreate the webhook
-                            // eslint-disable-next-line no-console
-                            console.debug(`Webhook ${String(webhookData.webhookId)} check failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                            const webhookId = String(webhookData.webhookId);
+                            if (isNotFoundError(error)) {
+                                // Webhook was deleted externally - this is expected, recreate it
+                                // eslint-disable-next-line no-console
+                                console.log(`[LemonSqueezy] Webhook ${webhookId} not found (404) - will recreate`);
+                            }
+                            else {
+                                // Unexpected error - could be auth, network, or server issue
+                                // eslint-disable-next-line no-console
+                                console.warn(`[LemonSqueezy] Webhook ${webhookId} check failed with unexpected error: ${error instanceof Error ? error.message : 'Unknown error'}. Will attempt to recreate.`);
+                            }
                             delete webhookData.webhookId;
                             return false;
                         }
@@ -117,15 +132,16 @@ class LemonSqueezyTrigger {
                             const existingWebhook = webhooks.find((webhook) => { var _a; return ((_a = webhook.attributes) === null || _a === void 0 ? void 0 : _a.url) === webhookUrl; });
                             if (existingWebhook) {
                                 webhookData.webhookId = existingWebhook.id;
+                                // eslint-disable-next-line no-console
+                                console.log(`[LemonSqueezy] Found existing webhook ${String(existingWebhook.id)} for URL ${webhookUrl}`);
                                 return true;
                             }
                         }
                     }
                     catch (error) {
-                        // Error checking webhooks - log for debugging
-                        // This could indicate API issues, but we'll try to create a new webhook
+                        // Error checking webhooks - this is more serious as it could indicate API/auth issues
                         // eslint-disable-next-line no-console
-                        console.debug(`Error checking existing webhooks: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                        console.error(`[LemonSqueezy] Error checking existing webhooks for store ${storeId}: ${error instanceof Error ? error.message : 'Unknown error'}. Will attempt to create new webhook.`);
                     }
                     return false;
                 },
@@ -167,14 +183,28 @@ class LemonSqueezyTrigger {
                 async delete() {
                     const webhookData = this.getWorkflowStaticData('node');
                     if (webhookData.webhookId) {
+                        const webhookId = String(webhookData.webhookId);
                         try {
-                            await helpers_1.lemonSqueezyApiRequest.call(this, 'DELETE', `/webhooks/${String(webhookData.webhookId)}`);
+                            await helpers_1.lemonSqueezyApiRequest.call(this, 'DELETE', `/webhooks/${webhookId}`);
+                            // eslint-disable-next-line no-console
+                            console.log(`[LemonSqueezy] Webhook ${webhookId} deleted successfully`);
                         }
                         catch (error) {
-                            // Webhook might already be deleted or API error
-                            // Log for debugging but don't fail - we're cleaning up anyway
-                            // eslint-disable-next-line no-console
-                            console.debug(`Webhook ${String(webhookData.webhookId)} deletion failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                            // Check if it's a 404 (already deleted) vs other errors
+                            const is404 = error &&
+                                typeof error === 'object' &&
+                                (error.statusCode === 404 ||
+                                    error.httpCode === 404);
+                            if (is404) {
+                                // Webhook was already deleted - this is fine
+                                // eslint-disable-next-line no-console
+                                console.log(`[LemonSqueezy] Webhook ${webhookId} already deleted (404)`);
+                            }
+                            else {
+                                // Unexpected error during deletion - log as warning
+                                // eslint-disable-next-line no-console
+                                console.warn(`[LemonSqueezy] Webhook ${webhookId} deletion failed: ${error instanceof Error ? error.message : 'Unknown error'}. Continuing cleanup.`);
+                            }
                         }
                         delete webhookData.webhookId;
                     }
@@ -252,10 +282,13 @@ class LemonSqueezyTrigger {
         const subscribedEvents = this.getNodeParameter('events');
         if (!eventName || !subscribedEvents.includes(eventName)) {
             // Event not subscribed, acknowledge but don't trigger workflow
+            // Log for debugging - helps identify misconfigured webhooks
+            // eslint-disable-next-line no-console
+            console.log(`[LemonSqueezy] Received event '${eventName || 'unknown'}' but not in subscribed events [${subscribedEvents.join(', ')}]. Acknowledged but not processed.`);
             return {
                 webhookResponse: {
                     status: 200,
-                    body: { received: true, processed: false },
+                    body: { received: true, processed: false, event: eventName },
                 },
             };
         }

package/dist/nodes/LemonSqueezy/constants.d.ts

@@ -6,6 +6,8 @@ export declare const DEFAULT_PAGE_SIZE = 100;
 export declare const MAX_RETRIES = 3;
 export declare const RETRY_DELAY_MS = 1000;
 export declare const RATE_LIMIT_DELAY_MS = 60000;
+/** Default timeout for API requests in milliseconds (30 seconds) */
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 /**
  * Resource to API endpoint mapping
  */

package/dist/nodes/LemonSqueezy/constants.js

@@ -3,12 +3,14 @@
  * Lemon Squeezy API constants
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INTERVAL_TYPES = exports.PRODUCT_STATUSES = exports.PAUSE_MODES = exports.DISCOUNT_DURATION_TYPES = exports.DISCOUNT_AMOUNT_TYPES = exports.LICENSE_KEY_STATUSES = exports.CUSTOMER_STATUSES = exports.ORDER_STATUSES = exports.SUBSCRIPTION_STATUSES = exports.WEBHOOK_EVENTS = exports.RESOURCE_ID_PARAMS = exports.RESOURCE_ENDPOINTS = exports.RATE_LIMIT_DELAY_MS = exports.RETRY_DELAY_MS = exports.MAX_RETRIES = exports.DEFAULT_PAGE_SIZE = exports.API_BASE_URL = void 0;
+exports.INTERVAL_TYPES = exports.PRODUCT_STATUSES = exports.PAUSE_MODES = exports.DISCOUNT_DURATION_TYPES = exports.DISCOUNT_AMOUNT_TYPES = exports.LICENSE_KEY_STATUSES = exports.CUSTOMER_STATUSES = exports.ORDER_STATUSES = exports.SUBSCRIPTION_STATUSES = exports.WEBHOOK_EVENTS = exports.RESOURCE_ID_PARAMS = exports.RESOURCE_ENDPOINTS = exports.DEFAULT_REQUEST_TIMEOUT_MS = exports.RATE_LIMIT_DELAY_MS = exports.RETRY_DELAY_MS = exports.MAX_RETRIES = exports.DEFAULT_PAGE_SIZE = exports.API_BASE_URL = void 0;
 exports.API_BASE_URL = 'https://api.lemonsqueezy.com/v1';
 exports.DEFAULT_PAGE_SIZE = 100;
 exports.MAX_RETRIES = 3;
 exports.RETRY_DELAY_MS = 1000;
 exports.RATE_LIMIT_DELAY_MS = 60000;
+/** Default timeout for API requests in milliseconds (30 seconds) */
+exports.DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 /**
  * Resource to API endpoint mapping
  */

package/dist/nodes/LemonSqueezy/helpers.d.ts

@@ -167,6 +167,7 @@ export declare function isRetryableError(error: unknown): boolean;
  * - Automatic authentication using stored credentials
  * - Rate limit handling with automatic retry after delay
  * - Exponential backoff for server errors (5xx)
+ * - Configurable request timeout (default: 30 seconds)
  * - Detailed error messages using NodeApiError
  *
  * @param this - The n8n execution context
@@ -174,8 +175,9 @@ export declare function isRetryableError(error: unknown): boolean;
  * @param endpoint - API endpoint path (e.g., '/v1/products')
  * @param body - Optional request body for POST/PATCH requests
  * @param qs - Optional query string parameters
+ * @param timeout - Request timeout in milliseconds (default: 30000)
  * @returns The API response data
- * @throws NodeApiError if the request fails after all retries
+ * @throws NodeApiError if the request fails after all retries or times out
  *
  * @example
  * // GET request
@@ -185,8 +187,11 @@ export declare function isRetryableError(error: unknown): boolean;
  * const checkout = await lemonSqueezyApiRequest.call(this, 'POST', '/v1/checkouts', {
  *   data: { type: 'checkouts', attributes: { ... } }
  * })
+ *
+ * // Request with custom timeout (60 seconds)
+ * const data = await lemonSqueezyApiRequest.call(this, 'GET', '/v1/orders', undefined, {}, 60000)
  */
-export declare function lemonSqueezyApiRequest(this: IExecuteFunctions | IWebhookFunctions | IHookFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, qs?: Record<string, string | number>): Promise<IDataObject>;
+export declare function lemonSqueezyApiRequest(this: IExecuteFunctions | IWebhookFunctions | IHookFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, qs?: Record<string, string | number>, timeout?: number): Promise<IDataObject>;
 /**
  * Makes paginated requests to fetch all items from a Lemon Squeezy API endpoint.
  *

package/dist/nodes/LemonSqueezy/helpers.js

@@ -341,6 +341,7 @@ function isRetryableError(error) {
  * - Automatic authentication using stored credentials
  * - Rate limit handling with automatic retry after delay
  * - Exponential backoff for server errors (5xx)
+ * - Configurable request timeout (default: 30 seconds)
  * - Detailed error messages using NodeApiError
  *
  * @param this - The n8n execution context
@@ -348,8 +349,9 @@ function isRetryableError(error) {
  * @param endpoint - API endpoint path (e.g., '/v1/products')
  * @param body - Optional request body for POST/PATCH requests
  * @param qs - Optional query string parameters
+ * @param timeout - Request timeout in milliseconds (default: 30000)
  * @returns The API response data
- * @throws NodeApiError if the request fails after all retries
+ * @throws NodeApiError if the request fails after all retries or times out
  *
  * @example
  * // GET request
@@ -359,13 +361,17 @@ function isRetryableError(error) {
  * const checkout = await lemonSqueezyApiRequest.call(this, 'POST', '/v1/checkouts', {
  *   data: { type: 'checkouts', attributes: { ... } }
  * })
+ *
+ * // Request with custom timeout (60 seconds)
+ * const data = await lemonSqueezyApiRequest.call(this, 'GET', '/v1/orders', undefined, {}, 60000)
  */
-async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}) {
+async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}, timeout = constants_1.DEFAULT_REQUEST_TIMEOUT_MS) {
     const options = {
         method,
         url: `${constants_1.API_BASE_URL}${endpoint}`,
         qs,
         json: true,
+        timeout,
     };
     if (body) {
         options.body = body;
@@ -378,13 +384,17 @@ async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}) {
         catch (error) {
             lastError = error;
             if (isRateLimitError(error)) {
-                // Wait for rate limit to reset (usually 60 seconds)
+                // Log rate limit for visibility
+                // eslint-disable-next-line no-console
+                console.warn(`[LemonSqueezy] Rate limited (429) on ${method} ${endpoint}. Waiting ${constants_1.RATE_LIMIT_DELAY_MS / 1000}s before retry...`);
                 await sleep(constants_1.RATE_LIMIT_DELAY_MS);
                 continue;
             }
             if (isRetryableError(error) && attempt < constants_1.MAX_RETRIES - 1) {
-                // Exponential backoff for retryable errors
-                await sleep(constants_1.RETRY_DELAY_MS * Math.pow(2, attempt));
+                const delayMs = constants_1.RETRY_DELAY_MS * Math.pow(2, attempt);
+                // eslint-disable-next-line no-console
+                console.warn(`[LemonSqueezy] Retryable error on ${method} ${endpoint} (attempt ${attempt + 1}/${constants_1.MAX_RETRIES}). Retrying in ${delayMs}ms...`);
+                await sleep(delayMs);
                 continue;
             }
             // Non-retryable error, throw immediately
@@ -454,6 +464,8 @@ async function lemonSqueezyApiRequestAllItems(method, endpoint, qs = {}, paginat
         }
         catch (error) {
             if (isRateLimitError(error)) {
+                // eslint-disable-next-line no-console
+                console.warn(`[LemonSqueezy] Rate limited during pagination (${returnData.length} items fetched). Waiting ${constants_1.RATE_LIMIT_DELAY_MS / 1000}s...`);
                 await sleep(constants_1.RATE_LIMIT_DELAY_MS);
                 continue;
             }

package/dist/nodes/LemonSqueezy/resources/shared.d.ts

@@ -47,8 +47,43 @@ export declare const RESOURCE_INCLUDES: Record<string, Array<{
     name: string;
     value: string;
 }>>;
+/**
+ * Creates a filters collection field for a resource
+ * @param resource - The resource name
+ * @param filterOptions - Array of filter field definitions
+ * @param operations - Operations where this field applies
+ */
+export declare function createFiltersField(resource: string, filterOptions: INodeProperties['options'], operations?: string[]): INodeProperties;
+/**
+ * Common filter field: Store ID
+ */
+export declare const storeIdFilter: INodeProperties;
+/**
+ * Common filter field: Status (generic)
+ */
+export declare function createStatusFilter(statusOptions: Array<{
+    name: string;
+    value: string;
+}>): INodeProperties;
+/**
+ * Common filter field: Email
+ */
+export declare const emailFilter: INodeProperties;
+/**
+ * Common filter field: Product ID
+ */
+export declare const productIdFilter: INodeProperties;
+/**
+ * Common filter field: Variant ID
+ */
+export declare const variantIdFilter: INodeProperties;
+/**
+ * Common filter field: Order ID
+ */
+export declare const orderIdFilter: INodeProperties;
 /**
  * Generate advanced options field for a specific resource
+ * Includes sorting, relationship expansion, and pagination timeout
  */
 export declare function createAdvancedOptionsField(resource: string, operations?: string[]): INodeProperties;
 /**

package/dist/nodes/LemonSqueezy/resources/shared.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.discountAdvancedOptions = exports.checkoutAdvancedOptions = exports.variantAdvancedOptions = exports.productAdvancedOptions = exports.licenseKeyAdvancedOptions = exports.customerAdvancedOptions = exports.subscriptionAdvancedOptions = exports.orderAdvancedOptions = exports.RESOURCE_INCLUDES = exports.COMMON_SORT_FIELDS = exports.SORT_DIRECTIONS = void 0;
+exports.discountAdvancedOptions = exports.checkoutAdvancedOptions = exports.variantAdvancedOptions = exports.productAdvancedOptions = exports.licenseKeyAdvancedOptions = exports.customerAdvancedOptions = exports.subscriptionAdvancedOptions = exports.orderAdvancedOptions = exports.orderIdFilter = exports.variantIdFilter = exports.productIdFilter = exports.emailFilter = exports.storeIdFilter = exports.RESOURCE_INCLUDES = exports.COMMON_SORT_FIELDS = exports.SORT_DIRECTIONS = void 0;
 exports.createReturnAllField = createReturnAllField;
 exports.createLimitField = createLimitField;
 exports.createIdField = createIdField;
+exports.createFiltersField = createFiltersField;
+exports.createStatusFilter = createStatusFilter;
 exports.createAdvancedOptionsField = createAdvancedOptionsField;
 /**
  * Shared field definitions for advanced query options
@@ -138,8 +140,91 @@ exports.RESOURCE_INCLUDES = {
         { name: 'Discount Redemptions', value: 'discount-redemptions' },
     ],
 };
+/**
+ * Creates a filters collection field for a resource
+ * @param resource - The resource name
+ * @param filterOptions - Array of filter field definitions
+ * @param operations - Operations where this field applies
+ */
+function createFiltersField(resource, filterOptions, operations = ['getAll']) {
+    return {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: { resource: [resource], operation: operations },
+        },
+        options: filterOptions,
+    };
+}
+/**
+ * Common filter field: Store ID
+ */
+exports.storeIdFilter = {
+    displayName: 'Store ID',
+    name: 'storeId',
+    type: 'string',
+    default: '',
+    description: 'Filter by store ID',
+};
+/**
+ * Common filter field: Status (generic)
+ */
+function createStatusFilter(statusOptions) {
+    return {
+        displayName: 'Status',
+        name: 'status',
+        type: 'options',
+        options: statusOptions,
+        default: '',
+        description: 'Filter by status',
+    };
+}
+/**
+ * Common filter field: Email
+ */
+exports.emailFilter = {
+    displayName: 'Email',
+    name: 'email',
+    type: 'string',
+    default: '',
+    description: 'Filter by email address',
+};
+/**
+ * Common filter field: Product ID
+ */
+exports.productIdFilter = {
+    displayName: 'Product ID',
+    name: 'productId',
+    type: 'string',
+    default: '',
+    description: 'Filter by product ID',
+};
+/**
+ * Common filter field: Variant ID
+ */
+exports.variantIdFilter = {
+    displayName: 'Variant ID',
+    name: 'variantId',
+    type: 'string',
+    default: '',
+    description: 'Filter by variant ID',
+};
+/**
+ * Common filter field: Order ID
+ */
+exports.orderIdFilter = {
+    displayName: 'Order ID',
+    name: 'orderId',
+    type: 'string',
+    default: '',
+    description: 'Filter by order ID',
+};
 /**
  * Generate advanced options field for a specific resource
+ * Includes sorting, relationship expansion, and pagination timeout
  */
 function createAdvancedOptionsField(resource, operations = ['getAll']) {
     const includes = exports.RESOURCE_INCLUDES[resource] || [];
@@ -160,6 +245,14 @@ function createAdvancedOptionsField(resource, operations = ['getAll']) {
             default: 'desc',
             description: 'Direction to sort results',
         },
+        {
+            displayName: 'Pagination Timeout (Seconds)',
+            name: 'paginationTimeout',
+            type: 'number',
+            default: 300,
+            description: 'Maximum time in seconds to wait for paginated results when using Return All. Set to 0 for no timeout.',
+            typeOptions: { minValue: 0, maxValue: 600 },
+        },
     ];
     if (includes.length > 0) {
         options.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-lemonsqueezy",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "n8n community node for Lemon Squeezy - digital products and subscriptions platform",
   "keywords": [
     "n8n-community-node-package",