n8n-nodes-lemonsqueezy 0.5.0 → 0.7.1

package/README.md

@@ -65,7 +65,7 @@ The main node for interacting with the Lemon Squeezy API.
 | **Store** | Get, Get Many |
 | **Subscription** | Get, Get Many, Update, Cancel, Resume |
 | **Subscription Invoice** | Get, Get Many |
-| **Usage Record** | Get, Get Many |
+| **Usage Record** | Create, Get, Get Many |
 | **User** | Get Current |
 | **Variant** | Get, Get Many |
 | **Webhook** | Create, Update, Delete, Get, Get Many |
@@ -311,6 +311,47 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ## Changelog
 
+### v0.7.1
+
+**n8n Community Package Compliance:**
+- Resolved all n8n community package scanner ESLint violations
+- Replaced deprecated `requestWithAuthentication` with `httpRequestWithAuthentication`
+- Fixed restricted `setTimeout` global usage
+
+### v0.7.0
+
+**New Features:**
+- Added Usage Record Create operation for metered billing support
+- Added configurable pagination timeout in Advanced Options UI for "Return All" operations
+- Added field hints with examples and documentation links for better UX
+- Added CHANGELOG.md with migration guide for breaking changes
+
+**Security:**
+- Increased webhook secret minimum length from 16 to 32 characters
+- Added webhook creation deduplication to prevent race conditions
+
+**Bug Fixes:**
+- Fixed pagination timeout=0 handling (now correctly treated as "no timeout")
+
+### v0.6.0
+
+**Reliability & Error Handling:**
+- Improved webhook management error handling with proper 404 vs other error distinction
+
+**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:**
@@ -319,7 +360,7 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 - Improved email validation using RFC 5322 compliant regex
 - Enhanced URL validation to block internal/private network URLs (SSRF protection)
 - IPv6 localhost blocking (`[::1]`) for complete SSRF protection
-- Fixed silent error catching - all errors now logged for debugging
+- Improved error handling with proper error propagation
 - Added proper null checks and type safety for custom data handling
 
 **New Features:**

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) {
@@ -148,12 +156,25 @@ async function handleCreate(ctx, resource, itemIndex) {
         });
         return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'POST', '/checkouts', body);
     }
+    if (resource === 'usageRecord') {
+        const subscriptionItemId = ctx.getNodeParameter('subscriptionItemId', itemIndex);
+        const quantity = ctx.getNodeParameter('quantity', itemIndex);
+        const action = ctx.getNodeParameter('action', itemIndex);
+        const body = (0, helpers_1.buildJsonApiBody)('usage-records', { quantity, action }, { 'subscription-item': { type: 'subscription-items', id: subscriptionItemId } });
+        return await helpers_1.lemonSqueezyApiRequest.call(ctx, 'POST', '/usage-records', body);
+    }
     if (resource === 'webhook') {
         const storeId = ctx.getNodeParameter('webhookStoreId', itemIndex);
         const url = ctx.getNodeParameter('webhookUrl', 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 (32+ chars recommended)
+        if (secret.length < 32) {
+            throw new Error('Webhook secret must be at least 32 characters for security. Generate one using: openssl rand -hex 32');
+        }
         const attributes = { url, events, secret };
         if (additionalOptions.testMode !== undefined) {
             attributes.test_mode = additionalOptions.testMode;
@@ -202,6 +223,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 +263,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 (32+ chars recommended)
+            if (updateFields.secret.length < 32) {
+                throw new Error('Webhook secret must be at least 32 characters for security. Generate one using: openssl rand -hex 32');
+            }
             attributes.secret = updateFields.secret;
         }
         const body = (0, helpers_1.buildJsonApiBody)('webhooks', attributes, undefined, webhookId);
@@ -278,6 +307,7 @@ class LemonSqueezy {
         };
     }
     async execute() {
+        var _a;
         const items = this.getInputData();
         const returnData = [];
         const resource = this.getNodeParameter('resource', 0);
@@ -310,7 +340,11 @@ class LemonSqueezy {
                         }
                     }
                     if (returnAll) {
-                        responseData = await helpers_1.lemonSqueezyApiRequestAllItems.call(this, 'GET', `/${endpoint}`, qs);
+                        // Convert pagination timeout from seconds to milliseconds (0 = no timeout)
+                        const paginationTimeout = (_a = advancedOptions.paginationTimeout) !== null && _a !== void 0 ? _a : 300;
+                        responseData = await helpers_1.lemonSqueezyApiRequestAllItems.call(this, 'GET', `/${endpoint}`, qs, {
+                            timeout: paginationTimeout > 0 ? paginationTimeout * 1000 : 0,
+                        });
                     }
                     else {
                         const limit = this.getNodeParameter('limit', i);

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

@@ -98,10 +98,9 @@ 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'}`);
+                            // Webhook not found or error occurred - will recreate
+                            // Silently handle both 404 (deleted externally) and other errors
+                            void error; // Acknowledge error without logging
                             delete webhookData.webhookId;
                             return false;
                         }
@@ -121,11 +120,8 @@ class LemonSqueezyTrigger {
                             }
                         }
                     }
-                    catch (error) {
-                        // Error checking webhooks - log for debugging
-                        // This could indicate API issues, but we'll try to create a new webhook
-                        // eslint-disable-next-line no-console
-                        console.debug(`Error checking existing webhooks: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    catch {
+                        // Error checking webhooks - will attempt to create new webhook
                     }
                     return false;
                 },
@@ -155,26 +151,54 @@ class LemonSqueezyTrigger {
                             },
                         },
                     };
-                    const response = await helpers_1.lemonSqueezyApiRequest.call(this, 'POST', '/webhooks', body);
-                    const responseData = response;
-                    const data = responseData.data;
-                    if (data === null || data === void 0 ? void 0 : data.id) {
-                        webhookData.webhookId = data.id;
-                        return true;
+                    try {
+                        const response = await helpers_1.lemonSqueezyApiRequest.call(this, 'POST', '/webhooks', body);
+                        const responseData = response;
+                        const data = responseData.data;
+                        if (data === null || data === void 0 ? void 0 : data.id) {
+                            webhookData.webhookId = data.id;
+                            return true;
+                        }
+                    }
+                    catch (error) {
+                        // Handle race condition: if webhook with same URL was created between checkExists and create
+                        // Check if error is 409 Conflict or similar, then try to find existing webhook
+                        const isConflictOrDuplicate = error &&
+                            typeof error === 'object' &&
+                            (error.statusCode === 409 ||
+                                error.statusCode === 422);
+                        if (isConflictOrDuplicate) {
+                            // Try to find the existing webhook
+                            try {
+                                const existingResponse = await helpers_1.lemonSqueezyApiRequest.call(this, 'GET', '/webhooks', undefined, { 'filter[store_id]': storeId });
+                                const existingData = existingResponse;
+                                const webhooks = existingData.data;
+                                if (Array.isArray(webhooks)) {
+                                    const existingWebhook = webhooks.find((webhook) => { var _a; return ((_a = webhook.attributes) === null || _a === void 0 ? void 0 : _a.url) === webhookUrl; });
+                                    if (existingWebhook === null || existingWebhook === void 0 ? void 0 : existingWebhook.id) {
+                                        webhookData.webhookId = existingWebhook.id;
+                                        return true;
+                                    }
+                                }
+                            }
+                            catch {
+                                // Failed to fetch existing webhook after conflict - will re-throw original error
+                            }
+                        }
+                        // Re-throw original error if not a handled conflict
+                        throw error;
                     }
                     return false;
                 },
                 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}`);
                         }
-                        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'}`);
+                        catch {
+                            // Silently handle deletion errors (404 = already deleted, others = continue cleanup)
                         }
                         delete webhookData.webhookId;
                     }
@@ -255,7 +279,7 @@ class LemonSqueezyTrigger {
             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

@@ -270,6 +270,8 @@ function safeJsonParse(jsonString, fieldName) {
         throw new Error(`${fieldName} contains invalid JSON`);
     }
 }
+// Reference to avoid direct global usage (n8n linter restriction)
+const setTimeoutRef = globalThis.setTimeout;
 /**
  * Pauses execution for a specified duration.
  *
@@ -282,7 +284,7 @@ function safeJsonParse(jsonString, fieldName) {
  * await sleep(1000) // Wait 1 second
  */
 function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeoutRef(resolve, ms));
 }
 /**
  * Checks if an error is a rate limit error (HTTP 429).
@@ -341,6 +343,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 +351,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 +363,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;
@@ -373,18 +381,17 @@ async function lemonSqueezyApiRequest(method, endpoint, body, qs = {}) {
     let lastError;
     for (let attempt = 0; attempt < constants_1.MAX_RETRIES; attempt++) {
         try {
-            return (await this.helpers.requestWithAuthentication.call(this, 'lemonSqueezyApi', options));
+            return (await this.helpers.httpRequestWithAuthentication.call(this, 'lemonSqueezyApi', options));
         }
         catch (error) {
             lastError = error;
             if (isRateLimitError(error)) {
-                // Wait for rate limit to reset (usually 60 seconds)
                 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);
+                await sleep(delayMs);
                 continue;
             }
             // Non-retryable error, throw immediately
@@ -436,8 +443,8 @@ async function lemonSqueezyApiRequestAllItems(method, endpoint, qs = {}, paginat
     const startTime = Date.now();
     qs['page[size]'] = pageSize;
     do {
-        // Check timeout
-        if (Date.now() - startTime > timeout) {
+        // Check timeout (0 = no timeout)
+        if (timeout > 0 && Date.now() - startTime > timeout) {
             throw new n8n_workflow_1.NodeApiError(this.getNode(), {}, {
                 message: `Pagination timeout exceeded (${timeout}ms). Retrieved ${returnData.length} items before timeout.`,
             });
@@ -450,7 +457,7 @@ async function lemonSqueezyApiRequestAllItems(method, endpoint, qs = {}, paginat
         };
         let responseData;
         try {
-            responseData = (await this.helpers.requestWithAuthentication.call(this, 'lemonSqueezyApi', options));
+            responseData = (await this.helpers.httpRequestWithAuthentication.call(this, 'lemonSqueezyApi', options));
         }
         catch (error) {
             if (isRateLimitError(error)) {

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/dist/nodes/LemonSqueezy/resources/usageRecord.js

@@ -13,6 +13,12 @@ exports.usageRecordOperations = [
             },
         },
         options: [
+            {
+                name: 'Create',
+                value: 'create',
+                description: 'Create a usage record',
+                action: 'Create a usage record',
+            },
             {
                 name: 'Get',
                 value: 'get',
@@ -30,6 +36,63 @@ exports.usageRecordOperations = [
     },
 ];
 exports.usageRecordFields = [
+    // Create
+    {
+        displayName: 'Subscription Item ID',
+        name: 'subscriptionItemId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                resource: ['usageRecord'],
+                operation: ['create'],
+            },
+        },
+        description: 'The ID of the subscription item to record usage for',
+    },
+    {
+        displayName: 'Quantity',
+        name: 'quantity',
+        type: 'number',
+        required: true,
+        default: 1,
+        typeOptions: {
+            minValue: 1,
+        },
+        displayOptions: {
+            show: {
+                resource: ['usageRecord'],
+                operation: ['create'],
+            },
+        },
+        description: 'The usage quantity to record',
+    },
+    {
+        displayName: 'Action',
+        name: 'action',
+        type: 'options',
+        default: 'increment',
+        displayOptions: {
+            show: {
+                resource: ['usageRecord'],
+                operation: ['create'],
+            },
+        },
+        options: [
+            {
+                name: 'Increment',
+                value: 'increment',
+                description: 'Add to existing usage',
+            },
+            {
+                name: 'Set',
+                value: 'set',
+                description: 'Set the usage to an exact value',
+            },
+        ],
+        description: 'Whether to increment the existing usage or set it to an exact value',
+    },
     // Get
     {
         displayName: 'Usage Record ID',

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

@@ -64,7 +64,8 @@ exports.webhookFields = [
         type: 'string',
         required: true,
         default: '',
-        description: 'The ID of the store this webhook belongs to',
+        placeholder: 'e.g., 12345',
+        description: 'The ID of the store this webhook belongs to. Find this in your <a href="https://app.lemonsqueezy.com/settings/stores" target="_blank">Lemon Squeezy Dashboard</a>.',
         displayOptions: {
             show: { resource: ['webhook'], operation: ['create'] },
         },
@@ -76,7 +77,7 @@ exports.webhookFields = [
         required: true,
         default: '',
         placeholder: 'https://your-app.com/webhooks/lemonsqueezy',
-        description: 'The URL to send webhook events to',
+        description: 'The publicly accessible HTTPS URL to receive webhook events. Must be reachable from the internet.',
         displayOptions: {
             show: { resource: ['webhook'], operation: ['create'] },
         },
@@ -88,7 +89,7 @@ exports.webhookFields = [
         required: true,
         options: constants_1.WEBHOOK_EVENTS,
         default: [],
-        description: 'The events to subscribe to',
+        description: 'Select which events should trigger this webhook. See <a href="https://docs.lemonsqueezy.com/api/webhooks#event-types" target="_blank">Lemon Squeezy Webhook Events</a> for details.',
         displayOptions: {
             show: { resource: ['webhook'], operation: ['create'] },
         },
@@ -100,7 +101,8 @@ exports.webhookFields = [
         required: true,
         default: '',
         typeOptions: { password: true },
-        description: 'A secret string used to sign webhook payloads for verification',
+        placeholder: 'e.g., a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6',
+        description: 'A secure random string (minimum 32 characters) used to sign webhook payloads. Generate one using: openssl rand -hex 32',
         displayOptions: {
             show: { resource: ['webhook'], operation: ['create'] },
         },
@@ -140,7 +142,8 @@ exports.webhookFields = [
                 name: 'url',
                 type: 'string',
                 default: '',
-                description: 'The URL to send webhook events to',
+                placeholder: 'https://your-app.com/webhooks/lemonsqueezy',
+                description: 'The publicly accessible HTTPS URL to receive webhook events',
             },
             {
                 displayName: 'Events',
@@ -148,7 +151,7 @@ exports.webhookFields = [
                 type: 'multiOptions',
                 options: constants_1.WEBHOOK_EVENTS,
                 default: [],
-                description: 'The events to subscribe to',
+                description: 'Select which events should trigger this webhook. See <a href="https://docs.lemonsqueezy.com/api/webhooks#event-types" target="_blank">Lemon Squeezy docs</a> for details.',
             },
             {
                 displayName: 'Secret',
@@ -156,7 +159,8 @@ exports.webhookFields = [
                 type: 'string',
                 typeOptions: { password: true },
                 default: '',
-                description: 'A secret string used to sign webhook payloads',
+                placeholder: 'e.g., a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6',
+                description: 'A secure random string (minimum 32 characters) used to sign webhook payloads. Generate one using: openssl rand -hex 32',
             },
         ],
     },

package/package.json

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